INSTITUTO FEDERAL DE EDUCAÇÃO CIÊNCIA E

TECNOLOGIA SUL-RIO-GRANDENSE

AUTOMAÇÃO INDUSTRIAL

DOMÓTICA - SISTEMAS SUPERVISÓRIOS - REDES

SCE – SISTEMA DE CONTROLE PARA ESTACIONAMENTO

Nome dos Alunos: Angelo Delamare, Clarissa Martins, Keila Kunz e

Letícia Ignacio

Professor: Rodrigo Scherer Correa

Camaquã

2017
 SUMÁRIO

SUMÁRIO DE IMAGENS ............................................................................................ 5

SUMÁRIO DE TABELAS............................................................................................. 6
INTRODUÇÃO ............................................................................................................ 7
1. MECÂNICA .......................................................................................................... 8
1.1 MAQUETE .................................................................................................... 8
1.2 CAIXAS ......................................................................................................... 9
1.3 TAMPA........................................................................................................ 10
1.4 MAQUETE PRONTA .................................................................................. 10
2. ELETRÔNICA .................................................................................................... 11
2.1 ARDUINO NANO ........................................................................................ 11
2.2 MÓDULO ETHERNET ................................................................................ 12
2.3 SENSOR ULTRASSÔNICO ........................................................................ 14
2.4 TRANSISTOR ............................................................................................. 16
2.5 FITA DE LED .............................................................................................. 16
2.6 ESQUEMAS ELÉTRICOS .......................................................................... 17
2.6.1 PLACA DE ACIONAMENTO DA FITA DE LED ..................................... 17
2.6.2 ARDUINO E ULTRASSÔNICO.............................................................. 18
2.6.3 ARDUINO E MÓDULO ETHERNET ...................................................... 18
2.6.4 ARDUINO, ULTRASSÔNICO E MÓDULO ETHERNET ........................ 19
2.6.5 COMPLETO COM OS DOIS ARDUINOS ............................................. 19
3. MODBUS ........................................................................................................... 21
3.1 HISTÓRICO ................................................................................................ 21
3.2 SOBRE O PROTOCOLO ............................................................................ 21
3.3 MODO DE TRANSMISSÃO ........................................................................ 23
3.4 ENDEREÇOS ............................................................................................. 23
3.5 CÓDIGO DA FUNÇÃO ............................................................................... 23
 3.6 MODO DE TRANSMISSÃO RTU (REMOTE TERMINAL UNIT)................. 24
3.7 MODBUS TCP ............................................................................................ 25
4. PROGRAMAÇÃO ARDUINO ............................................................................. 26
4.1 EtherCard.h ................................................................................................. 26
4.2 Modbus.h .................................................................................................... 26
4.3 Ultrasonic.h ................................................................................................. 28
4.4 NewPing.h ................................................................................................... 30
4.5 CÓDIGO DESENVOLVIDO ........................................................................ 32
5. SISTEMAS SUPERVISÓRIOS .......................................................................... 35
5.1 ELIPSE SCADA .......................................................................................... 35
5.1.1 MOTIVOS DA ESCOLHA ...................................................................... 36
5.1.1.1 EXPERIÊNCIA DA SALA DE AULA ................................................ 36
5.1.1.2 VERSÃO GRATUITA ...................................................................... 36
5.1.2 RECURSOS .......................................................................................... 36
5.1.2.1 LAYOUT .......................................................................................... 36
5.1.2.1.1 OBJETOS DE TELA .................................................................. 37
5.1.2.2 TAGS .............................................................................................. 38
5.1.2.3 SCRIPTS......................................................................................... 38
5.1.3 COMUNICAÇÃO ................................................................................... 39
5.1.3.1 CONFIGURAÇÃO DO DRIVER ...................................................... 39
5.1.3.1.1 CONFIGURAÇÕES EXTRAS .................................................... 40
5.1.3.2 CONFIGURAÇÃO DAS TAGS CLP ................................................ 41
5.1.4 PROBLEMAS ........................................................................................ 43
5.1.4.1 TEMPO DE RESPOSTA E PERDA DE SINAL ............................... 43
5.1.4.2 CONEXÃO COM DOIS CLPS ......................................................... 43
5.2 MYDESIGNER ............................................................................................ 43
5.2.1 MOTIVOS DA ESCOLHA ...................................................................... 44
5.2.1.1 LAYOUT .......................................................................................... 44
 5.2.1.2 VERSÃO GRATUITA ...................................................................... 44
5.2.2 RECURSOS .......................................................................................... 44
5.2.2.1 LAYOUT .......................................................................................... 44
5.2.2.1.1 OBJETOS DE TELA .................................................................. 45
5.2.2.2 TAGS .............................................................................................. 46
5.2.2.3 SCRIPTS......................................................................................... 46
5.2.3 COMUNICAÇÃO ................................................................................... 46
5.2.3.1 CONFIGURAÇÃO DA CONEXÃO .................................................. 46
5.2.3.2 CONFIGURAÇÃO DAS TAGS ........................................................ 47
5.2.4 LAYOUT DO ESTACIONAMENTO ....................................................... 48
5.2.4.1 PÁGINA HOME ............................................................................... 48
5.2.4.2 PÁGINA MONITORAMENTO ......................................................... 49
6. SIMULAÇÃO DE PROGRAMA UTILIZADO EM ESTACIONAMENTO .............. 49
CONCLUSÃO............................................................................................................ 52
REFERÊNCIAS BIBLIOGRÁFICAS .......................................................................... 53
 SUMÁRIO DE IMAGENS
Figura 1 - Maquete ...................................................................................................... 8
Figura 2 - Caixa Inferior ............................................................................................... 9
Figura 3 - Caixa Superior ............................................................................................ 9
Figura 4 - Tampa ....................................................................................................... 10
Figura 5 - Maquete pronta 1 ...................................................................................... 10
Figura 6 - Maquete pronta 2 ...................................................................................... 11
Figura 7 - Arduino Nano ............................................................................................ 11
Figura 8 - Módulo Ethernet ........................................................................................ 12
Figura 9 - Teste de funcionamento do módulo ethernet ............................................ 13
Figura 10 - Sensor ultrassônico................................................................................. 14
Figura 11 - Teste de funcionamento do sensor ultrassônico ..................................... 15
Figura 12 - Transistor ................................................................................................ 16
Figura 13 - Fita de LED ............................................................................................. 16
Figura 14 - Esquema placa de acionamento da fita de led ....................................... 17
Figura 15 - Esquema arduino e ultrassônico ............................................................. 18
Figura 16 - Esquema arduino e módulo ethernet ...................................................... 18
Figura 17 - Esquema arduino, ultrassônico e módulo ethernet ................................. 19
Figura 18 - Esquema completo com os dois arduinos............................................... 20
Figura 19 - Rede com o protocolo Modbus ............................................................... 22
Figura 20 - Quadro de mensagens para Protocolo Modbus ...................................... 22
Figura 21 - Bits no modo RTU ................................................................................... 24
Figura 22 - Modelo de mensagem Modbus TCP/IP .................................................. 25
Figura 23 - Layout Elipse Scada ............................................................................... 37
Figura 24 - Configuração do driver elipse scada ....................................................... 39
Figura 25 - Configurações extras do driver elipse scada .......................................... 40
Figura 26 - Configuração das tags CLP elipse scada ............................................... 41
Figura 27 - Layout myDesigner ................................................................................. 45
Figura 28 - Configuração da conexão myDesigner ................................................... 47
Figura 29 - Configuração das tags myDesigner ........................................................ 48
Figura 30 - Página Home .......................................................................................... 48
Figura 31 - Página Monitoramento ............................................................................ 49
Figura 32 - Programa ELIPSE (tela inicial) ................................................................ 50
Figura 33 - Programa ELIPSE (escolha de setores) ................................................. 50
Figura 34 - Programa ELIPSE (escolha de corredores) ............................................ 50
Figura 35 - Programa ELIPSE (movimentação de um corredor escolhido) ............... 51
 SUMÁRIO DE TABELAS

