INSTITUTO FEDERAL CATARINENSE

CAMPUS LUZERNA

CURSO SUPERIOR EM ENGENHARIA DE CONTROLE E AUTOMAÇÃO

IMPLEMENTAÇÃO DA COMUNICAÇÃO MODBUS RTU NO

MICROCONTROLADOR ATMEGA 328P

Maurício Bonadiman e Victor Vinícius Jung

Luzerna – SC

2021
 Resumo
A comunicação entre dispositivos no meio industrial, por muito tempo foi
dominada pelo protocolo Modbus RTU, através do meio físico RS-485. Hoje, com o
avanço das tecnologias de comunicação, o seu uso tende a diminuir, mas mesmo assim,
ainda é muito encontrado nas diversas aplicações industriais, por se tratar de um meio
de comunicação simples, eficaz e confiável.

Este projeto aborda o uso do protocolo Modbus RTU para comunicar um

Microcontrolador ATMEGA 328 com um inversor de frequência Schneider ATV-312 e
um programa de supervisório Elipse Scada, afim de entender o seu funcionamento para
futuras aplicações no chão de fábrica ou até mesmo para evolução do presente projeto.

Também, este projeto pode ser utilizado como base, para projetos onde se
necessite acionar dispositivos a distância com certa facilidade de instalação da
rede(apenas um par de cabos trançados), e com baixo custo em material, quando
comparado com a implementação de um controlador lógico programável (CLP).

Palavras Chaves: Modbus RTU, ATMEGA328, Inversor de frequência, Supervisório.

Sumário
1 Introdução ................................................................................................... 4
2 Objetivos ..................................................................................................... 5
2.1 Objetivo Geral ................................................................................................... 5
2.2 Objetivos Específicos ......................................................................................... 5
3 Fundamentação Teórica ............................................................................. 6
3.1 Componentes Utilizados...................................................................................6

3.1.1 Arduino Uno..........................................................................................6

3.1.2 Conversor TTL - RS485...........................................................................7

3.1.3 Inversor ATV312....................................................................................8

3.1.4 Protocolo Modbus.................................................................................8

4 Procedimentos Metodológicos (ou desenvolvimento) .................................. 9

4.1 Software.................................................................................................6

3.2 Microcontrolador...................................................................................6

4.3 Módulo Conversor TTL/RS485................................................................6

4.4 Inversor ATV-312 (escravo 1)..................................................................6

4.5 Supervisório Elipse SCADA (escravo 2)....................................................6

4.6 Programa................................................................................................6

5 Resultados e Discussões ............................................................................ 9

Conclusão ....................................................................................................... 10
Referências ..................................................................................................... 11
1 Introdução

Uma antena transmitindo sinal para os rádios, um controle remoto enviando sinal
para a TV, um controlador enviando sinal para o atuador, todos esses exemplos servem
para mostrar que a comunicação entre dispositivos está presente nas mais adversas
situações de nossas vidas através de diversos meios.

A criação do protocolo Modbus foi criada no final da década de 70 pela empresa

Modicon e era utilizado para a comunicação de dados em sistemas de automação. Mais
tarde, a empresa passou a ser controlada pela gigante francesa Schneider Eletric a qual
transferiu os direitos do protocolo para a Modbus Organization em 2004, deixando o seu
uso livre da taxa de licenciamento. Esse processo tornou o Modbus um dos protocolos
mais utilizados por todo o mundo e também amplamente utilizado nos dias de hoje,
contribuindo com a evolução tecnológica.

O protocolo Modbus RTU funciona como uma comunicação mestre-escravo,

onde o mestre requisita informações e os escravos respondem à essa requisição. A
mensagem enviada tanto pelo mestre quanto pelo escravo possui o mesmo formato,
sendo ele dividido em 4 partes: endereço do dispositivo, código da função, dados e
checagem de erros.
2 Objetivos

2.1 Objetivo Geral

O objetivo geral do projeto é realizar a comunicação de um microcontrolador

