Embed Size (px)
Citation preview
UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ
DEPARTAMENTO DE ELETRONICA
AUTOMAÇÃO INDUSTRIAL
GUILHERME NUNES DE MORAES E BUENO
CONTROLE DE ILUMINAÇÃO E TEMPERATURA PELA
PLATAFORMA ARDUINO VIA CELULAR
TRABALHO DE CONCLUSÃO DE CURSO
PONTA GROSSA
2015
GUILHERME NUNES DE MORAES E BUENO
CONTROLE DE ILUMINAÇÃO E TEMPERATURA PELA
PLATAFORMA ARDUINO VIA CELULAR
Trabalho de Conclusão de Curso apresentada como requisito parcial à obtenção do título de Tecnólogo em Automação Industrial, do Departamento de Eletrônica, da Universidade Tecnológica Federal do Paraná.
Orientador: Prof. Alexandre Junior Fenato M. Sc.
2015
TERMO DE APROVAÇÃO
CONTROLE DE TEMPERATURA E ILUMINAÇÃO PELA PLATAFORMA ARDUINO VIA CELULAR
por
GUILHERME NUNES DE MORAES BUENO
Este Trabalho de Conclusão de Curso (TCC) foi apresentado em 10 de dezembro de
2015 como requisito parcial para a obtenção do título de Tecnólogo em Automação
Industrial. O candidato foi arguido pela Banca Examinadora composta pelos
professores abaixo assinados. Após deliberação, a Banca Examinadora considerou
o trabalho aprovado.
_______________________________ Alexandre Junior Fenato
Prof. Orientador
_______________________________ Jeferson José Gomes, Msc.
Responsável pelos Trabalhos de Conclusão de Curso
_______________________________ Abraham Elias Ortega Paredes, Dr.
Membro titular
_______________________________ Fernanda Cristina Correa
Membro titular
_______________________________ Julio Cesar Guimarães, Msc.
Coordenador do Curso UTFPR - Campus Ponta Grossa
- O TERMO DE APROVAÇÃO ASSINADO ENCONTRA-SE ARQUIVADO NA SECRETARIA ACADÊMICA -
Ministério da Educação
Universidade Tecnológica Federal do Paraná Campus Ponta Grossa
Diretoria de Graduação e Educação Profissional
RESUMO
BUENO, Guilherme Nunes de Moraes e. Controle de Iluminação e Temperatura pela plataforma Arduino via Celular. 2015. 74f. Trabalho de Conclusão de Curso Tecnologia em Automação Residencial - Universidade Tecnológica Federal do Paraná. Ponta Grossa, 2015
O presente trabalho explora o universo Arduino e mostra a criação de um aplicativo para o sistema operacional Android, utilizando o ambiente de desenvolvimento App Inventor. Este sistema foi empregado na automação residencial e implantado em uma maquete em MDF de uma casa. O sistema criado mostra uma integração e controle de algumas variáveis como: luminosidade, temperatura e ventilação via celular. Para montagem do protótipo foram utilizados LED’s, um sensor de temperatura LM35 e um cooler. Após variados testes com diferentes dispositivos, obteve-se resultados positivos, mostrando a praticidade gerada e a possibilidade de implementação em um modelo real. Foi realizado também uma comparação de custos, entre o sistema proposto e um equivalente proposto por meio de um orçamento realizado por uma empresa de automação: o resultado dessa comparação é extremamente favorável ao sistema apresentado neste trabalho.
Palavras-chave: Arduino. Android. App Inventor. Automação residencial. Integração
ABSTRACT
BUENO, Guilherme Nunes de Moraes e. Control lighting and temperature for the Arduino platform via mobile phone. 2015. 74f.Trabalho de Conclusão de Curso Tecnologia em Automação Residencial - Universidade Tecnológica Federal do Paraná. Ponta Grossa, 2015
The present work explores the Arduino universe and shows the creation of an application for the Android operating system using the App Inventor development environment. This system has been used in home automation and deployed in a model of a house in MDF. The system created shows an integration and control of some variables such as light, temperature and ventilation via phone. For montage of the prototype were used LED's, a LM35 temperature sensor and a cooler. After various tests with different devices, positive results were obtained, showing the generated practicality and the possibility of practical implementation in a real model. It was also carried out a comparison of costs, among the proposed system and an equivalent proposed by means of an estimate carried out by an automation company: the result of this comparison is extremely favorable to the system presented in this work.
Keywords: Arduino. Android. App Inventor. Home Automation. Integration
LISTA DE ABREVIATURAS
A/D Analógico/Digital
CI Circuito Integrado
GND Ground
GPS Global Positioning System
GSM Global System for Mobile
HTML Hypertext Markup Language
HTTP Hypertext Transfer Protocol
IDE Integrated Development Enviroment
IP Internet Protocol
I/O Input/Output
KB Kilobytes
LED Light Emitting Diode
mA Miliamperes
Mb Megabytes
MDF Medium Density Fiberboard
Mhz Mega Hertz
MIT Massachusetts Institute of Technology
ms Milissegundos
mV Milivolts
NTC Negative Temperature Coeficient
PLC Programmable Logical Controller
PTC Positive Temperature Coeficient
PWM Pulse Width Modulation
R3 Review 3
SO Sistema Operacional
SPI Serial Peripheral Interface
SRAM Static Random Acess Memory
TTL Transistor-Transistor Logic
URL Uniform Resource Locator
USB Universal Serial Bus
VDC Voltage Direct Current
LISTA DE ILUSTRAÇÕES
Figura 1- Arduino Uno R3 ............................................................................... 10
Figura 2 – Arquitetura do Hardware Arduino .................................................. 13
Figura 3 - PWM no Arduino ............................................................................ 14
Figura 4 - Blocos do Arduino .......................................................................... 15
Figura 5 - Interface da IDE do Arduino ........................................................... 16
Figura 6 - Sketch do exemplo Blink Led ......................................................... 17
Figura 7 - Função Void Setup ......................................................................... 18
Figura 8 - Função Void Loop .......................................................................... 19
Figura 9 - Pagina Inicial do App Inventor ........................................................ 21
Figura 10 - Criação Gráfica do Aplicativo ....................................................... 22
Figura 11 - Blocos de Programação ............................................................... 23
Figura 12 – Opções de testes do MIT APP INVENTOR ................................. 24
Figura 13 - Arquitetura de rede do Arduino ..................................................... 25
Figura 14 - Arduino com Ethernet Shield ........................................................ 26
Figura 15 - Modem 3g Onda MSA190UP ....................................................... 27
Figura 16 - Roteador TP-LINK TL-MR3020 .................................................... 27
Figura 17 - Cooler de 12 volts ......................................................................... 28
Figura 18 - Modelo de Diodo .......................................................................... 29
Figura 19 - Representação do Transistor tipo PNP E NPN ............................ 30
Figura 20- Ilustração de um Transistor ........................................................... 30
Figura 21 - Representação de modelos de LM35 ........................................... 31
Figura 22 - Representação do LED ................................................................ 33
Figura 23 - Módulo Bluetooth HC-05 .............................................................. 35
Figura 24 - Código utilizado para medição de temperatura com o NTC ......... 36
Figura 25 - Termistor NTC .............................................................................. 36
Figura 26 - Motor Shield L293D ...................................................................... 37
Figura 27 - Conexão LED no pino 6 e no GND do Microcontrolador .............. 39
Figura 28 - Bloco Void Loop e a programação em HTML ............................... 40
Figura 29 - Configurações do Roteador .......................................................... 41
Figura 30 - Programação Utilizada para o teste do Ethernet Shield ............... 42
Figura 31 - Bloco Void Setup do circuito de Iluminação.................................. 43
Figura 32 - Iniciando requisição HTML ........................................................... 43
Figura 33 - Exemplo de Acionamento do LED ................................................ 44
Figura 34 - Fluxograma de processo de controle de luminosidade ................ 45
Figura 35 - Sistema de Iluminação do projeto ................................................ 45
Figura 36- Planta baixa da maquete e seus componentes ............................. 46
Figura 37 - Esquema de Ligação do LM35 no Arduino ................................... 47
Figura 38 - Conversão do Valor lido pelo sensor em graus Celsius ............... 47
Figura 39 - Esquema de ligação do motor DC com transistor TIP 120 ........... 48
Figura 40 - Fluxograma do processo de controle de temperatura. ................. 49
Figura 41 - Menu Principal do Aplicativo ......................................................... 50
Figura 42 - Tela de Iluminação ....................................................................... 51
Figura 43 - Tela de Temperatura e Ventilação ............................................... 52
Figura 44 - Fluxograma do processo do menu temperatura ........................... 53
Figura 45 - Fluxograma do funcionamento do acionamento das luzes ........... 54
Figura 46 - Código de Iluminação ................................................................... 55
Figura 47 - Programação do status das luzes ................................................ 56
Figura 48 - Funções de controle ..................................................................... 56
Figura 49 - Código de Temperatura e Ventilação ........................................... 57
SUMÁRIO
1 INTRODUÇÃO ..............................................................................6
1.1 OBJETIVO GERAL .......................................................................8
1.2 JUSTIFICATIVA ............................................................................8
2 REVISÃO DE LITERATURA ........................................................9
2.1 ARDUINO ......................................................................................9
Especificações ..............................................................................10
Alimentação ..................................................................................11
Microcontrolador ...........................................................................12
Entradas e Saídas .........................................................................13
Ide .................................................................................................15
Linguagem de Programação .........................................................17
Função Void Loop e Void Setup ....................................................18
2.2 ANDROID ......................................................................................19
MIT App Inventor ...........................................................................20
Ambiente de Desenvolvimento ......................................................20
2.3 COMUNICAÇÃO ...........................................................................24
Ethernet Shield ..............................................................................24
Roteador e Modem .......................................................................26
2.4 COMPONENTES ..........................................................................28
Cooler ...........................................................................................28
Diodo .............................................................................................29
Transistores ..................................................................................29
LM35 .............................................................................................31
LED ...............................................................................................33
3 METODOLOGIA E DESENVOLVIMENTO ...................................34
3.1 METODOS DE CONTROLE E MEDIÇÃO ....................................34
3.2 DESENVOLVIMENTO DO PROTÓTIPO ......................................38
Funcionamento do protótipo..........................................................38
Iluminação .....................................................................................39
Temperatura ..................................................................................46
Ventilação .....................................................................................48
3.3 APLICATIVO ANDROINO .............................................................49
Interface Gráfica ............................................................................50
Lógica de Programação ................................................................52
4 RESULTADOS E DISCUSSÕES ..................................................59
5 CONCLUSÃO ...............................................................................64
6
1 INTRODUÇÃO
Com o avanço tecnológico hoje é possível realizar uma enorme gama de
atividades com um celular, desde chamadas de vídeo, mensagens instantâneas via
internet, entre outras, fazendo com que este instrumento se torne cada vez mais
essencial ao ser humano.
O mercado atual de automação residencial atende às necessidades e aos
confortos tecnológicos exigidos pelos usuários, porém cada produto tem seu próprio
sistema e só funciona com seus próprios dispositivos. Isto dificulta a integração com
os demais dispositivos da casa, tornando o processo complicado (CIPRIANI, 2014).
A ideia de automatizar a vida das pessoas surgiu por meio de filmes de
ficção científica, nos quais pessoas comuns tem acesso a tecnologias avançadas.
Além disso, gera praticidade por meio da automação na vida cotidiana de cada
indivíduo, sendo possível suprir funções que muitas vezes as pessoas não possuem
tempo para executar. Ademais, a automação residencial traz conforto na vida de
cada indivíduo.
Um dos princípios da automação surgiu quando Nikola Tesla patenteou a
ideia de um controle remoto para embarcações e veículos em 1898 (TESLA
SOCIETY, 2014).
Atualmente, existe uma deficiência no uso da tecnologia moderna voltada
para automação das operações rotineiras de uma residência, por ser algo caro e que
muitas pessoas consideram um gasto desnecessário. Além disso, quando há uma
implementação de um sistema de automação residencial geralmente este é de difícil
operacionalidade e integração, como exemplo: a luminosidade do ambiente e a
ventilação (ASSOCIAÇÃO BRASILEIRA DE AUTOMAÇÃO RESIDENCIAL,2008).
Quando se estabelece um sistema com resultados positivos em relação a
esse tipo de automação, garante-se uma maior funcionalidade para o dia a dia das
pessoas, diminuindo os gastos desnecessários com energia elétrica. Além disso,
seria possível criar um sistema de segurança por meio do qual o morador poderia
monitorar remotamente sua casa por meio de câmeras, controlando a luminosidade
do cada ambiente. Ademais, é também possível, por meio de um sistema integrado,
aliar todos estes dispositivos com televisão, internet, aparelho de som, luz, ar
7
condicionado, portões eletrônicos, fazendo com que o morador tenha amplo controle
e visualize todas estas atividades.
O presente trabalho foi desenvolvido sobre a plataforma Arduino a fim de
automatizar algumas operações em uma residência, representada em uma maquete,
na qual foram utilizados sensores, LED’s e um motor para simular um ventilador.
Além disso, utilizou-se um celular com o sistema operacional Android, visto que o
objetivo principal se refere à criação de um aplicativo no telefone móvel que permite
visualizar o status da luz no ambiente, ventilação e temperatura atual da casa. Tais
atividades são demonstradas por meio da maquete de simulação do projeto, de
maneira que é possível executar o controle e comando destes dispositivos utilizando
o celular. Para criação do aplicativo no Android foi utilizado o App Inventor, uma
ferramenta desenvolvida pelo instituto de Tecnologia de Massachusetts (MIT), que
permite que se faça a programação, bem como a elaboração da parte gráfica do
aplicativo.
Por ser um open source vêm surgindo novos “Arduinos”, desde caseiros a
criados por empresas com diversas melhorias. Com a ampliação desse universo já
vem sendo possível interligar diferentes Hardwares para buscar a automação
desejada como o Raspberry Pi e o Arduino. Por meio da utilização do App Inventor
aumenta-se ainda mais este ambiente, de modo que é possível explorar todo
acessório de um smartphone complementar com a programação realizada na IDE e
utilizar do ambiente de uma residência para obter aquisição e controle de quaisquer
dados possíveis. Este sistema confere um aumento na comodidade do morador.
Assim, utilizando um aplicativo via celular, o monitoramento e atuação remota
utilizada de forma inteligente e racional por parte do usuário pode inclusive gerar
economia de energia elétrica.
Por meio do projeto foi possível conhecer a estrutura e assim programar de
uma maneira didática, além de observar a grandeza de possíveis métodos que
podem ser implementados com esse software
8
1.1 OBJETIVO GERAL
O objetivo do projeto é a criação de um aplicativo para o sistema operacional
Android, que juntamente com o microcontrolador Arduino realiza o controle da
luminosidade, temperatura e ventilação.
1.2 JUSTIFICATIVA
Uma das principais motivações para a elaboração deste trabalho está na
integração da tecnologia celular com o Arduino a fim de comprovar a viabilidade de
uma automação consistente em seus acionamentos e mais acessível, gerando uma
comodidade para o morador. Outro ponto importante refere-se à versatilidade dos
novos aparelhos celulares que vêm com diversas funcionalidades, com as quais é
possível desenvolver um controle bastante eficaz e integrado com o usuário.
O presente trabalho está dividido em quatro capítulos:
1 – Revisão de Literatura: neste capítulo estão explicitadas informações
técnicas sobre a plataforma utilizada, sobre os principais componentes e sobre o
ambiente de desenvolvimento do aplicativo no celular;
2 – Metodologia e Desenvolvimento: nesta parte estão descritas as
metodologias utilizadas para o desenvolvimento do protótipo;
3 – Resultados e Discussões: nesta etapa discute-se sobre os resultados
obtidos e possíveis melhorias e possibilidades para projetos futuros;
4 – Conclusão: neste capítulo, estão expostos os principais ganhos de
conhecimento adquiridos bem como as dificuldades encontradas durante a
elaboração do projeto.
9
2 REVISÃO DE LITERATURA
Neste capítulo, é apresentado um estudo sobre as plataformas de Arduino,
os meios de configuração e comunicação, o modo de criação de aplicativos para o
sistema operacional Android e sobre os sensores utilizados no projeto. Desta forma,
torna-se mais fácil o entendimento, por parte do leitor, dos componentes técnicos
físicos e teóricos do trabalho.
2.1 ARDUINO
O Arduino surgiu em 2005 no Interaction Design Institute situado na cidade
de Ivrea, na Itália. Pensando em um jeito barato e fácil de ensinar programação e
eletrônica para seus alunos, um professor chamado Massimo Banzi discutiu o
assunto junto com o pesquisador David Cuartielles, e assim surgiu a ideia da
plataforma Arduino, um microcontrolador barato e de fácil programação, na época os
produtos relacionados eram muito caros e difíceis de serem utilizado por pessoas
que não eram da área, o que acabava se tornando uma tarefa difícil (EVANS, et al.,
2013).
Banzi junto com seu aluno David Mellis desenvolveram a linguagem de
programação do Arduino que tem por base o C/C++ (RIOS, et al., 2012).
O Arduino acabou se tornando algo muito comum para os alunos de
eletrônica e automação, por ser uma maneira fácil de aprender e criar vários
projetos. Nele pode-se conectar LED’s, sensores, displays, controlar motores, enviar
dados para um computador, sites, celulares entre outras finalidades.
Atualmente, existem diversos modelos desde o mais básico aos mais
completos como o Arduino Uno, Leonardo, Mega entre outros, diferenciando no tipo
de microcontrolador utilizado, quantidade de pinos para entradas e saídas digitais e
analógicas, quantidade de memórias, entre outras diferenças.
Para o desenvolvimento do projeto foi utilizado o Arduino Uno R3 que é um
dos modelos mais populares, O Uno R3 é a versão 3 do modelo Uno, sendo que ele
é baseado na família Atmega328. O Arduino possui 14 pinos digitais que podem ser
usados tanto para saída como para entrada sendo que 6 deles podem ser usados
10
como saída PWM. Possui também 6 pinos para serem utilizados como entrada
analógica ou entrada e saída digital, além de uma conexão USB. Ademais, utiliza um
cristal de 16 MHz.
A figura 1 representa o modelo Uno, que possui aproximadamente as
dimensões de um cartão de crédito.
Figura 1- Arduino Uno R3 Fonte: http://arduino.cc/en/Main/ArduinoBoardUno.
Especificações
Como visto este modelo possui diversas funções, e possui grandes opções
de projetos, no entanto, primeiramente, é necessário entender o funcionamento
deste hardware para obter um melhor aproveitamento do mesmo.
Para melhor entendimento a seguir são definidos os elementos que
compõem esse hardware de acordo com o fabricante.
Microcontrolador: É um chip que pode ser programado para
desempenhar uma função nele contém um processador, memórias,
conversores A/D e vice-versa, entre outros periféricos.
Memória Flash: É a capacidade de preservar o armazenamento de
dados por um longo tempo sem a presença de corrente elétrica.
SRAM: É uma memória que mantém os dados desde que a
alimentação seja mantida.
11
EEPROM: É a memória não volátil, ou seja, pode ser programada e
reprogramada diversas vezes eletricamente.
Firmware: É o programa que é carregado na CPU com as definições
de funcionamento de entrada e saídas.
Reset: Botão para efetuar o reset físico do microcontrolador.
No quadro 1 são mostradas as especificações do Arduino Uno R3 de acordo
com os dados fornecidos pelo próprio fabricante.
Quadro 1 - Especificações do Arduino
Fonte: http://arduino.cc/en/Main/ArduinoBoardUno
Alimentação
Como observado no quadro 1, a alimentação recomendada é de 7 a 12
volts, a qual pode ser fornecida via conexão USB ou por uma fonte externa por meio
do conector de alimentação ou também pelos pinos Vin e GND do Arduino. Porém, a
placa pode operar entre 6 a 35 volts e corrente mínima de 300mA, (FILHO, 2012). A
Microcontrolador Atmega328
Tensão de Operação 5V
Tensão de entrada (Recomendado) 7—12 V
Tensão de Entrada (limites) 6- 20 V
Pinos I/O digitais 14 (dos quais 6 oferecem saída
PWM)
Pinos de entrada analógica 6
Corrente DC por I/O 40mA
Corrente DC para pinos 3.3v 50mA
Memória Flash 32KB (ATmega328) dos quais
0,5KB usados pelo Bootloader
SRAM 2KB (ATmega328)
EEPROM 1KB (ATmega328)
Clock Speed 16MHz
12
seguir apresenta-se os pinos utilizados para alimentação de acordo com a definição
do fabricante
Vin: Entrada de alimentação para a placa quando é utilizada uma
fonte externa, é possível fornecer alimentação por meio deste pino ou
acessá-la se estiver alimentando pelo conector de alimentação;
5V: Este pino fornece uma tensão regulada de 5 volts para o
microcontrolador e outros componentes da placa;
3V3: Fornecimento de 3,3 volts gerado pela placa FTDI (Controlador
USB) possui corrente máxima de 50mA;
GND: (Ground) pino de terra;
IOREF: Este pino fornece tensão de referência que o
microcontrolador opera quando utilizado uma placa de expansão
(Shields), configurado corretamente ele lê o pino IOREF e seleciona a
fonte de alimentação adequada ou habilita transdutores de tensão nas
saídas para trabalhar com 5 volts ou 3.3 volts.
Microcontrolador
O que difere um modelo de Arduino para outros, além da quantidade de
memórias, e de entradas e saídas, é o tipo de microcontrolador utilizado. No uno é o
Atmega 328, enquanto o Mega que é considerado uns dos mais completos da
família Arduino, utiliza o Atmega2560, que possui uma capacidade de
processamento bem maior. O microcontrolador contém memória RAM, memoria
ROM, uma unidade de processamento aritmético e os periféricos como as entradas
e saídas (FILHO, 2012).
O Atmega 328 utiliza uma memória flash de 32KB, sendo que 0,5KB são
utilizados pelo bootloader, que é um software gravado no processador que recebe a
aplicação por meio da interface serial e grava na memória do microcontrolador
(QUADROS, 2011).
Na figura 2 está ilustrada a arquitetura do Arduino por meio de blocos
funcionais, onde a fonte de alimentação divide a tensão de entrada em duas tensões
que podem ser trabalhadas no Arduino que são 5 volts e 3,3 volts, e com o
13
microcontrolador Atmega, ele oferece controles através de seus pinos digitais e
analógicos, que podem ser utilizados para sensores, chaves, controle de velocidade
de motores entre outras funcionalidades, o microcontrolador conta também com
pinos serias TX(Transmissor) RX(Receptor), para gravação do programa e
transmissão de dados.
Figura 2 – Arquitetura do Hardware Arduino Fonte: http://www.robotizando.com.br
Entradas e Saídas
O Arduino possui 20 pinos que podem ser utilizados tanto como saídas ou
entradas, sendo que 6 são usados para entradas analógicas e os 14 podem ser
utilizados como entradas e saídas digitais. Estes pinos operam com 5 volts e cada
pino pode fornecer ou receber 40mA. Além disso possui um resistor pull-up que está
desconectado por padrão de 20-50 Kohms com a finalidade de garantir o nível lógico
(ARDUINO, 2014).
Ademais, dos 14 pinos 6 deles podem oferecer saídas PWM (Pulse Width
Modulation) que é a modulação por largura de pulso, uma técnica para obtenção de
sinal analógico por meio de sinais digitais. No Arduino o controle digital utilizado para
a criação de uma onda quadrada se alterna em on (5 volts) ou off (0 volts),
14
modulando a largura de pulso, de maneira que é possível obter diferentes valores
analógicos (ARDUINO,2015).
Na família Arduino a escala de um pulso varia de 0 a 255 onde 0 representa
0%, 127 representa 50%, e 255 um ciclo de trabalho de 100%. Com esse comando
é possível modificar a intensidade de uma luz, a velocidade de rotação de um motor
entre outras funcionalidades que podem ser implementadas em qualquer projeto. Na
figura 3 exemplifica-se a atuação do PWM no Arduino, de forma que a linha verde
representa um período de tempo regular, no qual o período é inverso da frequência
PWM.
Figura 3 - PWM no Arduino
Fonte: http://www.arduino.cc/en/Tutorial/PWM
Conforme site do fabricante, a seguir definem os pinos presentes no Uno:
Serial: 0(RX) e 1 (TX) estes pinos são utilizados para comunicação
serial (RX) receptor e (TX) transmissor, usados para receber e
transmitir dados seriais TTL;
Pinos 2 e 3: Estes pinos são utilizados como interrupções e podem
ser configurados para disparar um valor alto borda de subida, valor
baixo, borda de descida ou mudança de valor;
PWM: Pinos 3,5,6,9,10,11 fornecem saída PWM;
15
SPI: Pino 10(SS), 11(MOSI), 12(MISO), 13(SCK), usados para
comunicação SPI, ou seja, usado para protocolo serial síncrono
utilizado para comunicação de microcontroladores com dispositivos
periféricos.
Conforme já mencionado, o Arduino também possui entradas analógicas,
numeradas de A0 a A5, na qual cada uma dispõe de 10 bits de resolução (1024
valores diferentes). Essas entradas analógicas são capazes de medir a tensão
aplicada, ou seja, o Arduino realizada a conversão do analógico para digital.
Na figura 4, por meio de uma divisão de blocos é possível identificar os itens
que compõem o Arduino.
Figura 4 - Blocos do Arduino
Fonte: http://www.robotizando.com.br
Ide
O Ambiente de desenvolvimento do Arduino é a IDE (Integrated
Development Environment), o qual tem como base o ambiente Processing que é
utilizado para programação com contexto gráfico interagindo com imagens e
animações (DEPARTAMENTO DE ENGENHARIA DE INFORMATICA ACADEMY,
2015).
A IDE contém um editor de texto onde se escreve o programa, que recebe o
nome de Sketch, e se comunica com o hardware do Arduino realizando o upload do
16
programa escrito (RIOS, et al., 2012). A IDE do Arduino pode ser baixada, em sua
versão mais atualizada, gratuitamente no site oficial do fabricante. Na figura 5 é
possível identificar as opções presentes no IDE do Arduino.
Figura 5 - Interface da IDE do Arduino
Fonte: http://techne.cesar.org.br/iniciando-com-arduino/
Como observado na figura 5, a interface do Arduino possui diversas opções.
É possível compilar o programa para verificação de erros, salvar realizar o upload do
programa na placa do Arduino entre outras opções. No próprio software é possível
escolher qual modelo de placa será utilizado e qual porta para comunicação será
usada. Uma função bastante empregada é o monitor serial, no qual é possível, por
meio da comunicação serial, visualizar os valores obtidos por meio do projeto
realizado.
Para ajudar o usuário na utilização do Arduino, o IDE possui alguns
exemplos de programação já prontos, facilitando o entendimento e a aprendizagem.
A figura 6 demonstra um dos exemplos disponíveis tanto no site do Arduino
como na IDE. Nele um LED conectado ao pino 13, liga e desliga a cada 1000ms,
uma programação bastante simples que ajuda o usuário entender melhor como
realizar diversas programações.
17
Figura 6 - Sketch do exemplo Blink Led
Fonte: Arduino IDE.
Linguagem de Programação
A programação do Arduino na IDE é bastante simples e de fácil
entendimento, sua estrutura de programação é chamada Sketch. Ele é dividido em
dois blocos de funções o Void Setup e o Void Loop, que são funções essenciais para
o funcionamento do programa (ARDUINO, 2015).
A linguagem de programação utilizada no Arduino é derivada da linguagem
C/C++. É formada por diferentes estruturas, no Sketch, primeiramente, é declarada
as bibliotecas que são uma forma de expandir o projeto facilitando a programação,
são funções extras desenvolvidas para uma determinada aplicação (ARDUINO,
2015). Em seguida entra as declarações de variáveis, como a variável int para
armazenar valores inteiros, float para armazenar valores em pontos flutuantes, char
para armazenamento de caracteres, entre outras variáveis utilizadas em linguagem
18
C/C++. As funções Void Setup e Void Loop são blocos de sub-rotinas que definem a
funcionalidade do programa, que são as próximas etapas.
Função Void Loop e Void Setup
Na etapa Void Setup iniciam-se as variáveis. Deve ser declarada toda
função que será utilizada no programa, assim, faz-se a configuração dos dispositivos
a serem utilizados. Além disso, define-se o modo de operação de cada pino que
será usado no projeto. Inicia-se a comunicação serial e a utilização das bibliotecas,
aqui se define se ele será uma entrada ou uma saída, determinado pelo comando de
Input ou Output, respectivamente. Esta etapa acontece apenas uma única vez ou
quando é realizado o reset da placa (Rios et al., 2012).
Na linha de programação, que pode ser observada na figura 7, demonstra-se
um exemplo de programação dentro da sub-rotina Void Setup
Figura 7 - Função Void Setup
Fonte: Autor
Como observado na imagem 7, a função pinMode é a definição do modo de
operação do pino 13 do Arduino, em seguida com a instrução OUTPUT
determinando como uma saída.
Logo após o bloco Void Setup, inicia-se o bloco Void Loop. Como próprio
nome já diz, ele efetua o Loop para leitura da programação, de acordo com as
instruções definidas no bloco anterior. Nele insere-se a programação e executa
repetitivamente. Nesta etapa acontece a leitura da porta serial, efetuado o comando
de cada pino do Arduino e outras definições.
Entra nesse contexto as leituras e escritas digitais como HIGH e LOW para
definição do nível de tensão +5 volts ou 0 volts respectivamente (SILVEIRA, 2012).
Seguindo o exemplo da ilustração 7, mostra-se na figura 8 como seria a
função Void Loop para a mudança de estado do LED conectado ao pino 13,
utilizando a programação mostrada no item 2.1.5 e no exemplo Blink, no qual o LED
conectado ao pino 13 do Arduino pisca a cada segundo.
19
Figura 8 - Função Void Loop
Fonte: Autor
Como observado na figura 8, a função Void Loop é responsável pela
execução dos comandos. A função digitalWrite mostrada na linha é o comando de
escrita digital no qual muda o estado do pino 13 para HIGH ou nível logico 1,
fazendo com que percorra corrente necessária no pino 13 fazendo o Led acender. A
seguir há o comando delay que provoca uma pausa de 1000 milissegundos para
efetuar a nova leitura. Após isso, a função digitalWrite muda o estado do pino 13
para 0 ou LOW, interrompendo o fluxo de corrente elétrica no LED e,
consequentemente, apagando-o, novamente seguido do comando delay que
aguarda 1 segundo para efetuar nova leitura, e assim retornando para o começo da
função Void Loop e efetuando o Loop diversas vezes (BARROS, 2013).
2.2 ANDROID
O Android é um sistema operacional para smartphones que foi desenvolvido
por Andy Rubin, Nick Sears e Chris White, o que começou com uma empresa
pequena e independente com foco em um sistema para câmeras, percebeu-se que
não havia muita demanda, e com isso mudaram seus projetos para disputar com
sistemas de mesma categoria, porem devido a falta de investimentos dificultava o
avanço do sistema, com projetos secretos o universo Android foi evoluindo a ponto
da empresa Google efetuar a compra do mesmo em 2005(GUIMARÃES, 2013), e
assim começaram a elaborar um software baseado no sistema Linux, o primeiro
aparelho com Android foi o HTC Dream G1 lançado em 2008 o que mostrou
inovação para a época, com barra de notificações, uma loja de aplicativos entre
outras funcionalidades, (MAIA, 2003). Hoje é um dos sistemas operacionais mais
utilizados nos smartphones e vem surgindo novos aplicativos que valorizam ainda
20
mais o Android devido a facilidade de manipulação do SO e a maior variedade de
componentes disponíveis no celular.
MIT App Inventor
O App Inventor é um ambiente de desenvolvimento de aplicativos online
para celulares com o sistema operacional Android. Ele foi criado pelo professor Hal
Abelson e uma equipe do Google Educação em 2010 (MIT APP INVENTOR, 2014).
Atualmente é administrado pelo MIT LABS (Massachussets Institute of Technology).
O App Inventor é um código aberto, de forma que qualquer pessoa pode utilizar para
criar um ambiente derivado (SANTOS, 2013).
O objetivo do App Inventor é tornar acessível à criação de aplicativos ao
público, visando a educação, de maneira que se tornou um sucesso para
educadores, alunos e pesquisadores. A facilidade de criação de aplicativos tanto na
parte gráfica quanto na parte de programação é um dos pontos fortes do App
Inventor, facilitando, assim, a utilização por aqueles que são leigos em programação.
O MIT vem melhorando cada vez mais a funcionalidade do App Inventor,
buscando expandir o universo de criação de aplicativos e incentivando a educação
de programação para o mundo todo (MIT APP INVENTOR, 2014). O App Inventor
está se tornando uma grande opção para programadores de Arduino, por se tratar
de uma ferramenta poderosa e de fácil acesso e entendimento. Com ela é possível
criar aplicativos para diversas funções. A partir disto, portanto, vem se tornando
simples a implementação de um sistema de automação residencial, utilizando
apenas um smartphone e a comunicação serial ou ethernet.
Ambiente de Desenvolvimento
Para o usuário ter acesso ao ambiente do App Inventor é preciso entrar no
site http://appinventor.mit.edu/explore/. É necessário, no entanto, ter uma conta no
Gmail para salvar os projetos criados. O MIT App Inventor oferece todo o tipo de
ajuda, desde vídeos à tutoriais de projetos de aplicativos, tudo isto de maneira
simples, facilitando a compreensão para aqueles que desejam se aventurar nessa
plataforma, bem como para aqueles que buscam uma alternativa para elaboração de
21
novos projetos. Na figura 9 reproduz-se a página inicial do ambiente App Inventor.
Nesta página é possível visualizar tutoriais, enviar dúvidas em fóruns, e ler sobre
diversos projetos e novidades no mundo do App Inventor.
Figura 9 - Pagina Inicial do App Inventor
Fonte: http://appinventor.mit.edu
O Ambiente é dividido em duas partes: Designer, que se destina à criação
gráfica; e Blocks destinado à programação em blocos. O App Inventor possui uma
forma bastante didática para a criação gráfica do aplicativo, de forma que nele é
possível criar botões, caixas de textos, inserir imagens entre outras utilidades, as
quais ampliam as opções de criação. Além disso, é possível interagir com diversos
componentes de um celular, como câmera, Bluetooth, acesso à web, e até mesmo a
utilização dos sensores do celular
O processo de criação da parte gráfica de um aplicativo é bastante
diversificado, de maneira que o usuário pode definir qualquer componente da parte
gráfica, como cor, tamanho de letras, fundo, inserção de imagens etc.
É importante neste processo de criação da parte gráfica nomear, ou seja,
inserir tags em cada objeto, assim facilitando a programação posteriormente. A
figura 10 demonstra a interface gráfica da etapa Designer do App Inventor.
22
Figura 10 - Criação Gráfica do Aplicativo
Fonte: http://appinventor.mit.edu
Na figura 10 observa-se as opções que os usuários têm como ferramentas
para criação gráfica, bem como as preferências de cores, tamanhos e imagens
Na área Blocks realiza-se a programação do aplicativo, de forma que são
inseridos os comandos que o aplicativo irá realizar. A programação é baseada na
linguagem C. Assim, utiliza-se blocos de lógica, de modo que usuário escolhe a
lógica que irá implementar em seu sistema, como componentes de controle, lógica,
matemática, texto, variáveis entre outros. Além disso, é possível interagir a lógica
escolhida com os componentes montados na área Designer. Abaixo, a figura 11
mostra a área Blocks.
23
Figura 11 - Blocos de Programação
Fonte: http://appinventor.mit.edu
Com o App Inventor é possível emular um celular com o sistema operacional
Android ou realizar testes com o próprio celular, apenas sendo necessário gerar um
arquivo apk (extensão dos aplicativos) após o término do aplicativo.
Para isso é necessário instalar no celular um aplicativo chamado MIT AI2
COMPANION que está disponível gratuitamente na Play Store, o aplicativo
desenvolvido pela MIT Center For Mobile Learning. Com este aplicativo é possível
baixar os projetos criados no App Inventor e testar no celular.
Após a criação da parte gráfica do aplicativo é feita a programação. O
usuário pode escolher emular um celular, sendo apenas necessário seguir as
instruções disponíveis no próprio site ou baixar o aplicativo. Caso optar pela última
opção, o site gerará um código do tipo QR, de forma que o aplicativo MIT AI2
COMPANION captará o código e automaticamente efetuará o download do
aplicativo. Na imagem 12 demonstra-se as opções para realizar testes do aplicativo,
disponíveis no site oficial (MIT APP INVENTOR, 2015).
24
Figura 12 – Opções de testes do MIT APP INVENTOR
Fonte: http://appinventor.mit.edu
2.3 COMUNICAÇÃO
A comunicação do Arduino com o aplicativo se dá via internet. Assim, é
necessário colocá-lo na mesma rede do aplicativo. A comunicação do
microcontrolador e a internet é feita com a adição de uma placa de expansão
chamada Ethernet Shield, que é responsável para a comunicação. Com isso é
possível enviar ou receber dados em qualquer parte do mundo com a conexão
internet (SARAFAN, 2015). Neste tópico demonstram-se o funcionamento do Shield,
bem como os componentes necessário para a comunicação com o aplicativo.
Ethernet Shield
Para a realização da comunicação do Arduino com a internet é necessário
adicionar uma placa, que torna possível a realização dessa comunicação. Para o
presente projeto utilizou-se o Ethernet Shield W5100. O Shield é encaixado em cima
do Arduino, sendo apenas necessário um cabo de rede e conectá-lo a um roteador.
25
A figura 13 demonstra como é a arquitetura de funcionamento do Arduino
com Ethernet Shield.
Figura 13 - Arquitetura de rede do Arduino
Fonte: Autor
O Shield é baseado no chip Wiznet W5100 que fornece um endereço IP
compatível com os protocolos TCP e UDP. Com ele é possível conectar o Arduino à
rede local ou até mesmo à internet para aquisição de dados. O Shield possui o
conector padrão RJ-45, e também possui um slot para cartão micro-sd que pode ser
utilizado para armazenar arquivos na rede (ARDUINO, 2015). Abaixo reproduz-se o
informativo sobre o Shield fornecido pelo próprio fabricante.
Tensão de Operação: 5V (Fornecido pela placa Arduino)
Controlador Ethernet: W5100 com buffer interno de 16K
Velocidade de Conexão: 10/100MB
Conexão com Arduino pela porta SPI
PWR: Indica que a placa Arduino e o Shield estão ligados
LINK: Representa a presença de uma ligação de rede e pisca quando
o Shield transmite ou recebe dados
FULLD: Indica que a conexão de rede é do tipo Full Duplex
100M: Demonstra a presença de uma ligação de rede 100Mb/s (em
vez de 10Mb/s)
RX: Indica quando o Ethernet Shield recebe um dado
26
TX: Responsável para indicação de transmissão de dados
COLL: Indica quando é detectado alguma colisão de rede
O Arduino se comunica com o W5100 e também por meio do cartão micro-
sd usando o barramento SPI (por meio do ICSP). Isto significa os pinos digitais 11,
12 e 13 no Uno e pinos 50, 51 e 52 no Mega. Nas placas, o pino 10 é usado para
selecionar W5100 e o pino 4 para o cartão-sd. Portanto, estes pinos não podem ser
usados como entradas e saídas gerais. No Arduino Mega, o pino 53 não é usado
para escolher o W5100 ou micro-sd, mas é necessário manter como saída ou a
interface SPI não irá funcionar (ARDUINO, 2015). A figura 14 mostra a ligação do
Arduino Uno com o Ethernet Shield
Figura 14 - Arduino com Ethernet Shield
Fonte: http://www.instructables.com
Roteador e Modem
Para obter maior mobilidade e facilidade para montagem e testes do projeto
utilizou-se um meio de comunicação com a internet mais prático, atendendo, assim,
todas as necessidades do projeto. Para isso utilizou-se o roteador 3g Wireless TL-
MR3020 da TP-LINK. Tal escolha justifica-se pelo fato de que utilizando um modem
3g é possível obter conexão com a internet e efetuar os comandos com o
smartphone, não sendo necessário nenhum tipo de configuração para realizar a
comunicação, sendo apenas necessário conectar com o Arduino e o Ethernet Shield.
Tudo isto acaba tornando ainda mais prática a comunicação com microcontrolador.
27
Na figura 15 apresenta-se o modem utilizado para comunicação com o roteador TL-
MR3020.
Figura 15 - Modem 3g Onda MSA190UP
Fonte: http://ondacommunication.com
Junto com o modem utilizou-se um roteador que permite a comunicação
Wireless para o funcionamento do projeto. O roteador utilizado é do modelo TL-
MR3020 da TP-LINK, porém é possível utilizar qualquer tipo de roteador sendo
apenas necessário conectar com o modem e configurando o Ethernet Shield, assim
possível compartilhar a internet via wireless. A figura 16 representa o modelo de
roteador utilizado para o projeto
Figura 16 - Roteador TP-LINK TL-MR3020
Fonte: http://www.tp-link.com.br
A facilidade de configuração do roteador da TP-LINK torna-se uma grande
opção. O site do fabricante apresenta as especificações completas do roteador e
seus recursos, mostrando a eficiência do modem. O tamanho menor comparado a
outros roteadores do mercado facilita para a montagem do projeto com o
microcontrolador sendo uma opção para quem deseja começar com projetos via
internet.
28
2.4 COMPONENTES
Neste tópico apresenta-se todos os componentes utilizados no projeto, bem
como suas especificações. Após a realização de pesquisas em sites, livros, artigos e
tutoriais optou-se por componentes que atendessem ao propósito e de forma
didática explica-se o seu funcionamento no projeto tanto na parte de iluminação
quanto na de temperatura.
Cooler
Para o projeto utilizou-se um cooler de 12 VDC para simulação de um
ventilador. Como visto no item 2.1.4 a corrente máxima que pode ser fornecida pelos
pinos do Arduino é de 40mA, todavia, como alguns motores exigem muito mais
corrente é necessário utilizar um resistor e um diodo para proteger o circuito. O
problema surge quando o motor entra em funcionamento, e, se por algum momento
ele é mandado parar, ele ainda continuará rodando devido à inércia, nesse tempo, é
gerada uma corrente contrária que pode danificar o Arduino (SILVA, 2012). A figura
17 mostra um modelo de cooler bastante utilizado em pequenos projetos, para
representação de ventiladores.
Figura 17 - Cooler de 12 volts
Fonte: http://www.sitroneletro.com.br
29
Diodo
O diodo é formado por uma junção de semicondutores do tipo N e do tipo P,
o semicondutor do tipo N possui elétrons livres, e no semicondutor do tipo P possui
lacunas (DEPARTAMENTO DE FISICA UFMG,2013). Da união desses cristais
ocorre uma recombinação surgindo um cristal neutro isolante entre os dois
semicondutores. Desta forma surge uma ddp entre os cristais chamada de barreira
de potencial.
O diodo permite que a corrente flua em um único sentido, assim inserindo no
circuito com a polaridade correta ele protege o circuito da corrente contraria gerada
pelo motor. Para evitar que a corrente contraria possa danificar o Arduino, no projeto
foi utilizado o diodo do tipo 1N4007 como mostra na figura 18.
Figura 18 - Modelo de Diodo
Fonte: https://arduinolivre.files.wordpress.com
Na figura 18 é possível identificar uma faixa cinza no diodo, ela indica o polo
negativo ou cátodo, e a outra parte preta indica o polo positivo ou ânodo. No diodo a
corrente circula do positivo para o negativo, e o polo negativo bloqueia a toda a
corrente contraria garantindo a segurança do circuito.
Transistores
O transistor é um componente eletrônico que possui 3 terminais feitos de
duas junções, a do tipo N e a do tipo P, seguindo o mesmo princípio do diodo,
formando o transistor tipo NPN e PNP. Ele é utilizado para poder controlar a corrente
que passa no circuito, de modo que o transistor é formado por duas camadas de
cristais semicondutores do mesmo tipo e entre elas outra camada, porém de tipo
30
diferente (SILVA, 2012). Na figura 19 exibe-se o transistor bem como sua
representação em circuitos.
Figura 19 - Representação do Transistor tipo PNP E NPN
Fonte: http://hyperphysics.phy-astr.gsu.edu
Como pode ser observado na figura 19, o transistor possui 3 terminais que
são a base, o coletor e o emissor. A camada do meio do transistor é responsável por
controlar o fluxo de corrente elétrica, é adicionado impurezas no transistor para o
componente se tornar mais ou menos condutor (PEREIRA, 2015).
Com isso para ter o controle da corrente que flui no motor é utilizado um
transistor do tipo TIP120 para realizar o chaveamento do motor, na figura 20 mostra
uma ilustração do transistor.
Figura 20- Ilustração de um Transistor
Fonte: https://i0.wp.com/www.nutchip.com
A figura 20 mostra os pinos do transistor, sendo B a base, C o coletor e pino
E emissor.
31
A base é ligada no pino digital do Arduino, o Coletor em dos terminais do
motor e emissor na terra (Ground). Aplicando uma corrente na base é possível
controlar a corrente entre o emissor e coletor (SILVA, 2012).
LM35
LM35 é um sensor de temperatura fabricado pela Texas Instruments, o qual
sua tensão de saída é linearmente proporcional a graus Celsius. Uma das vantagens
em relação aos demais sensores de temperatura calibrados em Kelvin é que o
usuário não é obrigado a subtrair variáveis para que se obtenha uma escala de
temperatura em graus Celsius (TEXAS INSTRUMENTS,2013). O LM35 é um dos
sensores de temperaturas mais utilizados para projetos com Arduino devido a sua
facilidade de programação.
Na figura 21 apresenta-se um dos modelos de LM35, bem como o utilizado
no projeto
Figura 21 - Representação de modelos de LM35
Fonte: http://pinout-circuits-images.dz863.com
Como citado nesta seção, por ser de fácil programação, muitos optam por
escolher este sensor. Ele possui 3 pinos: 1º pino de alimentação de 5 volts, 2º pino
de saída analógica e o 3º pino utilizado como terra (0 volts). Possui também um
range de -55ºC a 150ºC. O LM35 trabalha com a variação de tensão na saída
32
conforme a variação de temperatura, na qual sua taxa de variação é de 10mV para
cada 1ºC (TEXAS INSTRUMENTS, 2013). Para a leitura do sinal analógico o
Arduino necessita converter esse sinal para um valor conhecido, para isso ele utiliza
o conversor do Arduino que possui 10 bits de resolução. Considerando o cálculo de
resolução de conversores que será explicado na equação 1.
𝑉𝑟𝑒𝑓
2𝑛 (1)
Onde Vref seria a tensão de referência e n seria o número de bits do
conversor. No caso do Arduino a tensão de referência seria de 5 Volts e n seria 10.
Fazendo os cálculos chega-se ao seguinte resultado, como pode ser observado no
cálculo 2.
5 ÷ (210) = 5 ÷ 1024 = 0,00488 (2)
O resultado da equação 2 é a sensibilidade do conversor A/D o qual este
valor será utilizado posteriormente. O Arduino reconhece 1024 (0 a 1023), valores
entre 0 e 5V (WEBTRONICO, 2010),
Com isso fazendo uma simples regra de 3 é possível obter qual valor que
Arduino realmente vai ler e a tensão de sua saída, como 1ºC é 10mV assim na
equação 3 mostra o valor de leitura.
5𝑉 − 1023
0,01𝑉 − 𝑥 (3)
𝑉𝑎𝑙𝑜𝑟𝑙𝑖𝑑𝑜 = 10,23 ÷ 5 = 2,046
Observando resultado obtido, esse valor pode ser armazenado na variável
Valor_lido do tipo float, e assim esse valor armazenado é multiplicado pela
sensibilidade do sensor, porém é necessário fazer a correção do valor onde é
multiplicado por 100. E então a fórmula final para conversão do valor de saída
analógica do LM35 fica da forma como pode ser observado na equação 4 e 5.
(𝑉𝑎𝑙𝑜𝑟𝑙𝑖𝑑𝑜 × 0,00488) = (2,046 × 0,00488) = 0,00998448 (4)
(0,00998448 × 100) = 0,998448 (5)
Sendo assim a temperatura final detectada pelo sensor é de
aproximadamente 1ºC. No projeto o LM35 realiza a medição da temperatura, de
modo que ao atingir um setpoint definido o Arduino irá efetuar o controle de
temperatura ligando a ventilação até a temperatura abaixar (ARMELIN, 2011;
SEQUEIRA, 2013).
33
LED
No projeto utilizou-se LED’s para simulação de lâmpadas no interior da casa,
sendo estes controlados por meio do aplicativo criado e do Arduino, que recebe as
informações do aplicativo e com isso efetua o controle de iluminação de cada
cômodo da casa.
O LED vem sendo muito utilizado no lugar das lâmpadas incandescentes,
uma vez que é mais eficiente e utiliza pouca energia elétrica. LED vem da palavra
Light Emitting Diodes ou diodos emissores de luz (MOTISUKI, 2007). Como o diodo
o LED é bipolar, com dois terminais, o cátodo e o ânodo, e conforme a polarização
vai permitir ou não a passagem de corrente elétrica que resulta na emissão de luz
(UNILED, 2015). Ao contrário das lâmpadas do mercado, o LED não precisa de
filamentos metálicos, descargas de gases para o funcionamento (UTILUZ, 2015). Na
figura 22 tem-se representação do LED.
Figura 22 - Representação do LED
Fonte: www.instructables.com
34
3 METODOLOGIA E DESENVOLVIMENTO
Neste capítulo descreve-se a metodologia utilizada para elaboração do
projeto, por meio de testes iniciais aplicados no protótipo desenvolvido, simulando
situações que atendem as necessidades básicas de um morador que busca uma
tecnologia barata e eficiente de automação residencial.
3.1 METODOS DE CONTROLE E MEDIÇÃO
Inicialmente, pesquisou-se sobre a utilização do programa MATLAB para
aquisição de dados de um sensor de temperatura e um computador para realizar o
controle de iluminação. Obteve-se sucesso ao realizar a comunicação serial do
MATLAB com o microcontrolador, mas a dificuldade da programação tornou este
caminho um tanto complexo e como um dos objetivos do projeto é a simplicidade,
optou-se por encontrar outra forma de realizar esta etapa.
Na sequência foi estudada a possibilidade de criação de um aplicativo para
smartphones utilizando o ambiente MIT App Inventor, que possui uma grande
praticidade de montagem de aplicativos e diferentes métodos de comunicação com
o Arduino. Inicialmente efetuou-se a comunicação via bluetooth utilizando o módulo
HC-05 o mais utilizado para comunicações bluetooth com o Arduino. A figura 23
exibe o módulo utilizado.
35
Figura 23 - Módulo Bluetooth HC-05
Fonte: http://blog.roman-mueller.ch
Logo após foi montado em uma protoboard um circuito básico utilizando um
LED e um resistor em série ligados ao Arduino. Para a montagem do aplicativo
criou-se na parte gráfica do App Inventor 4 botões, sendo 2 deles responsáveis para
a conexão, de forma que um mostrava os dispositivos disponíveis para iniciar a
comunicação e outro botão para encerrar a comunicação. Já os outros 2 botões
ficaram para o controle da luz, liga ou desliga. Um projeto bastante simples, todavia,
somente surgiu dificuldade na realização da programação do aplicativo para fazer
com que ele se conectasse com o Arduino, pois foi necessário estudar sobre os
laços de controle do App Inventor. O principal problema de utilizar a comunicação
bluetooth é o alcance, que é inferior à comunicação Wifi, a segurança, a taxa de
dados entre outras limitações, consequentemente, optou-se por utilizar o método
Wifi, usando o Ethernet Shield. Ele é conectado ao Arduino e com isso um
smartphone ou um notebook conectado à mesma rede pode ter acesso aos dados
do Arduino, decidiu-se assim esta opção de comunicação a ser utilizada no projeto,
integrando a iluminação e a temperatura num mesmo aplicativo.
Para o sistema de temperatura realizaram-se testes iniciais com o termistor
NTC (Negative Temperature Coefficient). Seu funcionamento baseia-se na variação
da resistência, ao contrário do PTC (Positive Temperature Coefficient), se a
temperatura aumenta a resistência diminui (BRAGA, 2015). A ligação é simples,
conecta-se um resistor em um dos pinos do termistor, que se divide no pino GND e
uma entrada analógica do microcontrolador, e o outro pino do NTC conectado à
tensão de 5 Volts. A expressão utilizada para obtenção dos dados do sensor pode
ser observada na figura 24, e ela foi utilizada para a calibração do sensor, com o
36
comando Serial.print por meio da comunicação serial e por meio do monitor serial da
IDE obteve-se os valores de temperatura.
Figura 24 - Código utilizado para medição de temperatura com o NTC
Fonte: Autor
O NTC não é linear, e para converter a temperatura é necessário um
processo mais complexo, pois o termistor irá depender da resistência ligada a ele.
Desta forma, podem ocorrer variações, sendo necessário calibrar o sensor com as
temperaturas ambiente. Entretanto, é possível utilizar uma biblioteca do termistor
que realiza a conversão do valor lido pelo sensor em graus Celsius. A figura 25
mostra o sensor NTC utilizado para testes no projeto
Figura 25 - Termistor NTC
Fonte: http://www.eletrodex.com.br
Os resultados obtidos com o teste do termistor NTC foram positivos, porém a
dificuldade de conversão do valor lido, e da melhor resistência a ser utilizada,
motivaram a procura de outro método. Consultando tutoriais e exemplos de livros
sobre o Arduino, percebeu-se que o LM35 atendia melhor a proposta e que era o
sensor mais utilizado, tendo em vista que é um sensor linear e de fácil configuração
e funcionamento, não sendo necessário a calibração do sensor, apenas uma
conversão simples para graus Celsius.
37
Para o controle da ventilação do sistema analisou-se diferentes métodos de
controle de um motor de 12 volts para que ele realize a circulação do ar no ambiente
sem que danifique o Arduino. Encontrou-se um processo que utiliza o Motor Shield,
que funciona como um drive de potência, utilizando 2 CIs L293D e 1 CI 74HC595
(ARDUINO,2015). Esse Shield pode controlar até 4 motores de corrente contínua.
Baseia-se no CI L293D que é uma ponte H, onde ela pode efetuar controle do
sentido de giro do motor (LABORATORIO DE GARAGEM, 2012). O Shield é uma
ótima opção para quem deseja realizar controle de carros robôs, assim mostrando a
grande variedade de projetos que se podem fazer utilizando o Arduino. Este módulo
pode ser observado na figura 26.
Figura 26 - Motor Shield L293D
Fonte: http://playground.arduino.cc/Main/AdafruitMotorShield
Este Shield serve também como proteção do circuito contra a corrente
contraria do cooler. Nos testes realizados utilizando apenas o Uno R3 e o Motor
Shield obteve-se efeitos positivos, porém observou-se que para a utilização deste
Shield com o Ethernet não iria sobrar entradas suficientes para serem utilizadas para
o circuito de iluminação e temperatura. Isto porque o Shield utiliza pinos empilháveis
machos ao invés de fêmeas. Assim, foi necessário a utilização do Arduino Mega no
projeto, o qual possui muito mais entradas que o Uno, ou apenas utilizar o CI L293D,
aliado a modificações no projeto, porém a montagem do sistema ficaria mais
complexa e menos prática. O custo do Mega é mais elevado e visando uma forma
mais barata de automação, optou-se por outro método de controle do motor,
utilizando transistor TIP120 para tal controle, sendo que no protótipo ele iria realizar
o chaveamento do motor. Este método se mostrou funcional, atendendo aos
requisitos do projeto, junto com um diodo, garantindo a segurança do Arduino em
relação a corrente do motor.
38
3.2 DESENVOLVIMENTO DO PROTÓTIPO
Nesta seção, relatam-se todos os passos que foram realizados para a
montagem e programação do sistema de aquisição e controle, bem como o emprego
desse sistema para a automação residencial. Para uma aproximação à realidade,
utilizou-se uma casa em pequena escala feita de MDF, a fim de demostrar de forma
didática o funcionamento do sistema.
Funcionamento do protótipo
O princípio de funcionamento do sistema baseia-se no acionamento de luzes
de determinados cômodos representados na maquete de uma casa, do
monitoramento da temperatura ambiente, e respectivo controle automático e manual
de ventilação por meio de um setpoint definido na própria programação. Este
controle é feito via internet.
No aplicativo, ao clicar em iluminação o usuário é redirecionado a uma outra
tela com as informações de status das luzes dos cômodos da casa. O mesmo pode
acender ou desligar a luz de qualquer cômodo por meio do botão “ligar” ou “desligar”
respectivamente, e assim, atualizando o status do mesmo em torno de 1 segundo.
Ao clicar em temperatura/ventilação o usuário tem acesso à medição de
temperatura em graus Celsius e o controle manual do ventilador da casa. Esta
temperatura é atualizada a cada 1 segundo, e quando ultrapassa 25ºC o ventilador
entra em funcionamento automaticamente, parando somente quando esta
temperatura baixar. Também é possível realizar o acionamento manual desta
ventilação, independentemente da temperatura ambiente. Para isto, o usuário deve
selecionar o modo manual e assim efetuar o comando desejado. Nos próximos itens
será explicado cada etapa detalhadamente.
39
Iluminação
Inicialmente, para a iluminação, empregou-se a tecnologia do LED, a qual
por meio de uma página HTML, em que o Arduino é o servidor, é possível acender
ou apagar o LED remotamente. Para isto, foi encaixado o módulo Ethernet no
Arduino. Em seguida, realizou-se a conexão do LED com o módulo, sendo que o
pino ânodo foi conectado ao ground do Arduino e o pino cátodo foi conectado a um
resistor de 300 ohms, o qual é ligado ao pino digital do módulo Ethernet do
microcontrolador. A figura 27 mostra os detalhes desta montagem.
Figura 27 - Conexão LED no pino 6 e no GND do Microcontrolador
Fonte: Autor
Visando a realização de testes para a comunicação do Uno R3 com a
internet, inicialmente foi realizada uma simples programação em HTML dentro da
IDE do Arduino, gerando assim, uma página na qual é possível controlar o LED
conectado ao microcontrolador. Para isto, é necessário apenas compreender os
princípios básicos da programação HTML. A figura 28 apresenta o código utilizado
para este acionamento.
40
Figura 28 - Bloco Void Loop e a programação em HTML
Fonte: http://br.renatocandido.org
Pela análise do código da figura 28, percebe-se na linha 41 e 42 que essa
programação insere 2 links em uma página, escritos Ligar Led e Desligar Led e cada
um envia o comando “? ledon” e “? ledoff”, respectivamente. Nas linhas 50 e 55,
esses comandos são lidos pelo cliente para que seja possível que o servidor
entenda a instrução. Por meio do comando readString é verificado se existe no
endereço tais comandos e assim, o LED é ligado ou desligado (CANDIDO, 2013).
Para os testes é necessário abrir um navegador de internet e nele inserir o
IP configurado no Arduino. Ao acessar é possível verificar a página formatada de
acordo com a programação em HTML realizada na IDE e controlar a luz
remotamente por meio dos links da página.
41
Os resultados deste experimento foram positivos. Assim, foi refeita a
programação para que apenas mostre o status das luzes no ambiente, da
temperatura e da ventilação. Para o projeto foram colocados 5 LED’s em paralelo
conectados aos pinos 5, 6, 7, 8 e 9 do Arduino, utilizando o mesmo tipo de ligação.
Após isto, como explicado no item 2.3.2, para uma maior praticidade de
montagem do projeto foi utilizado o roteador TPLINK – TLMR3020 juntamente com o
modem 3g da Onda Communications (sendo necessário utilizar um chip 3g) para a
conexão do Arduino com a Internet. Para realizar esta comunicação é necessário
configurar o IP para que ambos estejam na mesma base. Assim, por exemplo, se o
IP atribuído pelo roteador é 192.168.1.1, o Ethernet Shield deve estar programado
com o IP 192.168.1.X, onde “X” tem que ser diferente de 1 e pode ir até 255. Para
isto, é necessário identificar o IP atribuído pelo Roteador.
Utilizando o DOS do Windows insere-se o comando ipconfig, o qual mostra
todas as configurações de rede, bem como Gateway padrão, máscara de sub-rede,
endereço IPv4, entre outras configurações. A figura 29 exibe as configurações do
roteador TLMR3020.
Figura 29 - Configurações do Roteador
Fonte: Autor
Como é possível observar na figura 29, o gateway padrão é 192.168.0.254.
Com este dado já é possível realizar a configuração do Arduino e a rede.
No Sketch primeiramente insere-se as bibliotecas para realizar a
comunicação do Shield com o Uno R3. Para isso utiliza-se a biblioteca SPI, que é
responsável por essa comunicação serial. A ligação é realizada pelos pinos
10;11;12;13. Como citado no tópico 1.1.4, sendo assim esses pinos ficam
impossibilitados de serem usados (ARDUINO,2015). Também é inserido a biblioteca
Ethernet para a comunicação com a internet, com a instrução #include <SPI.h> e
#include <Ethernet.h> inclui-se as bibliotecas no programa.
42
Em seguida, realiza-se as configurações de rede, inserindo-se o mac adress
e o IP. Para o mac adress é utilizado o comando byte mac, e nele é inserido um
código em hexadecimal que irá buscar automaticamente o endereço mac do shield.
Para a configuração do IP, como explicado, deve ser diferente do IP do
computador e do gateway padrão. Para o projeto foi utilizado o IP 192.168.0.150, em
seguida, utilizando o comando EthernetServer server (80), define-se a porta 80 do
roteador para a comunicação do Arduino com a Internet. A Figura 30 representa a
programação utilizada.
Figura 30 - Programação Utilizada para o teste do Ethernet Shield
Fonte: Autor
A figura 30 mostra, na linha 10, a instrução String readString que armazena
os caracteres que são recebidos um a um (CANDIDO, 2013), em seguida nas linhas
11-15 mostra a definição dos pinos que serão ligados aos LED’s com o comando int,
por ser um número inteiro, como por exemplo int sala = 6. Com essa instrução
define-se que o LED responsável pelo cômodo da sala está no pino 6. Após isso
declara-se também as variáveis booleanas para definição do status das luzes e
definição do modo automático ou manual descritos nas linhas 16-22, seguidos pela
definição do pino do sensor e do motor nas linhas 23 e 24.
A próxima etapa é a Void Setup. Aqui se inicia a comunicação do roteador
com o Shield e se define o modo de operação do pino em que está conectado aos
LED’s no microcontrolador como uma saída. Além disso, inicia-se a comunicação
com o Shield por meio do comando Ethernet.begin, que chama o endereço IP e o
Mac. Em seguida são iniciados o servidor e a comunicação serial, cuja velocidade é
43
9600 bits por segundo. Na figura 31, essas instruções são expostas no bloco Void
Setup. Este comando é padrão para utilização do módulo, somente desta forma será
feita a comunicação.
Figura 31 - Bloco Void Setup do circuito de Iluminação
Fonte: Autor
Na etapa Void Loop efetua-se o comando padrão de comunicação do
Ethernet onde, a cada caractere que é recebido pela placa é verificado se é um fim
de linha, assim, é enviada uma requisição para o cliente. Sendo bem-sucedida é
possível enviar a resposta, que será o cabeçalho HTTP padrão, o mesmo pode ser
observado na figura 32, este código também é padrão para a comunicação Ethernet
(CANDIDO, 2013).
Figura 32 - Iniciando requisição HTML
Fonte: Autor
Tomando por base a figura 33, após a configuração da página, realiza-se a
programação dos comandos de acionamento. Primeiramente, por meio do comando
readString efetua-se a leitura da barra de endereços pelo método GET, como pode-
44
se observar nas linhas 62 e 67. Caso a barra de endereços possua os comandos de
ligar ou desligar definido na programação, é efetuado seu acionamento (pelas linhas
64 e 67), ao mesmo tempo é atualizado seu status por meio da variável do tipo
booleana, como true ou false. A figura 33 mostra este comando sendo realizado.
Figura 33 - Exemplo de Acionamento do LED
Fonte: Autor
Utiliza-se o mesmo princípio para as demais luzes dos cômodos do
protótipo. Logo após, é feito o código para que o aplicativo identifique quais são os
status de cada luz. Empregando a variável booleana, caso seja verdadeira, é
enviado para aplicativo a indicação de ligado, caso seja falsa, indicará que está
desligado. O fluxograma da figura 34 representa o sistema de acionamento das
luzes do projeto.
45
Figura 34 - Fluxograma de processo de controle de luminosidade
Fonte: Autor
A figura 35 mostra o projeto no modelo final, demonstrando o funcionamento
do sistema de iluminação.
Figura 35 - Sistema de Iluminação do projeto
Fonte: Autor
A Figura 36 mostra o desenho da planta baixa, as lâmpadas foram
colocadas em cada cômodo e o ventilador na sala, para simulação da temperatura
optou-se por instalar o diretamente na placa de controle do sistema, localizada
46
externamente, entretanto em uma possível ampliação do projeto seria interessante
estar colocando um sensor em cada cômodo que possuir o ventilador.
Figura 36- Planta baixa da maquete e seus componentes
Fonte Autor
Temperatura
Após a realização de uma ampla pesquisa a fim de obter uma forma simples
para aquisição da temperatura ambiente, optou-se pelo o LM35 cujo funcionamento
e programação já foi explicado no item 2.4.4. A estabilidade de leitura do sensor é
um ponto forte deste dispositivo. O método de teste foi o seguinte: foi colocado um
objeto quente próximo do mesmo e verificou-se o aumento de temperatura por meio
do aplicativo. A figura 37 mostra o esquema de montagem do LM35 e do Arduino
utilizado no projeto, o sensor foi montado em uma placa de circuito impresso
obtendo a temperatura externa para simulação.
47
Figura 37 - Esquema de Ligação do LM35 no Arduino
Fonte Autor
Para o projeto foi conectado o pino +VS do sensor no pino de 5 Volts do
microcontrolador, em seguida o pino Vout no pino analógico A0, e o terceiro pino
conectado ao GND do Ethernet Shield. Para o processo de leitura e escrita o valor
da temperatura é declarado no início do programa como uma variável do tipo float
com o nome de “temperatura”, e em seguida, no bloco de função Void Loop, foram
feitos os cálculos para a conversão em graus Celsius, que pode ser observado pelo
código ilustrado na figura 38.
Figura 38 - Conversão do Valor lido pelo sensor em graus Celsius
Fonte: Autor
Analisando o código da figura 38 foi considerado uma variável int como
sendo o valor lido pelo sensor, referente à da temperatura. Para essa leitura aplica-
se o comando analogRead (0), onde “0” é a entrada analógica na qual o sensor está
conectado. Com isso a variável declarada como temperatura equivale ao resultado
da leitura do sensor multiplicado pela sensibilidade do conversor que é 0,00488, em
seguida, basta multiplicar esse resultado por 100, resultando no valor em graus
Celsius.
O envio da medição da temperatura ambiente para a intranet é um processo
simples. Para isto, foi utilizada a instrução “client.print” seguida da variável
temperatura, já convertida, essa instrução é responsável por enviar os dados ao
48
servidor que o cliente está conectado (ARDUINO, 2015). A atualização da leitura é
configurada na construção do aplicativo, que no caso, ocorre a cada 1 segundo.
Ventilação
Para a elaboração do mecanismo de ventilação optou-se por um cooler de
12 Volts para realizar a redução da temperatura. Como foi exemplificado no item
2.4.1 é necessário ter um cuidado especial ao comandar um motor via Arduino, pois
a corrente contrária gerada pela inércia do motor pode danificá-lo. Realizou-se o
projeto usando o transistor TIP 120, que funciona como chave no sistema,
controlando a corrente que flui no motor. A figura 39 exibe a representação desta
ligação.
Figura 39 - Esquema de ligação do motor DC com transistor TIP 120
Fonte: Autor
Como pode ser observado na figura 39, a ligação do motor ficou da seguinte
forma:
Foi utilizada uma fonte de 12 volts, onde o negativo foi conectado ao
ground do circuito, e o positivo conectado ao positivo do motor;
Conectado o cátodo do diodo juntamente com o pino coletor e o
negativo do motor, e o ânodo conectado ao pino emissor do TIP120 e
ele conectado ao ground;
Inserido um resistor de 1Kohms conectado a base do transistor e ao
pino PMW 3 do Arduino;
49
O acionamento do cooler foi definido da seguinte forma: quando estiver em
modo manual é possível controla-lo pelos botões de ligar e desligar do próprio
aplicativo. Caso esteja em automático, o acionamento do cooler é feito por meio do
“set de temperatura” quando a temperatura ultrapasse 25 °C, caso contrário, desliga.
A definição do status é feita pela instrução digitalRead, o qual efetua a leitura do
pino do motor que se estiver em nível logico alto define o status como true e indica
ventilação ligada, se estiver em nível logico baixo define como false, indicando
ventilação desligada.
O fluxograma da figura 40 ilustra o processo de controle de temperatura.
Figura 40 - Fluxograma do processo de controle de temperatura.
Fonte: Autor
3.3 APLICATIVO ANDROINO
Neste tópico, são apresentados os procedimentos realizados para a criação
do aplicativo intitulado de Androino para que numa possível ampliação de projeto
possa estar modificando suas funcionalidades, nome escolhido para demonstrar a
integração do Arduino com Android. Inicialmente, explica-se como foi criada a
50
interface gráfica na área Designer e em seguida as programações feitas na tela
Blocks e por fim as imagens do próprio aplicativo.
Interface Gráfica
O aplicativo intitulado de Androino foi desenvolvido visando um método
simples para o acionamento do Arduino. Na área Designer, para o menu principal,
criou-se 2 botões, utilizando a interface Buttom, sendo um denominado “Iluminação”
e o outro “Temperatura / Ventilação”. Cada botão leva à outra página, uma para
cada circuito. No layout empregou-se a cor branca de fundo. Além disso, os botões
foram dispostos de forma centralizada, possuindo tamanhos iguais, o que resultou
em uma interface simples. Na área Designer também se insere quais serão as
conectividades do aplicativo que são componentes não visíveis, implantando Web1
para realizar a comunicação com a internet que fornece funções do tipo HTTP GET,
POST, PUT (MIT APP INVENTOR). A figura 41 mostra o menu criado para o
aplicativo.
Figura 41 - Menu Principal do Aplicativo
Fonte: Autor
51
Para a parte gráfica do acionamento das luzes, para cada LED criou-se 2
botões, de ligar e desligar e embaixo mostrando o status seja desligado ou ligado.
Para a barra de status utiliza-se o textbox ajustado para os tamanhos desejados.
Nele foi escrito aguardando, para recebimento das informações, para a configuração
do textbox foi retirado o enable sendo assim não é possível escrever nele, ele
apenas recebe as atualizações do status dos LED’s por meio da variável booleana
do programa. Nessa tela é necessário inserir Web1 juntamente com o clock, no qual
é definido para que atualize a tela a cada 1 segundo. A figura 42 mostra a tela de
iluminação do aplicativo.
Figura 42 - Tela de Iluminação
Fonte Autor
Em seguida, para a tela de temperatura e ventilação foi colocado o textbox
para receber a temperatura lida. Nela não é possível escrever e é atualizada a cada
1 segundo, definido pelo clock. Sua leitura é feita pela quantidade de palavras que o
aplicativo recebe da página HTML gerada, cuja configuração é definida no modo
blocks. No modo de ventilação é possível escolher qual meio de controle será
utilizado, manual ou automático, cuja escolha é mostrada no visor. Neste modo,
também está presente os botões com as mesmas definições do acionamento dos
LED’s que são responsáveis pelo acionamento do motor. Entretanto, apenas em
modo manual. Logo abaixo dos botões é mostrado o status da ventilação que segue
52
o mesmo princípio utilizado no sistema de iluminação. Como visto, a criação desses
elementos gráficos é bastante simples, facilitado pela objetividade e simplicidade do
ambiente de desenvolvimento.
A figura 43 mostra a tela final do controle de temperatura do projeto, o
layout foi definido desta forma a fim de tornar o aplicativo mais dinâmico para o
usuário.
Figura 43 - Tela de Temperatura e Ventilação
Fonte: Autor
Lógica de Programação
A seção Blocks no App Inventor ficou separada de acordo com as telas
criadas na parte Designer. Nesta seção, cada componente criado na seção anterior
tem diversas funções na qual o usuário define qual vai ser utilizada, como por
exemplo, as instruções quando o botão é clicado, definições de variáveis, entre
outras funcionalidades. Um ponto importante na criação de um aplicativo é a
definição de tags para os componentes a fim de facilitar a programação.
O funcionamento completo do aplicativo é representado nos fluxogramas
das figuras 44 e 45.
53
Figura 44 - Fluxograma do processo do menu temperatura
Fonte: Autor
Como visto na figura 44, caso não possua nenhum comando é efetuado uma
nova leitura do status das variáveis, esse processo se dá pelo clock definido do App
Inventor, os comandos são por meio do método GET ou pelo envio de dados pela
barra de endereços, processo simples e bastante eficaz.
Na figura 45 é mostrado o fluxograma do menu de iluminação,
demonstrando um procedimento mais simples do que o menu de temperatura.
54
Figura 45 - Fluxograma do funcionamento do acionamento das luzes
Fonte: Autor
Na tela 1, referente ao menu inicial, utilizou-se a função when btn_luz click
do: open another screenName: Screen” em que btn_luz refere-se a tag do botão de
Iluminação. O Screen 2 é a tela referente ao circuito das luzes do cômodo, assim, ao
clicar no botão de iluminação, o aplicativo abre a tela correspondente. O
procedimento para abertura das telas de temperatura e ventilação é análogo.
Com relação à tela das luzes, a conectividade clock atualiza a página
definida pelo Web1, que chama o IP definido no programa e por meio do método
GET atualiza o status. De acordo com a figura 46 mostra o fluxograma de
programação da etapa Blocks, pode-se observar que para cada acionamento
realizado pelo usuário é utilizada a função When a qual define a ação do botão. Por
exemplo: quando for acionado o botão para ligar a luz da sala, definido pela tag
Btn_On_Sala, o aplicativo irá utilizar a função Web1 para escrever, na barra de
endereços, o comando configurado na programação referente ao acionamento da
55
luz, esta ação é dada pela função set web1.url, e pelo método GET, na sequência, o
Arduino efetua a leitura dessa string e realiza o acionamento.
Figura 46 - Código de Iluminação
Fonte: Autor
Para a atualização do status, o aplicativo pega como referência a página
HTML gerada pela programação feita na IDE. Ela é responsável pela comunicação
do Ethernet Shield com o aplicativo. Por meio da variável booleana o Arduino define
o status seja ele verdadeiro ou falso, com isso além do comando de acionamento ele
envia também o status para pagina. A figura 47 ilustra esta função.
56
Figura 47 - Programação do status das luzes
Fonte: Autor
A figura 48 mostra as principais funções, por partes utilizadas na
programação para definir o status da luz.
Figura 48 - Funções de controle
Fonte: Autor
Observando a figura 48, o aplicativo lê os dados da URL por meio da função
When.Web1.GotText demonstrada no item 1, que realiza uma instrução quando a
URL recebe um texto. Em seguida, a função evidenciada pelo número 2 if then
verifica se a função do bloco de número 3 contém o comando 1-On, caso seja
57
verdadeiro, o bloco if then efetua a ação mostrada no item 4, mudando o texto para
luz ligada.
A tela de Temperatura e Ventilação se tornou o procedimento mais
complicado do projeto, pois é necessária a interpretação dos dados que o Arduino
envia pelo aplicativo. Entretanto, o acionamento do motor, atualização do status e
definição do modo manual ou automático seguem o mesmo princípio do sistema de
iluminação.
A figura 49 mostra como é a estrutura da leitura de temperatura do Androino.
Figura 49 - Código de Temperatura e Ventilação
Fonte: Autor
Conforme a figura 49, inicialmente, é declarada uma variável temp para
receber o valor da temperatura. De forma análoga à leitura dos status (figura 48) é
utilizado o bloco de função When Web1.gotText, que definirá a variável temp como a
65ª palavra que a página recebe do Arduino, e com tamanho de 5 caracteres. Os
dados enviados do Arduino para a página HTML podem ser acessados por meio do
código fonte da página.
O Acionamento manual do ventilador segue o mesmo princípio utilizado para
os LED’s, ao clicar no botão envia-se a string para o Arduino, o qual efetua o
controle. O modo automático segue a programação realizada no microcontrolador de
acordo com o set de temperatura definido, ele aciona a ventilação e atualiza o
status. Quando o usuário seleciona o modo automático é definido a variável
booleana mode como verdadeira sendo assim, foi feito uma lógica que quando for
verdadeira e a temperatura for maior ou igual a 25ºC o ventilador liga, caso contrário
ele desliga, ao tentar realizar o comando manual, porém estando no modo
automático o comando não irá funcionar, pois estará intertravado pela linha de
58
automático, sendo necessário selecionar o modo manual e então assim o
acionamento manual irá funcionar, pois define a variável mode como falsa.
59
4 RESULTADOS E DISCUSSÕES
Neste capítulo, estão relatados os principais problemas encontrados para
realização do projeto, o comportamento dele após testes realizados e bem como
possíveis projetos futuros baseados no protótipo.
Após a realização de todos os procedimentos de configuração de rede, a
programação da lógica de funcionamento do sistema, bem como a criação do
aplicativo, realizaram-se os testes. Após a comprovação prática do funcionamento
do protótipo, transferiu-se o circuito da protoboard para uma placa de circuito
impresso.
Os primeiros testes realizados somente com o Ethernet Shield, não
apresentou tanta complexidade, pois o suporte dado via site do próprio fabricante
fornece ajuda suficiente para a implementação inicial de uma gama grande de
projetos. Para esta primeira etapa de testes também foram consultados alguns
artigos sobre a integração do Arduino com esta Shield. As primeiras dificuldades
encontradas estão relacionadas à escassez de material em português sobre a
comunicação do Ethernet Shield com os aplicativos criados no App Inventor. Nos
principais projetos encontrados utilizava-se o módulo bluetooth e os artigos em
inglês mostravam diferentes visões de controle. Por esta razão, tornou-se
necessário entender sobre os laços de controle utilizado pelo App Inventor e após
consultas em livros e artigos, foi possível obter uma melhor compreensão sobre o
funcionamento do software.
A simplicidade do programa contribuiu muito para a rapidez na elaboração
do software. Assim, após a compreensão do funcionamento do programa, a
elaboração da lógica de programação ocorreu de forma ágil e simples. Para realizar
a comunicação do aplicativo com o sistema é necessário ter um conhecimento
básico sobre os comandos em HTML, tendo em vista que a página programada no
Arduino é que irá realizar a ponte de comunicação com o aplicativo. No
microcontrolador, é possível programar páginas completas, usando o código HTML,
pois ele é integrado com o código utilizado pelo Uno R3 na etapa void loop. Para o
projeto foi feito uma simples programação apenas para visualização dos status das
luzes e a temperatura medida. Entretanto, é possível realizar o acionamento e
60
controle. Esta página pode ser visualizada inserindo o IP configurado no programa
em uma página de navegação.
No sistema de iluminação o principal problema está relacionado com o seu
acionamento. Desta maneira, utilizou-se o método que emprega o uso do parâmetro
GET que utiliza a instrução string, como comentado no item 3.2.2. Assim, ao apertar
o botão de ligar o LED, ele envia uma cadeia de caracteres e o comando readString
lê esse valor. Desta forma, é possível controlar a luz de qualquer ambiente. Esse
método se mostrou bastante eficaz, não apresentando problemas durante sua
construção.
Com relação ao funcionamento do sensor de temperatura e à leitura desses
dados é que apareceram as maiores dificuldades do projeto. No teste, utilizando
apenas o Ethernet Shield, a página programada efetuou as leituras corretamente. Os
testes foram realizados com a taxa de atualização entre 1, 2 e 5 segundos e obteve-
se sucesso, comprovando o funcionamento do sistema. Entretanto, o envio desses
dados ao aplicativo não ocorre da mesma forma, pois é necessário configurar o
tamanho da palavra que o textbox irá receber. Isto porque, no protótipo, ele envia os
dados referentes aos comandos de acionamento juntamente com a temperatura.
Assim, o aplicativo lia o valor do acionamento ao invés da temperatura, como por
exemplo: ao invés de ler “25ºC”, o aplicativo lia “3ON”, que seria o comando para
ligar a luz do cômodo 3. Como já mencionado, a dificuldade de encontrar material
com explicações claras e em português tornou esta etapa mais complicada.
Contudo, por meio das funcionalidades do App Inventor foi possível efetuar essa
correção.
Com relação ao código fonte da página HTML, com ele é possível identificar
quais são os dados que o Arduino envia. Com esta informação acessada, é possível
identificar o tamanho dos dados, bem como, a partir de qual dado o aplicativo vai ler.
Desta forma, como mencionado no item 3.3.2, insere-se esses valores no bloco
segment text, de forma que é feita a configuração da leitura do sensor. A figura 48
mostra essa configuração. O aplicativo teve alguns erros de leitura que foram
corrigidos, alterando o tamanho dos caracteres, e desta maneira, garantindo a leitura
correta.
Em relação ao acionamento do motor, no início do projeto houve certa
dificuldade a respeito do funcionamento, mas com os materiais disponíveis foi
possível entender melhor sobre como seria o acionamento do mesmo. A utilização
61
de apenas um transistor para realizar o controle do motor mostrou-se eficiente.
Utilizando um intertravamento, optou-se pela criação de um botão para modo
“automático” e outro para modo “manual”, a fim de selecionar qual estará ativo,
assim o usuário tem total controle do acionamento. Encontrou-se dificuldade nesta
etapa, pois foi necessário estudar o código e encontrar uma maneira de ativar um
modo e desativar outro.
A fim de encontrar uma maneira de fazer um aplicativo seguro, onde apenas
o morador da casa tenha acesso por meio de senha, pesquisou-se sobre formas de
inserir um componente “senha” no aplicativo. Para isto, verificou-se a necessidade
de utilizar a conectividade tinydb, que atuaria como um banco de dados do App
Inventor. Entretanto, como este processo é um tanto complexo e demandaria mais
tempo para sua implementação, optou-se por não o utilizar. Esta possibilidade ficou
elencada para possíveis projetos futuros.
Como o projeto focou a rede local do morador, só é possível realizar o
controle das variáveis se o mesmo estiver conectado à mesma rede. Foram
estudadas sobre possíveis modos de realizar o acionamento por meio de outra rede.
Assim, verificou-se que uma das maneiras mais comuns de fazer este tipo de
controle remoto é por meio de um servidor conectado ao Arduino ou por meio do uso
de um Shield GSM. Contudo, por ser um processo mais complexo e com o uso de
componentes com custo mais elevado, optou-se por não incorporar a ideia ao
projeto e deixá-la também como proposta para projetos futuros. Assim, esta
proposta futura juntamente com a possibilidade de inserção de senhas para
aumentar a segurança do sistema possibilitará ao usuário pode acessar dados de
sua casa, utilizando outra rede de internet ou uma rede GSM e com a segurança de
um sistema típico de senhas.
Para a implementação do sistema em um modelo real foi realizado um
levantamento dos custos, tomando por base uma casa que contém já as lâmpadas e
o ventilador montado, ficando apenas a montagem e a programação do sistema.
Estes custos foram comparados com os de uma empresa que também presta
serviços de automação residencial na cidade de Ponta Grossa. Entretanto, o sistema
apresentado pela empresa usa um sistema de alarme integrado, que no caso do
sistema apresentado, apesar de ser possível integrá-lo, optou-se por não o fazer.
62
No quadro 2 estão os custos aproximados, baseados em pesquisas via
internet, para uma implantação prática da automação residencial proposta por este
trabalho.
Equipamento Quantidade Valor Total
Arduino Uno R3 01 R$ 105,00 R$ 105,00
Ethernet Shield 01 R$ 34,21 R$ 34,21
Módulo Relê 6 canais 01 R$ 65,81 R$ 65,81
Cabo bicolor 1,50mm² Macrocabos (metro)
25 R$ 1,89 R$ 47,25
Sensor de Temperatura LM35 01 R$ 5,90 R$ 5,90
Roteador TP-Link MR3020 01 R$ 129,00 R$ 129,00
Modem 3G 01 R$ 28,86 R$ 28,86
Kit Jumper Macho/Macho 01 R$ 19,90 R$ 19,90
Mão de obra 01 R$ 150, 00 R$ 150, 00
Valor total da proposta R$ 585,93
Quadro 2 – Levantamento dos custos
Fonte: Autor
63
O quadro 3 mostra o orçamento feito pela empresa de Ponta Grossa para a
mesma situação com a adição de um sistema de alarme integrado.
Produto Quantidade Valor Total
Central de alarme EVO192 +
Teclado LCD K641 + Caixa metálica +
Trafo 16 V 1,5 Paradox
01 R$ 1.317,76 R$ 1.317,76
Módulo de comunicação IP150 Paradox 01 R$ 774,60 R$ 774,60
Bateria selada 12V 7A Moura 01 R$ 72,15 R$ 72,15
Placa montada com relé 05 R$ 16,65 R$ 83,25
Caixa universal Rossi 01 R$ 32,43 R$ 32,43
Cabo bicolor 1,50mm2 Macrocabos
(metro)
50 R$ 1,89 R$ 94,35
Mão de obra de instalação e
Programação
01 R$ 788,86 R$ 788,86
Valor total da proposta R$ 3.163,39
Quadro 3 – Orçamento de Central de Alarme e Acionamento remoto
Fonte: Motoral Distribuidora
Analisando os orçamentos, observa-se que a utilização do Arduino é a mais
acessível, equivalente a aproximadamente 20% do custo proposto pela empresa.
Ainda vale ressaltar que com o uso do Arduino é possível ampliar tornar o sistema
bem mais amplo e robusto, inserindo sensores de gases, alarmes, entre outros
módulos de controle, tudo isso de forma bem acessível, devido à grande quantidade
de projetos e exemplos livres presentes em livros, artigos e em sites dos fabricantes
e revendedores de componentes eletrônicos. O modelo da empresa mostra como o
preço da automação é elevado, e com isso muitas pessoas acabam por não aderir a
este modelo por achar desnecessário. E ainda, o sistema da empresa é fechado o
que é tendencioso a fazer com que o usuário dependa da empresa para possíveis
manutenções futuras.
64
5 CONCLUSÃO
Com a elaboração do presente projeto foi possível ter um melhor
entendimento sobre o funcionamento do microcontrolador Arduino, e de seus
periféricos, além de permitir observar a grande diversidade de aplicações que o
Arduino pode proporcionar no campo da automação. Neste sentido, é possível
expandir de projetos pequenos para o meio industrial, em pequenos acionamentos,
bem como sirenes, motores trifásicos e até na parte de sensoriamento, e
entendendo bem o funcionamento é possível realizar diversos tipos de controle.
O funcionamento do protótipo se mostrou bastante eficaz, atendendo as
expectativas, de maneira que é possível implementar em uma residência este
sistema, e em outros ambientes, como por exemplo um sistema de segurança para
acionamento do portão de uma garagem, alarmes entre outros.
No protótipo criado é possível constatar a comodidade adquirida ao
automatizar uma residência, tornando o ambiente agradável em relação à
temperatura. Além disso, estando o usuário dentro da casa pode verificar por meio
de seu smartphone se esqueceu a luz da garagem ligada, ou ventilador da sala
ligado, sem precisar sair do cômodo. Desta forma, diminui-se o consumo de energia
elétrica por meio da redução do uso. Isto demonstra a importância do sistema para a
geração de economia, combatendo o gasto desnecessário.
Ademais, a aplicação do protótipo em uma casa não é um processo de muita
complexidade, sendo apenas necessário criar uma central com o Arduino, e utilizar
relês para realizar tal acionamento.
O sistema utilizado para este projeto explorou grande parte das
funcionalidades do Arduino Uno R3, e para sua ampliação seria necessário a
utilização do Arduino Mega 2560, por possuir maior número de entradas e saídas.
Por isso, ao dimensionar o sistema, é necessário observar no projeto o número de
I/O que serão utilizados, pois alguns dos pinos o microcontrolador utiliza para
comunicação com o Shield, impossibilitando o uso dos mesmos no projeto. Em um
projeto mais amplo, o Uno só conseguirá atender as necessidades com a utilização
de uma Shield de entradas e saídas.
Se antes o uso de um sistema de automação envolvendo uma residência era
visto normalmente em filmes de ficção cientifica, hoje já é possível de ser aplicado
65
de uma maneira bastante simplificada e acessível, tornando o ambiente da casa
mais agradável, elegante e elevando o valor do imóvel.
Como já mencionado é possível aplicar este modelo na indústria, podendo
por exemplo: auxiliar na operação e manutenção de um equipamento com a criação
de um sistema supervisório no smartphone pelo App Inventor. Este método pode
tornar-se um elemento importante para o diagnóstico de falhas e acompanhamento
em áreas sem ser necessário depender de uma sala de controle para realizar o
comando de um motor. É importante destacar ainda que o App Inventor é gratuito, o
que já é um benefício em relação aos principais sistemas supervisórios existentes no
campo industrial. Este sistema pode ser implementado em locais em que o emprego
de PLC’s possa ser caracterizado um exagero para tal controle.
Este trabalho trouxe a percepção das variadas maneiras possíveis para a
realização de um controle integrado de qualquer sistema de forma simples e barata.
Nos dias atuais as empresas que prestam este tipo de serviço ainda o fazem de
forma muito onerosa para o usuário. Em oposição a este alto custo, utilizando-se
das ferramentas deste projeto é possível montar um esquema completo, englobando
segurança e praticidade à um custo relativamente mais baixo.
.
66
REFERÊNCIAS
ARDUINO. Arduino board UNO.,2014 Overview. Disponível
em:<http://www.arduino.cc/en/Main/ArduinoBoardUno>. Acesso em: 24 set. 2014.
ARDUINO. Ethernet Library.,2015 Disponível em:<
http://www.arduino.cc/en/reference/Ethernet>. Acesso em: 22 maio. 2015.
ARDUINO. Ethernet Shield., 2015 Disponível em:<
http://www.arduino.cc/en/Main/ArduinoEthernetShield>. Acesso em: 17 fev. 2015.
ARDUINO. Language Reference.,2015 Disponível em: <
http://www.arduino.cc/en/Reference/HomePage>. Acesso em: 10 maio. 2015.
ARDUINO. Motor Shield.,2015 Disponível em:<
http://playground.arduino.cc/Main/AdafruitMotorShield:>. Acesso em: 12 jun. 2015.
ARDUINO.SPI Library.,2015 A Brief Introduction to The Serial Peripheral Interface
(SPI). Disponível em: <http://www.arduino.cc/en/reference/SPI) >. Acesso em: 22
maio. 2015.
ARMELIN, Bruno. Leitura de temperatura (termômetro) com o Arduino e
comunicação serial: Construindo um termômetro e enviando a temperatura lida a
um computador, maio. 2011. Disponível em:<
http://centralavr.blogspot.com.br/2011/05/leitura-de-temperatura-termometro-com-
o.html>. Acesso em: 2 abr. 2015.
67
ASSOCIAÇÃO BRASILEIRA DE AUTOMAÇÃO RESIDENCIAL E PREDIAL.
Automação Residencial: Realidade Hoje! 2008. Disponível em: <
http://www.aureside.org.br/temastec/default.asp?file=concbasicos.asp>. Acesso em:
24 set. 2014.
BARROS, Tiago. Iniciando com Arduino. Tecnologia e Experiência do Usuário no
C.E.S.A.R, 2010. Disponível em:< http://techne.cesar.org.br/iniciando-com-arduino>.
Acesso em: 4 maio. 2015.
BRAGA, Newton. NTC., 2010 Disponível em:<
http://www.newtoncbraga.com.br/index.php/almanaque/1304-ntc.html>. Acesso em:
22 maio. 2015.
CANDIDO, RENATO. Acendendo um LED via Internet com Arduino e o Ethernet
Shield. Set.2013. Disponível em:< http://br.renatocandido.org/2013/09/acendendo-
um-led-via-internet-com-arduino-e-o-ethernet-shield/> Acesso em: 22 maio. 2015.
CIPRIANI, Jason. Revolv Smart Home Hub. Fortune, mar. 2014. Disponível em:
<http://tech.fortune.cnn.com/2014/03/26/review-revolv-smart-home-hub>.Acesso em:
24 set. 2014.
DEPARTAMENTO DE ENGENHARIA DE INFORMATICA ACADEMY. Processing-
Como Começar., Universidade de Coimbra, 2015. Disponível em:<
http://academy.dei.uc.pt/page/artigos/processing>. Acesso em: 4 maio. 2015.
DEPARTAMENTO DE FISICA UFMG. Diodo Semicondutor. Universidade Federal
de Minas Gerais, mar. 2013. Disponível em:
<http://www.fisica.ufmg.br/~labexp/roteirosPDF/Diodo_semicondutor.pdf>. Acesso
em: 30 maio. 2015.
68
EVANS, Martin; NOBLE, Joshua; Hochenbaum, Jordan. Arduino em ação.1 ed. São
Paulo: Novatec, ago. 2013.
FILHO, Daniel. Curso de Arduino: O que é Arduino?, 2012. Disponível em:<
http://www.robotizando.com.br/curso_arduino_hardware_pg1.php.>. Acesso em: 10
maio. 2015.
GUIMARÃES, Gleyser. A história do Sistema operacional Android.,
Departamento de Sistemas e Computação da Universidade Federal de Campina
Grande, ago. 2013. Disponível em:<
http://www.dsc.ufcg.edu.br/~pet/jornal/agosto2013/materias/historia_da_computacao
.html>. Acesso em: 06 out. 2015.
LABORATORIO DE GARAGEM. Tutorial sobre como utilizar motor DC com
L293D e Arduino., maio. 2012. Disponível em:<
http://labdegaragem.com/profiles/blogs/tutorial-de-como-utilizar-motor-dc-com-l293d-
ponte-h-e-arduino>. Acesso em: 22 maio. 2015.
MAIA, Felipe. A história de Andy Rubin, a mente por trás do Android. Olhar
Digital, março. 2013. Disponível em:< http://olhardigital.uol.com.br/noticia/quem-e-
andy-rubin-o-homem-que-deixa-o-android-anos-apos-te-lo-criado/33218>. Acesso
em: 06 out. 2015.
MIT APP INVENTOR. About us., 2015. Disponível em:<
http://appinventor.mit.edu/explore/about-us.html>. Acesso em: 23 set. 2014.
MIT APP INVENTOR. Designer and Block Editor.,2015. Disponível em:<
http://appinventor.mit.edu/explore/Designer-blocks.html>. Acesso em: 8 maio. 2015.
MOTITSUKI, Marcelo. O que é e como utilizar LED’s. São Paulo, 2007. Disponível
em: <http://autosom.net/artigos/led.htm>. Acesso em: 5 abr. 2015.
69
PEREIRA, Lilian. Dopagem Eletrônica. Info Escola., 2015. Disponível em:<
http://www.infoescola.com/quimica/dopagem-eletronica/>. Acesso em: 30 mar. 2015.
QUADROS, Daniel. Arduino- Afinal, o que é isso?, jun. 2011. Disponível em:<
http://dqsoft.blogspot.com.br/2011/06/arduino-afinal-o-que-e-isto.html>: Acesso em:
14 maio. 2015.
RIOS, Jefferson et al. Introdução ao Arduino. Universidade Federal do Mato
Grosso do Sul: Faculdade de Computação, Mato Grosso do Sul, 2012. Disponível
em: <http://www.academia.edu/5229813/Introdu%C3%A7%C3%A3o_ao_Arduino>.
Acesso em: 5 nov. 2014.
SANTOS. Sylvio. Introdução ao App Inventor. Programação Orientada a Eventos
em Celulares com Sistema Operacional Android. Departamento de Sistemas de
Informação. PUC Minas, nov.2013. Disponível em:<
http://www.dai.ifma.edu.br/~mlcsilva/aulassdist/Tutorial%20do%20App%20Inventor.p
df>. Acesso em: 5 nov. 2014.
SARAFAN, Randy. Arduino Ethernet Shield Tutorial., 2015. Disponível em:<
http://www.instructables.com/id/Arduino-Ethernet-Shield-Tutorial/. Acesso em: 17 fev.
2015.
SEQUEIRA, Ricardo. Arduino + LM35., jan. 2013. Disponível em:< http://ricardo-
sequeira.com/arduino-lm35/>. Acesso em: 5 abr. 2015.
SILVA, Clodoaldo. O Transistor de junção Bipolar. Clube da Eletrônica, Revisão
Novembro 2012, nov 2012. Disponível em:<
http://www.clubedaeletronica.com.br/Eletronica/PDF/Transistor.pdf>. Acesso em: 30
mar. 2015.
70
SILVA, Sillas. Controlando Motor DC pelo Arduino: Transistor e Diodo., jul.2012.
Disponível em:< https://arduinolivre.wordpress.com/2012/07/18/controlando-motor-
dc-pelo-arduino-transistor-e-diodo/>. Acesso em: 30 mar. 2015.
SILVEIRA, João. Experimentos com Arduino. Monte seus próprios projetos com
Arduino utilizando as linguagens C e Processing. 2. Ed, 2013. Disponível em:
<http://www.ordemnatural.com.br>. Acesso em: 4 maio. 2015.
TESLA MEMORIAL SOCIETY. Tesla Main Achievements. Disponível em:<
http://www.teslasociety.com/index.html:> Acesso em: 24 set. 2014.
TEXAS INSTRUMENTS. LM35 Temperature Sensor With Analog Output with 30
V Capability., Review E, 2015. Disponível em:<
http://www.ti.com/product/lm35?keyMatch=LM35&tisearch=Search-EN#descriptions>
Acesso em: 2 abr. 2015.
TP-LINK. Roteador Portátil Wireless N 3G/4G TL MR3020., 2015. Disponível em:<
http://www.tp-link.com.br/products/details/?model=TL-MR3020>. Acesso em: 18 fev.
2015.
UNILED. O que é LED?., Uniled Componentes Optoeletrônicos, São Paulo, 2015.
Disponível em: <http://www.uniled.com.br/o-que-e-led/>. Acesso em: 5 abr. 2015.
UTILUZ. CONHEÇA O LED. Caxias do Sul, 2015.Disponível em:<
http://www.utiluz.com/pt/oled>: Acesso em: 5 abr. 2015.
WEBTRONICO. ARDUINO+LM35: Como montar um termômetro, dez.
2010.Disponível em :< http://blog.webtronico.com/?p=57>. Acesso em: 2 abr. 2015.