Tabela 1 - Especificações do arduino nano.................................................................12

Tabela 2 - Especificações do módulo ethernet ...........................................................13
Tabela 3 - Ligações do módulo ethernet.....................................................................14
Tabela 4 - Especificações do sensor ultrassônico.......................................................15
Tabela 5 - Especificações do transitor........................................................................16
Tabela 6 - Especificações da fita de LED....................................................................17
Tabela 7 - Especificações do protocolo modbus.........................................................24
Tabela 8 - Comandos da biblioteca Modbus.h............................................................27
Tabela 9 - Propriedades do driver elipse scada..........................................................40
Tabela 10 - Principais parâmetros do driver elipse scada..........................................40
Tabela 11 - Propriedades da tag CLP elipse scada....................................................42
 INTRODUÇÃO

Durante as aulas de domótica, redes e sistemas supervisórios, o grupo decidiu

dar continuidade ao projeto do estacionamento que teve início no ano anterior. O SCE
traz uma forma mais simples e rápida de obter um espaço para seu veículo. Dessa
forma, indicando a atual situação das vagas, o motorista pode escolher o lugar mais
próximo ao seu objetivo de destino, no contexto de grandes centros comerciais. Usar
sistemas automatizados, atualmente, é uma tendência pois dispor de um grande
número de funcionários para determinadas funções gera um custo mais alto se
comparado a equipamentos que possam realizar as mesmas funções que seres
humanos. Hoje em dia, a maioria dos locais que frequentamos possui um
estacionamento próprio e, dependendo da sua dimensão, encontramos certa
dificuldade de encontrar vagas disponíveis.

A intenção é, ao longo deste semestre, detectar a situação das vagas em um

estacionamento por meio de sensores ultrassônicos e enviar esta informação para um
sistema de supervisão que mostrará as vagas ocupadas na cor vermelha e as livres
nas cores verde ou azul.
1. MECÂNICA

As principais peças que compõem o carro serão listadas e descritas a seguir.

1.1 MAQUETE

Figura 1 - Maquete
 A maquete que será utilizada para serem realizados os testes e fixadas as
caixas com os componentes eletrônicos segue abaixo:
1.2 CAIXAS

Figura 2 - Caixa Inferior

Figura 3 - Caixa Superior

Foram construídas duas caixas iguais para o estacionamento. A finalidade de

ambas é abrigar o arduino nano e o módulo Ethernet. E será fixada em cima das vagas
do estacionamento, com a face aberta, onde será fixada a tampa, para baixo.
 1.3 TAMPA

Figura 4 - Tampa

Assim como as caixas, também foram impressas duas tampas iguais. Nelas
serão colocados os sensores ultrassônicos, e, posteriormente, serão fixadas nas
caixas.

1.4 MAQUETE PRONTA

Figura 5 - Maquete pronta 1

 Figura 6 - Maquete pronta 2

2. ELETRÔNICA

2.1 ARDUINO NANO

Figura 7 - Arduino Nano

 A plataforma utilizada no projeto consiste no Arduino Nano, caracterizado por
seu tamanho pequeno, baseado no ATmega328 ou ATmega168. As especificações
do Arduino utilizado pelo grupo podem ser vistas na tabela seguinte:

ESPECIFICAÇÕES DO ARDUINO NANO

MICROCONTROLADOR Atmel ATmega328
TENSÃO DE OPERAÇÃO 5V
TENSÃO DE ENTRADA (RECOMENDADA) 7-12V
TENSÃO DE ENTRADA (LIMITE) 6-20V
PINOS DIGITAIS (I/O) 14 (6 PWM)
PINOS DE ENTRADA
ANALÓGICOS 8
CORRENTE DC POR PINO 40mA
MEMÓRIA FLASH 32KB
MEMÓRIA SRAM 2KB
MEMÓRIA EEPROM 1KB
VELOCIDADE CLOCK 16MHz
LARGURA 45mm
COMPRIMENTO 18mm
PESO 5g

Tabela 1 - Especificações do arduino nano

2.2 MÓDULO ETHERNET

Figura 8 - Módulo Ethernet

 Serão utilizados dois módulos ethernet do modelo ENC-28J60 para transmitir
as informações via cabo de rede para o sistema de supervisão. Suas especificações
podem ser conferidas a seguir:

ESPECIFICAÇÕES DO MÓDULO ETHERNET

ENC-28J60
INTERFACE SPI
TENSÃO DE TRABALHO 3.3V
CRISTAL 25MHz
DIMENSÕES 55mm x 33mm
PORTA ETHERNET RJ45

Tabela 2 - Especificações do módulo ethernet

Figura 9 - Teste de funcionamento do módulo ethernet

Para verificar o funcionamento do módulo, foi utilizado um Arduino UNO e nele,

conectados os cabos em seus devidos pinos, como pode ser visto abaixo.
Constatando o funcionamento adequado, eles foram fixados nas caixas.
 LIGAÇÕES
ENC28j60 ARDUINO NANO/DUE ARDUINO MEGA
CS D10 D53

SI D11 D51

SO D12 D50

SCK D13 D52

RESET RESET RESET

INT D2 D2

VCC 3V3 3V3

GND GND GND

Tabela 3 – Ligações do módulo ethernet

2.3 SENSOR ULTRASSÔNICO

Figura 10 - Sensor ultrassônico

Serão utilizados dois sensores ultrassônicos do modelo HC-SR04, um em cada

vaga, para a identificação de carros, indicando, assim, a situação da vaga. Em outras
palavras, se o sensor ultrassônico identificar um veículo na vaga determinada, indicará
que ela está ocupada, caso não indentifique nenhum veículo, indicará que ela está
livre. As especificações dos sensores se encontram na tabela abaixo:
 ESPECIFICAÇÕES DO SENSOR
ULTRASSÔNICO HC-SR04
TENSÃO DE TRABALHO 5V
CORRENTE 15mA
FREQUÊNCIA 40Hz
ALCANCE MÁXIMO 4m
ALCANCE MÍNIMO 2cm
ÂNGULO DE MEDIDA 15°
ENTRADA DE SINAL TRIGGER 10uS pulso TTL

Tabela 4 - Especificações do sensor ultrassônico

Figura 11 - Teste de funcionamento do sensor ultrassônico

Para o teste de funcionamento dos sensores ultrassônicos, por meio da

