BACHARELADO EM ENGENHARIA DE CONTROLE E AUTOMAÇÃO

HECTOR ALEXANDRE OLIVEIRA ALVES DA CRUZ

KARLUS DEYVID GOMES VIANA

PROJETO DE AUTOMAÇÃO RESIDENCIAL UTILIZANDO

SOFTWARES E HARDWARES LIVRES

Campos dos Goytacazes/RJ

2016
 ii

HECTOR ALEXANDRE OLIVEIRA ALVES DA CRUZ

KARLUS DEYVID GOMES VIANA

PROJETO DE AUTOMAÇÃO RESIDENCIAL UTILIZANDO

SOFTWARES E HARDWARES LIVRES

Trabalho de conclusão de curso apresentado ao

Instituto Federal de Educação, Ciência e Tecnologia
Fluminense como requisito parcial para conclusão
do curso de Bacharelado em Engenharia de Controle
e Automação.

Orientador: Prof. Marcos Moulin Valencia.

Campos dos Goytacazes/RJ

2016
 iii

HECTOR ALEXANDRE OLIVEIRA ALVES DA CRUZ

KARLUS DEYVID GOMES VIANA

PROJETO DE AUTOMAÇÃO RESIDENCIAL UTILIZANDO

SOFTWARES E HARDWARES LIVRES.

Trabalho de conclusão de curso apresentado ao

Instituto Federal de Educação, Ciência e Tecnologia
Fluminense como requisito parcial para conclusão
do curso de Bacharelado em Engenharia de Controle
e Automação.

Aprovada em 03 de Junho de 2016.

Banca Avaliadora:

......................................................................................................................................................
Prof. Marcos Moulin Valencia (orientador)
Engenheiro Eletricista – UFRJ
Instituto Federal de Educação, Ciência e Tecnologia Fluminense/Campos

......................................................................................................................................................
Prof. Caio Fábio Bernardo Machado
Engenheiro de Controle e Automação – IFF
Instituto Federal de Educação, Ciência e Tecnologia Fluminense/Campos

......................................................................................................................................................
Prof. Yves Rocha de Salles Lima
Engenheiro de Controle e Automação – IFF
Instituto Federal de Educação, Ciência e Tecnologia Fluminense/Campos
 iv

AGRADECIMENTOS

Agradecemos primeiramente a Deus, por todas as graças alcançadas e por mais um

objetivo conquistado em nossas vidas.
Agradecemos também aos nossos pais Janilda e Roque, Amaro e Cândida, por todos
ensinamentos ao longo da vida, pelo incentivo em momentos desanimo, pelo carinho nos
momentos difíceis, pelas alegrias proporcionadas, enfim, por todo suporte necessário para nossa
formação.
Aos nossos irmãos Adriele, Heitor e Lívia, pelo companheirismo dedicado ao longo de
nossas vidas.
A Marcelle e Jerliano, pela paciência e apoio essenciais prestados em momentos decisivos
da elaboração deste trabalho.
Aos nossos professores ao longo do curso, que sempre se mostraram solícitos a dúvidas
mesmo fora dos horários de aula, e sempre procuraram passar seus ensinamentos da melhor
maneira.
A todos os amigos que dividiram conosco momentos de dificuldades, mas também de
alegrias ao longo do curso.
 v

RESUMO

Este trabalho apresenta o estudo e a implementação de um sistema de automação

residencial de baixo custo utilizando hardware e software livres, cujo objetivo principal é prover
um sistema básico de automação residencial através da tecnologia open source. Utilizando o
Arduino UNO, Raspberry PI 2 e Mango Automation, foi possível criar um protótipo de controle e
supervisão residencial, simulando tarefas e situações rotineiras de uma residência e algumas
implementações visando a segurança do patrimônio. O projeto foi implementado e testado com
sucesso numa maquete, os testes feitos através do supervisório e da interface física obtiveram os
resultados esperados.

Palavras-chave: Automação Residencial. Segurança. Arduino. Raspberry PI 2. Mango

Automation. Open Source.
 vi

ABSTRACT

This paper presents the study and implementation of a home automation system using
low-cost hardware and open source software, whose main objective is to provide a basic home
automation system using open source technology. Using Arduino UNO, Raspberry PI 2 and
Mango Automation, it was possible to create a prototype of control and supervision in a
residence, simulating tasks and daily situations of a residence and some implementations
observing the security of the property. The project was implemented and successfully tested in a
model , the tests through the supervisory and physical interface achieved the expected results.

Keyword: Home Automation . Security. Arduino. Raspberry PI 2. Mango Automation.

Open Source.
 vii

LISTA DE SIGLAS E SÍMBOLOS

ARM Advanced RISC Machine

ASCII American Standard Code for Information Interchange
CLP Controlador Lógico Programável
DHT Humidity and Temperature Sensor
DOS Disk Operating System
DVI Digital Visual Interface
EPROM Erasable Programmable Read-Only Memory
FTDI Future Technology Devices International
GB Gigabyte
GIF Graphics Interchange Format
GPIO General Purpose Input/Output
GUI Graphical User Interface
HD Hard Disk
HDMI High-Definition Multimidia Interface
HTML HyperText Markup Language
ICSP In-Circuit Serial Programming
IDE Integrated Development Environment
JDK Java Development Kit
LDR Light-Dependent Resistor
LED Light Emitting Diode
MHZ Mega-Hertz
PIR Passive Infrared
PWM Pulse Width Modulation
RAM Random Access Memory
RISC Reduced Instruction Set Computer
RTU Remote Terminal Unit
SCADA Supervisory Control and Data Acquisition
SQL Structured Query Language
SRAM Static Random Access Memory
TCP-IP Transmission Control Protocol/Internet Protocol
 viii

USB Universal Serial Bus

VDC Voltage Direct Current
WI-FI Wireless Fidelity
 ix

LISTA DE FIGURAS

Figura 1: Microcontrolador ATMega 328P ................................................................................... 10

Figura 2: Arduino Uno ................................................................................................................... 12
Figura 3: Raspberry PI 2 ............................................................................................................... 13
Figura 4: Sensor de Temperatura .................................................................................................. 14
Figura 5: Sensor de Luminosidade ................................................................................................ 14
Figura 6: Sensor de Presença ......................................................................................................... 15
Figura 7: LED ................................................................................................................................ 16
Figura 8: Buzzer ............................................................................................................................. 17
Figura 9: IDE Arduino ................................................................................................................... 20
Figura 10: TomCat ......................................................................................................................... 24
Figura 11: Esquema do LED ......................................................................................................... 30
Figura 12: Código do LED ............................................................................................................ 31
Figura 13: Código do Sensor de Temperatura ............................................................................... 32
Figura 14: Esquema do Sensor de Temperatura ............................................................................ 33
Figura 15: Esquema do Sensor de Luminosidade ......................................................................... 34
Figura 16: Código do Sensor de Luminosidade ............................................................................ 35
Figura 17: Código do Sensor de Presença ..................................................................................... 36
Figura 18: Esquema do Sensor de Presença .................................................................................. 37
Figura 19: Maquete........................................................................................................................ 41
Figura 20: Custos do Projeto ......................................................................................................... 42
Figura 21: Tela de Login do Mango Automation .......................................................................... 49
Figura 22: Verificando Conexão ................................................................................................... 50
Figura 23: Nome da Conexão ........................................................................................................ 51
Figura 24: Localização do Diretório .............................................................................................. 51
Figura 25: Adicionando Usuários .................................................................................................. 52
Figura 26: Verificando Procedimento ........................................................................................... 53
Figura 27: IDE Instalada................................................................................................................ 53
Figura 28: Acessando o Menu ....................................................................................................... 54
Figura 29: Protocolo de Comunicação .......................................................................................... 55
Figura 30: Finalização do Data Source ......................................................................................... 56
Figura 31: Criação do Data Point de Saída Digital ....................................................................... 57
Figura 32: Criação do Data Point de Entrega Analógica .............................................................. 58
Figura 33: Criação do Data Point de Entrada Digital ................................................................... 59
Figura 34: Conectando os Data Points .......................................................................................... 59
Figura 35: Conectando o Data Source .......................................................................................... 59
Figura 36: Criação da Representação Gráfica ............................................................................... 60
Figura 37: Anexando Imagem ....................................................................................................... 61
Figura 38: Configuração do Tipo de Data Point do Botão do LED .............................................. 62
Figura 39: Selecionando Data Point do Botão do LED ................................................................ 62
Figura 40: Configuração do Botão do LED ................................................................................... 63
Figura 41: Botão de Controle do LED ........................................................................................... 63
Figura 42: Operação do Botão do LED ......................................................................................... 63
Figura 43: Configuração do Tipo de Data Point do Sensor de Temperatura ................................ 64
Figura 44: Selecionando o Data Point do Sensor de Temperatura ............................................... 64
 x

Figura 45:Configuração do Termômetro ....................................................................................... 65

Figura 46: Termômetro Configurado ............................................................................................ 65
Figura 47: Configuração do Tipo de Data Point do Status do LED.............................................. 66
Figura 48: Selecionando o Data Point do Status do LED ............................................................. 67
Figura 49:Configuação do Status do LED ..................................................................................... 67
Figura 50: Status do LED Configurado ......................................................................................... 68
 ii

SUMÁRIO

1- INTRODUÇÃO ....................................................................................................................... 05

1.1- Histórico ................................................................................................................................. 05

1.2- Contextualização .................................................................................................................... 05
1.3- Justificativa ............................................................................................................................ 06
1.4 – Objetivo ................................................................................................................................ 06
1.5 – Objetivo Específico .............................................................................................................. 07
2– REVISÃO BIBLIOGRÁFICA .............................................................................................. 08

2.1 – Hardware .............................................................................................................................. 08

2.1.1- Hardware Livre ........................................................................................................... 08

2.1.2 - Microcontrolador ........................................................................................................ 09

2.1.2.1 – Microcontrolador ATMega 328P. .......................................................................... 09

2.1.3 – Plataforma de Prototipagem ...................................................................................... 10

2.1.3.1 - Arduino .................................................................................................................... 11

2.1.3.1.1 – Arduino Uno ........................................................................................................ 11

2.1.4 – Raspberry PI 2 ........................................................................................................... 12

2.1.5 – Sensores ..................................................................................................................... 13

2.1.5.1 – Sensor de Temperatura ........................................................................................... 13

2.1.5.2 – Sensor de Luminosidade......................................................................................... 14

2.1.5.3 – Sensor de Presença ................................................................................................. 15

2.1.6 - LED ............................................................................................................................ 15

2.1.7 - Buzzer ......................................................................................................................... 16

2.2 -Software.................................................................................................................................. 17
2.2.1 – Software Livre ........................................................................................................... 17

2.2.2 - IDE ............................................................................................................................. 17

2.2.2.1 – IDE Arduino ........................................................................................................... 18

 iii

2.2.3 – Sistema Operacional .................................................................................................. 20

2.2.3.1 - Raspbian .................................................................................................................. 21

2.2.4 – Sistemas de Supervisão ............................................................................................. 21

2.2.4.1 – Sistemas SCADA ................................................................................................... 22

2.2.4.1.1 – Mango Automation .............................................................................................. 22

2.2.5 – Protocolo de Comunicação ........................................................................................ 25

2.2.5.1 – Protocolo Modbus ................................................................................................... 26

3- DESENVOLVIMENTO DO PROJETO ........................................................................... 27

3.1 – Instalação dos Softwares....................................................................................................... 27

