View/Open - Instituto Politécnico Nacional

INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA
DEPARTAMENTO DE INGENIERÍA EN CONTROL Y AUTOMATIZACIÓN
UNIDAD PROFESIONAL ADOLFO LÓPEZ MATEOS
INTERFAZ GRÁFICA EN JAVA COMO RECURSO
DIDÁCTICO PARA LA ASIGNATURA DE TEORÍA DE
CONTROL II
T E S I S
QUE PARA OBTENER EL TÍTULO DE
INGENIERO EN CONTROL Y AUTOMATIZACIÓN
PRESENTA
JOSÉ FRANCISCO REYES SALDAÑA
D I R E C T O R E S:
DRA. MARTHA LETICIA GARCÍA RODRÍGUEZ
M. en C. GUILIBALDO TOLENTINO ESLAVA
MÉXICO, D.F.
NOVIEMBRE 2012
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELECTRICA
UNIDAD PROFESIONAL "ADOLFO LÓPEZ MATEOS"
TEMA DE TESIS
QUE PARA OBTENER EL TITULO DE
INGENIERO EN CONTROL Y AUTOMATIZACION
POR LA OPCIÓN DE TITULACIÓN
PROYECTO DE INVESTIGACIÓN SIP20111060
DEBERA(N) DESARROLLAR
C. JOSÉ FRANCISCO REYES SALDAÑA
"INTERFAZ GRÁFICA EN JAVA COMÓ RECURSO DIDÁCTICO PARA LA ASIGNATURA DE
TEORÍA DE CONTROL 11"
.
.
DISEÑAR UNA INTERFAZ GRÁFICA DE USUARIO (IGU) UTILIZANDO EL LENGUAJE DE PROGRAMACIÓN JAVA
COMO APOYO PARA EL APRENDIZAJE DEL DISEÑO DE COMPENSADORES PROPORCIONAL DERIVATIVO (PD)
QUE ES UN TEMA DE LA ASIGNATURA DE TEORÍA DEL CONTOL 11.
.:. ANALIZAR EL CONTENIDO MATEMÁ nco IMPLICITO EN EL MÉTODO DEL LGR Y EL DISEÑO DE UN
COMPENSADOR PD EN LA ASIGNATURA DE TEORÍA DEL CONTROL 11.
•:. CREAR EL MODELO DE SOFTWARE DE LA INTERFAZ GRÁFICA DE USUARIO Y SU METODOLOGÍA.
•:. DISEÑAR EL CÓDIGO DE PROGRAMACIÓN BASADO EN EL MODELO DE SOFTWARE DE LA INTERFAZ
GRÁFICA DE USUARIO.
v..,lT.Y'rvr"lr/DEPARTAME
ACADÉMIQ{JI>J)EA le A
I1WÉl'j1(EkÍA EN CONTROL Y AUTOMATIZACIÓN
AGRADECIMIENTOS
A mis Padres, por la sabia enseñanza de que en la vida no existen límites para el ser
humano más que los que el mismo se impone.
A Francisco, mi Padre, por su esfuerzo y sacrificio personal en interés de mi bienestar
y formación humana y académica, por el apoyo incondicional y sincero en cada
momento de mi vida, por la enseñanza de valores que han enriquecido mi persona.
A Cristina, mi Madre, por su dedicación y atención a lo largo de la vida, por su
perseverancia en función de mi bienestar y formación humana y académica.
A Ricardo, mi Hermano, por su compañía durante la infancia, por su comprensión
durante la adolescencia y por su amistad incondicional.
A María de los Ángeles, mi Abuela, por su apoyo incondicional durante los últimos
años, por su dedicación y esfuerzo a procurar mi bienestar y por sus consejos.
A la Dra. Martha Leticia García Rodríguez, mi asesora, por compartir su experiencia
profesional en el ámbito de la Investigación y la Innovación Educativa en el IPN, por
su dedicación y atención a la elaboración del presente trabajo, por compartir sus
conocimientos científicos y su perseverancia en aras de la formación de profesionistas
con ética en la ESIME.
Al M. en C. Guilibaldo Tolentino Eslava, mi asesor, por su ayuda en la revisión y
consejos que dieron forma al presente trabajo de tesis, por su dedicación a la docencia
en el IPN y a la formación de profesionistas con ética en la ESIME.
A la ESIME y sus Maestros por abrirme las puertas del camino al conocimiento y por
haberme compartido la experiencia profesional.
Al IPN por brindarme una educación y una formación profesional de calidad desde el
momento en que se me dio la oportunidad de formar parte de la comunidad Politécnica.
A ORACLE y Sun MicroSystems, por facilitar la plataforma de desarrollo NetBeans
para la programación en lenguaje Java, y la documentación necesaria para el uso de la
misma plataforma y la implementación de software bajo los estándares de Java SE.
2
Índice
RESUMEN ................................................................................................................................................. 4
INTRODUCCIÓN ...................................................................................................................................... 5
CAPÍTULO 1. TEORÍA DE CONTROL II Y SUS ELEMENTOS MATEMÁTICOS ........................... 9
1.1.
TEORÍA DE CONTROL II................................................................................................................... 9
1.1.1.
Sistemas de Control.................................................................................................................. 9
1.1.2.
El Lugar Geométrico de las Raíces ....................................................................................... 13
1.1.3.
Diseño de Compensadores PD por el Lugar Geométrico de las Raíces ............................... 15
1.2.
ELEMENTOS MATEMÁTICOS IMPLÍCITOS EN LA TEORÍA DE CONTROL II. .................................. 15
1.2.1.
El Lugar Geométrico de las Raíces ....................................................................................... 16
1.2.2.
Ecuaciones Diferenciales Ordinarias ................................................................................... 17
1.2.3.
Transformada de Laplace ...................................................................................................... 19
CAPÍTULO 2. TEORÍA DE INTERFACES GRÁFICAS DE USUARIO .............................................. 22
2.1.
INTERFACES GRÁFICAS DE USUARIO ............................................................................................. 22
2.1.1.
Consideraciones Técnicas de las Interfaces Gráficas de Usuario ........................................ 23
2.1.2.
El Pensamiento de la Interfaz Gráfica de Usuario .............................................................. 24
2.1.3.
Manejo de Eventos con la Biblioteca AWT de la Versión Estándar de Java ...................... 25
2.2.
PROGRAMACIÓN Y DESARROLLO DE INTERFACES GRÁFICAS DE USUARIO EN JAVA .................. 27
2.2.1.
Herramientas Widgets de la Biblioteca Swing ...................................................................... 27
2.2.2.
Descripción del Lenguaje Java.............................................................................................. 30
2.2.3.
Desarrollo de Applets ............................................................................................................. 35
CAPÍTULO 3. DISEÑO DE LA INTERFAZ GRÁFICA DE USUARIO .............................................. 39
3.1.
INGENIERÍA DE SOFTWARE ............................................................................................................ 39
3.1.1.
Diagramas de Lenguaje Unificado de Modelado .................................................................. 41
3.1.2.
Proceso de Desarrollo del Software ....................................................................................... 46
3.2.
MODELO SEMIFORMAL PARA EL DESARROLLO DE SOFTWARE EDUCATIVO (MSDSE).............. 47
3.3.
DISEÑO DE LA INTERFAZ GRÁFICA DE USUARIO COMO APPLETS DE JAVA (DIGUAJ) .......... 50
CAPÍTULO 4. APLICACIÓN DE LA METODOLOGÍA (DIGUAJ) .................................................... 53
4.1.
4.2.
4.3.
4.4.
ARQUITECTURA DEL SOFTWARE PARA LA INTERFAZ GRÁFICA DE USUARIO ............................. 53
MODELO DE DESARROLLO DE LA INTERFAZ GRÁFICA DE USUARIO ........................................... 54
FASE DE OPERACIÓN ...................................................................................................................... 64
EJECUCIÓN DE LA APLICACIÓN..................................................................................................... 70
CONCLUSIONES .................................................................................................................................... 77
RECOMENDACIONES .......................................................................................................................... 79
REFERENCIAS ....................................................................................................................................... 80
APÉNDICE A. CÓDIGO DE PROGRAMACIÓN DE LA CLASE FRAME_COMPENSADORPD
DEL PAQUETE MENUCOMPENSADORPD........................................................................................ 82
3
Resumen
Se diseñó una Interfaz Gráfica de Usuario (IGU) utilizando el lenguaje de
programación Java como apoyo para el aprendizaje del diseño de compensadores
Proporcional Derivativo (PD) que es un tema de la asignatura de Teoría del Control II.
En el trabajo se justifica que la IGU puede ser un recurso didáctico que contribuya para
el aprendizaje del Método del Lugar Geométrico de las Raíces.
Se propuso una metodología para el Diseño de la Interfaz Gráfica de Usuario como
Applet de Java (DIGUAJ) que consta de tres etapas, 1ª) Arquitectura del Software 2ª)
Modelo de Desarrollo del Software 3ª) Fase de Operación. La metodología se basa en
los estándares de la Ingeniería de Software (IS) [17, 31] y en un Modelo Semi-formal
para el Desarrollo de Software Educativo (MSDSE) [22].
Utilizando el EDI NetBeans se desarrolló la programación de la IGU con las
características que provee la tecnología Applet de Java, por mencionar algunas:
robustez, portabilidad y compatibilidad que recaen en las ventajas que ofrecen las
Tecnologías de la Información y la Comunicación. La IGU que se obtuvo puede
hacerse accesible desde internet usando la tecnología Java para la creación de páginas
web con programación en servidor (Java Server Pages ó JSP por sus siglas en inglés).
Finalmente se hace un corrimiento de la IGU del cual se puede concluir que se llevó a
cabo con éxito la obtención del método a analítico, la solución numérica del diseño de
un compensador Proporcional Derivativo (PD) y la obtención de la gráfica del Lugar
Geométrico de las Raíces (LGR) para la Función de Transferencia (FT) del sistema que
se propone para el corrimiento.
4
Introducción
La asignatura de Teoría de Control II es una parte esencial de la formación académica
de los alumnos de la carrera de Ingeniería en Control y Automatización de la Escuela
Superior de Ingeniería Mecánica y Eléctrica Unidad Zacatenco del Instituto Politécnico
Nacional. Esta asignatura se ubica en el sexto semestre de la carrera y requiere los
elementos teóricos de las asignaturas Ecuaciones Diferenciales, Modelado de Sistemas
y Teoría de Control 1 que se imparten en semestres anteriores.
El estudio de la asignatura presenta dificultad en su aprendizaje como se puede inferir
de las estadísticas de 2009 y 2010 solicitadas al departamento de control escolar. En
2009 el número de reprobados en el segundo semestre del año fue de 77 alumnos de los
cuales, después de la segunda ronda del Examen a Título de Suficiencia (E.T.S.), 35%
aprobaron y 65% continuaron con la asignatura reprobada; en el primer semestre del
año 2010 el número de reprobados fue de 90 alumnos de los cuales, después de la
segunda ronda del E.T.S., 42% aprobaron y 58% continuaron adeudando la asignatura.
El programa de la asignatura de Teoría de Control II se estructura en cinco unidades:
1. Método del Lugar Geométrico de las Raíces
2. Compensación de Sistemas de Control
3. Efectos No-lineales de los Sistemas Físicos.
4. Método de la Función Descriptiva.
5. Método del Plano de Fase.
Considerando que las dos primeras unidades son una base del diseño de
compensadores para los sistemas de control, los cuales sirven para mejorar la respuesta
de los sistemas.
El conocimiento del Método del Lugar Geométrico de las Raíces y Compensación de
Sistemas de Control significa, más que llegar a la solución de problemas de diseño de
compensadores en forma numérica, se trata de entender los procedimientos
5
matemáticos implícitos y la relación que existe entre las soluciones numéricas, los
recursos gráficos y el método analítico.
Es claro que las dificultades en el aprendizaje de los temas expuestos son diversas y en
ellas influyen factores sociales, económicos y académicos, no es posible incidir en
todos estos ámbitos al mismo tiempo, pero si en los académicos.
Una forma de incurrir en los problemas académicos es mediante la incorporación de
herramientas didácticas al salón de clases y en la primera década de este siglo se ha
incrementado la incorporación de las Tecnologías de la Información y la
Comunicación (TIC) en la vida diaria de las personas.
El uso de las TIC hace más eficiente y disminuye el tiempo en la organización de
información, permite el ahorro de espacio; en particular el internet brinda acceso
inmediato a una gran cantidad de información sin importar la distancia. El uso de
herramientas proporcionadas por las TIC como son la computadora y el internet es
cada vez más frecuente en actividades administrativas, industriales, comerciales y
académicas, siendo éste último, el ámbito en el que se desarrolla este trabajo.
Las herramientas proporcionadas por las TIC son diversas y una de éstas son los
Applets de Java que debido a algunas de las ventajas que como TIC ofrece y que serán
mencionadas más adelante, se ha considerado que pueden brindar un recurso didáctico
que puede contribuir a una mejor comprensión de las unidades 1 y 2 de la asignatura de
Teoría del Control II, recurso que por el momento no se ha elaborado para los alumnos
de la carrera de Ingeniería en Control y Automatización (ICA).
Algunas ventajas de las TIC son:
1) Capacidad de visualización de gráficos computarizados.
2) Acceso a todo tipo de información y contenidos desde diferentes partes del
mundo.
6
3) Comunicación inmediata entre diferentes personas o instituciones.
El objetivo de este trabajo fue diseñar una Interfaz Gráfica de Usuario (IGU) utilizando
el lenguaje de programación Java como apoyo para el aprendizaje del diseño de
compensadores Proporcional Derivativo (PD) en la asignatura de Teoría del Control II.
Para alcanzar el objetivo de la tesis, ésta se encuentra integrada por 4 capítulos.
En el Capítulo 1 se describen los elementos de la teoría de control que son utilizados
para el diseño de Compensadores PD mediante el método del Lugar Geométrico de las
Raíces, así como los elementos matemáticos de la Teoría de Control Clásico que son
empleados en el método analítico de la solución de Compensadores PD.
En el Capítulo 2 se estudia la teoría necesaria para la creación de las IGU y de forma
particular, se mencionan los elementos gráficos utilizados en ellas, estos pueden ser los
llamados Widgets: ventanas, menús, botones, botones radio, cajas de cheque. Además
se hace una descripción de Java como lenguaje de programación y como una
plataforma y finalmente se describe el desarrollo y el ciclo de vida de los Applets.
En el Capítulo 3 se describen la Ingeniería de Software (IS) y el Modelo Semi-formal
para el Desarrollo de Software Educativo (MSDSE). En la IS se puede encontrar una
clasificación del software, una descripción de los diferentes diagramas del Lenguaje
Unificado de Modelado (LUM) y un Proceso de Desarrollo de Software (PDS) que
consta de cuatro etapas; en el MSDSE se puede observar una metodología que consta
de 3 etapas para el desarrollo de Software Educativo (SE); finalmente en este capítulo
se presenta la metodología propuesta para el Diseño de la Interfaz Gráfica de Usuario
como Applet de Java (DIGUAJ).
En el Capítulo 4 se Aplica la metodología DIGUAJ para obtener la IGU e
implementarla como Applet de Java, también se incluyen los diagramas del LUM que
describen la Arquitectura de Software y el Modelado de la IGU como un Sistema de
Software; se desarrolla la portabilidad de la IGU usando la tecnología Java para la
7
creación de páginas web con programación en servidor (Java Server Pages ó JSP por
sus siglas en inglés) y se hace un análisis de la IGU haciendo una prueba con una
Función de Transferencia (FT)
Finalmente se presentan las Conclusiones que se obtuvieron de esta tesis y las
Recomendaciones.
8
Capítulo 1. Teoría de Control II y sus Elementos Matemáticos
1.1. Teoría de Control II
Habitualmente las teorías de control usadas son Teoría de Control Clásico, Teoría de
Control Moderno y Teoría de Control Robusto, en el presente capítulo se recomienda
un recurso didáctico para la enseñanza de la Teoría de Control Clásico en general y al
método del lugar geométrico de las raíces en particular, el cual fue propuesto por
Evans y desarrollado por completo a finales de los años cuarenta y principios de los
cincuenta [3].
En la asignatura de Teoría de Control II que es impartida en ESIME existen elementos
fundamentales para el estudio de la Teoría de Control Clásico como el método del
lugar de las raíces y respuesta en frecuencia los cuales serán abordados a partir del
tema 1.1.1, pero también existen elementos matemáticos como las ecuaciones
diferenciales ordinarias y la transformada de Laplace que son usados como una
herramienta en la solución de problemas de control clásico.
1.1.1. Sistemas de Control
Un sistema es una combinación de componentes que actúan juntos y realizan un
objetivo determinado. Un sistema no está necesariamente limitado a los sistemas
físicos. El concepto se puede aplicar a fenómenos abstractos y dinámicos como los que
se encuentran en la economía. Por lo tanto el concepto de sistema debe ser interpretado
de una forma más amplia de modo que comprenda sistemas físicos, biológicos,
económicos y similares.
En ingeniería es común el estudio de sistemas de control físicos, algunos ejemplos son:

Sistema de control de velocidad

Sistema de control de temperatura

Sistemas empresariales

Sistema de control de presión
9
Dentro del estudio de los sistemas de control hay conceptos usados con frecuencia, los
cuales son:

Planta: es el sistema controlado o que se pretende controlar, puede ser un
equipo, una parte de un equipo o un conjunto de elementos de una máquina que
trabajan juntos y cuyo objetivo es realizar una operación determinada.

variable controlada: es la variable que se pretende mantener en un valor
predeterminado conocido comúnmente como set point.

señal de control o variable manipula: es la cantidad o condición que un
controlador modifica para afectar el valor de la variable controlada.
En la Teoría de Control Clásico existen dos tipos de sistemas de control:

Sistemas de Control en Lazo Abierto

Sistemas de Control en Lazo Cerrado
1.1.1.1. Sistemas de Control en Lazo Abierto
Son los sistemas en los cuales la salida no tiene efecto sobre la acción de control, en
otras palabras la salida no es medida ni se realimenta para compararla con la entrada.
Un ejemplo práctico y clásico es una lavadora común, en donde el objetivo es dejar la
ropa limpia y las acciones de remojado, lavado y centrifugado operan por un tiempo
pre programado y no por un sensor que envíe una señal de salida que en este caso sería
la limpieza de la ropa.
Características de los Sistemas de Control en Lazo Abierto:

En cualquier sistema de control en lazo abierto la salida no se compara con la
entrada de referencia.

A cada entrada de referencia le corresponde una condición de operación fija,
por lo que la precisión del sistema depende de la calibración del mismo.
10

Ante la presencia de perturbaciones un sistema de control en lazo abierto no
realiza la tarea deseada.

Cualquier sistema de control que opere con una base de tiempo está en lazo
abierto.
Otro ejemplo de Sistema de Control en Lazo Abierto es el control de tráfico vehicular
mediante señales operadas con una base de tiempo. La Figura 1.1 muestra el diagrama
a bloques de un Sistema de Control a Lazo Abierto.
Figura 1.1. Diagrama a bloques de un Sistema de Control a Lazo Abierto
1.1.1.2. Sistemas de Control en Lazo Cerrado
Los sistemas de Control en Lazo Cerrado se denominan también Sistemas de Control
Retroalimentado, en la práctica estos términos se usan de forma indistinta. En los
sistemas de control en lazo cerrado, se alimenta al controlador con una señal de error,
la cual es la diferencia entre la señal de entrada y la señal de retroalimentación, esta
señal puede ser la señal de salida o una función de la señal de salida y sus derivadas o
integrales.

La finalidad de un Sistema de Control en Lazo Cerrado es reducir el error y
llevar la salida del sistema a un valor deseado.

El término de lazo cerrado siempre implica el uso de una acción de control
realimentado para reducir el error del sistema.
En la Figura 1.2 se muestra el diagrama a bloques de un Sistema de Control en Lazo
Cerrado en donde E(s) es la señal de error, la señal de realimentación es Y(s), la
entrada del sistema es R(s), el controlador es el bloque K y la planta del sistema es el
bloque G(s).
11
Figura 1.2. Sistema de control en lazo cerrado
1.1.1.3. Comparación entre Sistemas de Control en Lazo
Cerrado y Sistemas de Control en Lazo Abierto
Una ventaja del Sistema de Control en Lazo Cerrado es que la respuesta del sistema se
vuelve relativamente insensible a perturbaciones externas y a las variaciones internas
de los parámetros del sistema.

Para los sistemas en los que se conoce con anticipación las entradas y en los
cuales no hay perturbaciones es posible implementar el control en lazo abierto.

El número de componentes utilizados en un sistema de control en lazo cerrado
es mayor que en sistema de control en lazo abierto, lo cual incrementa el coste
de la implementación del control.

En un sistema de control en lazo abierto la estabilidad no es un problema
importante, pero en un sistema de control en lazo cerrado la estabilidad si es un
gran problema.
Ventajas fundamentales de los sistemas de control en lazo abierto:

Construcción simple y facilidad de mantenimiento.

Menos costo que el correspondiente sistema en lazo cerrado.

No hay problemas de estabilidad.

Convenientes cuando la salida es difícil de medir o cuando medir la salida de
forma precisa no es económicamente viable.
Ventajas fundamentales de los sistemas de control en lazo cerrado:
12

Las perturbaciones y los cambios en la calibración originan errores, y la salida
puede ser diferente de lo que se desea.

Para mantener la calidad requerida en la salida, es necesaria la re-calibración
regularmente programada.
1.1.2. El Lugar Geométrico de las Raíces
Evans (a finales de los años cuarenta y principios de los cincuenta), utilizó un método
gráfico y sencillo con el cual se pueden encontrar las raíces de la ecuación
característica y observar el comportamiento de las mismas asociado a la dinámica del
sistema con base en un análisis matemático de la ecuación característica del sistema.
Este método se denomina método del lugar geométrico de las raíces, y en él se
representan las raíces de la ecuación característica para todos los valores de un
parámetro del sistema.
Por lo tanto en la gráfica que resulta del método se pueden localizar las raíces
resultantes para un valor dado de un parámetro, este parámetro es por lo general la
ganancia, aunque es posible utilizar cualquier otra variable de la función de
transferencia en lazo abierto. Al menos que se indique lo contrario, aquí se supondrá
que la ganancia de la función de transferencia en lazo abierto es un parámetro que
puede adoptar todos los valores de cero a infinito [3].
Para un sistema de control como el que se mostró en la figura1.2, se tiene el
planteamiento de las ecuaciones (1) y (2):
(s)
(s)
(s)
(1)
( )
( )
( )
(2)
Sustituyendo la ecuación (1) en la ecuación (2) se tiene:
( )
(s)
(s)
( )
(3)
13
Desarrollando la ecuación (3) y agrupando los términos de Y(s) del lado izquierdo
de la ecuación se obtienen las ecuaciones (4) y (5):
( )
(s) ( )
(s) ( )
(4)
( )
(s) ( )
(s) ( )
(5)
Haciendo la factorización de los términos semejantes de Y(s) de la ecuación (5):
(s)
( )
( )
( )
(6)
De acuerdo a la definición de Función de Transferencia, que es la relación de la
salida Y(s) respecto a la entrada R(s) del sistema de la ecuación (6) se obtiene:
( )
( )
( )
(7)
( )
En donde la ecuación (7) es la función de transferencia en lazo cerrado del sistema y
determinar la estabilidad del sistema consiste en analizar el comportamiento de la
ecuación característica, es decir de:
( )
( ).Se observa que K es la
ganancia y que por lo tanto la dinámica del sistema depende de K ya que es un
parámetro que puede adoptar todos los valores de cero al infinito.
La idea básica detrás del método del lugar de las raíces es que los valores de s que
hacen que la función de transferencia alrededor del lazo sea igual a -1, es decir:
( )
deben satisfacer la ecuación característica del sistema. El método debe
su nombre al lugar de las raíces de la ecuación característica del sistema en lazo
cerrado cuando un determinado parámetro (por lo general la ganancia K) varia de cero
a infinito.
14
Dicha gráfica muestra como contribuye cada polo o cero en lazo abierto a las
posiciones de los polos en lazo cerrado, por lo antes citado se puede decir que al
diseñar un sistema de control lineal, el método del lugar de las raíces resulta de gran
utilidad, ya que se puede observar la forma en que los polos y los ceros en lazo abierto
se deben modificar para que la respuesta del sistema cumpla con un comportamiento
específico [3].
Este método es puramente cualitativo, sin embargo por medio de operaciones aparte de
observar el comportamiento de las raíces se pueden obtener ciertos valores que a pesar
de estar en una gráfica en el plano complejo brindan información de forma intuitiva
sobre el comportamiento en el tiempo [1].
1.1.3. Diseño de Compensadores PD por el Lugar Geométrico de
las Raíces
El lugar geométrico de las raíces bosqueja el comportamiento de un sistema en lazo
cerrado, la ventaja que tiene esto es que si se quiere diseñar otro tipo de compensador,
siempre es posible verlo como una ganancia variable y una función de transferencia
compuesta por el sistema y todos los valores de las ganancias de cada compensadores y
además el diseño permite visualizar el efecto de todos los compensadores en la
estabilidad del sistema.
La idea básica es verificar primeramente si con un compensador proporcional se
cumple con los requerimientos del sistema, en caso de no hacerlo, se verifica cual es el
comportamiento que sí cumple para poder tomar la elección del compensador más
adecuado.
1.2. Elementos Matemáticos Implícitos en la Teoría de Control II.
En matemáticas existen elementos que son usados de forma recurrente en la asignatura
de teoría de control II, como la transformada de Laplace y los métodos de solución de
las ecuaciones diferenciales ordinarias de primero y segundo orden homogéneas y no
homogéneas, a partir de estos elementos matemáticos se derivan características
15
fundamentales de los sistemas que son analizados en la asignatura de teoría de control
II.
La transformada de Laplace y el estudio de las ecuaciones diferenciales ordinarias son
esenciales para que el Ingeniero en Control y Automatización pueda analizar los
sistemas y a través de estos elementos matemáticos pueda formar funciones de
transferencia. Para el estudio del lugar geométrico de las raíces es necesario entender
las características matemáticas que están involucradas en las funciones de transferencia
de los modelos estudiados en la asignatura. Lo anterior se puede observar en la figura
1.3.
Figura 1.3. Interacción de elementos matemáticos con elementos de la teoría de control
II [Creación Propia].
1.2.1. El Lugar Geométrico de las Raíces
La función de transferencia de un sistema es la relación existente entre la entrada y la
salida, cuando las condiciones iníciales son nulas. En general, la función de
transferencia de los sistemas puede escribirse como un cociente de polinomios en el
dominio de la frecuencia “s”. La función de transferencia está constituida por polos y
16
ceros, ceros en el numerador y polos en el denominador, además el denominador es
considerado como el polinomio característico del sistema o ecuación característica [2].
A partir de la función de transferencia es posible definir algunas características de
relevancia [3]:

La característica básica de la respuesta transitoria de un sistema en lazo cerrado
se relaciona estrechamente con la localización de los polos en lazo cerrado.

Si el sistema tiene una ganancia de lazo variable, la localización de los polos en
lazo cerrado depende del valor de la ganancia de lazo elegida.