utilização de um Arduino UNO, foram conectados (de acordo com a ordem de cores:
vermelho, verde, amarelo e preto) o sinal positivo, o Trig e Echo do sensor em pinos
de sinal do Arduino e o GND. Após confirmado o funcionamento dos sensores, foram
anexados em em cada tampa da caixa, prontos para a etapa da programação.
 2.4 TRANSISTOR

Figura 12 - Transistor

Serão utilizados seis transistores na placa eletrônica que funcionarão como

chave. Eles serão colocados na placa eletrônica responsável pelo funcionamento a
qual é responsável pelo funcionamento das fitas de LED.

ESPECIFICAÇÕES DO TRANSISTOR BC-548

TENSÃO 30V
CORRENTE IC 100A

Tabela 5 - Especificações do transistor

2.5 FITA DE LED

Figura 13 - Fita de LED

Outro componente presente no projeto é a fita de LEDs RGB que irá indicar a
situação das vagas do estacionamento de forma independente. Caso a vaga esteja
ocupada, somente os LEDs vermelhos ficarão ligados e, em contrapartida, se a vaga
estiver livre, ficarão ligados os LEDs verdes para vagas convencionais ou azuis para
vagas reservadas para portadores de deficiência. Suas especificações podem ser
vistas abaixo:

ESPECIFICAÇÕES DA FITA DE LED SMD 5050

POTÊNCIA 14,4W/metro
TENSÃO DE ENTRADA 12V
CORRENTE 1,2A
COR RGB
MATERIAL Silicone
PESO 484g
DIMENSÕES 25mm x 9mm x 5m

Tabela 6 - Especificações da fita de LED

2.6 ESQUEMAS ELÉTRICOS

2.6.1 PLACA DE ACIONAMENTO DA FITA DE LED

Figura 14 - Esquema placa de acionamento da fita de led

2.6.2 ARDUINO E ULTRASSÔNICO

Figura 15 - Esquema arduino e ultrassônico

2.6.3 ARDUINO E MÓDULO ETHERNET

Figura 16 - Esquema arduino e módulo ethernet

2.6.4 ARDUINO, ULTRASSÔNICO E MÓDULO ETHERNET

Figura 17 - Esquema arduino, ultrassônico e módulo ethernet

2.6.5 COMPLETO COM OS DOIS ARDUINOS

Figura 18 - Esquema completo com os dois arduinos
 3. MODBUS

3.1 HISTÓRICO

O protocolo Modbus é uma estrutura de mensagem aberta desenvolvida

pela Modicon na década de 70, utilizada para comunicação entre dispositivos mestre-
escravo/cliente-servidor. A Modicon foi posteriormente adquirida pela Schneider e os
direitos sobre o protocolo foram liberados pela Organização Modbus. Muitos
equipamentos industriais utilizam o Modbus como protocolo de comunicação e, graças
às suas características, este protocolo também tem sido utilizado em uma vasta gama
de aplicações como instrumentos e equipamentos de laboratório, automação
residencial e automação de navios.

3.2 SOBRE O PROTOCOLO

O Modbus é um dos protocolos mais utilizados em automação industrial, graças

à sua simplicidade e facilidade de implementação, podendo ser utilizado em diversos
padrões de meio físico, como RS-232, RS-485 e Ethernet TCP/IP (MODBUS TCP). A
velocidade de comunicação varia em cada um desses padrões, bem como o
comprimento máximo da rede e o número máximo de dispositivos conectados.

O padrão Ethernet no protocolo Modbus, o qual será utilizado neste projeto,

possui algumas variações, podendo chegar a 100Mbps ou até 10Gbps. A distância
máxima pode variar de 100m até próximo de 200m dependendo do tipo de cabo
utilizado e das condições de instalação do mesmo. Em alguns casos é possível utilizar
redes em fibra ótica, fato que permite alcançar distâncias maiores e melhores taxas
de comunicação, bem como utilizar comunicação wireless.

Na figura abaixo, é possível visualizar um exemplo de rede com o protocolo

Modbus, com um gateway fazendo a conexão entre os dois tipos de Modbus, o serial
em RS-485 e o TCP/IP em Ethernet. O mestre da rede, que nesse caso é um CLP
(Controlador Lógico Programável) envia e recebe dados dos escravos, que são
posteriormente um inversor de frequência, uma IHM (Interface Homem Máquina), um
controlador de temperatura e uma interface de I/O remota Modbus.
 Figura 19 - Rede com o protocolo Modbus

A estação mestre inicia a comunicação solicitando que os escravos enviem

seus dados. Os escravos, por sua vez, recebem a requisição do mestre e retornam os
dados solicitados. Os dados transmitidos podem ser discretos ou numéricos, ou seja,
é possível enviar valores numéricos como temperatura e pressão ou enviar um bit
para ligar e desligar um motor. Na figura a seguir é possível observar como é
constituído o quadro de mensagens no protocolo Modbus.

Figura 20 - Quadro de mensagens para Protocolo Modbus

 3.3 MODO DE TRANSMISSÃO

Na especificação do protocolo estão definidos dois modos de transmissão:

ASCII e RTU. Os modos definem a forma como são transmitidos os bytes da
mensagem, e como a informação da mensagem será empacotada na mensagem e
descompactada. Não é possível utilizar os dois modos de transmissão na mesma
rede. O modo de transmissão pode ser selecionado com outros parâmetros da porta
de comunicação serial, mas existem equipamentos que não permitem essa seleção,
pois possuem modo de transmissão fixo, como por exemplo alguns CLP's e inversores
de frequência que utilizam o modo RTU por padrão.

3.4 ENDEREÇOS

Ao todo o protocolo Modbus possui 256 endereços onde:

 0 - (Zero) é o endereço de Broadcast, quando o mestre envia uma mensagem

para o endereço zero, todos os escravos recebem a mensagem;
 1 - 1 até 247 -Endereços disponíveis para os escravos;
 2 - 248 até 255 Endereços reservados.

O mestre não possui endereço, somente os escravos devem possuir endereço

definido.

3.5 CÓDIGO DA FUNÇÃO

É onde o mestre especifica o tipo de serviço ou função solicitada ao escravo

(leitura, escrita, etc). No protocolo Modbus, cada função é utilizada para acessar um
tipo específico de dado.

CÓDIGO DA DESCRIÇÃO
FUNÇÃO
1 Leitura de bloco de bits do tipo coil (saída discreta).
2 Leitura de bloco de bits do tipo entradas discretas.
3 Leitura de bloco de registradores do tipo holding.
4 Leitura de bloco de registradores do tipo input.
5 Escrita em um único bit do tipo coil (saída discreta).
 6 Escrita em um único registrador do tipo holding.
7 Ler o conteúdo de 8 estados de exceção.
8 Prover uma série de testes para verificação da comunicação e
erros internos.
11 Obter o contador de eventos.
12 Obter um relatório de eventos.
15 Escrita em bloco de bits do tipo coil (saída discreta).
16 Escrita em bloco de registradores do tipo holding.
17 Ler algumas informações do dispositivo.
20 Ler informações de um arquivo.
21 Escrever informações em um arquivo.
22 Modificar o conteúdo de registradores de espera através de
operações lógicas.
23 Combina ler e escrever em registradores numa única transação.
24 Ler o conteúdo da fila FIFO de registradores.
43 Identificação do modelo do dispositivo.