3.1.1 – Instalação do Sistema Operacional ............................................................................ 27

3.1.2 – Instalação do Mango Automation .............................................................................. 29

3.2 – Testes dos Componentes ...................................................................................................... 29

3.2.1 – Teste dos LEDs .......................................................................................................... 29

3.2.2 – Teste do Sensor de Temperatura ............................................................................... 31

3.2.3 – Teste do Sensor de Luminosidade ............................................................................. 33

3.2.4 – Teste do Sensor de Presença...................................................................................... 35

3.3 – Implementação do Projeto .................................................................................................... 37

3.3.1 – Biblioteca Modbus ..................................................................................................... 38

3.3.2 – Configuração do Mango Automation ........................................................................ 39

3.3.3 – Criação da Interface Gráfica ...................................................................................... 40

3.3.4 – Montagem dos Componentes .................................................................................... 40

3.3.5 – Custos do Projeto ....................................................................................................... 41

4 – RESULTADOS E CONCLUSÕES.......................................................................................43

4.1 – Sugestões Para Trabalhos Futuros ........................................................................................ 44

REFERÊNCIA BIBLIOGRÁFICA............................................................................................45

ANEXO A......................................................................................................................................48
 iv

ANEXO B......................................................................................................................................50

ANEXO C......................................................................................................................................54

ANEXO D......................................................................................................................................60

ANEXO E......................................................................................................................................69
 5

1 INTRODUÇÃO

1.1 Histórico

O termo automação surgiu na década de 1960, na indústria de equipamentos. Atualmente

este termo designa qualquer sistema ou dispositivo, apoiado em computador, que substitua o
trabalho humano com intuito de obter menores custos, maior precisão, produtividade, segurança e
controle (MORAES; CASTRUCCI, 2006).
O sucesso na indústria fez com que outros setores da sociedade se beneficiassem das
vantagens da automação, surgindo assim os primeiros sistemas de automação para o comércio.
O rápido avanço da informática impulsionou a evolução deste ramo que vem apresentando cada
vez mais aspectos de grande sofisticação através de softwares de supervisão e gerenciamento.
Hoje a automação passou a ser utilizada em residências com o intuito de promover
principalmente o conforto do usuário (TEZA, 2002).
A automação residencial não é apenas tecnologia propriamente dita, ela possui relação
direta com a qualidade de vida dos usuários, pois busca promover, através da implementação da
tecnologia, maior bem-estar, segurança e economia. Atualmente no mercado, são oferecidos
sistemas com os mais variados tipos de recursos, cabendo ao usuário apenas escolher aquele que
atende melhor às suas necessidades (SENA, 2005).

1.2 Contextualização

A automação residencial, também conhecida como domótica, é efetivamente a aplicação

das técnicas e ferramentas de automação comercial em um cenário doméstico. O aumento da
procura pela domótica impulsionou a sua evolução. Máquinas mais velozes possibilitam o acesso
a múltiplos dispositivos quase que instantaneamente, novos equipamentos e dispositivos são
desenvolvidos continuamente por empresas nacionais e estrangeiras com vistas a atender este
mercado em expansão. No entanto, apesar de todos esses avanços, a domótica ainda é vista por
muitos como um “artigo de luxo” para as residências. Neste contexto, o custo, ainda elevado, é o
principal fator que dificulta a disseminação destes sistemas (MAINARDI, 2005).
 6

Uma matéria publicada no site da revista Exame, em abril de 2011, corrobora essa
afirmação. Com o título de: “Serviço automatiza casa por R$ 8 mil”, a matéria mostra que, por
esse valor, é possível adquirir um pacote básico, capaz de automatizar iluminação, ar-
condicionado, cortinas e eletrônicos em geral.
Esse custo não é elevado apenas no Brasil, ou em países menos desenvolvidos, segundo
dados disponibilizados pela FIXR (2013), site norte americano que conecta empresas com
consumidores que procuram os seus serviços, o custo para uma automatização residencial pode
variar, de 5 a 15 mil dólares, em média (ALHO; SEPULVEDA, 2013).
Além disso, a falta de padronização e uniformização de protocolos de comunicação para
os sistemas de automação residencial é, frequentemente, um problema para os técnicos
envolvidos na concepção e projeto dessas instalações, especialmente quando o sistema será
instalado num edifício ou residência cuja a infraestrutura de dutos não é adequada para suportar
esse nível de automação (MAINARDI, 2005).
Neste sentido, diversas empresas buscam minimizar esse impacto sobre seus produtos
através do uso de tecnologias de código aberto, cujas licenças são distribuídas de forma gratuita.

1.3 Justificativa

A elaboração deste projeto é justificada pela percepção de um novo nicho do mercado de

automação residencial. Os sistemas atuais demandam um alto investimento, portanto deseja–se
desenvolver um sistema de automação residencial através da plataforma Arduino, do computador
Raspberry PI 2, e do supervisório Mango Automation, todos de baixo custo e open source,
reduzindo assim os custos para desenvolvimento e implementação do projeto.
Outro ponto importante a se destacar é o conhecimento que se pode agregar sobre a
plataforma de prototipagem eletrônica Arduino, frequentemente utilizada em inúmeros projetos,
das mais variadas formas, e já bastante consolidada.

1.4 Objetivo

O objetivo deste trabalho é apresentar a implementação do protótipo de um sistema capaz

de automatizar e supervisionar algumas tarefas e ações domésticas básicas de forma simples,
 7

eficiente e com um gasto final significativamente menor do que o atualmente praticado no

mercado. Para que este objetivo possa ser alcançado, o desenvolvimento, da parte física e da
parte lógica do sistema, será realizado através de equipamentos de menor custo e linguagens de
open source.

1.5 Objetivo Específico

Neste projeto será utilizado o computador de baixo custo Raspberry PI 2, fazendo uso do
sistema operacional de código aberto Raspbian. Neste sistema operacional será instalado o
supervisório open source Mango Automation, que irá se comunicar com a plataforma de
prototipagem Arduino. O projeto será implementado numa maquete de uma casa, onde alguns
LED’s simularão lâmpadas, um sensor de presença acionará um buzzer ao ser atuado, um sensor
de temperatura irá indicar a temperatura do ambiente através do supervisório e um sensor de
luminosidade externo irá acender um LED ao ser atuado.
 8

2 REVISÃO BIBLIOGRÁFICA

Neste capítulo estão dispostos os principais temas envolvidos no desenvolvimento do

projeto. Serão apresentados os conceitos dos temas relevantes ao desenvolvimento deste trabalho
para que haja um melhor entendimento do projeto desenvolvido. Primeiramente serão
apresentadas as características e definições dos componentes necessários à elaboração deste
projeto. Posteriormente será apresentado como estes componentes foram integrados.

2.1 Hardware

O termo hardware, quando relacionado à tecnologia, refere-se aos componentes físicos

que integram um sistema computadorizado, tais como, teclado, monitor, placas e circuitos.
Quatro operações básicas são executadas para realizar uma tarefa computacional, são elas: inserir
dados no sistema, processamento dos dados, armazenamento das informações, e retirada das
informações processadas, que serão entregues ao usuário (ANDREWS, 2009).

2.1.1 Harware Livre

O termo hardware livre é utilizado para descrever placas e circuitos eletrônicos que,
assim como o software livre, podem ser estudados, modificados e redistribuídos livremente,
desde que dentro dos parâmetros previstos em lei (MAKE, 2007).
Corroborando esta ideia, Pomerantz (2000) afirma que, um hardware pode ser
considerado livre caso possua uma licença que garanta: i) a permissão para a livre redistribuição,
tanto do seu código fonte quanto de outros hardwares baseados neste primeiro, e ii) o direito de
criar obras derivadas baseadas no código fonte deste hardware e distribuí-las sob a mesma
licença.
Com intuito de desenvolver um sistema eficiente e de baixo custo, optou – se pela
utilização de hardwares livres que possuem histórico de sucesso em projetos similares.
 9

2.1.2 Microcontrolador

De acordo com SCHUNK e LUPPI (2001), “o microcontrolador é um componente

popularmente conhecido como computador de um só chip”.
TOOLEY (2007) confirma esta definição e acrescenta que o microcontrolador é
“projetado especificamente para as aplicações de controle, em vez de aplicações gerais. São
usados, muitas vezes, para satisfazer um determinado requisito de controle”.
Os microcontroladores possuem processador, memória e periféricos de entrada e saída
(portas I/O). Podem ser programados para realizar funções específicas de acordo com a aplicação
e utilização do equipamento onde serão instalados.
Existem muitos modelos e aplicações para os microcontroladores. Eles podem ser
encontrados em equipamentos eletrônicos do nosso cotidiano como: aparelhos de som,
televisores, geladeiras, automóveis, controles de acesso, entre outros.
Diversos fabricantes de microcontroladores podem ser citados, tais como: Microchip,
Atmel, Hitachi, Hewlett Packard (HP), Hyundai, Motorola, National, Philips e Panasonic.
Dentre os fabricantes citados anteriormente, optou-se pelo microcontrolador
ATmega328P, fabricado pela Atmel, para ser utilizado no projeto por atender aos
requisitos desejados para o funcionamento do dispositivo

2.1.2.1 Microcontrolador ATMega 328P

O microcontrolador ATmega328P pertence à família de microcontroladores AVR de

8 bits, com arquitetura RISC (Computador com um Conjunto Reduzido de Instruções),
fabricados pela Atmel.
 10

Figura 1: Microcontrolador ATMega 328P

Fonte: Atmel

Alguns dados técnicos do microcontrolador ATmega328P obtidos do datasheet do

fabricante são apresentados abaixo (ATMEL, 2013).

 Tensão de operação - 1,8 a 5,5 VDC

 Portas de entradas e saídas - 23 pinos
 Memória Flash - 32 KB
 Memória SRAM - 2 KB
 Memória EEPROM - 1 KB
 Velocidade de Clock - 0 a 20 MHz

2.1.3 Plataforma de Prototipagem

Um protótipo é um modelo concretizado a partir de uma ideia ou conceito onde são

estabelecidas as primeiras funcionalidades do projeto. O protótipo é modificado de acordo com
os testes realizados e a partir dele vão sendo incorporadas novas funções ou características
(GOMES, 2012).
No processo de fabricação de um dispositivo eletrônico, esta é uma das etapas mais
importantes, pois determinará o sucesso ou fracasso do projeto uma vez que investimentos serão
aplicados na fabricação das placas, gabinetes e montagem. Um erro nesta etapa pode prejudicar
todo o projeto.
 11

Os protótipos são validados e testados em plataformas de prototipagem. Para que placas

eletrônicas não necessitem ser alteradas frequentemente, gerando gastos desnecessários, são
utilizadas matrizes de contatos e kits de desenvolvimento nesta etapa do projeto.

2.1.3.1 Arduino

O Arduino é capaz de perceber o ambiente a sua volta e interagir com o mesmo, através
do uso de sensores, controle de luzes, motores, e outros mecanismos. Sua programação é feita
utilizando-se a linguagem C, e o código é embutido no microcontrolador com o auxílio de uma
IDE (ARDUINO, 2013).
Os projetos desenvolvidos com o Arduino podem ser independentes, isto é, terem o seu
funcionamento autônomo, ou eles também podem se comunicar com um software que esteja em
execução em um computador, o qual recebe o nome de servidor (ARDUINO, 2013).
Outro fato interessante acerca do Arduino é que suas placas podem ser construídas em
casa, já que todos os mapas de seus circuitos encontram-se disponíveis gratuitamente para
download. Assim, qualquer um que deseje se aventurar na construção de seu próprio Arduino,
basta ter em mãos os componentes necessários e conhecer um pouco de eletrônica para começar
(ARDUINO, 2013).