ATMEGA 328 com um inversor de frequência e um sistema supervisório através do
protocolo de comunicação Modbus RTU. Para o presente projeto, o microcontrolador
será o mestre da rede, requisitando e enviando informações aos escravos.

2.2 Objetivos Específicos

Compreender o funcionamento de um protocolo Modbus, do meio físico RS-485,

compreender o funcionamento da comunicação serial no microcontrolador, estudar e
aplicar a biblioteca ModbusRTU utilizando a IDE (Integrated Development Environment)
do Arduino como meio de programação e gravação do microcontrolador, compreender
e implementar a parametrização necessário para o funcionamento do inversor de
frequência em modbus RTU, criar um programa no software para supervisionar o
inversor.
3 Fundamentação Teórica

3.1 Componentes Utilizados

Para realizar a comunicação via Modbus RTU utilizou-se alguns componentes

que necessitam ser explicados para um entendimento mais detalhado do projeto. Este
capitulo é destinado para essa explicação.

3.1.1 Arduíno Uno

O arduino foi desenvolvido em 2005 com o objetivo de ser uma plataforma

programável barata e usual dando acesso a uma tecnologia que não era acessível a
todos, com esse diferencial, ele foi amplamente utilizado pelas escolas.

Atualmente existem diversos modelos de Arduino, basicamente o que os

diferenciam são o tipo de conexão ao hospedeiro e o tipo de controlador. O Arduino
pode ser utilizado no controle de sistemas caseiros (abrir/fechar uma cortina) bem como
em sistemas industriais, porém de porte menores devido à suas limitações
principalmente em questão à complexidade quando comparado a um CLP (Controlador
Lógico Programável) por exemplo. Neste projeto utilizou-se um Arduino uno e serão
listados algumas de suas características quanto aos componentes da placa:

- Microcontrolador ATMEGA328:

• Arquitetura RISC;
• 32KB de memória flash (menos 512 bytes reservados ao bootloader);
• 2Kb de RAM;
• 1Kb de EEPRON;
• 28 pinos (23 de I/O);
• Tensão de operação 4.5 - 5.5V (ou até 1.8V com frequência reduzida);
• 2 temporizadores/contadores 8 bits;
• 1 temporizador/contador 16 bits;
• 6 entradas e saídas ADC 10 bits;
• 32 registradores de 8 bits;
• Comparador analógico;

- Alimentação da Placa:

• Alimentação via USB ou externa através do conector Jack;

 • Tensão de alimentação com variação de 6-20V (porém é recomendado uma
variação de 7-12V);
• Regulação de tensão através do CI NCP1117;
• Circuito para comutar a alimentação caso haja uma tensão no conector DC
e a USB for conectada;

- Alimentação de Shields e módulos:

• IOREF – Fornece uma tensão de referência para Shields que funcionam em

outras tensões se adaptem e funcionem em 5V;
• RESET – Pino de reset externo;
• 3.3V – Fornece 3.3V com corrente máxima de 50mA;
• 5V – Fornece 5V;
• GND - Ground/Terra;
• VIN – Pino de alimentação através de bateria externa/shield;

- Entradas e Saídas da Placa:

• 14 pinos I/O digital de 5V com no máximo 40mA;

• 6 saídas PWM de 8 bits;
• 2 pinos de comunicação serial (comunicação do USB com o PC);
• 2 pinos para serem usados como interrupção externa;
• 6 entradas analógicas de 10 bits;

- Programação:

• A programação na placa é feita de forma serial, utilizando o protocolo

STK500;
• A programação no microcontrolador pode ser feita através do conector ICSP
utilizando um programador ATMEL;

3.1.2 Conversor TTL – RS485

Tendo em vista que o arduino se comunica através da linguagem TTL