Tabela 7 - Especificações do protocolo modbus

3.6 MODO DE TRANSMISSÃO RTU (REMOTE TERMINAL UNIT)

No modo RTU, cada mensagem de 8 bits contém dois caracteres hexadecimais

de 4 bits. Cada mensagem deve ser transmitida em um fluxo contínuo de caracteres.

Figura 21 - Bits no modo RTU

No modo RTU não existe um caractere específico que indique o início ou o fim
de um telegrama. A indicação de quando uma nova mensagem começa ou quando
ela termina é feita pela ausência de transmissão de dados na rede, por um tempo
mínimo de 3,5 vezes o tempo de transmissão de um byte de dados. Sendo assim,
caso um telegrama tenha iniciado após a decorrência desse tempo mínimo, os
elementos da rede irão assumir que o primeiro caractere recebido representa o início
de um novo telegrama. E da mesma forma, os elementos da rede irão assumir que o
telegrama chegou ao fim quando, recebidos os bytes do telegrama, este tempo
decorra novamente.
Se durante a transmissão de um telegrama o tempo entre os bytes for maior
que este tempo mínimo, o telegrama será considerado inválido, pois o controlador irá
descartar os bytes já recebidos e montará um novo telegrama com os bytes que
estiverem sendo transmitidos. O tempo para transmitir uma palavra do quadro varia
de 573us para taxas de comunicação acima de 19200bits/s e 9 ms para a taxa de
1200bits/s. O campo de checagem de erros é baseado no método CRC (Cyclical
Redundancy Checking).

3.7 MODBUS TCP

Modbus TCP é uma implementação do protocolo Modbus baseado em TCP/IP.

Utiliza a pilha TCP/IP para comunicação e adiciona ao quadro Modbus um cabeçalho
específico chamado MBAP (MODBUS Application Protocol). O modelo de mensagem
Modbus TCP/IP fica da seguinte forma:

Figura 22 - Modelo de mensagem Modbus TCP/IP

O cabeçalho MBAP tem tamanho de 7 bytes, e é composto pelos seguintes

campos:
 Transaction identifier: usado para identificação da resposta para a transação (2
bytes);
 Protocol identifier: 0 (zero) indica Modbus (2 bytes);
 Length: contagem de todos os próximos bytes (2 bytes);
 Unit identifier: utilizado para identificar o escravo remoto em uma rede Modbus
RTU (1 byte).
O Modbus TCP não acrescenta ao quadro um campo de checagem de erros,
entretanto, o frame ethernet já utiliza CRC-32 tornando desnecessário outro campo
de checagem. O cliente Modbus TCP deve iniciar uma conexão TCP com o servidor
a fim de enviar as requisições. A porta TCP 502 é a porta padrão para conexão com
servidores Modbus TCP.
 4. PROGRAMAÇÃO ARDUINO

Neste capítulo será apresentado o código desenvolvido para o projeto SCE -

Sistema de Controle para Estacionamento. Para que haja um melhor entendimento
da programação desenvolvida o primeiro passo será explicar as bibliotecas utilizadas
e o porquê de substituí-las ou não. No segundo momento será explicado o código final
desenvolvido.

4.1 EtherCard.h

Esta biblioteca foi desenvolvida para utilizar a módula ethernet ENC28J60,

nesta biblioteca já estão definidas as portas físicas do módulo. Os endereços de MAC
e de IP são definidos no void setup para que a conexão responda corretamente. Esta
biblioteca geralmente é usada em conjunto com outras bibliotecas, no caso do SCE
ela está vinculada com a biblioteca Modbus.

4.2 Modbus.h

Como já foi dito anteriormente a biblioteca Modbus é usada em conjunto com a

EtherCard. O protocolo usado nesta biblioteca é do tipo mestre-escravo, geralmente
usado em automações industriais e residenciais. As vantagens da utilização dessa
biblioteca é principalmente o fato de ser possível operar no modo escravo e suportar
o Modbus Serial.

A biblioteca Modbus se subdivide em:

 Modbus
 ModbusSerial
 ModbusIP
 ModbusIP_ENC28J60
 ModbusIP_ESP8266AT

Em nosso programa usamos a ModbusIP_ENC28J60, devido ao componente

que estamos utilizando no hardware possuir o chip ENC28J60.
 A biblioteca também possui comandos específicos para cada tipo de saída e
entrada, a tabela a seguir nos traz cada código e sua função correspondente.

Tabela 8 – Comandos da biblioteca Modbus.h

Para utilizar qualquer um desses comandos devesse colocar dentro dos

parênteses o registro da variável que deve ser enviada ou recebida, após uma divisão
por vírgula coloca-se o nome da variável. No programa utilizado no projeto usamos
apenas o comando addHreg(), pois desejamos apenas enviar para a rede um
parâmetro definido ao longo do programa.

O comando mb.task() serve para alterar a informação que foi enviada

anteriormente, caso necessário. Se a informação enviada for, por exemplo, uma
leitura de um sensor devesse usar este comando para trocar a informação ao finalizar
o loop. No entanto, um fato que deve ser destacado é que este comando
preferencialmente deve ser chamado apenas uma vez durante cada execução da
rotina.

Abaixo temos um exemplo de programação utilizado as duas bibliotecas já

citadas, no exemplo o objetivo é acender um led usando o TCP/IP do Modbus.

#include <EtherCard.h>
#include <Modbus.h>
#include <ModbusIP_ENC28J60.h>

//declaração variáveis
const int LAMP1_COIL = 100;
const int ledPin = 9;
 ModbusIP mb;

void setup() {
//configuração MAC
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//configuração IP
byte ip[] = { 192, 168, 1, 120 };
mb.config(mac, ip);
pinMode(ledPin, OUTPUT);
mb.addCoil(LAMP1_COIL);
}

void loop() {
mb.task();

digitalWrite(ledPin, mb.Coil(LAMP1_COIL));
}

4.3 Ultrasonic.h

Essa biblioteca foi desenvolvida para utilizar o ultrassônico HC-SR04. Está

biblioteca possui um funcionamento fácil, a primeira coisa que deve ser informada é
os pinos do arduino em que o trigger e o echo estão conectados.

Após declarar a variável e informar os pinos do hardware para a leitura são

usados dois comandos, um para calcular o tempo de resposta entre o envio do pulso
e seu retorno. O outro comando faz a conversão do tempo para centímetro ou para
polegadas. Abaixo temos um código para a leitura e visualização da distância
detectada pelo sensor.

#include <Ultrasonic.h>

#define TRIGGER_PIN 12
 #define ECHO_PIN 13

//declaração dos pinos do ultrassônico

Ultrasonic ultrasonic(TRIGGER_PIN, ECHO_PIN);

void setup()
{
Serial.begin(9600);
}

void loop()
{
float cmMsec, inMsec;
//leitura do tempo de resposta
long microsec = ultrasonic.timing();

//conversão do tempo de resposta para centímetros e para polegadas,

sucessivamente
cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
inMsec = ultrasonic.convert(microsec, Ultrasonic::IN);
Serial.print("MS: ");
Serial.print(microsec);
Serial.print(", CM: ");
Serial.print(cmMsec);
Serial.print(", IN: ");
Serial.println(inMsec);
delay(1000);
}