Desde el punto de vista del diseño, un simple ajuste de la ganancia en algunos
sistemas mueve los polos en lazo cerrado a las posiciones deseadas.

Los polos en lazo cerrado son las raíces de la ecuación característica.
1.2.2. Ecuaciones Diferenciales Ordinarias
Las ecuaciones diferenciales se encuentran en muchas áreas de ciencias e ingeniería y
la relación que existe entre las matemáticas y sus aplicaciones es conocida como
matemáticas aplicadas [4].
Las aplicaciones que ha visto un estudiante que ha cursado la asignatura de ecuaciones
diferenciales son variadas ya que los ejemplos que seguramente ha visto son de física,
química, biología, matemáticas e ingeniería, pero esto depende de la orientación del
curso.
Por lo que en algunas ocasiones las ecuaciones diferenciales son el tipo de matemáticas
que surgen de esas aplicaciones.
Por definición una Ecuación Diferencial Ordinaria Lineal es:
( )
( )
( )
( )
( )
17
En el estudio de las matemáticas aplicadas se incluyen tres aspectos [4]:

Proceso de modelado: es el proceso mediante el cual los objetos físicos y los
procesos se describen por medio de leyes físicas y formulaciones matemáticas
dadas.

Análisis: es el análisis de los problemas matemáticos que se postulan, esto
abarca una investigación sobre las formas de solucionar las ecuaciones
diferenciales ordinarias.

Interpretación: el resultado matemático de una ecuación diferencial ordinaria no
lo dice todo, por lo que es necesario interpretar el resultado en el contexto del
problema físico original.
Ejemplos de modelos que surgen de las matemáticas aplicadas:
Ecuación diferencial que determina la posición de una masa en movimiento y una
fuerza debida a la resistencia del aire proporcional a la velocidad dy/dt.
(1)
Ecuación diferencial que satisface la corriente que circula por un circuito típico
formado por un resistor, un capacitor y una bobina.
i
f(t)
(2)
De los ejemplos anteriores se pueden comenzar a observar distintos elementos
que son usados en la asignatura de teoría de control II.
De
g
(3)
18

Se encuentra que “ ” y “ ” son los pará etros que rigen la diná i a del
sistema.

os pará etros “ ” y “ ” ha en que el siste a sea ineal Invariante en el
Tiempo.
1.2.3. Transformada de Laplace
La idea de usar una transformación es cambiar un conjunto de objetos y operaciones en
otro conjunto de objetos y operaciones. En este caso la transformación será la
transformada de Laplace, la cual cambiará una ecuación diferencial lineal con
coeficientes constantes en un problema de álgebra [4].
Muchos procedimientos de diseño en la teoría de control están basados en la forma
algebraica del problema, la cual es proporcionada por la transformada de Laplace.
Definición de la transformada de Laplace:
(s)
f(t)
∫ e
f(t)dt
(4)
De la definición de la transformada surgen transformadas para las derivadas:
f (t)
s (s)
f (t)s
(s)
sf( )
f( )
(5)
f( )
(6)
En donde f( ) y f’( ) son las ondi iones iníciales del sistema que se está
estudiando.
19
Como se mencionó anteriormente la transformación de las ecuaciones diferenciales
revela aspectos matemáticos rescatables para la teoría del control, pero esto no se logra
hasta tener la función de transferencia de un sistema que esté definido por
una
ecuación diferencial ordinaria lineal con parámetros concentrados e invariante en el
tiempo, en donde además sus condiciones iníciales son iguales a cero.
Ejemplo de obtención de la función de transferencia de un sistema definido por
una ecuación diferencial ordinaria lineal con parámetros concentrados e
invariante en el tiempo, con condiciones iníciales iguales a cero:
y
u(t)
(7)
Aplicando la transformada de Laplace a la ecuación (7) se obtiene:
( )
( )
( )
[
( )
( )
]
( )
(8)
Dado que las condiciones son iguales a cero se puede conservar la linealidad del
sistema transformado por lo que te puede obtener la función de transferencia y
reducir la ecuación (8) a:
s
(s)
s (s)
(s)
(9)
Haciendo la factorización de Y(s) a partir de la ecuación (9):
(s) s
s
(10)
Despejando Y(s) de la ecuación (10):
20
(s)
(11)
(s)
(12)
Reduciendo la ecuación (11):
De la ecuación (11) es posible identificar distintos elementos matemáticos que se
usan en la teoría del control:

a solu ión de una e ua ión diferen ia “y(t)” es la salida de un siste a en
el do inio de “s”.

El orden de la ecuación característica de la función de transferencia es
igual al orden de la ecuación diferencial

El orden de la ecuación diferencial es igual al número de raíces de la
ecuación característica.
21
Capítulo2. Teoría de Interfaces Gráficas de Usuario
2.1. Interfaces Gráficas de Usuario
Interfaz Gráfica
de Usuario (IGU) es un programa o entorno que gestiona la
interacción con el usuario basándose en relaciones visuales como íconos, menús o un
puntero. Se les puede considerar como programas de cómputo, que un programador o
desarrollador de software crea apoyándose en herramientas llamadas Entorno de
Desarrollo Integrado (EDI).
Las interfaces o programas de cómputo que crea el desarrollador de software se basan
en elementos gráficos los cuales permiten a un usuario final controlar el
funcionamiento e interactuar con la interfaz o programa de cómputo. Los elementos
gráficos utilizados en las IGU se llaman Widgets, incluyen: ventanas, menús, botones,
botones radio, cajas de chequeo, íconos, áreas de texto y listas [19, 20].
Un acrónimo que engloba a los Widgets es VIMD (Ventanas, Íconos, Menús,
Dispositivos Señaladores) o WIMP (Windows, Icons, Menus, Pointing devices) por sus
siglas en inglés y para diseñar Interfaces Gráficas de Usuario es necesario recurrir a un
paquete de herramientas Widgets.
Los paquetes de herramientas Widgets más usados tienen nombre y son clasificados
por el lenguaje de programación en que fueron creados, esto se debe a que son
paquetes que le proporcionan robustez al lenguaje de programación. Los lenguajes de
programación se pueden clasificar en lenguajes de Bajo Nivel y de Alto Nivel, estos
últimos usualmente tienen las mayores prestaciones gráficas.
Existen Leguajes de Programación de Bajo Nivel como el lenguaje C que cuenta con
varios paquetes de herramientas Widgets. Los nombres de los paquetes de herramientas
se presentan en la tabla 2.1.
22
Tabla 2.1. Nombres de los Lenguajes Programación más conocidos con su respectivo
Paquete de Herramientas Widgets.
Nombre del Lenguaje
de Programación
Java
C++
C
Nombre
del
Paquete
Herramientas Widgets
Swing y AWT
Qt, Borland, wxWidgets
Motif, GTK+ y Tk
de Clasificación del Lenguaje
de Programación
Nivel Alto
Nivel Alto
Nivel Bajo
2.1.1. Consideraciones Técnicas de las Interfaces Gráficas de
Usuario
Una vez seleccionado el paquete de herramientas Widgets que se utilizará para el
diseño de la interfaz, es indispensable conocer las consideraciones técnicas que
orientarán el trabajo de programación adecuadamente. A continuación se mencionarán
tres aspectos fundamentales a considerar [20]:

Programación: necesita diseñarse bajo una arquitectura de software que
consiste en un Modelo de Software y una Arquitectura de Software, los cuales
depende de las características del lenguaje de programación, que puede ser
orientado a objetos, de programación estructurada, de bajo o alto nivel.

Ergonomía: es uno de los factores más importantes para que la IGU sea
amigable con un uso fácil y sin ambigüedad.

Diseño Gráfico: el diseño gráfico involucra las artes gráficas a través de las
cuales la interfaz gráfica resulta ser estética y cómoda a la vista.
Además de las consideraciones que ya se mencionaron existen factores que
complementan el diseño de la IGU y que influyen en la orientación de la programación
de forma directa, como cada usuario tiene necesidades diferentes podría dar usos a la
interfaz gráfica para los cuales no fue diseñada, lo que queda fuera del alcance del
programador, de ahí la necesidad de considerar los siguientes factores [20]:
23

Comportamiento del Usuario: cada usuario tiene un comportamiento diferente
al usar la interfaz por lo que es necesario que la IGU reaccione ante eventos
generados dentro de la misma.

Método Clásico de Diseño Poco Adaptado: el método clásico de diseño de una
IGU es como el que se muestra en la figura 2.1.
Figura 2.1. Método Clásico de Diseño de Interfaces Gráficas de Usuario
Se dice que este método esta poco adaptado debido a que el diseño de la IGU debe ser
iterativo por medio de una evaluación del usuario para retroalimentar el diseño de la
misma desde la etapa de análisis [20].
2.1.2. El Pensamiento de la Interfaz Gráfica de Usuario
Debido a que las IGU tienen como función establecer un enlace entre dos sistemas
llamados usuario y computadora, la IGU podría aparentar que en realidad está
haciendo reflexiones acerca del comportamiento del usuario al interactuar con ella
proporcionando información que orienta y dirige al usuario.
El enlace que se establece entre estos dos sistemas se logra mediante el manejo de
eventos generados en la IGU. Los eventos que se pueden generar son entradas que
provienen de los dispositivos de entrada de la plataforma tipo hardware en la que se
está ejecutando la IGU, como son el teclado y el mouse.
Una de las Herramientas Widgets que permite el manejo de eventos es la biblioteca
AWT de Java que contiene clases que a su vez tienen métodos que sirven para
identificar eventos que provienen del sistema huésped. Debido a que en Java las
24
aplicaciones se ejecutan dentro de la Máquina Virtual (JVM por sus siglas en ingles),
esta se encarga de recibir los eventos del sistema huésped.
El hecho de recibir los eventos no significa nada ya que es necesario que exista un
enlace entre la Máquina Virtual de Java y el sistema huésped que interprete estos
eventos, ese enlace entre el sistema huésped y la Máquina Virtual de Java se logra
incorporando métodos de las clases de la biblioteca AWT a los programas informáticos
creados en este lenguaje [10].
Debido a que la Interfaz Gráfica de Usuario podría manejarse de forma inadecuada por
los usuarios el programador de la Interfaz Gráfica de Usuario debe darse a la tarea de
tratar de predecir en que partes de la Interfaz Gráfica de Usuario pueden ocurrir
eventos inesperados para el usuario sin que este sepa que hacer.
Antes de que un evento inesperado ocurra deben actuar métodos de programación que
el programador debe diseñar y programar para poder anticipar al usuario y dirigirlo en
el uso de la Interfaz Gráfica de Usuario. Los métodos que el programador diseña se
rigen por los métodos contenidos en las clases de la biblioteca AWT de la versión
estándar de Java.
2.1.3. Manejo de Eventos con la Biblioteca AWT de la Versión
Estándar de Java
Cuando el usuario actúa sobre un componente, por ejemplo pulsando el ratón o la tecla
Enter, se crea un objeto Evento. El sistema manejador de eventos de la biblioteca AWT
pasa el Evento a través de un árbol de componentes, dando a cada componente una
oportunidad para reaccionar ante el evento antes de que el código dependiente de la
plataforma que implementan todos los componentes lo procese.
25
Cada manejador de eventos de un componente puede reaccionar ante un evento de
alguna de estas formas [21]:

Ignorando el evento y permitiendo que pase hacia arriba en el árbol de
componentes.

Mediante la modificación del objeto Evento antes de dejarlo subir por el árbol
de componentes.

Reaccionando de alguna otra forma ante el evento.

Interceptando el evento, evitando un procesamiento posterior.
Desde el punto de vista de un componente, el sistema de manejo de eventos del AWT
es como un sistema de filtrado de eventos. El código dependiente de la plataforma
genera un evento, pero los componentes tienen una oportunidad para modificar,
reaccionar o interceptar el evento antes de que el código dependiente dela plataforma
los procese por completo.
En la versión actual 1.6 del Paquete de Desarrollo de Java (JDK por sus siglas en
inglés), los eventos generados al manipular el puntero del ratón se envían a los
componentes después de que los haya procesado el código dependiente de la
plataforma. Por eso aunque los componentes pueden interceptar todos los eventos
generados por el teclado, generalmente no se pueden interceptar los eventos del ratón.
Aunque la biblioteca AWT define una amplia variedad de objetos evento, no ve ni
escucha todo lo que ocurre. De este modo, no todas las acciones del usuario en la IGU
se convierten en eventos. La biblioteca AWT sólo puede identificar eventos que están
relacionados código dependiente de la plataforma que hospeda a Java (DLL´s). Por
ejemplo, los movimientos del puntero sobre un campo de texto no generan algún objeto
evento.
26
Si se quiere acceder a una amplia colección de objetos eventos se necesitará
implementar una subclase de Lienzo, ya que la implementación dependiente de la
plataforma de la clase Lienzo reenvía todos los eventos.
Cuando un usuario genera un evento en la IGU, la AWT crea un objeto evento que
incluye la siguiente información [21]:

El tipo del evento -- por ejemplo, una pulsación de tecla o un click del ratón, o
un evento más abstracto como acción o iconificación de una ventana.

El objeto que fue el origen del evento. Por ejemplo, el objeto Botón
correspondiente al botón de la pantalla que pulsó el usuario, o el objeto Campo
de Texto en el que el usuario acaba de teclear algo.

Un campo indicando el momento en que ocurrió el evento. Por ejemplo, la
posición (x , y) donde ocurrió el evento. Esta posición es relativa al origen del
componente a cuyo manejador de eventos se pasó este evento.

La tecla que fue pulsada (para eventos de teclado). Por ejemplo, un argumento
arbitrario como lo es una cadena de texto mostrada en un componente y
asociada con el evento pulsar el teclado.