(Transistor-Transistor Logic) utilizando níveis de tensão de acordo com o binário 0 ou 1
(5V para 1 e 0V para 0) e o inversor de potência recebe os sinais no formato RS485,
onde os binários 0 e 1 são caracterizados pela diferença da polaridade entre os 2
condutores presentes no par de fios (0 se a tensão do condutor negativo for maior que
a do positivo e 1 caso a tensão do condutor positivo for maior que a do negativo), tornou-
se necessária a utilização de um conversor TTL – RS485 que através do chip MAX485
realiza essa conversão de dados.
3.1.3 Inversor ATV312

O inversor de frequência, é amplamente utilizado na indústria para controle de

velocidade de motores elétricos. O inversor de frequência vem se tornando cada
vez mais versátil, e adaptado as novas tecnologias industriais. Podendo ser
acionado de forma remota, a grande maioria dos inversores possui algum tipo de
porta de comunicação, no caso do inversor utilizado para o projeto, o mesmo possui
uma porta serial RS-485 que permita a comunicação do mesmo com outros
dispositivos na rede.

A sua utilização no projeto se dá apenas com o objetivo de estabelecer

comunicação entre ele e o microcontrolador, afim de enviar e receber dados e como
o objetivo principal de comprovar o funcionamento do protocolo modbus RTU
implementado.

3.1.4 Protocolo Modbus

O protocolo modbus funciona, de uma forma simplifica, através da divisão de

uma determinada mensagem nas seguintes partes:

• Endereço do Dispositivo: O protocolo Modbus possui 256

endereços, porém apenas os de 1-247 são utilizados para os escravos,
o endereço 0 serve para mandar mensagem para todos os escravos e
248-255 são reservados;
• Código da Função: É o que define qual função o mestre está requisitando
do escravo. Existem uma série de código de funções, porém os mais
utilizados são: (1) leitura das saídas digitais, (2) leitura das entradas
digitais, (3) leitura dos registradores de saída analógica, (4) leitura de
registradores de entrada analógica, (5) leitura de uma única saída digital,
(6) escrita de um único registrador de saída analógica, entre outros;
• Dados: É onde os dados de requisição específicos, de acordo com o
código da função, são enviados;
• CRC: Cyclic Redundancy Check: É um método de detecção de erros que
funciona através da definição de um polinômio CRC de n termos onde
cada termo é representado por bits (exemplo 1𝑥 3 + 0𝑥 2 + 1𝑥 1 + 1𝑥 0 é
representado pelos bits 1011). Primeiramente coloca-se zeros no fim da
mensagem original equivalente ao número de bits do CRC, no caso do
exemplo seriam 3 zeros. A mensagem original será dividida pelo
polinômio CRC iniciando pela esquerda e deslocada 1 bit à direita após
cada divisão, ao final da divisão os n polinômios que não foram zerados
pelo CRC recebem o nome de valor da função CRC e são usados para
verificar a autenticidade da resposta da seguinte forma, pega-se
novamente a mensagem original, porém ao invés de adicionar os zeros
equivalentes ao polinômio do CRC, será adicionado o valor da função
CRC descrito anteriormente. A divisão dessa nova mensagem pelo
mesmo polinômio CRC deve resultar em 0 para não alteração do
conteúdo da mensagem.
4 Desenvolvimento (Procedimentos
Metodológicos)

4.1 Software de programação

Para a realização do projeto, foi utilizado o software de programação do Arduino

V1.8.13, escolheu-se esse software pela praticidade de programação, pelos autores do
projeto já possuírem essa ferramenta, e pela disponibilidade de material (Arduino) para
os testes de funcionamento.

A linguagem de programação utilizada no software é o C++, com algumas

pequenas modificações de funções específicas do software. Sendo assim, o programa
foi desenvolvido pelo compilador do Arduino, e transferido ao microcontrolador utilizado
a plataforma Arduino Uno para download do programa.

4.2 Microcontrolador

Como citado anteriormente, foi escolhido inicialmente no projeto a utilização do