No início do projeto nós utilizamos a biblioteca Ultrasonic.h, mas tivemos

problemas na hora da conexão entre a interface gráfica e a resposta do arduino. O
ultrassônico por perder muitas respostas se torna muito instável com essa biblioteca,
portanto chegamos à conclusão que o melhor era utilizar a biblioteca NewPing.
 4.4 NewPing.h

A biblioteca NewPing.h foi criada justamente para resolver alguns problemas

que outras bibliotecas de ultrassônico do arduino sofriam. Uma das vantagens de usar
essa biblioteca é o fato de ser requisitado que o programador defina uma distância
máxima, o que diminui alguns bugs.

Esta biblioteca trabalha com diversos modelos de sensor: SR04, SRF5, SRF06,
entre outros. O atraso é diminuído com esta biblioteca. Abaixo temos um exemplo de
como esta biblioteca funciona:

#define SONAR_NUM 15
#define MAX_DISTANCE 200
#define PING_INTERVAL 33

unsigned long pingTimer[SONAR_NUM];

unsigned int cm[SONAR_NUM];
uint8_t currentSensor = 0;

NewPing sonar[SONAR_NUM] = {
NewPing(41, 42, MAX_DISTANCE);
NewPing(43, 44, MAX_DISTANCE),
NewPing(45, 20, MAX_DISTANCE),
NewPing(21, 22, MAX_DISTANCE),
NewPing(23, 24, MAX_DISTANCE),
NewPing(25, 26, MAX_DISTANCE),
NewPing(27, 28, MAX_DISTANCE),
NewPing(29, 30, MAX_DISTANCE),
NewPing(31, 32, MAX_DISTANCE),
NewPing(34, 33, MAX_DISTANCE),
NewPing(35, 36, MAX_DISTANCE),
 NewPing(37, 38, MAX_DISTANCE),
NewPing(39, 40, MAX_DISTANCE),
NewPing(50, 51, MAX_DISTANCE),
NewPing(52, 53, MAX_DISTANCE)
};

void setup() {
Serial.begin(115200);
pingTimer[0] = millis() + 75;
for (uint8_t i = 1; i < SONAR_NUM; i++)
pingTimer[i] = pingTimer[i - 1] + PING_INTERVAL;
}

void loop() {
for (uint8_t i = 0; i < SONAR_NUM; i++) {
if (millis() >= pingTimer[i]) {
pingTimer[i] += PING_INTERVAL * SONAR_NUM;
if (i == 0 && currentSensor == SONAR_NUM - 1) oneSensorCycle();
sonar[currentSensor].timer_stop();
currentSensor = i;
cm[currentSensor] = 0;
sonar[currentSensor].ping_timer(echoCheck);
}
}
}

void echoCheck() {
if (sonar[currentSensor].check_timer())
cm[currentSensor] = sonar[currentSensor].ping_result / US_ROUNDTRIP_CM;
}
void oneSensorCycle() {
for (uint8_t i = 0; i < SONAR_NUM; i++) {
Serial.print(i);
Serial.print("=");
Serial.print(cm[i]);
Serial.print("cm ");
}
Serial.println();
}

4.5 CÓDIGO DESENVOLVIDO

A seguir será mostrado o código usado no projeto SCE – Sistema de Controle

para Estacionamento. Antes é importante ressaltar que como usamos dois sensores
ultrassônicos, um para cada vaga, a programação usada em ambos os arduinos é
quase igual. A mudança entre a programação de cada vaga está no endereço de MAC
e do IP, isso foi necessário para que não haja conflito na rede entre a informação
enviada por cada módulo.

Programação final:

//As bibliotecas são adicionadas

#include <EtherCard.h>
#include <Modbus.h>
#include <ModbusIP_ENC28J60.h>

#include <NewPing.h>
//Declaração das variáveis e defines
#define BLUE 6
#define RED 7
const int ULTRA_1 = 0;

NewPing ultra (9, 8, 100);

int aux;

float cm;

long ultTempo;
long tempoAtual;
int periodo;

ModbusIP mb;

void setup ()
{
//Endereço de MAC do módulo
byte mac [] = {0xDE, 0xAD, 0xBE, 0xEF, 0xEF, 0xFE, 0xED};

//Endereço de IP do módulo
byte ip [] = {192, 168, 0, 5};

//Configuração do módulo
mb.config (mac, ip);

//Definição do endereço da variável que será enviada

mb.addHreg (ULTRA_1, 0);

aux = 0;

Serial.begin (115200);
 //Definição dos leds como saída
pinMode (BLUE, OUTPUT);
pinMode (RED, OUTPUT);

//Inicialização das variáveis

ultTempo = 0;
tempoAtual = 0;
periodo = 3000;
}

void loop ()
{
cm = ultra.ping_cm();

//Variável tempoAtual recebe o tempo decorrido de processamento

tempoAtual = millis ();

//Caso já tenha transcorrido 3 segundos a rotina dentro do if será executada

if (tempoAtual > ultTempo + periodo)
{

//teste se a distância está menor que 8cm

if (cm < 8)
{
//Leds acendem vermelho e o parâmetro 1 é enviado para a rede
aux = 1;
digitalWrite (BLUE, LOW);
digitalWrite (RED, HIGH);
}
else
{
//Leds acendem azuis e o parâmetro 0 é enviado para a rede
 aux = 0;
digitalWrite (BLUE, HIGH);
digitalWrite (RED, LOW);
}

ultTempo = tempoAtual;
}

//configuração para envio do parâmetro

mb.task ();
mb.Hreg(ULTRA_1, aux);
//Configuração para envio da distância pela serial
Serial.print(cm);
Serial.println("cm");
}

5. SISTEMAS SUPERVISÓRIOS

Os sistemas supervisórios são programas que permitem o monitoramento e

rastreamento de informações ao longo de um processo produtivo. Esses dados são
adquiridos por meio de equipamentos como sensores, sendo, em seguida,
manipulados, analisados, armazenados e apresentados ao usuário para o melhor
gerenciamento dos recursos.

5.1 ELIPSE SCADA

O Elipse Scada foi um dos primeiros sistemas de supervisão e aquisição de

dados produzido por uma empresa nacional na década de 90. Na época de seu
lançamento era considerada a mais poderosa ferramenta para o desenvolvimento de
sistemas de supervisão e controle de processos, posto que manteve por um longo
período até a apresentação de seu sucessor, o Elipse E3.

Ele possui uma grande versatilidade, a qual é representada em seus diversos

recursos que facilitam e agilizam a tarefa de desenvolvimento. Permitindo ser
totalmente configurável pelo usuário, proporciona a monitoração de variáveis em
tempo real, através de gráficos e objetos. Além de receber informações, consente em
envia-las, assim, possibilitando fazer acionamentos na planta operacional.

5.1.1 MOTIVOS DA ESCOLHA

Indiscutivelmente, apesar de todos seus recursos, esse sistema está bastante