2.1.3.1.1 Arduino Uno

A plataforma Arduino possui diferentes versões, sendo que a versão utilizada no protótipo
é denominada Arduino UNO.
O Arduino Uno foi desenvolvido e baseado no microcontrolador ATmega328P, ele possui
14 portas de entrada e saída, das quais 6 podem ser utilizadas como saída PWM, 6 entradas
analógicas, um pequeno ressoador cerâmico de 16 MHz, uma conexão USB, um conector de
alimentação, uma conexão ICSP, e um botão de reset. (ARDUINO, 2013).
O Arduino Uno difere de todas as placas antecessoras por não utilizar o chip FTDI para
conversão do sinal serial. Utiliza no seu lugar um Atmega8U2 programado como conversor de
USB para serial (ARDUINO, 2013).
 12

A plataforma Arduino UNO foi escolhida para o projeto devido a sua facilidade de
integração com os demais periféricos, ao número de entradas e saídas correspondentes a
necessidade e a possibilidade de integração com um sistema de supervisão e controle.

Figura 2: Arduino Uno

Fonte: Autores

2.1.4 Raspberry PI 2

O Raspberry PI é um computador de pequeno porte, do tamanho de um cartão de crédito,

com dimensões de 85.60mm x 21mm que pesa 45g. Ele foi anunciado em 2011, idealizado pelo
inglês Pete Lomas para ser o computador mais barato do mercado, com preço de 25 dólares
(Modelo A) e 35 dólares (Modelo B). O aparelho foi lançado em 29 de fevereiro de 2012 com
finalidades educativas. O computador de código aberto foi criado para estimular o ensino de
programação e tecnologia (RASPBERRY, 2016).
Neste projeto será utilizado o Raspberry PI 2 que possui 1GB de memória RAM,
processador ARM quad-core de 900 MHz, 4 portas USB, saída para vídeo composto, conector
HDMI, saída de áudio e conectores para câmera e display, além do conector de 40 pinos GPIO
que permite que ligue sensores, displays e outros dispositivos. O Raspberry PI 2 não possui disco
rígido (HD), porém permite a utilização de um HD externo conectado a uma porta USB, existe
também a opção de utilizar um cartão Micro SD, cujo slot está localizado na parte de trás da
placa.
 13

Figura 3: Raspberry PI 2

Fonte: Autores

2.1.5 Sensores

Sensores são dispositivos sensíveis a alguma forma de energia do ambiente, que pode ser
luminosa, térmica, cinética, entre outras, relacionando informações sobre uma grandeza física que
precisa ser medida, como: temperatura, pressão, velocidade, corrente, aceleração, posição, entre
outros.
Um sensor nem sempre possui as características elétricas necessárias para ser utilizado em
um sistema de controle. Normalmente o sinal de saída deve ser manipulado antes da sua leitura
no sistema de controle. Isso geralmente é realizado com um circuito de interface para produção
de um sinal que possa ser lido (WENDLING, 2010).

2.1.5.1 Sensor de Temperatura

Os sensores de temperatura e umidade da família DHTxx são compostos por um sensor

capacitivo para medir a umidade e por um termistor, que são dispositivos elétricos que têm sua
resistência elétrica alterada termicamente. Ambos os sensores são calibrados nos laboratórios
durante sua fabricação. O sensor DHT11 foi escolhido por ser aplicado em diversos projetos
similares e por possuir bibliotecas já programadas para o Arduino (OPIRON, 2016).
 14

Figura 4: Sensor de Temperatura

Fonte: Autores

2.1.5.2 Sensor de Luminosidade

Foi utilizado um sensor do tipo LDR (Light Dependent Resistor), que em português
significa resistência dependente de luz. Assim como seu próprio nome sugere, é uma resistência
capaz de variar de acordo com a quantidade de luz que lhe é incidida, possibilitando, com a
programação adequada, o acendimento de luzes de maneira autônoma, quando o ambiente estiver
mais escuro (MARINHO 2012).

Figura 5: Sensor de Luminosidade

Fonte: Autores
 15

2.1.5.3 Sensor de Presença

O sensor PIR é um sensor infravermelho passivo, sendo um importante elemento na

detecção de invasão e intrusões em um ambiente, pois não se trata de um sensor de movimento,
mas sim, um sensor de variação de temperatura.
Assim como outros sensores infravermelhos, o sensor PIR é calibrado para a temperatura
do corpo humano. A denominação de infravermelho passivo deve-se ao fato do sensor apenas
captar variações de irradiação de luz infravermelha, ou seja, variações de temperatura. Todos os
objetos emitem certa quantia de luz infravermelha, e uma mudança repentina de quantia de luz
infravermelha num ambiente, como por exemplo, a entrada de uma pessoa no ambiente, causará
detecção por parte do sensor. Devido a estas características, o sensor do tipo PIR foi o escolhido
para o projeto.

Figura 6: Sensor de Presença

Fonte: Autor

2.1.6 LED

O LED é um componente eletrônico semicondutor, ou seja, um diodo emissor de luz (L.E.

D = Light Emitter Diode), sendo a mesma tecnologia utilizada nos chips dos computadores, que
tem a propriedade de transformar energia elétrica em luz. Tal transformação é diferente da
encontrada nas lâmpadas convencionais que utilizam filamentos metálicos, radiação ultravioleta e
descarga de gases, dentre outras. Nos LEDs, a transformação de energia elétrica em luz é feita na
matéria, sendo, por isso, chamada de estado sólido (Solid State) (IAR, 2016).
 16

O LED é um componente do tipo bipolar, ou seja, tem um terminal chamado anodo e

outro, chamado catodo. Dependendo de como for polarizado, permite ou não a passagem de
corrente elétrica e, consequentemente, a geração ou não de luz. O componente mais importante
de um LED é o chip semicondutor de dimensões reduzidas responsável pela geração de luz.

Figura 7: LED

Fonte: Autores

2.1.7 Buzzer

Buzzer é um dispositivo de áudio que pode ser mecânico, eletrônico ou piezo elétrico.
Consiste num pequeno alto-falante capaz de emitir sons em diversas frequências. O buzzer é
normalmente utilizado em projetos que necessitam de avisos sonoros, relógios com alarme, e até
para reproduzir músicas.
Ao ser alimentado com uma fonte de sinal, o buzzer vibra da mesma frequência recebida,
funcionando como uma sirene ou alto-falante.
Existem várias versões e tamanhos. Todos os dispositivos sonoros de alarmes (como os de
automóvel) usam um buzzer para o som. Sua vantagem em relação a alto-falantes comuns é que
consome pouca energia em relação à potência sonora, sendo facilmente alimentado com pequenas
baterias.
 17

Figura 8: Buzzer

Fonte: Autores

2.2 Software

Softwares, ou programas, são os responsáveis por toda e qualquer ação que um

computador venha a executar. Ele constitui-se de uma sequência de instruções específicas que
dizem ao computador como ele deve manipular redirecionar e alterar dados de maneira lógica. O
termo software pode ser utilizado para referir-se tanto ao código-fonte, escrito em alguma
linguagem de programação específica, ou para o arquivo já compilado, ou seja, em sua forma
executável (UFPA, 2010).

2.2.1 Software Livre

Software livre é aquele cuja utilização, reprodução, modificação e distribuição é permitida

a qualquer pessoa, desde que dentro dos trâmites legais, podendo ocorrer de forma gratuita ou
paga. Sendo esta segunda opção, aplicada, por exemplo, a casos onde exista a necessidade de
alguma modificação feita sobre encomenda por parte de seu utilizador. Assim o pagamento
ocorre, na verdade, pelo serviço prestado e não pelo software em si (FSF, 2002).

2.2.2 IDE

Integrated Development Environment (IDE) é um ambiente de programação. Em geral,

um IDE é uma interface de usuário projetada graficamente para ajudar um desenvolvedor na
 18

construção de aplicações de software, com um ambiente integrado combinado com todas as

ferramentas necessárias à mão.
As principais características de uma IDE são:
 Editor de códigos
 Compilador
 Linker - liga (linka) os vários "pedaços" de código-fonte, compilados em linguagem de
máquina, em um programa executável que pode ser executado em um computador ou outro
dispositivo computacional.
 Depurador - um programa de computador usado para testar outros programas e fazer sua
depuração.
 Interface gráfica de usuário (GUI) - é uma interface através da qual um usuário interage
com dispositivos eletrônicos, como computadores, dispositivos portáteis e outros aparelhos.
 Modelagem - criação do modelo de classes, objetos, interfaces, associações e interações
dos artefatos envolvidos no software com o objetivo de solucionar as necessidades-alvo do
software final.
 Controle de versão e navegação na estrutura de dados, ajudando um desenvolvedor a
executar rapidamente as ações sem mudar para outras aplicações, assim ajuda a maximizar a
produtividade e reduzir o tempo.
Um IDE suporta linguagens únicas ou múltiplas, os mais modernos são usados
principalmente no contexto da programação visual, onde os aplicativos são criados rapidamente,
movendo blocos de construção de programação ou gerando código de fluxograma e diagramas de
estrutura, que são compilados ou interpretados (ELETRONITE, 2016).

2.2.2.1 IDE Arduino

O Arduino Software Integrated Development Environment (Ambiente de

Desenvolvimento Integrado de Software) é uma aplicação open-source, multiplataforma, escrita
em Java e derivada dos projetos Processing e Wiring. O IDE Arduino é esquematizado para
introduzir na programação usuários não familiarizados com o desenvolvimento de software.
A ferramenta possui um editor de código com recursos de realce de sintaxe, parênteses
correspondentes e endentação automática, sendo capaz de compilar e carregar os programas para
 19

a placa Arduino Uno em poucos cliques. Com isso não há necessidade de editar arquivos fora do
programa ou rodar programas em ambientes de linha de comando. (ARDUINO, 2016).
A ferramenta possui uma biblioteca chamada Wiring aceitando que a programação seja
feita em linguagem C/C++. Isso permite criar com facilidade muitas operações de entrada e saída,
definindo apenas duas funções no pedido para o programa funcional.
 setup () - Inserido no inicio, sendo usada para a inicialização da configuração.
 loop () - Chamada para repetir o bloco de comandos com a instrução principal do
programa ou até que seja desligada.
A principal finalidade do Arduino IDE é facilitar a programação voltada para
prototipagem, implementação ou emulação do controle de sistemas interativos, a nível doméstico,
comercial ou móvel, da mesma forma que um Controlador Lógico Programável (CLP) controla
sistemas de funcionamento industriais. Sendo possível o envio e recebimento de basicamente
qualquer sistema eletrônico. O software pode ser obtido gratuitamente no portal oficial do
Arduino. Existem versões disponíveis para Windows, MAC, e Linux. No portal também é possível
ter acesso ao código de programação do IDE do Arduino, se o usuário assim desejar.
No software deve-se definir o modelo de plataforma Arduino a ser utilizado, bem como a
porta de comunicação. Os menus disponíveis no software, assim como a descrição dos mesmos,
podem ser vistas em detalhes no manual do fabricante (ARDUINO, 2013).
O fabricante também disponibiliza ao usuário a descrição e a explicação de como utilizar
as funções e instruções necessárias para desenvolver o código na linguagem utilizada pelo IDE
do Arduino (ARDUINO, 2013).
 20