microcontrolador Atmega 328P-u para o controle (como mestre) da rede comunicação
entre os dispositivos. Como o projeto foi realizado de forma remota por conta da
pandemia do vírus COVID-19 onde as aulas presenciais e de laboratório foram
canceladas, optou-se por utilizar essas ferramentas do Arduíno pela praticidade de não
precisar de bancada, fonte regulável, gravador de Microcontrolador, que não tínhamos
em mãos, e que de certa forma seria difícil de adquirirmos ou emprestarmos da
instituição. Sendo assim, seguimos o projeto nessa ideia de utilizar o Arduino como
forma de gravador para o microcontrolador Atmega 328P-u.

O Microcontrolador utilizado possui apenas uma porta de comunicação serial

(Pino 0=RX, pino 1=TX), o que satisfaz a necessidade do projeto. O microcontrolador
possui comunicação serial comunicação serial UART (Universal Asynchronous
Receiver/Transmitter) onde os bits são enviados/recebidos a uma dada cadência
acordada entre emissor e receptor a que se chama Baudrate (velocidade da
transmissão, medida em bits por segundo).

A Comunicação serial nos pinos TX/RX no microcontrolador utilizado usa níveis

lógicos TTL (do inglês, Transistor-Transistor Logic) que opera em tensão de 5V. Mas
como a comunicação Modbus-RTU utiliza o meio físico RS-485 que opera em tensões
de -1.5v a 1.5v, foi necessário utilizar um conversor de TTL para o padrão RS-485
 Figura 1 - Montagem do microcontrolador na protoboard

4.3 Módulo Conversor TTL/RS-485

O módulo utilizado no projeto, utiliza basicamente o CI MAX-485 para conversão

dos dados no padrão TTL para o padrão RS-485 conforme a figura a seguir.

Figura 2 - Esquema de ligação e pinagem do MAX-485

O conversor possui basicamente 4 pinos de entrada e 4 pinos de saída, na entrada,

os pinos RO,RE,DE,DO fazem o controle da comunicação no padrão TTL, onde os pinos
possuem as seguintes funções:

• RO= Receptor de saída

• RE= Receptor habilitado (habilitado quando este pino está em nível baixo)
 • DE= habilitação do driver (habilitado quando este pino está em nível alto)
• DI= Driver in (o pino do transmissor)

Na saída o drive possui 4 pinos Vcc, GND, A, B. Os pinos A e B são conectados

diretamente no barramento de comunicação serial RS-485. E os pinos Vcc e GND são
ligados a alimentação 5V.

4.4 Inversor ATV-312 (escravo 1)

Foi escolhido um inversor de frequência Schneider ATV-312 para servir como

escravo 1 da rede modbus RTU, o objetivo inicial do projeto é realizar a comunicação
entre o microcontrolador e o inversor de frequência, coletando dados de leitura, e
fazendo o controle de ligar/desliga e incrementando um set-point de velocidade para o
inversor.

O equipamento citado, foi escolhido por estar disponível para os autores do

projeto, e por possuir uma porta de comunicação serial modbus RS-485. O mesmo
possui um conector RJ-45 com as seguintes pinagens:

Figura 3 - Porta de comunicação RS-485 do ATV-312

Como visto na figura anterior, retirada do manual do inversor de frequência, foi

necessário utilizar os pinos 4 e 5 do conector, para conectar ao conversor TT/485.

• Pino 4 (D1) do RJ45, ligado ao pino A do conversor TTL/485

• Pino 5 (D0) do RJ45, ligado ao pino B do conversor TTL/485
 Para o inversor se comunicar perfeitamente com o microcontrolador, foi necessário
realizar a seguinte parametrização:

PARAMETRO VALOR FUNÇÃO

FR1 ndb Referência de velocidade via modbus
Cd1 ndb comando via modbus
Addr 1 Nó do dispositivo
Tbr 19.2 Velocidade de transmissão = 19.2 Kbps
tFO 8n1 8 bits de dados, sem paridade, 1 bit de parada
tto 2s Modbus time out
Tabela 1 - Parametrização ATV-312

