PROTÓTIPO DE UM SISTEMA DE CONTROLE E …pericas/orientacoes/CtrlResidencial2006.pdf ·...
63
Retirar este rodapé do volume final Página 1 30/09/2006 Tcc_anderson_24_06_06 UNIVERSIDADE REGIONAL DE BLUMENAU CENTRO DE CIÊNCIAS TECNOLÓGICAS CURSO DE ENGENHARIA DE TELECOMUNICAÇOES – BACHARELADO PROTÓTIPO DE UM SISTEMA DE CONTROLE E MONITORAÇÃO RESIDENCIAL UTILIZANDO J2ME ANDERSON DE OLIVEIRA BLUMENAU 2006 2006/1-XX
Transcript of PROTÓTIPO DE UM SISTEMA DE CONTROLE E …pericas/orientacoes/CtrlResidencial2006.pdf ·...
Retirar este rodapé do volume final Página 1 30/09/2006 Tcc_anderson_24_06_06
UNIVERSIDADE REGIONAL DE BLUMENAU
CENTRO DE CIÊNCIAS TECNOLÓGICAS
CURSO DE ENGENHARIA DE TELECOMUNICAÇOES – BACHARELADO
PROTÓTIPO DE UM SISTEMA DE CONTROLE E
MONITORAÇÃO RESIDENCIAL UTILIZANDO J2ME
ANDERSON DE OLIVEIRA
BLUMENAU 2006
2006/1-XX
ANDERSON DE OLIVEIRA
PROTÓTIPO DE UM SISTEMA DE CONTROLE E
MONITORAÇÃO RESIDENCIAL UTILIZANDO J2ME
Trabalho de Conclusão de Curso submetido à Universidade Regional de Blumenau para a obtenção dos créditos na disciplina Trabalho de Conclusão de Curso II do curso de Engenharia de Telecomunicações-Bacharelado.
Prof. Francisco Adell Pericas, Mestre - Orientador
BLUMENAU 2006
2006/1-XX
PROTÓTIPO DE UM SISTEMA DE CONTROLE E
MONITORAÇÃO RESIDENCIAL UTILIZANDO J2ME
Por
ANDERSON DE OLIVEIRA
Trabalho aprovado para obtenção dos créditos na disciplina de Trabalho de Conclusão de Curso, pela banca examinadora formada por:
______________________________________________________ Presidente: Prof. Francisco Adell Péricas, Mestre – Orientador, FURB
______________________________________________________ Membro: Prof. Fábio Segundo, Mestre – FURB
______________________________________________________ Membro: Prof. Fábio Perez, Mestre – FURB
Blumenau, 31 de julho de 2006
Dedico este trabalho aos meus familiares amigos, professores, em especial aos meus pais e avos e aqueles que contribuíram diretamente para a conclusão deste trabalho.
AGRADECIMENTOS
À Deus, por ter me dado forças e conhecimento para que pudesse concluir este
trabalho.
À minha família, que sempre esteve em meu lado nos momentos em que mais precisei,
aqueles que quando eu não sabia o que fazer, me mostravam o caminho certo a prosseguir, e
me ensinaram a nunca desistir dos meus sonhos.
Aos meus amigos, pelos empurrões e cobranças.
Ao meu orientador, Francisco Adell Péricas, pelo incentivo e por ter acreditado na
conclusão deste trabalho.
Todo homem que lê demais e usa o cérebro de menos, adquire a preguiça de pensar.
Albert Einstein
RESUMO
Este trabalho apresenta a especificação de um protótipo de software para o controle residencial a distância, utilizando dispositivos móveis. Apresentando um estudo sobre as funções de domótica, a plataforma Java 2, J2EE, J2SE e mais especificamente o J2ME sendo esta a plataforma Java para dispositivos móveis. No protótipo desenvolveu-se o programa que comanda e monitora uma residência através de SMS, sendo que este programa será executado dentro do dispositivo móvel.
Palavras-chave: Automação Residencial. Java. J2ME.
ABSTRACT
This paper presents the specifications of a software prototype for distance residential control, using mobile devices. Presenting a study on the functions of domotica, the Java 2 platform, J2EE, J2SE and more specifically the J2ME once this is the Java platform for mobile devices. In this prototype, a program that commands and monitores a residence through SMS was developed, and this program will be executed inside the mobile device. Key-words: Residential automation. Java. J2ME.
LISTA DE ILUSTRAÇÕES
Figura 1: Representação dos ambientes de desenvolvimento Java ..........................................26
Figura 2: Casos de Uso do aplicativo .......................................................................................34
Figura 3: Diagrama de classes do protótipo .............................................................................35
Figura 4: Diagrama de Atividades............................................................................................36
Figura 5: Diagrama de Seqüência.............................................................................................38
Figura 6: Diagrama de Fluxo de Dados....................................................................................38
Figura 7: Criação do projeto TCC_Anderson no KToolbar .....................................................40
Figura 8: Configuração das propriedades do projeto................................................................41
Figura 9: Estrutura hierárquica do projeto................................................................................42
Figura 10: Hierarquia de Classes..............................................................................................43
Figura 11: Representa a tela de Login do Usuário....................................................................45
Figura 12: Tela de Seleção do Ambiente..................................................................................46
Figura 13: Cozinha ...................................................................................................................47
LISTA DE SIGLAS
API – Application Programming Interface
AWT – Abstract Window Toolkit
CDC – Connected Device Configuration
CLDC – Connected Limited Device Configuration
CLP – Controlador lógico programável
DES – Data Encryption Standard
HTML – HyperText Markup Language
JDBC – Java Database Connectivity
JSP – Java Server Pages
JVM – Java Virtual Machine
MAC – Macintosh Operating System
MIDP – Mobile Information Device Profile
OFDM – Orthogonal Frequency Division Multiplexing
PDAs – Personal digital assistants
PLC – Power Line Communications
RAM – Random Access Memory
ROM – Read Only Memory
SMS – Short message service
SUMÁRIO
1 INTRODUÇÃO..................................................................................................................12
1.1 OBJETIVOS DO TRABALHO ........................................................................................12
1.1.1 Objetivos Específicos......................................................................................................13
1.2 ESTRUTURA DO TRABALHO ......................................................................................13
2 DOMÓTICA.......................................................................................................................15
2.1 FUNÇÕES DOMÓTICAS ................................................................................................16
2.1.1 Função de Gestão ............................................................................................................16
2.1.2 Função de Controle .........................................................................................................18
2.1.3 Função de Comunicação .................................................................................................20
2.2 REDE DOMÓTICA ..........................................................................................................22
3 JAVA...................................................................................................................................23
3.1 JAVA 2..............................................................................................................................24
3.1.1 J2SE ................................................................................................................................25
3.1.2 J2EE ................................................................................................................................25
3.1.3 J2ME ...............................................................................................................................26
3.1.4 Java Card.........................................................................................................................29
4 PLC .....................................................................................................................................30
4.1 X-10...................................................................................................................................30
5 DESENVOLVIMENTO DO TRABALHO.....................................................................32
5.1 REQUISITOS PRINCIPAIS DO PROBLEMA A SER TRABALHADO.......................32
5.2 ESPECIFICAÇÃO ............................................................................................................33
5.2.1 Diagrama de Casos de Usos............................................................................................33
5.2.2 Diagrama de Classes .......................................................................................................34
5.2.3 Diagrama de Atividades..................................................................................................36
5.2.4 Diagrama de seqüência ...................................................................................................37
5.3 IMPLEMENTAÇÃO ........................................................................................................39
5.3.1 Técnicas e ferramentas utilizadas....................................................................................39
5.4 ESTRUTURA DO PROTÓTIPO......................................................................................42
5.4.1 Operacionalidade da implementação ..............................................................................44
5.5 RESULTADOS E DISCUSSÃO ......................................................................................48
6 CONCLUSÕES..................................................................................................................50
REFERÊNCIAS BIBLIOGRÁFICAS .................................................................................51
APÊNDICES ...........................................................................................................................53
12
1 INTRODUÇÃO
Nas últimas décadas presenciou-se o crescimento da automação industrial,
supervisionando e interligando máquinas, aos poucos surgiu a automação de edifícios
comerciais, e atualmente chegando à automação residencial, que está em grande crescimento
no mercado nacional.
A automação residencial vem em primeira instância como um símbolo de status, sendo
em um segundo momento conforto e tornando-se posteriormente uma necessidade e um fator
econômico (UHLIG, 2004).
O avanço tecnológico e das telecomunicações fez com que dispositivos móveis se
tornassem cada vez menores e mais poderosos. Esta evolução fez com que aumentasse sua
abrangência, saindo da sua premissa que era unicamente transmissão de voz, para, além de a
voz, transmitir dados e mensagens, se tornando uma ferramenta multiuso.
O desenvolvimento deste projeto tem por objetivo fazer o controle e monitoração
residencial através de dispositivos móveis, utilizando para este fim a linguagem de
programação Java, mais especificamente J2ME, que é o Java para dispositivos móveis, dando
uma nova dimensão para a automação residencial que até então ficava restrita a um
computador.
1.1 OBJETIVOS DO TRABALHO
Desenvolvimento de um programa para controle e monitoração residencial utilizando
dispositivos móveis.
13
1.1.1 Objetivos Específicos
Especificamente, pretende-se que o protótipo seja capaz de:
1. criar uma interface para permitir a visualização e a alteração do estado de
elementos gerenciáveis de uma casa.
2. enviar a alteração do status via SMS para um módulo receptor na residência.
3. receber e tratar mensagens SMS enviadas pelo módulo da residência.
4. disponibilizar as informações de status no módulo receptor para uma futura
implementação via serial.
1.2 ESTRUTURA DO TRABALHO
A estrutura deste trabalho está disposta em seis capítulos divididos nos temas
domótica, Java, PLC, desenvolvimento do trabalho e conclusão final.
No primeiro capítulo se apresenta uma introdução ao trabalho.
O segundo apresenta uma visão geral da domótica e suas funções, mostrando a função
de cada uma dentro da automação residencial.
Já no terceiro capítulo esta descrita a plataforma Java 2 suas divisões, fundamentos e
propriedades do J2ME que é a plataforma para dispositivos móveis, suas vantagens e
desvantagem no desenvolvimento de programas para celulares.
O quarto apresenta um contexto geral da tecnologia de transmissão de dados PLC e o
padrão X-10.
O desenvolvimento do trabalho, especificações, ferramentas utilizadas e a metodologia
empregada estão descritos no quinto capítulo.
14
Após o desenvolvimento é chegado à conclusão do trabalho sendo este o sexto e
último capítulo.
15
2 DOMÓTICA
A palavra domótica vem da fusão do latin domus (casa) e da atual robótica
(automação), podendo ser referenciada como smart building ou intelligent building.
A Domótica ou Automação Doméstica é uma aplicação específica da Automação
Industrial. Por definição, automação refere-se a um sistema ou método pelo qual eventos
podem ser executados e controlados sem intervenção de um pensamento consciente (ANGEL,
1993).
Segundo Venturi (2005), a automação residencial é um novo domínio de aplicação
tecnológica, tendo como objetivo básico melhorar a qualidade de vida, reduzindo o trabalho
doméstico, aumentando o bem estar e a segurança de seus habitantes, visando também uma
utilização racional e planejada dos diversos meios de consumo procurando uma melhor
integração através da automatização em áreas distintas como segurança, comunicação,
controle e gestão de fluídos. Segundo as necessidades humanas, podemos dividir a automação
residencial em três partes distintas:
1. necessidades de segurança como:
a. proteção e vigilância contra intrusão;
b. inundações;
c. incêndios;
d. fugas de gás;
e. prevenção de acidentes físicos;
2. necessidade de conforto nas atividades cotidianas como:
a. comunicar-se;
b. alimentar-se;
c. dormir;
16
d. diverti-se;
e. trabalhar;
3. necessidade de conforto do ambiente:
a. acústico;
b. térmico;
c. visual;
d. olfativo.
2.1 FUNÇÕES DOMÓTICAS
Segundo Angel (1993), as funções domóticas nos permitem satisfazer a um número
considerável de necessidades. Definem-se então, três grandes classes de funções segundo o
tipo de "serviço" a que elas se dirigem, as quais são divididas em sub-funções elementares,
que serão analisadas.
2.1.1 Função de Gestão
A função de gestão tem o objetivo de automatizar certo número de ações sistemáticas.
As automatizações realizam segundo uma programação o controle de consumo e manutenção.
As ações sistemáticas da função de gestão estão relacionadas principalmente com o conforto
(VENTURI, 2005).
Gestão da Iluminação
A gestão de iluminação vem como um dos primeiros elementos da domótica voltado
17
para o conforto sendo também a parte mais visível do sistema.
Além de otimizar os recursos energéticos, a solução pretende facilitar a utilização e ao
mesmo tempo tirar um melhor aproveitamento dos sistemas de iluminação adequando-a a
cada situação, evitando desta forma desperdícios de iluminação, fazendo a criação de cenários
adequados a várias utilizações do espaço como o convívio, janta, leitura etc.
Contribui para a gestão de energia uma utilização sem desperdícios da iluminação. O
fluxo de luz será em função da iluminação existente, possibilitando também que as luzes
liguem perante a detecção de passagem de pessoas durante a noite, com o cuidado de não as
encandear. Já ao sair de casa ou ao deitar-se pode-se apagar todas as luzes com o clicar de um
simples botão, mas sempre dando prioridade ao controle manual de iluminação.
Gestão de Aquecimento, Ventilação e Ar Condicionado
Conhecido como AVAC, proporciona à moradia um ambiente termicamente agradável
através do aquecimento por radiadores centrais, aparelhos de ar condicionado centralizados ou
descentralizado, levando sempre em consideração as janelas. Quando é detectada a abertura
de uma janela, o sistema desliga-se reduzindo o consumo de energia, de uma central
meteorológica, fazendo com que o sistema não atue somente em relação à temperatura interior
desejada, mas também da temperatura exterior antecipando a influência que esta poderá ter no
seu desempenho. A verificação da presença ou não de pessoas no ambiente a climatizar,
relacionando de acordo com os hábitos dos moradores.
18
Gestão da Qualidade do Ar
Segundo Angel (1993), a gestão da qualidade do ar pode controlar totalmente o ar do
ambiente, não supervisionando unicamente temperatura e umidade, mas também a existência
de gases tóxicos como o gás de cozinha.
Gestão da Funcionalidade dos Espaços
Segundo Angel (1993), se trata de uma necessidade de evolução dos espaços segundo
o cotidiano, modificações dos grupos familiares, adaptações de novas necessidades e de novos
modos de vida. Tal flexibilidade tem como objetivo permitir futuras atualizações dos
sistemas atuais, instalação de novos sistemas ou conexão dos mesmos, permitindo assim a
evolução das necessidades dos usuários. Para a domótica, a flexibilidade dos espaços das
instalações é de vital importância, pois este deve estar projetado para garantir adaptações de
novos equipamentos levando em conta a estrutura da residência, pisos e tetos flexíveis etc.
Estas exigências vêm do fato que uma edificação se trata de um conjunto flexível que
integra distintas tecnologias, abrangendo sistema de gestão, vigilância e manutenção,
segurança, comunicação interna e externa, sistemas eletrônicos e elétricos que devem estar
conectados entre si. Estes têm como principais objetivos aumentar a segurança, empregar os
recursos de forma mais eficiente e ter flexibilidade para novas e eventuais necessidades.
2.1.2 Função de Controle
Segundo Venturi (2005) a função de controle fornece ao usuário informações sobre o
19
estado de funcionamento dos equipamentos e das instalações e cria um registro dos diversos
parâmetros e eventualmente induz comandos corretivos. Essa função tem por objetivo fazer
com que os dispositivos de regulagem atuem, com a finalidade de que as tarefas programadas
sejam respeitadas.
Controle Técnico
Segundo Angel (1993), o controle técnico tem como objetivo auxiliar o usuário a fazer
o uso dos equipamentos, dispositivos e instalações, permitindo controlar e fazer prevenções e
programarem gastos. Esta função controla diferentes tipos de equipamentos, redes de
alimentação, transmissão de informações, diferentes fluidos utilizados na casa, presenças de
estranhos em um perímetro protegido e parâmetros excepcionais para verificar o estado de
saúde dos membros de uma família.
Podemos citar como exemplo de controle técnico:
1. recepção de mensagens de mau funcionamento dos equipamentos instalados;
2. organização do estado dos sistemas em pequenos ou grandes painéis que indiquem
portas ou janela abertas, luzes acesas, etc;
3. desligamento consecutivo de cargas elétricas com a finalidade de evitar sobrecarga
no sistema;
4. informação do consumo de água, eletricidade, gás e o custo dos mesmos;
5. comandos únicos que interferem em diversos equipamentos, como por exemplo
uma saída de férias, na qual o sistema deve cortar a água, gás, desligar as luzes,
ligar o alarme fechar cortinas, etc.
20
Segurança – Tele-transmissão
Por estar associada a valores materiais e devido aos altos valores estatísticos
relacionados a incêndios, acidentes domésticos e invasões, a domótica tem uma preocupação
prioritária à segurança. O sistema deve ser confiável, evitando assim falsos alarmes e ser de
fácil manuseio para os membros da família (ANGEL, 19993).
Estão relacionadas a esta função:
1. controle de acesso aos ambientes;
2. detecção de intrusos;
3. detecção de vazamento de gases e água;
4. tele-vigilância;
5. detecção de incêndio.
Assistência - Saúde
Esta sub-função permite ao usuário conectar-se com centros de assistência médica
através de computadores de uso pessoal, tendo considerável abrangência nos EUA e Japão,
sendo uma área muito pouco utilizada na Europa. Este permite o controle e acompanhamento
de casos graves de doenças ou por motivos de acidente (VENTURI, 2005).
2.1.3 Função de Comunicação
Através da função de comunicação tornou-se possível à interatividade dos sistemas
envolvidos. Através desta tornou-se possível o telecomando e a programação para que os
21
equipamentos envolvidos obedeçam a uma padronização e possam se comunicar por
intermédio de redes auxiliares.
Comunicação – controle
Com a evolução das telecomunicações, mais especificamente com o surgimento das
Redes Digitais de Serviços Integrados (RDSI) que permite o tráfego de vários sinais por um
mesmo meio como serviços de voz, texto, dados e imagens permitiram-se que se
interligassem vários dispositivos entre si e com o usuário do sistema, possibilitando também a
troca de comandos entre vários equipamentos e o operador.
Comunicação - Espaçamento
Uma das funções desta sub-função é a possibilidade do relacionamento dos membros
da família com o ambiente externo e serviços coletivos dos imóveis. Com isto tem-se a
necessidade de conectar os dispositivos de áudio e vídeo-comunicação da casa, fazendo com
que eles comuniquem entre si, permitindo um melhor serviço, tendo como principal objetivo o
aumento do conforto.
Comunicação – Serviços
Esta sub-função tem como principal objetivo à interconexão da rede interna de áudio e
vídeo com uma rede externa, esta podendo ser pública ou privada. Tem como exemplos
serviços: tele-educação, tele-vigilância, tele-trabalho, etc.
22
2.2 REDE DOMÓTICA
Segundo Venturi (2005) a rede domótica é o elemento principal de todo o sistema
domótico. A rede é o meio físico que permite realizar a comunicação entre os equipamentos
do sistema. Na maioria dos casos existe uma rede separada destinada à segurança, à detecção
de incêndios, ao controle de acessos, à climatização, à informática. Já as redes domóticas são,
em termos gerais, redes polivalentes que permitem realizar diferentes funções a fim de
simplificar a complexidade da instalação de uma rede. A mesma rede assegura, por exemplo,
as funções de segurança, conforto e gestão técnica. A rede pode estar constituída de um ou
vários suportes de comunicação dependendo somente das funções que o sistema pretende
realizar.
23
3 JAVA
É uma linguagem de alto nível com as seguintes características: simples, orientada a
objetos, robusta, segura, de arquitetura neutra e dinâmica, adequada para o desenvolvimento
de aplicações na rede Internet, redes fechadas ou ainda programas executáveis (DEPINÉ,
2002).
A plataforma Java completa uma década e seu sucesso é incontestável. O Java foi
pensado originalmente para se utilizar em qualquer tipo de eletrodoméstico, mas a idéia
fracassou. Um dos fundadores da Sun resgatou a idéia para utilizá-la no âmbito da Internet e
assim converteram em uma linguagem potente, segura e universal. Por ser gratuito e por
poder ser utilizado em todo mundo, um dos primeiros triunfos desta linguagem foi sua
integração no navegador Netscape onde permitia executar programas dentro de uma página
web, até então impensável somente com o HTML (YUAN, 2004).
Atualmente a linguagem Java e a principal ferramenta que impulsionou alguns dos
maiores avanços da computação mundial, como:
1. acesso remoto a banco de dados;
2. banco de dados distribuídos;
3. comércio eletrônico;
4. interatividade em páginas;
5. gerência de documentos;
6. ensino a distância;
7. jogos e entretenimento.
A tecnologia e plataforma de desenvolvimento Java constituem-se numa das mais
completas opções entre as ferramentas oferecidas aos programadores de softwares. Com ela,
utilizando uma única linguagem de programação, é possível implementar aplicações voltadas
24
a diferentes soluções, incluindo:
1. aplicações gráficas para desktops em PCs, MACs e outras plataformas de
hardware, as quais podem executar uma grande variedade de sistemas operacionais
por meio de bibliotecas AWT e Swing;
2. aplicações para Web executadas pelos próprios navegadores dos clientes, de modo
a lhes proporcionar mais interatividade e recursos mais avançados de visualização,
chamados applets;
3. aplicações para Web executadas nos servidores, que montam HTMLs
dinamicamente com conteúdos provenientes de banco de dados ou outras fontes
que sofrem constantes mudanças e atualizações;
4. aplicações destinadas a dispositivos móveis, incluindo PDAs celulares, JavaCards e
outros equipamentos embutidos em eletrodomésticos, algo ainda um pouco distante
da realidade nacional.
A plataforma Java foi criada com o conceito write once, run anywhere (“escreva uma
vez, execute em qualquer lugar”) cuja idéia consiste em desenvolver uma linguagem na qual o
programador escreveria e compilaria o código apenas uma vez e, a partir deste, poderia
executá-lo em qualquer plataforma que suportasse uma máquina virtual Java.
3.1 JAVA 2
Assim como a Sun Microsystems em seu princípio, a entidade Java Community
Process, que mantém hoje a plataforma Java 2, reconhecia que um único tipo de plataforma
não se ajustaria a todos os tipos de dispositivos. Agruparam, portanto, a tecnologias Java em
três edições, cada uma focada em uma área especifica da indústria da computação (Figura 1).
25
3.1.1 J2SE
O J2SE (Java 2 Standard Edition) é o ambiente de desenvolvimento mais utilizado.
Projetado para a execução de programas em máquinas simples pessoais e estações de trabalho
de acesso individual, ou seja, está direcionado ao mercado de computadores ao qual se está
familiarizado, onde há bem mais necessidade de aplicações. É a base da plataforma Java, com
a linguagem, a máquina virtual e uma coleção enorme de APIs que possibilitam o
desenvolvimento de inúmeros tipos de aplicação (INFO WESTER,2006).
3.1.2 J2EE
O J2EE (Java 2 Enterprise Edition) adequada a aplicativos baseados em servidores,
normalmente utilizada em ambientes corporativos escaláveis, com o objetivo de servir a
clientes, fornecedores e funcionários (INFO WESTER,2006).
A plataforma J2EE contém uma série de especificações, cada uma com
funcionalidades distintas. Entre elas, tem-se:
1. JDBC (Java Database Connectivity), utilizado no acesso a banco de dados;
2. JSP (Java Server Pages), um tipo de servidor Web;
3. Servlets, para o desenvolvimento de aplicações Web, permitindo a geração de
conteúdo dinâmico nos sites.
26
Figura 1: Representação dos ambientes de desenvolvimento Java
3.1.3 J2ME
O J2ME (Java 2 Micro Edition) define um padrão para colocar dentro de dispositivos
que não possuem um grande poder de processamento, dispositivos como PDAs, celulares,
eletrodomésticos, computadores de bordo e equipamentos de automação industrial. Com o
J2ME é possível construir ambientes de execução Java menores que 200 kilobytes (TOPLEY,
2004).
O crescimento no mercado de equipamentos eletrônicos computadorizados permitiu
que, independentemente do tipo de dispositivo, seus produtos pudessem interagir com
recursos diversos de maneira única e simplificada.
Este ideal é alcançado através da utilização da idéia máquina virtual. Neste caso cada
dispositivo executa uma máquina virtual Java desenvolvida por seu fabricante, e os
aplicativos em Java desenvolvidos por terceiros interagem apenas com a maquina virtual e
não com o dispositivo real. Isto garante que programadores de Java não precisem conhecer
nenhuma API e bibliotecas específicas de cada dispositivo. Torna-se, portanto inquestionável
27
que a eficiência da utilização de uma abstração de máquina virtual depende dos dispositivos, o
que justifica a existência de incontáveis modelos concorrentes de aparelhos celulares com
tecnologia Java no mercado.
Segundo Mattos (2005) existe a estimativa que até 2007 100% dos celulares do mundo
estarão utilizando a plataforma J2ME. Este é baseado em configurações que são um conjunto
mínimo de bibliotecas de classes disponíveis para um determinado dispositivo.
Apesar de os dispositivos de comunicação como celulares, pager e outros dispositivos
conectados, como PDAs e minicomputadores possuírem várias características em comum,
eles diferem bastante em relação à forma, às funções e aos componentes internos. Isto exige
que eles sejam categoricamente agrupados de maneira que a compatibilidade seja garantida
apenas entre equipamentos semelhantes.
A solução adotada foi dividi-la em duas camadas, chamadas “configuração” e “perfil”.
Configuração
A configuração especifica a máquina virtual JVM e alguns conjuntos de APIs básicos
que deverão ser utilizados para uma família particular de dispositivos. Atualmente existem
basicamente dois tipos de configuração: Connected Device Configuration – CDC
(“configuração para dispositivos conectados”) e Connected Limited Device Configuration –
CLDC (“configuração para dispositivos conectados limitados”).
Um dispositivo conectado tem, no mínimo, 512 Kb de memória para sistema (ROM),
256 Kb de memória de acesso randômico para leitura e escrita (RAM), e algum tipo de
conexão a rede. O CDC é destinado a dispositivos com recursos mais avançados de
processamento e armazenamento, podendo ser incluído alguns PDAs. De forma geral o CDC
especifica que uma JVM completa deve ser suportada. As configurações e os perfis do J2ME
28
são genericamente descritos baseando-se em sua capacidade de memória, sendo especificadas
as quantidades mínimas de ROM e RAM.
A CLDC está voltada para dispositivos menores que o CDC, cuja limitação se refere
aos recursos de memória, processamento e principalmente, da conectividade com redes e
Internet. Foi criada considerando dispositivos com 128Kb a 512Kb de memória disponível
para a plataforma Java. A conexão limitada refere-se a uma conexão de rede lenta e
intermitente. Utilizando como exemplo à maioria dos celulares da segunda geração a
velocidade alcançada e de aproximadamente 9.6Kbps. Levando em consideração que são
dispositivos de tela reduzida, memória limitada e conexão lenta, as aplicações desenvolvidas
para CLDC devem ser cautelosas no uso da rede.
Algumas limitações do CLDC:
� ausência de finalização: não existe o método finalize() no CLD;
� limitação no tratamento de Erros.
Perfil
O perfil está na camada superior à de configuração, adicionando APIs e especificações
necessárias para o desenvolvimento de aplicações para uma determinada família de
dispositivos. Alguns dos perfis existentes são: Mobílie Information Device Profile (MIDP),
PDA Profile, Foudation Profile, Personal Basic Profile, etc.
MIDP é um perfil CLDC voltado especificamente aos dispositivos portáteis. De acordo
com sua especificação, um dispositivo móvel de informação tem as seguintes características:
� 128Kb de memória não volátil para implementação do MIDP;
� 32Kb de memória volátil para heap de execução;
� 8Kb de memória não volátil para armazenamento persistente de dados;
29
� visor com tamanho mínimo de 96 x 54 pixels;
� algum mecanismo de entrada de dados, teclado ou sensível ao toque;
� conexão à rede, possivelmente de dois sentidos.
3.1.4 Java Card
Segundo SUN (2006), Java Card é uma das menores plataformas Java: são cartões
inteligentes com limitações de processamento e armazenamento. Além do ambiente de
execução seguro herdado de J2SE, o Java Card implementa diversas funções criptográficas,
aproveitando as funções dos cartões inteligentes como tokens criptográficos, tem a capacidade
de armazenar múltiplos aplicativos, podendo ter no mesmo cartão serviços de correio, banco
e telefonia.
Se uma entidade precisar atualizar o serviço no cartão de seus clientes, não precisará
mais enviar o mesmo novamente. Na próxima vez que o cartão for inserido no terminal, a
atualização será efetuada.
O Java Card é compatível com padrões da indústria, suportando padrões relacionados a
telecomunicações de modo que hoje boa parte dos SIM Cards no Brasil são Java Cards.
30
4 PLC
PLC (Power Line Communications) é uma tecnologia que utiliza a rede de energia
elétrica para transmissão de dados. Ela consiste em transmitir dados e voz em banda larga
pela rede de energia elétrica. Utilizando uma infra-estrutura já disponível, não necessita de
obras em uma edificação para ser implantada (TELECO,2006).
A tecnologia PLC trabalha na segunda camada do modelo de referência OSI, ou seja,
na camada de Enlace. Sendo assim, pode ser agregada a uma rede TCP/IP que está na terceira
camada, além de poder trabalhar em conjunto com outras tecnologias de segunda camada.
Uma das grandes vantagens do uso da PLC é que, por estar utilizando a rede elétrica,
qualquer ponto de energia pode se tornar um ponto de rede. Além disso, suporta altas taxas de
transmissão podendo chegar a até 40Mbps em faixas freqüência de 1,7MHz a 30MHz.
Utiliza a técnica de modulação de sinais OFDM, não interferindo em nenhum
eletrodoméstico. Entretanto, outros equipamentos podem causar interferências em uma rede
PLC, como motores de escova e os dimmers de Luz. Outro ponto importante da PLC é a
conexão com equipamentos bloqueadores de freqüência, equipamentos isoladores como, por
exemplo, estabilizadores ou que sejam alimentados por fontes chaveadas: nesses dispositivos
não podem ser ligados os equipamentos PLC. Para segurança, toda comunicação está
encriptada com o algoritmo DES de 56 bits.
4.1 X-10
O sistema X-10 PLC foi desenvolvido nos anos 70 pela Pico Eletronics, na Escócia.. A
patente original expirou em dezembro de 1997 possibilitando que vários fabricantes
passassem a desenvolver e fabricar novos produtos e mais confiáveis.
31
A tecnologia X-10 PLC transmite dados binários através da corrente elétrica usando
um pulso de sinal na freqüência de 60hz AC. O 1 binário é representado por um pulso de
120kHz no primeiro cruzamento e uma ausência de pulso no segundo, já um 0 binário é
representado por uma ausência de pulso no primeiro e um pulso de 120kHz no segundo
(AURESIDE, 2006).
As mensagens do X-10 usam 13 bits, sendo que os primeiros 4 bits são um código de
entrada, os 4 bits posteriores são o código de ambiente, os 4 seguintes um código de função
ou unidade e o último indica se os 4 anteriores devem ser interpretados como função ou como
unidade. Para enviar comandos a um equipamento X-10 são necessários dois conjuntos de 13
bits, um que enviará o endereço e outro o comando.
Segundo AURESIDE (2006) todos os sistemas contêm transmissores e receptores. Os
transmissores emitem um código específico que é sobreposto aos 220 volts da corrente
elétrica. Múltiplos transmissores podem emitir sinais para o mesmo módulo receptor. Temos
como exemplos de transmissores interruptores, controles remotos, sensores de presença,
timers, rádio relógios especiais.
Os receptores captam os sinais que uma vez recebido responde ligando ou desligando,
podendo ter numa casa diversos equipamentos endereçados pelo mesmo código.
32
5 DESENVOLVIMENTO DO TRABALHO
O protótipo proposto neste trabalho será formado basicamente por um programa Java
instalado em um celular que terá o objetivo de monitorar e comandar uma residência, através
de uma comunicação via SMS (Short Message System) com um módulo de comunicação
previamente instalado na residência a qual se deseja controlar.
5.1 REQUISITOS PRINCIPAIS DO PROBLEMA A SER TRABALHADO
O protótipo deverá ser executado em um celular com algumas especificações mínimas
como, suporte a aplicativos Java MIDP2.0, visor de no mínimo 96 x 54 pixels, 128Kb de
memória não volátil, 32Kb de memória volátil, 8Kb de memória não volátil para
armazenamento de dados e um dispositivo de entrada de dados, seja ele um teclado ou
sensível ao toque, suporte o envio de mensagens SMS, para que possa ser enviado e recebido
mensagens com a finalidade de comando e monitoração do ambiente o qual se deseja
controlar.
Partiu-se neste projeto do pressuposto que o ambiente a ser monitorado e comandado
já esteja todo automatizado com um CLP que irá controlar e monitorar todas as funções do
ambiente, como por exemplo, temperatura, iluminação, controle de entrada e saída de pessoas,
fechar e abrir portas e janelas e outras funções que este possa controlar, podendo este CLP
efetuar seus comandos através de uma comunicação via cabeamento estruturado ou via PLC
tecnologia que utiliza a rede elétrica para transmissão de dados, conhecida como X-10 muito
utilizada na Europa, como por exemplo, na Alemanha, e que este CLP esteja conectado a um
módulo de tele controle, o qual permite a comunicação direta e simplificada através de
telefone celular entre a residência e os usuários.
33
O programa proposto deverá ser de fácil uso e entendimento para os usuários sem
deixar a segurança do mesmo de lado, pois na adversidade da perda ou furto do celular não
torne a residência vulnerável a estranhos.
5.2 ESPECIFICAÇÃO
Na especificação do protótipo utilizou-se a linguagem UML (Unified Modeling
Language) para descrever os diagramas do mesmo.
5.2.1 Diagrama de Casos de Usos
Segundo Anquetil (2006), o diagrama de casos de uso apresenta uma lista das
interações entre um usuário e o sistema para cumprir uma tarefa.
No presente aplicativo encontrou-se dois Casos de Uso
1. Alteração do estado dos objetos: responsável pela alteração do estado dos objetos
que representam os elementos gerenciáveis de uma residência através do aplicativo
remoto, que através deste enviará os comandos.
2. Consulta a objetos: responsável pela consulta dos objetos da residência que pode
acontecer pela solicitação do usuário, ou automaticamente na inicialização do
programa, listando os estados de todos os elementos da residência.
34
Figura 2: Casos de Uso do aplicativo
5.2.2 Diagrama de Classes
Segundo Anquetil (2006), o diagrama de classes mostra as classes que compõem o
sistema e as relações entre elas.
35
Figura 3: Diagrama de classes do protótipo
1. TCCAnderson2: classe responsável pela configuração da tela para modificação
e monitoração dos objetos da residência, classe a qual envia comandos para a
classe SMSEnviar e recebe os estado dos objetos da classe SMSRecebe que
posteriormente atualiza na classe Aposentos.
2. SMSEnvia: classe responsável pelo envio de comando e solicitação de status
para o módulo receptor.
3. SMSRecebe: classe responsável pelo recebimento do status dos objetos da
residência enviando a mensagem para a classe TCCAnderson2.
4. Aposentos: classe responsável pelo status dos objetos de cada aposento,
mostrando o mesmo na tela do dispositivo móvel.
36
5.2.3 Diagrama de Atividades
Os diagramas de atividade descrevem o ciclo de vida de um objeto, um sistema ou uma
operação (ANQUETIL, 2006).
Alterar estado
Usuário
MonitorarEventos
Efetuar Evento
Residência
Figura 4: Diagrama de Atividades
Na Figura 4: Diagrama de Atividadesé apresenta o diagrama de atividades onde o
usuário ira alterar o estado remotamente através de seu celular, o qual enviará uma mensagem
SMS para o módulo celular que receberá a mensagem, fará a interpretação, e envia o comando
via serial para o CLP da residência, o qual executará o comando ordenado.
37
5.2.4 Diagrama de seqüência
No diagrama de seqüência da Figura 5 é demonstrada a ação do usuário desde a
inicialização, com o pedido da senha para efetuar o login do usuário, que é efetuada dentro do
aplicativo, que após a sua identificação envia uma mensagem SMS para o módulo receptor
solicitando o status da residência, que através de comunicação serial recebe o status do CLP
indicando qual o atual estado dos objetos. Depois de receber o status do CLP o módulo
receptor envia uma mensagem SMS para o celular do usuário, que atualiza sua tela mostrando
como os ambientes da residência se encontram no exato momento para que o mesmo escolha
se deseja alterar algo ou não, e assim possa efetuar os comando desejados.
Depois de escolher as alterações que deseja efetuar, e clicar no botão Enviar o celular
montará a mensagem e efetuará o envia da mesma para o módulo receptor que se encontra na
residência, para que este identifique os comando e o envie via serial para o CLP, para a
execução do comando, que depois de executado envia uma mensagem de confirmação da
ação.
38
Usuário
TCCAnderson2Módulo Remoto CLP
Inicia a Aplicação
Solicitação de Status
Solicita Senha
Solicita Status
Retorna StatusRetorna StatusVisualiza Status
Altera estado objetosEnvia Comandos
Envia Comandos
Confirma ExecuçãoConfirma ExecuçãoVisualiza execução
TCCAnderson2Módulo Rceptor
Figura 5: Diagrama de Seqüência
Na Figura 6 apresenta-se uma representação macro da interação dos módulos do
sistema e da forma com que os dados fluem pelo sistema.
Figura 6: Diagrama de Fluxo de Dados
39
Para demonstrar o funcionamento do protótipo foi desenvolvido um outro programa
que será colocado em um outro celular para simular o módulo receptor, já que no protótipo
partiu-se do pressuposto que a casa já era automatizada e continha o módulo, como mostra a
Figura 6.
5.3 IMPLEMENTAÇÃO
Neste capítulo será apresentada a implementação do protótipo desenvolvido neste
trabalho.
5.3.1 Técnicas e ferramentas utilizadas
No desenvolvimento do protótipo utilizou-se de alguns ambientes de desenvolvimento
como JavaTM 2SDK, Standard Edition (J2SE SDK), versão 1.4.2 que pode ser encontrado no
endereço web http://java.sun.com/j2se/downloads.html o qual tem como requisitos básicos
para instalação e funcionamento um computador com 50MB de espaço em disco rígido,
128MB de memória RAM, Pentium III 800MHz. Este programa torna-se necessário pois o
J2ME Wireless Toolkit efetua a compilação dentro do programa J2SE, o J2ME Wireless
Toolkit da Sun que esta disponível no endereço web http://java.sun.com/products/sjwtoolkis
denominado J2MEWTK, sendo que este inclui uma ferramenta visual que automatiza alguns
detalhes nos procedimentos de construção, compilação e empacotamento de MIDlets, além
de oferecer um caminho simples para códigos-fonte e para execução do mesmo. O programa
J2MEWTK não possui uma área de edição do código fonte, sendo que utilizou-se o programa
GEL que é gratuito e facilita muito a edição dos códigos fonte, podendo este ser encontrado
40
no site www.gexperts.com.
Após a instalação do J2SE SDK e efetuada a instalação do J2ME Wireless Toolkit no
diretório C: \WTK22, executa-se o KToobar no qual deverá ser criado o projeto.
Figura 7: Criação do projeto TCC_Anderson no KToolbar
O nome do projeto representa um título que será utilizado para organizar as MIDlets de
um mesmo projeto, o nome da classe MIDlet (“MIDlet Class Name”) é utilizada para inserir o
nome da classe da primeira MIDlet existente no projeto, podendo este projeto ter mais
MIDlets.
Após ter criado o projeto deve-se indicar na tela (Settings for Project
“TCC_Anderson”) na aba “API Selection” qual deverá ser a plataforma alvo, a versão do
perfil e a configuração a ser utilizada, além de acrecentar algumas APIs necessárias ao
programa, no presente projeto foram configurados com a plataforma alvo JTWI, onde o perfil
ficou com a versão 2.0 e 1.1 para a configuração, sendo selecionado como API adicional a
Wireless Messaging API2.0 (JSR 205).
Já a segunda aba intitulada de “Required” apresenta as propriedades do projeto que
serão armazenadas no arquivo de descrição da MIDlet.
41
Figura 8: Configuração das propriedades do projeto
Uma vez desenvolvido a aplicação MIDlet , quando se deseja executá-la em algum
dispositivo, no caso um celular, não poderá passar os arquivos de classes diretamente para o
dispositivo. Sua implantação é realizada por meio de arquivos de pacotes Java, o qual efetua o
empacotamento dos arquivos de classe e todos os seus recursos (imagens, dados do aplicativo,
etc.) em um arquivo de extensão .JAR.
Outro arquivo adicional e necessário é o JAD, que descreve o conteúdo da MIDlet
dentro do arquivo JAR, possibilitando que um software gerenciador de aplicações possa obter
informações sobre o JAR da MIDlet sem que este tenha sido instalado.
A grande vantagem da utilização do J2ME Wireless Toolkit é que todo o processo de
geração da aplicação, compilação e verificação prévia das classes de composição do projeto é
executado automaticamente pelo programa.
Após a criação do projeto o J2ME Wireless Toolkit cria um diretório para o projeto
dentro do diretório apps do WTK22 com várias pastas para organizar os arquivos do projeto
como pode ser visto na Figura 9.
42
Figura 9: Estrutura hierárquica do projeto
Na pasta bin estão gravados os arquivos JAD, JAR, na pasta class se encontram as
classes do projeto compiladas, na pasta res devem ser gravados os arquivos de recursos do
projeto como figuras e outros, já na pasta scr devem ser gravados os arquivos fonte do projeto
que neste caso foram editados no programa GEL.
Como os dispositivos móveis possuem uma memória muito reduzida, quanto menor a
aplicação melhor para o celular, sendo que para isto será usado um Obfuscador que diminuirá
o tamanho dos arquivos eliminando a redundância e também evitará a engenharia reversa. O
Obfuscador renomeia classes, variáveis e métodos para nomes mais compactos e inserem
dados ilegais ou questionáveis para confundir descompiladores.
Para este fim utilizou-se o programa Retroguard que pode ser encontrado em
www.retrologic.com onde este deve ser colocado dentro do diretório bin do WTK22.
5.4 ESTRUTURA DO PROTÓTIPO
A programação de interfaces gráficas de usuários para J2ME envolve diferentes
43
conceitos e bibliotecas de programação, necessitando que se entenda a hierarquia de classes
envolvidas com a interface do usuário, denominado Displayable.
Figura 10: Hierarquia de Classes
Sendo que há dois tipos de subclasses diretas do Displayable que determinam a
categoria a qual a aplicação pertence.
1. Canvas: objetos de baixo nível que permitem a aplicações fornecer um objeto da
classe Graphics , que permite maior liberdade de desenho, além de permitir
manipulação de entrada de dados, exemplos típicos jogos e gráficos.
2. Screen: objetos de alto nível que contem componentes completos de interfaces de
usuário, ao quais controlam por si só o desenho, o posicionamento e a manipulação de
eventos, entre eles podemos citar: Alert, List, TextBox e Form.
Qualquer aplicação pode usar uma combinação de objetos de classes Screen e Canvas
com o objetivo de apresentar uma interface de usuário integrada e com maiores detalhes de
recursos.
44
Estas classes são encontradas no pacote javax.microedition.lcdui.* que estão incluídas
no J2ME Wireless Toolkit.
Utilizando as classes acima descritas, o TCC_Anderson está organizado da seguinte
forma:
Nome Tipo Descrição
TCC_Anderson2 public class TCC_Anderson2
extends Midlet
classe principal que contém o Form
inicial do Sistema
SMSEnvio class SMSEnvio implements
Runnable
classe que efetua o envio da
mensagem SMS com os Comandos
SMSRecebimento class SMSRecebe implements
Runnable
Classe que efetua a recepção da
mensagem.
Aposentos class Aposento Exibe a lista de objetos de cada
aposento
O código das Classes relatadas acima na tabela encontram-se no Apêndices.
5.4.1 Operacionalidade da implementação
Neste capítulo é apresentado o funcionamento do protótipo de software.
O protótipo é formado por 4 telas:
A. Login: esta tela tem como objetivo efetuar o login do usuário para evitar que se
o mesmo seja extraviado não possa ser utilizado por pessoas desconhecidas.
Nesta tela deve ser digitado o nome e a senha do usuário para que seja feito o
login.
45
Figura 11: Representa a tela de Login do Usuário
Nesta tela temos disponíveis dois botões OK, e Sair. No botão OK será efetuado a
aferição do login. Se este estiver incorreto executa o encerramento do programa,
se estiver correto pula para a próxima tela. O botão de Sair como o próprio sugere
efetua o encerramento do programa.
46
B. Nesta tela o usuário poderá escolher o ambiente que deseja monitorar.
Figura 12: Tela de Seleção do Ambiente
No exemplo proposto pode-se monitorar 5 ambientes, mas a quantidade de ambientes
irá variar com a residência que está sendo monitorado podendo este número de ambientes ser
muito maior.
Esta tela também possui dois botões, Selecionar e Sair, sendo que o botão de
47
selecionar abrirá uma nova tela com os itens a serem monitorados e comandados. Já o botão
Sair ira efetuar o fechamento do programa.
Um exemplo de tela de ambiente de uma residência é mostrado na Figura 13.
Figura 13: Cozinha
48
Depois de selecionar os itens do ambiente a serem controlados, o usuário poderá enviar
os comandos via SMS utilizando para isto o comando Enviar que efetuará o envio da
mensagem para o módulo celular que se encontra na residência. Ou poderá voltar para a tela
de seleção dos ambientes para selecionar mais comandos a serem executados e posteriormente
enviar todos os comandos.
5.5 RESULTADOS E DISCUSSÃO
O protótipo apresentou os resultados esperados, concluindo tudo aquilo que foi
proposto, com o acréscimo do programa para simular o módulo receptor, sendo que foram
feitos testes em emuladores e em dispositivos reais, mostrando ter sido uma boa escolha a
utilização da plataforma J2ME, tendo como maior dificuldade o envio e recepção
propriamente dita das mensagens, que apesar de uma grande busca, não se encontrou muitos
documentos que indicassem como se deveria prosseguir para que se pudesse efetuar o mesmo.
Havia uma preocupação em evitar que qualquer mensagem recebida fosse lida, tanto pelo
programa do dispositivo remoto quanto pelo módulo receptor, pois estas poderiam partir de
dispositivos estranhos ao sistema, mas que foi suprido pela programação.
Outra preocupação era com o tempo de resposta quanto ao envio e recepção das
mensagens, mas que se mostrou aceitável, com pequenos tempos, quase que instantâneo,
quando as mensagens partiam de dispositivos da mesma operadora, sendo crítico quando de
operadoras diferentes.
Quanto à interface do usuário buscou-se facilitar o máximo possível para que o
programa fosse operado por qualquer um. Diferente de VENTURE(2005), não se permitiu
alteração de ambientes via usuário, sendo que estas haveriam de ser feitas no próprio
software.
49
Uma breve comparação com outros trabalhos na Tabela 1.
Acadêmico
Itens
Este
Trabalho
Venture
(2005)
Galvin
(2004)
SCHAEFER
(2004)
Depiné
(2002)
Plataforma de Desenvolvimento Java .NET .NET Java Java
Linguagem de Programação Java(J2ME) C#.NET VB.NET Java(J2ME) Java(J2ME)
Dispositivo Móvel Celular Pocket PC Pocket PC Celular Celular
Transmissão de Dados SMS Web service Web service E-mail -
Acesso a web Não Sim Sim Sim Não
Objetivos
Controlar e
monitora uma
residência através
de dispositivos
Móveis
Monitorar objetos
residenciais
através de
dispositivos
moveis á distância
Disponibilizar
informações
através de
dispositivos
moveis para o
segmento
metalúrgico
Transmitir dados
através de
dispositivos móveis
aplicada ao
segmento de
transporte.
Cálculo do melhor
tempo de
deslocamento para
um rally de
regularidade
Tabela 1: Tabela de comparação com outros trabalhos
50
6 CONCLUSÕES
Mostrou-se correta a escolha de se trabalhar com Java (J2ME), apesar da falta de
conhecimento da linguagem Java que pôde ser suprida com a consulta a livros e em fóruns na
Internet, obteve-se uma certa facilidade na montagem do programa, e leva-se também em
consideração que grande parte dos celulares vem com suporte a aplicativos Java, facilitando
sua implementação.
A escolha em trabalhar com mensagens SMS mostrou-se interessante por ser uma
opção diferente de envio de comandos, tendo como inconveniente o de se ter que trabalhar
com a mesma operadora para o celular remoto e o módulo receptor com a finalidade de ter o
menor tempo de recebimento possível, que em muitos casos chega a ser quase instantâneo.
Apesar da implementação promover somente a alteração do estado dos objetos de
forma binária, ou seja, ligado/desligado, poderia ter sido implementado a alteração de modo
analógico como 50% da luz acesa, necessitando apenas de algumas alterações no software.
Outra particularidade do protótipo é que não se permite acrescentar ou excluir
algum objeto para controle e verificação pelo usuário, tendo este que solicitar para o
administrador.
O aplicativo ficou com uma aparência um pouco diferente no celular do que no
simulador, pois cada celular implementa botões, por exemplo, conforme as características do
celular, facilitando ainda mais o entendimento por parte do usuário que já se esta
familiarizado com o ambiente do celular.
O protótipo atingiu seus objetivos que era a monitoração e o envio de comandos entre
o dispositivo remoto e módulo receptor, não fazendo parte do escopo do trabalho a
comunicação via serial com o CLP, ficando este como sugestão para posteriores trabalhos.
51
REFERÊNCIAS BIBLIOGRÁFICAS
ANGEL, Patricia Marta. Introducción a la Domótica, Embalse:EBAI, 1993 ANQUETIL, Nicolas. Desenvolvimento de Software Orientado a Objetos, junho 2006. Disponível em: http://www.ucb.br/ucbtic/mgcti/paginapessoalprof/Nicolas/Disciplinas/UML/node5.html. Acessado em 10 junho de 2006. AURESIDE, Protocolos, julho 2006. Disponível em: http://www.aureside.org.br/temastec/default.asp?file=protocolos.asp. Acesso em 20 de julho 2006. DEPINÉ, Fábio Marcelo. Protótipo de Software para Dispositivos Móveis Utilizando Java ME para Cálculo de Regularidade em Rally. Blumenau – SC: dezembro de 2002. INFO WESTER, J2SE, J2EE e J2ME: uma breve explicação, março 2006. Disponível em: http://www.infowester.com/versoesjava.php. Acesso em 23 março 2006. GALVIN, Deleon. Protótipo de Sistema CRM para Dispositivos Móveis Utilizando a Tecnologia .Net. Blumenau – SC: dezembro de 2004 KNUDSEN, Jonathan; Wireless Java Developing With J2ME, A! Apress,2004. MATTOS, Érico Tavares. Programação Java para Wireless, DIGERATI BOOKS, 2005. SCHAEFER, Carine. Protótipo de Aplicativo para Transmissão de Dados a partir de Dispositivos Móveis Aplicado a uma Empresa de Transporte. Blumenau – SC: julho de 2004 SUN . Java Card Technology, [S.1], maio 2006. Disponivel em: http://java.sun.com/products/javacard/. Acesso em 10 maio 2006. TELECO, Tecnologia PLC, julho 2006. Disponível em: http://www.teleco.com.br/emdebate/aderbal01.asp. Acesso em 20/07/06. TOPLEY, Kim, J2ME In A Nutshell A Desktop Quick Reference, O’REILLY, 2004. UHLIG, Michael, Desenvolvimento De Aplicativos para PDASs Utilizando J2ME, TCC Graduação no curso de Analise de Sistemas – Universidade São Francisco, Itatiba, São Paulo.
VENTURI, Eli. Protótipo de um Sistema para Controle e Monitoração Residencial através de Dispositivos Móveis utilizando a Plataforma .Net. Blumenau –�SC: julho de 2005�
YUAN, Michael Juntao; Enterprise J2ME Developing Mobile Java Applications, Prentice Hall, 2004.
52
53
APÊNDICES
Class TCC_anderson2
//*********************************************************************** // Desenvolimento programa para enviar comando para uma residencia via // SMS desenvolvido por Anderson de Oliveira //*********************************************************************** // API necessarias import javax.microedition.midlet.*; import javax.microedition.io.*; import javax.microedition.lcdui.*; import javax.wireless.messaging.*; import java.io.*; public class TCC_Anderson2 extends MIDlet implements CommandListener, Runnable { private Display display; /** Tela visivel quando for pausado*/ private Displayable TelaAtiva = null; private String NomeLogin; private String SenhaLogin; private Form Login; private List lista; private TextField Nome; private TextField Senha; private final int IndQuarto_Sala = 1; private final int IndCozinha = 2; private final int IndGaragem = 3; private Aposento ApQuarto_Casal; private Aposento ApQuarto_Criancas; private Aposento ApQuarto_Visitas; private Aposento ApSala; private Aposento ApCozinha; private Aposento ApGaragem; private SMSEnvio EnviaSMS; private SMSRecebe RecebeSMS; private String Comando; Command CmdSair = new Command("Sair", Command.EXIT, 2); Command CmdOk = new Command("OK", Command.OK, 1); Command CmdSelecionar = new Command("Selecionar", Command.OK, 1); Command CmdVoltar = new Command("Voltar", Command.EXIT, 1); Command CmdEnviar = new Command("Enviar", Command.OK,2); public TCC_Anderson2() { // Componentes da Tela de Login this.display = Display.getDisplay(this); this.Login = new Form("Login digite Usuario e Senha!"); this.Nome = new TextField("Nome:", "", 20, TextField.ANY); this.Senha = new TextField("Senha:", "", 20, TextField.PASSWORD); DateField df = new DateField("Data:", DateField.DATE); df.setDate(new java.util.Date()); this.Login.append(Nome); this.Login.append(Senha); this.Login.addCommand(CmdOk); this.Login.addCommand(CmdSair); this.Login.append(df); this.Login.setCommandListener(this); // Componentes da Tela de Listagem dos Ambientes
54
this.lista = new List("Selecione o Ambiente ", Choice.IMPLICIT); this.lista.append("Quarto Casal", null); this.lista.append("Quarto Crianças", null); this.lista.append("Quarto de Visitas", null); this.lista.append("Sala", null); this.lista.append("Cozinha", null); this.lista.append("Garagem", null); this.lista.append("--------------------------", null); this.lista.append("RECEBER STATUS DO AMBIENTE", null); this.lista.addCommand(CmdSelecionar); this.lista.addCommand(CmdSair); this.lista.setCommandListener(this); // tela quarto casal ApQuarto_Casal = new Aposento(this.IndQuarto_Sala); ApQuarto_Casal.SetCommandListener(this); ApQuarto_Casal.SetCommand(CmdVoltar); ApQuarto_Casal.SetCommand(CmdEnviar); // tela quarto criancas ApQuarto_Criancas = new Aposento( this.IndQuarto_Sala); ApQuarto_Criancas.SetCommandListener(this); ApQuarto_Criancas.SetCommand(CmdVoltar); ApQuarto_Criancas.SetCommand(CmdEnviar); // tela quarto de visitas ApQuarto_Visitas = new Aposento(this.IndQuarto_Sala); ApQuarto_Visitas.SetCommandListener(this); ApQuarto_Visitas.SetCommand(CmdVoltar); ApQuarto_Visitas.SetCommand(CmdEnviar); // tela da sala ApSala = new Aposento(this.IndQuarto_Sala); ApSala.SetCommandListener(this); ApSala.SetCommand(CmdVoltar); ApSala.SetCommand(CmdEnviar); // tela da cozinha ApCozinha = new Aposento(this.IndCozinha); ApCozinha.SetCommandListener(this); ApCozinha.SetCommand(CmdVoltar); ApCozinha.SetCommand(CmdEnviar); //tela da garagem ApGaragem = new Aposento(this.IndGaragem); ApGaragem.SetCommandListener(this); ApGaragem.SetCommand(CmdVoltar); ApGaragem.SetCommand(CmdEnviar); EnviaSMS = new SMSEnvio(display); RecebeSMS = new SMSRecebe(display, lista); RecebeSMS.SetApQuarto_Casal(ApQuarto_Casal); RecebeSMS.SetApQuarto_Criancas(ApQuarto_Criancas); RecebeSMS.SetApQuarto_Visitas(ApQuarto_Visitas); RecebeSMS.SetApSala(ApSala); RecebeSMS.SetApCozinha(ApCozinha); RecebeSMS.SetApGaragem(ApGaragem); TelaAtiva = Login; } public void startApp() { this.display.setCurrent(TelaAtiva); } /* *Armazenar a ultima tela que se esta apresentando
55
*/ public void pauseApp() { TelaAtiva = this.display.getCurrent(); } public void destroyApp(boolean b) { } public void commandAction(Command c, Displayable d) { if(c == this.CmdSair || c == Alert.DISMISS_COMMAND) { destroyApp(true); notifyDestroyed(); } if(c == CmdOk) { this.SenhaLogin = this.Senha.getString(); this.NomeLogin = this.Nome.getString(); if (SenhaLogin.equals("1234") && NomeLogin.equals("Anderson")) { this.display.setCurrent(lista); } else { destroyApp(true); notifyDestroyed(); } } if (c == CmdSelecionar) { int selectedIndex = ((List) d).getSelectedIndex(); if (selectedIndex == 0) { this.display.setCurrent(ApQuarto_Casal.GetLista()); } if (selectedIndex == 1) { this.display.setCurrent(ApQuarto_Criancas.GetLista()); } if (selectedIndex == 2) { this.display.setCurrent(ApQuarto_Visitas.GetLista()); } if (selectedIndex == 3) { this.display.setCurrent(ApSala.GetLista()); } if (selectedIndex == 4) { this.display.setCurrent(ApCozinha.GetLista()); } if (selectedIndex == 5) { this.display.setCurrent(ApGaragem.GetLista()); } if (selectedIndex == 7) { Alert aviso = new Alert( "Recebimento de Comandos", "Solicitando recebimento de comandos...", null,AlertType.INFO); aviso.setTimeout( 2000 ); this.display.setCurrent( aviso); //Irá receber os comandos RecebeSMS.ReceberMensagem(); String MessRecebida = RecebeSMS.Mensagem; } } if(c == CmdVoltar) { this.display.setCurrent(lista);
56
} if(c == CmdEnviar) { Comando = ""; List Aposento = ApQuarto_Casal.GetLista(); for (int i = 0; i < 5 ; i++) { boolean selet = Aposento.isSelected(i); if (selet == true) { Comando += "QC"+(i)+("n#"); } else { Comando += "QC"+(i)+("f#"); } } Aposento =ApQuarto_Criancas.GetLista(); for (int i = 0; i < 5 ; i++) { boolean selet = Aposento.isSelected(i); if (selet == true) { Comando += "QR"+(i)+("n#"); } else { Comando += "QR"+(i)+("f#"); } } Aposento = ApQuarto_Visitas.GetLista(); for (int i = 0; i < 5 ; i++) { boolean selet = Aposento.isSelected(i); if (selet == true) { Comando += "QV"+(i)+("n#"); } else { Comando += "QV"+(i)+("f#"); } } Aposento = ApSala.GetLista(); for (int i = 0; i < 5 ; i++) { boolean selet = Aposento.isSelected(i); if (selet == true) { Comando += "S"+(i)+("n#"); } else { Comando += "S"+(i)+("f#"); } } Aposento = ApCozinha.GetLista(); for (int i = 0; i < 8 ; i++) { boolean selet = Aposento.isSelected(i); if (selet == true) { Comando += "C"+(i)+("n#"); } else { Comando += "C"+(i)+("f#"); } } Aposento = ApGaragem.GetLista(); boolean selet = Aposento.isSelected(0); if (selet == true) { Comando += "G"+(0)+("n#");
57
} else { Comando += "G"+(0)+("f#"); } EnviaSMS.EnviaMensagem(Comando); } } public void run() { } }
Classe SMSEnviar //CLASSE PARA ENVIO DAS MENSAGENS class SMSEnvio implements Runnable{ //Porta para envio das mensagens SMS static final String PortaEnv = "12345"; //Endereço para envio private String Telefone_Res = "99582554"; //Conteudo da mensagem, contendo os comandos private String comando; private Display display; //Indica se esta deve enviar private boolean Enviar; public SMSEnvio(Display Display) { this.display = Display; this.Enviar = false; } public void EnviaMensagem(String Comando){ this.comando = Comando; this.Enviar = true; try{ new Thread(this).start(); } catch( Throwable e ) { System.out.println("Erro tarefa ENVIO: "); e.printStackTrace(); } } public void run(){ while (this.Enviar){ // comunica ao usuario do envio da mensagem Alert aviso = new Alert( "Enviando Comando..", "Enviando Comandos " +this.Telefone_Res+ "...", null,AlertType.INFO); aviso.setTimeout( 2000 ); this.display.setCurrent( aviso); //URL com o número de telefone e a porta de comunicação String destino = "sms://+" +this.Telefone_Res + ":" +this.PortaEnv; MessageConnection con = null; try { // Abrindo Conexao com a residencia con = (MessageConnection) Connector.open( destino ); // Criando um mensagem de texto TextMessage Enviar_SMS = (TextMessage)con.newMessage(
58
MessageConnection.TEXT_MESSAGE ); // Anexado o conteudo Comando da mensagem Enviar_SMS.setPayloadText( this.comando ); // Envio da mensage con.send( Enviar_SMS ); // comunica ao usuario que a mensagem foi enviada aviso = new Alert( "Enviado "," Comandos enviados com sucesso!", null,AlertType.INFO); this.display.setCurrent( aviso); } catch( Throwable e ) { System.out.println("Erro no envio: "); e.printStackTrace(); } // Encerra a conexao com a residencia finally { if( con != null ) { try { con.close(); this.Enviar = false; } catch( IOException ie ) {} } } } } }
ClasseSMSRecebe //CLASSE PARA RECEBIMENTO DAS MENSAGENS class SMSRecebe implements Runnable, CommandListener, MessageListener{ // Porta para o recebimento das mensagens static final String PortaRec = "54321"; //Endereço do remetente public String EnderecoRecebimento; //Mensagem corrente public String Mensagem; // Message msg; public MessageConnection con; private Display display; //Tela para retornar da aplicacao private Displayable TelaAtiva; private Command CmdRejeitar; private Command CmdProcessar; //Indica se esta deve enviar private boolean Receber = false; //Aposentos a terem seu estado alterado Aposento ApQuarto_Casal; Aposento ApQuarto_Criancas; Aposento ApQuarto_Visitas; Aposento ApSala; Aposento ApCozinha; Aposento ApGaragem; public void SetApQuarto_Casal(Aposento Ap){ this.ApQuarto_Casal = Ap; } public void SetApQuarto_Criancas(Aposento Ap){ this.ApQuarto_Criancas = Ap; }
59
public void SetApQuarto_Visitas(Aposento Ap){ this.ApQuarto_Visitas = Ap; } public void SetApSala(Aposento Ap){ this.ApSala = Ap; } public void SetApCozinha(Aposento Ap){ this.ApCozinha = Ap; } public void SetApGaragem(Aposento Ap){ this.ApGaragem = Ap; } //Construtor public SMSRecebe(Display display, Displayable TelaAtiva) { this.display = display; this.TelaAtiva = TelaAtiva; this.Receber = false; CmdRejeitar = new Command( "Rejeitar",Command.EXIT,1 ); CmdProcessar = new Command( "Processar",Command.OK,2 ); } public void startApp() { } public void ReceberMensagem(){ this.Mensagem = ""; String destino = "sms://:" +PortaRec; if( con == null ) { //Habilita nova tarefa para recebimento try { con = (MessageConnection)Connector.open( destino); // Ativamos o MIDlet como receptor con.setMessageListener( this ); } catch( IOException e ) { e.printStackTrace(); } // comunica ao usuario do envio da mensagem Alert aviso = new Alert( "Recebimento de Comandos", "Aguardando o recebimento...", null,AlertType.INFO); aviso.setTimeout( 3000 ); this.display.setCurrent( aviso); } } // Método que indica a chegada de uma nova mensagem public void notifyIncomingMessage( MessageConnection conn ) { Receber = true; this.run(); } protected void pauseApp() { } protected void destroyApp( boolean flag ) { Receber = false; if( con != null ) { try { con.setMessageListener(null); con.close(); } catch( Exception e ) {} } } public void commandAction( Command c,Displayable d ) { if( c == CmdRejeitar ) { Mensagem = ""; this.display.setCurrent(TelaAtiva);
60
} if (c == CmdProcessar){ Alert aviso = new Alert("PROCESSANDO",this.Mensagem, null,AlertType.INFO); aviso.setTimeout( 3000 ); this.display.setCurrent( aviso); String aStr; String teste =""; int ct = 0; int ct2= 0; List LAp = ApQuarto_Casal.GetLista(); for (int i = 0; i < 5 ; i++) { ct = Mensagem.indexOf(("QC"+(i)+"n"), ct2); teste = (i) +"- "+ ct+" -- "+("QC"+(i)) +"\n "+teste; if (ct> ct2){ } ct2= ct; } Alert aviso = new Alert("TESTE", teste, null,AlertType.INFO); aviso.setTimeout( 3000 ); this.display.setCurrent( aviso); LAp =ApQuarto_Criancas.GetLista(); for (int i = 0; i < 5 ; i++) { boolean selet = LAp.isSelected(i); if (selet == true) { Comando += "QR"+(i)+("n#"); } else { Comando += "QR"+(i)+("f#"); } } LAp = ApQuarto_Visitas.GetLista(); for (int i = 0; i < 5 ; i++) { boolean selet = LAp.isSelected(i); if (selet == true) { Comando += "QV"+(i)+("n#"); } else { Comando += "QV"+(i)+("f#"); } } LAp = ApSala.GetLista(); for (int i = 0; i < 5 ; i++) { boolean selet = LAp.isSelected(i); if (selet == true) { Comando += "S"+(i)+("n#"); } else { Comando += "S"+(i)+("f#"); } } LAp = ApCozinha.GetLista(); for (int i = 0; i < 8 ; i++) { boolean selet = LAp.isSelected(i); if (selet == true) {
61
Comando += "C"+(i)+("n#"); } else { Comando += "C"+(i)+("f#"); } } LAp = ApGaragem.GetLista(); boolean selet = LAp.isSelected(0); if (selet == true) { Comando += "G"+(0)+("n#"); } else { Comando += "G"+(0)+("f#"); } this.display.setCurrent(TelaAtiva); } } public void run(){ try{ Message msg = con.receive(); if( msg != null && msg instanceof TextMessage ) { TextMessage Tmsg = (TextMessage)msg; String origem = msg.getAddress(); EnderecoRecebimento = origem; Mensagem = (String)Tmsg.getPayloadText(); Alert aviso = new Alert(" Origem: "+origem, Tmsg.getPayloadText(), null,AlertType.INFO); aviso.setTimeout( 3000 ); List lista = new List("Comandos recebidos.", Choice.IMPLICIT); lista.addCommand(CmdRejeitar); lista.addCommand(CmdProcessar); lista.setCommandListener(this); this.display.setCurrent( aviso, lista ); } } catch( Throwable e ) { System.out.println("Erro no envio: "); e.printStackTrace(); } // Encerra a conexao com a residencia finally { if( con != null ) { try { con.close(); this.Receber = false; } catch( IOException ie ) {} } } } }
62
Classe Aposento //Definição da Classe dos Aposentos class Aposento{ private List LAposento; //Cria uma nova instancia de um dos aposentos public Aposento(int TipoAposento){ this.LAposento = new List("Selecione os Comandos", Choice.MULTIPLE); switch (TipoAposento){ case 1: this.LAposento.append("Luz",null); this.LAposento.append("Ar-Condicionado",null); this.LAposento.append("Aparelho de Som", null); this.LAposento.append("TV",null); this.LAposento.append("Teto Solar",null); break; case 2: this.LAposento.append("Luz",null); this.LAposento.append("Ar-Condicionado",null); this.LAposento.append("Aparelho de Som", null); this.LAposento.append("Cafeteira", null); this.LAposento.append("Microondas",null); this.LAposento.append("Geladeira",null); this.LAposento.append("Fogao",null); this.LAposento.append("Freezer",null); break; case 3: this.LAposento.append("Luz",null); break; } } public List GetLista(){ return LAposento; } public void SetLista(List Lista){ this.LAposento = Lista; } public void SetCommandListener(CommandListener MIDAnderson){ this.LAposento.setCommandListener(MIDAnderson); } public void SetCommand(Command Comando){ this.LAposento.addCommand(Comando); } }