Figura 9: IDE Arduino

Fonte: Autores

2.2.3 Sistema Operacional

Um sistema operacional é um programa ou conjunto de programas que faz o

gerenciamento do computador. Sua principal função é controlar o funcionamento do computador,
gerenciando a utilização e o compartilhamento de recursos tais como processador, memória e
dispositivos de entrada/saída. São exemplos de sistemas operacionais os antigos D.O.S. (Disk
Operation System) e o Unix, e os atuais Windows XP, Windows Vista, Windows Seven, Windows
8, Windows 10, Solaris, Mac OS X, Linux e todas suas derivações, FreeBSD, Symbian, Android,
iOS entre outros. Sendo alguns sistemas operacionais livres e distribuídos com o código-fonte
aberto, outros são sistemas proprietários. Também temos aqueles que foram desenvolvidos
exclusivamente para celulares e smartphones, como o Android. Se não existisse o sistema
operacional, para trabalhar com o computador, seria necessário um profundo conhecimento do
hardware. O sistema operacional serve como interface entre o usuário e o hardware, as suas
funções são executadas por demanda, ou seja, sempre que necessário e não de forma linear, como
um programa desenvolvido em Pascal ou C. As funções são executadas sempre que algum
 21

evento ocorrer, como exemplo, a solicitação de desligar o computador por parte do usuário
(FACOL, 2016).

2.2.3.1 Raspbian

Raspbian é um sistema operacional livre baseado em Debian otimizado para o hardware

da Raspberry PI, que conta com mais de 35 mil pacotes. A construção inicial destes pacotes
otimizados do Raspbian foi concluída em junho de 2012. No entanto, o Raspbian encontra-se em
desenvolvimento ativo, com, ênfase em melhorar a estabilidade e o desempenho de tantos pacotes
quanto possível.
Raspbian é a distribuição recomendada para a maioria dos usuários da Raspberry PI. A
exceção é para os usuários que são dependentes de de software que ainda não está presente ou
funcional em Raspbian.
O sistema operacional Raspbian foi o escolhido para este projeto, pois foi o que
apresentou mais robustez e adequação as necessidades de desenvolvimento do sistema proposto,
devido ao fato de ter sido projetado e otimizado para o Raspberry PI.

2.2.4 Sistemas de Supervisão

“Um sistema supervisório permite que sejam monitoradas e rastreadas informações de um

processo produtivo ou instalação física. Tais informações são coletadas através de um
equipamento de aquisição de dados e, em seguida, manipuladas, analisadas, armazenadas e,
posteriormente, apresentadas ao usuário. Estes sistemas também são conhecidos como SCADA
(Supervisory Control and Data Aquisition)” (PINHEIRO, 2006).
Segundo Matt, um sistema supervisório “destina-se a capturar e armazenar em um banco
de dados, informações sobre um processo de produção” (MATT, 2014). Com os dados
capturados pelo sistema supervisório é possível monitorar alarmes, realizar operações remotas,
gerar relatórios e gráficos e aperfeiçoar, por exemplo, uma planta industrial, aumentando a sua
eficiência e produção.
 22

2.2.4.1 Sistemas Scada

A aquisição de dados em um sistema de automação transforma fenômenos físicos do

mundo real em sinais elétricos que são medidos e convertidos em sinas digitais para que possam
ser processados, analisados e manipulados por computadores. Nessa fase, são utilizados
computadores com interface gráfica apurada.
Os sistemas de aquisição e controle de dados (SCADAs) são de importância estratégica,
já que são adotados na maioria das indústrias que compõem a infraestrutura de um país. As
aplicações da tecnologia SCADA alcançam praticamente todo o espectro do setor produtivo. Para
exemplificar, esses sistemas são utilizados na indústria química, petroquímica e de cimento,
indústria alimentícia, na produção e na distribuição de energia elétrica, no controle de água, no
controle de oleodutos, gasodutos, centrais nucleares, edifícios inteligentes e tráfego.
Na maioria de suas aplicações, os sistemas de aquisições de dados são designados não só
para adquirir dados, mas também para também atuar sobre esses.
Para o desenvolvimento deste protótipo, optou-se pela utilização de um software de
supervisão SCADA, visto que este tipo de sistema atende as necessidades do projeto, possui
softwares livres e conta com vasta referência bibliografia disponível para consulta.

2.2.4.1.1 Mango Automation

Este sistema SCADA é um dos sistemas open source mais conhecidos do mundo. É de
origem canadense, possui várias características importantes, é um software “M2M” (Máquina
para Máquina), possui diversos protocolos de comunicação, geração de gráficos de tendências,
históricos, alarmes, construtor de telas é todo baseado na WEB, pode ser acessado por um
browser e pode visualizar e controlar equipamentos dos mais variados processos, seja local ou à
distância.
O Mango Automation é executado a partir do Apache TomCat, que consiste num servidor
Web open source utilizado em mais de 70% dos servidores do mundo.
Optou-se pela utilização do Mango Automation, pois foi o sistema supervisão que
apresentou uma maior facilidade de instalação no Raspbian. O ScadaBR é basicamente uma
 23

versão do Mango Automation traduzida para o português, no entanto, apresentou diversos

problemas durante as tentativas de instalação e configuração no Raspbian.

 FUNCIONAMENTO

O Mango Automation ao ser instalado num computador funcionará como um servidor de

aplicação Web em Java, utilizando o Apache TomCat, possibilitando assim o acesso através de
qualquer navegador de internet, permitindo que o usuário consiga visualizar e configurar as
funcionalidades do sistema. O acesso ao Mango Automation poderá ser feito através do mesmo
computador onde se encontra instalado ou através do browser de um smartphone ou tablet que
esteja conectado a mesma intranet. Existe também a possibilidade de ser acessado pela internet
mediante algumas configurações adicionais que não serão abordadas neste projeto.

 SERVIDOR WEB

O Apache TomCat é um servidor Web livre para aplicações Java desenvolvido pela
Apache Software Foundation, fazendo parte do projeto Apache Jakarta. É considerado um
servidor muito robusto, sendo utilizado inclusive em ambientes de produção.
A utilização da linguagem Java facilitou o desenvolvimento de aplicações para Web
baseados na internet, onde as comunicações são baseadas em pacotes e no relacionamento entre
cliente e servidor. Desta forma, o cliente (navegador Web) solicita uma ação que é enviada ao
servidor (servidor Web), que executa a ação e responde com uma página da Web em HTML
correspondente para o cliente – navegador (RAYSARO, 2009).
 24

Figura 10: TomCat

Fonte: Autores

 DATA SOURCE

São as fontes de dados recebidas pelo sistema, ou seja, a configuração dos componentes
que serão fisicamente controlados, constituindo uma parte imprescindível para o funcionamento
do sistema. É constituído por um barramento de comunicação com os mais variados tipos de
protocolos como: Modbus, Http, TCP-IP, ASCII, SQL entre outros.

 DATA POINT

São os pontos de medição e controle ou tags – são todas as variáveis numéricas e

alfanuméricas envolvidas num aplicativo. Funcionam como uma coleção de valores históricos
que contém atributos como: nome, de que forma os dados são registrados, se totalmente ou
quando mudam de valor, por quanto tempo manter esses dados, em que condições os dados
devem ser formatados para exibição e de que maneira traçar um determinado gráfico para
exibição dos valores medidos. O sistema suporta cinco tipos de dados que são: Binários – 0 e 1,
Estados Múltiplos – ligado/desligado/desativado, Numéricos ou Analógicos – temperatura,
pressão, vazão, umidade etc. e Alfanuméricos – sequência de caracteres e imagens. Com relação
 25

às medições, os pontos podem ser representados, por exemplo, como uma leitura de pressão,
temperatura, umidade vazão, etc. Em relação ao controle podem indicar uma condição de ligado e
desligado num determinado equipamento. Sendo assim os data points armazenam todos os
valores de dados que são coletados por um data source (RAYSARO, 2009).

 PARTE GRÁFICA

O Mango Automation possui uma quantidade considerável de recursos disponíveis para

elaboração de representações gráficas. Existe a opção de criar painéis de controle, onde os data
points podem ser monitorados em tempo real e também são disponibilizados elementos gráficos,
como botões, ícones, gráficos, componentes HTML e displays representando o processo real que
está sendo monitorado ou controlado, isto é, representa a interface com o usuário para operação
do sistema.

2.2.5 Protocolo de Comunicação

Um protocolo de comunicação é um conjunto de regras e convenções precisamente

definidas que permitem a comunicação através de uma rede. Esse conjunto de regras estabelece
como um componente conecta-se ao outro, como se identifica, quando pode enviar ou receber
informações e quanto tempo pode esperar para que cada evento ocorra, bem como a forma de se
desfazer a conexão.
Além de estabelecer comportamentos para as situações normais de funcionamento de uma
rede, um protocolo deve também possuir regras para as situações anormais, especificando como
normalizar tais situações.
Dois ou mais computadores que desejarem trocar informações entre si, deverão seguir os
mesmos protocolos. Os protocolos devem ser compatíveis nos meios digitais de forma que as
transferências de informações sejam corretas.
Basicamente os protocolos são a parte do sistema operacional da rede encarregada de ditar as
normas e regras para a comunicação entre os dispositivos em questão (MIRANDA, 2008).
 26

2.2.5.1 Protocolo Modbus

O protocolo serial Modbus é um protocolo mestre e escravo. Um sistema operando como

mestre-escravo possui um nó mestre, que emite comandos explícitos para um dos nós escravos e
processa a sua resposta. Tipicamente os escravos não irão transmitir dados sem uma requisição
do nó mestre e não se comunicam com outros escravos.
Modbus em linhas seriais podem usar diferentes interfaces físicas (RS485, RS232, etc.). A
interface de dois fios é a mais comum. No entanto, a interface RS485 também pode ser
implementada. A interface serial RS232 só poderá ser utilizada quando uma comunicação ponto
a ponto de curta distância for requerida.
Algumas características do protocolo Modbus são fixas, como o formato da mensagem,
funções disponíveis e tratamento de erros de comunicação. Outras características são
selecionáveis, como o meio de transmissão, velocidade, timeout, bits de parada e paridade, e o
modo de transmissão (RTU ou ASCII).
Denardin (2010) descreve que estes modos de transmissão definem o conteúdo de bits dos
campos das mensagens transmitidas serialmente no barramento. Eles determinam como a
informação é empacotada nos campos das mensagens e, posteriormente, como são decodificadas.
Denardin (2010) ainda diz que o modo de transmissão (e o padrão da porta serial) deve
ser o mesmo em todos os dispositivos conectados a linha serial.
 27

3 DESENVOLVIMENTO DO PROJETO

Neste capitulo serão descritas as etapas do projeto, desde a aquisição dos componentes, a
linguagem de programação utilizada e IDE, até a criação da parte gráfica no supervisório.
Através de conhecimentos básicos em linguagem de programação C, noções de eletrônica básica,
elétrica e sistemas de supervisão, foi possível a criação de um protótipo de controle de automação
residencial de baixo custo.
Para o desenvolvimento do projeto, foram adquiridos os seguintes equipamentos: Arduino
Uno, Raspberry PI 2, sensor de presença PIR, sensor de luminosidade LDR, buzzer, LEDs, fonte
de alimentação, cartão de memória, adaptador USB WI-FI, jumpers e resistores. Uma maquete de
uma casa com quatro cômodos servirá de exemplo de implementação do sistema proposto.
Após a conclusão do projeto, o protótipo permitirá ao usuário realizar o controle e
supervisão de algumas tarefas e estados de uma residência através do supervisório Mango
Automation, que poderá ser acessado através de um browser conectado à intranet.