Consultando o manual do inversor de frequência, foi possível verificar o endereço

dos registradores dos parâmetros de comando e set point de frequência, que são
disponibilizados da seguinte maneira:

Figura 4 - Endereços de escrita no ATV-312

Através de testes, foi possível perceber que os endereços são deslocados em

uma unidade, ou seja, ficou definido no programa que a variável de comando está no
endereço 8502, e a referência de velocidade no endereço 8503.
 Já os registradores de leitura (Hz saída, corrente no motor, e tensão da linha)
são lidos através dos endereços de registradores 3202 até 3207, conforme imagem a
seguir.

Figura 5 - Endereços de leitura no ATV-312

4.5 Supervisório Elipse SCADA (escravo 2)

Para realizar a visualização dos dados de leitura e enviar os comandos para o

inversor, foi utilizado o Software Elipse Scada. Nesse foram criadas duas telas
principais, a tela inicial de Login, e uma tela principal de controle. Na tela de login, é
possível fazer o controle de usuários, onde somente os usuários que possuírem login
podem acessar a tela de controle, possui indicação de usuário logado, um botão que
acessa a tela de controle (disponível apenas para usuário administrador), botões de
login e logout, e um botão de sair da aplicação, conforme a figura a seguir:

Figura 6 - Imagem tela login do supervisório

Na tela de comando, foi adicionado um botão de Liga/desliga, um status que

indica o comando enviado para o inversor (Control-Word), um Set-point de velocidade
e os valores de visualização dos parâmetros de saída do inversor, conforme a figura a
seguir:

Figura 7 - Tela de comando do supervisório

Para realizar a comunicação do supervisório com o microcontrolador, foi

necessário realizar a instalação do drive ModbusSlave.ddl, disponibilizado na página da
elipse. A partir daí foi necessário configurar o drive com a velocidade de transmissão
conforme a imagem a seguir:

Figura 8 - Configuração driver ModbusSlave

Também foi necessário definir os endereços das variáveis de acordo com a

programação feita no microcontrolador, conforme a imagem a seguir:
 Figura 9 - Configuração dos endereços das variáveis do supervisório

Para realizar a comunicação entre o Supervisório do computador e o barramento

RS-485, foi necessário a utilização de um conversor USB/R-485, esse possui dois
bornes de saída A e B, que são interligados ao barramento serial, nas portas A e B
respectivamente. O conversor utilizado é um modelo genérico, conforme o da figura a
seguir:

Figura 10 - Conversor USB/RS-485 utilizado no projeto

 Portanto, com todos os dispositivos na rede, o layout da rede ficou o
seguinte:

Figura 11 - Layout da rede

4.6 Programação

Como mencionado anteriormente, foi utilizado a ferramenta de programação do

Arduino para programação do microcontrolador. Para o funcionamento da comunicação,
foi necessário o uso da biblioteca <ModbusRtu.h>, que auxilia no gerenciamento das
transferências de dados entre os dispositivos. A programação realizada será comentada
por partes posteriormente.

Inicialmente, como representado na figura a seguir, foi declarado as bibliotecas

utilizadas, sendo elas a biblioteca ModbusRtu.h e outra biblioteca LiquidCrystal_I2c que
é uma biblioteca para funcionamento do display de 16x2 utilizado durante os
testes.Também é definido o pino 2 como controle de RE_DE, o número da porta serial
utilizada (zero), as strings de dados do pacote de comunicação para o escravo 1 e
escravo 2, as variáveis que indicam o estado da comuinicação, e as variáveis do pacote
de dados chamado telegram da comunicação com dada escravo.
 /*-----------------------------------------------------------------
* PROJETO INTEGRADOR 1
* Alunos: Mauricio Bonadiman e Victor Jung
* Comunicação Modbus RTU - Atmega 328/ATV-312/Supervisório
----------------------------------------------------------------*/
#include <LiquidCrystal_I2C.h> // Inclui a bibliotece do Display I2C
#include<ModbusRtu.h> // Inclui a biblioteca do Modbus RTU