El estado de las teclas modificadoras, como Shift o Control, cuando ocurrió el
evento.
2.2.
Programación y desarrollo de Interfaces Gráficas de Usuario en
Java
2.2.1. Herramientas Widgets de la Biblioteca Swing
Los componentes gráficos que ofrece Java se encuentran en una biblioteca llamada
Swing, los componentes gráficos se pueden implementar dentro de los Applets, a estos
Applets se les llama Applets Swing. Existe una diferencia importante entre un Applet
no-Swing y un Swing, éste último debe descender de la clase JApplet, en vez de
hacerlo directamente de la clase Applet [10].
27
Se pueden ejecutar Applets Swing en cualquier navegador que tenga instalado el
conector de Java conocido como Java Plug-in. Otras opciones son:

Un navegador que sea compatible con el JDK 1.1 y que pueda encontrar las
clases de la biblioteca Swing.

Un navegador que sea compatible con el JDK 1.2. Actualmente, el único
navegador compatible con esta versión disponible es la utilidad Applet Viewer
proporcionada con el JDK 1.2.
Los componentes gráficos se utilizan para mostrar salidas pero algunos otros para
obtener entradas del usuario, en la figura 2.2.1.1 se muestran diferentes elementos
gráficos o Widgets de la biblioteca Swing de Java. En el caso de la figura 2.2.1.2 los
elementos gráficos que se aprecian son utilizados para obtener eventos de entrada
desde el usuario, los cuales serán manejados con la biblioteca de clases AWT de Java.
Área de Texto
Seleccionador de Archivos
Tabla
Árbol
Seleccionador de Colores
Figura 2.2.1.1.Pantallas editables de información formateada de la biblioteca Swing
28
El orden y uso de los elementos de la figura 2.2.1.1 depende de las necesidades del
usuario final, de los requisitos analizados durante el proceso de modelado de desarrollo
de la interfaz para que sea ergonómica que se le dé a la IGU.
En la figura 2.2.1.2 se muestran los elementos que pueden generar salidas y al mismo
tiempo ser editados por el usuario, se les considera como pantallas de información que
permiten una interacción entre el usuario y la interfaz.
Botones (button)Listas (combo box)
Listas (list)
Menús (menu)
Barras deslizantes(slider)
Texto (textfield)
Barra herramientas (tool bar)
Figura 2.2.1.2 Herramientas Widgets básicas de la biblioteca Swing que generan
entradas a la biblioteca AWT
29
2.2.2. Descripción del Lenguaje Java
Java está dividido en dos entidades: a) Un lenguaje de programación que es facilitado
por la bibliotecas del Java Development Kit (JDK) y b) Una plataforma que es
proporcionada por el paquete Java Runtime Environment (JRE), esto quiere decir que
se podrían construir sistemas operativos por completo con Java. En la figura 2.2.2.1 se
describe la estructura global de Java y se puede observar tanto el paquete JDK como el
JRE.
Figura 2.2.2.1. Estructura global de Java [9].
2.2.2.1. Java como Lenguaje de Programación
El lenguaje de programación Java es de nivel alto y tiene las siguientes características
[5]:

Simple

Multiprocesos

Con Arquitectura Neutral

Robusto

Orientado a Objetos

Dinámico
30

Portable

Distribuible

De Rendimiento Alto

Seguro
2.2.2.2. Java como una Plataforma
Una plataforma es el entorno de hardware o software en el que un programa se ejecuta.
Las plataformas de software más conocidas son Microsoft Windows, Linux, Solaris y
Mac OS. La mayoría de las plataformas se describen como una combinación del
sistema operativo y el hardware que soporta dicho sistema. La plataforma Java difiere
de las anteriores en que se ejecuta solo en la parte superior de otras plataformas
basadas en hardware.
La plataforma Java cuenta con su procesador, memoria RAM; los cuales son creados
virtualmente tomando prestados algunos de los recursos del sistema huésped. Una
desventaja de lo anterior es que los procesos que se ejecutan dentro de la plataforma
Java dependen de la cola de procesos del sistema operativo huésped.
La plataforma Java tiene dos componentes:

La Máquina Virtual de Java ó The Java Virtual Machine(JVM)

La Interfaz de Programación de Java ó The Java Application Programming
Interface (API)
La JVM es la base para la plataforma Java como se muestra en la figura 2.2.2.2.1 y ha
sido adaptada a varias plataformas
basadas en
hardware y la API es una gran
colección de componentes de software listos para usarse que proporcionan muchas
funciones útiles; se agrupan en las bibliotecas de clases e interfaces relacionadas, estas
31
bibliotecas se conocen como paquetes de Java.
Figura 2.2.2.2.1. Estructura de Java como una plataforma [5]
La API y la máquina virtual de Java están para aislar el programa desde el hardware
del Sistema operativo huésped, esto permite tener un control sobre los programas
creados en Java permitiendo brindar a los usuarios de las aplicaciones condiciones de
seguridad tanto para su sistema operativo como para el equipo de cómputo y datos
personales.
En un entorno independiente, la plataforma Java puede ser un poco más lenta que el
código nativo. Sin embargo, los avances en el compilador y las tecnologías de Máquina
Virtual proporcionan un rendimiento cercano al de código nativo sin poner en peligro
la portabilidad [5].
2.2.2.3. Prestaciones de la Tecnología Java
Debido a que el lenguaje de programación Java es un lenguaje de nivel alto tiene como
propósito general funcionar como una plataforma basada en software, por lo que todas
las implementaciones de la plataforma Java pueden componerse de las siguientes
características [5, 6]:

Herramientas de desarrollo: Las herramientas de desarrollo proporcionan lo
necesario para compilar, correr, monitorear, depurar y documentar las
aplicaciones. Algunas herramientas de desarrollo de aplicaciones son: Javac
compiler, el Java launcher, y el Javadoc documentation tool.
32

Interfaz de Aplicación de Programación (Application Programming Interface
API): La API proporciona un núcleo de funcionalidades del lenguaje de
programación Java. Dentro de este núcleo se ofrecen un sin fin de clases, las
cuales están siempre disponibles para emplearse en las aplicaciones. Estas
clases permiten diseñar cualquier forma básica de objetos para redes y
seguridad, para XML, para acceso a bases de datos y más.
El núcleo API es tan extenso como para desarrollar una aplicación la cual
ocupe todas las clases del núcleo. Además documentarlo o intentar mencionar
sus clases seria inconveniente por cuestiones de espacio por lo que para obtener
información detallada de las clases del núcleo API de Java es necesario
consultar la documentación de la API Java SE Development Kit 6 (JDKTM 6)
documentation.

Tecnologías de Desarrollo o Deployment Technologies: En Java existe una
tecnología de desarrollo llamada Paquete de Desarrollo de Java o Java
Development Kid (JDK), el Paquete de Desarrollo de Java es un software que
proporciona mecanismos de diseño estándar como el Java Web Start y el
software conector de Java (Java Plug-In) para el desarrollo de aplicaciones de
usuario final.

Kit de Herramientas de Interfaces de Usuario o User Interface Toolkits: En Java
existen dos clases
que proporcionan funcionalidades gráficas
a las
aplicaciones creadas las cuales son las bibliotecas Swing y Java 2D.
2.2.2.4. Proceso de Creación de Programas Informáticos en
Java
1) En el lenguaje de programación Java todo el código que formará parte del
programa informático primero es escrito en archivos de texto plano, guardados con
33
la terminación .Java, es decir se pueden escribir en un bloc de notas y al terminar
de escribir el código el archivo deberá guardarse con extensión de archivo .Java.
2) Los archivos creados de esta forma después son convertidos (compilados) en un
archivo que tiene como extensión .class mediante el compilador Javac. Aunque un
archivo .class no contiene código el cual sea nativo para el procesador, si contiene
bytecodes el cual es el código que entiende la Máquina Virtual de Java (Java VM
por sus siglas en ingles).
3) Después la herramienta de lanzamiento de Java corre la aplicación mediante una
instancia de la Máquina Virtual de Java como se puede observar en la figura
2.2.2.4.1.
4)
Figura 2.2.2.4.1. Una vista general del proceso de creación de Programas Informáticos
en Java [5].
Existen distintas Máquinas Virtuales de Java (JavaVM) y algunas como la
JavaHotSpotMáquina Virtual realizan pasos adicionales en la rutina del proceso de
lanzamiento para dar un aumento en el rendimiento de la aplicación.
Los archivos .class tienen la posibilidad de correr sobre Microsoft Windows, el sistema
operativo Solaris TM (Solaris OS), Linux, o Mac OS y esto tiene como resultado que
la Java VM sea compatible con varios Sistemas Operativos como se muestra en la
figura 2.2.2.4.2 [5].
34
Figura 2.2.2.4.2. Con la Java VM la misma aplicación es capaz de correr en múltiples
plataformas operativas [5].
2.2.3. Desarrollo de Applets
El Applet es también conocido como un subprograma de Java, el cual puede
incrustarse en un documento HTML; también conocido como página web, cuando un
navegador Web descarga una página web que contiene un Applet, este se descarga en
el navegador y comienza a ejecutarse. Esto permite crear programas que cualquier
usuario con acceso a la Web puede ejecutar con sólo cargar la página Web
correspondiente en el navegador web.
Un Applet es un programa que se puede ejecutar mediante líneas de comando y ser
visualizado con el programa herramienta del Paquete de Desarrollo de JavaSDK (por
sus siglas en inglés) appletviewer.exe. Appletviewer también es conocido como un
navegador mínimo, el cual solo sabe cómo interpretar Applets [10].
En Java existe una clase llamada Applet, la cual proporciona todo lo necesario para la
creación de Applets en la versión 1 de Java. Está contenida en el paquete Java.applet,
por tanto, siempre que sequiera desarrollar un appletse debe importar este paquete, así
como también el paquete Java.awt , Java.awt.event, y Javax.swing que contienen
todas las herramientas necesarias para desarrollar interfaces gráficas [11,12].
35
A partir de la versión J2SDK se usa la clase JApplet del paquete Javax.swing.para la
creación de Applets que contienen proyectos como pueden ser Interfaces Gráficas de
Usuario, Formularios, Aplicaciones Web, JavaBeans y JavaCards.
Los Applets tienen la ventaja de ejecutarse en Internet sobre el navegador en el equipo
del cliente, pero los diseñadores de Java les colocaron algunas restricciones para evitar
que estos dañen o inserten virus en las máquinas donde se ejecutan, entre ellas
están[11]:
a)
b)
No pueden leer o escribir en el sistema de archivos desde un navegador
Solo tienen acceso al servidor definido dentro del Applet en un programa que
use sockets.
c)
Impedimento para ejecutar programas en el cliente
d)
Impedimento para cargar programas nativos como las DLL para sistemas
operativos.
4.1.1.1. Construcción de Applets
Con la versión de Java 2 la estructura para crear un programa de tipo Applet
tiene la siguiente forma [12]:
importJavax.swing.JApplet;
importJavax.swing.SwingUtilities;
importJavax.swing.JLabel;
public class HelloWorld extends JApplet {
//Called when this applet is loaded into the browser.
public void init() {
//Execute a job on the event-dispatching thread; creating this
applet's GUI.
try {
SwingUtilities.invokeAndWait(new Runnable() {
public void run() {
JLabellbl = new JLabel("Hello World");
add(lbl);
}
});
} catch (Exception e) {
System.err.println("createGUI didn't complete successfully");
}
}
}
36
4.1.1.2. Ciclo de vida de un Applet
Comprender el ciclo de vida del Applet es sumamente importante ya que de esto
depende una buena implementación de la programación, un correcto uso de los
recursos y un aprovechamiento máximo de los métodos de clases usados para la
implementación.
Un Applet hereda sus propiedades y sus métodos de la clase JApplet del paquete
Javax existente en la biblioteca swing, cuenta con varios métodos que el usuario puede
sobre escribir para darle la funcionalidad requerida. Estos métodos se detallan en la
tabla 2.2 y siguen un ciclo de vida que se explica en el diagrama de la figura 2.2.3.2.1
[12].
En esta clase el método inicial para ejecutar un Applet es init cuando se omite se usa el
método start, si también se omite se usa el método paint, esto significa que no requiere
de un método main [13].
Tabla 2.2. Métodos que hereda un Applet desde la clase JApplet y su descripción.
Nombre del
Descripción del método
Método
init():
Es el primer método que se ejecuta al cargar el Applet y sólo se ejecuta una
vez. Se debe utilizar para inicializar las variables.
start():
Se ejecuta después del init(). Permite reinicializar un Applet después de que
se haya parado. El método start() se ejecuta cada vez que se muestra en
pantalla el documento HTML que contiene el Applet.
paint():
stop():
Se ejecuta cada vez que se debe volver a pintar la salida de un Applet.
Se ejecuta cuando el navegador abandona la página HTML que contiene el
Applet. Se utiliza para parar el Applet; para volverlo a iniciar se llama el
37
método start().
destroy():
Se ejecuta cuando el entorno determina que el Applet debe ser borrado
completamente de la memoria. El método stop() siempre se ejecuta antes que
el destroy.
Figura2.2.3.2.1.Muestra el ciclo de vida de un Applet [13].
38
Capítulo 3. Diseño de la Interfaz Gráfica de Usuario
3.1. Ingeniería de Software
El término Software fue usado por primera vez por John W. Tukeyen 1957, lo
consideró como la parte lógica de una computadora porque permite el manejo de los
recursos con la que esta cuenta y la ejecución de tareas específicas también
denominadas subprogramas.
De forma general el software se clasifica en [29]:
1. Software de sistemas: Son aquellos programas que permiten la administración de la
parte física o los recursos de la computadora y que permiten la interacción entre el
usuario y los componentes hardware del ordenador; se clasifican el Sistemas
Operativos Mono usuarios y Multiusuario.
2. Software de aplicación: Son aquellos programas que ayudan a realizar tareas
específicas como edición de textos, imágenes, cálculos, entre otros, también
conocidos como aplicaciones.
De una forma más específica, el software se clasifica en tres gruposde acuerdo con el
tipo de trabajo que el usuario puede realizar con él:
1. Software de sistemas
En este grupo se encuentran los programas básicos que controlan a la computadora,
también llamados sistema operativo, el cual tiene tres grandes funciones: a) coordina y
manipula el hardware del ordenador, como la memoria y las unidades de disco; b)
organiza los archivos en diversos dispositivos de almacenamiento, como memorias y
discos externos y c) gestiona los errores de hardware y del mismo software, como
errores de arranque del sistema operativo y de cierre de sesión de usuario.
Los sistemas operativos pueden ser de tarea única o multitarea,los sistemas operativos
de tarea única son los más primitivos y solo pueden manejar un proceso en cada
39
momento; mientras que los sistema operativos multitarea pueden realizar varias
acciones a la vez como mandar a imprimir y editar en forma simultánea otro
documento.
2. Software de aplicación
Es el que permite a los usuarios llevar a cabo una o varias tareas específicas, en
cualquier campo de actividad susceptible de ser automatizado o asistido, su uso tiene
especial énfasis en los negocios y en la educación. En su diseño se utiliza el software
de desarrollo.
3.
Software de desarrollo
En este grupo se encuentra cualquier lenguaje artificial o programa de cómputo que se
puede utilizar para definir una secuencia de instrucciones que serán procesadas por un
compilador que tiene la capacidad de traducir las instrucciones de un lenguaje a un
código que comprende la computadora.
Los compiladores junto con los editores de texto ayudan a los programadores y
diseñadores de software en la escritura, compilación y prueba de programas
informáticos que se desarrollan con diferentes lenguajes de programación como C++,
Java, C#, Visual Basic, HTML y con algunos software de desarrollo son NetBeans,
VisualStudio, Net y DreamWeaver [29].
Como se mencionó en el tema 2.1 las Interfaces Gráficas de Usuario (IGU) son
programas de cómputo que gestionan la interacción con el usuario basándose en
relaciones visuales como íconos, menús o un puntero, por lo que de acuerdo a la
clasificación de software mencionada en párrafos anteriores a la IGU se le considera
como un software de aplicación y para su diseño se deben tomar en cuenta los
lineamientos de la Ingeniería de Software.
40
La Ingeniería de Software (IS) es una actividad de modelado de sistemas de software
que permite la solución de problemas que requieren el desarrollo de un software; una
vez identificado el problema se analizan los detalles relevantes y se ignoran todos los
demás. En la actividad de modelado se recopilan datos que se organizan en
información y se traducen en adquisición de conocimiento; que permitirá la toma de
decisiones y la justificación de las razones que llevan a la misma [31].
El modelado de un sistema de software consta de distintos tipos de diagramas que se
construyen siguiendo el Lenguaje Unificado de Modelado (LUM) y una serie de pasos
que permiten la construcción de los mismos.
De acuerdo con la Ingeniería de Software se aseguran la calidad del Sistema de
Software (SS) a través del uso de herramientas de diseño como el LUM. Un SS no
necesariamente debe incluir todos los diagramas de la nomenclatura.
3.1.1. Diagramas de Lenguaje Unificado de Modelado
La Ingeniería de Software es una actividad de modelado de Sistemas de Software, su
concepción es un proceso ordenado y en el que intervienen distintos actores o personas
con papeles específicos: el cliente, el analista de sistemas y el o los programadores.
En las industrias de la construcción, la mecánica o la aeroespacial es esencial el uso de
planos durante la etapa de diseño para luego llevar a producción lo que se ha diseñado,
lo que LUM proporciona son las herramientas necesarias para poder obtener los
diagramas LUM de un Sistema de Software (SS), los cuales equivalen a los planos que
se utilizan en las industrias antes mencionadas.
Dado que el desarrollo de SS es una actividad humana existen muchas posibilidades de
cometer errores en el proceso de creación o Proceso de Desarrollo del Software, los
diagramas LUM permiten dar a conocer de forma precisa y ordenada los lineamientos
bajo los que se deberá diseñar el SS que permitirán conseguir un software de calidad,
41
que sea duradero, fácil de mantener y flexible al cambio por actualización. Además
LUM permite desarrollar el código del software de forma rápida, eficiente y con un
enfoque apropiado.
El LUM está compuesto por distintos elementos gráficos que se combinan para
construir diagramas. Debido a que es un lenguaje, trabaja con una sintaxis que le
permite combinar los elementos gráficos y llegar a la creación de los diagramas, la
finalidad de los diagramas es presentar diversas perspectivas de un sistema a las cuales
se les conoce como Modelo del Sistema de Software (MSS).
En la Ingeniería de Software existen diferentes tipos de diagramas LUM y el desarrollo
de una aplicación se recomienda la construcción de los siguientes [30]:

Diagrama de clases: las clases son elementos de la programación orientada a
objetos que representan una categoría o un grupo de cosas, en ellas se definen
atributos (propiedades) y acciones de la categoría que son representadas por la
clase.
Es posible considerar la clase Lavadora, una lavadora tiene atributos y
acciones, en la figura 3.1.1 se especifica cómo se puede representar la clase
Lavadora con sus atributos y acciones; en donde los atributos son: “marca”,
“modelo”, “número de serie” y “capacidad” y las acciones son: “agregar ropa”,
“agregar detergente” y “sacar ropa”.
Figura 3.1.1.Diagrama LUM de la Clase Lavadora
42
Las clases permiten que los Sistemas de Software simulen algún aspecto del
mundo real. Décadas de experiencia sugieren que es más sencillo desarrollar
SS que simulen aspectos del mundo cuando se representa a las cosas reales con
clases, porque es más fácil trabajar con ellas para los desarrolladores y
programadores de software.

Diagrama de objetos: los objetos son la instancia de una clase, una instancia
es una entidad que tiene valores específicos de los atributos y acciones de una
clase. Un objeto puede estar formado por otros objetos y en un Sistema de
Software los diagramas LUM modelan objetos de la realidad. La figura 3.1.2
muestra el diagrama LUM de un objeto llamado Mi Lavadora, el símbolo es un
rectángulo como el de una clase pero en este caso el nombre se encuentra
subrayado. El nombre de la instancia especifica se encuentra del lado izquierdo
de los dos puntos (:)y a la derecha, el nombre de la clase.
Figura 3.1.2. Diagrama LUM de un Objeto

Diagrama de casos de uso: un caso de uso es una descripción de las acciones
de un sistema desde el punto de vista del usuario final y son de gran
importancia cuando se requiere que el sistema pueda ser utilizado por usuarios
que no son expertos en computación. La figura 3.1.3 es el diagrama LUM de
casos de uso en donde la acción “Lavar ropa” que se encuentra en la clase
Lavadora es ejecutada por un usuario de la lavadora.
43
Figura 3.1.3. Diagrama LUM de Caso de Uso

Diagrama de estados: en un instante de tiempo un objeto puede encontrarse
en un estado particular. En la figura 3.1.4 se captura la realidad de los posibles
estados que tiene el objeto lavadora, los estados también pueden ser llamados
fases de un objeto. El símbolo que se encuentra en la parte superior de la figura
representa el estado inicial y el de la parte inferior el estado final.
Figura 3.1.4. Diagrama LUM de Estados
44

Diagrama de secuencias: los diagramas de clases y los de objeto de las
figuras 3.1.1 y 3.1.2 aparentan ser estáticos pero en un Sistema de Software
los objetos se encuentran en constante interacción con otras clases y en del
tiempo. El diagrama de secuencias muestra la relación de los estados de los
objetos en el tiempo.
En una lavadora se encuentran los componentes manguera de agua, tambor y
sistema de drenaje, los cuales pueden ser representados como objetos en un
diagrama LUM. Cuando un usuario oprime el botón lavar ropa la
programación del Sistema de Software de la lavadora invoca el caso de uso
Lavar ropa, con lo que se da por hecho que se han completado las operaciones
agregar ropa, agregar detergente y activar. Un ciclo de lavado esta se puede
describir mediante las siguientes secuencias:
1. El agua empezará a llenar el tambor a través de una manguera.
2. El tambor permanecerá inactivo durante cinco minutos.
3. La manguera dejará de abastecer agua.
4. El tambor girará de un lado a otro durante quince minutos.
5. El agua jabonosa saldrá por el drenaje
6. Comenzará de nuevo el abastecimiento de agua.
7. El tambor centrifugará girando.
8. El abastecimiento de agua se detendrá.
9. El agua del enjuague saldrá por el drenaje
10. El tambor girará en una sola dirección y se incrementara su velocidad
por cinco minutos.
11. El tambor dejará de girar y el proceso de lavado habrá finalizado.
Las secuencias anteriores se representan como un diagrama de secuencias en la
figura 3.1.5.
45
Figura 3.1.5. Diagrama LUM de Secuencias.
3.1.2. Proceso de Desarrollo del Software
La construcción de un SS que dará solución a un problema sigue un proceso llamado
Proceso de Desarrollo de Software (PDS), en el proceso de desarrollo se analiza el
problema y se diseña cuidadosamente la solución mediante la planeación de distintas
actividades y la relación de los productos de las mismas.
Con el uso de un proceso de desarrollo adecuado la construcción de sistemas software
se vuelve panificable y repetible, además de aumentarla probabilidad de obtener un
sistema con calidad. El PDS incluye cuatro etapas [17]:
46
ETAPA 1.- Identificación:
a) La identificación de los requerimientos del usuario
b) La identificación de las tareas del usuario
c) La identificación del ambiente de desarrollo de la Interfaz
ETAPA 2.- Análisis y creación de los escenarios para el usuario:
Definición de un conjunto de objetos y acciones de la interfaz.
ETAPA 3.- Creación de la plantilla para el diseño gráfico:
a) Definición de la colocación de los íconos
b) Definición de los textos descriptivos
c) Especificación de los títulos de las ventanas
d) Especificación de aspectos mayores y menores del menú, estos últimos
corresponden a opciones con un grado más alto de especificidad y
utilidad que se brindan al usuario.
ETAPA 4.- Desarrollo del prototipo:
Programación de la interfaz, en alguno de los siguientes Entornos de
Desarrollo Integrado (EDI) para Java: Sun One Studio, Eclipse,
NetBeans ,AnyJ, NetBeans, Sun Java Studio Creator, Borland JBuilder,
IBM Web Sphere Studio Application Developer.
3.2. Modelo Semi-formal para el Desarrollo de Software Educativo
(MSDSE)
La Interfaz Gráfica de Usuario que se desarrollará es un software educativo y los
lineamientos de la Ingeniería de Software no precisan una metodología para este tipo
47
de soluciones de software, por lo que se considera conveniente retomar elementos de la
propuesta metodológica planteada por Canales, que se muestra en la figura 3.1.
ETAPA 1.Arquitectura de
sistemas tecnológicos
para el aprendizaje
•a)Arquitectura
•b)Ciclo de vida doble
•c)Técnicas cognitivas
ETAPA 2.- Modelado
y desarrollo de la
herramienta
•a)Análisis
•b)Diseño o modelado
•c)Desarrollo
ETAPA 3.- Fase
operativa
•a)Instalación y
puesta en
funcionamiento
•b)Pruebas de
campo
MSDSE
Figura 3.1. Muestra de forma general la metodología propuesta por Canales [22].
Canales [22] propone un modelo de diseño instruccional, un modelo de desarrollo de
software y un sistema de desarrollo de eCursos, en su propuesta incluye tres etapas
para el Proceso de Desarrollo del Software que a continuación se describen:
ETAPA 1.- Arquitectura de sistemas tecnológicos para el aprendizaje:
a) Se refiere al diseño de una arquitectura para regular el desarrollo de sistemas de
Educación Basada en Web (Web-Based Education WBE) adaptables e inteligentes,
que responda a las necesidades tecnológicas y pedagógicas, se basa en el estándar
IEEE 1484 LTSA (Learning Technology Systems Architecture) y consta de cinco
capas que cubren el entorno del WBE: (1) Interacciones del ambiente y el
estudiante; (2) Características de diseño relacionadas con el estudiante; (3)
Componentes del sistema; (4) Prioridades y perspectivas de los participantes; y (5)
Codificación, APIs y protocolos.
48
b) Ciclo de vida doble que incorpora el modelo de diseño instruccional al modelo de
desarrollo de software para incluir actividades de análisis de dominio y desarrollo
de Componentes Reutilizables Orientados a Objetos (CROO), que son productos
para los grupos de aplicaciones. La integración de estas nuevas actividades en el
desarrollo de software educativo se facilitada si se considera que en el desarrollo de
cualquier asignatura orientado a la enseñanza, incluido el software educativo, ha de
llevarse a cabo un proceso de diseño instruccional. Este proceso implica un análisis
y estructuración del conocimiento que es objeto de la enseñanza.
c) Técnicas cognitivas, incluyen un análisis de los Mapas Conceptuales que pueden
aplicarse para el aprendizaje mediante un sistema de WBE. La finalidad de las
técnicas cognitivas es que el software colabore en la adquisición de conocimientos.
d) Análisis y modelado de medios para eCursos para el WBE consiste en un análisis y
modelado de eCursos para WBE,
los formatos de los medios utilizados
recomendados son: jpg (imágenes), mp3 (sonido), swf (animaciones) y flv
(video),se recomiendan estos formatos debido a que en México no se cuenta con un
gran ancho de banda.
ETAPA 2.- Modelado y desarrollo de la herramienta
a) Análisis. En el análisis de la herramienta se incluyen: estándares internacionales,
XML, conexión al servidor, composición dinámica y ancho de banda.
b) Diseño o modelado. Con base en el análisis de la herramienta se modela la solución
y se elaboran los diagramas de casos de uso, secuencia, clases, componentes,
estados, colaboración de la misma, con los atributos y funcionalidades requeridas
para la herramienta.
49
c) Desarrollo. Consiste en seleccionar una plataforma tecnológica (JavaBeans o
Microsoft.NET) para implementar la herramienta, buscando la compatibilidad entre
las diferentes tecnologías involucradas, con lo que se logra la interoperabilidad
entre la herramienta y el Servidor.
ETAPA 3.- Fase operativa
a) Instalación y puesta en funcionamiento. En esta etapa el autor describe que el
sistema será instalado y puesto en funcionamiento en un servidor que reúna las
condiciones básicas para su buen funcionamiento, seguridad, accesibilidad y
administración.
b) Pruebas en campo. Recomienda realizar pruebas para comprobar el buen
funcionamiento dela herramienta en el servidor y su acceso por Internet.
3.3.Diseño de la Interfaz Gráfica de Usuario como Applets de
Java(DIGUAJ)
A continuación se presenta la metodología propuesta para el diseño de la interfaz:
ETAPA 1.- Arquitectura del software
En el presente estudio se propuso el uso de dos arquitecturas, debido a que se
pretende que la IGU sea un recurso disponible en web. La arquitectura que se
presenta en el inciso “a” es la arquitectura que se utilizara para hacer que la IGU
esté disponible en web, para hacer disponible el recurso en web se usara la
tecnología Paginas de Servidor de Java (PSJ). La arquitectura que se presenta en el
inciso “b” es la arquitectura que se utilizara para crear los componentes y las
operaciones de la propia IGU.
50
a) Arquitectura Webapp: de los elementos de la Ingeniería de Software se retoma
la arquitectura Controlador Vista Modelo (CVM) de la cual se puede observar
un diagrama en la figura 3.2 [26].
Figura 3.2. Arquitectura Controlador Vista Modelo utilizado para hacer que la IGU se
encuentre disponible desde web [26].
b) Arquitectura orientada a objetos: De la metodología de Canales se retoma la
arquitectura de creación de Componentes Reutilizables Orientados a Objetos
[22] en donde la Ingeniería de Software indica que los componentes del sistema
incluyen datos y dentro de los componentes deben existir operaciones que
deben aplicarse para manipular los componentes del sistema y acceder a los
datos [17].
ETAPA 2.- Modelo de Desarrollo del Software
Se retomó de los lineamientos de Ingeniería de Software el análisis de
requerimientos de usuario y de la metodología de Canales [22] se retomó la etapa
de diseño o modelado y la de desarrollo:
51
a) Análisis de Requerimientos de usuario. En el análisis de requerimientos se
incluyen las siguientes preguntas [27]:

¿Quién usará la solución?

¿Cuál será el beneficio de la solución?

¿Qué problema resolverá la solución?

¿Cuál sería una buena salida Generada por la solución exitosa?
b) Diseño o modelado. Con base en el análisis de la herramienta es necesario
modelar la solución y realizar los diagramas de casos de uso, secuencia, clases,
componentes, estados, colaboración de la misma, con los atributos y
funcionalidades requeridas para la herramienta.
c) Desarrollo. Propone utilizar una plataforma tecnológica JavaBeans para
implementar la herramienta, buscando la compatibilidad entre las diferentes
tecnologías involucradas, con lo que se logra la interoperabilidad entre la
herramienta y el Servidor.
ETAPA 3.- Fase de Operación
a) Selección del servidor. Es necesario contar con la prestación de un servidor en
donde pueda instalarse la IGU como Applet de Java.
b) Instalación y puesta en funcionamiento. En esta etapa la solución será instalada
y puesta en funcionamiento en un servidor que reúna las condiciones básicas
para su buen funcionamiento, seguridad, accesibilidad y administración.
52
Capítulo4. Aplicación de la metodología (DIGUAJ)
4.1. Arquitectura del Software para la Interfaz Gráfica de Usuario
En el presente estudio se propuso el uso de dos arquitecturas, la primera es la
Arquitectura CVM que se mostró en la figura 3.2. La segunda es la Arquitectura
Orientada a Objetos para la que no existe un diagrama debido a que cada aplicación
orientada a objetos es diferente. En el DIGUAJ se elaboró el diagrama LUM de la
Arquitectura Orientada a Objetos y se muestra en la figura 4.1. Esta arquitectura consta
de seis paquetes de fuentes en donde para cada paquete existe un diagrama LUM.
Figura 4.1 Arquitectura Orientada a Objetos.
53
4.2. Modelo de Desarrollo de la Interfaz Gráfica de Usuario
a) Análisis de Requerimientos de usuario. En el análisis de requerimientos se
contestaron las preguntas planteadas por Gause D. y Weunberg [27]:

¿Quién usará la solución?
La solución de software será utilizada por alumnos que cursan la asignatura
de Teoría del Control II

¿Cuál será el beneficio de la solución?
El beneficio que la solución de software ofrece es propiciar una reflexión
en el estudiante para el análisis del diseño de compensadores PD mediante
la relación que existe entre la respuesta del sistema, el Lugar Geométrico
de las Raíces y la solución numérica del problema de diseño.

¿Qué problema resolverá la solución?
El problema que se pretende resolver es que en el salón de clases no se
cuenta con los recursos gráficos interactivos como los que proporciona una
computadora, además de que el tiempo es insuficiente para analizar una
gran variedad de casos durante una sesión.

¿Cuál sería una buena salida generada por la solución exitosa?
Una salida de la solución del software seria presentar en forma simultánea
la solución numérica, la gráfica del LGR y la respuesta del sistema en el
tiempo.
b) Diseño de la Interfaz Gráfica de Usuario.
El diseño de la IGU consta de una serie de diagramas de LUM. En la figura 4.2 se
muestra el diagrama de caso de uso en donde un usuario de la IGU proporciona a la
interfaz gráfica una función de transferencia de un sistema en lazo abierto.
En la figura 4.1 se mostró la arquitectura y en la figura 4.3 se describe a través de un
diagrama de clase el paquete Datos que contiene la clase Proporciona_Datos, la cual
54
se encarga de suministrar los métodos que permiten que el usuario ingrese los datos
una función de transferencia.
Figura 4.2. Diagrama de caso de uso para evaluar una función de transferencia, es un
caso del modelo de desarrollo del software.
55
Figura4.3. Definición del modelo de la claseProporciona_Datos del Paquete Datos.
De acuerdo a la figura 4.2 el usuario ingresa los datos a la IGU, una vez realizada esta
acción, los datos son enviados a la clase CompensadorPropuesto del paquete
Datos.Calculos en donde se realiza el cálculo numérico de la solución de
Compensadores PD. Lo anterior se puede observar en la figura 4.4.
En la figura 4.5 se puede observar el diagrama LUM de la clase Ajustes del Paquete
Datos.Calculos, que hereda operaciones a la clase CompensadorPropuesto del paquete
Datos.Calculos. Esta clase permite calcular los valores de la frecuencia natural no
amortiguada del sistema (
), la frecuencia natural amortiguada (
) y el factor de
amortiguamiento ( ).
Cuando se han calculado la frecuencia natural no amortiguada del sistema (
frecuencia natural amortiguada (
), la
) y el factor de amortiguamiento ( ), la clase
CompensadorPropuesto del Paquete Datos.Calculos, que hereda operaciones de la
clase Ajustes del paquete Datos.Calculos, calcula los ángulos que permiten posicionar
los polos propuestos en el LGR. La relación de herencia que existe entre las clases
CompensadorPropuesto y Ajustes se observa en la figura 4.6.
56
Para mostrar los resultados del método analítico al usuario se utiliza la clase
MuestraResultados del Paquete Resultados, que hereda operaciones de la clase
CompensadorPropuesto con la finalidad de disminuir el tiempo de procesamiento del
cálculo como se puede observar en la figura 4.7.
Finalmente en la figura 4.8 se puede observar la clase Frame_CompensadorPD del
Paquete MenuCompensadorPD, con esta clase se genera la instancia que finalmente
construye
la
IGU.
Esta
clase
está
compuesta
por
los
objetos
Menu:Frame_CompensadorPD, el area de texto JTextArea:Frame_CompensadorPD y
el objeto FrameGraficadelLGR:LGR que asu vez contiene un objeto JPanel en cual se
realiza el dibujo del LGR.
Figura 4.4. Definición del modelo de la claseEntrega_Datos del Paquete Datos, que
hereda operaciones de la clase CompensadorPropuesto del paquete Datos.Calculos.
57
Figura 4.5. Definición del modelo de la clase Ajustes del Paquete Datos.Calculos, que
hereda operaciones a la clase CompensadorPropuesto del paquete Datos.Calculos.
58
Figura4.6. Definición del modelo de la clase CompensadorPropuesto del Paquete
Datos.Calculos, que hereda operaciones de la clase Ajustes del paquete Datos.Calculos.
Figura 4.7. Definición del modelo de la claseMuestraResultados del Paquete
Resultados, que hereda operaciones de la clase CompensadorPropuesto que hereda
operaciones de la clase Ajustes del paquete Datos.Calculos.
59
Figura4.8. Definición del modelo de la claseFrame_CompensadorPD del Paquete
MenuCompensadorPD.
c) Desarrollo.
La plataforma de desarrollo gráfico de JavaBeans llamada Entorno de Desarrollo
Integrado (EDI) NetBeans. Es la plataforma que se eligió para el desarrollo debido a
las prestaciones que brinda para el desarrollo de aplicaciones con Java, además de ser
de código abierto y gratuito para uso tanto comercial como no comercial[25].
En la clasificación de software se ha mencionado que el software de desarrollo es
cualquier lenguaje artificial o programa de cómputo que se puede utilizar para definir
una secuencia de instrucciones, estas últimas serán procesadas por un compilador que
tiene la capacidad de traducirlas de un lenguaje a un código que comprende la
computadora. El EDI NetBeans se considera un software de este tipo, la figura 4.9
muestra la interfaz del mismo.
60
Figura 4.9. Interfaz de Usuario del EDI NetBeans.
El EDI NetBeans permite la organización de las instrucciones en distintos lenguajes de
programación como Java, C, C++, PHP, HTML entre otros. Aplicando la arquitectura
de la IGU que fue mostrada en la figura 4.1en el EDI NetBeansse presenta el resultado
que muestra el administrador de proyectos en la figura 4.10.
En la figura 4.1 se puedo observar que el nombre de la arquitectura de software es
CompensadorPD y como se puede observar en la figura 4.10 el nombre de proyecto
que se asignó en el EDI fue CompensadorPD. La arquitectura está contenida en el
Paquete de Fuentes como se puede observar en la figura 4.10.
El EDI NetBeans permite desarrollar la IGU de una forma sencilla mediante el uso de
paletas que contienen los elementos swing y awt de Java, los elementos solo deben
arrastrarse a un área de diseño, para activar esta función se debe de crear una clase del
tipo Formulario JFrame haciendo clic derecho sobre el paquete de la arquitectura que
contendrá la IGU, en este caso es el paquete MenuCompensadorPD como se muestra
en la figura 4.11.
61
De
acuerdo
con
la
figura
Menú:Frame_CompensadorPD,
el
4.8
la
cual
es
IGU
una
contiene
instancia
un
de
Objeto
la
clase
Frame_CompensadorPD y es el nombre que recibe la misma, como se observa en la
figura 4.12.
Figura 4.10. Arquitectura de la IGU desarrollada en el EDI NetBeans
Figura 4.11. Activación de creación rápida de una IGU en el EDI NetBeans
62
Figura 4.12. Asignación del nombre a la clase del tipo JFrame
Paleta de
Componentes swings
Área de Diseño
Paleta de
Componentes
awt
Figura 4.13. Área de diseño y paletas de componentes swing y awt.
63
Figura 4.14. Diseño Previo de la IGU
4.3. Fase de Operación
En esta fase se continuó con el uso del EDI NetBeans porque es versátil y permite el
desarrollo de código en diferentes lenguajes y como se mencionó se requiere
desarrollar código en JSP para lanzar la IGU como Applet de Java.
Las aplicaciones en lenguaje Java requieren de portabilidad para poder cargarlas en un
servidor, la generación de la portabilidad consta de la creación de un paquete tipo jar y
la generación de un archivo tipo jsp. Para crear el paquete jar se hace clic derecho
sobre el proyecto y se selecciona la opción Limpiar y Construir como se muestra en la
figura 4.14a. Cuando el proceso de creación del paquete jar es correcto, en el visor de
archivos del NetBeans se observa este paquete como se muestra en la figura 4.15.
64
Figura 4.14a. Creación del paquete tipo jar.
Figura 4.15. Paquete tipo jar desde la Vista de Archivos
Haciendo clic derecho sobre el ícono del archivo se accede a la opción propiedades, en
donde se observa el tamaño del archivo como se muestra en la figura 4.16. Es
necesario conocer el tamaño del archivo para definir la capacidad del servidor que
requerirá la aplicación.
Para dar portabilidad a la IGU se crea un proyecto web en el NetBeans, en este
proyecto se desarrollara la secuencia de código necesaria para que el paquete tipo jar se
ejecute desde internet como un Applet de Java. En la figura 4.17 se presenta la
creación del proyecto web después de seleccionar la opción proyecto nuevo del menú
Archivo.
65
Figura 4.16. Propiedades del paquete tipo jar.
Figura 4.17. Comienzo de creación de proyecto web en el EDI NetBeans
66
Al seleccionar el tipo de proyecto, que en este caso es de la categoría Java Web, tipo
Web Application como se observó en la figura 4.17, se selecciona el botón siguiente
para darle nombre al proyecto como se muestra en la figura 4.18, hasta este momento
se da por finalizado el proceso de portabilidad se selecciona el servidor.
Figura 4.18. Asignación del nombre al proyecto web.
a) Selección del Servidor.
Para el servicio web se selecciona un software de servidor. En la figura 4.19 el EDI
NetBeans demanda la selección de un software: Apache Tomcat o Glass Fish y la
versión de JavaEE que es compatible con el software del servidor. Después de la
selección se pulsa en Terminar para continuar con la creación del proyecto web.
Al dar clic en el botón Terminar que se mostró en la figura 4.19 el EDI NetBeans
muestra una página index.jsp como se observa en la figura 4.20 que será modificada
67
para invocar el paquete tipo jar, reemplazando las siguientes líneas 11 a 19, por el
siguiente código:
<html><head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<h1>Bienvenido a la IGU de Teoría de Control II como Applet de Java!</h1>
<center>
<appletcode="MenuCompensadorPD.Frame_CompensadorPD"
archive="CompensadorPD.jar"
width="900" height="590" />
</center></body></html>
La carga de la IGU como Applet de Java se lleva a cabo desde la página index.jsp.
Versión de JavaEE
compatible
Selección del
software de
servidor
Botón Terminar
Figura 4.19. Selección del software de servidor y de la versión de Java EE.
68
Figura 4.20. Página index.jsp
Se pulsa clic derecho sobre el proyecto web y se selecciona la opción propiedades, para
acceder al botón AddProject que vinculara el proyecto web con el proyecto de la IGU,
como se observa en la figura 4.21.
Nombre del proyecto
de la IGU vinculado al
proyecto web
Botón
AddProject
Botón
Aceptar
Figura 4.21. Vinculación de la IGU con el Proyecto web en NetBeans.
69
Durante las pruebas de la aplicación como web Application es necesario contar con el
cero por ciento de errores de código de programación de la Interfaz, de no ser así, el
EDI NetBeans no permite la ejecución de la página index.jsp en el explorador web.
4.4. Ejecución de la Aplicación
Al ejecutar el Applet se muestra la IGU de la figura 4.22, que incluye los objetos
descritos anteriormente en la figura 4.8; Menu:Frame_CompensadorPD, área de texto
JTextArea:Frame_CompensadorPD y el objeto FrameGraficadelLGR:LGR que a su
vez contiene un objeto JPanel en cual se realiza el dibujo del LGR.
Menu:Frame_CompensadorPD
Boton Graficar el
LGR que lanza el
Jpanel en donde
se dibuja el LGR
Área de texto en donde se
muestra el método analítico
Figura 4.22. Objetos de la figura 4.8 presentados en la IGU
Al hacer clic sobre el menú aplicaciones aparece una opción que permite ingresar datos
de una función de transferencia de la forma
( )
(
)
(figura 4.23) que se encuentra
70
en lazo abierto, en donde
( ) es una constante y b es un polo. La figura 4.24 muestra
la ventana en que se solicita al usuario que ingrese el valor del polo.
Figura 4.23. Muestra la opción de ingresar datos a la IGU
Figura 4.24.La IGU pide el valor del polo
71
Un ejemplo para mostrar la ejecución de la IGU consiste en solicitar un compensador
PD para la función de transferencia en lazo abierto
si se requiere que el
sistema en lazo cerrado cumpla con tiempo pico de 2 segundos y un máximo sobreimpulso de 5%.
En el apartado 1.1.2 del Capítulo 1, se describió como se obtiene la función de
transferencia de un sistema en lazo cerrado y que el método del LGR permite observar
el comportamiento del sistema en lazo cerrado cuando la función de transferencia a
analizar se encuentra en lazo abierto como es el caso de este ejemplo. En la figura 4.25
se puede observar la ventana que aparece para introducir los datos del problema.
Figura 4.25. Selección de la forma de Función de Transferencia que se desea introducir
a la IGU
72
En la figura 4.26 se solicita el valor del polo, de acuerdo a los datos dela FT el polo es
igual a 12.
Figura 4.26.Ingreso de un valor de polo
En la figura 4.27 la IGU solicita el siguiente valor; el máximo sobre-impulso.
Figura 4.27.Ingreso del valor del máximo sobre impulso
73
Posteriormente se solicita el tiempo pico y el coeficiente del numerador, como se
muestra en las figuras 4.28 y 4.29
Figura 4.28. Ingreso del valor del tiempo pico
Figura 4.29.Ingreso del coeficiente del numerador
74
En la introducción se mencionó que el conocimiento del Método del Lugar Geométrico
de las Raíces (LGR) y Compensación de Sistemas de Control significa, más que llegar
a la solución de problemas de diseño de compensadores en forma numérica, se trata de
entender los procedimientos matemáticos implícitos y la relación que existe entre las
soluciones numéricas, los recursos gráficos y el método analítico.
En la sección 1.1.2 se explicó con mayor detalle que una representación gráfica puede
ser de gran utilidad para entender cómo contribuye cada polo o cero en lazo abierto, a
las posiciones de los polos en lazo cerrado, y la forma en que los polos y los ceros en
lazo abierto se deben modificar para que la respuesta del sistema cumpla con un
comportamiento específico.
En este sentido la IGU brinda la posibilidad al estudiante de reflexionar en el método
analítico que se debe realizar para determinar la solución numérica del compensador
PD, como se muestra en la figura 4.30. También brinda un recurso gráfico para
observar el LGR cuando el usuario de la IGU haga clic en botón “Graficar el LGR”
como se observa en la figura 4.31.
Figura 4.30.Metodo de solución analítica del compensador PD
75
Figura 4.31. Solución Analítica del Compensador PD, Gráfica del LGR y los cálculos
realizados en el método analítico.
El análisis del método analítico y su relación con el LGR contribuye para una mejor
comprensión del diseño de compensadores Proporcional Derivativo (PD) en la
asignatura de Teoría del Control II.
El modelo de Software que se explicó en el apartado 4.2 del capítulo 4 es capaz de
ayudar a otros desarrolladores de software a generar un modelo de software flexible y
ajustable a cualquier asignatura que para su aprendizaje haga uso de recursos gráficos.
Debido a que cada asignatura tiene contenidos distintos y que en ocasiones no pueden
ser adaptados con facilidad, los que sí pueden ser adaptados deben cubrir
características como el uso de objetos gráficos utilizados en el aula y que por su
naturaleza se pueden adaptar con la finalidad de convertirse en una solución de
software educativo.
76
Conclusiones
.