3.1 Instalação dos Softwares

Neste tópico serão abordados os procedimentos utilizados para instalação dos softwares
utilizados neste projeto.

3.1.1 Instalação do Sistema Operacional

O sistema operacional utilizado no Raspberry PI 2 foi o Raspbian, sua instalação foi o

primeiro desafio encontrado no desenvolvimento deste projeto. Primeiramente, foram conectados
alguns periféricos para facilitar a instalação e configuração da placa. Foram utilizados os
seguintes componentes:

 Raspberry PI 2
 Teclado USB
 Mouse USB
 28

 Fonte de alimentação de 5V / 2A com conexão micro USB. Lembrando que entrada USB
do computador suporta no máximo 500 mA, portanto o Raspberry PI 2 não foi conectado
diretamente nesta porta.
 Monitor de vídeo com entrada HDMI ou DVI
 Cartão Micro SD vazio de pelo menos 8 GB
 Computador com entrada para cartão Micro SD

PREPARANDO O CARTÃO SD

Foi utilizado um computador para realizar a formatação do cartão Micro SD que será
utilizado como disco rígido do Raspberry PI 2. Em seguida foi acessado o site
<www.raspberry.org> onde foi feito o download do software Noobs, que conduz de forma
facilitada a instalação do sistema operacional Raspbian no Raspberry PI 2. Após o download,
descompactou-se o arquivo e copiou-se todos os arquivos para o cartão Micro SD.

CONECTANDO O RASPBERRY P12

O Raspberry PI 2 foi conectado na entrada HDMI do monitor, também foram conectados

o mouse e o teclado nas portas USB, e o cartão Micro SD no seu slot correspondente, por último,
foi conectada a fonte de alimentação. Após o carregamento dos dados do cartão Micro SD foi
apresentada uma lista com vários sistemas operacionais, onde se optou pelo Raspbian, pelas
razões já apresentadas.
Após selecionar a versão Raspbian e clicar em install, foi exibida uma mensagem
informando que o sistema operacional selecionado será instalado no cartão Micro SD e todos os
outros arquivos do cartão serão excluídos, clicou-se em yes logo em seguida e aguardou-se o
término da instalação.
Após a instalação ser concluída, foi exibida uma tela de configuração do Raspberry PI 2,
onde se optou pela interface gráfica ao invés de linha de comando. Feito isto, foi finalizada
instalação do sistema operacional Raspbian.
 29

3.1.2 Instalação do Mango Automation

Após a instalação do sistema operacional Raspbian, deu–se continuidade ao projeto

através da instalação do software de supervisão Mango Automation. Como este projeto está se
desenvolvendo em ambiente Linux, foi mais conveniente realizar a instalação via terminal. A
sequência dos procedimentos e comandos executados está descrita no Anexo A.

3.2 Teste dos Componentes

Após um estudo de mercado, onde foram avaliados os custos e os benefícios dos modelos
mais comuns de Arduino, concluiu-se que para o desenvolvimento deste trabalho a melhor opção
seria a aquisição de um kit básico para desenvolvimento, contendo uma grande variedade de
componentes. Dentre eles, foram testados e utilizados os sensores luminosidade, temperatura e
presença, buzzer e os LEDs.
A partir desse kit, teve início a fase de experimentação e de familiarização com um novo
tipo de desenvolvimento, voltado para plataformas de hardwares e microcontroladores. Para tal,
foi necessária uma revisão dos conceitos básicos de eletrônica, elétrica e um aprimoramento dos
conhecimentos de programação em C com ênfase em microcontroladores.
Optou-se por realizar testes individuais de acionamento de cada componente eletrônico,
através de códigos e esquemas de ligações específicos para cada tipo de componente.
Adotou–se a estratégia de testar o acionamento somente no Arduino e posteriormente
implementar a supervisão e o controle no Mango Automation. Neste tópico serão descritos os
testes realizados com os sensores, os LEDs e o buzzer.

3.2.1 Teste dos LEDs

O teste descrito a seguir tem o objetivo de acender um LED através de um botão físico,
ambos componentes estão conectados a uma protoboard e interligados ao Arduino Uno.
Segue o esquema de ligação utilizado:
 30

Figura11: Esquema do LED

Fonte: Autores

Para realizar o acionamento do LED através do Arduino, foi necessária a utilização de um

código a ser compilado e enviado para o hardware através da IDE Arduino.
 31

Figura 12: Código do LED

Fonte: Autores

3.2.2 Teste do Sensor de Temperatura

O sensor DHT11 possui a capacidade de realizar medições de temperatura e umidade,

para este projeto será utilizada somente a medição de temperatura. A seguir será apresentado o
esquema de ligação do sensor bem como o código utilizado para implementação do mesmo.
 32

Figura 13: Código do Sensor de Temperatura

Fonte: Autores
 33

Figura 14: Esquema de Sensor de Temperatura

Fonte: Autores

3.2.3 Teste do Sensor de Luminosidade

O teste deste sensor irá contemplar também o acionamento de um LED, simulando assim
uma situação típica de uma residência onde, na ausência de determinada quantidade de luz, um
sensor aciona uma lâmpada.
Segue o esquema de ligação e o código utilizado:
 34

Figura 15: Esquema do Sensor de Luminosidade

Fonte: Autores
 35

Figura 16: Código do Sensor de Luminosidade

Fonte: Autores

3.2.4 Teste do Sensor de Presença

Assim como o sensor anterior, o sensor de presença PIR também irá acionar um
componente eletrônico ao ser atuado, trata-se de um buzzer (buzina). Sendo assim, obtém-se
outra situação comum ao sistema de automação residencial, onde a presença indesejada de uma
pessoa dispara um alarme.
 36

Figura 17: Código do Sensor de Presença

Fonte: Autores
 37

Figura 18: Esquema do Sensor de Presença

Fonte: Autores

3.3 Implementação do Protótipo

Após todos os componentes eletrônicos do projeto terem sido testados com sucesso,
objetivou – se a comunicação entre o Arduino Uno e o Mango Automation.
 38

O primeiro passo foi estabelecer a comunicação Modbus Serial entre o Arduino e o

Mango Automation. Para isso, utilizou se como base uma biblioteca disponível na internet, onde
foram feitas as modificações necessárias para a adequação a este projeto, posteriormente, foram
feitas as configurações no Mango Automation, onde criou-se o data source e os data points
necessários e foi elaborada a parte gráfica.

3.3.1 Biblioteca Modbus

Essa comunicação foi realizada utilizando-se o protocolo Modbus Serial. Isso foi possível
graças a utilização da biblioteca open-source Modbus-Arduino obtida no endereço
<https://github.com/andresarmento/Modbus-Arduino>.
Primeiramente, efetuou-se o download dos arquivos e os adicionou na pasta de bibliotecas
da IDE do Arduino. Após esse processo, as funções da biblioteca ficaram disponíveis para
utilização.
Para a construção do programa foram adicionados os seguintes includes necessários:

 #include <Modbus.h>
 #include <ModbusSerial.h>
 #include <SoftwareSerial.h>

Nos códigos utilizados na IDE Arduino existe a função setup() que é chamada no início da
programação. É utilizada para inicializar variáveis, definir os modos de entrada ou saída dos
pinos, inicializar bibliotecas etc. Essa função é executada somente uma vez, quando o Arduino é
iniciado ou quando ocorre um reset. Para possibilitar a comunicação com o Mango Automation
foi preciso inserir algumas funções na biblioteca Mudbus-Arduino:

 mb.config( &Serial, 9600, Serial_8N1)

O código acima tem a função de informar a porta de comunicação, a velocidade de
comunicação e o formato dos bytes.

 mb.setSlaveId(1)
 39

O código acima tem a função de informar para o Mango Automation, o número de

identificação do escravo que, neste caso, é o Arduino e há apenas um (1).
Dentro da função setup() foi informado as funções para cada porta utilizada no Arduino,
sendo que para cada tipo de porta há uma função diferente:

 mb.addIsts(Entrada_digital_1)
 mb.addCoil(Saída_digital_1)
 mb.addHreg(Saída_analógica_1)
 mb.addIreg(Entrada_analógica_1)

Após a função setup() foi executada a função loop(), que tem objetivo de repetir-se
continuamente permitindo que o programa funcione dinamicamente, sendo utilizada para
controlar de forma ativa a placa Arduino. Foi necessário adicionar a função da biblioteca
Modbus-Arduino que é responsável por responder as requisições e alterar os registradores se
necessário, funcionando apenas uma vez, no início de cada loop:

 mb.task()

Após essas definições, para enviar e receber dados entre o Arduino e o Mango
Automation, foi preciso utilizar as seguintes funções:

 mb.Ists(Número_da_Porta) – Entrada Digital

 mb.Ireg(Número_da_Porta) – Entrada Analógica
 mb.Coil(Número_da_Porta) – Saída Digital
 mb.Hreg(Número da Porta) – Saída Analógica

3.3.2 Configuração do Mango Automation

Para um melhor desenvolvimento deste trabalho, optou-se por descrever de forma

genérica a criação de um data source e de um data point, funcionalidades essenciais para o
desenvolvimento do projeto, mas que seguem um mesmo procedimento, alterando apenas os
 40

parâmetros de acordo com a necessidade. Os procedimentos para criação de data source e data
point estão descritos no Anexo C.

3.3.3 Criação da Interface Gráfica

Neste tópico será descrito o procedimento para criação da interface gráfica que será
exibida através do supervisório Mango Automation. Será demonstrada a criação de um botão para
acender e apagar um LED, uma indicação do status desse LED e a indicação da temperatura
aferida pelo sensor DHT11. Apesar do projeto possuir mais representações gráficas, a criação e
configuração destes itens citados abrange o procedimento para a criação dos demais, conforme
será explicado no Anexo D.

3.3.4 Montagem dos Componentes

Para demonstração do projeto foi utilizada uma maquete de quatro cômodos: quarto,
banheiro, sala e cozinha. Os componentes eletrônicos e suas respectivas funções estão descritas
abaixo:

 Os LEDs foram distribuídos pela maquete, sendo que cada LED citado possui
acionamento por um botão físico e por um virtual. Foi implementado um botão virtual que
permite que o usuário escolha se deseja realizar os acionamentos dos LED’s de forma virtual ou
através dos botões físicos. Quando o acionamento físico estiver atuado, não será possível
controlar os LEDs pelo supervisório, da mesma forma que, quando o acionamento virtual estiver
atuado, não será possível controlar os LEDs pelos botões físicos. Também foi implementada a
visualização dos status dos LEDs, obtendo assim a informação de ligado/desligado.
 Sensor de Presença – quando atuado, este sensor irá acionar um buzzer, simulando assim
um alarme de presença. O disparo do buzzer pode ser visualizado no supervisório.
 Sensor de Temperatura – A indicação de temperatura foi implementada no supervisório.
 Sensor de Luminosidade – Quando atuado, aciona um LED na parte externa da maquete,
o status desse LED pode ser observado no supervisório.
Segue a foto com a montagem do circuito na maquete:
 41

Figura 19 – Maquete

Fonte: Autores

3.3.5 Custos do Projeto

Para o desenvolvimento do projeto foram adquiridos alguns componentes cujo os custos

estão descritos abaixo:
 42

