Download - Relatorio Smarthouse
ALEX SOUZA SILVA GABRIEL TORRES DA SILVA
GUILHERME CAVALCANTE DE MORAES E SILVA HERYK PRADO MARTINS
RAFAEL GIALORENÇO SGOBBI
SMARTHOUSE
SÃO CARLOS
2014
ALEX SOUZA SILVA
GABRIEL TORRES DA SILVA
GUILHERME CAVALCANTE DE MORAES E SILVA
HERYK PRADO MARTINS
RAFAEL GIALORENÇO SGOBBI
SMARTHOUSE
Trabalho de Conclusão de Curso apresentado ao Centro Paula Souza – ETEc Paulino Botelho para obtenção do título de Técnico em Mecatrônica. Professor Responsável: Frederico Jurgensen Junior.
Data da aprovação: __/__/2014.
_____________________________________________
Professor Unidade de Ensino
_____________________________________________
Professor Unidade de Ensino
_____________________________________________
Professor Unidade de Ensino
SÃO CARLOS
2014
DEDICATÓRIA
Aos nossos amigos, familiares e também aos professores que de alguma forma nos ajudaram e nos deram confiança para continuar e batalhar pelos nossos objetivos, e principalmente ao nosso grupo pelo empenho, comprometimento, união e amizade.
AGRADECIMENTOS
Primeiramente a Deus aos nossos familiares, que sempre nos apoiaram, e nos ajudaram a trilhar o caminho certo. À escola Etec Paulino Botelho pela oportunidade de um novo aprendizado, e todo suporte. A todos os amigos, que fizeram do curso ainda mais especial, e deixarão saudades. E aos nossos professores, que se dedicaram em nos passar um pouco de seus conhecimentos, orientações e conselhos.
RESUMO
Nosso projeto foi desenvolvido com base na “domótica”, uma tecnologia diretamente ligada ao ato de automatizar, ou seja, realizar ações rotineiras de uma residência de forma automática. O projeto consiste em automatizar uma residência (maquete). Nosso projeto é controlado através da internet, portanto é possível controlá-lo, ao ser conectado ao servidor, utilizando computadores, tablet, celulares que tenham conexão com a internet. Com o sistema pronto, é possível abrir o portão da garagem, lâmpadas, irrigação do jardim, ventilador, temperatura, umidade do ar, consumo de energia elétrica e o sistema de segurança (câmera e alarme). Todavia o projeto pode ser facilmente ampliado, tornando possível o uso de vários sensores, além da implantação de novas saídas, de acordo com cada necessidade.
Palavras chaves: automação, casa inteligente, tecnologia.
ABSTRACT
Our project was developed based on home automation, technology directly linked to the act of automating, that is, being controlled automatically. The project consists in automation of some of the residential areas. Much of our design is controlled through the internet, so it is possible control it by connecting to the server, using any type of device that has internet connection. Example: SmartPhone. With the system ready, you can control your garage door, lights, garden irrigation, fan, temperature, air humidity, consumption of electricity and the security system (camera and alarm). However the project can be easily expanded, making possible the use of several sensors, addition the implementation of new outlets, to suit every need.
Keywords: Automation, smart home technology.
LISTA DE ILUSTRAÇÕES
IMAGEM 1 - SISTEMA BIOLÓGICO VERSUS SISTEMA MECATRÔNICO ................................... 12
IMAGEM 2 - ARDUINOMEGA ......................................................................................... 15
IMAGEM 3 – TELA DO SOFTWARE DO ARDUINO .............................................................. 17
IMAGEM 4 – FRENTE DO ETHERNET SHIELD ................................................................... 21
IMAGEM 5 - SHIELD RELÉ ............................................................................................. 22
IMAGEM 6 - SINAL DE SAÍDA DE DADOS DO DHT11 ......................................................... 23
IMAGEM 7 - SENSOR DHT11 ....................................................................................... 24
IMAGEM 8 – SENSOR PIR ........................................................................................... 25
IMAGEM 9 -BUZZER ..................................................................................................... 25
IMAGEM 10 - SENSOR DE CORRENTE SCT013 .............................................................. 26
IMAGEM 11- REPRESENTAÇÃO DE PULSOS .................................................................... 27
IMAGEM 12 - MINI SERVO MOTOR SG90 ...................................................................... 28
IMAGEM 13 -MINI BOMBA ............................................................................................. 28
IMAGEM 14 - PLANTA DA MAQUETE .............................................................................. 30
IMAGEM 15 - BASE DA MAQUETE .................................................................................. 31
IMAGEM 16 - MONTAGEM DA MAQUETE ......................................................................... 31
IMAGEM 17 - FUNIL DO JARDIM ..................................................................................... 32
IMAGEM 18 - MAQUETE PRONTA SEM ACABAMENTO........................................................ 32
IMAGEM 19 - MAQUETE PRONTA ................................................................................... 33
IMAGEM 20 - TELA DO SISTEMA ONLINE ......................................................................... 67
IMAGEM 21 - MONTAGEM DO HARDWARE (FRITZING) ...................................................... 68
IMAGEM 22 - CIRCUITO IMPRESSO (FRITZING) ............................................................... 69
IMAGEM 23 - CIRCUITO IMPRESSO TRANSPORTADO PARA A PLACA ................................... 69
IMAGEM 24 - CORROENDO A PLACA COM ÁCIDO PERCLORETO ......................................... 70
IMAGEM 25 - PLACA CORROÍDA .................................................................................... 70
IMAGEM 26 - IMAGEM DETALHADA DA MAQUETE ............................................................. 71
IMAGEM 27 - IMAGEM DETALHADA DA PLACA .................................................................. 72
IMAGEM 28 - TELA DO SISTEMA DETALHADO .................................................................. 72
SUMÁRIO
INTRODUÇÃO ........................................................................................................... 9
1 OBJETIVOS ...................................................................................................... 10
1.1 Objetivos Específicos ............................................................................... 10
2 FUNDAMENTAÇÃO TEÓRICA ........................................................................ 10
2.1 Mecatrônica ............................................................................................... 10
2.3 Domótica.................................................................................................... 14
2.4 Plataforma De Desenvolvimento: Hardware Livre, ARDUINO................ 15
2.5 Software ..................................................................................................... 17
2.6 Linguagem de programação voltada para web ....................................... 18
2.6.1 HTML .................................................................................................................. 18
2.6.2 CSS ..................................................................................................................... 18
2.6.3 AJAX .................................................................................................................. 19
2.7 ETHERNET SHIELD W5100 ...................................................................... 19
2.8 Relé Shield ................................................................................................. 21
2.9 Sensor DHT11 ........................................................................................... 22
2.10 Sensor PIR ................................................................................................. 24
2.11 Buzzer Arduino.......................................................................................... 25
2.12 Sensor de Corrente SCT013 ..................................................................... 26
2.13 Servo Motor ............................................................................................... 27
2.14 Mini Bomba ................................................................................................ 28
3 PROJETO ......................................................................................................... 29
3.1 Desenvolvimento do Projeto .................................................................... 29
3.2 A Maquete .................................................................................................. 30
3.3 Programação ............................................................................................. 33
3.4 Confecção da Placa .................................................................................. 68
3.5 Desenhos detalhados ............................................................................... 71
4 CONSIDERAÇÕES FINAIS .............................................................................. 74
4.1 Ensaios ...................................................................................................... 74
4.2 Conclusão.................................................................................................. 74
4.3 Sugestões .................................................................................................. 74
BIBLIOGRAFIA ....................................................................................................... 75
9
INTRODUÇÃO
Desde a criação da roda (existem registros de que a humanidade já o utiliza
há mais de 7.500 anos), o homem sempre vem criando soluções para facilitar a sua
vida. Um dos aspectos que diferenciam os humanos de outras criaturas do reino
animal é a capacidade de lidar com situações de maneira criativa. Com a chegada
da computação ajudou a evoluir ainda mais a vida do ser humano deixando-a mais
rápida e eficiente. Agora você já se imaginou chegando em sua casa após um dia de
trabalho, com um simples clique em seu smartphone, preparar seu banho ligando a
hidromassagem, deixando a água com temperatura do seu agrado, ouvindo uma
música ambiente podendo controlar o volume e mudando de música com comandos
de voz, ao sair do banheiro, ligar o micro-ondas para esquentar o seu jantar, ligar e
desligar as luzes com o celular, seria ótimo não é mesmo. É um equívoco pensar
que tudo isso é pura imaginação, mas hoje temos algumas tecnologias para
transformar algum desses pensamentos em realizada. O sistema que antes era
utilizado exclusivamente nos ambientes corporativos das indústrias passou a ser
projetados e utilizados também nos ambientes domésticos. Com a ajuda da
domótica, que é uma nova tecnologia que consiste em um sistema único capaz de
controlar todos os ambientes de uma casa através de um celular, computador ou
outro dispositivo, podendo controlar a luminosidade do ambiente, som, segurança,
obter temperatura e a umidade, entre outras. Tudo isso é voltado para bem-estar e
conforto em uma residência.
10
1 OBJETIVOS
O desenvolvimento do projeto tem o objetivo de facilitar a vida de pessoas
que passam muito tempo ocupadas com a rotina diária e cansativa.
1.1 Objetivos Específicos
O projeto tem como principal finalidade de ser implantado em residências,
com ajuda da internet, onde será possível automatizar alguns ambientes,
controlando luzes, portão da garagem, ventilador entre outras também é possível
coletar informação de temperatura e consumo de energia, tudo em tempo real e em
qualquer lugar.
2 FUNDAMENTAÇÃO TEÓRICA
2.1 Mecatrônica
O nome vem da união das palavras “mecânica” e “eletrônica”, e de fato, a
mecatrônica é a união da tecnologia mecânica com a eletrônica, com um pequeno
toque de informática.
Segundo o Comitê Assessor para Pesquisa e Desenvolvimento Industrial da
Comunidade Europeia (IRDAC), "Mecatrônica é a integração sinergética da
engenharia mecânica com a eletrônica e o controle inteligente por computador no
projeto de processos e de manufatura de produtos". Dessa forma, a mecatrônica
enfatiza o gerenciamento e o controle da complexidade dos processos de indústrias
que exigem ferramentas sofisticadas para gerar em tempo real seus diversos
processos integrados.
A mecatrônica já está sendo considerada ciência e com ela podemos
automatizar diversos processos manuais, ou até mesmo melhorar outros. Como
envolve a mecânica, ela está diretamente ligada à hidráulica e pneumática.
Uma de suas grandes vantagens são a versatilidade, e a combinação de
processos mecânicos com eletrônicos abre um grande leque de possibilidades e
11
utilização em diversas áreas, principalmente na indústria. E é claro que não
podemos esquecer a robótica.
Um engenheiro, ou técnico, mecatrônico tem uma boa escolha de onde, e
com o que, trabalhar, ainda mais com o mercado em expansão. Engenheiros
mecatrônicos podem até mesmo servir como um trunfo: antes onde era necessário
um mecânico e um eletrônico, agora podem ser substituídos por apenas um
mecatrônico, o que faz determinadas empresas preferirem contratar um
engenheiro/técnico dessa área.
A atuação no mercado de trabalho é normalmente em indústrias,
automatizando processos, melhorando outros ou com a manutenção das máquinas.
Alguns podem até ser mais ousados, ou espertos, e não se limitar a isso: eles
próprios decidem criar suas máquinas, mecanismos, dispositivos, etc. Criando-se
algo realmente necessário e útil, pode fazer o Engenheiro/técnico vender sua ideia
por muito dinheiro!
12
Imagem 1 - Sistema biológico versus sistema mecatrônico (Fonte: www.ebah.com.br/content/ABAAAAT88AA/apostila-robotica )
2.2 Automação
Resumidamente automação é sistema de aplicações técnicas,
computadorizadas, ou mecânicas, que diminui a mão-de-obra e aumenta a
produtividade, reduzindo custos e mais eficaz principalmente numa linha de
produção.
Também pode ser definida como um conjunto de técnicas que podem ser
aplicadas sobre um processo objetivando torná-lo mais eficiente, ou seja
maximizando a produção com menor consumo de energia, menor emissão de
resíduos e melhores condições de segurança, tanto humana e material quanto das
informações inerentes ao processo.
A automação pode ser dividida em alguns ramos principais:
Automação industrial - A automação industrial de uma máquina/processo
consiste essencialmente em escolher, de entre as diversas tecnologias que se
13
encontram ao nosso dispor, as que melhor se adaptam ao processo a desenvolver e
a melhor maneira de as interligar para garantir sempre a melhor relação
custo/benefício. A automação industrial é normalmente dividida em 3 níveis:
Nível de Campo - constituído pelos elementos a controlar (ex:Motores) e
pelos elementos de detecção (ex:Sensores)
Nível de Controlo - Como o próprio nome indica, é o nível onde se encontram
os elementos que vão controlar o processo (ex: Autómatos)
Nível de Supervisão - É composto pelos programas de interface homem-
máquina e aquisição de dados (este Outro ponto importante quando se faz a
automação de uma máquina/processo é pensar no futuro, pensar que as
funcionalidades iniciais de uma máquina/processo, na maioria dos casos,
podem estar muito longe das que esta vai ter no futuro.
Automação comercial - Ramo da automação onde ocorre a aplicação de
técnicas específicas na otimização de processos comerciais, geralmente utilizando-
se mais software do que hardware, tais como: sistemas controle de estoques, contas
a pagar e receber, folha de pagamentos, identificação de mercadorias por códigos
de barras ou por rádio frequência RFID, etc.
Automação Residencial - Aplicação das técnicas de automação para
melhoria no conforto e segurança de residências e conjuntos habitacionais, tais
como: Controle de acesso por biometria, porteiro e portões eletrônicos, circuitos
Fechados de Televisão (CFTV), controle de luminosidade de ambientes, controle de
umidade, temperatura e ar condicionado (HVAC), etc.
Atualmente, a automação está presente em diferentes níveis de atividades do
homem, desde as residências, no trânsito, através de sistemas de controle de
tráfego e sinalização, nos edifícios comerciais, processos de compra, venda e
transporte de bens, processos industriais primários e secundários, e até nas
jornadas espaciais.
14
2.3 Domótica
Domótica é uma tecnologia recente e é responsável pela gestão de todos os
recursos habitacionais. Este termo nasceu da fusão da palavra “Domus” (latim), que
significa casa, com a palavra “Robótica”, que está ligada ao ato de automatizar, isto
é, realizar ações de forma automática.
Esse conceito de automação, vem no seguimento de encontrar soluções que
deem respostas à necessidade do homem de querer realizar o mínimo esforço nas
atividades diárias e rotineiras. Assim a domótica, para além de introduzir conforto e
melhoria de vida aos seus utilizadores, introduz ainda novos conceitos, tais como
comunicação e segurança.
Naturalmente que este melhoramento de vida e comodidade apenas se
consegue associando tecnologia. Mas também importante é que a utilização dessa
tecnologia seja fácil ao utilizador comum.
A domótica consegue ir de encontro a essa linha de raciocínio, tendo dado
grandes passos para melhorar a vida do ser humano.
Apesar de ainda ser pouco conhecida e divulgada, pelo conforto e
comodidade que pode proporcionar, a domótica promete vir a ter muitos adeptos
face ao crescimento de projetos com estas soluções de automatização.
A domótica utiliza e associa as vantagens dos meios eletrônicos e
informáticos, de forma a obter uma utilização e uma gestão integrada dos diversos
equipamentos de um edifício, quer seja residencial ou comercial. Para o
manuseamento do sistema poderá fazê-lo de acordo com as suas próprias
necessidades ou poderá optar por um manuseamento mais ou menos automático.
No funcionamento passivo, um elemento reage só quando lhe é transmitida
uma ordem, dada diretamente pelo utilizador, utilizando por isso os recursos
disponíveis: botão de pressão, painéis tácteis, telecomandos.
No funcionamento automático, mais avançado e com mais inteligência, o
sistema não só interpreta parâmetros, como reage às circunstâncias (informação
que é transmitida pelos sensores), por exemplo, detectar que uma janela está aberta
e avisa o utilizador, ou que a temperatura está a diminuir e ligar o aquecimento.
Por fim, a facilidade do controle remoto e do acesso às funções vitais da casa,
através da Internet ou do celular deixa de ser uma utopia para ser uma realidade dos
nossos dias.
15
Os benefícios de ter Domótica em sua casa com valências modernas e
eficazes, além de estar a aumentar o seu nível de conforto está a valorizar o seu
empreendimento, quer como construtor para vender ou no mínimo ter uma pré-
instalação que permite oferecer essa opção aos seus residentes. Os predicados da
domótica permitem que a sua casa seja:
Mais moderna;
Mais prática e fácil de usar;
Mais fácil de controla;
Mais econômica energeticamente;
Mais segura.
2.4 Plataforma De Desenvolvimento: Hardware Livre, ARDUINO
Imagem 2 - ArduinoMega (Fonte: www.arduino.cc )
O que é arduino?
Arduino é uma plataforma de prototipagem eletrônica open source (o
software, hardware e todo material são livres), criado por Massimo Banzi e David
Cuartielles em 2005 com objetivo de permitir o desenvolvimento de controle de
16
sistemas interativos, de baixo custo e acessível a todos. O projeto foi criado
pensando em artistas e amadores, ou seja, não é necessário ter conhecimentos
prévios em eletrônica ou programação para iniciar-se no mundo Arduino.
Com o Arduino é possível também enviar e receber informações de
praticamente qualquer outro sistema eletrônico. Existe diversos modelos de arduino,
como o arduinoduemilanove, arduinomega 2560.
Arduino mega 2560
O ArduinoMega 2560 é uma placa de micro controlador baseada no
ATmega2560 (datasheet). Ele possui 54 pinos de entradas/saídas digitais, 16
entradas analógicas, 4 UARTs (portas seriais de hardware), um oscilador de cristal
de 16 MHz, uma conexão USB, uma entrada de alimentação, uma conexão ICSP e
um botão de reset. Ele contém tudo o que é necessário para dar suporte ao micro
controlador; basta conectar a um computador com um cabo USB ou a uma fonte de
alimentação e já está pronto para começar. O mega é compatível com a maioria dos
shields desenhados para os Arduino Uno, Duemilanove e para o Diecimila. Possui
ainda o dobro de memória do antigo ArduinoMega.
Especificações técnicas
MicrocontroladorATmega1280
Tensão de funcionamento 5V
Tensão de entrada (recomendado) 7-12V
Tensão de entrada (limites) 6-20V
Digital I / O pins 54 (dos quais 15 oferecem saída PWM)
Pinos de entrada analógica 16
Corrente DC por I / O Pin 40 mA
Corrente DC 3.3V para Pin 50 mA
Memória Flash 128 KB dos quais 4 KB usados pelo bootloader
SRAM 8 KB
EEPROM 4 KB
Velocidade do relógio 16 MHz
17
2.5 Software
Quando tratamos de software na plataforma do Arduino, podemos referir-nos:
ao ambiente de desenvolvimento integrado do Arduino e ao software desenvolvido
por nós para enviar para a nossa placa. O ambiente de desenvolvimento do Arduino
é um compilador gcc (C e C++) que usa uma interface gráfica construída em Java.
Basicamente se resume a um programa IDE muito simples de se utilizar e de
estender com bibliotecas que podem ser facilmente encontradas. As funções da IDE
do Arduino são basicamente duas: Permitir o desenvolvimento de um software e
enviá-lo à placa para que possa ser executado. O software pode ser baixado
diretamente do site arduino.cc, por ser open source, é gratuito.
Imagem 3 – Tela do Software do Arduino (Fonte: www.codingcolor.com)
18
2.6 Linguagem de programação voltada para web
2.6.1 HTML
HTML é uma das linguagens que utilizamos para desenvolver websites. O
acrônimo HTML vem do inglês e significa Hypertext Markup Language ou em
português Linguagem de Marcação de Hipertexto.
O HTML é a linguagem base da internet. Foi criada para ser de fácil
entendimento por seres humanos e também por máquinas, como por exemplo o
Google ou outros sistemas que percorrem a internet capturando informação.
2.6.2 CSS
CSS é o acrônimo de Cascading Style Sheets que em português seria algo
como “folhas de estilo em cascata”. É uma especificação que define como os
elementos que compõem uma página, um documento ou aplicação Web serão
exibidos.
Quando falamos de acessibilidade, performance e manutenção, tem-se como
princípio fazer separação do conteúdo, da interatividade e da apresentação de um
site ou aplicação web. O CSS desempenha um grande papel na camada da
apresentação.
A forma certa de publicar um documento web é seguindo uma estrutura
semântica. O CSS traz toda a informação do layout, isto é, cores, posicionamento,
fontes, tamanhos e imagens de fundo, enquanto o HTML deve fornecer uma
“arquitetura” para o conteúdo. O suporte a CSS pelos navegadores de hoje é bem
sólido, mas teve um início tímido, sendo inicialmente suportado pelo navegador
Netscape. A primeira versão da especificação foi lançada em 1996 e uma segunda
versão publicada em 1998 mas até 2009 nem todos os navegadores em uso
suportavam plenamente seus recursos. Uma nova versão da especificação está em
desenvolvimento e felizmente os navegadores mais recentes já estão testando-a.
Como o navegador Internet Explorer demorou a suportar todos os recursos do
CSS, web developers e web designers utilizavam tabelas para montar a estrutura
das páginas e toda a informação de estilo ficava junto do conteúdo. Com a melhoria
das velocidades de internet (em tempos de conexão discada), foi possível adotar
19
layouts mais complexos e modernos, ainda usando tabelas. Criou-se um mito de que
projetos utilizando CSS eram muito simples, limpos e” quadrados”. Este mito foi
desvendado quando outros navegadores entraram em uso e o suporte às novas
especificações foi implementado no Internet Explorer. Outro fator que contribuiu
muito para a adoção das novas tecnologias para CSS foi o crescimento no uso de
internet mobile em que as páginas precisam ser leves e o conteúdo apresentado de
forma correta em diferentes dispositivos, o que não seria possível com tabelas.
2.6.3 AJAX
AJAX é acrônimo em língua inglesa de "Asynchronous Javascript and XML",
que em português significa "Javascript e XML Assíncronos". Designa um conjunto de
técnicas para programação e desenvolvimento web que utiliza tecnologias como
Javascript e XML para carregar informações de forma assíncrona.
O desenvolvimento em AJAX permite a criação de páginas mais criativas e
com maior interação com o usuário. A sua utilização foi importante para a criação do
conceito Web 2.0. que tornou a experiência do usuário mais interessante e
proveitosa.
Alguns serviços do Google como o Gmail, Google Earth e Google Maps
fazem uso das ferramentas AJAX.
Ao usar AJAX no desenvolvimento de serviços para web, a informação é
carregada de maneira mais simples e precisa. O usuário não precisa aguardar que a
página seja totalmente recarregada quando faz uma requisição, pois o servidor só
irá retornar os dados relevantes, reduzindo o tráfego de dados pela rede.
2.7 Ethernet Shield W5100
O Arduino Ethernet Shield conecta o Arduino à internet em poucos
minutos. Basta ligar este módulo a sua placa Arduino, conecte-o à sua rede com
um RJ45 (cabo) e seguir algumas instruções simples para começar a controlar
através da internet. Como sempre acontece com Arduino, cada elemento da
plataforma - hardware, software e documentação - está disponível gratuitamente e
de código aberto. Isso significa que você pode saber exatamente como ele é feito e
usar o seu projeto como ponto de partida para os seus próprios circuitos.
20
O Arduino Ethernet Shield baseia-se na Wiznet W5100chip de ethernet. Ele
suporta até quatro conexões de soquete simultâneas. O escudo ethernet conecta a
uma placa Arduino usando fios de finalização longos que se estendem através do
escudo. Isso mantém a pinagem intacto e permite que outro escudo possa ser
empilhado em cima.
A mais recente revisão da placa expõe a pinagem 1.0 em rev 3 da placa
Arduino UNO.
Há um slot para cartão micro-SD de bordo, que pode ser usado para
armazenar arquivos para servir através da rede. É compatível com a Arduino Uno e
mega. O leitor de cartão microSD é acessível através da Biblioteca SD.
O escudo também inclui um controlador de reposição, para garantir que o
módulo Ethernet W5100 seja redefinida corretamente em alta voltagem. O escudo
atual tem um poder Ethernet (mais PoE módulo) projetado para extrair energia a
partir de um cabo Ethernet convencional par trançado.
Características:
Requer uma placa Arduino
5V Tensão de operação
Controlador Ethernet: W5100 com buffer interno 16K
Velocidade de conexão: 10/100 Mb
Conexão com o Arduino na porta SPI
Baixa ondulação de saída e ruído (100mVpp)
O Arduino se comunica tanto com o W5100 e o cartão SD usando o
barramento SPI. Esta é nos pinos digitais 10, 11, 12 e 13 no Uno e pinos 50, 51 e 52
sobre os mega. Em ambas as placas, pino 10 é usado para selecionar o W5100 e o
pino 4 para o cartão SD. Estes pinos não podem ser utilizados. Sobre os mega, o
pino SS hardware, pino 53, não é usado para selecionar o W5100 ou o cartão SD,
mas deve ser mantido como uma saída ou a interface SPI não vai funcionar.
Com o compartilhamento de W5100 e SD card do barramento SPI, somente
um pode estar ativo de cada vez. Se você estiver usando ambos os periféricos em
seu programa, eles devem ser cuidados pelas bibliotecas correspondentes. Se você
não está usando um dos periféricos em seu programa, no entanto, você vai precisar
para desmarcá-la explicitamente. Para fazer isso com o cartão SD, coloque o pino 4
como uma saída e escrever uma alta para ele. Para o W5100, definir pino digital 10
como uma saída de alta.
21
O Ethernet Shield utiliza das seguintes portas do arduino:
Porta 0 e 1 - TX e RX
Porta 4 - Comunicação Micro SD
Porta 10 - é usado para selecionar o W5100
Porta 11 - bus SPI (através do ICSP)
Porta 12 - bus SPI (através do ICSP)
Porta 13 - bus SPI (através do ICSP)
Imagem 4 – Frente do Ethernet shield ( Fonte: www.arduino.cc )
2.8 Relé Shield
O Shield Relé é um módulo compatível com Arduino, possui 4 relés
mecânicos que fornecem uma maneira fácil de controlar altas tensões. O shield relé
pode ser controlado diretamente pelo Arduino.
Funcionamento:
Alimente com tensão positiva 5VDC o pino VCC e ligue o GND ao terra
(Comum/Negativo).
22
O Módulo possui quatro entradas: IN1, IN2, IN3 e IN4 cada uma controla um
relé, e para aciona-lo, basta aplicar um pulso de nível TTL (5V) na entrada
correspondente ao relé desejado.
Imagem 5 - Shield relé (Fonte: www.msseletronica.com)
2.9 Sensor DHT11
O DHT11 é um sensor de temperatura e umidade que permite fazer leituras de
temperaturas entre 0 a 50 Celsius e umidade entre 20 a 90%, muito usado para projetos
com Arduino.
O elemento sensor de temperatura é um termistor do tipo NTC e o sensor de
Umidade é do tipo HR202, o circuito interno faz a leitura dos sensores e se comunica a um
microcontrolador através de um sinal serial de uma via.
Especificações:
Modelo: DHT11
Faixa de medição de umidade: 20 a 90% UR
Faixa de medição de temperatura: 0º a 50ºC
Alimentação: 3-5VDC (5,5VDC máximo)
Corrente: 200uA a 500mA, em stand by de 100uA a 150 uA
Precisão de umidade de medição: ± 5,0% UR
Precisão de medição de temperatura: ± 2.0 ºC
Tempo de resposta: 2s
23
Imagem 6 - Sinal de saída de dados do DHT11 ( Fonte: www.filipeflop.com)
Especificações:
Modelo: DYP-ME003 (datasheet)
Sensor Infravermelho com controle na placa
Sensibilidade e tempo ajustável
Tensão de Operação: 4,5-20V
Tensão Dados: 3,3V (Alto) - 0V (Baixo)
Distância detectável: 3-7m (Ajustável)
Tempo de Delay: 5-200seg (Default: 5seg)
Tempo de Bloqueio: 2,5seg (Default)
Trigger: (L)-Não Repetível (H)-Repetível (Default: H)
Temperatura de Trabalho: -20 ~ +80°C
Dimensões: 3,2 x 2,4 x 1,8cm
Peso: 7g
24
Imagem 7 - Sensor DHT11(Fonte: www.mlb-s2-p.mlstatic.com)
2.10 Sensor PIR
O Sensor de Movimento PIR DYP-ME003 consegue detectar o movimento de
objetos que estejam em uma área de até 7 metros! Caso algo ou alguém se
movimentar nesta área o pino de alarme é ativo.
É possível ajustar a duração do tempo de espera para estabilização do PIR
através do potenciômetro amarelo em baixo do sensor bem como sua sensibilidade.
A estabilização pode variar entre 5-200 seg.
Conecte uma fonte de 5v ao GND e VCC. O pino DADOS refere-se ao sinal
de saída que será 'Alto' indicando movimento ou 'Baixo' indicando nenhuma
movimentação.
Quando a saída é acionada pelo movimento detectado esta ficará em alto por
um curto período de tempo, mesmo se não haja mais movimento. O tempo em alto
pode ser setado variando o potenciômetro 'Time', sendo que o outro altera a
sensibilidade.
25
Imagem 8 – Sensor PIR (Fonte: www.filipeflop.com)
2.11 Buzzer Arduino
O buzzer um pequeno alto-falante alimentado com tensão de 5 volts, capaz
de emitir sons em diversas frequências. O buzzer é normalmente usado em projetos
que necessitam de avisos sonoros, relógios com alarme, e até para reproduzir
músicas.
O primeiro pino do buzzerarduino é o positivo, o segundo pino é a saída de
sinal e o terceiro pino é o negativo.
Imagem 9 - Buzzer (Fonte: www.dx.com)
26
2.12 Sensor de Corrente SCT013
Esse sensor é usado para medir a corrente alternada, ele não é invasivo não
a necessidade de cortar o fio para realizar a medição.
Onde sua entrada permite uma variação no range de 0 – 30 A. Tem uma
saída de, no máximo, 1 Volt. Sua resistência de amostragem é de 62 ohms e sua
rigidez dielétrica de saída é de 1500 VAC. A tensão de saída é proporcional à
corrente que passa através do condutor.
Imagem 10 - Sensor de Corrente SCT013 (Fonte: http://mlb-s1-p.mlstatic.com)
27
2.13 Servo Motor
Servo motores são dispositivos de malha fechada, ou seja, recebem um sinal
de controle; verificam a posição atual; atuam no sistema indo para a posição
desejada.
Em contraste com os motores contínuos que giram indefinidamente, o eixo do
servo motores possui a liberdade de até cerca de 180º graus mas são precisos
quanto à posição.
A característica mais marcante de um servo é a sua capacidade de
movimentar o seu braço até uma posição e mantê-lo lá, mesmo que este seja
forçado em outra direção.
Para fazer um servo funcionar você deve ligá-lo a um receptor (RX) e este
receptor deve estar ligado a uma bateria que forneça no mínimo 4,8volts (não
discutiremos aqui uma ligação com SpeedControl). Este receptor deve estar
sintonizado a um rádio (TX). Em geral um receptor para um aeromodelo elétrico
deve ter no mínimo 3 canais (sendo mais comum encontrarmos os receptores de 4
canais), mas para os aeromodelos mais simples usamos só 2 servos. Cada servo é
ligado a um canal diferente do receptor e recebe um sinal no formato PWM
(PulseWidthModulation). Este sinal pode ter 0Volts ou 5Volts. O circuito de controle
do servo fica monitorando este sinal em intervalos de 20ms (mili segundos), se
dentro deste intervalo ele percebe uma alteração do sinal de 0v para 5v durante 1ms
até 2ms ele altera a posição do seu eixo para coincidir com o sinal que recebeu.
Um sinal de 1ms corresponde a uma posição do braço do servo todo a
esquerda ou 0º
Um sinal de 1,5ms é o que chamamos de posição central do servo ou 90º
Um sinal de 2ms corresponde a uma posição do braço do servo todo a direita
ou 180º. Veja na imagem:
Imagem 11- Representação de pulsos (Fonte: www.pictronics.com.br)
28
Imagem 12 - Mini Servo Motor SG90(Fonte: www.weiku.com)
2.14 Mini Bomba
Mini bomba compatível com arduino, o tipo de alimentação elétrica 12v. Sua
aplicação deve ser Submersa: água. Onde sua taxa de fluxo de água é de 4L por
minuto, podendo operar até 60°.
Imagem 13 -Mini bomba (Fonte: www.mercadolivre.com.br)
29
3 PROJETO
Cronograma
1ªS 2ª S 3ª S 4ª S 1ªS 2ª S 3ª S 4ª S 1ªS 2ª S 3ª S 4ª S 1ªS 2ª S 3ª S 4ª S 1ªS 2ª S 3ª S 4ª S
Relatorio X X X X X X X X X X X X X
Programaçao X X X X X X X X X X X X X X X X X
Desenho X X X X X X X X X X X X
Construçao X X X X X X X X X X X X X X X
Pesquisa X X X X X
Planejamento X X X X X
Cronograma
Julho Agosto Setembro Outubro Novembro
Nosso projeto, foi desenvolvido com a intenção de facilitar a vida das pessoas
em suas residências. O projeto consiste em automatizar algumas funções de uma
residência, como por exemplo: portão da garagem, lâmpadas, irrigação de jardim,
ventilador, coletar informação como temperatura e humidade, e o consumo de
energia e sistema de segurança (câmera e alarme). Tudo isso é controlado via
internet, ou seja, qualquer dispositivo, conectado à internet, pode controlá-la se
conectando ao servidor. O sistema pode ser facilmente ampliado, é possível utilizar
vários sensores, criar novas saídas, isso irá da necessidade de cada aplicação.
3.1 Desenvolvimento do Projeto
O projeto foi realizado a partir de reuniões dentro e fora da escola, e também
utilizamos as Redes Sociais como meio de comunicação durante o desenvolvimento
do projeto.
Dividimos o desenvolvimento do projeto em 3 partes sendo:
1º Parte física (Maquete)
2º Programação
3º Confecção da placa.
30
3.2 A Maquete
A maquete do nosso projeto foi criada com materiais reaproveitados, ou seja,
utilizamos madeiras, peças de computadores e até recicláveis para realizar nossas
ideias. Utilizamos o software SolidWorks para desenvolver a planta.
A base da nossa maquete tem 66 cm de comprimento, 48 cm de largura e 9,5
de altura. Entretanto a parte superior da maquete, onde localiza-se a residência,
possui comprimento de 95 cm, largura de 51 cm e altura de 10 cm.
A residência por sua vez tem comprimento total de 38 cm, altura total de 40
cm e largura de 15 cm. Cada andar da residência possui19 cm de comprimento,
20cm de altura e 15cm de largura.
Imagem 14 - Planta da Maquete
31
Imagem 15 - Base da Maquete
Imagem 16 - Montagem da maquete
32
Imagem 17 - Funil do jardim
Imagem 18 - Maquete pronta sem acabamento
33
Imagem 19 - Maquete pronta
3.3 Programação
Nossa programação foi dividida em 2 partes sendo:
1º Microcontrolador: Utilizamos o Arduino Mega 2560 (C e C++).
Código Fonte utilizado:
//Ethernet
#include <SPI.h>
#include <Ethernet.h>
#include <SD.h>
// Sensor de Temperatura e Humidade
#include <dht.h> // Biblioteca DHT11
#define dht_dpin A9 // Sinal DHT11 ligado a porta Analogica A3
dht DHT; //Inicialização do sensor
//Servo motor
#include <Servo.h>
Servo myservo;
int pos = 0;
34
// Alarme
int LDR_pin = A11; // Sinal LDR ligado a porta Ananlogica A5
int LDR_val = 0; // Variavel onde armazena o valor do LDR
int buzina = 21; //Sinal da buzina ligada ao pino 21
// Tamanho do tampão utilizado para capturar os pedidos HTTP
#define REQ_BUF_SZ 60
// Endereço MAC de Ethernet
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 0,177); // Endereço IP
EthernetServer server(8888); // Criar um servidor na porta 8888
File webFile; // Puxa o arquivo web ( htm ) dentro do cartão SD
char HTTP_req[REQ_BUF_SZ] = {0}; // Solicitação HTTP buffer armazenado como nulo string
terminada
char req_index = 0; // Índice em buffer HTTP_req
boolean LED_state[6] = {0}; // Armazena os estados dos LEDs
// Sensor de Corrente
#include "EmonLib.h"
#include <avr/eeprom.h>
#define eeprom_read_to(dst_p, eeprom_field, dst_size) eeprom_read_block(dst_p, (void
*)offsetof(__eeprom_data, eeprom_field), MIN(dst_size, sizeof((__eeprom_data*)0)->eeprom_field))
#define eeprom_read(dst, eeprom_field) eeprom_read_to(&dst, eeprom_field, sizeof(dst))
#define eeprom_write_from(src_p, eeprom_field, src_size) eeprom_write_block(src_p, (void
*)offsetof(__eeprom_data, eeprom_field), MIN(src_size, sizeof((__eeprom_data*)0)->eeprom_field))
#define eeprom_write(src, eeprom_field) { typeof(src) x = src; eeprom_write_from(&x, eeprom_field,
sizeof(x)); }
#define MIN(x,y) ( x > y ? y : x )
/*
* __eeprom_data is the magic name that maps all of the data we are
* storing in our EEPROM
*/
struct __eeprom_data {
double flash_kwhtotal;
};
EnergyMonitor emon1;
//Cria variaveis globais
35
double kwhTotal;
double vlreais;
unsigned long ltmillis, tmillis, timems, previousMillis;
char charBuf[30];
// Fim sensor Corrente
void setup()
{
//Sensor Corrente
emon1.current(10, 64); // Current: input pin, calibration for 24 Ohms
eeprom_read(kwhTotal, flash_kwhtotal);
previousMillis = millis();
// Servo Motor
myservo.attach(20); // Sinal do servo motor ligado no pino 20
// Alarme
pinMode(buzina,OUTPUT);
// Desativar chip de Ethernet
pinMode(10, OUTPUT);
digitalWrite(10, HIGH);
Serial.begin(9600); // Para depuração
// Inicializar cartão SD
Serial.println("Iniciação cartão SD ...");
if (!SD.begin(4)) {
Serial.println("ERRO - Cartão SD não iniciado!");
return; // inicialização falhou
}
Serial.println("SUCESSO - Cartão SD iniciado.");
//verificar a existência de arquivo index.htm
if (!SD.exists("index.htm")) {
Serial.println("ERRO - Arquivo index.html não encontrado!");
return; // não pode encontrar o arquivo de índice
}
Serial.println("SUCESSO - Arquivo index.html encontrado.");
// Declaração de interruptores
36
pinMode(48,INPUT); // Pino 5, interrupitor que mostra o estatos do alarme ligado em serie com o
SINAL do BUZZER.
digitalWrite(48,1);
// LEDs
pinMode(33, OUTPUT); // Pino 2 Liga/Desliga S1 ( Bomba Jardim ) LED 5
pinMode(53, OUTPUT); // Pino 3 Liga/Desliga S2 ( Ventilador ) LED 6
pinMode(35, OUTPUT); // Pino 6 Liga/Desliga S3 ( Lampada SALA) LED 1
pinMode(37, OUTPUT); // Pino 7 Liga/Desliga S4 ( Lampada QUATO 1) LED 2
pinMode(39, OUTPUT); // Pino 8 Liga/Desliga S5 ( Lampada QUARTO 2 ) LED 3
pinMode(20, OUTPUT); // Pino 9 Liga/Desliga S6 (Portão Garagem ) LED 4
pinMode(9, OUTPUT); // Pino 23 Liga/Desliga S7 ( Alarme ) LED 7
Ethernet.begin(mac, ip); // Inicializar dispositivo Ethernet
server.begin(); // Começar a comunicação com o server
}
void loop()
{
//Alarme
LDR_val = analogRead(LDR_pin); // Variavel onde lê o valor do LDR
if(LDR_val >= 25){ // Se o movimento for menor ou igual a 25 ligar a buzina
digitalWrite(buzina,0);
//digitalWrite(48,1);
}
else
{
digitalWrite(buzina,1);
//digitalWrite(48,0);
}
//Incio Sensor Corrente
//Calculate amount of time since last realpower measurment.
ltmillis = tmillis;
tmillis = millis();
timems = tmillis - ltmillis;
double Irms = emon1.calcIrms(1480); // Calculate Irms only
37
//Calculate todays number of kwh consumed.
//kwhTotal = kwhTotal + ((realPower/1000.0) * 1.0/3600.0 * (timems/1000.0));
//Calculate todays number of kwh consumed.
kwhTotal = kwhTotal + (((Irms*127.0)/1000.0) * 1.0/3600.0 * (timems/1000.0));
// Serial.print("Watts: ");
//Serial.println(Irms*127.0); // Apparent power
// Serial.print("Current: ");
//Serial.println(Irms); // Irms
// Serial.print("kwhTotal: ");
printFloat(kwhTotal, 10);
// Serial.println("");
//grava na memoria a cada 1 minuto
if ((millis() - previousMillis)>4000)
{
Serial.println("Gravando na EEprom");
eeprom_write(kwhTotal, flash_kwhtotal);
previousMillis=millis();
}
//converter double em string
dtostrf(kwhTotal, 8, 7, charBuf);
//Multiplica pelo valor kilowatt hora R$ 0.35 Reais
vlreais = kwhTotal * 0.35;
dtostrf(vlreais, 8, 7, charBuf);
//Serial.print("VALOR EM REAL : ");
//Serial.println(vlreais);
//delay(2000);
}
void printFloat(float value, int places) {
// this is used to cast digits
int digit;
float tens = 0.1;
int tenscount = 0;
int i;
float tempfloat = value;
38
// make sure we round properly. this could use pow from <math.h>, but doesn't seem worth the
import
// if this rounding step isn't here, the value 54.321 prints as 54.3209
// calculate rounding term d: 0.5/pow(10,places)
float d = 0.5;
if (value < 0)
d *= -1.0;
// divide by ten for each decimal place
for (i = 0; i < places; i++)
d/= 10.0;
// this small addition, combined with truncation will round our values properly
tempfloat += d;
// first get value tens to be the large power of ten less than value
// tenscount isn't necessary but it would be useful if you wanted to know after this how many chars
the number will take
if (value < 0)
tempfloat *= -1.0;
while ((tens * 10.0) <= tempfloat) {
tens *= 10.0;
tenscount += 1;
}
// write out the negative if needed
if (value < 0)
Serial.print('-');
if (tenscount == 0)
Serial.print(0, DEC);
for (i=0; i< tenscount; i++) {
digit = (int) (tempfloat/tens);
Serial.print(digit, DEC);
tempfloat = tempfloat - ((float)digit * tens);
tens /= 10.0;
}
// if no places after decimal, stop now and return
if (places <= 0)
return;
39
// otherwise, write the point and continue on
// Serial.print('.');
// now write out each decimal place by shifting digits one by one into the ones place and writing the
truncated value
for (i = 0; i < places; i++) {
tempfloat *= 10.0;
digit = (int) tempfloat;
Serial.print(digit,DEC);
// once written, subtract off that digit
tempfloat = tempfloat - (float) digit;
}
//Final Sensor Corrte
EthernetClient client = server.available(); // Tentar obter cliente
if (client) { // Se encontrar cliente faça a comunicação.
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) { // Dados do cliente disponíveis para leitura
char c = client.read(); // Ler 1 byte (caractere) de cliente
// Limitar o tamanho do pedido HTTP recebido armazenado
// Tampão primeira parte do pedido HTTP em ordem HTTP_req (string)
//Deixar último elemento em array como 0 para nulo terminar string (REQ_BUF_SZ - 1)
if (req_index < (REQ_BUF_SZ - 1)) {
HTTP_req[req_index] = c; // salvar HTTP caráter pedido
req_index++;
}
// Última linha da solicitação do cliente está em branco e termina com \ n
// Responder ao cliente somente após a última linha recebida
if (c == '\n' && currentLineIsBlank) {
// enviar um cabeçalho de resposta HTTP padrão
client.println("HTTP/1.1 200 OK");
// restante do cabeçalho segue abaixo, dependendo se
// página web ou XML página é solicitada
// Solicitação Ajax - Enviar arquivo XML
if (StrContains(HTTP_req, "ajax_inputs")) {
40
// enviar resto do cabeçalho HTTP
client.println("Content-Type: text/xml");
client.println("Connection: keep-alive");
client.println();
SetLEDs();
// Enviar arquivo XML contendo estados de entrada
XML_response(client);
}
else { // solicitação de página web
// enviar resto do cabeçalho HTTP
client.println("Content-Type: text/html");
client.println("Connection: keep-alive");
client.println();
// enviar página web
webFile = SD.open("index.htm"); // Abre o arquivo index.htm dentro do cartão SD
if (webFile) {
while(webFile.available()) {
client.write(webFile.read()); // Enviar página web para o cliente
}
webFile.close();
}
}
//exibição recebeu solicitação HTTP na porta de serial
Serial.print(HTTP_req);
// redefinir índice tampão e todos os elementos de amortecimento a 0
req_index = 0;
StrClear(HTTP_req, REQ_BUF_SZ);
break;
}
// todas as linhas de texto recebido do cliente termina com \ r \ n
if (c == '\n') {
// último caractere na linha de texto recebidas
// iniciar nova linha com o próximo caractere lido
currentLineIsBlank = true;
41
}
else if (c != '\r') {
// um caractere de texto foi recebida do cliente
currentLineIsBlank = false;
}
} // acabar if (client.available ())
} // final, enquanto (client.connected())
delay(1); // dar tempo ao navegador para receber os dados
client.stop(); // fechar a conexão
} // acabam if (cliente)
}
// verifica se o pedido HTTP recebido é ligar / desligar LEDs
// Também evita o estado dos LEDs
void SetLEDs(void){
// LED 1 (pin 6)
if (StrContains(HTTP_req, "LED1=1")) {
LED_state[0] = 1; // salvar o estado LED
digitalWrite(35, HIGH);
}
else if (StrContains(HTTP_req, "LED1=0") ) {
LED_state[0] = 0; // salvar o estado LED
digitalWrite(35, LOW);
}
// LED 2 (pin 7)
if (StrContains(HTTP_req, "LED2=1")) {
LED_state[1] = 1; // salvar o estado LED
digitalWrite(37, HIGH);
}
else if (StrContains(HTTP_req, "LED2=0")) {
LED_state[1] = 0; // salvar o estado LED
digitalWrite(37, LOW);
}
// LED 3 (pin 8)
if (StrContains(HTTP_req, "LED3=1")) {
42
LED_state[2] = 1; // salvar o estado LED
digitalWrite(33, HIGH);
}
else if (StrContains(HTTP_req, "LED3=0")) {
LED_state[2] = 0; // salvar o estado LED
digitalWrite(33, LOW);
}
// LED 4 (pin 9)
if (StrContains(HTTP_req, "LED4=1")) {
LED_state[3] = 1; // salvar o estado LED
pos = 90;
myservo.write(pos);
}
else if (StrContains(HTTP_req, "LED4=0")) {
LED_state[3] = 0; // salvar o estado LED
pos = 0;
myservo.write(pos);
}
// LED 5 (pin 2)
if (StrContains(HTTP_req, "LED5=1")) {
LED_state[4] = 1; // salvar o estado LED
digitalWrite(39, HIGH);
}
else if (StrContains(HTTP_req, "LED5=0")) {
LED_state[4] = 0; // salvar o estado LED
digitalWrite(39, LOW);
}
// LED 6 (pin 3)
if (StrContains(HTTP_req, "LED6=1")) {
LED_state[5] = 1; // salvar o estado LED
digitalWrite(53, HIGH);
}
43
else if (StrContains(HTTP_req, "LED6=0")) {
LED_state[5] = 0; // salvar o estado LED
digitalWrite(53, LOW);
}
// LED 7 (pin 23)
if (StrContains(HTTP_req, "LED7=1")) {
LED_state[6] = 1; // salvar o estado LED
digitalWrite(9, HIGH);
}
else if (StrContains(HTTP_req, "LED7=0")) {
LED_state[6] = 0; // salvar o estado LED
digitalWrite(9, LOW);
}
}
// Envia o arquivo XML com os valores analógicos, estado dos botões e dos LEDS
void XML_response(EthernetClient cl)
{
int analog_val; // Lojas valor lido a partir de entradas analógicas
int count; // Usado por 'para' laços
int sw_arr[] = {48}; //pinos sendo interruptores
cl.print("<?xml version = \"1.0\" ?>");
cl.print("<inputs>");
// ler entradas analógicas
/* for (count = 2; count <= 5; count++) { // A2 até A5
analog_val = analogRead(count);
cl.print("<analog>");
cl.print(analog_val);
cl.println("</analog>");
}
44
*/
// Ler temperatura
DHT.read11(dht_dpin);
cl.print("<temper>");
cl.print(DHT.temperature);
cl.println("</temper>");
cl.print("<humi>");
cl.print(DHT.humidity);
cl.println("</humi>");
// Sensor de Corrente
cl.print("<kwh>");
cl.print(kwhTotal);
cl.println("</kwh>");
cl.print("<valoreal>");
cl.print(vlreais);
cl.println("</valoreal>");
cl.print("<corrente>");
cl.print(emon1.calcIrms(1480));
cl.println("</corrente>");
cl.print("<potencia>");
cl.print(emon1.calcIrms(1480) * 127);
cl.println("</potencia>");
// Leia interruptores
for (count = 0; count < 3; count++) {
cl.print("<switch>");
if (digitalRead(sw_arr[count])) {
cl.print("Desligado");
45
}
else {
cl.print("Ligado");
}
cl.println("</switch>");
}
// checkbox LED estados
// LED1
cl.print("<LED>");
if (LED_state[0]) {
cl.print("on");
}
else {
cl.print("off");
}
cl.println("</LED>");
// LED2
cl.print("<LED>");
if (LED_state[1]) {
cl.print("on");
}
else {
cl.print("o");
}
cl.println("</LED>");
// botão LED estados
// LED3
cl.print("<LED>");
if (LED_state[2]) {
cl.print("on");
}
else {
cl.print("off");
}
46
cl.println("</LED>");
// LED4
cl.print("<LED>");
if (LED_state[3]) {
cl.print("on");
}
else {
cl.print("off");
}
cl.println("</LED>");
// LED5
cl.print("<LED>");
if (LED_state[4]) {
cl.print("on");
}
else {
cl.print("off");
}
cl.println("</LED>");
// LED6
cl.print("<LED>");
if (LED_state[5]) {
cl.print("on");
}
else {
cl.print("off");
}
cl.println("</LED>");
// LED7
cl.print("<LED>");
if (LED_state[6]) {
cl.print("on");
}
47
else {
cl.print("off");
}
cl.println("</LED>");
cl.print("</inputs>");
}
//define cada elemento de str a 0 (limpa matriz)
void StrClear(char *str, char length)
{
for (int i = 0; i < length; i++) {
str[i] = 0;
}
}
// Procura o sfind corda na string str
// Retorna 1 se a cadeia encontrada
// Retorna 0 se a cadeia não encontrado
char StrContains(char *str, char *sfind)
{
char found = 0;
char index = 0;
char len;
len = strlen(str);
if (strlen(sfind) > len) {
return 0;
}
while (index < len) {
if (str[index] == sfind[found]) {
found++;
if (strlen(sfind) == found) {
return 1;
}
}
else {
found = 0;
48
}
index++;
}
return 0;
}
2º Sistema Online: Utilizamos linguagens voltada para WEB ( HTML, CSS e AJAX)
HTML + AJAX
<!DOCTYPE html>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<html>
<link rel='stylesheet' href='css.css' type='text/css' media='all' />
<style type="text/css">
a:link {
color: #F5F5F8;
text-decoration: none;
}
a:visited {
text-decoration: none;
color: #F0F0F5;
}
a:hover {
text-decoration: none;
color: #E8E8ED;
}
a:active {
text-decoration: none;
49
@charset "utf-8";
body {
background-color: #302f2d;
}
.central {
position: absolute;
top: 1px;
left: 50%;
width:980px;
height: 900px;
padding: 20px;
margin-left: -500px; /* por causa do posicionamento absoluto temos que usar margem
negativa para centralizar o site */
background-image:
url("http://downloadsferoz.com.br/automacao_residencial/site_automacao.png");
background-repeat: no-repeat;
}
h1 {
font-size:19px;
color:#fff;
text-shadow: 2px -2px 10px #5993c3;
}
h2 {
font-size:0px;
color:#fff;
text-shadow: 2px -2px 10px #5993c3;
}
a:link {text-decoration: none;color: #000099}
a:active {text-decoration: none;}
a:visited {text-decoration: none;color: #000099}
50
a:hover {text-decoration: underline;color: #000099}
.sala {
border: 0px solid blue;
height: 48px;
width: 104px;
border-radius: 10px;
position : absolute;
left : 260px;
top : 210px;
}
.quarto1 {
border: 0px solid blue;
height: 48px;
width: 104px;
border-radius: 10px;
position : absolute;
left : 260px;
top : 366px;
}
.quarto2 {
border: 0px solid blue;
height: 49px;
width: 104px;
border-radius: 10px;
position : absolute;
left : 260px;
top : 503px;
}
.portao {
border: 0px solid blue;
51
height: 47px;
width: 103px;
border-radius: 10px;
position : absolute;
left : 260px;
top : 752px;
}
.jardim {
border: 0px solid blue;
height: 43px;
width: 106px;
border-radius: 10px;
position : absolute;
left : 260px;
top : 632px;
}
.ventilador {
border: 0px solid blue;
height: 43px;
width: 106px;
border-radius: 10px;
position : absolute;
left : 260px;
top : 274px;
}
.temperatura {
border: 0px solid blue;
height: 110px;
width: 157px;
52
border-radius: 10px;
position : absolute;
left : 547px;
top : 109px;
}
.camera {
border: 0px solid blue;
height: 443px;
width: 571px;
border-radius: 10px;
position : absolute;
left : 402px;
top : 208px;
}
.button {
display: inline-block;
text-decoration: none;
color: #fff;
font-weight: bold;
background-color: #538fbe;
padding: 15px 30px;
font-size: 10px;
border: 1px solid #2d6898;
border-radius: 10px;
background-image: linear-gradient(bottom, rgb(73,132,180) 0%, rgb(97,155,203) 100%);
background-image: -o-linear-gradient(bottom, rgb(73,132,180) 0%, rgb(97,155,203) 100%);
background-image: -moz-linear-gradient(bottom, rgb(73,132,180) 0%, rgb(97,155,203) 100%);
background-image: -webkit-linear-gradient(bottom, rgb(73,132,180) 0%, rgb(97,155,203) 100%);
background-image: -ms-linear-gradient(bottom, rgb(73,132,180) 0%, rgb(97,155,203) 100%);
background-image: -webkit-gradient(
linear,
53
left bottom,
left top,
color-stop(0, rgb(73,132,180)),
color-stop(1, rgb(97,155,203))
);
}
.button:hover {
background-image: linear-gradient(bottom, rgb(79,142,191) 0%, rgb(102,166,214) 100%);
background-image: -o-linear-gradient(bottom, rgb(79,142,191) 0%, rgb(102,166,214) 100%);
background-image: -moz-linear-gradient(bottom, rgb(79,142,191) 0%, rgb(102,166,214)
100%);
background-image: -webkit-linear-gradient(bottom, rgb(79,142,191) 0%, rgb(102,166,214)
100%);
background-image: -ms-linear-gradient(bottom, rgb(79,142,191) 0%, rgb(102,166,214) 100%);
background-image: -webkit-gradient(
linear,
left bottom,
left top,
color-stop(0, rgb(79,142,191)),
color-stop(1, rgb(102,166,214))
);
font-size: 11px;
}
}
</style>
<head>
<title>Automação Redidêncial</title>
<script>
strLED1 = "";
strLED2 = "";
strLED3 = "";
strLED4 = "";
strLED5 = "";
54
strLED6 = "";
var LED1_state = 0;
var LED2_state = 0;
var LED3_state = 0;
var LED4_state = 0;
var LED5_state = 0;
var LED6_state = 0;
function GetArduinoIO()
{
nocache = "&nocache=" + Math.random() * 1000000;
var request = new XMLHttpRequest();
request.onreadystatechange = function()
{
if (this.readyState == 4) {
if (this.status == 200) {
if (this.responseXML != null) {
// Arquivo XML recebido - contém valores
analógicos, valores de opção e estados do LED
var count;
// Temperatura
var num_an =
this.responseXML.getElementsByTagName('temper').length;
for (count = 0; count < num_an; count++) {
document.getElementsByClassName("temper")[count].innerHTML =
this.responseXML.getElementsByTagName('temper')[count].childNodes[0].nodeValue;
}
// Humidade
var num_an =
this.responseXML.getElementsByTagName('humi').length;
for (count = 0; count < num_an; count++) {
55
document.getElementsByClassName("humi")[count].innerHTML =
this.responseXML.getElementsByTagName('humi')[count].childNodes[0].nodeValue;
}
// obter entradas do interruptor
var num_an =
this.responseXML.getElementsByTagName('switch').length;
for (count = 0; count < num_an; count++) {
document.getElementsByClassName("switches")[count].innerHTML =
this.responseXML.getElementsByTagName('switch')[count].childNodes[0].nodeValue;
}
// LED 1
if
(this.responseXML.getElementsByTagName('LED')[0].childNodes[0].nodeValue === "on") {
document.getElementById("LED1").innerHTML = "DESLIGAR";
LED1_state = 1;
}
else {
document.getElementById("LED1").innerHTML = "LIGAR";
LED1_state = 0;
}
// LED 2
if
(this.responseXML.getElementsByTagName('LED')[1].childNodes[0].nodeValue === "on") {
document.getElementById("LED2").innerHTML = "DESLIGAR";
LED2_state = 1;
}
else {
56
document.getElementById("LED2").innerHTML = "LIGAR";
LED2_state = 0;
}
// LED 3
if
(this.responseXML.getElementsByTagName('LED')[2].childNodes[0].nodeValue === "on") {
document.getElementById("LED3").innerHTML = "DESLIGAR";
LED3_state = 1;
}
else {
document.getElementById("LED3").innerHTML = "LIGAR";
LED3_state = 0;
}
// LED 4
if
(this.responseXML.getElementsByTagName('LED')[3].childNodes[0].nodeValue === "on") {
document.getElementById("LED4").innerHTML = "DESLIGAR";
LED4_state = 1;
}
else {
document.getElementById("LED4").innerHTML = "LIGAR";
LED4_state = 0;
}
// LED 5
if
(this.responseXML.getElementsByTagName('LED')[4].childNodes[0].nodeValue === "on") {
document.getElementById("LED5").innerHTML = "DESLIGAR";
LED5_state = 1;
}
else {
57
document.getElementById("LED5").innerHTML = "LIGAR";
LED5_state = 0;
}
// LED 6
if
(this.responseXML.getElementsByTagName('LED')[5].childNodes[0].nodeValue === "on") {
document.getElementById("LED6").innerHTML = "DESLIGAR";
LED6_state = 1;
}
else {
document.getElementById("LED6").innerHTML = "LIGAR";
LED6_state = 0;
}
}
}
}
}
// enviar solicitação HTTP GET com LEDs para ligar / desligar, se qualquer
request.open("GET", "ajax_inputs" + strLED1 + strLED2 + strLED3 + strLED4
+ strLED5 + strLED6 + nocache, true);
request.send(null);
setTimeout('GetArduinoIO()', 1000);
strLED1 = "";
strLED2 = "";
strLED3 = "";
strLED4 = "";
strLED5 = "";
strLED6 = "";
}
// LEDs de serviços quando caixa de seleção marcada / desmarcada
function GetCheck()
{
58
if (LED_form.LED2.checked) {
strLED2 = "&LED2=1";
}
else {
strLED2 = "&LED2=0";
}
}
function GetButton1()
{
if (LED3_state === 1) {
LED3_state = 0;
strLED3 = "&LED3=0";
}
else {
LED3_state = 1;
strLED3 = "&LED3=1";
}
}
function GetButton2()
{
if (LED4_state === 1) {
LED4_state = 0;
strLED4 = "&LED4=0";
}
else {
LED4_state = 1;
strLED4 = "&LED4=1";
}
}
function GetButton3()
{
if (LED1_state === 1) {
LED1_state = 0;
59
strLED1 = "&LED1=0";
}
else {
LED1_state = 1;
strLED1 = "&LED1=1";
}
}
function GetButton4()
{
if (LED2_state === 1) {
LED2_state = 0;
strLED2 = "&LED2=0";
}
else {
LED2_state = 1;
strLED2 = "&LED2=1";
}
}
function GetButton5()
{
if (LED5_state === 1) {
LED5_state = 0;
strLED5 = "&LED5=0";
}
else {
LED5_state = 1;
strLED5 = "&LED5=1";
}
}
function GetButton6()
{
60
if (LED6_state === 1) {
LED6_state = 0;
strLED6 = "&LED6=0";
}
else {
LED6_state = 1;
strLED6 = "&LED6=1";
}
}
</script>
</head>
<body onload="GetArduinoIO()">
<!-- -->
<!-- ÍNICIO DIV CENTRARL -->
<div class="central">
<!-- ÍNICIO DIV SALA -->
<div class="sala">
<button type="button" id="LED1" class="button" onclick="GetButton3()">LIGAR1</button><br /><br />
<!--ENTRADA D6 -->
</div> <!-- FIM DIV SALA -->
<!-- ÍNICIO DIV QUATO 1 -->
<div class="quarto1">
<button type="button" id="LED2" class="button" onclick="GetButton4()">LIGAR2</button><br /><br />
<!-- ENTRADA D7 -->
</div><!-- FIM DIV QUATO 1 -->
<!-- ÍNICIO DIV QUATO 2-->
<div class="quarto2">
<button type="button" id="LED3" class="button" onclick="GetButton1()">LIGAR3</button><br /><br
/><!--ENTRADA D8 -->
61
<form id="check_LEDs" name="LED_form">
<!--<input type="checkbox" name="LED1" value="0"
onclick="GetCheck()" />LED 1 (D6)<br /><br />
<input type="checkbox" name="LED2" value="0"
onclick="GetCheck()" />LED 2 (D7)<br /><br />-->
</form>
</div><!-- FIM DIV QUATO 2 -->
<!-- ÍNICIO DIV PORTÃO -->
<div class="portao">
<button type="button" id="LED4" class="button" onclick="GetButton2()">LIGAR4</button><br /><br />
<!--ENTRADA D9 -->
</div> <!-- FIM DIV PORTÃO -->
<!-- ÍNICIO DIV JARDIM -->
<div class="jardim">
<button type="button" id="LED5" class="button" onclick="GetButton5()">LIGAR5</button><br /><br />
<!-- BOTÃO ENTRADA D2 -->
</div><!-- FIM DIV JARDIM -->
<!-- ÍNICIO DIV VENTILADOR -->
<div class="ventilador">
<button type="button" id="LED6" class="button" onclick="GetButton6()">LIGAR6</button><br /><br />
<!--ENTRADA D3 -->
</div> <!-- FIM DIV VENTILADOR -->
<!-- ÍNICIO DIV TEMPERATURA -->
<div class="temperatura">
<h1><p>Temperatura: <span class="temper">...</span></p></h1>
<h1><p>Humidade: <span class="humi">...</span></p></h1>
<!-- <p class="small_text">D1: utilizado por série TX</p> -->
<h2><p>Switch 1 (D2): <span class="switches">...</span></p>
62
<p>Switch 2 (D3): <span class="switches">...</span></p>
<!--<p class="small_text">D4:utilizado pelo escudo Ethernet</p>-->
<p>Switch 3 (D5): <span class="switches">...</span></p></h2>
</div><!-- FIM DIV TEMPERATURA -->
<div class="camera">
<iframe width='571' height='376' frameborder='0'
src='http://192.168.0.104:81/iphone.htm'></iframe>
<center><h3><a href="http://192.168.0.104:81/monitor2.htm" target="_blank"><strong>
Ampliar</strong></a></h3><center>
</div>
</div><!-- FIM DIV CENTRARL -->
</body>
</html>
CSS
@charset "utf-8";
body {
background-color: #302f2d;
}
.central {
position: absolute;
top: 1px;
left: 50%;
width:980px;
height: 900px;
padding: 20px;
margin-left: -500px; /* por causa do posicionamento absoluto temos que usar margem
negativa para centralizar o site */
63
background-image:
url("http://downloadsferoz.com.br/automacao_residencial/site_automacao.png");
background-repeat: no-repeat;
}
h1 {
font-size:19px;
color:#fff;
text-shadow: 2px -2px 10px #5993c3;
}
h2 {
font-size:0px;
color:#fff;
text-shadow: 2px -2px 10px #5993c3;
}
a:link {text-decoration: none;color: #000099}
a:active {text-decoration: none;}
a:visited {text-decoration: none;color: #000099}
a:hover {text-decoration: underline;color: #000099}
.sala {
border: 0px solid blue;
height: 48px;
width: 104px;
border-radius: 10px;
position : absolute;
left : 260px;
top : 210px;
}
.quarto1 {
64
border: 0px solid blue;
height: 48px;
width: 104px;
border-radius: 10px;
position : absolute;
left : 260px;
top : 366px;
}
.quarto2 {
border: 0px solid blue;
height: 49px;
width: 104px;
border-radius: 10px;
position : absolute;
left : 260px;
top : 503px;
}
.portao {
border: 0px solid blue;
height: 47px;
width: 103px;
border-radius: 10px;
position : absolute;
left : 260px;
top : 752px;
}
.jardim {
border: 0px solid blue;
height: 43px;
width: 106px;
65
border-radius: 10px;
position : absolute;
left : 260px;
top : 632px;
}
.ventilador {
border: 0px solid blue;
height: 43px;
width: 106px;
border-radius: 10px;
position : absolute;
left : 260px;
top : 274px;
}
.temperatura {
border: 0px solid blue;
height: 110px;
width: 157px;
border-radius: 10px;
position : absolute;
left : 547px;
top : 109px;
}
.camera {
border: 0px solid blue;
height: 443px;
width: 571px;
border-radius: 10px;
position : absolute;
left : 402px;
66
top : 208px;
}
.button {
display: inline-block;
text-decoration: none;
color: #fff;
font-weight: bold;
background-color: #538fbe;
padding: 15px 30px;
font-size: 10px;
border: 1px solid #2d6898;
border-radius: 10px;
background-image: linear-gradient(bottom, rgb(73,132,180) 0%, rgb(97,155,203) 100%);
background-image: -o-linear-gradient(bottom, rgb(73,132,180) 0%, rgb(97,155,203) 100%);
background-image: -moz-linear-gradient(bottom, rgb(73,132,180) 0%, rgb(97,155,203) 100%);
background-image: -webkit-linear-gradient(bottom, rgb(73,132,180) 0%, rgb(97,155,203) 100%);
background-image: -ms-linear-gradient(bottom, rgb(73,132,180) 0%, rgb(97,155,203) 100%);
background-image: -webkit-gradient(
linear,
left bottom,
left top,
color-stop(0, rgb(73,132,180)),
color-stop(1, rgb(97,155,203))
);
}
.button:hover {
background-image: linear-gradient(bottom, rgb(79,142,191) 0%, rgb(102,166,214) 100%);
background-image: -o-linear-gradient(bottom, rgb(79,142,191) 0%, rgb(102,166,214) 100%);
background-image: -moz-linear-gradient(bottom, rgb(79,142,191) 0%, rgb(102,166,214)
100%);
background-image: -webkit-linear-gradient(bottom, rgb(79,142,191) 0%, rgb(102,166,214)
100%);
67
background-image: -ms-linear-gradient(bottom, rgb(79,142,191) 0%, rgb(102,166,214) 100%);
background-image: -webkit-gradient(
linear,
left bottom,
left top,
color-stop(0, rgb(79,142,191)),
color-stop(1, rgb(102,166,214))
);
font-size: 11px;
}
Imagem 20 - Tela do sistema online
68
3.4 Confecção da Placa
Para a confecção da placa utilizamos uma placa de fenolite de 15 x 20,
criamos o circuito pelo software Fritzing Utilizando uma impressora a laser para
imprimir o circuito impresso. Usamos um ferro de passar roupa para aquecer a
impressão sobre a placa assim fazendo com que o circuito seja gravado na placa.
Utilizamos o ácido percloreto de ferro, para corroer o cobre o qual não foi
protegido pela tinta da impressão.
Imagem 21 - Montagem do hardware (Fritzing)
69
Imagem 22 - Circuito Impresso (Fritzing)
Imagem 23 - Circuito impresso transportado para a placa
70
Imagem 24 - Corroendo a placa com ácido percloreto
Imagem 25 - Placa corroída
71
Imagem 26 - Placa pronta com os componentes
3.5 Desenhos detalhados
Imagem 26 - Imagem detalhada da maquete
72
Imagem 27 - Imagem detalhada da placa
Imagem 28 - Tela do sistema detalhado
73
Tabela de Preços
Componente Quantidade Preço
Casa (Maquete) 1 R$ 76,00
ArduinoMega 1 R$ 35,00
Shield Ethernet 1 R$ 25,00
Shield Relé 4 Saídas 1 R$ 30,00
Sensor DHT11 1 R$ 11,00
Sensor PIR 1 R$ 5,00
Buzzer 1 R$ 5,00
Sensor de Corrente SCT-013-000 1 R$ 22,00
Servo Motor 1 R$ 5,00
Mini bomba 1 R$ 25,00
Lâmpadas 3 R$ 6,00
Placa Fenolite 15 x20 1 R$ 6,70
Capacitor 10 MF 1 R$ 0,12
Barra de pinos 180x40 1 R$ 4,20
Barra de soquete 40 1 R$ 1,90
Borne KRE 2 5 R$ 5,00
Percloreto De Ferro Em Pó 250gr 1 R$ 12,00
Broca 0.8 mm 1 R$ 12,00
Câmera IP 1 Doação
Total R$ 286,92
74
4 CONSIDERAÇÕES FINAIS
4.1 Ensaios
Começamos a testar o projeto a partir de um protobord, obtivemos dificuldade
em interagir o sistema online com o arduíno, devido a complexibilidade da
programação exigida. Depois da programação pronta, realizamos os testes com a
maquete, com os devidos componentes instalados. Todas as funções funcionaram
perfeitamente, exceto o sensor de correte que não conseguimos 100 % de eficácia.
Por último confeccionamos a placa, e a partir desse ponto começamos a realizar os
testes com ela, na qual, a princípio, apresentou um pequeno problema de curto, mas
conseguimos solucionar e tudo ficou funcionando.
4.2 Conclusão
Após muita dedicação e trabalho conseguimos realizar nosso propósito de
automatizar uma residência desde a parte interna até o exterior, visando além do
conforto a segurança e o bem estar das pessoas.
4.3 Sugestões
Fica à disposição, para próximos grupos a ampliação do projeto, onde é
possível adicionar outros sensores, por exemplo, de gás, reconhecimento de voz,
música ambiente, alimentador automático para animais, a instalação de placas
solares para captação de energia, entre outras.
75
BIBLIOGRAFIA
www.seriallink.com.br/forum/viewtopic.php?f=90&t=2018&start=20#.VEACnfldWb9
Acessado em 05/07/2014
www.guiadoestudante.abril.com.br/profissoes/engenharia-
producao/mecatronica-602824.shtml
Acessado em 05/07/2014
www.ucp.br/index.php/graduacao/cec/engenharia/mecatronica
Acessado em 05/07/2014
www.esateceducacional.com.br/Cursos/Tecnico_Mecatronica/
Acessado em 05/07/2014
www.mecahoje.blogspot.com.br/2011/04/afinal-o-que-e-mecatronica.html
Acessado em 05/07/2014
ftp://ftp.demec.ufpr.br/disciplinas/TM265/Livro_Rosario/cap01.ppt
Acessado em 12/07/2014
www.automatecbrasil.comunidades.net/index.php?pagina=1579111567
Acessado em 12/07/2014
www.arq.ufsc.br/arq5661/trabalhos_20091/automacao_residencial/automacao_resid
encial.pdf
Acessado em 12/07/2014
www.luzesom.pt/dom_domotica_01.htm
Acessado em 12/07/2014
www.sislite.pt/domus.htm
Acessado em 19/07/2014
www.electronica-pt.com/content/view/67/
Acessado em 19/07/2014
www.projeto39.wordpress.com
Acessado em 19/07/2014
www.inf.ufes.br/~erus/arquivos/ERUS_minicurso%20arduino.pdf
Acessado em 20/07/2014
76
www.filipeflop.com/pd-6b8f7-sensor-de-umidade-e-temperatura-dht11.html
Acessado em 20/07/2014
www.puccampinas.edu.br/websist/Rep/Sic08/Resumo/2013819_155813_161531537
_resiaM.pdf
Acessado em 20/07/2014
www.elecrow.com/wiki/index.php?title=Relay_Shield
Acessado em 23/07/2014
www.startingelectronics.com/tutorials/arduino/ethernet-shield-web-server-tutorial/
Acessado em 23/07/2014
www.binarycodec.blogspot.com.br/2013/01/controle-de-rele-via-internet-com.html
Acessado em 03/08/2014
www.blog.concord.org/streaming-arduino-data-to-a-browser
Acessado em 03/08/2014
www.tableless.com.br/o-que-html-basico/
Acessado em 03/08/2014