El objetivo de este trabajo fue diseñar una Interfaz Gráfica de Usuario (IGU)
utilizando el lenguaje de programación Java como apoyo para el aprendizaje del
diseño de compensadores Proporcional Derivativo (PD) en la asignatura de Teoría
del Control II.

Se considera que un apoyo para el aprendizaje de este tema se encuentra en el
manejo simultáneo de una representación gráfica, el desarrollo matemático y la
teoría de control como se explicó en el primer capítulo en el apartado del LGR, lo
que se logró mediante una programación en Java, al desarrollar la Interfaz Gráfica
de Usuario que incluye estos elementos.

Durante el desarrollo de esta tesis se encontraron limitaciones de tipo
administrativo para el uso de los recursos informáticos con los que cuenta el
Instituto Politécnico Nacional, por lo que la portabilidad de la IGU la convierte en
una solución para el docente, ante las limitaciones en la gestión de los recursos
tecnológicos.

Se justificó la pertinencia de utilizar el lenguaje de programación Java para el
diseño de la IGU, tomando en consideración las ventajas que este ofrece, en
particular La portabilidad que facilita que cualquier usuario pueda ejecutar el
programa en cualquier lugar y desplaza la problemática de accesibilidad al software
debida a la limitación de los recursos tecnológicos con los que disponen las
instituciones de educación en general y los estudiantes en particular.

Es importante enfatizar que la interfaz gráfica se convierte en un recurso didáctico
al poder ser usada como un apoyo para el profesor de la asignatura, para que los
alumnos puedan reflexionar más sobre el tema una vez que el profesor lo haya
impartido. También puede ser utilizada por el estudiante como un recurso de
estudio en el hogar debido a que el código de programación creado con Java y
77
basado en un modelo de software brinda portabilidad a la IGU implementada
como Applet.

De la ejecución de la aplicación descrita en el apartado 4.4 del capítulo 4 se
concluye que la IGU ejecuta correctamente el método a analítico, determina
correctamente la solución numérica del diseño de un compensador PD y grafica
correctamente el LGR para la FT del sistema que se propuso, por lo que la IGU se
convierte en un recurso didáctico confiable para los usuarios así como un recurso
de verificación de resultados.

La metodología DIGUAJ es el resultado de cubrir la necesidad de tener una
metodología que permitiera resolver la creación de la IGU con el lenguaje de
programación Java, ya que no se encontró una metodología que involucrara los
aspectos didácticos, educativos y que además involucrara dicho lenguaje de
programación.
78
Recomendaciones

Al concluir este trabajo se vuelve necesario comprobar que la interfaz puede
brindar un aporte significativo a los estudiantes.

Con el presente trabajo de tesis se abre la posibilidad de hacer una prueba piloto
con estudiantes para verificar que la IGU sirva como un apoyo al estudio de los
temas de la unidad 1 y 2 de la asignatura de Teoría de Control II.

Es conveniente mencionar que si se quisiera mayor autonomía en el aprendizaje
del alumno, la IGU creada en el presente trabajo, deberá ser parte de un
proyecto de Portal Web, es decir la IGU es una de tantas herramientas que se
podrían integrar en una plataforma para el aprendizaje de la asignatura de
Teoría de Control II que además incluya documentos sobre teoría.