atrasado em relação as novidades do mercado, entretanto nossa escolha não se
fundamentou nisso, e sim, nos respectivos itens:

5.1.1.1 EXPERIÊNCIA DA SALA DE AULA

Ao longo do primeiro semestre do quarto ano do Curso Técnico de Automação

Industrial na matéria de Sistema Supervisório, ministrada pelo professor Rodrigo
Scherer Correa, posteriormente a um período teórico, trabalhamos exclusivamente
com esse programa. Desse modo, conhecíamos quase todos os seus comandos e
possibilidades, o que foi a razão fundamental para proclamação do Elipse Scada para
a elaboração do sistema de supervisão do estacionamento.

5.1.1.2 VERSÃO GRATUITA

Em virtude de não ser mais o carro chefe da empresa, essa oportuniza uma
versão gratuita do mesmo. Apesar dessa ser limitada em 20 tags, isso não tornou-se
um problema para o projeto, em razão de necessitarmos de apenas duas tags PLC
para o desenvolvimento da proposta. Assim, juntando esse quesito com o anterior, a
inclinação pelo Elipse Scada pareceu a mais óbvia para o grupo por permitir, na teoria,
a composição do trabalho sem nenhum grande obstáculo.

5.1.2 RECURSOS

5.1.2.1 LAYOUT
 Figura 23 - Layout Elipse Scada

5.1.2.1.1 OBJETOS DE TELA

A seguir é apresentada uma lista com os principais objetos de tela que o Elipse
Scada oferece e suas respectivas funções.

 Slider – é um potenciômetro que permite visualizar e enviar valores para uma

tag.
 Tendência – possibilita visualizar informações de até 16 tags em um gráfico.
 Botão – acionamentos ou execução de tarefas especificadas pelo usuário
através do mouse ou teclado.
 Gauge – demonstra valores analógicos com um medidor
 Texto – permite escrever informações nas telas de execução, além de atribuir
mensagens a intervalos de valores, Zonas, das tags, definindo cores e textos
para cada um deles.
 Barras – possibilita visualizar informações de até 16 tags em um gráfico de
barras.
 Display – mostrador alfanumérico em tempo real.
  Animação – possibilita a formação de animações através de imagens
escolhidas pelo usuário.
 Setpoint – caixa de edição para digitação e envio de valores para uma variável.
 Alarmes – permite a visualização de alarmes pré-ordenados pelo usuário.
 Browser – viabiliza a visualização de arquivos de banco de dados.
 Bitmap – promove a inserção de imagens na tela.
 Watcher – propicia inserir objetos para a visualização de vídeos ao vivo.

5.1.2.2 TAGS

A seguir é apresentada uma lista com os tipos de tags que o Elipse Scada
oferece e suas respectivas funções.

 PLC – é utilizada para trocar informações com equipamentos de aquisição de

dados, o que inclui escrita e leitura, por intermédio de drivers de comunicação.
 Bloco PLC – mesma funcionalidade da tag PLC, contudo permite a leitura de
vários dados simultaneamente, desse modo, otimiza a comunicação.
 RAM – viabiliza guardar valores em memória, mas, como própria memória
RAM, é volátil, só guardando informações enquanto o aplicativo estiver
correndo.
 Matriz – mesma funcionalidade da tag RAM, contudo permite acesso matricial.
 Demo – propicia a simulação de valores.
 Crono – promove a criação de contadores e temporizadores.
 Expressão – permite a formação de expressões numéricas e alfanuméricas.
 DDE – possibilita o acesso e troca de dados com programas cuja finalidade são
servidores.

5.1.2.3 SCRIPTS

Os Scripts são pequenos procedimentos escritos em linguagem de

programação, Elipse Basic, que permitem uma maior flexibilidade na aplicação. Os
scripts são sempre associados a ocorrência de eventos, os quais são relacionados a
objetos. Eles podem ser físicos, como alguma ação no mouse, ou internos, como a
mudança do valor de uma variável. Em cada caso, temos diversas informações
relevantes como a tecla pressionada ou a posição do cursor. Por fim, eles podem
também ter associações físicas, como a mudança de uma temperatura quando temos
uma tag associada.

5.1.3 COMUNICAÇÃO

Para usufruir da comunicação entre o Arduino e o Elipse Scada é necessário

utilizar tags PLC, que permitem ler e escrever dados em um CLP, nesse caso o
Arduino. Elas podem representar variáveis digitais ou analógicas, dependendo da
configuração escolhida pelo usuário. Todavia, antes de utilizar-se de qualquer tag
desse gênero é indispensável criar um objeto driver, o qual comandará a interligação
entre a tag associada e o CLP.

5.1.3.1 CONFIGURAÇÃO DO DRIVER

Uma vez escolhido o arquivo de driver – biblioteca - que será associado a um

objeto driver, deve-se fazer as configurações dos parâmetros de comunicação como:
porta serial, taxa de comunicação e outros, de acordo com os requisitos de cada tipo
de arquivo .DLL.

Figura 24 - Configuração do driver elipse scada

 PROPRIEDADES DO DRIVER
Opção Descrição
Nome Nome do objeto corresponde ao driver.
Localizar Permite trocar o driver.
Recarregar Atualiza o sistema, recarregando o driver.
Ajuda Instruções do funcionamento do driver.

Tabela 9 – Propriedades do driver elipse scada

PRINCIPAIS PARÂMETROS
P1; P2; P3; P4 Campos de entrada dos parâmetros do CLP.
Abortar em erro Possibilita a abertura de uma caixa de mensagem, em
caso de erro de comunicação, pleitando o
cancelamento da interligação.
Retentar comunicações Indica que driver pode tenta restabelecer a conexão
falhadas perdida.
No. de tentativas Número de tentativas no caso de erro de comunicação.

Tabela 10 – Principais parâmetros do driver elipse scada

5.1.3.1.1 CONFIGURAÇÕES EXTRAS

Figura 25 - Configurações extras do driver elipse scada

 Na aba de configurações extras é possivel configurar o Modbus, Setup
(inicialização do driver), Serial, Ethernet, Modem e RAS (comandos AT). Para o
funcionamento de nosso projeto em rede Modbus TCP somente foi necessário utilizar-
se das páginas Modbus e Ethernet.

Apesar da página Modbus oferecer uma grande lista de opções de

configuração, como as variáveis de operações, apenas necessitamos ajustar o modo
do Modbus para Modbus TCP. Por sua vez, na página Ethernet, foi imprescindível
regular o transporte para TCP/IP e a conexão, IP e porta. Para o módulo ethernet 1
utilizamos IP: 192.168.0.5 e Port: 502, já para o módulo ethernet 2 utilizamos IP:
192.168.0.6 e mesma Port.

5.1.3.2 CONFIGURAÇÃO DAS TAGS CLP

Figura 26 - Configuração das tags CLP elipse scada

PROPRIEDADES DA TAG CLP

Opção Descrição
Nome Nome da tag.
Mudar tipo para... Possibilita a mudança do tipo de tag.
 Acessar bit... Permite abrir a tag em bits, criando tags bit para um ou
