Comunicação Modbus entre Raspberry Pi e Arduinos 3

Neste post, irei demonstrar como realizar uma conexão entre três dispositivos através de uma rede de comunicação utilizando o protocolo Modbus.

Apesar de ser antigo, o protocolo de rede Modbus ainda é amplamente utilizado nas indústrias, geralmente em aplicações em que se utilizam Controladores Lógico-Programáveis (PLC), Inversores de Frequência e IHMs, mas neste projeto iremos utilizar duas das plataformas mais famosas no mundo maker: o Arduino e o Rasbperry Pi.

Dentro das indústrias, uma das aplicações mais comuns para o protocolo Mudbus é o controle de motores elétricos, onde a IHM ou o PLC enviam valores para os parâmetros dos Inversores de Frequência com base nos comandos do operador. Este protocolo também é muito utilizado para a comunicação entre o PLC e a IHM, onde estes dispositivos trocam dados entre si, como leituras de sensores e comandos realizados pelo operador.

Juntamente com todos os outros protocolos de comunicação, o Modbus é, sem dúvidas, uma peça fundamental para as tecnologias da Indústria 4.0!

O Protocolo Modbus

Antes de iniciarmos o desenvolvimento do projeto, devemos lembrar de alguns conceitos relacionados ao protocolo Modbus. O primeiro deles é sobre o seu modelo de comunicação do tipo “mestre-escravo”, onde o dispositivo mestre (ou master, em inglês) é responsável por requisitar e então aguardar uma resposta do dispositivo escravo (ou slave, em inglês), ou seja, neste formato somente o mestre possui a capacidade de iniciar a comunicação, enquanto o escravo apenas envia a resposta quando solicitada pelo mestre.

Além disso, o protocolo Modbus é representado como uma camada de aplicação do Modelo OSI. Sendo assim, será preciso escolher a camada física a qual será realizada a comunicação. Para o Modbus, podemos escolher entre 3 camadas físicas diferentes: RS-232, RS-485 ou Ethernet TCP/IP (Modbus TCP).

Neste projeto, iremos utilizar um Raspberry Pi 3B+ como mestre, dois Arduinos Mega como escravos e a camada física RS-485. Vale lembrar que nenhum destes dispositivos possui uma interface direta para o RS-485, então precisaremos utilizar alguns conversores para a interpretação dos dados na rede.

Material necessário

• 1x Raspberry Pi 3 Model B+
• 1x Cartão de memória de, no mínimo, 8 GB (recomendável: 16 GB)
• 1x Fonte Chaveada Micro USB 5V / 3A
• 2x Placa MEGA 2560 R3 + Cabo USB para Arduino
• 2x Módulo Conversor RS485 para Arduino
• 1x Conversor USB para RS485

Montagem do circuito

A montagem do circuito é bem simples, devemos apenas tomar cuidado para não ligar nenhum fio invertido. A montagem pode ser realizada em uma protoboard para facilitar a conexão com os terminais dos Arduinos e dos conversores.

Ligação Arduino – Conversor

A ligação entre o Arduino e o conversor é realizada com 5 fios:

• Os pinos VCC e GND do conversor devem estar ligados, respectivamente, aos pinos 5V e GND do Arduino;
• Os pinos DI e DO do conversor devem estar ligados, respectivamente, aos pinos TX1 e RX1 do Arduino (neste caso, estou utilizando a Serial1 do Arduino Mega, caso você tenha um Arduino Uno, pode utilizar os pinos RX e TX da única porta Serial presente nestes modelos);
• Os pinos RE e DE do conversor devem ser jumpeados e conectados ao pino 3 do Arduino.

Ligação Conversor – Conversor (Rede Modbus)

A ligação da rede Modbus é bem simples: apenas um par de fios é o suficiente para realizar a comunicação entre os dispositivos da rede. Todo dispositivo deve possuir conexões com a marcação “A” e “B”: o fio ligado ao “A” do dispositivo mestre deve estar conectado ao “A” de todos os dispositivos escravos da rede, e o mesmo deve ser feito para o “B”.

Ligação Conversor – Raspberry Pi

O conversor RS-485 utilizado para a ligação da rede modbus à Raspberry Pi é um dispositivo USB, portanto é apenas necessário conectá-lo à qualquer porta USB disponível na Raspberry Pi.

Desenvolvimento

Antes de iniciar o desenvolvimento dos códigos, precisaremos instalar as bibliotecas utilizadas na Raspberry Pi e no Arduino para a interpretação dos dados no protocolo Modbus. Lembre-se que, antes de qualquer coisa, você precisa instalar o sistema operacional na Raspberry Pi. Caso você não saiba como instalar, pode verificar neste post.

Biblioteca Raspberry Pi

A biblioteca Modbus utilizada na Raspberry Pi é a MinimalModbus. Toda a documentação técnica pode ser encontrada nesta página (em inglês), mas a sua instalação é realizada através do terminal da Raspberry Pi.