El diseño de compensadores no se limita a los compensadores PD, por lo que
un trabajo a futuro sería extender la aplicación al diseño de compensadores
Proporcional-Integral y al diseño de compensadores PID.
79
REFERENCIAS
[1]Dorsey J. Sistemas de Control Continuos y Discretos. McGraw-Hill, México, 2005.
[2]KuoB. Sistemas de Control Automático. Prentice Hall, México, 1996.
[3] Ogata, K. Ingeniería de Control Moderna. Pearson, Madrid, 2003.
[4] Campbell S. y Heberman R. Ecuaciones Diferenciales: problemas de valor de
frontera. McGraw-Hill, México, 1988.
[5]http://download.oracle.com/Javase/tutorial/getStarted/intro/index.html
Diciembre
2010.
[6]http://download.oracle.com/Javase/tutorial/getStarted/intro/definition.html
Diciembre 2010
[7]http://download.oracle.com/Javase/tutorial/getStarted/intro/cando.html
Diciembre 2010
[8]http://download.oracle.com/Javase/tutorial/getStarted/intro/changemylife.html
Diciembre 2010
[9] http://download.oracle.com/Javase/6/docs/index.html Diciembre 2010
[10] Deitel H. y Deitel P. Cómo Programar en Java. Pearson Educación, Quinta
Edición, 2010
[11]http://download.oracle.com/Javase/tutorial/deployment/applet/getStarted.html
Enero 2010
[12]http://download.oracle.com/Javase/tutorial/deployment/applet/index.html
Enero 2010
[13]http://www.cic.ipn.mx/anterior/oldsite/ogonzalez/Cursos/Java/index2.htmEnero
2010
[14]http://www.wordreference.com/es/en/frames.asp?es=bytecodeMayo 2011
[15]http://www.sitiosargentina.com.ar/Help/diccionario%20tecnico.htmMayo 2011
[16]http://www.sitiosespana.com/webmasters/diccionario_tecnico.htm Mayo 2011
[17]Pressman R. Ingeniería de Software Un Enfoque Práctico. MC-Graw Hill, 2010.
[18]http://www.specifications.ws Diciembre 2010
80
[19]http://sabia.tic.udc.es/gc/Contenidos%20adicionales/trabajos/Interfaces/enlightmen
t/definiciones_1.html Junio 2011
[20]http://www.cimat.mx/~jbhayet/CLASES/PROGRAMACION/slides/clase19.pdf
Junio 2010
[21] Oracle. Manual de JavaBásico. Sun MycroSystems 2010.
[22]Canales C. Un Modelo Semiformal Para El DesarrolloDe Software Educativo.
Centro de Investigación en Computación del Instituto Politécnico Nacional, Abril
2007.
[23] García Barneto, A. y Gil Martín. Entornos constructivistas de aprendizajebasados
en simulaciones informáticas. Revista Electrónica de Enseñanza de lasCiencias, Págs.
304-322. 2006.
[24] Esquembre F. EasyJavaSimulations. Applets aplicados a la simulación de eventos
físicos. 2008.
[25] http://netbeans.org/index_es.htmlseptiembre 2011.
[26]Krasner G. y Pope S. A Cookbook for Using the Model-View-Controller User
interface Paradigm in Smalltalk. Journal of Object-Oriented Programming, Vol. 1.
2001.
[27] Gause D. y Weunberg G. Exploring Requirements.1991.
[28] BouciguezM. y Santos G. Applets en la enseñanza de la física: un análisis de
lascaracterísticas tecnológicas y disciplinares. Universidad Nacional del Centro de la
Provincia de Buenos Aires, Argentina.2009.
[29]http://www.mitecnologico.com/Main/ClasificacionDelSoftwareSeptiembre 2011.
[30] Schumeller J. Aprendiendo UML en 24 horas. Prentice-Hill, 2004.
[31] Neumann L. Ingeniería de Software. Pearson Educación, 2005.
81
Apéndice A.
Código de Programación de la clase Frame_CompensadorPD del
Paquete MenuCompensadorPD.
82
/*
* Frame_CompensadorPD.Java
*
* Created on 23/06/2011, 12:53:27 PM
*/
packageMenuCompensadorPD;
/**
*
* @author FRANZ
*/
importResultados.MuestraResultados;
import Datos.*;
importHerramientas.Guardar_en_Archivo;
importGráfica cion.GráficaLGRJPanel;
importJava.util.logging.Level;
importJava.util.logging.Logger;
importJavax.swing.*;
importJava.io.*;
public class Frame_CompensadorPD extends Javax.swing.JFrame {
/** Creates new form Frame_CompensadorPD */
publicFrame_CompensadorPD() {
super("Herramienta de calculo para el LGR");
initComponents();
Gráfica LGRJPanelgráfica = new Gráfica LGRJPanel();
}
83
/** 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.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {
GráficaLGRJFrame = new Javax.swing.JFrame();
jScrollPane1 = new Javax.swing.JScrollPane();
jTextArea_Texto_Salida = new Javax.swing.JTextArea();
jToolBar1 = new Javax.swing.JToolBar();
jButton_Info_Extra = new Javax.swing.JButton();
jLabel1 = new Javax.swing.JLabel();
BotonGráficaLGR = new Javax.swing.JButton();
jMenuBar1 = new Javax.swing.JMenuBar();
jMenuAplicaciones = new Javax.swing.JMenu();
jMenuCompensadorPD = new Javax.swing.JMenu();
jMenuItemForma1 = new Javax.swing.JMenuItem();
jMenuHerramientas = new Javax.swing.JMenu();
jMenuItem_GuardarTexto = new Javax.swing.JMenuItem();
jMenuControles = new Javax.swing.JMenu();
jMenuItem_LimpiarArea = new Javax.swing.JMenuItem();
GráficaLGRJFrame.setDefaultCloseOperation(Javax.swing.WindowConst
84
ants.DISPOSE_ON_CLOSE);
Gráfica LGRJFrame.setTitle("Gráfica del Lugar Geometrico de las
Raices");
Gráfica LGRJFrame.setMinimumSize(new Java.awt.Dimension(400,
400));
Javax.swing.GroupLayoutGráfica LGRJFrameLayout = new
Javax.swing.GroupLayout(Gráfica LGRJFrame.getContentPane());
Gráfica LGRJFrame.getContentPane().setLayout(Gráfica
LGRJFrameLayout);
Gráfica LGRJFrameLayout.setHorizontalGroup(
Gráfica
LGRJFrameLayout.createParallelGroup(Javax.swing.GroupLayout.Align
ment.LEADING)
.addGap(0, 400, Short.MAX_VALUE)
);
GráficaLGRJFrameLayout.setVerticalGroup(
GráficaLGRJFrameLayout.createParallelGroup(Javax.swing.GroupLayout
.Alignment.LEADING)
.addGap(0, 300, Short.MAX_VALUE)
);
setDefaultCloseOperation(Javax.swing.WindowConstants.EXIT_ON_CL
OSE);
85
jTextArea_Texto_Salida.setColumns(20);
jTextArea_Texto_Salida.setRows(5);
jScrollPane1.setViewportView(jTextArea_Texto_Salida);
jToolBar1.setRollover(true);
jButton_Info_Extra.setText("Acerca del Programa");
jButton_Info_Extra.setFocusable(false);
jButton_Info_Extra.setHorizontalTextPosition(Javax.swing.SwingConstan
ts.CENTER);
jButton_Info_Extra.setVerticalTextPosition(Javax.swing.SwingConstants.
BOTTOM);
jButton_Info_Extra.addActionListener(new
Java.awt.event.ActionListener() {
public void actionPerformed(Java.awt.event.ActionEventevt) {
jButton_Info_ExtraActionPerformed(evt);
}
});
jToolBar1.add(jButton_Info_Extra);
jLabel1.setText("MetodoAnalitico");
BotonGráficaLGR.setText("Gráficar el LGR");
BotonGráficaLGR.addActionListener(new
Java.awt.event.ActionListener() {
public void actionPerformed(Java.awt.event.ActionEventevt) {
BotonGráficaLGRActionPerformed(evt);
86
}
});
jMenuAplicaciones.setText("Aplicaciones");
jMenuCompensadorPD.setText("CompensadorPD");
jMenuItemForma1.setAccelerator(Javax.swing.KeyStroke.getKeyStroke(J
ava.awt.event.KeyEvent.VK_P,
Java.awt.event.InputEvent.CTRL_MASK));
jMenuItemForma1.setIcon(new
Javax.swing.ImageIcon(getClass().getResource("/MenuCompensadorPD/i
cono_Poli.jpg"))); // NOI18N
jMenuItemForma1.setText("Forma K(c)/s(s+b)");
jMenuItemForma1.addActionListener(new
Java.awt.event.ActionListener() {
public void actionPerformed(Java.awt.event.ActionEventevt) {
jMenuItemForma1ActionPerformed(evt);
}
});
jMenuCompensadorPD.add(jMenuItemForma1);
jMenuAplicaciones.add(jMenuCompensadorPD);
jMenuBar1.add(jMenuAplicaciones);
jMenuHerramientas.setText("Herramientas");
87
jMenuItem_GuardarTexto.setText("Guardar en Archivo de Texto");
jMenuItem_GuardarTexto.addActionListener(new
Java.awt.event.ActionListener() {
public void actionPerformed(Java.awt.event.ActionEventevt) {
jMenuItem_GuardarTextoActionPerformed(evt);
}
});
jMenuHerramientas.add(jMenuItem_GuardarTexto);
jMenuBar1.add(jMenuHerramientas);
jMenuControles.setText("Controles");
jMenuItem_LimpiarArea.setText("Limpiar Area de Texto");
jMenuItem_LimpiarArea.addActionListener(new
Java.awt.event.ActionListener() {
public void actionPerformed(Java.awt.event.ActionEventevt) {
jMenuItem_LimpiarAreaActionPerformed(evt);
}
});
jMenuControles.add(jMenuItem_LimpiarArea);
jMenuBar1.add(jMenuControles);
setJMenuBar(jMenuBar1);
88
Javax.swing.GroupLayout layout = new
Javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(Javax.swing.GroupLayout.Alignment.LEADI
NG)
.addGroup(layout.createSequentialGroup()
.addGroup(layout.createParallelGroup(Javax.swing.GroupLayout.Alignme
nt.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addComponent(jToolBar1,
Javax.swing.GroupLayout.PREFERRED_SIZE, 150,
Javax.swing.GroupLayout.PREFERRED_SIZE))
.addGroup(layout.createSequentialGroup()
.addGap(21, 21, 21)
.addGroup(layout.createParallelGroup(Javax.swing.GroupLayout.Alignme
nt.LEADING)
.addComponent(jLabel1)
.addGroup(Javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()
.addComponent(jScrollPane1,
Javax.swing.GroupLayout.PREFERRED_SIZE, 343,
Javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(Javax.swing.LayoutStyle.ComponentPlacement.RELAT
ED, 40, Short.MAX_VALUE)
.addComponent(BotonGráficaLGR)))))
89
.addContainerGap())
);
layout.setVerticalGroup(
layout.createParallelGroup(Javax.swing.GroupLayout.Alignment.LEADI
NG)
.addGroup(layout.createSequentialGroup()
.addComponent(jToolBar1,
Javax.swing.GroupLayout.PREFERRED_SIZE, 25,
Javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(22, 22, 22)
.addComponent(jLabel1)
.addPreferredGap(Javax.swing.LayoutStyle.ComponentPlacement.RELAT
ED)
.addGroup(layout.createParallelGroup(Javax.swing.GroupLayout.Alignme
nt.LEADING)
.addGroup(layout.createSequentialGroup()
.addComponent(jScrollPane1,
Javax.swing.GroupLayout.PREFERRED_SIZE, 346,
Javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(31, Short.MAX_VALUE))
.addComponent(BotonGráficaLGR)))
);
pack();
}// </editor-fold>
private void
90
jMenuItemForma1ActionPerformed(Java.awt.event.ActionEventevt) {
MuestraResultados nuevo = new MuestraResultados();
nuevo.Bienvenida();
Proporciona_Datos polo=new Proporciona_Datos();
polo.PidePolo();
Proporciona_Datosmp =new Proporciona_Datos();
mp.PideMaximo();
Proporciona_Datos tiempo =new Proporciona_Datos();
tiempo.PideTiempoPico();
Proporciona_Datosgain =new Proporciona_Datos();
gain.PideGanancia();
//Comienzan los metodos para entrega de Datos de los
//calculos realizados por la computadora
MuestraResultados muestra = new MuestraResultados();
Proporciona_Datos a = new Proporciona_Datos();//Proporciona_Datos b =
new Proporciona_Datos();
jTextArea_Texto_Salida.setText("La funcion de transferencia introducida
fue: "
+"\n
+"\n
+"\n
"+a.getGananciaInicial()
------------------"
s(s+"+a.getPolo()+")\n"
+"Los calculos realizados son los siguientes:\n\n"
+muestra.Salida()+"\n\nPuedes copiar esta informacion y pegarla en tus
91
practicas.");
// TODO add your handling code here:
}
//fin delmetodo jMenuItemForma1ActionPerformed
private void
jMenuItem_LimpiarAreaActionPerformed(Java.awt.event.ActionEventevt
){
// TODO add your handling code here:
jTextArea_Texto_Salida.setText(null);
}
private void
jButton_Info_ExtraActionPerformed(Java.awt.event.ActionEventevt) {
// TODO add your handling code here:
String cadena ="Esta aplicacion fue creada con el proposito de ayudar a
los"+
"\nestudiantes de la Carreca de Control y Automatización" +
"\nen la comprobacion de calculos de compensadores
Proporcional_Diferencial" +
"\nbasados en el estudio del Lugar Geometrico de las Raices.\n\n\n\n " +
"\n°Este programa es libre de distribuirce a todos los alumnos de la "+
"\nCarrera de Control y Automatización" +
"\n°Queda completamente prohibida su venta o distribucion con fines
lucrativos" +
"\npor cualquier medio informatico o digital."+
"\n\n" +
92
"Esta aplicacion fue crada por Francisco Reyes Alumno de Dicha carrea"
+
"\nFecha de creacion de la aplicacion: 23 de Junio del 2010"+
"\nUltima Actualización:23 de Julio del 2010";
// JOptionPane.showMessageDialog(cadena, null, "informacion de uso",
JOptionPane.CENTER_ALIGNMENT);
JOptionPane.showMessageDialog(jMenuControles, cadena);
}
private void
jMenuItem_GuardarTextoActionPerformed(Java.awt.event.ActionEventev
t) {
// TODO add your handling code here:
Herramienta_Creador_de_Archivostxt();
}
private void
BotonGráficaLGRActionPerformed(Java.awt.event.ActionEventevt) {
// TODO add your handling code here:
ConstruccionGráfica(this.GráficaLGRJFrame);
}
//fin del metodo del jMenuItem un boton de herramienta
/**
* @paramargs the command line arguments
93
*/
public static void main(String args[]) {
Java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
newFrame_CompensadorPD().setVisible(true);
}
});
}//fin del main
publicvoidHerramienta_Creador_de_Archivostxt(){
Guardar_en_Archivo nombre = new Guardar_en_Archivo();
Guardar_en_Archivoselecruta = new Guardar_en_Archivo();
selecruta.Seleccionador_de_ruta();
Guardar_en_Archivonuevoarchivo = new Guardar_en_Archivo();
/*intnumerolineas= jTextArea_Texto_Salida.getLineCount();
String lineas;
for(int i=0; i<numerolineas; i++ ){
File f = new File(jTextArea_Texto_Salida.write(null));
lineas=jTextArea_Texto_Salida.getText();
}*/
String cadena=jTextArea_Texto_Salida.getText();
Stringnom = nombre.NombrarArchivo();
try{
nuevoarchivo.CrearArchivo(cadena,nom);
}
catch(FileNotFoundExceptionfnft){
JOptionPane.showMessageDialog(jMenuControles, "El archivo no se
94
pudo crear",
fnft.getMessage(), JOptionPane.ERROR_MESSAGE); }//fin del bloque
catch
catch (IOException ex) {
Logger.getLogger(Frame_CompensadorPD.class.getName()).log(Level.S
EVERE, null, ex);
}
}//fin del metodoHerramienta_Creador_de_Archivostxt()
// Variables declaration - do not modify
privateJavax.swing.JButtonBotonGráficaLGR;
privateJavax.swing.JFrameGráficaLGRJFrame;
privateJavax.swing.JButtonjButton_Info_Extra;
privateJavax.swing.JLabel jLabel1;
privateJavax.swing.JMenujMenuAplicaciones;
privateJavax.swing.JMenuBar jMenuBar1;
privateJavax.swing.JMenujMenuCompensadorPD;
privateJavax.swing.JMenujMenuControles;
privateJavax.swing.JMenujMenuHerramientas;
privateJavax.swing.JMenuItem jMenuItemForma1;
privateJavax.swing.JMenuItemjMenuItem_GuardarTexto;
privateJavax.swing.JMenuItemjMenuItem_LimpiarArea;
privateJavax.swing.JScrollPane jScrollPane1;
privateJavax.swing.JTextAreajTextArea_Texto_Salida;
privateJavax.swing.JToolBar jToolBar1;
// End of variables declaration
privatevoidConstruccionGráfica (JFrame Frame1){
try{
95
GráficaLGRJPanelPanelG = new GráficaLGRJPanel();
Frame1.add(PanelG);
Frame1.setVisible(true);}
catch(NumberFormatExceptionexcepcionFormatoNumero){
JOptionPane.showMessageDialog(this,
"Debe escribir dos enteros", "Formato de numero invalido
"+excepcionFormatoNumero.toString(),
JOptionPane.ERROR_MESSAGE );
Frame1.setVisible(false);
}
}//fin del metodoconstruccionGráfica
}
96