mais bit da tag principal.
Descrição Uma breve descrição sobre a tag.
Driver Permite a seleção do driver associado a tag.
Ajuda Instruções do funcionamento do driver.
Parâmetros N Valores expressos em decimais, octais ou hexadecimais,
ajustados de acordo com as configurações de cada driver.
Scan Intervalo de tempo para a releitura do valor da tag.
Testar conexão aqui Testa a conexão com o CLP
Habilita leitura por Valor da tag será atualizado de acordo com o tempo
scan definido no parâmetro scan.
Habilita leitura Valor da tag só é lido quando necessário. Caso a opção
automática “Habilita leitura por scan” estiver acionada, esta opção é
ignorada.
Habilita escrita Promove a escrita automática para a tag PCL.
automática

Tabela 11 – Propriedades da tag CLP elipse scada

Posteriormente a criação das tags PCL, vaga_1 e vaga_2, adequou-se as

alternativas driver, parâmetros N e scan. Na primeira opção, selecionou-se para cada
vaga seu respectivo driver, alocado na aba drivers, por sua vez, na segunda ajustou-
se os valors N1= 1, N2 = 1, N3 = 0, N4 = 1, de acordo com o sugerido pelo driver.
Finalmente, adaptamos o scan para 500ms, assim, atualizando o valor da tag nesse
intervalo de tempo.

Ademais, foi habilita a leitura pelo scan e utilizado bastante o teste de conexão
de leitura, pois apenas mandamos o dado, se a vaga está ocupada ou não, do CLP
para o Elipse Scada. Esse emprego constante da alternativa, deu-se em razão da
necessidade de experimentar a conexão, o qual é facilitado com essa opção em
virtude de não precisarmos rodar a aplicação para avaliar
 5.1.4 PROBLEMAS

5.1.4.1 TEMPO DE RESPOSTA E PERDA DE SINAL

Ao longo do desenvolvimento do projeto, se constatou que na maioria das

vezes o Elipse Scada demorava demais para responder as mudanças na vaga, o que,
por seu turno, resultava no travamento do software. Outrossim, destacou-se o grande
fluxo de perda de sinal entre o CLP e o Scada. Esses dois problemas não deviam
acontecer em tamanha dimensão, pois apenas um CLP estava conectado com o
sistema de supervisão e enviando apenas uma informação, assim, não se requerendo
muito processamento. Após, uma bateria de ajuste na programação do arduino,
conseguiu-se diminuir a ocorrência desses fatores, entretanto continuou-se com uma
média de erro elevada, algo em torno de 1 para 2, ou seja, em metade das execuções
do projeto acontecia uma dessas falhas.

5.1.4.2 CONEXÃO COM DOIS CLPS

Depois da diminuição dos problemas anteriores, tentamos conectar as duas

vagas juntas, ou seja, os dois arduinos e seus acessórios. Nesse momento, ficou claro
para o grupo que o Elipse Scada não conseguiria ajudar no desenvolvimento do
projeto, o sistema supervisório simplesmente parou de responder, deixando de
funcionar a vaga que já era utilizada e travando a cada tentativa de execução do
aplicativo. Desse modo, evidenciou-se que em razão de ser um software antigo, com
drivers desatualizados, o tempo gasto tentando resolver mais essa questão seria
inviável, em virtude de outros Scadas, mais modernos, estarem mais preparados para
a execução do projeto.

5.2 MYDESIGNER

O myDesigner, um sistema supervisório da myScada, é flexível e possui uma

interface de usuário intuitiva, biblioteca de componentes e muitas funções. Sua grande
vantagem é que possibilita utilizar o projeto em qualquer dispositivo, como um
servidor, tablet, PC ou smartphone. Diferente do Elipse Scada, que apesar dos
recursos estava atrasado em relação as novidades do mercado, o myDesigner é
considerado uma das plataformas de desenvolvimento mais avançadas e simples da
atualidade.

5.2.1 MOTIVOS DA ESCOLHA

O professor Rodrigo ao se deparar com os respectivos problemas causados

pelo Elipse Scada, nos sugeriu a mudança para o myDesigner por ser um produto
mais novo, entretanto essa não foi a única razão da escolha desse sistema.

5.2.1.1 LAYOUT

Como já explanado anteriormente, o sistema supervisório possui um layout

totalmente diferente do Elipse Scada. Enquanto, o Elipse, possui uma grande
quantidade de itens em 3d em virtude de ter sido lançada na época que esse recurso
estourou nos computadores pessoais, o myDesigner busca deixar a tela o mais limpa
possível, de acordo com os estudos atuais da área de designer. Além disso, ele
possui uma grande biblioteca de componentes e possibilitava criar com extrema
facilidade qualquer equipamento necessário para o projeto.

5.2.1.2 VERSÃO GRATUITA

Outra justifica para a escolha foi que para uso pessoais, como no caso do
projeto do estacionamento, a myScada o disponibiliza totalmente de graça, ainda que
quiséssemos comercialização o projeto, o custo cobrado pela empresa é muito inferior
a outros Scadas. Assim, juntando os quesitos apresentados, a inclinação pelo
myDesigner pareceu a mais óbvia para o grupo, após o fracasso com o Elipse Scada.

5.2.2 RECURSOS

5.2.2.1 LAYOUT
 Figura 27 - Layout myDesigner

5.2.2.1.1 OBJETOS DE TELA

A seguir é apresentada uma lista com os principais objetos de tela que o

myDesigner oferece e suas respectivas funções.

 Draw – nessa seção da barra de ferramentas, pode-se escolher o tipo de objeto

que deseja desenhar ou inserir uma área ativa, imagem ou componentes da
biblioteca.

- Line – cria uma linha.

- Square – cria um quadrado.

- Circle – cria um círculo.

- PolyLines / Bézier Curves – cria um conjunto de linhas ou um arco.

- Rectangle – cria um retângulo.

- Elipse – cria uma elipse.

- Text Element – permite inserir uma mensagem na tela, que pode ser
atualiza com valores de tags.
 - Image – propicia a inserção de imagens nos formatos PNG, JPG e
JPEG, as quais podem ser redimensionadas.

- Components – abre a biblioteca de itens, a qual é instalada junto com

o myDesigner. Essa possui barras, botões, gráficos, displays, switches,
gauges, entre outros recursos que podem ser customizados conforme a
preferência do usuário.

- Active Areas – regiões na tela que apresenta conteúdo dinâmico,

como alarmes e históricos.

 Outras Seções – são focadas mais na distribuição, agrupamento, ajuste e

redimensionamento dos objetos da tela.

5.2.2.2 TAGS

No myDesginer são possíveis criar tags de script, usadas nos scripts,

expressão, usadas para fazer operações com as tags, e de acordo com o tipo de
comunicação escolhida.

5.2.2.3 SCRIPTS

Os scripts desse sistema supervisório seguem a mesma lógica do Elipse

Scada, as diferenças são a linguagem de programação e os recursos. Enquanto o
sistema anterior utilizava uma linguagem própria, esse utiliza JavaScript, o que resulta
em uma gama muito maior de funcionalidades.

5.2.3 COMUNICAÇÃO

5.2.3.1 CONFIGURAÇÃO DA CONEXÃO

Para usufruir da comunicação entre o Arduino e o myDesigner é necessário