O processo de instalação é fácil, você precisa abrir o terminal da Raspberry Pi e digitar o comando abaixo.

Atenção: antes de realizar esse passo, você precisa verificar qual versão do Python você está utilizando (Python2 ou Python3).

• Para Python 2: $ pip install -U minimalmodbus
• Para Python 3: $ pip3 install -U minimalmodbus

No meu caso, estou utilizando Python 3, então utilizei o segundo comando.

Espere alguns segundos até aparecer a mensagem de confirmação da instalação.

Pronto, a instalação da biblioteca para comunicação em Modbus está instalada! Mas, antes de iniciarmos o desenvolvimento do código em Python, vamos descobrir qual o nome da porta em que o conversor USB está conectada.

Antes de conectar o conversor na porta USB (caso já estiver conectado, retire-o), digite no terminal o seguinte comando:

$ ls /dev/tty*

Este comando irá listar os dispositivos conectados às portas USB:

Conecte o dispositivo na porta USB e digite o comando novamente. Como poderá perceber, o dispositivo novo será listado (neste caso ele apareceu como ttyUSB0):

Guarde o nome do dispositivo para incluí-lo no código em Python que veremos mais adiante.

Biblioteca Arduino

Para o código do Arduino, foi necessário a utilização da biblioteca ModbusRtu. Esta biblioteca pode ser baixada neste link. Ao clicar no link, será realizado o download de um arquivo “.zip”. Este arquivo deverá ser importado para a IDE do Arduino. Você pode fazer isso da seguinte maneira:

Na IDE do Arduino, clique em “Sketch”, depois vá em “Incluir Biblioteca” e por último em “Adicionar Biblioteca .ZIP”, conforme a imagem abaixo:

Agora, você precisa selecionar o arquivo .zip que foi baixado e clicar em “Abrir” para incluir a biblioteca na IDE. Feito isso, podemos seguir para o desenvolvimento dos códigos, que estão na próxima seção.

Códigos

Os códigos para este projeto são simples: o mestre irá enviar apenas uma única informação (0 ou 1) e , ao receber a informação, o escravo irá acender ou apagar o LED (que está incluso nas placas Arduino pelo pino 13), conforme a informação recebida pelo mestre (Se 1, liga o LED. Se 0, o LED desliga).

Código Python (Raspberry Pi)

Por meio deste código, o usuário poderá, por meio da interface, digitar para qual escravo a informação será enviada (10 ou 11) e, depois, qual informação será enviada (0 ou 1).

Código Arduino

Segue abaixo o código para o Arduino. Lembre-se que você deve atualizar o valor do ID toda vez que for instalar um novo dispositivo na rede. Esse processo é realizado alterando o valor do primeiro parâmetro na função Modbus slave().

/**
 *  Exemplo - Modbus Escravo exemplo:
 *  Matheus Antonio da Silva
 *  19/10/2020
 */

//Inclui a biblioteca ModbusRtu.h
#include <ModbusRtu.h>     

// Define a variável TXEN como o pino 3 que será conectado aos pino RE-DE do conversor
#define TXEN  3 
//Define a variável LEDPIN como o pino 13 (que está conectado ao Led incluso nas placas do Arduino Mega) 
#define LEDPIN  13 

// Array que será utilizado como registrador para a leitura dos dados na rede
uint16_t au16data[16] = {
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };


/**
 *  Declaração de um objeto da biblioteca ModbusRtu
 *  u8id : nó da rede id = 0 para o mestre, = 1..247 para o escravo
 *  port : porta serial (conectada aos pinos DI-RO do conversor)
 *  u8txenpin : 0 caso for conexão RS-232 e USB-FTDI 
 *               ou qualquer outro pino > 1 para RS-485
 */
Modbus slave(10,Serial1,TXEN);

void setup() {
  Serial1.begin( 19200 );    //Inicia a Serial com baud-rate de 19200
  pinMode(LEDPIN,OUTPUT);   //Define o pino do led como Saída
  digitalWrite(LEDPIN,LOW); //Inicia o programa com o led desligado
  slave.start();            //Inicia a conexão na rede
}

void loop() {
  slave.poll(au16data,16);   //Atualiza o registrador com a informação enviada pelo Mestre

  if(au16data[1]){              //Caso o bit 1 do registrador for "true"...
     digitalWrite(LEDPIN,HIGH); //Acende o led.
  }else{                        //Se não...
    digitalWrite(LEDPIN,LOW);   //Apaga o led.
  }
}

Conclusão

Agora que você já sabe o básico para realizar a comunicação Modbus entre esses dispositivos, pode utilizar sua imaginação para desenvolver projetos mais complexos, como por exemplo: acionar relés, ler dados de sensores conectados aos escravos e instalar dispositivos diferentes na rede.

Espero que tenha gostado do post e que suas dúvidas estejam esclarecidas! 🙂