#define RE_DE 2 // Define o pino 2 como DE_RE (DE=ATIVA PARA ENVIAR, RE=ATIVA PARA
RECEBER)
#define PORTA_Serial 0 // Define a porta seria 0 como porta de comunicação

#define LED 13

LiquidCrystal_I2C lcd(0x27, 16, 2); // define( Endereço do Lcd I2C, qnt colunas, qnt linhas)

uint16_t au16data[16]; // String de dados para uso da rede Modbus

uint8_t u8state; // status da comunicação
int CMD=0; // Variável de comando habilita
int pv_hz=0;
int sp_hz=0;
int pv_v=0;

uint16_t au16data_2[16]; // String de dados para uso da rede Modbus

uint8_t u8state_2; // status da comunicação
Modbus master_2(0, PORTA_Serial, RE_DE); // Configuração da biblioteca ( Modo Master=0, porta
Serial 0, controle RE_DE habilitado na porta 2)
modbus_t telegram_2[1]; // String para o telegrama do Modbus
unsigned long u32wait_2; // variável de tempo de esperad de do ciclo moddus

Modbus master(0, PORTA_Serial, RE_DE); // Configuração da biblioteca ( Modo Master=0, porta Serial
0, controle RE_DE habilitado na porta 2)
modbus_t telegram[1]; // String para o telegrama do Modbus
unsigned long u32wait; // variável de tempo de esperad de do ciclo moddus

Figura 12 - Definições iniciais do programa

A seguir, está apresentado a função para a comunicação com o escravo 1, onde

programa roda um switch sobre os estados da variável u8state. Sendo que para cada
estado é realizado um case. No case zero, é atribuído as variáveis de comando, e sp_hz
aos registradores au16data[0] e au16data[1], e em seguida no case um, é feita o envio
dos holding register para o primeiro escravo. O envio é determinado pela função 16
(Escrever holding registers), em dois registradores a partir do endereço 8501. Esse
endereço é referente a palavra de comando do inversor, e o segundo endereço (8502)
é referente ao set-point de velocidade do inversor. As tabelas dos endereços utilizados
no inversor serão apresentadas posteriormente. No case 2, é feito a checagem do
recebimento da mensagem, e posteriormente no case três é feita leitura dos
registradores do escravo 1 (inversor). É realizada a leitura de 6 registradores, a partir do
endereço 3202. O endereço 3202 é referente a frequência de saída do inversor, e os
endereços seguintes são referentes os parâmetros de leitura apresentados no
supervisório (corrente de saída do inversor, tensão de saída, e rotação do motor).
int escravo_1()
{
switch(u8state)
{
case 0:
if(millis() > (u32wait + 25))
{
uint8_t aux;
au16data[0] = CMD;
au16data[1] = sp_hz;
u8state++; // Tempo entre solicitações de informações (250mseg neste caso)
}
break;

case 1:
telegram[0].u8id = 1; // endereço do escravo
telegram[0].u8fct = 16; // código de função para escrever em multiplos registradores
telegram[0].u16RegAdd = 8501; // endereço de inicio da escrita
telegram[0].u16CoilsNo = 2; // quantidade de registradores a escrever
telegram[0].au16reg = au16data; // ponteiro para o vetor de memória
master.query(telegram[0]); // envia a solicitação ao escravo
u8state++;
break;
case 2:
master.poll(); // checa se recebeu retorno do comando
if(master.getState() == COM_IDLE) u8state++; // Incrementa contador
break;

case 3:
telegram[0].u8id = 1; // endereço do escravo
telegram[0].u8fct = 3; // código de função para ler registradores
telegram[0].u16RegAdd = 3202; // endereço de inicio da leitura
telegram[0].u16CoilsNo = 6; // numero de registradores a serem lidos
telegram[0].au16reg = au16data; // ponteiro para o vetor de memória
master.query(telegram[0]); // envia a solicitação ao escravo
u8state++;
break;
case 4:
master.poll(); // checa se recebeu retorno da solicitação
if(master.getState() == COM_IDLE)
{
u8state = 0; // Limpa o registrador para iniciar o ciclo
u32wait = millis(); // recarrega o contador
pv_hz = au16data[0];
pv_v = au16data[5];
}
break;
}

Figura 13 - Função escravo 1

 Posteriormente é implementado a mesma função criada para o escravo 1 para o
escravo 2, ajustando somente as variáveis de registro e endereço, e acertando os
endereços desejados para os registradores. Sendo assim, foi criada a função escravo_2
que realiza esses comandos de envio, checagem e requisição de dados também para
o segundo escravo que nesse projeto é o sistema de supervisório.

Após criar a função para o escravo 2, são atribuídos os parâmetros do programa

na função void setup(). Nessa, são configurados a velocidade de comunicação da rede
(19.2kbps), o endereço da porta serial, definidas as entradas e saídas digitais, e outros
parâmetros utilizados no programa.

void setup()

Serial.begin( 0, 19200 ); // Inicia a serial (Serial 0, velocidade=19200)

master.begin( &Serial, 19200 ); // (endereço da serial,velocidade)

master.setTimeOut( 1000 ); // Tempo limite para resposta

u32wait = millis(); // O número de milissegundos passados desde que o programa iniciou

//master_2.begin( &Serial, 19200 ); // (endereço da serial,velocidade)

//master_2.setTimeOut( 1000 ); // Tempo limite para resposta

u32wait_2 = millis(); // O número de milissegundos passados desde que o programa iniciou

Figura 14 - Void Setup

pinMode(LED, OUTPUT); // configura pino como saida

pinMode(RE_DE, OUTPUT); // configura pino como saida

lcd.init(); // INICIA A COMUNICAÇÃO COM O DISPLAY LCD

lcd.backlight(); // Liga luz de fundo

lcd.setCursor(5, 0);lcd.print("ATV-312"); lcd.setCursor(5, 1);lcd.print("ModBus RTU"); // Frase de inicialização do

LCD

delay(500);

lcd.clear(); //Limpa o LCD

}
 E finamente é chamada a função void loop, que é a função cíclica que é