criar uma conexão do tipo Modbus. Para isso é primordial acessar na aba Project
Window, a opção Connections e nessa Add Connection. Na nova página se pode
configurar o type (tipo), alias (apelido), IP, port (porta), devide ID (ID do dispositivo) e
advanced options (opções avançadas).

No caso do estacionamento foi necessário apenas configurar o tipo, apelido e

IP. Para os dois arduinos se utilizou o tipo MODBUS e as configurações padrões para
port (502), device ID(1) e Advanced Option (Optimisation Window = 50 e Separate
Writes desabilitada). A diferença entre cada arduino ficou nas variáveis apelido e IP,
o primeiro recebeu o pseudônimo CLP5 e IP 192.168.0.5, já o outro CLP6 e
192.168.0.6.

Figura 28 - Configuração da conexão myDesigner

5.2.3.2 CONFIGURAÇÃO DAS TAGS

Posteriormente a elaboração das conexões é imprescindível criar tags

referentes as posições de registros utilizadas no CLC (arduino). Para isso é primordial
acessar na aba Project Window, a opção Tags Database. Na nova página se pode
configurar o Alias, Tag@Conn, Desc, Unit, Format e Eng. Unit.

No caso do estacionamento foi necessário apenas ajustar o apelido e a

Tag@Conn, para o CLP5 se criou uma tag com apelido Vaga 1 e H:0@CLP5, já para
o CLP5 se criou uma tag com apelido Vaga 2 e H:0@CLP6.

A opção Tag@Conn é adequada da seguinte forma:

 Em Tag se escolhe o tipo de variável e a posição de registro, nesse caso foi

determinado H:0, aonde H equivale ao tipo inteiro estritamente não negativo de
 16 bits (unsigned integer) e o 0 equivale a posição zero de registro na rede
modbus.
 Em Conn se escolhe a qual conexão a tag estará subordinada.

Figura 29 - Configuração das tags myDesigner

5.2.4 LAYOUT DO ESTACIONAMENTO

As duas páginas do projeto foram configuradas para a resolução 1280 X 800 e

para visualização do sistema supervisório se utiliza o software myView7.

5.2.4.1 PÁGINA HOME

Figura 30 - Página Home

Para ter acesso a página “Monitoramento”, o usuário deve fazer o login na

chave no canto direito superior, caso seu nível de acesso seja 9 na opção Views, no
canto superior esquerdo, aparecerá a outra página, onde é feito o controle das vagas.
 5.2.4.2 PÁGINA MONITORAMENTO

Figura 31 - Página Monitoramento

No caso da Vaga I, se ela estiver liberada aparecerá a imagem do carro verde

e quando ocupada a imagem do carro vermelha. Por sua vez, no caso da Vaga II, se
ela estiver liberada aparecerá a imagem do carro azul e quando ocupada a imagem
do carro vermelha. Essa diferenciação acontece em razão da Vaga II ser destinada a
portadores de deficiência.

Para voltar à página inicial deve-se clicar na Views, no canto superior esquerdo,
e escolher a opção “Home”, se o usuário quer sair do programa basta clicar no boneco,
no canto superior direito, assim, fazendo logoff da aplicação.

6. SIMULAÇÃO DE PROGRAMA UTILIZADO EM ESTACIONAMENTO

Foi criado no Elipse SCADA um programa que simula o sistema de supervisão

de nosso projeto em funcionamento.
 Figura 32 - Programa ELIPSE (tela inicial)

Figura 33 - Programa ELIPSE (escolha de setores)

Figura 34 - Programa ELIPSE (escolha de corredores)

Figura 35 - Programa ELIPSE (movimentação de um corredor escolhido)
 CONCLUSÃO

A partir dos testes realizados com o protótipo foi possível concluir que a escolha
do utilizar sensores ultrassônicos, ao invés de LDRs como no ano anterior, foi
adequada às aplicações propostas para o estacionamento, pois possibilitou uma
leitura menos instável. Além disso, pelo fato dos sensores ultrassônicos estarem muito
próximos um do outro, verificamos uma interferência entre eles, o que acarretou em
problemas de leitura. Para resolver o problema foi preciso isolar os sensores, o que
foi feito utilizando um pedaço de madeira.
O desenvolvimento do sistema de supervisão foi concluído e possibilitou a
visualização da situação das vagas através da tela de um computador, sem a
necessidade do motorista procurar as vagas livres pelo estacionamento e sim, ter a
possibilidade de localizá-las na tela. Isso foi possível através da utilização de Modbus,
que transmitiu a informação lida pelo sensor por meio de um cabo ethernet, para o
computador.
As aulas de redes, sistemas supervisórios e domótica foram de grande utilidade
para aplicarmos conhecimentos de eletrônica, programação e comunicação. Estudar
a construção da maquete, montar o circuito eletrônico, escrever a programação e
realizar a comunicação via Modbus enriqueceu o conhecimento de cada integrante do
grupo. Os testes e observações realizados a cada etapa do processo proporcionaram
maior compreensão e domínio dos assuntos.
 REFERÊNCIAS BIBLIOGRÁFICAS

Monk, Simon. Projetos com arduino e android: use seu smartphone ou tablet para
controlar o arduino. Tradução: Anatólio Laschuk. Porto Alegre: Bookman, 2014.

McRoberts, Michael. Arduino básico; Tradução: Rafael Zanolli. São Paulo; Novatec
Editora, 2011.

Monk, Simon. Programação com Arduino: Começando com Sketches, 1ed; Grupo
A, 2013.

Monk, Simon. 30 Projetos com Arduino. 1ed; Grupo A, 2014.

Oliveira, Cláudia Luís vieira. Arduino Descomplicando: como Elaborar Projetos de

Eletrônica. 1ed; Érica, 2015.

SOFTWARE, Myscada. MyDesigner user manual version 7. 2017

SOFTWARE, Elipse. Manual do usuário. 2010

ECKEL, Tim. New Ping Library for Arduino. 2017. Disponível em:
http://playground.arduino.cc/Code/NewPing. Capturado em: 24 de outubro de 2016;
14h:32min:26seg.

ITEAD. Arduino Library for ultrasonic ranging module HC-SR04. 2010. Disponível
em: https://www.itead.cc/blog/arduino-library-for-ultrasonic-ranging-module-hc-sr04.
Capturado em:10 de setembro de 2016; 04h:04min:07seg.

TECKEL. New Ping Library Project Homepage. 2016. Disponível em

https://forum.arduino.cc/index.php?topic=106043.0. Capturado em: 22 de outubro de
2016; 18h:21min:30seg.
SARMENTO, Andreia. Biblioteca Modbus para Arduino. Disponível em:
https://github.com/andresarmento/modbus-arduino/blob/master/README_pt_BR.md.
Capturado em: 05 de setembro de 2016; 13h:27min:32seg.

SILVEIRA, Cristiano Bertulucci. Saiba Tudo Sobre o Protocolo Modbus. Disponível

em: https://www.citisystems.com.br/modbus/. Capturado em: 14 de outubro de 2016;
17h:37min:58seg.

INSTRUMENTS, National. O protocolo Modbus em detalhes. Disponível em:

http://www.ni.com/white-paper/52134/pt/. Capturado em: 15 de outubro de 2016;
22h:48min:23seg.