Visualizar - Polis Educacional

Transcrição

Leonardo Torati
RA: 0205022 – 8º SEM
INTERFACE PARA CONTROLE DE MOVIMENTOS DE UM
ROBÔ TIPO ARANHA COM QUATRO PATAS (AR+)
Jaguariúna
2005
1
Leonardo Torati
RA: 0205022 – 8º SEM
SISTEMA DE CONTROLE DO ROBÔ AR+
INTERFACE PARA CONTROLE DE MOVIMENTOS DE UM
ROBÔ TIPO ARANHA COM QUATRO PATAS (AR+)
Monografia apresentada à disciplina Trabalho
de Conclusão de Curso, do Curso de Ciência da
Computação da Faculdade de Jaguariúna, sob
a orientação do Prof. André Mendeleck, como
exigência parcial para conclusão do curso de
graduação.
Jaguariúna
2005
2
TORATI, Leonardo. Interface para controle de movimentos de um robô tipo aranha com
quatro patas. Monografia defendida e aprovada na Faculdade de Jaguariúna – FAJ no dia
16.DEZ.05 pela banca avaliadora:
__________________________________________________________________________
Prof. André Mendeleck
Orientador – Faj
__________________________________________________________________________
Prof.
Presidente da Banca Avaliadora
__________________________________________________________________________
Prof.
Convidado
3
AGRADECIMENTOS
Gostaria de agradecer a todas as pessoas que, de alguma forma, colaboraram para a
realização desta Monografia.
Em particular, gostaria de agradecer:
ao Prof. André Mendeleck, orientador do trabalho, por acreditar na minha capacidade
de realização e por compartilhar um pouco do seu conhecimento comigo, orientando
sabiamente os meus passos para a realização desta Monografia.
aos Professor Paulo por ensinar a essência da criação de uma monografia e aos
professores Peter e Silvio, por me ajudarem no desenvolvimento das técnicas de
programação empregadas no desenvolvimento do software de controle do robô tipo aranha.
4
RESUMO
Face às exigências por qualidade e produtividade, cada vez mais está se automatizando os
processos produtivos. Por exemplo, tornos com controle numérico, robôs de montagem e
soldagem, permitem a uniformização da qualidade e flexibilizam a linha da produção. Por
outro lado, robôs são utilizados para explorar lugares onde, por enquanto, o homem ainda
não pode ir, como o fundo do oceano ou os planetas "próximos" da Terra. Para isso, esses
robôs precisam movimentar-se de forma autônoma, geralmente sob a supervisão de um
sistema computadorizado que está embarcado no mecanismo, contudo, algumas aplicações
necessitam de intenso processamento que é realizado externamente. Assim, deve-se
estabelecer um meio de comunicação. Existem vários meios de realizar a comunicação do
robô com o computador. A comunicação através da porta serial é um exemplo de
comunicação utilizado e o robô precisa ser capaz de interpretar os comandos enviados pelo
computador. Para o robô tipo aranha com quatro patas (AR+) desenvolvido neste projeto,
são utilizados servo-motores para permitir o movimento das patas e o sistema desenvolvido
(ARc) para controlar o robô permite a criação de seqüências de movimentos. As seqüências
criadas pelo sistema ARc podem ser salvas e reutilizadas. O sistema foi desenvolvido na
linguagem Java e utiliza o banco de dados Firebird para armazenar as seqüências de
movimentos.
Palavras-chave: ROBÓTICA, ROBÔ ARANHA, SERVO-MOTOR.
5
ABSTRACT
In this work we developed a system and a Man Machine Interface to control the moviments
of a four legs mobile robot called spider robot. The system can move the robot front, back,
left and right sides. The robot has four legs with two articulations each. The actuators are
servo-motors with position control. The system was developed using JAVA language and
FIREBIRD data base system.
6
Sumário
1. INTRODUÇÃO................................................................................................................ 08
1.1. Robótica....................................................................................................................... 08
1.2. Robótica Móvel ............................................................................................................ 10
2. METODOLOGIA ............................................................................................................. 13
3. O ROBÔ ......................................................................................................................... 14
3.1. Projeto: Interface para controle de movimento de um robô aranha de quatro patas .. 14
3.2. Componentes utilizados .............................................................................................. 14
3.3. Estrutura ...................................................................................................................... 17
3.4. Movimentos ................................................................................................................. 19
3.5. Sistema de controle ..................................................................................................... 21
4. “AR” – ROBÔ ARANHA DE QUATRO PATAS............................................................... 26
4.1. Movimento ................................................................................................................... 27
4.2. Projeto ......................................................................................................................... 28
5. DIVISÃO DO SISTEMA “ARc”........................................................................................ 29
5.1. Classes de informação (Módulos de informação) ....................................................... 29
6. NÍVEL BAIXO ................................................................................................................. 33
6.1. Relação entre os módulos do nível Baixo ................................................................... 37
7. NÍVEL ALTO ................................................................................................................... 38
7.1. Módulos de controle .................................................................................................... 38
7.2. Módulos de interação .................................................................................................. 41
7.3. Relação entre os módulos do nível Alto ...................................................................... 46
8. NÚCLEO......................................................................................................................... 47
9. BANCO DE DADOS ....................................................................................................... 49
9.1. Tabelas ........................................................................................................................ 49
10. TRAJETÓRIA DE UM COMANDO ............................................................................... 53
10.1. Trajetória do comando na visão do operador ............................................................ 53
10.2. Trajetória do comando na visão do sistema .............................................................. 54
11. CONCLUSÃO ............................................................................................................... 57
Bibliografia ........................................................................................................................... 58
ANEXO 1 – Código Fonte do Sistema ARc
7
Lista de Ilustrações
Figura 1 – Servo-Motor......................................................................................................14
Figura 2 – Placa Servo-Controladora SB Servo-Control ...................................................15
Figura 3 – Conector do Servo-Motor .................................................................................15
Figura 4 – Pulsos para o servo-motor ...............................................................................16
Figura 5 – Estrutura Básica ...............................................................................................18
Figura 6 – Disposição dos componentes...........................................................................18
Figura 7 – Articulações das patas .....................................................................................19
Figura 8 – Pata estendida na direção contrária à base .....................................................20
Figura 9 – Pata estendida na direção da base ..................................................................20
Figura 10 – Movimento para o sentido oposto à base.......................................................21
Figura 11 – Sistema de controle........................................................................................21
Figura 12 – IHM .................................................................................................................23
Figura 13 – Seqüências NPA e NSAs ...............................................................................24
Figura 14 – NPA e NSAs ...................................................................................................24
Figura 15 – ICM .................................................................................................................25
Figura 16 – Identificação das patas e motores..................................................................26
Tabela 1 – Posição dos motores nas patas.......................................................................26
Tabela 2 – Comando .........................................................................................................31
Figura 17 – Escalonador....................................................................................................35
Figura 18 – Relação entre os módulos do nível Baixo ......................................................37
Figura 19 – Árvore do Desmontador NSA .........................................................................39
Figura 20 – Loop na execução de um NSA.......................................................................40
Figura 21 – Tela Principal..................................................................................................41
Figura 22 – Tela de Edição NPA .......................................................................................42
Figura 23 – Tela de Edição NSA .......................................................................................44
Figura 24 – Tela de Configuração .....................................................................................45
Figura 25 – Relação entre os módulos do nível Alto .........................................................46
Figura 26 – Relação entre os módulos através do Núcleo................................................48
Tabela 3 – Comando .........................................................................................................50
Tabela 4 – Exemplo de comando armazenado .................................................................50
Tabela 5 – Exemplo tabela NSA........................................................................................51
Tabela 6 – Exemplo tabela NSA Lista ...............................................................................51
8
1. INTRODUÇÃO
A automação de processos, equipamentos e manufaturas atinge as mais variadas áreas do
contexto sócio-econômico e do nosso cotidiano. Como ator principal, o computador e seus
agregados de hardware e software tem facilitado a implementação de processos produtivos
e melhorado a qualidade de vida. Assim, novas tecnologias e novos equipamentos surgem
para facilitar ou, até mesmo, automatizar determinadas tarefas rotineira. Por exemplo,
pequenos robôs são utilizados para explorar lugares onde, por enquanto, o homem ainda
não pode ir, como o fundo do oceano, outros planetas, ou realizando atividades
"domésticas" de limpeza. Como características principais, esses elementos robóticos devem
ser autônomos e Ter capacidade de auto-aprendizado.
1.1 Robótica
A busca de qualidade total no processo produtivo e manufatura fazem surgir uma crescente
demanda de tarefas com eficiência, eficácia e precisão. Existem também tarefas a serem
realizadas em lugares onde a presença humana se torna difícil, arriscada e até mesmo
impossível, como o fundo do mar ou a imensidão do espaço. Para realizar essas tarefas, se
faz cada vez mais necessária a presença de dispositivos (robôs), que realizam essas tarefas
sem risco de vida. A robótica é a área que se preocupa com o desenvolvimento de tais
dispositivos.
A Robótica é uma área multidisciplinar que busca o desenvolvimento e a integração de
técnicas e algoritmos para a criação de robôs. A robótica integra contextos comuns às áreas
de engenharia mecânica, engenharia elétrica, inteligência artificial, entre outras, que se faz
necessária para se projetar essas maravilhosas tecnologias. [CAEIRO; SERRA; JORGE, O
primeiro grande..., 19.JUN.05]
Os robôs permeiam as mais variadas áreas de nossa sociedade: robôs que prestam
serviços, como os desarmadores de bomba, robôs com a nobre finalidade da pesquisa
científica e educacional, robôs médicos, robôs de manipulação e até mesmo os robôs
operários, que se instalaram em nossas fábricas e foram responsáveis pela "segunda
9
Revolução Industrial", revolucionando a produção em série e fornecendo maior qualidade
aos produtos.
Uma dos maiores sonhos do homem é construir uma máquina com "Inteligência Artificial"
capaz de agir e pensar como ele. No entanto, este desejo esconde em seu subconsciente a
vontade de possuir um "escravo metálico" que satisfaça todos os seus desejos. "Este sonho
humano está perto de se tornar realidade com o espantoso avanço da tecnologia
computável". [LIMA, Home Page. 10.ABR.05]
A palavra robô tem origem da palavra tcheca robotnik, que significa servo, o termo robô foi
utilizado inicialmente por Karel Capek em 1923, nesta época a idéia de um "homem
mecânico" parecia vir de alguma obra de ficção.
Não é só do homem moderno o desejo de construir tais robôs, existem alguns fatos
históricos que nos mostram que a idéia não é nova, por exemplo, existem inúmeras
referências sobre o "Homem Mecânico" construído por relojoeiros com a finalidade de se
exibir em feiras. [LIMA, Home Page. 10.ABR.05]
Temos relatos também da realização de várias "Animações Mecânicas" como o leão
animado de Leonardo da Vinci, e seus esforços para fazer máquinas que reproduzissem o
vôo das aves. Porém estes dispositivos eram muito limitados, pois não podiam realizar mais
que uma tarefa, ou um número reduzido delas. [KLICKEDUCAÇÃO, Quem foram....
10.OUT.05]
A idéia de se criar máquinas que substituíssem o trabalho humano já é bem antiga, sendo
datada desde a Grécia antiga com Ctesibus, em 270 A.C, que desenvolveu figuras
animadas movidas com a energia da água. O primeiro robô móvel foi o robô Shakey,
desenvolvido nos laboratórios do Instituto de Pesquisas de Stanford no ano de 1966. Apesar
de ser pioneiro, o robô já possuía muitos dos recursos utilizados atualmente na grande
maioria dos robôs: [TOURINO, Sistema de rastreamento..., 22.MAI.05]
- Câmera de TV;
- Sensor por triangulação laser;
- Sensores de colisão por contato;
- Conexão via rádio com computadores PDP-10 e PDP-15 (figura ) para controle e vídeo;
- Programas para percepção do ambiente, modelagem e ação.
10
Um robô é qualquer dispositivo capaz de executar alguma tarefa normalmente realizada
pelo homem, como por exemplo, movimentar peças. [TORATI, Leonardo]
A idéia de se construir robôs começou a tomar força no início do século XX com a
necessidade de aumentar a produtividade e melhorar a qualidade dos produtos. É nesta
época que o robô industrial encontrou suas primeiras aplicações, o pai da robótica industrial
foi George Devol. [CAEIRO; SERRA; JORGE, O primeiro grande..., 19.JUN.05]
Atualmente devido aos inúmeros recursos que os sistemas de microcomputadores nos
oferecem, a robótica atravessa uma época de contínuo crescimento que permitirá, em um
curto espaço de tempo, o desenvolvimento de robôs inteligentes fazendo assim a ficção do
homem antigo se tornar a realidade do homem atual.
Sem dúvida a automação industrial foi, e é um grande impulsionador da tecnologia de
robótica. Cada vez mais tem se procurado aperfeiçoar os dispositivos, dotando-os com
inteligência para executar as tarefas necessárias. Por exemplo, usando Redes Neurais
procura-se a linearização de acionamentos eletromecânicos; com Fuzzy Logic pode-se fazer
o planejamento de trajetória para robôs redundantes; ou utilizando Sistemas Especialistas é
possível a detecção de problemas e/ou rapidamente encontrar soluções para problemas
específicos.
1.2 Robótica Móvel
"Um robô móvel é um robô com capacidade de se locomover, ou seja, um sistema que
possui auto-propulsão, capacidade de locomoção (re)programável, controle automático ou
semi-automático e capacidade de realizar uma determinada tarefa." [TORATI, Leonardo]
Existem robôs móveis que atuam em diferentes ambientes como terrestres, aquáticos, subaquáticos, robôs voadores e até mesmo robôs espaciais, como telescópios robotizados ou
que atuam em outros planetas, como os robôs exploradores enviados para marte
(Opportunity, Sojourner).
Existem diversos critérios que classificam os robôs móveis:
11
-
Tipo de locomoção
o
Rodas: como veículos convencionais
o
Pernas: como insetos
Quadrúpedes: quatro patas
Hetópodes: seis patas
o
Hovers: flutuam por meio de fluxo de ar.
-
Tipo de estrutura (rígida, flexível, única, modular)
-
Forma geométrica
o
Simples, como retêngulo, circular
o
Complexa - multi articulada como as rótulas
-
Ambiente de funcionamento (terrestre, aquático, sub-aquático, aéreo, espacial, etc.)
-
Nível de autonomia
o
Tele operado, com supervisão humana remota
o
Totalmente autônomo, sem supervisão
A aplicabilidade de robôs móveis é muito ampla, principalmente as plataformas móveis
intercambiáveis. A seguir apresentamos alguns exemplos:
- Alguns exemplos de atividades já executadas por robôs móveis:
-
Desarmamento de bombas e artefatos perigosos e localização de sobreviventes em
áreas de risco: O desarmamento de artefatos explosivos envolve um grande risco de
vida e esse tipo de robô tem por função permitir que um especialista perito em
explosivos possa desarmar o dispositivo perigoso sem envolver risco de vida. O
especialista controla o robô a uma distância segura, através de câmeras ele vê o que
o robô vê e utiliza ferramentas instaladas no robô para executar a tarefa de desarmar
o artefato explosivo. Esse tipo de robô móvel também é utilizado para procurar por
sobreviventes
em
áreas
risco
como,
por
exemplo,
entre
escombros
de
desabamentos, locais com gás tóxicos presentes, etc. [SANTUCI CARVALHO,
15.MAI.2005]
-
Recuperação de turbinas em usinas hidrelétricas: Pesquisadores da Universidade
Federal de Santa Catarina (CTC-UFSC) e do Instituto de Tecnologia para o
Desenvolvimento (Lactec), de Curitiba (PR), desenvolveram o primeiro robô capaz
de recuperar pás das turbinas de usinas hidrelétricas do Brasil. Chamado de
12
Roboturb, projeto foi apresentado nesta semana em Florianópolis. O Roboturb é um
robô soldador, que se fixa nas paredes das pás das turbinas por meio de ventosas.
Ele possui ainda um trilho, no qual ele consegue mobilidade suficiente para atuar em
uma área maior da pá sem precisar se deslocar. [INOVAÇÃO TECNOLÓGICA, Robô
brasileiro..., 25.MAI.2005]
-
Pesquisa submarina: Um pequeno submarino robô chamado Spray é um robô
autônomo que atravessou a corrente do Golfo coletando dados científicos. Lançado
no dia 11 de Setembro de 2004, cerca de 100 milhas náuticas ao sul da ilha
Nantucket, Estados Unidos, o submarino de dois metros de comprimento chegou às
Bermudas após viajar por mais de 600 milhas a uma velocidade de cerca de um
quilômetro por hora, a uma profundidade de 1.000 metros. Três vezes ao dia o Spray
ia
até
a
superfície,
sempre
coletando
dados
científicos.
[INOVAÇÃO
TECNOLÓGICA, Robô submarino..., 25.MAI.2005]
Este ano (2005), na Feira Internacional de Ciência e Engenharia da Intel, um aluno
português de 18 anos desenvolveu e apresentou um protótipo de uma aranha robô com seis
patas. Carlos Arsénio, aluno que desenvolveu o projeto, disse ter utilizado pernas para
melhor mobilidade do robô e que, um robô com essa capacidade de mobilidade poderia ser
utilizado para várias funções, desde construção civil até desarmamento de bombas.
[ANSÉNIO, Um Robot Aranha, 29.SET.05]
13
2. METODOLOGIA
Através de pesquisas sobre robôs e robôs móveis será possível entender aspectos básicos
sobre o funcionamento, os componentes, os movimentos e o controle desses equipamentos,
podendo, assim, realizar novas pesquisas desses aspectos básicos individualmente focando
nas necessidades
para realização do projeto. Através das informações adquiridas nas
pesquisas será possível desenvolver um modelo do robô aranha de quatro patas e aplicar
estudos sobre a estrutura, os movimentos, etc.
Um elemento fundamental para a operacionalidade do mecanismo é o software gestor de
movimentos. Realizamos várias pesquisas para levantar as informações necessárias sobre
as características (requisitos) do software, será feito um estudo sobre uma linguagem de
programação que permita o desenvolvimento tanto da parte lógica quanto da parte visual do
sistema e um banco de dados de fácil utilização. Um protótipo real do robô aranha de quatro
patas deverá ser construído para testes práticos do sistema de controle. Será desenvolvida
uma interface visual para o sistema de controle, que vai permitir que pessoas operando o
computador (operadores) controlem o robô aranha de quatro patas.
14
3. O ROBÔ
3.1 Projeto: Interface para controle de movimento de um robô
aranha de quatro patas (AR+)
O robô AR+ (aranha robô de quatro patas) é um robô móvel do tipo quadrúpede, servocontrolado e seu controle é feito totalmente por computador pela porta serial através de uma
interface gráfica com o operador.
O operador (usuário), através de um programa, informa quais movimentos o robô deve
executar, o programa gera os comandos necessários para executar tais movimentos e os
envia para o robô através da porta serial. Uma placa servo-controladora, situada no centro
do robô, recebe os comandos do computador e os interpreta fazendo movimentar oito servomotores, dois em cada uma das quatro patas do robô.
3.2 Componentes utilizados
O AR+ possui oito servo-motores e uma placa servo-controladora.
Figura 1 - Servo-motor
VCC
5V
3A
MOTORES
PIC
16F628
MAX
232
COMPUTADOR
CNEXÃO SERIAL
CONTROLE
VCC
GND
15
PO TÊNCIA
Figura 2 – Placa Servo-Controladora SB Servo-Control
Os motores possuem três conectores: alimentação de energia, terra e controle. Cada motor
precisa de uma tensão de alimentação e sinais no conector de controle entre 4,6 e 6 V.
CONTROLE
VCC 4.6 a 6 V
TERRA (GND)
Figura 3 - Conector do Servo-Motor
A placa controladora de servo-motores, SB Servo Control da Solbet, é conectada ao
computador pela porta serial (RS232-C), por onde recebe os comandos, e tem capacidade
de controlar até oito servo-motores. Também possui integrada toda a eletrônica necessária
para implementar um sistema capaz de se posicionar em um determinado ângulo, sob o
16
comando de um sinal eletrônico. O controle do servo-motor é realizado através de pulsos de
amplitude constante de 5V na sua entrada de controle.
Os pulsos de controle devem se repetir a cada 25~30 ms. Se o pulso tiver uma largura de
1,5 ms, o servo ficará na posição central. Com um pulso de 1 ms o servo se deslocará todo
para a esquerda, e um pulso de 2 ms provocará desvio do servo para toda a direita.
Pulso de 1 ms - Esquerda
Pulso de 1,5 ms - Centro
Pulso de 2 ms - Direita
Figura 4 – Pulsos para o servo-motor
Esses pulsos devem ser mantidos durante todo o tempo. A falta dos pulsos irá fazer com
que o servo retorne para a posição central.
Os servo-motores se movimentam cerca de 180º e recebem como comandos valores
inteiros de 1 a 128. Então, para indicar ao motor que deve ser assumido uma rotação de
90º, deve-se enviar o valor 64, ou seja, 180º equivalem a um valor 128, 90º, a 64 e assim
por diante.
Os comandos enviados para a SB Servo Control, através da porta serial, são compostos por
três campos: identificação do servo, deslocamento desejado (ângulo) e terminador (CR). A
identificação do servo é dada por letras maiúsculas, na seguinte seqüência:
17
A, servo 1
B, servo 2
até H, servo 8
Exemplos de comandos:
A23<CR>
B77<CR>
H110<CR>
Um valor de 65 para o deslocamento corresponde a um pulso de 1,5 ms, o que corresponde
a um deslocamento de 0 grau. Valores acima de 65 até 130 provocam deslocamento de até
60 graus no sentido horário e abaixo de 65, geram deslocamento de até 60 graus no sentido
anti-horário.
Ao ser energizado, o sistema assume a geração de pulsos de 1,5 ms, levando todos os
servos à posição de 0 grau.
A placa SB Servo Control possui 5 conectores: JP1, JP2, JP3, JP4 e X1. JP1, JP3 e JP4
são utilizados em conjunto.
JP1: Tensão de controle dos servos. O servo A corresponde ao pino 1.
JP3: Tensão de alimentação dos servos. Pode variar de 4,6 a 6 V.
JP4: Terra.
JP2: Alimentação DC do sistema. Pode variar de 5 a 6 v.
X1: Conector DB-9 RS232-C. Utilizado para interligar o sistema a um microcomputador via
interface serial.
Alguns problemas podem ocorrer, como trepidação do servo, por exemplo. Isso pode
ocorrer se o sistema não estiver devidamente alimentado ou a alimentação de energia não
estiver estabilizada.
3.3 Estrutura
As estrutura do robô AR+ é feita principalmente de alumínio. A base tem a forma de um ‘+’
(sinal de adição) e as patas são conectadas uma em cada lado da base, como na figura.
18
Patas
Base em forma de ‘+’
Figura 5 - Estrutura básica
Cada pata tem duas articulações e cada articulação é movimentada por um servo-motor.
A placa SB Servo Control fica no centro da base. Os servo-motores estão distribuídos dois
em cada pata, um na articulação ligada a base e outro na articulação central da pata. Na
extremidade de cada pata há um pé de apoio feito de borracha.
MD
PÉS DE APOIO
MC
MB
MA
INTERFACE
CONTROLE
SERVO-MOTORES
ME
MF
MG
MH
Figura 6 - Disposição dos componentes
19
BASE
ARTICULAÇÕES
Figura 7 - Articulações das patas
3.4 Movimentos
O AR+ tem seus movimentos limitados em quatro direções (N, S, L e O), tornando menos
complexo e mais confiável sua movimentação. O AR+ não possui sensores, os movimentos
são gerados pelo programa de computador que se baseia em informações previamente
inseridas, ou seja, o programa entende que certos valores de comandos correspondem a
determinados movimentos, mas não são fornecidas informações sobre se os movimentos
planejados foram realmente executados. Então, com a limitação das direções de
movimentos, os movimentos gerados pelo programa são executados com maior
confiabilidade pelo robô.
Para se deslocar o AR+ se apóia em duas patas paralelas, estendendo as outras duas
patas, uma em direção contrária à base e outra na direção da base. Veja a figura:
20
BASE
Figura 8 - Pata estendida na direção contrária à base
BASE
Figura 9 - Pata estendida na direção da base
Após o posicionamento das patas estendidas, as patas de apoio levantam, deixando
somente as patas que estão estendidas sustentando a estrutura. Neste momento o robô
está pronto para se deslocar. Para isso, as patas que estão sustentando a estrutura se
movimentam. Se a pata estiver estendida para a direção da base do robô, ela executa um
movimento de forma a assumir a direção contrária à base. Se a pata estiver estendida para
a direção contrária à base, faz o movimento na direção da base.
21
BASE
Figura 10 - Movimento para o sentido oposto à base
Como o robô AR+ tem a forma de um ‘+’ (sinal de adição), todas as quatro patas se
movimentam no sentida da base ou oposto à base. O método de movimento apresentado é
válido para qualquer uma das quatro direções em que o robô se movimenta.
3.5 Sistema de controle
BASE DE
DADOS
IHM INTERFACE
HOMEM /
MÁQUINA
GERADOR DE
TAREFAS
MOTOR
A
MOTOR
B
MOTOR
C
MOTOR
D
SOFTWARE DE
CONTROLE
SERIAL
RS232
INTERFACE DE
CONTROLE DOS
MOTORES
MOTOR
E
GERADOR DE
MOVIMENTOS
CONTROLE
DOS
MOTORES
MOTOR
H
Figura 11 - Sistema de Controle
MOTOR
G
MOTOR
F
22
O robô AR+ é totalmente controlado por um software (sistema de controle) instalado em um
computador do tipo PC. Esse software se comunica com o robô enviando comandos,
formados por caracteres ASCII, através da porta serial utilizando o protocolo RS232-C.
O sistema de controle é um software que: gera movimentos, controla movimentos, possui
uma interface Homem-Máquina (IHM), armazena movimentos e gera tarefas.
Controle dos Motores: Gera a posição de cada motor conforme a posição desejada das
patas. As informações do Controle dos Motores são enviadas para o robô.
Gerador de Movimentos: Seqüência as posições necessárias dos motores para a geração
de movimento. Os movimentos podem ser simples, compostos ou seqüenciais.
-
Movimento simples: é o movimento executado por um único motor, por exemplo,
o movimento do motor C.
-
Movimento composto: é o movimento executado por mais de um motor de um
mesmo conjunto, ou seja, para movimentar uma pata do robô, são necessários
movimentos de mais de um motor dessa mesma pata; um conjunto de
movimentos simples.
-
Movimento seqüencial: é uma composição de movimentos compostos que são
executados seqüencialmente para executar uma determinada tarefa, como por
exemplo, andar para frente, andar para traz, etc.
Interface Homem-Máquina (IHM): Realiza a interface do robô com o operador permitindo a
implementação funcional das ações a serem realizadas. A IHM permite ao operador:
23
IHM
CONTROLE INDIVIDUAL
DOS MOTORES
CONTROLE INDIVIDUAL DAS
PATAS
CONTROLE DE MOVIMENTO
EM ALTO NÍIVEL
GRAVAÇÃO DE
MOVIMENTOS
Figura 12 – IHM
-
Controle Individual dos Motores: a posição de cada motor pode ser alterada.
-
Controle Individual das Patas: Cada pata possui um conjunto de motores que têm
suas posições alteradas de acordo com o movimento desejado da pata, ou seja, o
operador informa o que a pata deve fazer e a posição dos motores é ajustada pelo
sistema.
-
Controle de Movimento em Alto Nível: O robô possui um conjunto de patas que têm
suas posições alteradas de acordo com o movimento do robô, ou seja, o operador
informa o que o robô deve fazer e a posição das patas é ajustada pelo sistema.
-
Gravação de Movimentos: Os movimentos ou seqüências de movimentos realizados
podem ser gravados para serem reutilizados em outros movimentos ou seqüências
de movimentos.
Base de Dados: Armazena seqüências de movimento dos motores. Essas seqüências
formam os Conjuntos de Ações (CAs). O conjunto de ações que contém os movimentos
básicos do robô e é chamado de Núcleo Primário de Ação (NPA). O NPA é a base para
outras seqüências de movimento. Quando novos conjuntos de ações são criados, são
chamados de Núcleos Secundários de Ações (NSA) e podem ser criados a partir do NPA ou
24
de outros NSAs. Cada seqüência de um NPA ou NSA possui um identificador (label) e um
tempo de espera (delay) além da seqüência de movimentos.
Sequencias
DELAY
LABEL
NPA / NSA
SEQÜÊNCIA
Figura 13 - Seqüências NPA e NSAs
Gerador de tarefas: Gera composições de movimentos e ações (NSAs) para executar uma
determinada tarefa. Uma vez validada a tarefa, esta é armazenada no Banco de Dados,
NSA
tornando-se um novo NSA.
NSA
NPA
NSA
Figura 14 - NPA e NSAs
Interface de Controle dos Motores (ICM): Recebe os comandos do computador e aplica
nos motores.
VCC
5V
3A
MOTORES
PIC
16F628
MAX
232
COMPUTADOR
CNEXÃO SERIAL
CONTROLE
VCC
GND
25
PO TÊNCIA
Figura 15 – ICM
TERRA
Componentes da ICM:
-
Conexão serial: Plug DB9 para conexão do fio serial que liga a ICM ao computador.
-
MAX 232: Chip que faz a interface de comunicação da ICM com o computador
utilizando o protocolo RS232.
-
PIC 16F628: Micro controlador que contém o programa de controle dos servomotores.
-
Potência: Chip que distribui a energia necessária para cada dispositivo.
Os servo-motores são conectados à ICM por meio de 3 fios: VCC, TERRA e CONTRLE,
onde VCC e TERRA são para a alimentação de energia e CONTROLE fornece a freqüência
de controle de posição do servo-motor.
26
4. “AR+” – ROBÔ ARANHA DE QUATRO PATAS
O Robô AR+ é um quadrúpede no formato de uma aranha que se movimenta de frente ou
de lado, ele não executa movimentos circulares como, por exemplo, girar em torno de si
mesmo.
Cada uma das quatro patas do AR+ possui dois motores que permitem o movimento da
pata. Como cada pata possui dois motores e o robô possui quatro patas, são necessários
oito motores e uma placa para controle dos motores. Esses componentes são distribuídos
da seguinte forma:
PATA N
C
A
PATA L
G
INTERFACE
CONTROLE
E
F
H
PATA O
B
PATA S
D
Figura 16 – Identificação das patas e motores
MOTORES
PATA
SUPERIOR
INFERIOR
N
A
C
S
B
D
L
E
G
O
F
H
Tabela 1 – Posição dos motores nas patas
27
A tabela acima indica quais motores pertencem a qual pata e em qual parte da pata o motor
está situado. Por exemplo, a pata N possui o motor A na parte superior e o motor C na parte
inferior. A atribuição de letras para cada motor é válida a partir do momento em que os
motores são conectados na placa servo-controladora, pois é na placa que estão descritos
quais contados do circuito onde é conectado o servo-motor pertence a qual letra de
identificação.
Como é possível observar na figura 16 e na tabela 1, os motores não estão distribuídos em
seqüência nas patas. O programa agrupa os motores em dois grupos: grupo X = {A, B, C, D}
e grupo Y = {E, F, G, H}. O grupo X tem prioridade sobre o grupo Y, ou seja, durante a
execução dos comandos, a seqüência do grupo X sempre é enviada primeiro que a
seqüência do grupo Y. No decorrer deste documento, veremos mais detalhes sobre como os
comandos são enviados para o robô.
As patas dianteira e traseira pertencem ao grupo X, então, podemos dizer que elas têm
prioridade sobre as patas laterais, que pertencem ao grupo Y. Portanto, os movimentos
serão executados primeiro pelas patas dianteiras e depois pelas patas laterais.
Mas por que executar apenas duas patas de cada vez ao invés de oito? Os motores
utilizados nas articulações das patas do AR+ consomem muita energia ao se
movimentarem. Quanto mais motores forem movimentados simultaneamente, mais corrente
elétrica (Amperes) será requerida da fonte de energia. Fontes de corrente contínua com
potência suficiente para suprir os oito motores se movimentando simultaneamente são
difíceis de encontrar, então, reduzindo o os movimentos simultâneos dos motores reduz a
necessidade de fontes mais fortes, facilitando o acesso a fontes de energia capazes de
funcionar o robô AR+. Ao movimentar duas patas são movimentados quatro motores
simultaneamente.
4.1 Movimento
O robô AR+ anda em quatro direções: para frente, para trás, para a esquerda e para a
direita. Para se mover, ele não executa rotações em torno de seu próprio eixo, ou seja,
quando anda para a esquerda, por exemplo, todo o corpo do robô é deslocado para a
esquerda mantendo sempre a frente voltada para a mesma direção.
28
Quando se move para frente, as patas laterais apóiam-se na superfície de modo a liberar o
movimento das patas dianteiras e traseiras. As patas liberadas tomam a posição inicial de
um passo para frente, ou seja, ficam estendidas para frente. Quando as patas dianteiras e
traseiras estão posicionadas, as patas laterais são levantas deixando todo o apoio nas patas
dianteiras e traseiras, que, assim que estiverem apoiadas, se movimentam para trás,
tomando a posição final e deslocando o corpo do robô para frente.
Para se mover para trás, é executado um movimento semelhante ao de mover para frente,
onde apenas as posições inicial e final são invertidas. E para se mover para esquerda ou
direita, as patas que apóiam são a dianteira e a traseiras e as patas laterais assumem os
movimentos inicial e final.
Para que o robô execute os movimentos de cada motor para movimentar as patas e se
deslocar, o software ARc é responsável por coletar os comandos fornecidos pelo operador,
tratar esses comandos e envia-los para o robô. A seguir, será detalhado a construção e o
funcionamento do software de controle do robô AR+ (ARc).
4.2 Projeto
O projeto foi desenvolvido na linguagem Java versão 1.5.0. Duas Bibliotecas de expansão
foram utilizadas no projeto: o driver JDBC para o banco de dados Firebird e; API
javax.comm, utilizada para envio dos comandos via porta serial. Foram criados módulos
(Classes) com funções específicas para cada parte o sistema. Os módulos controlam desde
a conexão com o banco de dados, as telas de interação com o operador até mecanismos de
escalonamento e ajuste de espera. Grande parte dos módulos necessita de parâmetros de
ajuste para executar corretamente as funções atribuídas. Esses parâmetros são armazenas
e podem ser ajustados pelo operador, de acordo com a necessidade.
O sistema foi dividido em dois níveis: nível Baixo e nível Alto. Onde cada nível possui
funções e módulos exclusivos ou compartilhados.
Os módulos podem ser classificados em: módulos de controle, informação, interação e
núcleo, onde a classificação é dada de acordo com a função do módulo.
29
5. DIVISÃO DO SISTEMA “ARc”
O sistema ARc é dividido em duas partes onde cada parte é chamada de Nível,
respectivamente, Nível Baixo e Nível Alto. Os níveis foram criados para dividir o processo de
desenvolvimento do sistema, onde o nível Baixo compreende os módulos necessários para
que um determinado comando chegue ao robô com as informações ajustadas e corretas e,
o nível Alto, compreende os módulos necessários para construir, armazenar e reutilizar os
comandos a serem enviados para o robô e permitir a interação do usuário operador. Há um
módulo especial que não pertence a nenhum dos níveis. Esse módulo, chamado Núcleo, é
responsável pela interação dos outros módulos, tanto do nível Alto quanto do nível Baixo.
Além da divisão do sistema em níveis há uma outra divisão criada para agrupar os módulos
com um propósito em comum. As divisões dos módulos são: Módulos de informação,
Módulos de Controle, Módulos de Interação e Núcleo.
Os módulos de Controle, Interação e Núcleo recebem e retornam informações, portanto, é
necessário entender, primeiro, como as informações são organizadas (módulos de
Informação).
Nota: A partir deste momento, os módulos de informação serão chamados de Classes para
facilitar a compreensão quando estivermos relatando os módulos de controle e serão
utilizadas notações peculiares da linguagem Java (linguagem em que o sistema foi
desenvolvido).
5.1 Classes de Informação (Módulos de Informação)
As classes (ou módulos) de informação são unidades cuja função é servir como um grupo
de informações em comum, ou seja, uma forma de agrupar informações para representar
um determinado objeto. Por exemplo, uma classe Motor possui informações de posição e
tempo de espera utilizadas em um motor real do robô AR+.
A seguir, uma descrição das classes de Informação:
30
MOTOR
É a unidade básica de informação do sistema. O Motor é a abstração do modelo físico do
Servo-motor utilizado no robô AR+ e está contido em todas as classes de informação. Em
alguns momentos a referência para essa classe será feita como Informação de Motor.
A classe Motor possui as informações necessárias para o controle do motor real. Essas
informações são:
Ì
Valor: posição do eixo que deve ser assumida pelo motor real.
Ì
ID: identificação do motor real interpretada pela placa servo-controladora.
Ì
Delay: tempo de espera necessário para que o motor real complete o movimento
indicado pela informação valor.
FILA MOTOR
É uma fila do tipo FIFO de classes do tipo Motor com algumas modificações. A FilaMotor
permite as seguintes ações:
Ì
Inserção: insere um Motor no fim da fila.
Ì
Remoção: remove o primeiro Motor da fila.
Ì
Alteração: permite alterar um determinado Motor da fila. Altera o Motor apenas por
outro Motor, não permite exclusão.
Ì
Consulta: permite consultar as informações de um Motor da fila.
A FilaMotor utiliza uma classe de informação exclusiva chamada ElementoFilaMotor. Essa
classe serve apenas para organização da FilaMotor, portando, não é utilizada em outras
classes do sistema.
COMANDO
É a abstração de uma ação (um comando) enviada para o robô. O Comando é composto
por quatro classes do tipo FilaMotor, que representam as quatro patas do robô: N, S, L e O.
Portando, o Comando possui informações para todos os motores reais do robô, em outras
palavras, o Comando é um conjunto de informações dos motores reais necessárias para
que o robô execute algum movimento.
31
COMANDO
FilaMotor Motor
N
(ID Motor 1, Valor, Delay), (ID Motor 2, Valor, Delay, ...)
S
L
O
Tabela 2 – Comando
FILA COMANDO
É uma fila do tipo FIFO de classes do tipo Comando. A FilaComando permite as seguintes
ações:
A
Ì
Inserção: insere um Comando no fim da fila.
Ì
Remoção: remove o primeiro Comando da fila.
Fila
de
Comandos
utiliza
uma
classe
de
informação
exclusiva
chamada
ElementoFilaComando. Essa classe serve apenas para organização da Fila de Comandos,
portando, não é utilizada em outras classes do sistema.
COMANDO ESCALONADO
Um comando possui quatro filas motor e passa por vários processos até ser enviado para o
robô. O robô recebe apenas uma informação de cada vez, então, o comando passa por um
módulo chamada Escalonador e é convertido em um comando escalonado. O comando
escalonado possui uma única fila motor com as informações de motor ajustadas na
seqüência correta para serem enviadas.
FILA COMANDO ESCALONADO
Assim como a Fila de Comandos, a Fila de Comnados Escalonada é uma fila do tipo FIFO
de classes do tipo Comando Escalonado. A Fila de Comandos Escalonados permite as
seguintes ações:
Ì
Inserção: insere um Comando no fim da fila.
Ì
Remoção: remove o primeiro Comando da fila.
A Fila de Comandos Escalonados também utiliza uma classe de informação exclusiva
chamada ElementoFilaComandoEscalonado. Essa classe serve apenas para organização
da Fila de Comandos Escalonados, portando, não é utilizada em outras classes do sistema.
32
NPA
A classe NPA representa um Núcleo Primário de Ação, que contém um determinado
Comando que é enviado para o robô. O NPA contém as seguintes informações:
Ì
ID: Identificação do NPA;
Ì
Comando: uma informação do tipo Comando.
O NPA possui métodos que permitem apenas coletar o ID e o Comando. Essas duas
informações do NPA são definidas no construtor NPA.
NSA
A classe NSA representa um Núcleo Secundário de Ações. O Núcleo Secundário de Ações
é uma lista de execução onde os itens dessa lista são NPA’s e/ou outros NSA’s. A lista é
executada em seqüência.
O NSA contém as seguintes informações:
Ì
ID: Identificação do NSA;
Ì
Lista: lista de NPA’s ou NSA’s.
A informação Lista é do tipo Vector<BDListaElemento>, onde Vector é uma classe
utilizatária do java pra trabalhar com vetores (java.util.Vector) e BDListaElemento é uma
classe utilizada somente pelo NSA para permitir o armazenamento de informações do
NPA/NSA listado. Essas informações são: ID, Tipo (NSA/NPA).
NSA PROCESSADO
Antes de ser executado, o NSA deve ser desmontado em comandos, ou seja, todos os itens
da lista do NSA, sejam NPA’s ou outros NSA’s devem ser lidos e armazenados em uma
única fila de comandos escalonados pronta para a execução.
Ao desmontar um NSA, os comandos e as informações de motores dos comandos passam
por diversos processos como o Controle de Delay e o Escalonador (ambos serão vistos
mais adiante). Ao concluírem a passagem por esses processos, as informações estão
prontas para serem enviadas ao robô, mas, ao invés disso, são armazenadas em um
arquivo que, posteriormente, poderá ser enviado para o robô em conjunto com outros
arquivos. Cada arquivo é representado por um NSA Processado.
O NSA Processado possui uma informação de identificação (ID) e um comando escalonado,
onde estão todos os comandos prontos para serem enviados ao robô.
33
6. NÍVEL BAIXO
O operador cria uma seqüência de comandos e, em determinado momento, solicita a
execução dessa seqüência pelo robô AR+. Uma seqüência de comandos passa por diversos
módulos até ser, literalmente, enviada para o robô. Esses módulos compõem o Nível Baixo
do Sistema de Controle do robô AR+.
Os módulos que compõem o nível Baixo são: Controle de Delay, Escalonador, Serial CMDE
e Transm. A seguir uma descrição desses módulos:
CONTROLE DE DELAY
Os motores do AR+ executam movimentos de rotação no seu eixo onde podem rotacionar
com limite de 120°. O sistema envia a informação da posição que cada motor deve assumir,
ou seja, o sistema informa se o motor deve se posicionar a 0°, 35°, etc, informando o valor
correspondente ao ângulo. Essa informação é tratada como um movimento.
Quando um movimento é enviado para algum dos motores do robô, o motor precisa de um
determinado tempo para executar tal movimento. Esse tempo de espera necessário é
chamado de delay.
O Controle de Delay calcula o delay necessário para que o motor realize o movimento
indicado. O sistema envia a informação do movimento para um determinado motor e
aguarda o tempo indicado pelo delay para enviar outra informação ao mesmo motor, que por
sua vez, possui outro tempo de delay. Se o tempo de delay não for respeitado, o motor não
completará o movimento em execução, passando a assumir o novo movimento enviado.
Para calcular o delay necessário para o movimento enviado ao motor, o Controle de Delay
possui um parâmetro configurável que informa quanto tempo o motor leva para executar um
movimento de 50º. É efetuado um calculo usando uma regra de três e o resultado é o delay
necessário para executar o movimento enviado para o motor.
O Controle de Delay recebe uma Fila de Comandos e atribui delay a todos os motores
contidos nos comandos da fila de comandos, retornando a fila ajustada para outro módulo
utilizar.
34
ESCALONADOR
O robô AR+ possui quatro patas, então foi criada a classe Comando que possui quatro filas
de motores, onde cada fila de motores representa uma pata do robô. O problema é que para
enviar os comandos para o robô, apenas um comando pode ser enviado de cada vez, ou
seja, as quatro filas de motores de um comando precisam virar uma só de forma que as
informações sejam enviadas na ordem correta.
A função do Escalonador é mesclar as quatro filas de motores de um comando em uma fila.
O comando que passa pelo Escalonador é transformado em um Comando Escalonado.
A estratégia de escalonamento empregada pelo escalonador é simples: são removidas
algumas informações de motores do comando selecionado, nos quais representam o
movimento de duas patas; os delays das informações de motores removidas são verificados
e é selecionado a informação de motor com o maior delay; as outras informações de
motores não selecionadas são ajustadas com delay igual a zero; as informações de motores
são inseridas em um comando escalonado sendo a última informação inserida a
selecionada com o maior delay. Quando o módulo Transm (será visto a seguir) ler um
comando escalonado, vai ler a informação de motor e aguardar o tempo indicado pelo delay
para, somente após esperar, ler a próxima informação de motor. Por isso as informações de
motores que continham delay menor são ajustadas para zero, fazendo com que todas sejam
enviadas rapidamente, uma após a outra, de forma que os motores sejam sincronizados e
aguarda o maior delay entre as informações de motores enviadas garantindo a execução de
correta de todos os motores do robô.
O Escalonador recebe uma fila de comandos, processa e retorna um fila de comandos
escalonada.
35
Informações de Motores
Maior delay
COMANDO
N
A1
A2
A3
A4
S
B1
B2
B3
B4
L
C1
C2
C3
C4
O
D1
D2
D3
D4
COMANDO ESCALONADO
A1
A2
Filas de Informações de
Motores
B2
B1
Figura 17 - Escalonador
SERIAL CMDE
Foi visto anteriormente que um NSA Processado é armazenado em arquivo para depois ser
executado. O módulo Serial CMDE é o módulo responsável por gravar e ler um arquivo NSA
Processado.
O nome Serial CMDE quer dizer “Comando Escalonado Serializado”. Este módulo utiliza a
interface Serializable e recursos de gravação de arquivos do Java para manipular os
arquivos NPA Processados. A classe NPAProcessado é gravada em um arquivo utilizando
um ObjectOutputStream e lida utilizando um ObjectInputStream.
Ao gerar um arquivo, o Serial CMDE grava o nome do arquivo no banco de dados para
poder referenciar o arquivo e, ao excluir o arquivo, o registro no banco de dados também é
removido. O nome do arquivo e da entrada no banco de dados é o mesmo do NSA que
originou o NSA Processado.
36
TRANSM
O sistema ARc utiliza um módulo especial para envio dos comandos. Esse módulo utiliza a
biblioteca de expansão javax.comm fornecida pela Sun. A javax.comm permite o controle
das portas de comunicação do computador. No caso deste projeto, a javax.comm é utilizada
para controlar a porta serial.
O TRASM recebe uma fila de comandos escalonada e faz o envio seqüencial das
informações de motores contida nas filas, sempre respeitando o delay indicado em cada
informação de motor.
37
6.1 Relação Entre os Módulos do Nível Baixo
Fila de Comandos
Controle de Delay
Fila de Comandos
Escalonador
Arquivo
Serializado
Serial CMDE
Fila de Comandos
Escalonada
Serial CMDE
Fila de Comandos
Escalonada
TRANSM
AR+
Figura 18 – Relação entre os módulos do nível Baixo
38
7. NÍVEL ALTO
Como visto, quando se tem uma seqüência de comandos e essa seqüência é enviada para
o robô, os módulos pelo qual essa seqüência passa constituem o nível Baixo. Mas como a
seqüência de comandos foi criada?
O nível Alto compreende os módulos necessários para criar, armazenar e reutilizar os
comandos a serem enviados para o robô e permitir a interação do usuário operador.
Esses módulos pertencentes ao nível Alto estão distribuídos em duas categorias: Controle e
Interação.
7.1 Módulos de Controle
CONEXÃO
O sistema ARc armazena informações em um banco de dados. O módulo Conexão é
responsável por carregar os drivers necessários e executar a conexão com o banco de
dados.
Atualmente, o ARc conecta ao banco de dados Firebird utilizando um driver JDBC próprio do
Firebird. Se for necessário a troca do banco de dados ou do driver de conexão, essa troca é
feita somente no módulo Conexão, que passa a disponibilizar acesso ao banco de dados
para todo o programa.
CONTROLE BD
O Controle BD é responsável por executar todas as manipulações na base de dados, ou
seja, é ele que insere, altera e remove dados da base de dados. Qualquer módulo do
sistema que precise gravar ou ler informações do banco de dados faz uma chamada para o
Controle BD, no qual retorna a informação solicitada.
39
DESMONTADOR NSA
Como visto anteriormente, o NSA é uma lista de execução que possui itens NPAs e/ou
NSAs. Quando o NSA é preparado para execução, todos os comandos dos itens da lista
NSA devem ser extraídos e preparados em uma fila de comandos. Ao encontrar um NPA na
lista NSA, o Desmontador extrai o comando do NPA encontrado e o coloca em uma fila.
Quando é encontrado um NSA na lista NSA, ele deve ser desmontado, então, o
Desmontador cria uma nova instância de si mesmo e informa a fila de comandos onde
devem ser armazenados os comandos e o NSA que deve ser desmonstado.
Um NSA é um espécie de árvore onde os nós são ou outros NSAs da lista e as folhas são
os NPAs. O Desmontador efetua as lituras das folhas dessa árvore efetuando uma busca
por profundidade.
Ao concluir a leitura do NSA (árvore), o Desmontador retorna uma fila de comandos
contendo todos os comandos (folhas).
NSA 1
NSA 2
NPA 5
NSA 4
NPA 1
NSA 3
NPA 6
NSA 5
NPA 2
NPA 3
NPA 4
NPA 7
NPA 8
Figura 19 – Árvore do Desmontador NSA
Observando a árvore acima, é possível entender a leitura feita pelo Desmontador. A fila de
comandos possui a mesma seqüência dos NPAs encontrados na árvore, já que um NPA é
um comando.
40
VALIDADOR NSA
Como visto, o NSA é um árvore onde os comandos são as folhas. O sistema ARc permite a
edição de NSAs. Supondo que existam três NSAs onde o primeiro chama o segundo, o
segundo o terceiro e o terceiro o primeiro. Ao executar qualquer um desses NSAs, o
programa ficaria em redundância, ou seja, a execução ficaria presa em um loop infinito,
causando o travamento do sistema.
NSA 1
NSA 2
NSA 3
NPA ?
Figura 20 – Loop na execução de um NSA
O Validador NSA foi criado para verificar se o NSA a ser executado não possui referências
circulares. Se nenhuma referência circular for encontrada e execução procede normalmente,
caso contrário, a execução é interrompida.
41
7.2 Módulos de Interação
TELA PRINCIPAL
Figura 21 – Tela Principal
A tela principal do sistema ARc permite executar o processamento, a execução de
comandos e o acessa as telas de edição de NSAs e NPAs.
Os NSAs criados aparecem na parte esquerda da tela na lista “NSAs” e podem ser
selecionados e processados. Ao processar um NSA ele aparece na lista “NSAs
Processados” situada ao centro. Os NSAs Processados podem ser selecionados para
execução onde, ao selecionar, são adicionados à “Lista de Execução” onde são executados
sequencialmente conforme a lista. A pequena lista situada a parte inferior esquerda da tela é
o LOG, onde aparecem as mensagens de ações executadas pelo sistema.
42
TELA DE EDIÇÃO DE NPA
Figura 22 – Tela de edição NPA
A tela de edição de NPA permite criar um NPA dispondo controles para configuração dos
movimentos dos motores, ou seja, permite que o usuário operador configure as informações
de motores que serão inseridas no NPA criado.
A tela de edição de NPA é dividida em quatro partes: sliders de controle, listas de
informações de motores, botões de ação e conclusão de NPA.
Sliders de controle: Há um slider para cada motor do robô. Os sliders são
controles deslizantes e permitem configurar o valor que cada motor deve assumir
para realizar um movimento.
43
Listas de informações de motores: Todas as informações
de motores são adicionadas nas listas. Cada lista representa
um motor específico. Os itens das listas podem ser
adicionados ou removidos, sempre que um item de uma lista
é removido um item de mesma posição das outras listas
também é removido.
Botões de ação: Os botões de ação permitem adicionar, remover e visualizar as
informações que estão sendo editadas. Os botões são os seguinte:
Ì
ADD: Adiciona os valores indicados nos sliders nas listas.
Ì
Resetar: Volta a posição de todos os sliders para a posição inicial.
Ì
Visualizar: faz com que o robô assuma a posição indicada nos sliders, permitindo ver
a posição real a ser tomada pelos motores do robô.
Ì
Editar: Lê as informações selecionadas nas listas e ajusta os sliders.
Ì
Limpar: Remove todas as informações das listas.
Ì
Remover: remove os itens selecionados nas listas.
Conclusão de NPA: É onde é inserido o nome do NPA e é escolhida a opção Salvar ou
Cancelar.
44
TELA DE EDIÇÃO DE NSA
Figura 23 – Tela de Edição NSA
A tela de edição de NSA permite criar, editar e excluir um NSA. Esta tela é composta por
três partes: NPA, NSA e Novo NSA.
Parte NPA: Todos os NPAs existentes são exibidos em uma lista onde podem ser
selecionados para fazer parte do novo NSA, editados ou excluídos. Ao adicionar um NPA
como parte de um novo NSA ele aparece na lista Novo NSA.
Parte NSA: Assim como os NPAs, os NSAs existentes são exibidos numa lista onde podem
ser selecionados para fazer parte do novo NSA, editados ou excluídos. Ao adicionar um
NSA com parte de um novo NSA ele aparece na lista Novo NSA.
Parte Novo NSA: Os NPAs e NSAs são adicionados a lista Novo NSA para serem parte do
novo NSA. Esta parte é utilizada para criar, salvar e editar NSAs.
45
TELA DE CONFIGURAÇÃO
Figura 24 – Tela de Configuração
A tela de Configuração permite ajustar alguns parâmetros do sistema ARc, como
inicialização dos motores, login do banco de dados e tempo de delay.
As configurações de inicialização dos motores permitem ajustar qual a posição que deve ser
assumida pelo robô no momento da carga do sistema. As informações de banco de dados
indicam o nome de usuário e senha para serem utilizados na abertura do banco de dados e
onde está o arquivo de banco de dados. O tempo de delay é o parâmetro utilizado pelo
módulo do nível Baixo Controle de Delay para calcular o tempo necessário para o robô
executar o movimento. Os botões salvar e cancelar permitem salvar ou não as alterações
nas configurações.
46
7.3 Relação Entre os Múdulos do Nível Alto
EDIÇÃO DE NPA
PRINCIPAL
CONFIGURAÇÕES
EDIÇÃO DE NSA
CONTROLE
BD
NPA
CONEXÃO
NSA
DESMONTADOR
NSA
FILA DE
COMANDOS
Figura 25 - Relação Entre os Múdulos do Nível Alto
VALIDADOR
NSA
47
8. NÚCLEO
Como visto anteriormente, o sistema ARc foi dividido em dois níveis que possuem módulos
que comunicam entre si. O problema é: como fazer a comunicação entre os módulos do
mesmo nível e/ou de um nível diferente?
O Núcleo se comunica com todos os módulos do sistema, de forma a centralizar as
chamadas aos módulos, ou seja, se um módulo precisa enviar ou coletar informações de
outro módulo solicita ao núcleo que execute a ação. O Núcleo se encarrega de solicitar e
enviar as informações para os módulos.
Para fazer com que o Núcleo veja e seja visto por todos os módulos, todos os módulos são
carregados a partir do Núcleo e recebem uma referência do núcleo no momento de sua
criação. Para explicar melhor vamos utilizar termos da linguagem Java: Os módulos são
instanciados dentro do Núcleo e uma referência do Núcleo é passada no construtor dos
módulos.
Por exemplo, para exibir os NSAs existentes na tela Principal, a tela Principal solicita ao
Núcleo que solicite ao Controle BD uma lista de NSAs, o Núcleo executa a tarefa e retorna a
lista para a tela Principal.
Por intermediar a comunicação entre os módulos dos dois níveis, o Núcleo não pertence a
nenhum dos níveis, fica situado externamente aos dois níveis.
O Núcleo, além centralizar todos os módulos, também armazena as informações de
parâmetros utilizadas pelos módulos. Para isso possui um módulo de informação próprio
chamado Parâmetros.
PARÂMETRO: MÓDULO DE INFORMAÇÃO
As informações contidas no módulo Parâmetro são gravadas em um arquivo de
propriedades do Java, o properties. A classe properties do Java tem a função de armazenar
identificadores e valores, normalmente, em um arquivo texto com extensão .properties. Esse
arquivo é lido sempre que o programa inicia e pode ser gravado sempre que o usuário
operador alterar as configurações e clicar no botão ‘Salvar’ na tela Configurações.
48
Abaixo, um diagrama representativo de como é a relação entre os módulos através do
Núcleo:
Módulos do nível Alto
Núcleo
Todos os módulos, com exceção dos
módulos de informação, precisam
passar
pelo
núcleo
para
se
comunicarem, inclusive os módulos de
mesmo nível.
Módulos do nível Baixo
Figura 26 – Relação entre os módulos através do
49
9. BANCO DE DADOS
O sistema ARc armazenas informações como NPAs e NSAs em um banco de dados para
que essas informações possam ser utilizadas mais de uma vez.
O banco de dados utilizado neste Trabalho de Conclusão de Curso é o Firebird 1.5 que é
acessado pelo java através de um driver JDBC. Apenas recursos de leitura e gravação em
tabelas são utilizados. A seguir veremos quais são as tabelas utilizadas pelo sistema e como
o mapeamento de um módulo de informação (classe) foi feito para o banco de dados:
9.1 Tabelas
O sistema ARc utiliza cinco tabelas: Comando, NPA, NSA, NSA_LISTA e PROC.
Tabela COMANDO:
A tabela COMANDO armazena as informações de uma classe Comando. Os campos da
tabela COMANDO são:
Ì
NPA: Referência do NPA ao qual o comando armazenado pertence.
Ì
PATA: Identificador que indica qual fila de motores (pata) do comando o motor
pertence.
Ì
MOTOR: Identificação do motor que deverá receber o valor armazenado.
Ì
VALOR: Valor a ser passado para o motor. (Lembrando que as informações de
motores de um comando passa por diversos ajustes até chegar ao robô)
Ì
ORDEM: Garante que a ordem de leitura das informações da tabela seja a mesma
mostrada durante a criação do comando.
Abaixo, veja um exemplo de como acontece o mapeamento do objeto Comando para a
tabela COMANDO, respectivamente:
(onde: V = valor e D = delay)
50
COMANDO
FilaMotor Motor
N
(N1, V1, D1), (N2, V2, D2), ..., (Nn, Vn, Dn)
S
(S1, V1, D1), (S2, V2, D2), ..., (Sn, Vn, Dn)
L
(L1, V1, D1), (L2, V2, D2), ..., (Ln, Vn, Dn)
O
(O1, V1, D1), (O2, V2, D2), ..., (On, Vn, Dn)
Tabela 3 - Comando
NPA
PATA
MOTOR
VALOR
ORDEM
NPA 1
N
N1
V1
01
NPA 2
N
N2
V2
05
NPA 1
S
S1
V1
02
NPA 1
S
S2
V2
06
NPA 1
L
L1
V1
03
NPA 3
L
L2
V2
07
NPA 3
O
O1
V1
04
NPA 2
O
O2
V2
08
Tabela 4 – Exemplo de Comando armazenado
Os comandos só são salvos quando atribuídos a um NPA, ou seja, a tabela COMANDO é
uma espécie de lista de informações de um NPA.
O valor do campo ORDEM da tabela COMANDO é atribuído a medida que as informações
vão sendo salvas.
TABELA NPA
A tabela NPA foi criada para armazenar as informações essenciais de cada NPA. Nesta
versão do sistema ARc, a tabela NPA armazena apenas uma listagem de NPAs existentes,
mas a intenção é já deixar o banco de dados preparado para inserir informações diferentes
sem precisar reestruturar as tabelas.
51
TABELA NSA
Assim como a tabela NPA, a tabela NSA também é uma listagem com a intentenção de
deixar o banco de dados preparado.
TABELA NSA LISTA
Como visto anteriormente, um NSA possui uma lista cujos elementos podem ser NPAs ou
NSAs. A tabela NSA LISTA foi criada para armazenar essa lista.
Os campos da tabela NSA LISTA são:
Ì
NSA: Referência ao NSA no qual o elemento da lista pertence.
Ì
ITEM: Referência ao Item listado (nome NPA ou NSA).
Ì
TIPO: Tipo do item listado (NPA ou NSA).
Ì
ORDEM: Garante que a ordem de leitura das informações da tabela seja a mesma
mostrada durante a criação da lista do NSA.
Para poder mapear as informações de um NSA para a tabela NSA LISTA, existe uma classe
chamada BDListaElemento utilizada exclusivamente para este fim. Ao solicitar gravação dos
dados, a lista do NSA é convertida em uma lista de BDListaElemento e depois enviada para
a gravação.
A classe BDListaElemento possui as seguintes informações:
Ì
ID: Identificação (Nome) do item da lista (NPA ou NSA).
Ì
TIPO: Tipo do item (NPA ou NSA).
O mapeamento do NSA, com a classe BDListaElemento fica simples:
NSA: passo frente
LISTA do NSA
(BDListaElemento)
ID
TIPO
Frente1
NPA
Traz2
NPA
Tabela 5 – Exemplo tabela NSA
TABELA NSA LISTA
NSA
ITEM
TIPO
Passo frente
Frente1
NPA
Passo frente
Traz2
NPA
Tabela 6 – Exemplo tabela NSA Lista
ORDEM
1
2
52
O campo NSA da tabela recebe o nome do NSA; o campo ITEM recebe o ID do
BDListaElemento; o campo TIPO recebe o TIPO do BDListaElemento e; o campo ORDEM é
incrementado conforme a leitura de cima para baixo na lista NSA.
TABELA PROC
Como visto, um NSA quando é processado, é gerado um arquivo com o nome do NSA. A
tabela PROC armazena o nome desse arquivo indicando que o arquivo foi gerado. É apenas
uma listagem de nomes de arquivos criados com o processamento de NSAs.
53
10. A TRAJETÓRIA DE UM COMANDO
Até agora, vimos que os comandos passam por diversas alterações até serem transmitidos
para o robô. Neste capítulo, veremos o trajeto que um comando faz desde sua criação até a
execução do mesmo pelo robô.
10.1 Trajeto do comando na visão do operador
Um comando nasce na tela de Edição de NPA, afinal, todos os NPA são comandos, equanto
um NSA, é uma lista de comandos. Na tela de edição de NPA, o operador informa ao
sistema a posição de cada motor e, após informar várias posições diferentes para um
mesmo motor, dizemos que este motor executa um movimento. O operador informa várias
posições para todos os motores do robô e salva o NPA.
O NPA salvo é armazenado no banco de dados e é listado na tela de edição de NSA. Na
tela de edição NSA o NPA criado pode ser selecionado para uma ou mais listas de
execução de um novo NSA. O mesmo NPA pode ser incluido quantas vezes necessário em
uma lista de um mesmo NSA, ou seja, o NSA pode possuir uma chamada para um
determinado NPA várias vezes em sua lista. O operador, na tela de edição de NSA, cria um
novo NSA contendo outros NPAs ou NSAs salvos e salva o novo NSA, que é armazenado
no banco de dados e passa a ser listado na tela Principal.
Na tela principal, o operador seleciona o NSA desejado e solicita que seja processado. O
NSA é desmontado e é gerado um arquivo no computador contendo as informações dos
movimentos executados pelo NSA processado. Ao processar um NSA, ele passa a ser
listado na lista de NSAs Processados e pode ser selecionado para execução.
O operador seleciona um ou mais NSAs Processados e solicita execução. Todas as
informações dos NSAs Processados selecionadas para execução são concatenadas e
enviadas para o robô.
54
10.2 Trajeto do comando na visão dos sistema
Criando o NPA:
Na tela de edição de NPA, o operador informou as posições dos motores e solicita que os
dados sejam salvos como um novo NPA. Cada posição informada pelo operador é
convertida em uma informação de motor (classe de informação Motor) e colocada em um
Comando (classe de informação Comando). O Comando é inserido em uma classe NPA
(classe de informação) juntamente com o nome atribuído ao novo NPA. O novo NPA é
passado para o módulo Controle BD, acionado a partir do Núcleo, para ser salvo no banco
de dados. O Controle BD lê todas as informações de motores dentro do NPA e salva no
banco de dados.
Criando o NSA:
Na tela de edição de NSA, o operador seleciona os NPAs e NSAs que irão compor a lista de
novo NSA e solicita que os dados sejam salvos como um novo NSA. A lista de NPAs e
NSAs selecionados é inserida em uma nova classe NSA (classe de informação). Essa nova
classe NSA é enviada para o Controle BD para ser salva. O Controle BD salva cada item
das lista de execução do novo NSA no banco de dados.
Processando um NSA para a exeucução:
Na tela Principal, o operador escolhe o NSA e solicita que seja processado. Quando o
operador escolhe o NSA, ele seleciona o nome do NSA em uma lista, então, o Controle BD
utiliza esse nome selecionado e resgata as informações desse NSA no banco de dados,
retornando uma classe NSA (classe de informação). Essa classe NSA precisa ser ajustada
para que suas informações estejam corretas antes de serem enviadas para o robô, então é
enviada aos módulos de controle.
O primeiro módulo que o NSA percorre é o VALIDADOR (módulo do nível alto) que verifica
se a lista não possui redundância que possa travar o sistema. Ao passar pelo Validador, o
NSA segue para o DESMONTADOR (classe do nível alto) onde todas as informações de
motores são extraídas para um Fila de Comandos (classe de informação).
A Fila de Comandos contém todas as informações de motores do NSA na seqüência em
que devem ser executados, então, essa Fila é enviada para os módulos do nível baixo onde
as informações de motores serão ajustadas.
55
O primeiro módulo de nível baixo a receber a Fila de Comandos é o Controle de Delay que
lê os valores de cada informação de motor em cada comando da fila de comandos. O dado
valor em uma informação de motor (classe de informação Motor) é a posição que o motor
deve assumir. O Controle de Delay verifica qual vai ser o movimento do motor de acordo
com as informações de motores, calcula o delay necessário para que os movimentos sejam
executados corretamente e atribui o delay para cada informação de motor nos comandos da
fila de comandos.
Após serem atribuídos os delays, a fila de comandos segue para o módulo Escalonador que
ajusta os delays e mescla as filas internas de cada comando na fila de comandos,
retornando uma fila de comandos escalonada. Essa fila de comandos escalonada é enviada
para o módulo Serial CMDE onde é gerado um arquivo serializado com as informações da
fila.
Execução um NSA Processado:
A partir do momento que é gerado o arquivo do NSA Processado, o nome desse NSa
aparece na lista NSA Processados da tela principal, onde o operador pode seleciona-lo para
execução.
O operador seleciona e adiciona os NPAs Processados que deseja executar para a lista de
execução e solicita execução da lista. Cada item da lista de execução é o nome de um NSA
Processado. O sistema percorre todos os nomes de NSA Processados da lista de execução
e, a cada nome, solicita ao Serial CMDE que des-serialize o NSA Processado, ou seja, o
Serial CMDE lê o arquivo e retorna uma classe NSA Processado. A classe NSA Processado
contém uma fila de comandos escalonada. Se forem selecionados mais de um NSA
Processado para execução, o sistema lê arquivo a arquivo e concatena em seqüência todas
as filas de comandos escalonados existentes nos NSA Processados lidos dos arquivos em
uma única fila.
A fila de comandos escalonados final é enviada para o módulo TRANSM que lê a fila e
converte os comandos para um arquivo de texto (ASCII). A parte externa do módulo
TRANSM lê o arquivo de texto e envias os comandos para a placa servo-controladora do
robô através da porta serial.
O arquivo texto possui duas informações distintas: o comando literalmente interpretado pelo
robô e o delay que deve ser aguardado até o envio do próximo comando. Essas
56
informações são distribuídas linha a linha: nas linhas ímpares são lidos os comandos e nas
linhas pares, os delays.
57
11. CONCLUSÃO
Neste Trabalho de Conclusão de Curso desenvolvemos um robô tipo aranha servocontrolado, onde manifestamos as competências e habilidades específicas para a área de
computação permitindo um aprendizado aprofundado da linguagem Java e sobre sistemas
robóticos.
O controle de robôs exige o uso de sistemas computacionais que permitam processamento
em tempo real e linguagens de programação de mais baixo nível, contudo, conseguimos
mostrar
que a linguagem Java, apesar de interpretada, pode ter utilizada no
desenvolvimento de interfaces para robótica. Mesmo sendo uma linguagem com execução
mais lenta que as utilizadas atualmente para robótica, possui métodos que podem facilitar o
desenvolvimento e o controle de aplicações robóticas.
Com relação à funcionalidade e operacionalidade do robô, a estratégia utilizada
empregando NSAs e NPAs mostrou-se eficaz na transmissão e controle dos movimentos,
mesmo os movimentos sincronizado.
Como trabalhos futuros, podemos incorporar uma câmera e sensores (ultra-som,
infravermelho, ... ) permitindo o desenvolvimento de sistemas para a navegação autônoma
de robôs com auto-aprendizado. Por outro lado, a linguagem java também permite a criação
de uma máquina virtual para facilitar e padronizar sistemas de controle em robótica, ou seja,
frameworks próprios para robótica móvel de forma a ter java como linguagem em comum de
desenvolvimento.
58
Bibliografia
UERJ, Universidade do Estado do Rio de Janeiro. Movimento dos animais tem aplicação
na construção de robôs. Disponível em:
http://www2.uerj.br/~agenc/htmmaterias/materias/2003mes08_07/01.htm
Acesso em: 25.MAR.05
WIKIPÉDIA, Definição de cinemática. Disponível em:
http://pt.wikipedia.org/wiki/Cinem%C3%A1tica
Acesso em: 25.MAR.05
ALMEIDA, Luis. Luis de Almeida home page. Disponível em:
http://sweet.ua.pt/~lda/index.htm
Acesso em: 10.ABR.05
SEW-EURODRIVE. Home Page – Perguntas e Respostas. Disponível em:
http://www.sew.com.br/modulos/faq/main_faq.asp
LIMA, Christiane. Home Page. Disponível em: http://www.robofull.hpg.ig.com.br/
VIRGILIO. Newton Channel. Disponível em: http://members.xoom.virgilio.it/ailab/
Acesso: 12.ABR.05
VERLAB, Laboratório de Visão Computacional e Robótica. Robótica Móvel. Disponível
em: http://www.lrvpa.dcc.ufmg.br/cursos/roboticamovel/
Acesso: 12.ABR.05
UFRN, Departamento de Engenharia de Computação e Automação. Notas de aula de
Percepção Robótica. Disponível em:
http://www.dca.ufrn.br/~lmarcos/courses/robotica/notes/index.html
SANTUCI CARVALHO, Marco Antônio. Utilização de robôs autônomos na detecção e
desarmamento de minas terrestres. Disponível em: http://www.lrvpa.dcc.ufmg.br/.
Acesso em: 15.MAI.2005
INOVAÇÃO TECNOLÓGICA, Redação. Robô brasileiro recupera turbinas de usinas
hidrelétricas. Disponível em:
http://www.inovacaotecnologica.com.br/noticias/noticia.php?artigo=010180041130
INOVAÇÃO TECNOLÓGICA, Redação. Robô submarino autônomo cruza a corrente do
Golfo. Disponível em:
http://www.inovacaotecnologica.com.br/noticias/noticia.php?artigo=010180041116
NETBEANS, Welcome. Disponível em: http://www.netbeans.org. Acesso em: 18.JUL.05
FERIBIRD, Relational Database for the New Millenium. Disponível em:
http://firebird.sourceforge.net. Acessado em: 27.AGO.05.
59
JAVA, Java Tecology. Disponível em: http://java.sun.com. Acessado em: 3.JUN.05.
PORTAL JAVA, A maior comunidade Java do Brasil. Disponível em:
http://www.portaljava.com. Acessado em: 2.SET.05.
ROBÔ CLUBE, Robótica e Eletrônica. Algumas dicas de como desenvolver o seu
projeto. Disponível em: http://www.roboclube.com.br/mand.html. Acessado em: 2.SET.05.
ANSÉNIO, CARLOS. Um Robot Aranha. Disponível em:
http://www.intel.com/cd/corporate/education/emea/por/elem_sec/comp_awards/isef/success/
221560.htm. Acessado em: 29.SET.05.
KLICKEDUCAÇÃO, Robótica. Quem foram os antepassados dos robês industriais?.
Disponível em:
http://www.klickeducacao.com.br/Conteudo/Referencia/tecnologia/Item_View/0,1655,1009tecnologia-23---POR,00.html. Acessado em: 10.OUT.05.
TOURINO, SÉRGIO ROBERTO GONÇALVES. Sistema de rastreamento para robôs
móveis utilizando visão embarcada. Disponível em:
http://www.graco.unb.br/~tourino/mestrado/dis.html. Acessado em: 22.MAI.05.
CAEIRO, CÉLIA MARGARIDA; SERRA, DIANA ROLDÃO; JORGE, JOSEANA DIAS. O
primeiro grande momento da inteligência artificial. Disponível em:
http://www.citi.pt/citi_2005_trabs/ia/index.html. Acessado em: 19.JUN.05.
JAVA, JavaTM 2 Platform Standard Edition 5.0 API Specification. Disponível em:
http://java.sun.com/j2se/1.5.0/docs/api/index.html. Acessado em: 04.JUN.05.
1
ANEXO 1 – Código Fonte do Sistema ARc
Para desenvolver o código do sistema foi utilizado o NetBeans IDE 4.1, encontrado em
http://www.netbeans.org.
CLASSES
[ ar ]
[ informação ]
BDLista.java ............................................................................................3
Comando.java .........................................................................................3
ComandoEscalonado.java .....................................................................4
ElementoComando.java .........................................................................4
ElementoComandoEscalonado.java .....................................................5
ElementoMotor.java................................................................................5
FilaComando.java ...................................................................................6
FilaComandoEscalonado.java ...............................................................8
FilaMotor.java........................................................................................10
Motor.java ..............................................................................................12
NPA.java ................................................................................................13
NSA.java ................................................................................................13
NAProcessado.java ..............................................................................14
ValorMotores.java .................................................................................14
[ controle ]
ControleDelay.java................................................................................16
Escalonador.java ..................................................................................19
SerialCMDE.java....................................................................................20
2
Transmissor.java ..................................................................................22
[ controle.bd ]
Conexão.java ...................................................................................26
ControleBD.java ..............................................................................27
DesmontadorNSA.java ...................................................................35
ValidadorNSA.java ..........................................................................36
[ interação ]
Config.java.............................................................................................39
Principal.java.........................................................................................47
Splash.java ............................................................................................55
TelaAguarde.java ..................................................................................57
TelaNPA.java..........................................................................................58
TelaNSA.java .........................................................................................81
[ núcleo ]
Núcleo.java ............................................................................................88
Paramentros.java ..................................................................................93
Main.java......................................................................................................98
3
PACOTE: ar.informacao
BDLista.java
1 /*
2 * BDLista.java
3 *
4 */
5
6 package ar.informacao;
7
8 /**
9 * Utilizado para intermediar a passagem de dados do Banco de Dados e do
NSA.
10 * @author Leonardo Torati
11 */
12 public class BDListaElemento {
13
14
public String id, tipo;
15
16
/**
17
*
18
*/
19
public BDListaElemento(String ID, String TIPO) {
20
id = ID;
21
tipo = TIPO;
22
}
23
24
public String toString(){
25
return id + " (" + tipo + ")";
26
}
27 }
28
Comando.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*
* Comando.java
*/
package ar.informacao;
/**
*
* @author Leonardo Torati
*/
public class Comando {
public FilaMotor n, s, l, o;
public int getElementos(){
int i = n.getElementos() + l.getElementos() + s.getElementos() +
o.getElementos();
return i;
}
4
21
22
23
24
25
26
27
28
29
30 }
}
return ("CMD: " + getElementos());
public Comando(){
n = new FilaMotor("N");
s = new FilaMotor("S");
l = new FilaMotor("L");
o = new FilaMotor("O");
}
ComandoEscalonado.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/*
* ComandoEscalonado.java
*/
import java.io.Serializable;
/**
*
*/
public class ComandoEscalonado implements Serializable{
public FilaMotor fila;
public ComandoEscalonado(FilaMotor f){
fila = f;
}
public ComandoEscalonado(){
fila = new FilaMotor("X");
}
}
ElementoComando.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/*
* ElementoComando.java
*/
import ar.*;
/**
*
*/
public class ElementoComando {
5
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31 }
private Comando comando;
private ElementoComando proximo;
public
public
public
public
void setComando(Comando cmd){comando = cmd;}
Comando getComando(){return comando;}
void setProximo(ElementoComando p){proximo = p;}
ElementoComando getProximo(){return proximo;}
return ("" + comando);
}
public ElementoComando(Comando c, ElementoComando p){
proximo = p;
comando = c;
}
ElementoComandoEscalonado.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*
* ElementoComandoEscalonado.java
*/
/**
*
*/
public class ElementoComandoEscalonado {
22
23
24
25
26 }
private ComandoEscalonado comando;
private ElementoComandoEscalonado proximo;
public
public
public
public
void setComando(ComandoEscalonado cmd){comando = cmd;}
ComandoEscalonado getComando(){return comando;}
void setProximo(ElementoComandoEscalonado p){proximo = p;}
ElementoComandoEscalonado getProximo(){return proximo;}
public ElementoComandoEscalonado(ComandoEscalonado c,
ElementoComandoEscalonado p){
proximo = p;
comando = c;
}
ElementoMotor.java
1/*
2 * ElementoMotor.java
3 */
4
6
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import ar.*;
/**
*
*/
public class ElementoMotor implements Serializable{
private Motor motor;
private ElementoMotor proximo;
public void setMotor(Motor m){motor = m;}
public Motor getMotor(){return motor;}
public void setProximo(ElementoMotor p){proximo = p;}
public ElementoMotor getProximo(){return proximo;}
public ElementoMotor(Motor m, ElementoMotor p){
motor = m;
proximo = p;
}
}
return motor.getId() + motor.getValor();
}
FilaComando.java
1/*
2 * FilaComando.java
3 */
4
6
7 /**
8 *
9 * @author Usuario
10 */
11 import java.util.Vector;
12 import ar.informacao.ElementoComando;
13 import ar.informacao.Comando;
14
15 /**
16 *
18 */
19 public class FilaComando{
20
private Vector<ElementoComando> v;
21
private int qtd;
22
private ElementoComando inicio, fim;
23
24
public int getElementos(){return qtd;}
25
26
public Vector<ElementoComando> getVector(){
7
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
}
return v;
public void adicionar(Comando c){
if(c != null){
//criar elemento
ElementoComando e = new ElementoComando(c, null);
//adicionar elemento
v.add(e);
//setar inicio e fim
if(qtd == 0){ //primeiro elemento
inicio = e;
fim = e;
}else{
fim.setProximo(e);
fim = e;
}
//incrementar contador
qtd++;
}
}
public Comando remover(){
Comando retorno = null;
if(qtd == 0){
//fila vazia
retorno = null;
}else{
//fila n?o vazia
//remover cabe?a
ElementoComando tmp;
retorno = inicio.getComando();
tmp = inicio;
inicio = inicio.getProximo();
tmp = null;
//System.gc();
}
}
qtd--;
return retorno;
public Comando consultar(int pos){
Comando ret = null;
if(qtd > 0 && pos <= qtd){
ElementoComando e = v.get(pos - 1);
ret = e.getComando();
}
}
return ret;
public void alterar(int pos, Comando c){
if(qtd > 0 && pos <= qtd && c != null){
ElementoComando e = v.get(pos -1);
8
86
87
88
89
90
91
92
93
94
95
96
97 }
}
}
e.setComando(c);
v.set(pos - 1, e);
public FilaComando(){
v = new Vector<ElementoComando>();
inicio = null;
fim = null;
qtd = 0;
}
FilaComandoEscalonado.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/*
* FilaComandoEscalonado.java
*/
import java.util.Vector;
import ar.*;
//Comando, ElementoComando, FilaComando
/**
*
*/
public class FilaComandoEscalonado{
private Vector<ElementoComandoEscalonado> v;
private int qtd;
private ElementoComandoEscalonado inicio, fim;
public void adicionar(ComandoEscalonado c){
//pre: c nao eh null
//pos: c adicionado em v e qtd incrementado
if(c != null){
//criar elemento
ElementoComandoEscalonado e = new ElementoComandoEscalonado(c,
null);
v.add(e);
inicio = e;
fim = e;
}else{
fim.setProximo(e);
fim = e;
}
qtd++;
}
}
9
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96 }
public ComandoEscalonado remover(){
//pre: qtd nao eh 0
//pos: elemento removido e retornado
ComandoEscalonado retorno = null;
if(qtd == 0){
//fila vazia
retorno = null;
}else{
//fila n?o vazia
//remover cabe?a
ElementoComandoEscalonado tmp;
retorno = inicio.getComando();
tmp = inicio;
tmp = null;
//System.gc();
}
qtd--;
}
return retorno;
public ComandoEscalonado consultar(int pos){
//pre: pos eh valido
//pos: retorna o motor do elemento em pos
ComandoEscalonado ret = null;
}
if(qtd > 0 && pos <= qtd){
ElementoComandoEscalonado e = v.get(pos - 1);
ret = e.getComando();
}
return ret;
public void alterar(int pos, ComandoEscalonado c){
//pre: pos eh valido e m != null
//pos: motor do elemento na pos indicada eh reconfigurado
}
if(qtd > 0 && pos <= qtd && c != null){
ElementoComandoEscalonado e = v.get(pos -1);
e.setComando(c);
v.set(pos - 1, e);
}
public FilaComandoEscalonado(){
v = new Vector<ElementoComandoEscalonado>();
inicio = null;
fim = null;
qtd = 0;
}
10
FilaMotor.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/*
* FilaMotor.java
*/
import ar.*;
//Motor, ElementoMotor, FilaMotor
/**
*
*/
public class FilaMotor implements Serializable{
private Vector<ElementoMotor> v;
private int qtd;
private String id;
private ElementoMotor inicio, fim;
public String getId(){return id;}
public String toString(){return (id + " (" + qtd + ")");}
public Vector<ElementoMotor> getVector(){
return v;
}
public void adicionar(Motor m){
//pre: m nao eh null
//pos: m adicionado em v e qtd incrementado
if(m != null){
String mid = m.getId();
}
}
//criar elemento
ElementoMotor e = new ElementoMotor(m, null);
v.add(e);
inicio = e;
fim = e;
}else{
fim.setProximo(e);
fim = e;
}
qtd++;
public Motor remover(){
//pre: qtd nao eh 0
//pos: elemento removido e retornado
11
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
Motor retorno = null;
if(qtd == 0){
//fila vazia
retorno = null;
}else{
//fila n?o vazia
//remover cabe?a
ElementoMotor tmp;
retorno = inicio.getMotor();
tmp = inicio;
tmp = null;
//System.gc();
}
qtd--;
}
return retorno;
public Motor primeiro(){
Motor retorno = null;
if(qtd == 0){
//fila vazia
retorno = null;
}else{
//fila n?o vazia
//remover cabe?a
ElementoMotor tmp;
}
}
retorno = inicio.getMotor();
return retorno;
public Motor consultar(int pos){
//pre: pos eh valido
//pos: retorna o motor do elemento em pos
Motor ret = null;
if(qtd > 0 && pos < qtd){
ElementoMotor e = v.get(pos);
ret = e.getMotor();
}
}
return ret;
public void alterar(int pos, Motor m){
//pre: pos eh valido e m != null
//pos: motor do elemento na pos indicada eh reconfigurado
if(qtd > 0 && pos < qtd && m != null){
ElementoMotor e = v.get(pos);
e.setMotor(m);
v.set(pos, e);
12
116
117
118
119
120
121
122
123
124
125
126 }
}
}
public FilaMotor(String sid){
id = sid;
v = new Vector<ElementoMotor>();
inicio = null;
fim = null;
qtd = 0;
}
Motor.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/*
* Motor.java
*/
/**
*
*/
public class Motor implements Serializable{
private int valor; //valor
private int delay;
private String id, nome;
public void setValor(int v){
valor = v;
}
public
public
public
public
void setId(String s){id = s;}
String getId(){return id;}
void setNome(String n){nome = n;}
String getNome(){return nome;}
public void setDelay(int d){delay = d;}
public int getDelay(){return delay;}
public int getValor(){return valor;}
public Motor(String s, int v, int d){
valor = v;
delay = d;
id = s;
}
public String toString(){return "" + id + valor + "(" + delay + ")";}
}
13
NPA.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/*
* NPA.java
*/
import ar.informacao.Comando;
/**
*
*/
public class NPA {
String id;
Comando cmd;
public String getId(){ return id; }
public Comando getCmd(){ return cmd; }
/** Creates a new instance of NPA */
public NPA(String ID, Comando CMD) {
id = ID;
cmd = CMD;
}
}
public String toString(){ return id; }
NSA.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
* NSA.java
*/
import ar.informacao.*;
/**
*
*/
public class NSA {
private String id;
private Vector<BDListaElemento> lista;
public Vector<BDListaElemento> getLista(){ return lista; }
/** Creates a new instance of NSA */
public NSA(String ID, Vector<BDListaElemento> LISTA) {
id = ID;
lista = LISTA;
}
public String toString(){ return id; }
14
27 }
NSAProcessado.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/*
* NSAProcessado.java
*/
/**
*
*/
public class NSAProcessado {
private String id;
private ComandoEscalonado cmde;
public ComandoEscalonado getComandoEscalonado(){ return cmde; }
public void setComandoEscalonado(ComandoEscalonado c){ cmde = c; }
/** Creates a new instance of NSAProcessado */
public NSAProcessado(String ID) {
id = ID;
cmde = null;
}
public NSAProcessado(String ID, ComandoEscalonado c) {
id = ID;
cmde = c;
}
}
return id + " ("+cmde.fila.getElementos()+")";
}
ValorMotores.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/*
* ValorMotores.java
*/
/**
*
*/
public class ValorMotores {
public int a, b, c, d, e, f, g, h;
15
15
16
17
18
19
20
21 }
public ValorMotores(){
}
public ValorMotores(int valPadrao){
a = b = c = d = e = f = g = h = valPadrao;
}
16
PACOTE: ar.controle
ControleDelay.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/*
* ControleDelay.java
*/
package ar.controle;
import ar.nucleo.*;
import ar.nucleo.Nucleo;
/**
*
*/
public class ControleDelay {
private Nucleo nucleo;
private FilaComando fentrada, fsaida;
private int tempoDelay;
private int da, db, dc, dd, de, df, dg, dh;
/**
*
*/
public void setEntrada(FilaComando fila){
fentrada = fila;
}
/**
*
*/
public FilaComando getSaida(){
return fsaida;
}
/**
*
*/
public void ajustarDelay(){
fsaida = new FilaComando();
Comando cmd;
//descarregar fila de entrada
if(fentrada != null){
while(fentrada.getElementos() > 0){
//remover proximo comando
cmd = fentrada.remover();
//calcular fila
cmd.n = calcular(cmd.n);
cmd.s = calcular(cmd.s);
cmd.l = calcular(cmd.l);
cmd.o = calcular(cmd.o);
17
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
}
}
}
//adicionar comando na saida
fsaida.adicionar(cmd);
nucleo.msg(fsaida.getElementos() + " Comandos.", true);
private int getUltimoValor(Motor m){
if(m.getId().equals("A")){
return da;
}
if(m.getId().equals("B")){
return db;
}
if(m.getId().equals("C")){
return dc;
}
if(m.getId().equals("D")){
return dd;
}
if(m.getId().equals("E")){
return de;
}
if(m.getId().equals("F")){
return df;
}
if(m.getId().equals("G")){
return dg;
}
if(m.getId().equals("H")){
return dh;
}
return 0;
}
private void setUltimoValor(Motor m){
if(m.getId().equals("A")){
da = m.getValor();
return;
}
if(m.getId().equals("B")){
db = m.getValor();
return;
}
if(m.getId().equals("C")){
dc = m.getValor();
return;
}
if(m.getId().equals("D")){
dd = m.getValor();
return;
}
if(m.getId().equals("E")){
de = m.getValor();
return;
}
18
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
}
if(m.getId().equals("F")){
df = m.getValor();
return;
}
if(m.getId().equals("G")){
dg = m.getValor();
return;
}
if(m.getId().equals("H")){
dh = m.getValor();
return;
}
private FilaMotor calcular(FilaMotor fila){
int delay, ultimoVal, diferenca;
Motor motor;
//calcular delay para cada motor da fila
//verificar motores
for(int i=0;i<fila.getElementos();i++){
//consultar motor
motor = fila.consultar(i);
//diferença
ultimoVal = getUltimoValor(motor);
diferenca = Math.abs(ultimoVal - motor.getValor());
if(diferenca != 0){ //se não houver movimento, não é
necessário inserir
//delay do Motor
delay = (tempoDelay * diferenca) / 50;
delay);
//aplicar novo delay ao motor
Motor x = new Motor(motor.getId(), motor.getValor(),
fila.alterar(i, x);
}
}
//guardar ultimo valor enviado para o motor
setUltimoValor(x);
}/*else{
System.err.println("Comando não inserido");
}*/
return fila;
/**
*
*/
public ControleDelay(Nucleo n){
nucleo = n;
Parametros p = nucleo.getParametros();
19
170
171
172
173
174
175
176 }
tempoDelay = p.getTempoDelay();
}
fentrada = null;
fsaida = null;
Escalonador.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
/*
* Escalonador.java
*/
import ar.nucleo.Nucleo;
/**
*
*/
public class Escalonador {
Nucleo nucleo;
FilaComando entrada;
ComandoEscalonado cmde;
String id;
public void setEntrada(FilaComando fila){entrada = fila;}
//executar um motor de cada fila no comando e aguardar o maior
delay
public void escalonar(String ID, boolean gravar){
id = ID;
if(entrada != null && entrada.getElementos() > 0){
cmde = new ComandoEscalonado();
Comando cmd;
Motor mn, ms, ml, mo, m;
int delay;
while(entrada.getElementos() > 0){
cmd = entrada.remover();
while(cmd.getElementos()>0){
delay = maiorDelay(cmd);
mn
ms
ml
mo
=
=
=
=
cmd.n.remover();
cmd.s.remover();
cmd.l.remover();
cmd.o.remover();
m = new Motor(mn.getId(), mn.getValor(), 0);
cmde.fila.adicionar(m);
m = new Motor(ms.getId(), ms.getValor(), 0);
20
49
50
51
52
53
54
55
56
57
58
m = new Motor(ml.getId(), ml.getValor(), 0);
m = new Motor(mo.getId(), mo.getValor(), delay);
}
}
nucleo.msg("Escalonador: " + cmde.fila.getElementos() + "
elementos no comando escalonado.");
if(gravar == true) gravarNSAProcessado();
}
}
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100 }
public ComandoEscalonado getSaida(){return cmde;}
private int maiorDelay(Comando cmd){
int ret=0, delay;
Motor m;
m=cmd.n.primeiro();
delay = m.getDelay();
if(delay > ret) ret = delay;
m=cmd.s.primeiro();
m=cmd.l.primeiro();
m=cmd.o.primeiro();
}
return ret;
/**
*
*/
public Escalonador(Nucleo n) {
nucleo = n;
entrada = null;
}
private void gravarNSAProcessado(){
NSAProcessado nsap = new NSAProcessado(id, cmde);
nucleo.getControleBD().updateNSAProcessado(nsap);
}
SerialCMDE.java
1 /*
2 * SerialCMDE.java
21
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
*/
import java.io.*;
/**
*
*/
public class SerialCMDE {
//public void setCmde(ComandoEscalonado c){cmde = c;}
//public void setId(String ID){id = ID;}
public boolean serializar(ComandoEscalonado cmde, String id){
boolean ret = true;
//criar e serializar arquivo
if(id.equals("") == false && cmde != null){
try{
File file = new File(id + ".nsap");
FileOutputStream out = new FileOutputStream(file);
ObjectOutputStream objout = new ObjectOutputStream(out);
objout.writeObject(cmde);
objout.close();
}catch(IOException e){
ret = false;
e.printStackTrace();
}
}
}else{
ret = false;
}
return ret;
public ComandoEscalonado deSerializar(String id){
//desserializar arquivo
ComandoEscalonado cmde = null;
if(id.equals("") == false){
if(file.exists() == true){
try{
FileInputStream in = new FileInputStream(file);
ObjectInputStream objin = new ObjectInputStream(in);
cmde = (ComandoEscalonado) objin.readObject();
objin.close();
}catch(IOException e){
}catch(ClassNotFoundException e){
}
22
61
62
63
64
65
66
67 }
}
}
}
return cmde;
Transmissor.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/*
* Transmissor.java
*/
import ar.nucleo.*;
import java.io.*;
import java.util.*;
import javax.comm.*;
/**
*
*/
public class Transm {
private static Enumeration portList;
private static CommPortIdentifier portId;
private static SerialPort serialPort;
private static OutputStream outputStream;
private FilaComandoEscalonado fentrada;
private String porta;
int motoresEnviados;
private boolean portaAberta;
public void setEntrada(FilaComandoEscalonado fila){
fentrada = fila;
}
public void transmitir(){
//preparar porta
motoresEnviados = 0;
if(preparar() == false){
ComandoEscalonado cmde;
//descarregar todos os Motores da Fila
if(fentrada != null){
nucleo.msg(fentrada.getElementos() + " Comandos. ", true);
while(fentrada.getElementos() > 0){
//Descarregar proximo comandoEscalonado
23
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
cmde = fentrada.remover();
if(cmde != null){
//descarregar todos os motores e enviar para
robo
enviarMotores(cmde);
}
}
nucleo.msg(motoresEnviados + " motores enviados.");
}
}else{
nucleo.msg("Erro na transmissão", "Não é possivel preparar
para transmissão");
}
}
private void enviarMotores(ComandoEscalonado c){
Motor motor;
//descarrega e envia motores do ComandoEscalonado
if(c != null){
if(c.fila != null){
while(c.fila.getElementos()> 0){
//descarregar proximo motor
motor = c.fila.remover();
//transmitir
enviar(motor);
}
}
}
}
motoresEnviados++;
private boolean preparar() {
boolean ret = false;
portList = CommPortIdentifier.getPortIdentifiers();
if(portaAberta == false){
portaAberta = true;
while (portList.hasMoreElements()) {
portId = (CommPortIdentifier) portList.nextElement();
if (portId.getPortType() ==
CommPortIdentifier.PORT_SERIAL) {
if (portId.getName().equals(porta)) {
try {
serialPort = (SerialPort) portId.open("AR",
2000);
} catch (PortInUseException e) {
ret = true;
nucleo.msg("Abrir porta.", e.toString());
portaAberta = false;
}
try {
outputStream = serialPort.getOutputStream();
nucleo.msg(serialPort.toString());
//##########################
} catch (IOException e) {
24
ret = true;
nucleo.msg("Preparar strem de saída.",
104
105
e.toString());
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
}
try {
serialPort.setSerialPortParams(4800,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);
} catch
(javax.comm.UnsupportedCommOperationException e) {
ret = true;
nucleo.msg("Operação não suportada.",
e.toString());
}
}
}
}
}
}
return ret;
private void enviar(Motor m){
String msg = "";
int delay=0;
if(m != null){
msg = m.getId() + m.getValor() + "\r";
try {
nucleo.msg(msg);
//#####################################################
outputStream.write(msg.getBytes());
} catch (IOException e) {
nucleo.msg("Falha no envio dos dados.", e.toString());
}catch(NullPointerException e){
nucleo.msg("Falha no envio dos dados.", e.toString());
}
}
//delay
timerDelay(delay);
}
private void timerDelay(int d){
//faz uma pausa de tamanho d
long tatual = System.currentTimeMillis();
long tfinal = tatual + d;
//nucleo.msg(">" + tatual);
while(tfinal > System.currentTimeMillis()){
//esperar
}
//verificação - apagar ao concluir projeto
//nucleo.msg("-" + System.currentTimeMillis());
25
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176 }
}
public Transm(Nucleo n){
nucleo = n;
Parametros p = n.getParametros();
porta = p.getPortaSerial();
portList = null;
portId = null;
serialPort = null;
outputStream = null;
}
26
PACOTE: ar.controle.bd
Conexão.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/*
* Conexao.java
*/
package ar.controle.bd;
import ar.nucleo.*;
import java.sql.*;
/**
*
*/
public class Conexao {
private String login, senha, arquivo;
private Connection conn;
public void conectar(){
conn = null;
try {
Class.forName("org.firebirdsql.jdbc.FBDriver");
conn =
DriverManager.getConnection(
"jdbc:firebirdsql:localhost/3050:" + arquivo,
login,
senha);
nucleo.msg("Conectado ao Banco de Dados.");
}
}catch(ClassNotFoundException e){
nucleo.msg("Conectando no banco de dados.", e.toString());
}catch(SQLException e){
nucleo.msg("Conectando no banco de dados.", e.toString());
}
public Connection getConnection(){ return conn; }
/**
*
*/
public Conexao(Nucleo n) {
nucleo = n;
login = nucleo.getParametros().getLogin();
senha = nucleo.getParametros().getSenha();
arquivo = nucleo.getParametros().getArquivo();
}
}
27
ControleBD.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/*
* ControleBD.java
*/
import
import
import
import
import
import
java.sql.*;
ar.nucleo.*;
ar.informacao.*;
java.util.Vector;
java.io.File;
ar.controle.SerialCMDE;
/**
*
*
*
*/
public class ControleBD {
private
private
private
private
Nucleo nucleo;
Connection conn;
Statement stm;
SerialCMDE scmde;
//====CONEXÃO=========================================================
======
public void setConexao(Conexao c){
conn = c.getConnection();
}
private void setStm(){
if(conn != null){
try{
stm = conn.createStatement();
nucleo.msg("Preparando controle BD.", e.toString());
}
}else{
nucleo.msg("Preparando controle BD.", "Conexão nula.");
}
}
//====LISTAS==========================================================
======
public Vector<String> listaNSA(){
//retorn lista de NSA
Vector<String> res = new Vector<String>();
ResultSet rs = null;
String sql = "SELECT * FROM TAB_NSA;";
try{
28
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
setStm();
rs = stm.executeQuery(sql);
if(rs != null){
//estrair valor dos motores do Banco de Dados
String str;
while(rs.next()){
str = rs.getString("ID");
res.add(str);
};
}
}catch(SQLException ex) {
nucleo.msg("Listando NSA.", ex.toString());
}
}
return res;
public Vector<String> listaNSAProcessado(){
//retorn lista de NSA
String sql = "SELECT * FROM TAB_PROC;";
try{
setStm();
if(rs != null){
String str;
while(rs.next()){
res.add(str);
};
}
nucleo.msg("Listando NSA Processado.", ex.toString());
}
}
return res;
public Vector<String> listaNPA(){
//retorn lista de NPA
String sql = "SELECT * FROM TAB_NPA;";
try{
setStm();
if(rs != null){
29
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
}
String str;
while(rs.next()){
res.add(str);
};
nucleo.msg("Listando NPA.", ex.toString());
}
}
return res;
//====CONSULTAS=======================================================
======
public ResultSet consulta(String sql){
ResultSet res = null;
try{
setStm();
res = stm.executeQuery(sql);
nucleo.msg("Consulta SQL.", e.toString());
}
}
return res;
public NPA consultaNPA(String id){
NPA npa = null;
Comando cmd = new Comando();
String sql = "SELECT * FROM TAB_COMANDO WHERE NPA = "" + id +
"" ORDER BY ORDEM;";
int valor;
String motorId, pata;
Motor motor;
try{
setStm();
if(rs != null){
while(rs.next()){
motorId = rs.getString("MOTOR");
pata = rs.getString("PATA");
valor = rs.getInt("VALOR");
}
motor = new Motor(motorId, valor, 0);
pata.toUpperCase();
if(pata.equals("N")){ cmd.n.adicionar(motor);
if(pata.equals("S")){ cmd.s.adicionar(motor);
if(pata.equals("L")){ cmd.l.adicionar(motor);
if(pata.equals("O")){ cmd.o.adicionar(motor);
}
}
}
}
30
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
}
if(cmd.getElementos() > 0){
npa = new NPA(id, cmd);
}
nucleo.msg("Consultando NPA.", ex.toString());
}
}
return npa;
public NSA consultaNSA(String id){
NSA nsa = null;
Vector<BDListaElemento> v = null;
String sql = "SELECT * FROM TAB_NSA_LISTA WHERE NSA = "" + id +
"" ORDER BY ORDEM;";
try{
setStm();
if(rs != null){
v = new Vector<BDListaElemento>();
//estrair lista NSA
BDListaElemento elemento;
String aa, bb;
while(rs.next()){
aa = rs.getString("ITEM");
bb = rs.getString("TIPO");
elemento = new BDListaElemento(aa, bb);
}
}
v.add(elemento);
}
if(v.size() > 0){
nsa = new NSA(id, v);
}
nucleo.msg("Consultando NSA.", ex.toString());
}
return nsa;
public boolean consultaNSAProcessado(String id){
boolean nsap = false;
ComandoEscalonado cmde = new ComandoEscalonado();
String sql = "SELECT * FROM TAB_PROC WHERE ID = "" + id + "";";
try{
31
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
setStm();
if(rs != null){
//testar se arquivo existe
nsap = true;
}else{ //se não há arquivo, eliminar bd
excluirNSAProcessado(id);
}
}
}
nucleo.msg("Consultando NSA Processado.", ex.toString());
}
return nsap;
//====UPDATES=========================================================
======
public void updateNPA(NPA cnpa){
//verificar se existe npa, se sim, atualiza, se não, cria
Vector<String> vsql = new Vector<String>();
NPA tmp = consultaNPA(cnpa.getId());
Comando cmd = cnpa.getCmd();
Motor m;
int valor, ordem;
String pata, motorId, npaId, sql;
npaId = cnpa.getId();
int cont = cmd.n.getElementos();
for(int i=1; i<=cont; i++){
m = cmd.n.remover();
valor = m.getValor();
motorId = m.getId();
pata = "N";
ordem = i;
sql = "INSERT INTO TAB_COMANDO (NPA, PATA, MOTOR, VALOR,
ORDEM) VALUES (""+
npaId + "", "" + pata + "", "" + motorId + "", " +
valor + ", " + ordem + ");";
vsql.add(sql);
}
cont = cmd.s.getElementos();
m = cmd.s.remover();
pata = "S";
ordem = i;
ORDEM) VALUES (""+
32
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
}
valor + ", " + ordem + ");";
vsql.add(sql);
cont = cmd.l.getElementos();
m = cmd.l.remover();
pata = "L";
ordem = i;
sql = "INSERT INTO TAB_COMANDO (NPA, PATA, MOTOR, VALOR, ORDEM)
VALUES (""+
valor + ", " + ordem + ");";
vsql.add(sql);
}
cont = cmd.o.getElementos();
m = cmd.o.remover();
pata = "O";
ordem = i;
ORDEM) VALUES (""+
valor + ", " + ordem + ");";
vsql.add(sql);
}
tmp = consultaNPA(cnpa.getId());
if(tmp != null){ //apagar existente
sql = "DELETE FROM TAB_COMANDO WHERE NPA = "" + cnpa.getId()
+ "";";
if(update(sql) == false){
nucleo.msg("Inserindo NPA na Base de Dados.", "Falha no
DELETE.");
}
}else{
sql = "INSERT INTO TAB_NPA (ID) VALUES ("" + npaId + "");";
nucleo.msg("Inserindo NPA na Base de Dados.", "Falha ao
criar NPA na Tabela NPA.");
}
}
for(int i = 0; i<vsql.size(); i++){
sql = (String) vsql.get(i);
nucleo.msg("Inserindo NPA na Base de Dados.", "Falha no
Update.");
break;
}
}
}
public void updateNSA(NSA item){
33
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
Vector<String> vsql = new Vector<String>();
String sql, idNsa, idItem, tipo;
int ordem;
BDListaElemento bde;
//preparar sqls da lista nsa
int cont = item.getLista().size();
for(int i=0; i<cont; i++){
bde = item.getLista().get(i);
idNsa = item.getId();
idItem = bde.id;
tipo = bde.tipo;
ordem = (i + 1);
sql = "INSERT INTO TAB_NSA_LISTA (NSA, ITEM, TIPO, ORDEM)
VALUES (""+
idNsa + "", "" + idItem + "", "" + tipo + "", " +
ordem + ");";
}
vsql.add(sql);
//verificar se existe nsa, se sim, excluir e criar
NSA tmp = consultaNSA(item.getId());
if(tmp != null){ //existe nsa, excluir
sql = "DELETE FROM TAB_NSA_LISTA WHERE NSA = "" +
item.getId() + "";";
nucleo.msg("Inserindo NSA na Base de Dados.", "Falha no
DELETE.");
}
}else{
sql = "INSERT INTO TAB_NSA (ID) VALUES ("" + item.getId() +
"");";
nucleo.msg("Inserindo NSA na Base de Dados.", "Falha ao
criar NSA na Tabela NSA.");
}
}
for(int i = 0; i<vsql.size(); i++){
sql = (String) vsql.get(i);
nucleo.msg("Inserindo NSA na Base de Dados.", "Falha no
Update.");
break;
}
}
}
public void updateNSAProcessado(NSAProcessado cnsa){
//verificar se existe npa, se sim, atualiza, se não, cria
String sql;
ComandoEscalonado cmde = cnsa.getComandoEscalonado();
String id = cnsa.getId();
boolean tmp = consultaNSAProcessado(id);
if(tmp == false){ //apagar existente
34
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
sql = "INSERT INTO TAB_PROC (ID) VALUES ("" + id + "");";
nucleo.msg("Inserindo NPA na Base de Dados.", "Falha ao
criar NPA na Tabela NPA.");
}
}
}
//criar arquivo
scmde = new SerialCMDE();
scmde.serializar(cmde, id);
public boolean update(String sql){
boolean res = false;
try{
setStm();
stm.executeUpdate(sql);
nucleo.msg("Update efetuado.");
res = true;
nucleo.msg("Atualização", e.toString());
}
return res;
}
//====EXCLUSÕES=======================================================
=====
public void excluirNPA(String id){
String sql;
sql = "DELETE FROM TAB_COMANDO WHERE NPA = "" + id + "";";
update(sql);
sql = "DELETE FROM TAB_NPA WHERE ID = "" + id + "";";
update(sql);
}
public void excluirNSA(String id){
String sql;
sql = "DELETE FROM TAB_NSA_LISTA WHERE NSA = "" + id + "";";
update(sql);
sql = "DELETE FROM TAB_NSA WHERE ID = "" + id + "";";
update(sql);
}
public void excluirNSAProcessado(String id){
String sql = "DELETE FROM TAB_PROC WHERE ID = "" + id + "";";
update(sql);
//excluir arquivo
if(file.delete() == false){
nucleo.msg("Falha ao deletar NSA Processado.", "Arquivo
não deletado.");
}
}
}
35
440
441
442
443
444
445
446
447
448
//====CONSTRUTOR======================================================
=====
/**
*
*/
public ControleBD(Nucleo n, Conexao c) {
nucleo = n;
setConexao(c);
}
}
DesmontadorNSA.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
/*
* DesmontadorNSA.java
*/
import ar.nucleo.*;
/**
*
*/
public class DesmontadorNSA {
Nucleo nucleo;
FilaComando fila;
Vector lista;
ControleBD cbd;
String id;
Comando cmd;
public
}
DesmontadorNSA(Nucleo n, String ID, Vector l, FilaComando f) {
nucleo = n;
cbd = n.getControleBD();
lista = l;
id = ID;
fila = f;
private int verificarLista(String ID){
int res = -1;
String str;
for(int i = 0; i<lista.size(); i++){
str = (String) lista.get(i);
if(str.equals(ID)){
res = i;
}
}
}
return res; //se > -1: encontrou na lista
public boolean desmontar(){
36
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90 }
boolean res = true;
NSA tmp = cbd.consultaNSA(id);
if(tmp != null){
Vector<BDListaElemento> v = tmp.getLista();
if(v != null){
if(v.size() != 0){
//verificar itens de v
for(int i=0;i<v.size();i++){
BDListaElemento bdl = (BDListaElemento) v.get(i);
if(bdl.tipo.equals("NSA")){
if(verificarLista(bdl.id) != -1){
//adicionar id nsa na lista
lista.add(bdl.id);
//desmontar
DesmontadorNSA dnsa = new
DesmontadorNSA(nucleo, bdl.id, lista, fila);
if(dnsa.desmontar() == false){
res = false;
break;
}
//remover id nsa da lista
lista.remove(verificarLista(bdl.id));
}
}else{ //NPA, colocar na fila
NPA novo =
nucleo.getControleBD().consultaNPA(bdl.id);
if(novo != null){
//adicionar na fila
cmd = novo.getCmd();
fila.adicionar(cmd);
}else{
res = false;
}
}
if(res == false) break;
}
}else{
res = false;
}
}else{
res = false;
}
}
return res; //se true, é válido
}
ValidadorNSA.java
1 /*
2 * ValidadorNSA.java
3 */
4
5 package ar.controle.bd;
6
7 import ar.nucleo.*;
8 import ar.informacao.*;
37
9 import java.util.Vector;
10 /**
11 *
13 */
14 public class ValidadorNSA {
15
Nucleo nucleo;
16
Vector lista;
17
ControleBD cbd;
18
String id;
19
20
public ValidadorNSA(Nucleo n, String ID, Vector l) {
21
nucleo = n;
22
cbd = n.getControleBD();
23
lista = l;
24
id = ID;
25
26
}
27
28
private int verificarLista(String ID){
29
int res = -1;
30
String str;
31
32
for(int i = 0; i<lista.size(); i++){
33
str = (String) lista.get(i);
34
if(str.equals(ID)){
35
res = i;
36
}
37
}
38
39
return res; //se > -1: encontrou na lista
40
}
41
42
public boolean validar(){
43
boolean res = true;
44
45
NSA tmp = cbd.consultaNSA(id);
46
if(tmp != null){
47
Vector<BDListaElemento> v = tmp.getLista();
48
if(v != null){
49
if(v.size() != 0){
50
//verificar itens de v
51
for(int i=0;i<v.size();i++){
52
BDListaElemento bdl = (BDListaElemento) v.get(i);
53
if(bdl.tipo == "NSA"){
54
if(verificarLista(bdl.id) != -1){
55
//adicionar id nsa na lista
56
lista.add(bdl.id);
57
//desmontar
58
ValidadorNSA dnsa = new
ValidadorNSA(nucleo, bdl.id, lista);
59
if(dnsa.validar() == false){
60
res = false;
61
break;
62
}
63
//remover id nsa da lista
64
lista.remove(verificarLista(bdl.id));
65
}
66
}
38
67
68
69
70
71
72
73
74
75
76
77 }
}
}else{
res = false;
}
}else{
res = false;
}
}
}
return res; //se true, é válido
39
PACOTE: ar.interacao
Config.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
/*
* Config.java
*/
package ar.interacao;
import ar.nucleo.*;
import java.io.*;
import ar.informacao.ValorMotores;
/**
*
*/
public class Config extends javax.swing.JFrame {
private Parametros p;
private ValorMotores vm;
//====PARÂMETROS======================================================
======
/**
*
*/
public Config(Nucleo n) {
nucleo = n;
p = n.getParametros();
initComponents();
}
/**
*
*/
public void carregarParametros(){
vm = p.getIni();
sldA.setValue(vm.a);
sldB.setValue(vm.b);
sldC.setValue(vm.c);
sldD.setValue(vm.d);
sldE.setValue(vm.e);
sldF.setValue(vm.f);
sldG.setValue(vm.g);
sldH.setValue(vm.h);
tfTempoDelay.setText("" + p.getTempoDelay());
tfDelayMax.setText("" + p.getDelayMax());
String l="", s="", arq = "";
l = p.getLogin();
40
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
}
s = p.getSenha();
tfLogin.setText(l);
pfSenha.setText(s);
arq = p.getArquivo();
tfArquivo.setText(arq);
tfPortaSerial.setText(p.getPortaSerial());
public Parametros salvarParametros(){
Parametros p = nucleo.getParametros();
vm.a
vm.b
vm.c
vm.d
vm.e
vm.f
vm.g
vm.h
=
=
=
=
=
=
=
=
sldA.getValue();
sldB.getValue();
sldC.getValue();
sldD.getValue();
sldE.getValue();
sldF.getValue();
sldG.getValue();
sldH.getValue();
p.setIni(vm);
p.setDelayMax(Integer.parseInt(tfDelayMax.getText()));
p.setTempoDelay(Integer.parseInt(tfTempoDelay.getText()));
p.setLogin(tfLogin.getText());
p.setSenha(pfSenha.getText());
p.setArquivo(tfArquivo.getText());
p.setPortaSerial(tfPortaSerial.getText());
}
return p;
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
// <editor-fold defaultstate="collapsed" desc=" Generated Code ">
private void initComponents() {
jPanel1 = new javax.swing.JPanel();
jLabel1 = new javax.swing.JLabel();
tfA = new javax.swing.JTextField();
sldA = new javax.swing.JSlider();
tfB = new javax.swing.JTextField();
sldB = new javax.swing.JSlider();
tfC = new javax.swing.JTextField();
sldC = new javax.swing.JSlider();
tfD = new javax.swing.JTextField();
sldD = new javax.swing.JSlider();
tfE = new javax.swing.JTextField();
sldE = new javax.swing.JSlider();
41
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
tfF = new javax.swing.JTextField();
sldF = new javax.swing.JSlider();
tfG = new javax.swing.JTextField();
sldG = new javax.swing.JSlider();
tfH = new javax.swing.JTextField();
sldH = new javax.swing.JSlider();
tfTempoDelay = new javax.swing.JTextField();
tfDelayMax = new javax.swing.JTextField();
tfPortaSerial = new javax.swing.JTextField();
btSalvar = new javax.swing.JButton();
btCancelar = new javax.swing.JButton();
tfLogin = new javax.swing.JTextField();
pfSenha = new javax.swing.JPasswordField();
tfArquivo = new javax.swing.JTextField();
getContentPane().setLayout(new java.awt.GridLayout(1, 0));
setTitle("Configura\u00e7\u00e3o");
setResizable(false);
jPanel1.setLayout(null);
jPanel1.setPreferredSize(new java.awt.Dimension(490, 300));
jPanel2.setLayout(new java.awt.GridLayout(8, 3));
jPanel2.setBorder(new
javax.swing.border.TitledBorder("Inicializa\u00e7\u00e3o"));
jLabel1.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
jLabel1.setText("Motor A: ");
jPanel2.add(jLabel1);
tfA.setEditable(false);
tfA.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfA.setText("64");
jPanel2.add(tfA);
sldA.setMaximum(130);
sldA.setMinimum(1);
sldA.setValue(64);
sldA.addChangeListener(new javax.swing.event.ChangeListener() {
public void stateChanged(javax.swing.event.ChangeEvent evt) {
sldAStateChanged(evt);
}
});
jPanel2.add(sldA);
42
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
jLabel2.setText("Motor B: ");
tfB.setEditable(false);
tfB.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfB.setText("64");
jPanel2.add(tfB);
sldB.setMaximum(130);
sldB.setMinimum(1);
sldB.setValue(64);
sldB.addChangeListener(new javax.swing.event.ChangeListener() {
sldBStateChanged(evt);
}
});
jPanel2.add(sldB);
jLabel3.setText(" Motor C: ");
tfC.setEditable(false);
tfC.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfC.setText("64");
jPanel2.add(tfC);
sldC.setMaximum(130);
sldC.setMinimum(1);
sldC.setValue(64);
sldC.addChangeListener(new javax.swing.event.ChangeListener() {
sldCStateChanged(evt);
}
});
jPanel2.add(sldC);
jLabel4.setText("Motor D: ");
tfD.setEditable(false);
tfD.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfD.setText("64");
jPanel2.add(tfD);
sldD.setMaximum(130);
sldD.setMinimum(1);
sldD.setValue(64);
sldD.addChangeListener(new javax.swing.event.ChangeListener() {
sldDStateChanged(evt);
}
});
jPanel2.add(sldD);
43
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
jLabel5.setText("Motor E: ");
tfE.setEditable(false);
tfE.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfE.setText("64");
jPanel2.add(tfE);
sldE.setMaximum(130);
sldE.setMinimum(1);
sldE.setValue(64);
sldE.addChangeListener(new javax.swing.event.ChangeListener() {
sldEStateChanged(evt);
}
});
jPanel2.add(sldE);
jLabel6.setText("Motor F: ");
tfF.setEditable(false);
tfF.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfF.setText("64");
jPanel2.add(tfF);
sldF.setMaximum(130);
sldF.setMinimum(1);
sldF.setValue(64);
sldF.addChangeListener(new javax.swing.event.ChangeListener() {
sldFStateChanged(evt);
}
});
jPanel2.add(sldF);
jLabel7.setText("Motor G: ");
tfG.setEditable(false);
tfG.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfG.setText("64");
jPanel2.add(tfG);
sldG.setMaximum(130);
sldG.setMinimum(1);
sldG.setValue(64);
sldG.addChangeListener(new javax.swing.event.ChangeListener() {
sldGStateChanged(evt);
}
});
44
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
jPanel2.add(sldG);
jLabel8.setText("Motor H: ");
tfH.setEditable(false);
tfH.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfH.setText("64");
jPanel2.add(tfH);
sldH.setMaximum(130);
sldH.setMinimum(1);
sldH.setValue(64);
sldH.addChangeListener(new javax.swing.event.ChangeListener() {
sldHStateChanged(evt);
}
});
jPanel2.add(sldH);
jPanel1.add(jPanel2);
jPanel2.setBounds(10, 10, 235, 280);
javax.swing.border.TitledBorder("Par\u00e2metros"));
jLabel9.setText("Tempo de Delay: ");
tfTempoDelay.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfTempoDelay.setText("500");
jPanel3.add(tfTempoDelay);
tfDelayMax.setBackground(java.awt.SystemColor.control);
tfDelayMax.setEditable(false);
tfDelayMax.setForeground(java.awt.SystemColor.control);
tfDelayMax.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfDelayMax.setText("750");
jPanel3.add(tfDelayMax);
jLabel11.setText(" ");
tfPortaSerial.setBackground(java.awt.SystemColor.control);
tfPortaSerial.setEditable(false);
tfPortaSerial.setForeground(java.awt.SystemColor.control);
tfPortaSerial.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfPortaSerial.setText("COM1");
45
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
jPanel3.add(tfPortaSerial);
btSalvar.setText("Salvar");
btSalvar.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
btSalvarActionPerformed(evt);
}
});
jPanel1.add(btSalvar);
btSalvar.setBounds(250, 255, 110, 30);
btCancelar.setText("Cancelar");
btCancelar.addActionListener(new java.awt.event.ActionListener() {
btCancelarActionPerformed(evt);
}
});
jPanel1.add(btCancelar);
btCancelar.setBounds(370, 255, 110, 30);
jPanel4.setBorder(new javax.swing.border.TitledBorder("Banco de
Dados"));
jLabel14.setText("Login: ");
tfLogin.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfLogin.setText("sysdba");
jPanel4.add(tfLogin);
jLabel15.setText("Senha: ");
pfSenha.setHorizontalAlignment(javax.swing.JTextField.CENTER);
pfSenha.setText("masterkey");
jPanel4.add(pfSenha);
jLabel12.setText("Arquivo: ");
tfArquivo.setHorizontalAlignment(javax.swing.JTextField.CENTER);
jPanel4.add(tfArquivo);
getContentPane().add(jPanel1);
pack();
46
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
}
// </editor-fold>
private void sldHStateChanged(javax.swing.event.ChangeEvent evt) {
tfH.setText(sldH.getValue() + "");
}
private void sldGStateChanged(javax.swing.event.ChangeEvent evt) {
tfG.setText(sldG.getValue() + "");
}
private void sldFStateChanged(javax.swing.event.ChangeEvent evt) {
tfF.setText(sldF.getValue() + "");
}
private void sldEStateChanged(javax.swing.event.ChangeEvent evt) {
tfE.setText(sldE.getValue() + "");
}
private void sldDStateChanged(javax.swing.event.ChangeEvent evt) {
tfD.setText(sldD.getValue() + "");
}
private void sldCStateChanged(javax.swing.event.ChangeEvent evt) {
tfC.setText(sldC.getValue() + "");
}
private void sldBStateChanged(javax.swing.event.ChangeEvent evt) {
tfB.setText(sldB.getValue() + "");
}
private void sldAStateChanged(javax.swing.event.ChangeEvent evt) {
tfA.setText(sldA.getValue() + "");
}
private void btCancelarActionPerformed(java.awt.event.ActionEvent evt) {
this.setVisible(false);
}
private void btSalvarActionPerformed(java.awt.event.ActionEvent evt) {
Parametros pa = salvarParametros();
nucleo.setParametros(pa);
nucleo.salvarParametros();
}
// Variables declaration - do not modify
private javax.swing.JButton btCancelar;
private javax.swing.JButton btSalvar;
private javax.swing.JLabel jLabel1;
47
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485 }
private javax.swing.JPanel jPanel1;
private javax.swing.JPasswordField pfSenha;
private javax.swing.JSlider sldA;
private javax.swing.JSlider sldB;
private javax.swing.JSlider sldC;
private javax.swing.JSlider sldD;
private javax.swing.JSlider sldE;
private javax.swing.JSlider sldF;
private javax.swing.JSlider sldG;
private javax.swing.JSlider sldH;
private javax.swing.JTextField tfA;
private javax.swing.JTextField tfArquivo;
private javax.swing.JTextField tfB;
private javax.swing.JTextField tfC;
private javax.swing.JTextField tfD;
private javax.swing.JTextField tfDelayMax;
private javax.swing.JTextField tfE;
private javax.swing.JTextField tfF;
private javax.swing.JTextField tfG;
private javax.swing.JTextField tfH;
private javax.swing.JTextField tfLogin;
private javax.swing.JTextField tfPortaSerial;
private javax.swing.JTextField tfTempoDelay;
// End of variables declaration
Principal.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*
* Principal.java
*/
import
import
import
import
import
import
ar.nucleo.*;
ar.interacao.*;
java.util.Vector;
ar.informacao.*;
java.io.File;
ar.controle.SerialCMDE;
/**
*
*/
public class Principal extends javax.swing.JFrame {
private Config config;
48
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
private Vector<String> vExecucao;
public Principal() {
initComponents();
vExecucao = new Vector<String>();
nucleo = new Nucleo(jtxtLog, lstNSA, lstProcessados);
config = new Config(nucleo);
//posição inicial
nucleo.msg("Posição inicial...");
ValorMotores vm = nucleo.getParametros().getIni();
Motor motor;
int valor;
valor = vm.a;
motor = new Motor("A", valor, 0);
cmd.n.adicionar(motor);
valor = vm.b;
motor = new Motor("B", valor, 0);
valor = vm.c;
motor = new Motor("C", valor, 0);
cmd.s.adicionar(motor);
valor = vm.d;
motor = new Motor("D", valor, 0);
valor = vm.e;
motor = new Motor("E", valor, 0);
cmd.l.adicionar(motor);
valor = vm.f;
motor = new Motor("F", valor, 0);
valor = vm.g;
motor = new Motor("G", valor, 0);
cmd.o.adicionar(motor);
valor = vm.h;
motor = new Motor("H", valor, 0);
nucleo.visualizar(cmd);
nucleo.atualizarNSA();
nucleo.msg("ARc Iniciado.");
}
49
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
*/
jScrollPane1 = new javax.swing.JScrollPane();
lstNSA = new javax.swing.JList();
btNPA = new javax.swing.JButton();
btNSA = new javax.swing.JButton();
tfNSA = new javax.swing.JTextField();
btProcessar = new javax.swing.JButton();
jButton4 = new javax.swing.JButton();
btLimpar = new javax.swing.JButton();
btSair = new javax.swing.JButton();
jtxtLog = new javax.swing.JTextArea();
lstProcessados = new javax.swing.JList();
btExcluir = new javax.swing.JButton();
btAdicionar = new javax.swing.JButton();
btRemover = new javax.swing.JButton();
btExecutar = new javax.swing.JButton();
lstExecucao = new javax.swing.JList();
setDefaultCloseOperation(javax.swing.WindowConstants.DO_NOTHING_ON_CLOSE);
setTitle("ARc - Sistema de Controle do AR+");
setName("Principal");
jPanel1.setBackground(new java.awt.Color(255, 255, 255));
jPanel2.setBorder(new javax.swing.border.EtchedBorder());
jScrollPane1.setBackground(new java.awt.Color(255, 255, 255));
jScrollPane1.setBorder(new javax.swing.border.EmptyBorder(new
java.awt.Insets(1, 1, 1, 1)));
lstNSA.setBorder(new javax.swing.border.TitledBorder("NSAs"));
lstNSA.addListSelectionListener(new
javax.swing.event.ListSelectionListener() {
public void valueChanged(javax.swing.event.ListSelectionEvent
evt) {
50
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
lstNSAValueChanged(evt);
});
}
jScrollPane1.setViewportView(lstNSA);
jPanel2.add(jScrollPane1);
btNPA.setText("NPA");
btNPA.addActionListener(new java.awt.event.ActionListener() {
btNPAActionPerformed(evt);
}
});
jPanel4.add(btNPA);
btNSA.setText("NSA");
btNSA.addActionListener(new java.awt.event.ActionListener() {
btNSAActionPerformed(evt);
}
});
jPanel4.add(btNSA);
tfNSA.setEditable(false);
tfNSA.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfNSA.setText("Selecione um NSA");
jPanel5.add(tfNSA);
btProcessar.setText("Processar");
btProcessar.addActionListener(new java.awt.event.ActionListener() {
btProcessarActionPerformed(evt);
}
});
jPanel5.add(btProcessar);
jButton4.setText("Configura\u00e7\u00f5es");
jButton4.addActionListener(new java.awt.event.ActionListener() {
jButton4ActionPerformed(evt);
}
});
51
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
jPanel5.add(jButton4);
jPanel6.setLayout(new java.awt.BorderLayout());
btLimpar.setText("Limpar");
btLimpar.addActionListener(new java.awt.event.ActionListener() {
btLimparActionPerformed(evt);
}
});
jPanel7.add(btLimpar);
btSair.setText("Sair");
btSair.addActionListener(new java.awt.event.ActionListener() {
btSairActionPerformed(evt);
}
});
jPanel7.add(btSair);
jPanel6.add(jPanel7, java.awt.BorderLayout.EAST);
jtxtLog.setEditable(false);
jtxtLog.setText("LOG de execu\u00e7\u00e3o.");
jScrollPane2.setViewportView(jtxtLog);
jPanel6.add(jScrollPane2, java.awt.BorderLayout.CENTER);
lstProcessados.setBorder(new javax.swing.border.TitledBorder("NSAs
Processados"));
52
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
jScrollPane3.setViewportView(lstProcessados);
btExcluir.setText("Excluir");
btExcluir.addActionListener(new java.awt.event.ActionListener() {
btExcluirActionPerformed(evt);
}
});
jPanel10.add(btExcluir);
btAdicionar.setText("Adicionar");
btAdicionar.addActionListener(new java.awt.event.ActionListener() {
btAdicionarActionPerformed(evt);
}
});
jPanel10.add(btAdicionar);
btRemover.setText("Remover");
btRemover.addActionListener(new java.awt.event.ActionListener() {
btRemoverActionPerformed(evt);
}
});
jPanel10.add(btRemover);
btExecutar.setText("Executar");
btExecutar.addActionListener(new java.awt.event.ActionListener() {
btExecutarActionPerformed(evt);
}
});
jPanel10.add(btExecutar);
lstExecucao.setBorder(new javax.swing.border.TitledBorder("Lista de
Execu\u00e7\u00e3o"));
jScrollPane4.setViewportView(lstExecucao);
53
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
pack();
}
// </editor-fold>
private void btExecutarActionPerformed(java.awt.event.ActionEvent evt) {
if(vExecucao.size() > 0){
FilaComandoEscalonado fcmde = new FilaComandoEscalonado();
ComandoEscalonado cmde = null;
String id;
File file;
SerialCMDE scmde = new SerialCMDE();
int cont = vExecucao.size();
for(int i=0;i<cont;i++){ //percorrer itens para executar
id = (String) vExecucao.get(i);
}
//consultar nsap
if(nucleo.getControleBD().consultaNSAProcessado(id) == true){
//deserializar cmde
cmde = scmde.deSerializar(id);
if(cmde != null){
fcmde.adicionar(cmde);
}
}
nucleo.transmitir(fcmde);
}
}
vExecucao.clear();
lstExecucao.setListData(vExecucao);
private void btRemoverActionPerformed(java.awt.event.ActionEvent evt) {
if(lstExecucao.getSelectedValue() != null){
vExecucao.remove(lstExecucao.getSelectedValue());
}
}
private void btAdicionarActionPerformed(java.awt.event.ActionEvent evt) {
if(lstProcessados.getSelectedValue() != null){
vExecucao.add((String) lstProcessados.getSelectedValue());
}
}
private void btExcluirActionPerformed(java.awt.event.ActionEvent evt) {
if(lstProcessados.getSelectedValue() != null){
String id = (String) lstProcessados.getSelectedValue();
54
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
nucleo.getControleBD().excluirNSAProcessado(id);
lstProcessados.setListData(nucleo.getControleBD().listaNSAProcessado());
}
}
private void btNPAActionPerformed(java.awt.event.ActionEvent evt) {
nucleo.getTelaNPA().limpar();
nucleo.getTelaNPA().setVisible(true);
}
private void lstNSAValueChanged(javax.swing.event.ListSelectionEvent
evt) {
tfNSA.setText((String) lstNSA.getSelectedValue());
}
private void btNSAActionPerformed(java.awt.event.ActionEvent evt) {
Vector<String> v = nucleo.getControleBD().listaNSA();
nucleo.getTelaNSA().listarNSA(v);
v = nucleo.getControleBD().listaNPA();
nucleo.getTelaNSA().listarNPA(v);
nucleo.getTelaNSA().atualizarListas();
nucleo.getTelaNSA().setVisible(true);
}
private void jButton4ActionPerformed(java.awt.event.ActionEvent evt) {
config.carregarParametros();
config.setVisible(true);
}
private void btSairActionPerformed(java.awt.event.ActionEvent evt) {
System.exit(0);
}
private void btLimparActionPerformed(java.awt.event.ActionEvent evt) {
nucleo.limparLog();
}
private void btProcessarActionPerformed(java.awt.event.ActionEvent evt) {
String tmp = (String) lstNSA.getSelectedValue();
if(tmp != null){
nucleo.executarNSA(tmp);
}
}
private javax.swing.JButton btAdicionar;
private javax.swing.JButton btExcluir;
private javax.swing.JButton btExecutar;
private javax.swing.JButton btLimpar;
private javax.swing.JButton btNPA;
private javax.swing.JButton btNSA;
private javax.swing.JButton btProcessar;
private javax.swing.JButton btRemover;
private javax.swing.JButton btSair;
private javax.swing.JButton jButton4;
55
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438 }
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTextArea jtxtLog;
private javax.swing.JList lstExecucao;
private javax.swing.JList lstNSA;
private javax.swing.JList lstProcessados;
private javax.swing.JTextField tfNSA;
Splash.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/*
* Splash.java
*/
/**
*
*/
public class Splash extends javax.swing.JFrame {
/**
*
*/
public Splash() {
initComponents();
}
*/
lblA = new javax.swing.JLabel();
56
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87 }
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setTitle("ARc Beta 1");
setAlwaysOnTop(true);
setCursor(new java.awt.Cursor(java.awt.Cursor.WAIT_CURSOR));
setLocationByPlatform(true);
setName("Inicio");
setUndecorated(true);
javax.swing.border.BevelBorder(javax.swing.border.BevelBorder.RAISED));
lblA.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
lblA.setText("Iniciando...");
jPanel2.add(lblA);
jLabel2.setBackground(new java.awt.Color(255, 255, 255));
jLabel2.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
jLabel2.setIcon(new
javax.swing.ImageIcon(getClass().getResource("/ar/interacao/logo.jpg")));
jLabel2.setBounds(10, 10, 280, 130);
pack();
}
// </editor-fold>
/**
*
*/
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Splash().setVisible(true);
}
});
}
private javax.swing.JLabel lblA;
57
TalaAguarde.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
/*
* TelaAguarde.java
*/
/**
*
*/
public class TelaAguarde extends javax.swing.JFrame {
/**
*
*/
public TelaAguarde() {
initComponents();
}
*/
setTitle("Aguarde");
setAlwaysOnTop(true);
setFocusableWindowState(false);
setFont(new java.awt.Font("Agency FB", 0, 10));
setLocationByPlatform(true);
setName("Aguarde");
setUndecorated(true);
jPanel1.setBorder(new javax.swing.border.LineBorder(new
java.awt.Color(255, 0, 0), 2));
jLabel1.setFont(new java.awt.Font("Microsoft Sans Serif", 1, 12));
jLabel1.setForeground(new java.awt.Color(255, 51, 0));
jLabel1.setText("AGUARDE...");
jLabel1.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
pack();
}
58
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76 }
// </editor-fold>
/**
*
*/
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new TelaAguarde().setVisible(true);
}
});
}
TelaNPA.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/*
* TelaNPA.java
*/
import
import
import
import
import
ar.informacao.*;
ar.informacao.NPA;
java.util.Vector;
ar.nucleo.*;
ar.controle.bd.*;
/**
*
*/
public class TelaNPA extends javax.swing.JFrame {
private
private
private
private
FilaMotor n, s, l, o;
Vector<Motor> a, b, c, d, e, f, g, h;
Nucleo nucleo;
Parametros p;
public TelaNPA(Nucleo nu) {
initComponents();
nucleo = nu;
p = nu.getParametros();
carregarMotores();
//incializar
n = new FilaMotor("N");
s = new FilaMotor("S");
59
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
l = new FilaMotor("L");
o = new FilaMotor("O");
}
a
b
c
d
e
f
g
h
=
=
=
=
=
=
=
=
new
new
new
new
new
new
new
new
Vector<Motor>();
Vector<Motor>();
Vector<Motor>();
Vector<Motor>();
Vector<Motor>();
Vector<Motor>();
Vector<Motor>();
Vector<Motor>();
private void carregarMotores(){
ValorMotores vm;
//carrear motores
vm = p.getIni();
tfNA.setText("" + vm.a);
sldNA.setValue(vm.a);
tfNB.setText("" + vm.b);
sldNB.setValue(vm.b);
tfSA.setText("" + vm.c);
sldSA.setValue(vm.c);
tfSB.setText("" + vm.d);
sldSB.setValue(vm.d);
tfLA.setText("" + vm.e);
sldLA.setValue(vm.e);
tfLB.setText("" + vm.f);
sldLB.setValue(vm.f);
tfOA.setText("" + vm.g);
sldOA.setValue(vm.g);
}
tfOB.setText("" + vm.h);
sldOB.setValue(vm.h);
*/
sldNA = new javax.swing.JSlider();
tfNA = new javax.swing.JTextField();
sldSA = new javax.swing.JSlider();
60
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
tfSA = new javax.swing.JTextField();
sldLA = new javax.swing.JSlider();
tfLA = new javax.swing.JTextField();
sldOA = new javax.swing.JSlider();
tfOA = new javax.swing.JTextField();
sldNB = new javax.swing.JSlider();
tfNB = new javax.swing.JTextField();
sldSB = new javax.swing.JSlider();
tfSB = new javax.swing.JTextField();
sldLB = new javax.swing.JSlider();
tfLB = new javax.swing.JTextField();
sldOB = new javax.swing.JSlider();
tfOB = new javax.swing.JTextField();
btAdd = new javax.swing.JButton();
btResetar = new javax.swing.JButton();
btVisualizar = new javax.swing.JButton();
btEditar = new javax.swing.JButton();
btLimpar = new javax.swing.JButton();
btRemover = new javax.swing.JButton();
jlstA = new javax.swing.JList();
jlstB = new javax.swing.JList();
jlstC = new javax.swing.JList();
jlstD = new javax.swing.JList();
jlstE = new javax.swing.JList();
jlstF = new javax.swing.JList();
jlstG = new javax.swing.JList();
61
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
jlstH = new javax.swing.JList();
tfNome = new javax.swing.JTextField();
btSalvar = new javax.swing.JButton();
btCancelar = new javax.swing.JButton();
setTitle("Edi\u00e7\u00e3o de NPA");
setName("NPA");
javax.swing.border.SoftBevelBorder(javax.swing.border.BevelBorder.RAISED)
);
172
173
174
175
176
sldNA.setMajorTickSpacing(10);
177
sldNA.setMaximum(130);
178
sldNA.setMinimum(1);
179
sldNA.setMinorTickSpacing(1);
180
sldNA.setOrientation(javax.swing.JSlider.VERTICAL);
181
sldNA.setValue(64);
182
sldNA.addChangeListener(new javax.swing.event.ChangeListener() {
183
184
sldNAStateChanged(evt);
185
}
186
});
187
188
jPanel1.add(sldNA);
189
190
191
192
193
jLabel12.setText("A");
194
jLabel12.setVerticalAlignment(javax.swing.SwingConstants.BOTTOM);
195
196
197
tfNA.setEditable(false);
198
tfNA.setHorizontalAlignment(javax.swing.JTextField.CENTER);
199
tfNA.setText("64");
200
tfNA.setDisabledTextColor(new java.awt.Color(0, 0, 0));
201
jPanel7.add(tfNA);
202
203
204
62
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
sldSA.setMajorTickSpacing(10);
sldSA.setMaximum(130);
sldSA.setMinimum(1);
sldSA.setMinorTickSpacing(1);
sldSA.setOrientation(javax.swing.JSlider.VERTICAL);
sldSA.setValue(64);
sldSA.addChangeListener(new javax.swing.event.ChangeListener() {
sldSAStateChanged(evt);
}
});
jPanel1.add(sldSA);
jLabel10.setText("C");
tfSA.setEditable(false);
tfSA.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfSA.setText("64");
tfSA.setDisabledTextColor(new java.awt.Color(0, 0, 0));
jPanel8.add(tfSA);
sldLA.setMajorTickSpacing(10);
sldLA.setMaximum(130);
sldLA.setMinimum(1);
sldLA.setMinorTickSpacing(1);
sldLA.setOrientation(javax.swing.JSlider.VERTICAL);
sldLA.setValue(64);
sldLA.addChangeListener(new javax.swing.event.ChangeListener() {
sldLAStateChanged(evt);
}
});
jPanel1.add(sldLA);
jLabel8.setText("E");
tfLA.setEditable(false);
tfLA.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfLA.setText("64");
tfLA.setDisabledTextColor(new java.awt.Color(0, 0, 0));
jPanel9.add(tfLA);
63
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
sldOA.setMajorTickSpacing(10);
sldOA.setMaximum(130);
sldOA.setMinimum(1);
sldOA.setMinorTickSpacing(1);
sldOA.setOrientation(javax.swing.JSlider.VERTICAL);
sldOA.setValue(64);
sldOA.addChangeListener(new javax.swing.event.ChangeListener() {
sldOAStateChanged(evt);
}
});
jPanel1.add(sldOA);
jLabel7.setText("G");
tfOA.setEditable(false);
tfOA.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfOA.setText("64");
tfOA.setDisabledTextColor(new java.awt.Color(0, 0, 0));
jPanel10.add(tfOA);
sldNB.setMajorTickSpacing(10);
sldNB.setMaximum(130);
sldNB.setMinimum(1);
sldNB.setMinorTickSpacing(1);
sldNB.setOrientation(javax.swing.JSlider.VERTICAL);
sldNB.setValue(64);
sldNB.addChangeListener(new javax.swing.event.ChangeListener() {
sldNBStateChanged(evt);
}
});
jPanel1.add(sldNB);
jLabel13.setText("B");
tfNB.setEditable(false);
tfNB.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfNB.setText("64");
tfNB.setDisabledTextColor(new java.awt.Color(0, 0, 0));
jPanel11.add(tfNB);
64
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
sldSB.setMajorTickSpacing(10);
sldSB.setMaximum(130);
sldSB.setMinimum(1);
sldSB.setMinorTickSpacing(1);
sldSB.setOrientation(javax.swing.JSlider.VERTICAL);
sldSB.setValue(64);
sldSB.addChangeListener(new javax.swing.event.ChangeListener() {
sldSBStateChanged(evt);
}
});
jPanel1.add(sldSB);
jLabel11.setText("D");
tfSB.setEditable(false);
tfSB.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfSB.setText("64");
tfSB.setDisabledTextColor(new java.awt.Color(0, 0, 0));
jPanel12.add(tfSB);
sldLB.setMajorTickSpacing(10);
sldLB.setMaximum(130);
sldLB.setMinimum(1);
sldLB.setMinorTickSpacing(1);
sldLB.setOrientation(javax.swing.JSlider.VERTICAL);
sldLB.setValue(64);
sldLB.addChangeListener(new javax.swing.event.ChangeListener() {
sldLBStateChanged(evt);
}
});
jPanel1.add(sldLB);
jLabel9.setText("F");
tfLB.setEditable(false);
tfLB.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfLB.setText("64");
tfLB.setDisabledTextColor(new java.awt.Color(0, 0, 0));
jPanel13.add(tfLB);
65
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
sldOB.setMajorTickSpacing(10);
sldOB.setMaximum(130);
sldOB.setMinimum(1);
sldOB.setMinorTickSpacing(1);
sldOB.setOrientation(javax.swing.JSlider.VERTICAL);
sldOB.setValue(64);
sldOB.addChangeListener(new javax.swing.event.ChangeListener() {
sldOBStateChanged(evt);
}
});
jPanel1.add(sldOB);
jLabel6.setText("H");
tfOB.setEditable(false);
tfOB.setHorizontalAlignment(javax.swing.JTextField.CENTER);
tfOB.setText("64");
tfOB.setDisabledTextColor(new java.awt.Color(0, 0, 0));
jPanel14.add(tfOB);
btAdd.setText("ADD");
btAdd.addActionListener(new java.awt.event.ActionListener() {
btAddActionPerformed(evt);
}
});
jPanel3.add(btAdd);
btResetar.setText("Resetar");
btResetar.addActionListener(new java.awt.event.ActionListener() {
btResetarActionPerformed(evt);
}
});
jPanel3.add(btResetar);
btVisualizar.setText("Visualizar");
btVisualizar.setToolTipText("Visualiza a posi\u00e7\u00e3o atual
no rob\u00f4");
434
btVisualizar.addActionListener(new java.awt.event.ActionListener() {
435
66
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
btVisualizarActionPerformed(evt);
});
}
jPanel3.add(btVisualizar);
btEditar.setText("Editar");
btEditar.setToolTipText("Salva os valores atuais no item
selecionado");
btEditar.addActionListener(new java.awt.event.ActionListener() {
btEditarActionPerformed(evt);
}
});
jPanel3.add(btEditar);
btLimpar.setText("Limpar");
btLimpar.addActionListener(new java.awt.event.ActionListener() {
}
});
jPanel3.add(btLimpar);
btRemover.setText("Remover");
btRemover.addActionListener(new java.awt.event.ActionListener() {
btRemoverActionPerformed(evt);
}
});
jPanel3.add(btRemover);
jLabel14.setText("Motor A: ");
jlstA.addKeyListener(new java.awt.event.KeyAdapter() {
public void keyPressed(java.awt.event.KeyEvent evt) {
jlstAKeyTyped(evt);
}
public void keyTyped(java.awt.event.KeyEvent evt) {
jlstAKeyTyped(evt);
}
});
jlstA.addListSelectionListener(new
489
evt) {
490
jlstAValueChanged(evt);
67
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
}
});
jlstA.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
jlstAMouseClicked(evt);
}
});
jScrollPane1.setViewportView(jlstA);
jLabel15.setText("Motor B: ");
jlstB.addKeyListener(new java.awt.event.KeyAdapter() {
jlstAKeyTyped(evt);
}
jlstAKeyTyped(evt);
}
});
jlstB.addListSelectionListener(new
evt) {
}
});
jlstB.addMouseListener(new java.awt.event.MouseAdapter() {
}
});
jScrollPane2.setViewportView(jlstB);
jLabel16.setText("Motor C: ");
jlstC.addKeyListener(new java.awt.event.KeyAdapter() {
jlstAKeyTyped(evt);
}
jlstAKeyTyped(evt);
}
});
jlstC.addListSelectionListener(new
543
evt) {
544
68
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
}
});
jlstC.addMouseListener(new java.awt.event.MouseAdapter() {
}
});
jScrollPane3.setViewportView(jlstC);
jLabel17.setText("Motor D: ");
jlstD.addKeyListener(new java.awt.event.KeyAdapter() {
jlstAKeyTyped(evt);
}
jlstAKeyTyped(evt);
}
});
jlstD.addListSelectionListener(new
evt) {
}
});
jlstD.addMouseListener(new java.awt.event.MouseAdapter() {
}
});
jScrollPane4.setViewportView(jlstD);
jLabel18.setText("Motor E: ");
jlstE.addKeyListener(new java.awt.event.KeyAdapter() {
jlstAKeyTyped(evt);
}
jlstAKeyTyped(evt);
}
});
jlstE.addListSelectionListener(new
597
evt) {
598
69
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
}
});
jlstE.addMouseListener(new java.awt.event.MouseAdapter() {
}
});
jScrollPane5.setViewportView(jlstE);
jLabel19.setText("Motor F: ");
jlstF.addKeyListener(new java.awt.event.KeyAdapter() {
jlstAKeyTyped(evt);
}
jlstAKeyTyped(evt);
}
});
jlstF.addListSelectionListener(new
evt) {
}
});
jlstF.addMouseListener(new java.awt.event.MouseAdapter() {
}
});
jScrollPane6.setViewportView(jlstF);
jLabel20.setText("Motor G: ");
jlstG.addKeyListener(new java.awt.event.KeyAdapter() {
jlstAKeyTyped(evt);
}
});
jlstG.addListSelectionListener(new
evt) {
}
});
jlstG.addMouseListener(new java.awt.event.MouseAdapter() {
70
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
});
}
jScrollPane7.setViewportView(jlstG);
jLabel21.setText("Motor H: ");
jlstH.addKeyListener(new java.awt.event.KeyAdapter() {
jlstAKeyTyped(evt);
}
jlstAKeyTyped(evt);
}
});
jlstH.addListSelectionListener(new
evt) {
}
});
jlstH.addMouseListener(new java.awt.event.MouseAdapter() {
}
});
jScrollPane8.setViewportView(jlstH);
jLabel1.setText("Nome do NSA:");
jLabel1.setHorizontalTextPosition(javax.swing.SwingConstants.RIGHT);
jLabel1.setBounds(10, 10, 90, 15);
jPanel5.add(tfNome);
tfNome.setBounds(100, 10, 180, 19);
btSalvar.setText("Salvar");
btSalvar.addActionListener(new java.awt.event.ActionListener() {
btSalvarActionPerformed(evt);
}
});
71
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
jPanel5.add(btSalvar);
btSalvar.setBounds(300, 10, 95, 23);
btCancelar.setText("Cancelar");
btCancelar.addActionListener(new java.awt.event.ActionListener() {
}
});
jPanel5.add(btCancelar);
btCancelar.setBounds(410, 10, 100, 23);
18));
jLabel2.setFont(new java.awt.Font("Microsoft Sans Serif", 1,
jLabel2.setText("N");
18));
jLabel3.setText("S");
18));
jLabel4.setText("L");
18));
jLabel5.setText("O");
pack();
}
// </editor-fold>
{
private void jlstAValueChanged(javax.swing.event.ListSelectionEvent evt)
}
selecionar((javax.swing.JList) evt.getSource());
72
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
private void btRemoverActionPerformed(java.awt.event.ActionEvent evt) {
//remove itens selecionados
if(jlstA.getSelectedValue() != null){
int valor, i;
i = jlstA.getSelectedIndex();
a.remove(i);
b.remove(i);
c.remove(i);
d.remove(i);
e.remove(i);
f.remove(i);
g.remove(i);
h.remove(i);
carregarListas();
}
}
private void btEditarActionPerformed(java.awt.event.ActionEvent evt) {
//salva a sequencia exibida
if(jlstA.getSelectedValue() != null){
Motor motor;
int valor, i;
i = jlstA.getSelectedIndex();
jlstA.setSelectedIndex(i);
jlstB.setSelectedIndex(i);
jlstC.setSelectedIndex(i);
jlstD.setSelectedIndex(i);
jlstE.setSelectedIndex(i);
jlstF.setSelectedIndex(i);
jlstG.setSelectedIndex(i);
jlstH.setSelectedIndex(i);
//Motores nas listas
valor = sldNA.getValue();
a.set(i, motor);
valor = sldNB.getValue();
b.set(i, motor);
//motores da fila S - C e D
valor = sldSA.getValue();
c.set(i, motor);
valor = sldSB.getValue();
d.set(i, motor);
//motores da fila L - E e F
valor = sldLA.getValue();
73
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
e.set(i, motor);
valor = sldLB.getValue();
f.set(i, motor);
//motores da fila O - G e H
valor = sldOA.getValue();
g.set(i, motor);
valor = sldOB.getValue();
h.set(i, motor);
//carregar vectors nas listas
carregarListas();
}
}
public void limpar(){
btLimparActionPerformed(null);
btResetarActionPerformed(null);
}
private void btCancelarActionPerformed(java.awt.event.ActionEvent evt) {
//limpar e ocultar
btResetarActionPerformed(evt);
}
private void btSalvarActionPerformed(java.awt.event.ActionEvent evt) {
//criar NPA e enviar para o nucleo
boolean confirmacao = true;
if((a.size()) != 0 && !(tfNome.getText().equals(""))){
Comando cmd = gerarComando();
NPA npa = new NPA(tfNome.getText(), cmd);
//verificar a existência do NPA no bd
NPA tmp = nucleo.getControleBD().consultaNPA(tfNome.getText());
if(tmp == null){ //não existe
confirmacao = true;
}else{//existe, solicitar confirmação
}
if(confirmacao == true){
//solicitar alteração/cadastro do NSA no BD
nucleo.getControleBD().updateNPA(npa);
}
//zerar e ocultar
}
74
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
}
private Comando gerarComando(){
//motores das jlist para o comando
Motor m;
int cont = a.size();
for(int i=0; i<cont;i++){
m = (Motor) jlstA.getSelectedValue();
cmd.n.adicionar(m);
m = (Motor) jlstB.getSelectedValue();
cmd.n.adicionar(m);
m = (Motor) jlstC.getSelectedValue();
cmd.s.adicionar(m);
m = (Motor) jlstD.getSelectedValue();
cmd.s.adicionar(m);
m = (Motor) jlstE.getSelectedValue();
cmd.l.adicionar(m);
m = (Motor) jlstF.getSelectedValue();
cmd.l.adicionar(m);
m = (Motor) jlstG.getSelectedValue();
cmd.o.adicionar(m);
m = (Motor) jlstH.getSelectedValue();
cmd.o.adicionar(m);
}
}
return cmd;
private void jlstAKeyTyped(java.awt.event.KeyEvent evt) {
}
private void jlstAMouseClicked(java.awt.event.MouseEvent evt) {
}
private void btLimparActionPerformed(java.awt.event.ActionEvent evt) {
//LIMPAR
a.clear();
b.clear();
c.clear();
d.clear();
75
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
e.clear();
f.clear();
g.clear();
h.clear();
carregarListas();
}
tfNome.setText("");
public void visualizar(){
btVisualizarActionPerformed(null);
}
private void btVisualizarActionPerformed(java.awt.event.ActionEvent evt) {
//solicita ao nucleo que envie as posições atuais dos motores
ao robo
953
//as posições indicadas pelos Slides Control
954
955
nucleo.msg("Visualizar posição:");
956
957
//gerar comando
958
959
Motor motor;
960
int valor;
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
76
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
}
nucleo.visualizar(cmd);
private void btResetarActionPerformed(java.awt.event.ActionEvent evt) {
//ajustar controle para a posição inicial
carregarMotores();
}
private void btAddActionPerformed(java.awt.event.ActionEvent evt) {
//criar motores com valores dos slides e adicionar nos Vectors
//carregar vectors nas filas
Motor motor;
int valor;
a.add(motor);
b.add(motor);
c.add(motor);
d.add(motor);
e.add(motor);
f.add(motor);
g.add(motor);
h.add(motor);
//carregar vectors nas listas
carregarListas();
77
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
}
private void carregarListas(){
jlstA.setListData(a);
jlstB.setListData(b);
jlstC.setListData(c);
jlstD.setListData(d);
jlstE.setListData(e);
jlstF.setListData(f);
jlstG.setListData(g);
jlstH.setListData(h);
}
private void sldOBStateChanged(javax.swing.event.ChangeEvent evt) {
tfOB.setText("" + sldOB.getValue());
}
private void sldOAStateChanged(javax.swing.event.ChangeEvent evt) {
tfOA.setText("" + sldOA.getValue());
}
private void sldLBStateChanged(javax.swing.event.ChangeEvent evt) {
tfLB.setText("" + sldLB.getValue());
}
private void sldLAStateChanged(javax.swing.event.ChangeEvent evt) {
tfLA.setText("" + sldLA.getValue());
}
private void sldSBStateChanged(javax.swing.event.ChangeEvent evt) {
tfSB.setText("" + sldSB.getValue());
}
private void sldSAStateChanged(javax.swing.event.ChangeEvent evt) {
tfSA.setText("" + sldSA.getValue());
}
private void sldNBStateChanged(javax.swing.event.ChangeEvent evt) {
tfNB.setText("" + sldNB.getValue());
}
private void sldNAStateChanged(javax.swing.event.ChangeEvent evt) {
tfNA.setText("" + sldNA.getValue());
}
private javax.swing.JButton btAdd;
private javax.swing.JButton btCancelar;
private javax.swing.JButton btEditar;
private javax.swing.JButton btLimpar;
private javax.swing.JButton btRemover;
private javax.swing.JButton btResetar;
private javax.swing.JButton btSalvar;
private javax.swing.JButton btVisualizar;
78
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
private
javax.swing.JLabel jLabel13;
javax.swing.JPanel jPanel1;
javax.swing.JScrollPane jScrollPane1;
javax.swing.JList jlstA;
javax.swing.JList jlstB;
javax.swing.JList jlstC;
javax.swing.JList jlstD;
javax.swing.JList jlstE;
javax.swing.JList jlstF;
javax.swing.JList jlstG;
javax.swing.JList jlstH;
javax.swing.JSlider sldLA;
javax.swing.JSlider sldLB;
javax.swing.JSlider sldNA;
javax.swing.JSlider sldNB;
javax.swing.JSlider sldOA;
javax.swing.JSlider sldOB;
javax.swing.JSlider sldSA;
javax.swing.JSlider sldSB;
javax.swing.JTextField tfLA;
79
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
private javax.swing.JTextField tfLB;
private javax.swing.JTextField tfNA;
private javax.swing.JTextField tfNB;
private javax.swing.JTextField tfNome;
private javax.swing.JTextField tfOA;
private javax.swing.JTextField tfOB;
private javax.swing.JTextField tfSA;
private javax.swing.JTextField tfSB;
private void selecionar(javax.swing.JList lista){
if(lista.getSelectedValue() != null){
int i = lista.getSelectedIndex();
//aplicar as lista o index
Motor m;
m = (Motor) jlstA.getSelectedValue();
sldNA.setValue(m.getValor());
m = (Motor) jlstB.getSelectedValue();
sldNB.setValue(m.getValor());
m = (Motor) jlstC.getSelectedValue();
sldSA.setValue(m.getValor());
m = (Motor) jlstD.getSelectedValue();
sldSB.setValue(m.getValor());
m = (Motor) jlstE.getSelectedValue();
sldLA.setValue(m.getValor());
m = (Motor) jlstF.getSelectedValue();
sldLB.setValue(m.getValor());
m = (Motor) jlstG.getSelectedValue();
sldOA.setValue(m.getValor());
}
}
m = (Motor) jlstH.getSelectedValue();
sldOB.setValue(m.getValor());
public void desmontarComando(Comando cmd){
int cont = cmd.n.getElementos();
//limpar vectors
a.clear();
b.clear();
c.clear();
80
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279 }
d.clear();
e.clear();
f.clear();
g.clear();
h.clear();
//carregar motores
Motor m;
for(int i=0;i<cont;i++){
//motor A
a.add(m);
//motor B
b.add(m);
//motor C
c.add(m);
//motor D
d.add(m);
//motor E
e.add(m);
//motor F
f.add(m);
//motor G
g.add(m);
}
}
//motor H
h.add(m);
public void editar(NPA item){
limpar();
tfNome.setText(item.getId());
desmontarComando(item.getCmd());
carregarListas();
setVisible(true);
}
public void novo(){
limpar();
setVisible(true);
}
81
TelaNSA.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/*
* TelaNSA.java
*/
import
import
import
import
import
import
ar.controle.bd.ValidadorNSA;
ar.informacao.*;
ar.informacao.NPA;
ar.informacao.NSA;
java.util.Vector;
ar.nucleo.*;
/**
*
*/
public class TelaNSA extends javax.swing.JFrame {
private Vector<BDListaElemento> novoNsa;
/**
*
*/
public TelaNSA(Nucleo n) {
nucleo = n;
initComponents();
novoNsa = new Vector<BDListaElemento>();
}
*/
lstNPA = new javax.swing.JList();
btAddNPA = new javax.swing.JButton();
btEditarNPA = new javax.swing.JButton();
btNovoNPA = new javax.swing.JButton();
btExcluirNPA = new javax.swing.JButton();
lstNovoNSA = new javax.swing.JList();
btExcluirItem = new javax.swing.JButton();
tfNomeNovoNSA = new javax.swing.JTextField();
btSalvarNovoNSA = new javax.swing.JButton();
btCancelarNovoNSA = new javax.swing.JButton();
btAddNSA = new javax.swing.JScrollPane();
lstNSA = new javax.swing.JList();
82
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
jButton8 = new javax.swing.JButton();
btEditarNSA = new javax.swing.JButton();
btNovoNSA = new javax.swing.JButton();
btExcluirNSA = new javax.swing.JButton();
setTitle("Edi\u00e7\u00e3o de NSA");
setName("NSA");
jPanel2.setBorder(new javax.swing.border.TitledBorder("NPAs"));
jScrollPane1.setViewportView(lstNPA);
btAddNPA.setText("ADD >");
btAddNPA.addActionListener(new java.awt.event.ActionListener() {
btAddNPAActionPerformed(evt);
}
});
jPanel3.add(btAddNPA);
btEditarNPA.setText("Editar");
btEditarNPA.addActionListener(new java.awt.event.ActionListener() {
btEditarNPAActionPerformed(evt);
}
});
jPanel3.add(btEditarNPA);
btNovoNPA.setText("Novo");
btNovoNPA.addActionListener(new java.awt.event.ActionListener() {
btNovoNPAActionPerformed(evt);
}
});
jPanel3.add(btNovoNPA);
btExcluirNPA.setText("Excluir");
btExcluirNPA.addActionListener(new java.awt.event.ActionListener() {
btExcluirNPAActionPerformed(evt);
}
});
jPanel3.add(btExcluirNPA);
83
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
jPanel4.setBorder(new javax.swing.border.TitledBorder(null, "Novo
NSA", javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION,
javax.swing.border.TitledBorder.DEFAULT_POSITION, new
java.awt.Font("Microsoft Sans Serif", 0, 11), java.awt.Color.red));
jScrollPane2.setViewportView(lstNovoNSA);
btExcluirItem.setText("Excluir");
btExcluirItem.addActionListener(new java.awt.event.ActionListener() {
btExcluirItemActionPerformed(evt);
}
});
jPanel5.add(btExcluirItem);
jPanel5.add(tfNomeNovoNSA);
{
btSalvarNovoNSA.setText("Salvar");
btSalvarNovoNSA.addActionListener(new java.awt.event.ActionListener()
});
btSalvarNovoNSAActionPerformed(evt);
}
jPanel5.add(btSalvarNovoNSA);
btCancelarNovoNSA.setText("Cancelar");
btCancelarNovoNSA.addActionListener(new
java.awt.event.ActionListener() {
btCancelarNovoNSAActionPerformed(evt);
}
});
jPanel5.add(btCancelarNovoNSA);
jPanel6.setBorder(new javax.swing.border.TitledBorder("NSAs"));
btAddNSA.setViewportView(lstNSA);
84
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
jPanel6.add(btAddNSA);
jButton8.setText("< ADD");
jButton8.addActionListener(new java.awt.event.ActionListener() {
jButton8ActionPerformed(evt);
}
});
jPanel7.add(jButton8);
btEditarNSA.setText("Editar");
btEditarNSA.addActionListener(new java.awt.event.ActionListener() {
btEditarNSAActionPerformed(evt);
}
});
jPanel7.add(btEditarNSA);
btNovoNSA.setText("Novo");
btNovoNSA.addActionListener(new java.awt.event.ActionListener() {
btNovoNSAActionPerformed(evt);
}
});
jPanel7.add(btNovoNSA);
btExcluirNSA.setText("Excluir");
btExcluirNSA.addActionListener(new java.awt.event.ActionListener() {
btExcluirNSAActionPerformed(evt);
}
});
jPanel7.add(btExcluirNSA);
pack();
}
// </editor-fold>
private void btEditarNSAActionPerformed(java.awt.event.ActionEvent evt) {
if(lstNSA.getSelectedValue() != null){
String id = (String) lstNSA.getSelectedValue();
NSA tmp = nucleo.getControleBD().consultaNSA(id);
if(tmp != null){
//listar
85
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
tfNomeNovoNSA.setText(tmp.getId());
novoNsa = tmp.getLista();
atualizarListas();
}
}
}
private void btExcluirNSAActionPerformed(java.awt.event.ActionEvent evt) {
if(lstNSA.getSelectedValue() != null){
//confirmar antes de excluir
String id = (String) lstNSA.getSelectedValue();
nucleo.getControleBD().excluirNSA(id);
atualizarListas();
}
}
private void btNovoNSAActionPerformed(java.awt.event.ActionEvent evt) {
novoNsa.clear();
tfNomeNovoNSA.setText("");
listarNovoNSA();
}
private void btCancelarNovoNSAActionPerformed(java.awt.event.ActionEvent
evt) {
novoNsa.clear();
listarNovoNSA();
setVisible(false);
}
private void btSalvarNovoNSAActionPerformed(java.awt.event.ActionEvent
evt) {
boolean confirmacao = true;
if(novoNsa.size() > 0 && !tfNomeNovoNSA.getText().equals("")){
String nomeNovoNsa = tfNomeNovoNSA.getText();
Vector<String> vtmp = new Vector<String>();
vtmp.add(nomeNovoNsa);
vtmp);
ValidadorNSA vNsa = new ValidadorNSA(nucleo, nomeNovoNsa,
if(vNsa.validar() == true){ //NSA é válido
NSA novo = new NSA(nomeNovoNsa, novoNsa);
//verificar se existe NSA com mesmo nome
NSA tmp = nucleo.getControleBD().consultaNSA(nomeNovoNsa);
if(tmp != null){ //NSA existe, solicitar confirmação
confirmacao = true;
}
if(confirmacao == true){
nucleo.getControleBD().updateNSA(novo);
}
novoNsa.clear();
listarNovoNSA();
atualizarListas();
86
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
}
}
}else{
nucleo.msg("O NSA criado não é válido!");
}
private void btExcluirNPAActionPerformed(java.awt.event.ActionEvent evt) {
String nome = (String) lstNPA.getSelectedValue();
if(nome != null){
//confirmação de exclusão
nucleo.getControleBD().excluirNPA(nome);
Vector<String> v = nucleo.getControleBD().listaNPA();
listarNPA(v);
}
}
private void btNovoNPAActionPerformed(java.awt.event.ActionEvent evt) {
nucleo.getTelaNPA().novo();
}
private void btExcluirItemActionPerformed(java.awt.event.ActionEvent evt) {
BDListaElemento bde = (BDListaElemento)
lstNovoNSA.getSelectedValue();
if(bde != null){
novoNsa.remove(bde);
listarNovoNSA();
}
}
private void jButton8ActionPerformed(java.awt.event.ActionEvent evt) {
String nome = (String) lstNSA.getSelectedValue();
if(nome != null) addNovo(nome, "NSA");
}
private void btAddNPAActionPerformed(java.awt.event.ActionEvent evt) {
if(nome != null) addNovo(nome, "NPA");
}
private void btEditarNPAActionPerformed(java.awt.event.ActionEvent evt) {
if(lstNPA.getSelectedValue() == null){
//novo NPA
nucleo.getTelaNPA().novo();
}else{
//editar NPA
if(nome != null){
NPA tmp = nucleo.getControleBD().consultaNPA(nome);
if(tmp != null){
nucleo.getTelaNPA().editar(tmp);
}
}
}
}
87
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388 }
private javax.swing.JButton btAddNPA;
private javax.swing.JScrollPane btAddNSA;
private javax.swing.JButton btCancelarNovoNSA;
private javax.swing.JButton btEditarNPA;
private javax.swing.JButton btEditarNSA;
private javax.swing.JButton btExcluirItem;
private javax.swing.JButton btExcluirNPA;
private javax.swing.JButton btExcluirNSA;
private javax.swing.JButton btNovoNPA;
private javax.swing.JButton btNovoNSA;
private javax.swing.JButton btSalvarNovoNSA;
private javax.swing.JButton jButton8;
private javax.swing.JList lstNPA;
private javax.swing.JList lstNSA;
private javax.swing.JList lstNovoNSA;
private javax.swing.JTextField tfNomeNovoNSA;
public void atualizarListas(){
listarNPA(nucleo.getControleBD().listaNPA());
listarNSA(nucleo.getControleBD().listaNSA());
listarNovoNSA();
}
public void listarNPA(Vector<String> v){
lstNPA.setListData(v);
}
public void listarNSA(Vector<String> v){
lstNSA.setListData(v);
}
private void listarNovoNSA(){ lstNovoNSA.setListData(novoNsa); }
private void addNovo(String id, String tipo){
BDListaElemento bde = new BDListaElemento(id, tipo);
novoNsa.add(bde);
listarNovoNSA();
}
88
PACOTE: ae.nucleo
Nucleo.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
/*
* Nucleo.java
*/
package ar.nucleo;
import
import
import
import
import
import
import
import
import
import
import
import
import
ar.informacao.*;
ar.informacao.NPA;
ar.informacao.NSA;
ar.interacao.*;
ar.nucleo.*;
java.io.*;
javax.swing.JList;
javax.swing.JTextArea;
java.util.Vector;
java.sql.*; //ResultSet
java.util.Properties;
ar.controle.*;
ar.controle.bd.*;
/**
*
*/
public class Nucleo {
private Transm transm;
private Escalonador esc;
private
private
private
private
ControleDelay cdelay; //= new ControleDelay(this);
Conexao conexao;
ControleBD cbd;
TelaAguarde telaA;
private TelaNPA npa;
private TelaNSA nsa;
private String nsaExecucao;
//==== COMANDOS
============================================================
/**
*
*/
public void visualizar(Comando cmd){
if(cmd != null){
limparLog();
String tmp = "Vis:" + cmd.getElementos();
FilaComando fcmd = new FilaComando();
FilaComandoEscalonado fcmde = new FilaComandoEscalonado();
89
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
fcmd.adicionar(cmd); //adiciona cmd a uma fila
escalonada
msg("Controle de Delay...");
cdelay.setEntrada(fcmd);
cdelay.ajustarDelay();
msg("Escalonador...");
esc.setEntrada(cdelay.getSaida()); //prepara fila para ser
esc.escalonar("VIS", false); //escalona fila
fcmde.adicionar(esc.getSaida());
transm.setEntrada(fcmde); //prepara fila escalonada para ser
transmitida
msg("Transmissor:");
transm.transmitir(); //transmite fila
}
}
public void executarNPA(NPA item){
FilaComando fc = new FilaComando();
msg("Executando NPA: " + item.getId());
Comando cmd = item.getCmd();
if(cmd.getElementos() == 0){
msg("Não há elementos no NPA para executar.");
}else{
fc.adicionar(cmd);
preparar(fc);
}
}
public void executarNSA(String id){
//obter nsa
NSA item = cbd.consultaNSA(id);
if(item != null){
//desmontar NSA
FilaComando fila = new FilaComando();
Vector<String> lista = new Vector<String>();
lista.add(id);
DesmontadorNSA dnsa = new DesmontadorNSA(this, id, lista,
fila);
if(dnsa.desmontar() == false){
msg("Desmontando NSA.", "Falha ao desmontar.");
}
}
}
nsaExecucao = id;
preparar(fila);
lstProcessados.setListData(cbd.listaNSAProcessado());
/**
*
*/
public void preparar(FilaComando fila){
telaA.setVisible(true);
if(fila != null){
limparLog();
90
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
cdelay.setEntrada(fila);
cdelay.ajustarDelay(); //calcular delay necessario
esc.setEntrada(cdelay.getSaida());
esc.escalonar(nsaExecucao, true);
}
}
telaA.setVisible(false);
public void transmitir(FilaComandoEscalonado f){
transm.setEntrada(f);
transm.transmitir();
}
//====ARQUIVO DE
PARÂMETROS=================================================
private Parametros parametros;
public Parametros getParametros(){
return parametros;
}
public void setParametros(Parametros p){
parametros = p;
}
private String arquivo = "parametros.properties";
public void carregarParametros(){
parametros = new Parametros(this);
java.io.FileInputStream entrada = null;
Properties prop = new Properties();
java.io.File file = new java.io.File(arquivo);
try{
entrada = new java.io.FileInputStream(file);
try{
prop.load(entrada);
parametros.setProperties(prop);
}catch(java.io.IOException e){
msg("Lendo arquivo de parâmetros.", e.toString());
}
}catch(java.io.FileNotFoundException e){
msg("Abrindo arquivo de parâmetros.", e.toString());
}
}
public void salvarParametros(){
Properties prop = parametros.getProperties();
if(prop != null){
java.io.FileOutputStream saida = null;
91
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
java.io.File file = new java.io.File(arquivo);
try{
saida = new java.io.FileOutputStream(file);
try{
prop.store(saida, "parametros");
msg("Parâmetros salvos.");
}catch(java.io.IOException e){
msg("Gravando arquivo de parâmetros.", e.toString());
}
}catch(FileNotFoundException e){
msg("Salvando arquivo de parâmetros.", e.toString());
}
}
}
//====LOG=============================================================
======
//mensagem de saida para a tela principal
private JTextArea jtxt;
public void msg(String m){
if(jtxt != null){
jtxt.append("\n" + m);
logVerFim();
}
}
public void msg(String m, String erro){
if(jtxt != null){
jtxt.append("\n\n ### ERRO: ###\n" + m + "\n >" + erro
+"\n#############");
logVerFim();
}
}
public void msg(String m, boolean noLinha){
if(jtxt != null){
jtxt.append(m);
logVerFim();
}
}
public JTextArea getJtxt(){ return jtxt; }
public void setJtxt(JTextArea jt){
jtxt = jt;
jtxt.setText("LOG.");
}
private void logVerFim(){
if(jtxt != null){
jtxt.select(jtxt.getText().length(), jtxt.getText().length());
}
}
public void limparLog(){
jtxt.setText("");
92
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
}
//====BANCO DE
DADOS========================================================
public Conexao getConexao(){
return conexao;
}
public ControleBD getControleBD(){ return cbd; }
//====ACESSO AS
TELAS=======================================================
private JList lstPrincipal, lstProcessados;
private Vector<String> vPrincipal, vProcessados;
public TelaNPA getTelaNPA(){ return npa; }
public TelaNSA getTelaNSA(){ return nsa; }
public void atualizarNSA(){
nsa.atualizarListas();
vPrincipal = cbd.listaNSA();
vProcessados = cbd.listaNSAProcessado();
lstPrincipal.setListData(vPrincipal);
lstProcessados.setListData(vProcessados);
}
//====CONSTRUTOR======================================================
======
/**
*
*/
public Nucleo(JTextArea jta, JList lst, JList lst2) {
vPrincipal = new Vector<String>();
lstPrincipal = lst;
lstProcessados = lst2;
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273 }
setJtxt(jta);
//abrir e carregar parametros
msg("Carregando parâmetros...");
carregarParametros();
esc = new Escalonador(this);
cdelay = new ControleDelay(this);
transm = new Transm(this);
conexao = new Conexao(this);
conexao.conectar();
cbd = new ControleBD(this, conexao);
npa = new TelaNPA(this);
nsa = new TelaNSA(this);
}
telaA = new TelaAguarde();
93
Parâmetros.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/*
* Parametros.java
*/
package ar.nucleo;
import ar.informacao.ValorMotores;
/**
*
*/
public class Parametros {
Nucleo nucleo;
//====INICIALIZAÇÃO DOS
MOTORES=============================================
private ValorMotores valorMotores;
public void setIni(ValorMotores vm){
valorMotores = vm;
}
public ValorMotores getIni(){
return valorMotores;
}
//====AJUSTES=========================================================
======
private int delayMax, tempoDelay;
private String portaSerial;
public void setDelayMax(int dm){
delayMax = dm;
}
public int getDelayMax(){
return delayMax;
}
public void setTempoDelay(int td){
tempoDelay = td;
}
public int getTempoDelay(){
return tempoDelay;
}
public String getPortaSerial(){
return portaSerial;
}
public void setPortaSerial(String ps){
portaSerial = ps;
}
94
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
//====BANCO DE
DADOS========================================================
private String login, senha, arquivo;
public void setLogin(String l){
login = l;
}
public String getLogin(){
return login;
}
public void setSenha(String s){
senha = s;
}
public String getSenha(){
return senha;
}
public void setArquivo(String arq){
arquivo = arq;
}
public String getArquivo(){
return arquivo;
}
//====VALORES
PADRÃO========================================================
private void valorPadrao(){
int valPadrao = 64;
valorMotores = new ValorMotores(valPadrao);
tempoDelay = 500;
delayMax = 750;
login = "sysdba";
senha = "masterkey";
}
portaSerial = "COM1";
//====PROPERTIES======================================================
======
private java.util.Properties prop;
public java.util.Properties getProperties(){
prop = new java.util.Properties();
prop.setProperty("motorA",
prop.setProperty("motorB",
prop.setProperty("motorC",
prop.setProperty("motorD",
prop.setProperty("motorE",
prop.setProperty("motorF",
""
""
""
""
""
""
+
+
+
+
+
+
valorMotores.a);
valorMotores.b);
valorMotores.c);
valorMotores.d);
valorMotores.e);
valorMotores.f);
95
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
prop.setProperty("motorG", "" + valorMotores.g);
prop.setProperty("motorH", "" + valorMotores.h);
prop.setProperty("delayMax", "" + delayMax);
prop.setProperty("tempoDelay", "" + tempoDelay);
prop.setProperty("login", login);
prop.setProperty("senha", senha);
prop.setProperty("arquivo", arquivo);
prop.setProperty("portaSerial", portaSerial);
}
return prop;
public void setProperties(java.util.Properties p){
boolean flag = true;
String v;
if(p != null){
v = p.getProperty("motorA");
if(v != null){
valorMotores.a = Integer.parseInt(v);
}else{
flag = false;
}
v = p.getProperty("motorB");
if(v != null){
valorMotores.b = Integer.parseInt(v);
}else{
flag = false;
}
v = p.getProperty("motorC");
if(v != null){
valorMotores.c = Integer.parseInt(v);
}else{
flag = false;
}
v = p.getProperty("motorD");
if(v != null){
valorMotores.d = Integer.parseInt(v);
}else{
flag = false;
}
v = p.getProperty("motorE");
if(v != null){
valorMotores.e = Integer.parseInt(v);
}else{
flag = false;
}
v = p.getProperty("motorF");
if(v != null){
valorMotores.f = Integer.parseInt(v);
96
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
}else{
flag = false;
}
v = p.getProperty("motorG");
if(v != null){
valorMotores.g = Integer.parseInt(v);
}else{
flag = false;
}
v = p.getProperty("motorH");
if(v != null){
valorMotores.h = Integer.parseInt(v);
}else{
flag = false;
}
v = p.getProperty("delayMax");
if(v != null){
delayMax = Integer.parseInt(v);
}else{
flag = false;
}
v = p.getProperty("tempoDelay");
if(v != null){
tempoDelay = Integer.parseInt(v);
}else{
flag = false;
}
v = p.getProperty("login");
if(v != null){
login = v;
}else{
flag = false;
}
v = p.getProperty("senha");
if(v != null){
senha = v;
}else{
flag = false;
}
v = p.getProperty("arquivo");
if(v != null){
arquivo = v;
}else{
flag = false;
}
v = p.getProperty("portaSerial");
if(v != null){
portaSerial = v;
}else{
flag = false;
97
226
227
228
229
230
231
232
233
}
}else{
flag = false;
}
if(flag == false){//falha no carregamento dos parametros
nucleo.msg("Inicializar parâmetros.", "Valor padrão
atribuído.");
valorPadrao(); //assume padrao
}
}
234
235
236
237
238
239
240
241
242
243
244
245 }
/**
*
*/
public Parametros(Nucleo n) {
nucleo = n;
valorPadrao();
}
98
PACOTE: ar
Main.java
1 /*
2 * Main.java
3 */
4
5 package ar;
6
7 import ar.interacao.*;
8 /**
9 *
11 */
12 public class Main {
13
14
/**
15
*
16
*/
17
public static void main(String[] args) {
18
System.out.println("ARc - Sistema de Controle do AR+");
19
20
Splash splash;
21
splash = new Splash();
22
splash.setVisible(true);
23
24
//form principal
25
Principal p = new Principal();
26
p.setVisible(true);
27
28
splash.setVisible(false);
29
splash = null;
30
}
31 }

Visualizar - Polis Educacional

Transcrição

Documentos relacionados

Apostila - Mais que Música

Aplicações Desktop: Swing/SubMacroForms

TREINAMENTO COM KETTLEBELL E LEVANTAMENTO DE PESO

InclusÃ£o do estilo "West Coast Swing" nas atividades do

Informação

Houve um problema com o certificado digital do nosso

Vídeo captura utilizando Java e DirectX Introdução

Equipamed é parceira das mães Produtos dão suporte ao

Aula 8 - GUI - Colégio Agrícola de Frederico Westphalen

Núcleo Desenvolvimento