Figura 20: Custos do Projeto

Custos do Projeto
Cotação do Dólar em 03/06/2016: R$ 3,52

Equipamento Quantidade Preço

Raspberry PI 2 1 R$ 170,00
Kit de desenvolvimento com
1 R$ 160,00
Arduino Uno
Sensor de Presença PIR 1 R$ 20,00

Sensor de Luminosidade LDR 1 R$ 10,00

Sensor de Temperatura DHT11 1 R$ 15,00

Buzzer 1 R$ 3,00

Fonte de Alimentação - 5V - 2ª 1 R$ 40,00

Cartão de Memória Classe 10

1 R$ 68,00
de 32 GB
Total R$ 486,00

Fonte: Autores

O custo total de R$ 486,00 é bastante baixo em relação aos valores praticados no

mercado. Vale ressaltar que o Arduino Uno e o Raspberry PI 2 possuem capacidade para suportar
um número maior de componentes interligados, garantindo assim uma possível expansão do
sistema proposto sem elevação dos custos em relação a estes componentes que são os que
necessitam de um maior desembolso financeiro.
 43

4 RESULTADOS E CONCLUSÕES

Neste trabalho foi realizada a integração entre hardwares e softwares livres com o
objetivo de desenvolver um protótipo de um sistema de automação residencial básico de baixo
custo. Através da utilização da plataforma de prototipagem Arduino Uno, do sistema de
supervisão Mango Automation e do computador Raspberry PI 2, foi possível realizar o controle e
supervisão de simples tarefas residenciais.
Uma das principais dificuldades encontradas foi a busca por um software de supervisão
que pudesse ser instalado no sistema operacional utilizado. O Mango Automation, assim como o
ScadaBr, necessitam de um servidor Web para funcionar, esse servidor é o TomCat, que é escrito
na linguagem de programação Java. No ScadaBr o TomCat é instalado de forma independente e
por isso apresenta mais problemas de compatibilidade com a máquina virtual Java instalada no
sistema operacional. A versão mais nova do ScadaBr foi instalada com a versão mais nova do
Java e não funcionou. Mesmo instalando versões mais antigas do TomCat e do Java o problema
persistiu. Após algumas pesquisas, foi levantado que o Mango Automation não traria esse tipo de
problemas, visto que já possui o TomCat integrado, eliminando assim o problema de
compatibilidade.
Ocorreram problemas também na comunicação entre o Arduino e o Mango Automation
para definir a velocidade correta de comunicação da porta serial. Como os exemplos da biblioteca
sempre utilizavam a velocidade de 38400, demorou-se um pouco até perceber que o problema
não estava no código e sim na incompatibilidade de comunicar o Arduino e o Mango Automation
com essa velocidade. Após algumas pesquisas, testou-se a velocidade de 9600, onde obteve-se
sucesso.
Outra dificuldade foi entender como o Mango Automation diferencia os dados das
variáveis (Coil, Ists, Ireg e Hreg) quando estes são do mesmo tipo. Após pesquisas, constatou-se
que é preciso configurar no código e no campo Offset dos data points um valor para cada variável
do mesmo tipo, iniciando pelo número zero e crescendo sucessivamente.
Superadas essas dificuldades, os testes realizados na maquete ocorreram sem problemas,
todos as implementações previstas funcionaram como o planejado, não ocorrendo problemas na
comunicação entre os softwares e hardwares utilizados, com todos os comandos e status
funcionando conforme o esperado.
 44

Os conhecimentos adquiridos ao longo e todo o curso foram determinantes tanto na

elaboração das ideias que nortearam o projeto, como também na elaboração dele. Os objetivos
traçados no início do projeto foram alcançados, a implementação do protótipo de automação
residencial foi realizada com sucesso, obtendo assim um sistema de automação residencial de
baixo custo, utilizando softwares e hardwares livres.

4.1 Sugestões para Trabalhos Futuros

Projetos futuros podem ser implementados permitindo que o usuário tenha acesso a
interface gráfica do sistema através da internet e não somente pela intranet. Além disso, outras
funções do Mango Automation podem ser mais exploradas como por exemplo, log de eventos e
scripts. Podem ser implementadas diversas outras funcionalidades como por exemplo, controle de
ar-condicionado, cortinas, irrigação de jardim, nível de caixa d’água, dentre outros. Dependendo
da quantidade de funções adicionais, pode ser necessário substituir o Arduino Uno pelo Arduino
Mega, que possui uma maior capacidade de memória e pinos.
 45

REFERÊNCIAS BIBLIOGRÁFICAS

FAUSTO, Emerson. CRUZ, Ariadne. WebHome – Automação Residencial Utilizando

Raspberry PI 2. São Paulo: Revista Ciência e Tecnologia, v. 17, n. 31, Jul/Dez. 2014.

GOMES, José. Automação Industrial com Recurso a Ferramentas “Open Source”. 2014.
135 f. Dissertação (Mestre em Ciências) - Faculdade de Engenharia Universidade do Porto.
Portugal.

TEZA, Vanderlei. Alguns Aspectos sobre a Automação Residencial – Domótica. 2002. 108 f.
Dissertação (Mestre em Ciências) – Universidade Federal de Santa Catarina. Santa Catarina.

SANDOVAL, Paulo. Monitoramento Remoto Aplicado ao Controle da Umidade Ambiental.

2014. 89 f. Dissertação - Faculdade de Tecnologia e Ciências Sociais Aplicadas. Brasília.

FERREIRA, Victor. A Domótica como Instrumento para a Melhoria da Qualidade de Vida

dos Portadores de Deficiência. 2010. 41 f. Dissertação - Instituto Federal de Educação, Ciência
e Tecnologia da Paraíba. João Pessoa.

HENRIQUES, Moises. Alimentador Automático com Supervisório para Animais de

Pequeno Porte. 2015. 56 f. Dissertação – Universidade Federal de Ouro Preto. Ouro Preto.

ALMEIDA, Alexandre. Implementação de um Sistema de Automação Residencial Modular

sem Fio: Módulo Periférico. 2009. 72 f. Dissertação – Universidade de São Paulo. São Carlos.

SILVA, Armando. Alarme com Ativação por Sensor Presencial e Alerta via SMS. 2013. 67 f.
Dissertação – Faculdade de Tecnologia e Ciências Sociais Aplicadas. Brasília.

ALHO, Gabriel. GOMES, Jeferson. SEPULVIDA, Lucas. Automação Residencial de Baixo

Custo com Software e Hardware Livres. 2013. 69 f. Dissertação – Instituto Federal de
Educação, Ciência e Tecnologia Fluminense. Campos dos Goytacazes.

BARROS, André. Implementação de um Servidor Utilizando Linux Embarcado com Acesso

e Gerenciamento através de Smartphones. 2013. 127 f. Dissertação – Universidade de São
Paulo. São Carlos.

LANG, Arthur. DUTRA, Augusto. WAROMBY, Paulo. Desenvolvimento de um Irrigador

Microcontrolador Integrado a um Sistema de Supervisão e Controle. 2013. 78 f. Dissertação
– Universidade Tecnológica Federal do Paraná. Curitiba.

LEMES, João. Monitoramento em redes IPv6 com Zabbix e Rasperry PI. 2013. 64 f.
Dissertação – Universidade Tecnológica Federal do Paraná. Curitiba.
 46

HULLER, Israel. Sistema de Atuação e Supervisão para Segurança de Ambientes Remotos.

2014. 109 f. Dissertação – Universidade Federal de Educação, Ciências e Tecnologia de Santa
Catarina. Florianópolis.

ArduinoBR – Explorando o mundo com Arduino. Disponível em:

<http://www.Arduinobr.com/2014/12/>. Acesso em: 27 de mar. 2016.

ARAÚJO, João. Sistema de Aquisição e Monitorização de Dados para Indústria Alimentar e

Laboratorial. 2012. 104 f. Dissertação – Instituto Politécnico de Viseu. Viseu.

MENDES, Flávio. Automação Residencial Baseada em Software Supervisório. 2007. 57 f.

Dissertação – Universidade Federal de Ouro Preto. Ouro Preto.

SANTOS, Alexandro. Os IDE’s (Ambientes de Desenvolvimento Integrado) como

Ferramentas de Trabalho em Informática. Universidade Federal de Santa Maria.

OLIVEIRA, Jefferson. Linux como Alternativa de Sistema Operacional para Desktops. 2008.
109 f. Dissertação – Universidade do Estado de Minas Gerais. Frutal.

MARCHESAN, Marcelo. Sistema de Monitoramento Residencial Utilizando a Plataforma

Arduino. 2012. 62 f. Dissertação – Universidade Federal de Santa Maria. Santa Maria.

SCHOLL, Marcos. Sistema SCADA Open Source. 2015. 75 f. Dissertação – Universidade

Federal do Rio Grande. Rio Grande.

RAYSARO, Márcio. Sistema Open-Source de Supervisão Controle e Aquisição de Dados.

2019. 99 f. Dissertação - Universidade de Cuiabá. Cuiabá.

QUINDERÉ, Patrick. Casa Inteligente – Um Protópito de Sistema de Automação Residencial

de Baixo Custo. 2009. 69 f. Dissertação – Faculdade Farias Brito. Fortaleza.

MORAES, Cícero. CASTRUCCI, Plínio – Residências Inteligentes. 2006. 360 f. Brasil. LTC.

MAINARDI, E., BANZI, S., BONFIÈ, M. e BEGHELLI, S., A low-cost Home Automation
System based on Power-Line Communication Links, 22nd International Symposium on
Automation and Robotics in Construction. ISARC 2005 - September 11 mar 2016, Itália.

MONTEIRO, Aline. Serviço Automatiza Casa por R$ 8 mil, 2011. Revista Exame.
Disponível em: <http://exame.abril.com.br/tecnologia/noticias/servico-automatizacasa-por-r-8-
mil>. Acesso em: 16 abr. 2016.

ANDREWS, Jean. A+ Guide to Hardware: Managing, Maintaining and

Troubleshooting, 2009.

MAKE, Open source Hardware, what is it? Here's a start, 2007. Disponível em
<http://blog.makezine.com/2007/04/23/open-source-Hardware-what/>. Acesso em:
21 mar. 2016.
 47

POMERANTZ, Gregory M. Business Models for Open Source Hardware Design,

2000. Disponível em: <https://files.nyu.edu/gmp216/public/papers/bmfosh-1.0.html>.
Acesso em: 22 mar. 2016.

SCHUNK, L. M.; LUPPI, A. Microcontroladores AVR: Teoria e Aplicações Práticas. São

Paulo: Érica. 2001.

TOOLEY, M. Circuitos Eletrônicos: Fundamentos e Aplicações. 3. Ed. Rio de Janeiro:

Elsevier, 2007.

GOMES, I. Prototipagem em Papel: Desenvolver e Testar Interfaces Antes de Iniciar a

Programação. 2012. Disponível em: <http://www.ivogomes.com/apresentacoes/prototipagem-
empapel.pdf>. Acesso em: 20 set. 2016.

WENDLING, Marcelo, 2010. Sensores. Universidade Estadual Paulista. Disponível

em: <http://www2.feg.unesp.br/Home/PaginasPessoais/ProfMarceloWendling/4---sensores-
v2.0.pdf>. Acesso em: 25 abr. 2016.

ELETRONICS, O. Opiron. Opiron, 03 mar. 2013. Disponível em:

<www.opiron.com/portfolio/todossobre-los-sensores-dht11-dht22-by-opiron-2>. Acessoem: 18
mai. 2016.