executada a cada ciclo de scan do microcontrolador. nessa função são chamadas as
funções do escravo 1 e escravo 2, e feitas as escritas no display lcd as variáveis de
sp_hz, pv_hz, comando, e de pv_volts da saída do inversor.

void loop()

escravo_1();

escravo_2(pv_hz,pv_v);

lcd.setCursor(9,0);lcd.print("CMD:");lcd.print(12);lcd.print(" "); // -- Imprime o COMANDO no LCD

lcd.setCursor(0,0);lcd.print("SP:");lcd.print((sp_hz)/10);lcd.print("Hz "); // -- Imprime SP no LCD

lcd.setCursor(9,1);lcd.print("V:");lcd.print((float)(pv_v)/10, 1);lcd.print(" "); // -- Imprime o COMANDO

no LCD

lcd.setCursor(0,1);lcd.print("PV:");lcd.print((float)(pv_hz)/10, 1);lcd.print("Hz "); // -- Imprime SP no LCD

Figura 15 - Void loop

5 Resultados e Discussões

Mesmo não sendo um projeto inovador sem nenhuma fonte de pesquisa o

mesmo demandou uma quantidade significativa de conhecimentos acumulados durante
a faculdade e até mesmo fora dela, no mercado de trabalho. Muitas das fontes de
pesquisa utilizadas não possuíam uma explicação detalhada da aplicação do projeto
cabendo aos integrantes ir mais a fundo para tornar viável a sua aplicação, sendo assim,
foram gastas muitas horas em cima de pesquisas.

Os testes finais iniciaram um pouco em cima do prazo final, porém ambos os

