Martin André Arnold Dill
Programa Institucional de Bolsas de Iniciação Científica
PIBIC/CNPq - UNIJUÍ 2008-2009
Framework para Desenvolvimento de Aplicações maemo para Dispositivos Móveis
Relatório Final de Atividades
apresentado ao Comitê Científico
da Universidade Regional do
Noroeste do Estado do RS
Orientador: Prof. Dr. Paulo Sérgio Sausen
Departamento de Tecnologia - DeTEC
Ijuí
Agosto de 2009
Sumário
Introdução.....................................................................................................................3
1
INTRODUÇÃO AO MAEMO ..............................................................................4
1.1
2
Principais Tecnologias Envolvidas ..................................................................4
1.1.1
GTK+ e Hildon ........................................................................................4
1.1.2
D-Bus ......................................................................................................4
1.1.3
LibOSSO .................................................................................................5
FERRAMENTAS UTILIZADAS PARA O DESENVOLVIMENTO....................5
2.1
maemo SDK ...................................................................................................5
2.2
Scratchbox ......................................................................................................5
2.3
Xephyr (X Window Server) ............................................................................6
3
LINGUAGENS DE PROGRAMAÇÃO UTILIZADAS ........................................6
4
PYTHON PARA MAEMO ...................................................................................7
4.1
Módulos Python ..............................................................................................7
4.2
Exemplo de Aplicação Python para maemo.....................................................8
5
FRAMEWORK PARA DESENVOLVIMENTO DE APLICAÇÕES....................9
6
PROGRAMA PARA MONITORAMENTO DE SUBESTAÇÃO .......................10
6.1
Base de dados ...............................................................................................12
6.2
Web Service..................................................................................................12
6.3
Aplicação......................................................................................................12
6.3.1
Módulos de Monitoramento em Tempo Real..........................................13
6.3.2
Módulo de Consulta à Base....................................................................13
6.3.3
Módulo de Procura de Erros...................................................................14
6.3.4
Configurações ........................................................................................16
7
CRONOGRAMA DE ATIVIDADES..................................................................17
8
CONSIDERAÇÕES FINAIS...............................................................................18
9
BIBLIOGRAFIA.................................................................................................18
2
Introdução
A computação encontra-se diante de uma importante revolução. Um exemplo
disso é a miniaturização de componentes eletrônicos como memórias e processadores,
permitindo assim a construção de dispositivos pequenos e portáteis, como os atuais
telefones celulares, PDAs, tablet PCs e Internet tablets. Outro ponto interessante nesse
escopo foi o aumento do poder computacional desses dispositivos. Essa característica
possibilitou aos mesmos executarem aplicações cada vez mais complexas, como por
exemplo, jogos eletrônicos, tanto em 2D quanto em 3D, aplicações de multimídia,
dentre outras. Um destes dispositivos é o NOKIA N800, da família dos Internet Tablets,
dispositivo utilizado neste projeto, que roda sob uma plataforma Linux chamada
maemo.
O maemo é um sistema operacional desenvolvido especialmente para rodar em
dispositivos móveis, foi desenvolvido sob a plataforma Linux, baseado na distribuição
Linux Debian. Maemo é de código aberto e foi desenvolvido sob a arquitetura ARM
(Acorn RISC Machine), ARM é uma arquitetura utilizada especialmente por
dispositivos móveis por ser simples, barata e possuir um baixo consumo de energia,
comparado às arquiteturas dos computadores desktop, como, por exemplo, a arquitetura
x86, arquitetura amplamente utilizada nos computadores pessoais.[1]
A plataforma maemo foi anunciado no final de 2004 e lançado em 2005, com o
Nokia 770 Internet Tablet. Em 2006, maemo 2.0 foi introduzido, com duas revisões
posteriores (codinomes Mistral, Scirocco e Gregalle, respectivamente). No início de
2007, maemo 3.0 (codinome Bora) foi lançado juntamente com o tablet Nokia N800,
com muitos aprimoramentos, permitindo o uso de novas ferramentas.
No fim de 2007, a versão 4.0 da plataforma maemo (codinome Chinook) foi
anunciada e rapidamente lançada juntamente com o novo tablet, Nokia N810,
consolidando assim os desenvolvimentos que aconteceram com o maemo 2.2 e 3.0.
Este projeto tem como principal objetivo a construção de um framework para
desenvolvimento de aplicações maemo, este auxiliará qualquer um que deseja
desenvolver aplicações para maemo sem precisar gastar muitos meses aprendendo sobre
o sistema e suas características, o que torna mais prático e eficiente o desenvolvimento.
Após um período inicial de estudo da plataforma maemo, necessário para o
correto andamento do projeto, foi desenvolvida uma aplicação utilizando o framework
proposto comprovando a sua eficiência.
Esta aplicação, na verdade, é parte de um sistema maior, desenvolvido em outros
projetos do Grupo de Automação Industrial e Controle (GAIC), a aplicação
desenvolvida restringe-se ao monitoramento remoto de uma subestação de energia a
partir de um dispositivo móvel, neste caso, o NOKIA N800. Mais detalhes sobre este
dispositivo bem como seu sistema operacional podem ser obtidos na página do projeto
(http://www2.unijui.edu.br/~maemo).
3
1 INTRODUÇÃO AO MAEMO
1.1 Principais Tecnologias Envolvidas
Nesta sessão serão apresentadas as principais tecnologias envolvidas na
plataforma maemo, essenciais para o desenvolvimento de aplicações neste ambiente.
Primeiramente serão apresentados os principais frameworks para a construção das
interfaces gráficas (GTK+ e Hildon) e manipulação de eventos que utilizam interface
com o usuário (janelas, caixas de texto, alertas e etc.).
Também será apresentada a tecnologia D-Bus, uma solução simples, porém muito
poderosa usada na comunicação entre processos no sistema operacional, estes
processos, que normalmente são aplicativos, conversam entre si, D-Bus utiliza um
sistema de mensagens simples e eficientes, economizando processamento e aumentando
o desempenho do sistema operacional maemo.
Por fim será descrita a LibOSSO, uma biblioteca importante e de baixo nível
pertencente ao D-Bus que realiza funções (que serão explicadas no item 1.1.3) nos
aplicativos e tem conhecimento de acontecimentos à nível de hardware e pode ser útil
para avisar os aplicativos sobre possíveis erros no sistema.
1.1.1 GTK+ e Hildon
O maemo foi desenvolvido sob a plataforma GTK+ (GIMP Toolkit) que é uma
biblioteca de elementos de interface gráfica (widgets), escrita em C e orientada a
objetos, para o desenvolvimento de aplicações baseadas em janelas, muito utilizadas em
ambiente Linux.
O maemo também utiliza um framework chamado Hildon, desenvolvido pela
Nokia e baseado nas tecnologias Gnome/GTK+, a fim de melhorar o desenvolvimento
das aplicações para maemo, oferecendo uma extensa quantidade de ferramentas.
1.1.2 D-Bus
Para a comunicação entre processos no sistema maemo é utilizada a tecnologia
D-Bus (o D originalmente vem de "Desktop"). O D-Bus é um sistema de barramento de
mensagens, que é um meio simples para a comunicação entre aplicativos. Além da
comunicação entre processos (IPC, Inter Process Communication), o D-Bus ajuda a
coordenar o ciclo de duração do processo; tornando mais simples e confiável a
codificação de um aplicativo ou demonstrativo de "evento único" executando-os sob
demanda quando seus serviços são necessários.
A maior área de problema que o D-Bus objetiva resolver ou mesmo facilitar a
comunicação entre aplicações de software desktop (geralmente gráficas). O D-Bus tem
um papel muito importante no maemo, visto que é o mecanismo de IPC a ser usado para
utilizar os serviços disponibilizados na plataforma (e dispositivos). Prover serviços
sobre D-Bus é também a maneira mais simples de garantir reuso de componentes de
outras aplicações.[2, 3]
4
1.1.3 LibOSSO
A LibOSSO é uma biblioteca amplamente utilizada pelos aplicativos projetados
para Maemo deverão utilizar. Ela proporciona um mecanismo de notificação para
aplicativos de maneira que podem ser encerrados tranquilamente no caso de
encerramento do sistema ou falta de memória. Além disso, a LibOSSO isola
convenientemente o aplicativo de possíveis mudanças de implementação no nível do DBus.
A LibOSSO também proporciona funções úteis para manusear recursos de
gravação automática e gravação do estado da plataforma, mudanças no modo do
dispositivo e estado do hardware do processo e outros eventos importantes que
acontecem em dispositivos do tipo Internet Tablet. [4]
2 FERRAMENTAS UTILIZADAS PARA O DESENVOLVIMENTO
Nesta sessão serão apresentadas e descritas todas as ferramentas utilizadas no
desenvolvimento de aplicações para maemo, maemo SDK, Scratchbox e Xephyr. Estes
softwares são livres de custo e podem ser instalados em um sistema operacional
GNU/Linux, neste projeto utilizaremos o Sistema Operacional Ubuntu 8.04 LTS.
2.1 maemo SDK
Aplicações maemo podem ser desenvolvidas diretamente no ambiente desktop,
usando o maemo SDK (Kit de Desenvolvimento de Software). O maemo SDK constitui
de um conjunto de bibliotecas e ferramentas que permitem o desenvolvimento de
aplicações para Maemo e Internet Tablets. Este SDK deve ser instalado em um
ambiente Scratchbox para que possa ser útil, pois o maemo, como dito anteriormente,
foi desenvolvido sob a arquitetura ARM, diferentemente dos computadores de propósito
geral que, na maioria, utilizam a arquitetura x86. Por isso deve-se instalar o maemo
SDK em um ambiente Scratchbox, que serve como um emulador e compilador para
outras arquiteturas assim permitindo que o maemo SDK funcione corretamente.[1, 12]
2.2 Scratchbox
Scratchbox é um toolkit de compilação para diversas arquiteturas destinada a
tornar o desenvolvimento de aplicações para Linux embarcado mais fácil. Ela também
fornece um conjunto completo de ferramentas para integrar e compilar toda uma
distribuição Linux.[13]
A idéia básica no uso do Scratchbox é utilizar outro processador denominado
HOST para compilar software para qualquer outra plataforma que será o alvo e que usa
para uma arquitetura diferente, este processador alvo é denominado TARGET. Isto
significa que a máquina na qual você está compilando o software nativamente não pode
executar o software compilado. O software é compilado para outro processador, no
nosso caso, o processador ARM.
Em resumo, o Scratchbox permite criar, compilar e executar programas de uma
determinada arquitetura (i.e., ARM) em uma máquina com a arquitetura x86. Com isso
é obtida uma significativa economia, pois não existe a necessidade do equipamento alvo
durante o desenvolvimento das aplicações.
5
2.3 Xephyr (X Window Server)
O X Window Server proporciona um ambiente básico para a construção de
ambientes GUI: desenho e janelas que se deslocam na tela, interagindo com um mouse
e/ou teclado. O servidor X no X Window Server reúne usuário, entrada (teclado, mouse)
e passa ao conhecimento de aplicações X, chamada X cliente. O servidor X fornece
também uma maneira de mostrar aos clientes X a saída gráfica.
Na Figura 01 há um pequeno exemplo de como o servidor X funciona, na área
de trabalho do usuário situam-se os dispositivos de entrada (mouse e teclado) e também
a saída gráfica (monitor), estes estão ligados ao servidor X que recebe estes dados e os
envia para os clientes (browser e xterm), que são aplicações, então o servidor X recebe a
resposta dos clientes e atualiza o estado das aplicações clientes para o usuário na área de
trabalho. Também pode ser observado na Figura 01 que os clientes podem situar-se
tanto na mesma máquina, quanto na rede.
Figura 01. Exemplificação do funcionamento do X Server.
(http://lions-wing.net/lessons/remote/X_client_server_example.png)
É instalado o Servidor X porque será necessário executar os aplicativos que
desenvolvemos após instalar o SDK. E este exibirá o sistema Maemo e as aplicações
desenvolvidas para fazer os devidos testes e sabermos se o programa está rodando
corretamente. Existem variadas opções de servidores X que podem ser usados, um deles
é o Xephyr, que é o servidor x utilizado em nosso projeto.
3 LINGUAGENS DE PROGRAMAÇÃO UTILIZADAS
A linguagem C/C++ é a única linguagem reconhecida oficialmente para o
desenvolvimento de aplicações maemo, o compilador C/C++ já vem incluído no maemo
SDK para que os programas depois de escritos já possam ser compilados e testados no
próprio Scratchbox. Conforme a TARGET escolhida, que será o computador alvo para
qual o código será compilado, seja x86 ou ARM, o compilador trabalha o código para a
arquitetura selecionada, a TARGET x86 é utilizada para compilar e testar os programas
no Scratchbox, depois de concluída a etapa de desenvolvimento, pode-se utilizar a
6
TARGET para compilar para a arquitetura ARM, que é a arquitetura do tablet, destino
final da aplicação.
É possível utilizar outras linguagens para o desenvolvimento, uma delas é a
linguagem Python. Python é uma linguagem de programação de alto nível interpretada,
interativa, orientada a objetos e de tipagem dinâmica e forte, é muito conhecida por ter
uma sintaxe muito simples e ser muito poderosa, oferecendo vários recursos.
O interpretador Python não é nativo ao maemo SDK nem ao sistema maemo dos
Internet Tablets, mas este é facilmente encontrado para download no site oficial do
Python para maemo (http://pymaemo.garage.maemo.org/), além da documentação e
todo material necessário para iniciar o desenvolvimento de aplicações.
4 PYTHON PARA MAEMO
O desenvolvimento de aplicações com a linguagem de programação Python é
semelhante, senão idêntica, à programação em C/C++, em Python, foi criado um
módulo especifico para a criação de interfaces gráficas baseado em GTK+ do C/C++.
Esse módulo possui todas as classes, métodos e propriedades do Tool Kit escrito
em C, o que facilita muito o desenvolvimento, por ser uma linguagem de altíssimo nível
e com objetivo de facilitar a vida do programador. Resultados preliminares desde
projeto mostram que o desenvolvimento de programas em Python acaba por se tornar
muito mais simples que C, por não haver necessidade de escrever tanto código e a
linguagem ser mais simples de ser declarada.[6]
4.1 Módulos Python
Cada arquivo contendo código Python é denominado um módulo. Na grande
maioria dos casos utiliza-se um ou mais módulos Python em combinação: o
interpretador interativo é adequado para realizar experimentos curtos, mas não para
escrever código de produção.
Um módulo Python consiste de código-fonte contido em um arquivo
denominado com a extensão .py, como tal, pode conter variáveis, funções e classes. Para
fins de nomenclatura, qualquer um destes elementos contidos em um módulo é
considerado um atributo do módulo.
Python, através do módulo, oferece excelentes mecanismos para modular
código-fonte. Esta modularização pode ter diversas motivações: o programa pode ser
extenso demais, ter partes reutilizáveis que devem ser separadas, ou ainda necessitar de
módulos escritos por terceiros. Para utilizar o código de um módulo em uma aplicação
Python o comando import é utilizado.
Como dispositivos portáteis dispõem de recursos limitados (quando comparados
aos computadores desktop ou notebook), foram feitas modificações no Python a fim de
torná-lo mais rápido e estável, portanto vários módulos foram removidos do Python
para Maemo.
Os seguintes módulos foram removidos:
• test
• ctypes/test
• sqlite3/test
• email/test
• _ctypes_test.so
7
• _testcapi.so
• linuxaudiodev.so
• ossaudiodev.so
• audioop.so
• lib-tk
• bsddb
• idlelib
Os seguintes módulos foram removidos, mas são oferecidos por outros módulos:
• pyexpat.so
• xmldom
• xmlsax
• xmlparsers
Os seguintes módulos são precários, instáveis e/ou inseguros, portanto o uso
destes não é aconselhável [5]:
• dbhash
• curses
• posixfile
• getpass
• macpath
• macurl2path
• os2emxpath,
• nturl2path,
• pty
• pyclbr
• rexec
• rlcompleter
• statvfs
• stringold
• telnetlib
• this
• toaiff
• tty
• user
• xdrlib
• aifc
• audiodev
• sunaudio
• sunau
4.2 Exemplo de Aplicação Python para maemo
Nesta sessão será apresentado um pequeno exemplo de aplicação para Maemo
utilizando a linguagem de Programação Python, utilizando os módulos GTK+ e Hildon,
mais detalhes podem ser encontrados no site oficial do Python para maemo:
http://pymaemo.garage.maemo.org.
Este programa é simples e serve para mostrar um pouco da sintaxe do Python, este
exemplo cria uma janela para a aplicação e insere um rótulo (texto) escrito “Hello
World”, o código está logo abaixo e a saída da execução deste programa é ilustrada na
Figura 02.
8
#!/usr/bin/env python2.5
import gtk
import hildon
class HelloWorldApp(hildon.Program):
def __init__(self):
hildon.Program.__init__(self)
self.window = hildon.Window()
self.window.connect("destroy", gtk.main_quit)
self.add_window(self.window)
label = gtk.Label("Hello World!")
self.window.add(label)
label.show()
def run(self):
self.window.show_all()
gtk.main()
app = HelloWorldApp()
app.run()
Esta aplicação exemplo ao ser executada será exibida como na imagem abaixo.
Figura 02. Exemplo de Aplicação Maemo Utilizando Python
(http://test.maemo.org/platform/docs/pythonbora/images/pymaemo_bora/hello_world_3_small.jpg)
5 FRAMEWORK PARA DESENVOLVIMENTO DE APLICAÇÕES
Após o estudo inicial do sistema operacional maemo e a familiarização com o
ambiente de desenvolvimento de software, foi desenvolvido o Framework para
desenvolvimento de aplicações maemo, este framework foi desenvolvido totalmente sob
plataformas livres de custo, o que torna o desenvolvimento totalmente viável para
qualquer pessoa que desejar utilizá-lo.
9
O desenvolvimento inicial de aplicações acontece em ambiente desktop, o que
elimina a necessidade de possuir um dispositivo móvel N800. Neste Framework, o
sistema operacional escolhido para portar as tecnologias que serão utilizadas no
desenvolvimento de aplicações é o Linux Ubuntu 8.04 LTS, esta distribuição Linux foi
escolhida pois possui melhor suporte ao usuário, mais softwares compatíveis e ser uma
distribuição estável, porém outras distribuições Linux podem ser utilizadas.
No sistema operacional da máquina, foi instalado o Scratchbox, software descrito
no item 2.2, responsável pela emulação de distribuições Linux (maemo) que rodam sob
outras arquiteturas (i.e., ARM) e compilação de softwares para estas arquiteturas. Este
software é extremamente necessário, pois sem ele não é possível rodar o maemo SDK.
Sobre o Scratchbox foi instalado o maemo SDK, kit para desenvolvimento de
aplicações maemo, com esta ferramenta e o auxilio do Scratchbox, é possível emular o
maemo e suas funcionalidades necessárias para o desenvolvimento de softwares.
Com estes três itens, já é possível iniciar o desenvolvimento das aplicações, porém
ainda resta escolher uma linguagem de programação a ser utilizada para o
desenvolvimento, neste framework, a linguagem de programação Python (explicada e
exemplificada no item 4) foi a escolhida.
Também é possível utilizar a linguagem de programação C para o desenvolvimento
das aplicações, as ferramentas necessárias para a compilação e execução das aplicações
maemo na linguagem C já estão presentes no maemo SDK, estas variações são
possíveis e tornam o framework flexível, possibilitando novas opções de
desenvolvimento. Este framework e suas partes integrantes pode ser melhor
visualizados na Figura 03.
Figura 03. Framework para desenvolvimento de aplicações maemo
6 PROGRAMA PARA MONITORAMENTO DE SUBESTAÇÃO
Para validar o framework proposto, foi desenvolvida uma aplicação modelo, que
consiste em um subsistema móvel de monitoramento de subestações de energia elétrica,
um módulo móvel, independente e remoto do Sistema de Monitoramento de
Subestações de Energia Elétrica apresentado em [9] e estendido em [10] que é um
projeto desenvolvido pelo Grupo de Automação Industrial e Controle (GAIC) com
apoio da CEEE-D/RS. Este projeto determina inovações tecnológicas para a aquisição
de sinais, processamento e transmissão através de um sistema supervisório.
As principais características deste sistema, que o diferencia dos demais, são a
facilidade de implementação de sistemas micro-processados, a utilização de plataforma
10
de desenvolvimento gratuita, implementação economicamente viável no nível de
hardware e software, portabilidade, mobilidade e segurança, por possuir diversas rotas
de comunicação e possibilidade de utilização de estruturas de rede já existentes.
Os dados captados pela Unidade Remota de Aquisição de Dados (URAD) e pelo
Módulo de Sensores Inteligentes (MSInt) são transmitidos através de Wireless para o
Gateway, na qual são retransmitidos para o Servidor Remoto (SR) e Controlador
Supervisório (CS) via RS 232. O SR pode transmitir os dados via protocolo MODBUS
sobre TCP/IP cabeado ou Wi-Fi para o SR numa rota alternativa conforme ilustra a
Figura 4. Os dados estáticos, como temperatura, podem ser transmitidos pelo MSInt que
tem o diferencial de enviar dados em intervalos maiores com o objetivo de economizar
as baterias. Esta variedade de rotas para a aquisição de dados denota segurança neste
processo do sistema. Na Figura 4 pode ser visto o sistema com as três subdivisões
interconectadas: Subsistema de Aquisição de Dados, Subsistema Servidor Remoto e
Subsistema Controlador Supervisório.
Figura 04. Arquitetura do Sistema de Monitoramento de Subestações Elétricas.
O subsistema de monitoramento móvel, que é a aplicação desenvolvida neste
projeto, foi desenvolvido em três níveis, o primeiro nível é o SGBD, que possui a base
de dados onde estão armazenados todas as grandezas coletadas pela URAD, o segundo
nível é o Web Service (WS), que contém todos os métodos necessários para a leitura dos
dados na base e a linguagem para comunicar-se com a aplicação e enviar os dados para
a mesma. O terceiro nível é composto por uma aplicação, que o usuário utilizará para
monitorar a subestação de energia a partir do NOKIA N800 com o Sistema Operacional
maemo. Na Figura 5 é mostrada a organização do sistema, com o módulo de
monitoramento móvel agregado e a identificação dos níveis deste sistema.
11
Figura 05 - Modelo organizacional do sistema de monitoramento de subestações de
energia elétrica incluindo o subsistema móvel.
6.1 Base de dados
A utilização de um SGBD, hoje em dia, é essencial para o desenvolvimento de
sistemas, ele propicia muitos benefícios e entre eles estão: maior velocidade na
recuperação de dados, grande capacidade de indexação, controle de inconsistência dos
dados, maior segurança e múltiplas transações (pode-se ler e gravar no banco de dados
ao mesmo tempo). Todas essas características não estão presentes em um sistema de
arquivos tradicional, neste caso, como se trata de uma aplicação em tempo real, as
gravações no banco de dados devem ser rápidas, para que o usuário não receba dados
antigos na aplicação[11].
O SGBD utilizado neste projeto é o IBM DB2 Express-C, na Base de dados há uma
tabela principal que guarda todos os dados captados pela URAD (i.e., TA, TB, TC, CA,
CB, CC, FP, PA, PAP), por meio dela, o WS consegue recuperar todos os dados
necessários para a aplicação, um descritivo completo destas grandezas pode ser
consultado em [10].
6.2 Web Service
O WS é o nível que se situa entre a base de dados e a aplicação, WS é uma
solução utilizada na integração de sistemas e na comunicação entre aplicações
diferentes. Com esta tecnologia é possível que novas aplicações possam interagir com
aquelas que já existem e que sistemas desenvolvidos em plataformas diferentes sejam
compatíveis. Permite também que as diferentes partes desse subsistema residam em
máquinas distintas e não necessitem estar próximas fisicamente. Com esse sistema é
possível acessar os dados em qualquer lugar que exista uma conexão com a Internet, a
aplicação poderá conversar com o WS e requisitar os dados.
Um WS baseia-se no protocolo SOAP (Simple Object Access Protocol). SOAP é um
protocolo utilizado para troca de informações estruturadas em uma plataforma
descentralizada e distribuída, utilizando tecnologias baseadas em XML [7,8]. O WS
desenvolvido para o subsistema de monitoramento possui a função de fazer as
negociações entre os dois níveis (aplicação e SGBD) através da Internet. O WS é
instalado no mesmo microcomputador onde se situa a base de dados, e este deve ter um
endereço Internet Protocol (IP) válido, para que possa ser acessado pela aplicação.
6.3 Aplicação
A aplicação de monitoramento da subestação, projetada para ser executada no
dispositivo móvel NOKIA N800, foi desenvolvida utilizando o framework proposto,
utilizando a linguagem de programação Python. Ao executar a aplicação, a janela
principal é carregada, contendo doze botões, nove deles carregam as telas com os
gráficos para a visualização das nove grandezas coletadas pela subestação (i.e., TA, TB,
TC, CA, CB, CC, FP, PA, PAP), um botão para um módulo de consulta á base, outro
módulo de procura de erros e, por ultimo, o botão para a tela de Configurações.
12
6.3.1 Módulos de Monitoramento em Tempo Real
As nove telas para a geração dos gráficos seguem o mesmo princípio, ao clicar
em um dos botões, uma nova tela é carregada e está organizada da seguinte forma: na
parte superior está o título da janela, no meio, ocupando a maior parte da tela, está o
gráfico que exibe os dados recebidos do WS, e na parte inferior, uma área reservada
para emitir avisos/alarmes previamente configurados na aba de configuração (veja
Figura 12).
Ao carregar uma tela, os limites das grandezas e as configurações da base de dados
são carregados e se inicia a conexão com o banco de dados. Internamente, uma função
que realiza a chamada para o Web Service, manipula os dados recebidos, gera o gráfico
e atualiza a tela do programa é chamada periodicamente, em um intervalo de tempo que
pode ser definido pelo usuário na aba “Configurações”. Os dados serão recebidos e
exibidos até que o usuário abandone a tela. O programa recupera sempre os últimos
dados que foram inseridos na base (últimos dados coletados pela URAD), ou seja,
resgata os últimos 20 registros da subestação em tempo real.
A tela que exibe a grandeza Tensão com as fases A, B e C (veja Figura 6), possui
mais duas informações ao usuário: A tensão mais alta e baixa que foram recebidas desde
que a conexão foi iniciada. Os avisos possíveis na tela “Tensão” fases A, B e C são:
sobre e sub tensão.
A tela “Corrente”, semelhante à tela “Tensão” (ver Figura 6), com as fases A, B e C
exibe somente avisos de sobrecarga. Os limites das grandezas Tensão e Corrente são
variáveis, portanto podem ser modificadas na aba “Configurações” de acordo com os
limites que o usuário desejar. As telas que exibem a Potência Ativa, Potência Aparente e
Fator Potência não emitem nenhum tipo de aviso, apenas exibem os dados coletados
pelo WS na base de dados. Na Figura 6 é mostrado um gráfico com os valores online da
Tensão na Fase A.
Figura 06. Tela “Tensão Fase A” da aplicação de monitoramento móvel de subestação.
6.3.2 Módulo de Consulta à Base
Após o desenvolvimento dos módulos de monitoramento em tempo real
(Tensões, Correntes e Potências), foi desenvolvido um novo módulo, cujo objetivo é
realizar consultas para analisar situações anteriores da subestação. Este módulo será de
grande utilidade para o operador da subestação, que não necessitará estar atento o tempo
todo á subestação.
13
Ao clicar no botão Consultar Base, na Tela principal do programa, uma nova tela
é exibida, contendo um formulário (ver Figura 07) com as seguintes opções: Grandeza,
data, hora inicial, hora final e numero de registros. Na opção grandeza é selecionada a
grandeza que será consultada na base de dados (Tensões, Correntes, Potências), na
opção data, deve ser informado a data a ser consultada, na opção hora inicial, deve-se
informar a hora em que se iniciará a consulta.
Das ultimas duas opções, hora final e número de registros, apenas uma pode ser
escolhida. Escolhendo a opção hora final, deve-se informar a hora em que terminará a
consulta, formando então um intervalo de consulta baseados na hora inicial e final. Ao
clicar no botão “gerar gráfico” será exibido um gráfico (ver Figura 08) mostrando a
média aritmética de cada minuto no intervalo definido.
Entretanto se a opção número de registros for escolhida, a opção ser selecionada
é a quantidade de registros a serem exibidos a partir da hora inicial, então será exibido
em formato de gráfico os primeiros n registros resultantes da base a partir da hora
inicial.
Figura 07. Formulário de Consulta à Base de Dados
Figura 08. Gráfico da Consulta à Base
6.3.3 Módulo de Procura de Erros
Após a conclusão do módulo de consulta à base de dados, foi desenvolvido um
novo módulo, que é o módulo de Procura de Erros. Um dos principais objetivos do
sistema de monitoramento de subestações é analisar as grandezas coletadas a fim de
14
encontrar erros, e a partir destes erros, localizar as possíveis causas e melhorar a
distribuição de energia para que estes erros não mais ocorram, e este módulo de procura
de erros facilitará ainda mais esta tarefa.
O módulo de procura de erros visa encontrar as sub-tensões, sobre-tensões e
sobrecargas ocorridas em um intervalo de tempo definido pelo usuário. Para um dado de
grandeza ser classificado como um erro, ele deve estar fora da faixa de valores de limite
definidos na tela de configurações. Ao clicar no botão “Ocorrência de erros” uma nova
tela contendo um formulário é carregada (ver Figura 09), neste formulário há as
seguintes opções a serem selecionadas: “Grandeza”, define qual será a grandeza pela
qual serão procurados os erros, podem ser escolhidas as tensões, correntes ou, até
mesmo, todas estas opções.
Ao escolher uma tensão ou uma corrente, deve-se escolher o tipo de erro à ser
procurado, os erros possíveis são sub-tensão e sobre-tensões para as Tensões e
sobrecarga para as Correntes, ao escolher a opção “todas” todos os erros serão
procurados. As outras três opções “Data”, “Hora Inicial” e “Hora Final” são referentes
ao intervalo de tempo em que serão procurados estes erros.
Figura 09. Formulário Ocorrência de Erros
Ao escolher todas as grandezas, informar o intervalo de tempo e clicar no botão
“Procurar Ocorrências”, uma requisição é feita para o Web Service, que procurará na
base de dados todos os erros das Tensões e Correntes, e exibirá uma nova tela exibindo
os tipos de erros e a quantidade de erros encontrados, esta tela é exibida na Figura 10.
Figura 10. Tela de Erros Encontrados
15
Ao clicar em um dos botões de “Ver Ocorrências” serão carregadas as
informações sobre os erros em uma nova janela, em formato de tabela, os erros
disponíveis são: Hora inicial do erro, Hora final do erro, Valor Médio (Volts), e Valor
do Pico (Volts), um exemplo desta tela pode ser visto na Figura 11.
Figura 11. Tabela de informações sobre os erros.
Ao escolher apenas uma grandeza para exibição dos erros, a tabela de Erros será
exibida de forma direta, pois se trata apenas de uma grandeza e um tipo de erro.
6.3.4 Configurações
Na aba de Configurações, é possível editar os limites das grandezas e as
configurações da base de dados. Na aba “Limites” é possível configurar a tensão
nominal da subestação (Volts), os limites de sub e sobre tensão (%), o limite de
sobrecarga (Amperes) e também o intervalo de tempo (segundos) em que será
atualizado os dados nos gráficos.
Na aba “Base de dados” é possível alterar o endereço IP do servidor do WS, o nome
da base de dados, o usuário e a senha para acessar a base. Estas configurações não são
registradas em uma base de dados, por serem poucos bytes de informação, portanto foi
utilizado um arquivo seqüencial (arquivo de texto) para armazenar essas configurações
e este fica salvo no diretório raiz da aplicação.
Figura 12. Tela Configurações, rodando no ambiente Scratchbox (aba “Limites”
selecionada).
16
7 CRONOGRAMA DE ATIVIDADES
As atividades desenvolvidas no projeto foram realizadas de acordo com o
cronograma de atividades proposto (ver Tabela 01). Os itens um e dois que são a
revisão bibliográfica sobre o sistema operacional maemo e o estudo do ambiente de
desenvolvimento de softwares para maemo já foram totalmente concluídos. Nestas
etapas foram instalados todos os softwares e ferramentas necessárias para o
desenvolvimento das aplicações para maemo (maemo SDK, Scratchbox e Xephyr),
também foi efetuada a revisão sobre o sistema operacional e todos seus principais
componentes (GTK+, Hildon, D-Bus e etc.).
O conhecimento nas linguagens de programação C/C++ e Python foram
fortalecidos e muitos exemplos de aplicações para maemo foram criados, compilados e
executados tanto no maemo SDK quanto no dispositivo alvo (Nokia N800).
Um site com todo o material pesquisado até aqui, incluindo exemplos de
aplicações para maemo em C/C++ e Python, tutoriais de instalação das ferramentas para
o desenvolvimento pode ser acessado em http://www2.unijui.edu.br/~maemo.
O framework de desenvolvimento foi estruturado, então utilizando este
framework foi desenvolvida a aplicação modelo, após o desenvolvimento em ambiente
desktop a aplicação foi instalada e configurada no Internet Tablet N800 com sucesso,
como pode ser visto na Figura 13. A publicação dos resultados está descrita no item oito
deste relatório.
Figura 13. Nokia N800 rodando aplicação de monitoramento de subestação.
Atividades
1. Revisão bibliográfica e estudos iniciais sobre o sistema operacional maemo/Symbian;
2. Estudo do ambiente de desenvolvimento de softwares da plataforma maemo;
3. Definição da aplicação a ser desenvolvida no maemo SDK;
4. Estruturação e montagem inicial do framework e desenvolvimento de uma
aplicação modelo;
5. Instalação e configuração da aplicação em um dispositivo móvel (i.e., smartphone
17
ou tablet);
6. Publicação dos resultados da pesquisa e elaboração do relatório final das
atividades desenvolvidas no projeto;
Atividades 10/08 11/08 12/08 01/09 02/09 03/09 04/09 05/09 06/09 07/09
1
x
x
x
2
x
x
x
x
3
x
x
x
4
x
x
x
5
x
x
x
6
x
x
x
Tabela 01: Cronograma de atividades do projeto.
8 CONSIDERAÇÕES FINAIS
A partir dos resultados parciais deste projeto, foi submetido um artigo para o
evento: Brazilian Conference on Dynamics Control and Applications DINCON – 09,
com título: Automação de Subestações de Energia Elétrica Utilizando Dispositivos
Móveis, o artigo foi aceito e consta nos anais do evento como artigo completo, este
também foi apresentado no evento que aconteceu na Universidade Estadual de São
Paulo - UNESP na cidade de Bauru, nos dias 18 a 22 de Maio.
Também está sendo desenvolvido um novo recurso que permitirá que a aplicação
seja alertada pelo servidor quando houver falhas na subestação, para isso um novo
módulo será desenvolvido e ficará disponível no servidor, para que quando ocorrerem
falhas, este possa enviar avisos à aplicação. Para o desenvolvimento desta nova rotina
será utilizada a Linguagem Java, Java possui mais recursos e, por esta razão, é mais
indicada para o desenvolvimento deste módulo.
Outra atividade de continuidade deste projeto é a troca do Web Service do módulo
remoto, inicialmente escrito em Python, por um Web Service mais robusto, em Java,
que oferecerá melhores recursos para a troca de informações, o principal motivo da
troca é a limitação do módulo para captura de dados na base de dados do servidor
causadas por falhas nos módulos integrantes que constituíam este Web Service.
As atividades mencionadas como extensão do projeto inicial serão iniciadas no
novo período de bolsa (renovação). Cabe ressaltar que pretendemos, a partir do término
deste projeto (conclusão do cronograma apresentado na Tabela 01) submeter um novo
artigo (extensão do artigo do DINCON), com as novas opções da aplicação modelo para
a revista do CCEI, que atualmente é classificada como B3 Interdisciplinar WebQualis.
9 BIBLIOGRAFIA
[1] Fórum Nokia. (s.d.). Acesso em 09 de Fevereiro de 2009, disponível em
http://wiki.forum.nokia.com/index.php/Category:Maemo_(Portugu%C3%AAs)
[2] Fórum Nokia. (s.d.). Acesso em 10 de Fevereiro de 2009, disponível em
http://wiki.forum.nokia.com/index.php/DBUS_(Portugu%C3%AAs)
18
[3] Introdução ao D-Bus. (s.d.). Acesso em 10 de Fevereiro de 2009, disponível em
Free Desktop: http://www.freedesktop.org/wiki/Software/dbus
[4] Mobile Linux Internet Project. (s.d.) Acesso em 10 de Fevereiro de 2009, disponível
em: http://v1.moblin.org/toolkits/prepDev/brazilian-portuguese/developmentlibraries.php
[5] Módulos e comando import. (s.d.). Acesso em 13 de Fevereiro de 2009, disponível
em Async Open Source : http://www.async.com.br/projects/python/pnp/node34.html
[6] Using Python for maemo. (s.d.). Acesso em 15 de Fereveiro de 2009, disponível em
Python for maemo:
http://pymaemo.garage.maemo.org/documentation/pymaemo_tutorial/python_maemo_h
owto.html
[7] Rommel, Marcus. Simple Object Access Protocol - Entendendo o Simple Object
Access Protocol (SOAP)
[8] W3Schools, SOAP Tutorial Acesso em 01 de Abril de 2009, disponível em
http://www.w3schools.com/ soap/default.asp
[9] Salvadori, F.; Sausen, P.S.; Hartmann, L.V.; Campos M., Padoin, E.L;
“Acquisition And Transmission Data Monitoring System Applied To Energy
Substation”, Industrial Informatics, 2003. INDIN 2003. Proceedings. IEEE International
Conference on 21-24 Aug. 2003 Page(s):60 – 64, Banff, Alberta, Canada.
[10] Padoin, E. L., Salvadori, Fabiano, Campos, Maurício de, Sausen, Paulo Sérgio,
Dill, Sérgio Luis, Idalencio, T. A.. Mobilidade no Monitoramento de Subestações
Elétricas através de Serviços Web. In: VI SIRC - Simpósio de Informática da Região
Centro do RS, 2007, Santa Maria. VI SIRC - Simpósio de Informática da Região Centro
do RS, 2007.
[11] Navathe; Elmasri. Sistema de Banco de Dados: Fundamentos e Aplicações.
Terceira Edição. Editora LTC, 2002, P 795.
[12] maemo.org. (s.d.). Acesso em 09 de maio de 2009, disponível em
http://www.maemo.org
[13] Scratchbox. (s.d.). Acesso em 09 de maio de 2009, disponível em
http://www.scratchbox.org/
19
20