MARINHO, Rui, 2012. Electronic Piece, Arduino + LDR. Disponível em:

<http://electronicpiece.blogspot.com.br/2012/01/boas-hoje-venho-aqui-publicar-maisum.html>.
Acesso em: 04 abr. 2016.

PINHEIRO, J. M. S. Introdução às Redes de Supervisão e Controle. 2006. Disponível em:

<http://www.projetoderedes.com.br/artigos/artigo_redes_de_supe
rvisao_e_controle php>. Acesso em: 18 maio 2016.

PARK, J. & MACKAY, S. Practical Data Aquisiion for Instrumentation and Control
Systems, Newnes Publications, United Kingdom, 2003.

MIRANDA, A. Introdução às redes de computadores. 2008

DENARDIN, Gustavo Weber. Modbus. Disponível em:

<http://pessoal.utfpr.edu.br/gustavo/Modbus_apostila.pdf>. Acesso em: 26 abr
2016.
 48

ANEXO A - INSTALAÇÃO DO MANGO AUTOMATION NO RASPBIAN

A instalação do Mango Automation foi realizada através dos passos descritos a seguir:
1- Foi acessado o terminal como usuário administrador, para isso digitou-se:

 sudo su

2- Foram atualizados todos os repositórios disponíveis e baixadas as listas com os pacotes

disponíveis em cada um. Para isso digitou-se:

 apt-get update

3- Foi verificado se a versão instalada do Java era a JDK 1.8 (versão utilizada pelo Mango
Automation). Para isso, digitou-se:

 java – version

4- Foi observado que a versão do Java instalada não era a 1.8. Desta forma, procedeu – se
com a atualização digitando:

 apt-get install oracle-java8-jdk

5- Após a instalação do Java foi preciso criar uma pasta para instalar o Mango Automation.
Ela foi criada dentro da pasta OPT, para isso digitou-se:

 Mkdir /opt/mango

6- Utilizou-se o browser Epiphany presente no Rasbpian para que fosse possível acessar o
endereço <http://infiniteautomation.com/index.php/download-mango> e efetuar o download do
Mango Automation. Após o download, descompactou-se o arquivo obtido em uma pasta chamada
“mango” e o copiou para o caminho /opt.
 49

7- Foi executado um scripit para inicialização do Mango Automation. Para isso digitou-se:

 ./bin/ma/sh start

8- Foi realizado o teste de funcionalidade do Mango Automation abrindo o navegador e

digitando:

 <http://localhost:8080>

Após a digitação do endereço a seguinte tela foi exibida:

Figura 21: Tela de Login do Mango Automation

Fonte: Autores
 50

ANEXO B – CONFIGURAÇÃO E COMUNICAÇÃO COM O ARDUINO

1- Conectou-se o Arduino ao Raspberry PI 2 através da porta USB.

2- Foi efetuado o login no terminal como usuário administrativo.

3- Foi verificado se o Raspberry PI 2 reconheceu a conexão do Arduino na porta USB. Para

isso, digitou-se no terminal:

 Lsusb

Visualizando a seguinte tela:

Figura 22: Verificando Conexão

Fonte: Autores

4- Foi pesquisado e exibido o nome que o Raspberry PI 2 atribuiu a conexão do Arduino na

porta USB. Para isso, digitou – se:

 dmesg | grep USB*

 51

Figura 23: Nome da Conexão

Fonte: Autores

5- Buscou se a localização do diretório onde estão localizados os arquivos de configuração

da porta USB onde o Arduino foi conectado. Para isso, digitou-se:

 ls –la/dev/ttyUSB*

Foi visualizada a seguinte tela:

Figura 24: Localização do Diretório

Fonte: Autores
 52

6- No Raspbian apenas o usuário root e o grupo dialout tem a permissão para controlar a
porta onde o Arduino está conectado. Sendo assim, foi necessário acrescentar o usuário pi,
que é o usuário padrão do Raspbian e o www-data, que é o usuário do servidor TomCat.
Para isso, digitou – se:

 chown root /dev/ttyUSB (permite a alteração do proprietário e grupo no diretório)

 chgrp dialout /dev/ttyUSB ( configura o diretório para pertencer ao grupo dialout )
 chmod 660 /dev/ttyUSB (configura o diretório para permitir leitura e gravação)

7- Foram adicionados os usuários pi e www-data ao grupo dialout. Para isso, digitou-se.

 adduser pi dialout
 adduser www-data dialout

Foi visualizada a seguinte tela:

Figura 25: Adicionando Usuários

Fonte: Autores

8- Foi verificado se todo o procedimento ocorreu de maneira correta digitando:

 cat /etc/group | grep dialout

Foi visualizada a tela a seguir, indicando que o procedimento obteve o resultado esperado.
 53

Figura 26: Verificando Procedimento

Fonte: Autores

9- Foi instalada a IDE Arduino. Para isso, digitou-se:

 apt-get install Arduino

Figura 27: IDE Instalada

Fonte: Autores
 54

ANEXO C – CONFIGURAÇÃO DO MANGO AUTOMATION

Primeiramente criou-se um data source. Para isso foi preciso acessar o menu Data
Sources na barra de menus. Conforme figura abaixo:

Figura 28: Acessando o Menu

Fonte: Autores

Em seguida, foi selecionado o tipo de comunicação que será utilizada pelo data source.
Foi selecionada a Modbus Serial, conforme figura abaixo:
 55

Figura 29: Protocolo de Comunicação

Fonte: Autores

O novo data source foi configurado da seguinte forma:

1- Foi informado um nome para o data source;

2- Foi informado o período que deve ocorrer o ciclo de varredura do software. Vale ressaltar
que, quanto menor for este período, mais poder de processamento o Mango Automation exigirá
do Raspberry PI 2. Nos testes realizados o sistema se comportou muito bem com um período de
cinco (5) segundos.
3- Foi necessário informar a porta que o Arduino está conectado.
 56

4- A velocidade foi configurada com o mesmo valor utilizado no código do Arduino. Nos
testes realizados funcionou apenas na velocidade de 9600 baud.
5- Conforme o código utilizado no Arduino, o padrão de transmissão utilizado é o 8N1, ou
seja, 8 bits de dados, com 1 bit de parada e sem paridade.
6- Foi selecionado o tipo de codificação RTU.
7- Em relação aos outros parâmetros, foi utilizado o valor padrão já disponibilizado pelo
Mango Automation.

Figura 30: Finalização do Data Source

Fonte: Autores

Após inserir os dados de configuração do data source deve-se salva-lo, para que o mesmo
seja criado.
Após a criação do data source, foi realizado o procedimento para criação dos data points,
responsáveis por controlar no Mango Automation o envio e recebimento dos dados do Arduino.
Em cada data point foi preciso informar a qual tipo de entrada ou saída ele se refere.
Segue um exemplo de configuração para cada tipo de data point que foi utilizado no projeto,
ressaltando que não foi utilizado saída analógica.
 57

 Saída Digital

1. Foi informado um nome para o dispositivo.

2. Foi informado ID do escravo que está conectado, neste caso, o Arduino.
3. Especificou-se o tipo de registrador, que para saída digital deve ser o COIL STATUS.
4. O campo Offset deve ser zero (0) para o primeiro data point. Mas é preciso ir aumentando
conforme sejam adicionados outros data points do mesmo tipo de registrador.
5. No campo Write type foi selecionada a opção Settable que permite que seja possível
definir os sets de valores a partir do Mango Automation.
6. Realizada essas configurações, o data point foi salvo para que fosse criado.

Figura 31: Criação do Data Point de Saída Digital

Fonte: Autores

 Entrada Analógica

1. Foi informado um nome para o dispositivo.

2. Foi especificado o tipo de registrador utilizado, que para entrada analógica é o
INPUT REGISTER.
3. No campo Modbus data type selecionou-se a opção 2 byte unsigned integer.
4. No campo Write type foi selecionada a opção “Not settable”, pois este data point
apenas recebe dados da porta analógica.
 58

5. Realizada essas configurações, o data point foi salvo para que fosse criado.

Figura 32: Criação do Data Point de Entrada Analógica

Fonte: Autores

 Entrada Digital

1- Foi informado um nome para o dispositivo.

2- Foi especificado o tipo de registrador utilizado, que para entrada digital é o INPUT
STATUS.
3- No campo Write type foi selecionada a opção “Not settable” pois este data point apenas
recebe dados da porta analógica.
4- Após essa configuração é preciso clicar em Salvar para que o data point seja criado.
 59

Figura 33: Criação do Data Point de Entrada Digital

Fonte: Autores

Após a criação dos datas points foi necessário conectá-los. Para isso, clicou-se nos ícones
destacados na figura abaixo.

Figura 34: Conectando os Data Points

Fonte: Autores

Em seguida foi conectado o data source, clicando no ícone destacado na figura abaixo.

Figura 35: Conectando o Data Source

Fonte: Autores
 60

ANEXO D – CRIAÇÃO DA INTERFACE GRÁFICA

 Para criação da interface gráfica, utilizou-se o seguinte método:

1- Clicou-se no ícone “Representação gráfica” na barra de menus e na tela seguinte clicou-se

no botão ( ).

Figura 36 – Criação da Representação Gráfica.

Fonte: Autores

2- Informou-se um nome para a representação gráfica, e foi anexada uma imagem de uma
planta 3D similar a maquete do projeto. Esta imagem foi utilizada como plano de fundo para as
animações que serão implementadas. Após todas as configurações, clicou-se em “Save”.
 61

Figura 37 – Anexando Imagem

Fonte: Autores

 Para a configuração da representação gráfica foi necessário inserir os datas points, através
dos quais será possível controlar um LED e visualizar informações como status do LED e
temperatura aferida. Segue o procedimento de criação do botão Liga/Desliga do LED.

1- No menu “Componentes” selecionou-se a opção “Data Point Simples”. Conforme

imagem:
 62

Figura 38 – Configuração do Tipo de Data Point do Botão do LED

Fonte: Autores

2- Em seguida, foi selecionado o data point referente ao botão que está sendo configurado,
que no caso é “Lampada_Quarto – Liga_Desliga”.
Conforme imagem:

Figura 39 – Selecionando Data Point do Botão do LED

Fonte: Autores

3- Foi selecionado as opções “Configurável” e “Exibir Controles”.

 63

Conforme imagem abaixo:

Figura 40 – Configurações do Botão do LED

Fonte: Autores

4- Realizada as configurações, o botão será exibido desta forma:

Figura 41: Botão de Controle do LED

Fonte: Autores

5- Ao passar o mouse sobre, o botão ele será exibido num formato que permita o controle do
LED, conforme imagem abaixo:

Figura 42: Operação do Botão de Controle do LED

Fonte: Autores

 Inserindo e configurando o data point do sensor de temperatura

 64

1- No campo “Componentes” foi selecionada a opção “Gif analógico”.

Figura 43 – Configuração do Tipo de Data Point do Sensor de Temperatura

Fonte: Autores

2- Selecionou-se o data point correspondente. Que neste caso foi “Sensor-Temperatura”.

Figura 44 – Selecionando o Data Point do Sensor de Temperatura

Fonte: Autores
 65

3- Foi definido o range de indicação de temperatura e depois selecionou-se a imagem do

termômetro.

Figura 45 – Configuração do Termômetro

Fonte: Autores

4- Imagem do sensor após configuração.

Figura 46 – Termômetro Configurado