testes foram concluídos com sucesso, sem nenhum imprevisto que pudesse causar
algum tipo de atraso na entrega. Por outro lado, após a conclusão de todos os itens
previstos no projeto, tentou-se utilizar um IHM (Interface Homem Máquina) para
comunicar com o Microcontrolador também como escravo, porém não foi possível
devido a falta de equipamento disponível para isso, portanto, optou-se por utilizar o
sistema de supervisório.

Como sugestão de melhoria futuras do projeto, pode-se explorar a inclusão de

outros escravos na rede, o melhoramento do desempenho da comunicação, e a
implementação de um controlador PID no microcontrolador atuando na frequência de
saída do inversor via Modbus.
Conclusão

Estabelecer a comunicação entre dispositivos utilizando o microcontrolador sem

dúvidas foi uma tarefa árdua para o grupo, tendo em vista que o curso só apresenta de
forma superficial a comunicação Modbus RTU, mostrou-se necessário pesquisar por
conta própria os tópicos do assunto para um entendimento mais detalhado.

Quanto a parte estrutural do projeto, só foi possível dar continuidade pois

conseguiu-se o uso dos equipamentos mais caros, como o inversor, da empresa Fast
LTDA, empresa à qual um dos integrantes do grupo presta seus serviços. Sem ela o
projeto ficaria apenas no papel devido ao COVID-19 e suas limitações impostas quanto
ao acesso do instituto bem como ao empréstimo de materiais do mesmo. Dito isso,
observou-se um ganho considerado no aprendizado devido à variedade de ferramentas
utilizadas no projeto, um exemplo é o uso do software elipse SCADA utilizado para a
construção do sistema supervisório.

Apesar de não utilizar o Arduino durante disciplinas na faculdade, sua plataforma

de programação baseada em C++ é muito similar às trabalhadas na disciplina de
programação básica e também em microcontroladores, então não apresentou grande
dificuldades de implementação. Mesmo com dificuldades, o projeto foi finalizado dentro
do prazo e cumprindo todos os requisitos estabelecidos no planejamento, deixando
espaço para futuras ampliações.
Referências

ATLAS, Equipe (Coord. e Superv.) NR-16 – Atividades e operações perigosas.

In: Segurança e medicina do trabalho. 65. ed. São Paulo: Atlas, 2010.

AHMED, Ashfaq. Eletrônica de potência. 1. ed. São Paulo: Prentice Hall, 1999.
479 p.

ASSOCIAÇÃO BRASILEIRA DE NORMAS TÉCNICAS. NBR 14724: informação

e documentação: trabalhos acadêmicos: apresentação. Rio de Janeiro, 2011.

ASSOCIAÇÃO BRASILEIRA DE NORMAS TÉCNICAS. NBR 6023: informação

e documentação: referências: elaboração. Rio de Janeiro, 2002.

ASSOCIAÇÃO BRASILEIRA DE NORMAS TÉCNICAS. NBR 6028: informação

e documentação: resumo: apresentação. Rio de Janeiro, 2003.

ASSOCIAÇÃO BRASILEIRA DE NORMAS TÉCNICAS. NBR 10520: informação

e documentação: citações em documentos: apresentação. Rio de Janeiro, 2002.

BARBI, Ivo. Eletrônica de potência. 4. ed. Florianópolis: Editora do Autor, 2002.

408 p.

CERVO, Amado Luiz; BERVIAN, Pedro Alcino; DA SILVA, Roberto.

Metodologia científica. 6. ed. 7. reimp. São Paulo: Pearson Prentice Hall, 2007. 162 p.

INSTITUTO FEDERAL CATARINENSE. Logo do IFC. [2014]. Disponível em:

<http://luzerna.ifc.edu.br/>. Acesso em: 19 nov. 2014.

STANKIEWICZ, Sidnei Rodrigo. Substituição da IHM do regulador de tensão

da hidrelétrica de campos novos. 2012. 45 f. Projeto de melhoria (Curso técnico em
Automação Industrial) – Instituto Federal Catarinense – IFC, Luzerna, 2012.