Fonte: Autores
 66

 Mostrar status do LED

1- Em “Componentes” foi selecionada a opção GIF Binário.

Figura 47 - Configuração do Tipo de Data Point do Status do LED

Fonte: Autores

2- Em seguida informou - se o data point correspondente, neste caso foi “Lampada –

Status”. Também foi informado um nome para que seja mostrado este item na tela de
representação gráfica. Porém esse nome só será exibido ao passar mouse sobre o ícone.
 67

Figura 48 - Selecionando o Data Point do Status do LED

Fonte: Autores

3- Clicou- se na opção “Exibir texto”, para que seja mostrado o status “Ligado/Desligado”
do LED e escolheu como ele será exibido com status de ligado e desligado.

Figura 49 – Configuração do Status do LED

Fonte: Autores
 68

Figura 50 – Status do LED Configurado

Fonte: Autores

Os passos para configurar a indicação de ativação do buzzer são similares a esse, alterando
apenas o estilo das lâmpadas.
 69

ANEXO E – CÓDIGO COMPLETO

//Inclusao das Bibliotecas

#include <Modbus.h>
#include <ModbusSerial.h>
#include <DHT.h>
#include <SPI.h>

//Configuraçao Inicial do Sensor de Temperatura

#define DHTPIN A0
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

//Configurando Registradores Sensor de Temperatura

const int SENSOR_TEMP = 0;
const int sensorPin_Temp = A0;

//Configurando Registradores dos Botoes e LEDs Quarto

const int LAMP_Quarto_COIL = 0;
const int HAB_Quarto_COIL = 1;
const int SWITCH_Quarto_ISTS = 0;

const int Botao_Quarto = 12;

const int LED_Quarto = 13;

int Status_Quarto = 0;
int Status_LED_Quarto = 0;

//Configurando Registradores dos Botoes e LEDs Sala Cozinha

const int LAMP_sala_COIL = 2;
const int HAB_sala_COIL = 3;
const int SWITCH_sala_ISTS = 1;

const int Botao_sala = 10;

const int LED_sala = 11;

int Status_sala = 0;
int Status_LED_sala = 0;

//Configurando Registradores dos Botoes e LEDs Banheiro

const int LAMP_ban_COIL = 4;
const int HAB_ban_COIL = 5;
const int SWITCH_ban_ISTS = 2;
 70

const int Botao_ban = 8;

const int LED_ban = 9;

int Status_ban = 0;
int Status_LED_ban = 0;

//LDR - Sensor de Luminosidade

int LED_LDR = 5; //Porta a ser utilizada para ligar o LED
int portaLDR = A1; //Porta analógica utilizada pelo LDR

const int LED_Status_LDR_ISTS = 3;

//Configuracao PIR

int pinBuzzer = 6;
int pinSensorPIR = 7;
int valorSensorPIR = 0;

const int Status_PIR_ISTS = 4;

ModbusSerial mb;

long ts;

void setup () {

// Inicializa a porta Serial

Serial.begin(9600);
//Inicializa a Biblioteca DHT
dht.begin();

// Config Modbus Serial (port, speed, byte format)

mb.config(&Serial, 9600, SERIAL_8N1);
// Set the Slave ID (1-247)
mb.setSlaveId(1);

pinMode(LED_Quarto, OUTPUT);
pinMode(Botao_Quarto, INPUT);
digitalWrite(LED_Quarto, LOW);

pinMode(LED_sala, OUTPUT);
pinMode(Botao_sala, INPUT);
digitalWrite(LED_sala, LOW);

pinMode(LED_ban, OUTPUT);
pinMode(Botao_ban, INPUT);
 71

digitalWrite(LED_ban, LOW);

pinMode(LED_LDR, OUTPUT);
pinMode(pinBuzzer, OUTPUT);
pinMode(pinSensorPIR, INPUT);

mb.addIsts(SWITCH_Quarto_ISTS);
mb.addCoil(LAMP_Quarto_COIL);
mb.addCoil(HAB_Quarto_COIL);

mb.addIsts(SWITCH_sala_ISTS);
mb.addCoil(LAMP_sala_COIL);
mb.addCoil(HAB_sala_COIL);

mb.addIsts(SWITCH_ban_ISTS);
mb.addCoil(LAMP_ban_COIL);
mb.addCoil(HAB_ban_COIL);

mb.addIsts(LED_Status_LDR_ISTS);
mb.addIsts(Status_PIR_ISTS);

mb.addIreg(SENSOR_TEMP);

void loop()
{
mb.task();

//Logica do Botao Quarto

// Se o habilita do mango estive acionado

if (mb.Coil(HAB_Quarto_COIL) == true)
{
// Recebe o comando virtual do mango e aciona o LED
digitalWrite(LED_Quarto, mb.Coil(LAMP_Quarto_COIL));
// Envia para o mango a situaçao que esta o porta do LED
mb.Ists(SWITCH_Quarto_ISTS, digitalRead(LED_Quarto));
}

else // Senao faz a rotina de acionamento dos botoes fisicos

{
// Se o botao estiver nao pressionado e o
// o Status_LED for 0
if (digitalRead(Botao_Quarto) == LOW && Status_LED_Quarto == 0)
{
 72

// Passa o status para 1

Status_Quarto = 1;
// espera 100 mili segundos
delayMicroseconds(100);
}

// Status for para 1 e o botao for pressionado

if (Status_Quarto == 1 && digitalRead(Botao_Quarto) == HIGH)
{
//Ligo o LED
digitalWrite(LED_Quarto, HIGH);
// Modo e Status_LED para 1
Status_LED_Quarto = 1;
// Envia para o mango a situaçao que esta o porta do LED
mb.Ists(SWITCH_Quarto_ISTS, digitalRead(LED_Quarto));
}

// Se o botao for solto e o Status_LED for 1

if (digitalRead(Botao_Quarto) == LOW && Status_LED_Quarto == 1)
{
// Mudo o Status para 0
Status_Quarto = 0;
// espera 100 mili segundos
delayMicroseconds(100);
}

// Se o Status for 0 e o botao for novamente pressionado

if (Status_Quarto == 0 && digitalRead(Botao_Quarto) == HIGH)
{
// Apago o LED
digitalWrite(LED_Quarto, LOW);
// Mudo o Status para condiçao inicial 0
Status_LED_Quarto = 0;
// Envia para o mango a situaçao que esta o porta do LED
mb.Ists(SWITCH_Quarto_ISTS, digitalRead(LED_Quarto));
}
}

//Logica do Botao Sala e Cozinha

if (mb.Coil(HAB_sala_COIL) == true)
{
// Recebe o comando virtual do mango e aciona o LED
digitalWrite(LED_sala, mb.Coil(LAMP_sala_COIL));
// Envia para o mango a situaçao que esta o porta do LED
mb.Ists(SWITCH_sala_ISTS, digitalRead(LED_sala));
}
 73

else // Senao faz a rotina de acionamento dos botoes fisicos

{
// Se o botao estiver nao pressionado e o
// o Status_LED for 0
if (digitalRead(Botao_sala) == LOW && Status_LED_sala == 0)
{
// Passa o status para 1
Status_sala = 1;
// espera 100 mili segundos
delayMicroseconds(100);
}

// Status for para 1 e o botao for pressionado

if (Status_sala == 1 && digitalRead(Botao_sala) == HIGH)
{
//Ligo o LED
digitalWrite(LED_sala, HIGH);
// Modo e Status_LED para 1
Status_LED_sala = 1;
// Envia para o mango a situaçao que esta o porta do LED
mb.Ists(SWITCH_sala_ISTS, digitalRead(LED_sala));
}

// Se o botao for solto e o Status_LED for 1

if (digitalRead(Botao_sala) == LOW && Status_LED_sala == 1)
{
// Mudo o Status para 0
Status_sala = 0;
// espera 100 mili segundos
delayMicroseconds(100);
}

// Se o Status for 0 e o botao for novamente pressionado

if (Status_sala == 0 && digitalRead(Botao_sala) == HIGH)
{
// Apago o LED
digitalWrite(LED_sala, LOW);
// Mudo o Status para condiçao inicial 0
Status_LED_sala = 0;
// Envia para o mango a situaçao que esta o porta do LED
mb.Ists(SWITCH_sala_ISTS, digitalRead(LED_sala));
}
}

//Logica Botao Banheiro

// Se o habilita do mango estive acionado

 74

if (mb.Coil(HAB_ban_COIL) == true)
{
// Recebe o comando virtual do mango e aciona o LED
digitalWrite(LED_ban, mb.Coil(LAMP_ban_COIL));
// Envia para o mango a situaçao que esta o porta do LED
mb.Ists(SWITCH_ban_ISTS, digitalRead(LED_ban));
}

else // Senao faz a rotina de acionamento dos botoes fisicos

{
// Se o botao estiver nao pressionado e o
// o Status_LED for 0
if (digitalRead(Botao_ban) == LOW && Status_LED_ban == 0)
{
// Passa o status para 1
Status_ban = 1;
// espera 100 mili segundos
delayMicroseconds(100);
}

// Status for para 1 e o botao for pressionado

if (Status_ban == 1 && digitalRead(Botao_ban) == HIGH)
{
//Ligo o LED
digitalWrite(LED_ban, HIGH);
// Modo e Status_LED para 1
Status_LED_ban = 1;
// Envia para o mango a situaçao que esta o porta do LED
mb.Ists(SWITCH_ban_ISTS, digitalRead(LED_ban));
}

// Se o botao for solto e o Status_LED for 1

if (digitalRead(Botao_ban) == LOW && Status_LED_ban == 1)
{
// Mudo o Status para 0
Status_ban = 0;
// espera 100 mili segundos
delayMicroseconds(100);
}

// Se o Status for 0 e o botao for novamente pressionado

if (Status_ban == 0 && digitalRead(Botao_ban) == HIGH)
{
// Apago o LED
digitalWrite(LED_ban, LOW);
// Mudo o Status para condiçao inicial 0
Status_LED_ban = 0;
 75

// Envia para o mango a situaçao que esta o porta do LED

mb.Ists(SWITCH_ban_ISTS, digitalRead(LED_ban));
}
}

// Logica do Sensro de Temperatura

analogRead(sensorPin_Temp);
float t = dht.readTemperature();
if (millis() > ts +2000)
{
ts = millis();
Serial.println(t);
Serial.println(" ºC");
mb.Ireg(SENSOR_TEMP, t);
}

//Logica do Sensor LDR

int estado = analogRead(portaLDR); //Lê o valor fornecido pelo LDR

// Caso o valor lido na porta analógica seja maior do que

// 800, acende o LED
if (estado > 900)
{
digitalWrite(LED_LDR, HIGH);
mb.Ists(LED_Status_LDR_ISTS, digitalRead(LED_LDR));
}
else //Caso contrário, apaga o LED
{
digitalWrite(LED_LDR, LOW);
mb.Ists(LED_Status_LDR_ISTS, digitalRead(LED_LDR));
}

//Logica Sensor PIR

valorSensorPIR = digitalRead(pinSensorPIR);

if (valorSensorPIR == 1) {

ligaAlarme();
mb.Ists(Status_PIR_ISTS, digitalRead(pinSensorPIR));
}
else
desligaAlarme();
mb.Ists(Status_PIR_ISTS, digitalRead(pinSensorPIR));
 76

void ligaAlarme(){
tone(pinBuzzer,1500);
//delay(3000);
desligaAlarme();
}

void desligaAlarme(){
noTone(pinBuzzer);
}