Post on 28-Dec-2015
description
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 75
CAPÍTULO 4
4.1. Introducción
Matlab permite desarrollar de forma sencilla un conjunto de pantallas con botones, menús,
ventanas, etc., que permiten utilizar de manera muy simple programas realizados en el entorno
Windows. Este conjunto de herramientas se denomina interfaz de usuario.
Para poder hacer programas que utilicen las capacidades gráficas avanzadas de Matlab hay
que conocer algunos de los conceptos que se explicaron en el capítulo anterior. Matlab dispone de
una herramienta GUIDE, que tal y como hemos visto, permite generar interfaces de usuario de una
forma simple y dinámica. De cualquier manera, es conveniente conocer los fundamentos de lo que
se está haciendo, de esta forma se podría modificar, incluso programarlo sin ayuda.
El desarrollo de la aplicación mediante GUIs se realiza en dos etapas:
• Diseño de los componentes (controles, menús y ejes) que formarán el GUI.
• Programación de la respuesta de cada uno de los componentes ante la interacción del usuario.
Una vez tenemos planificada la forma de la interfaz, guardamos el proyecto y el GUIDE
genera de forma automática un fichero .m que controla el funcionamiento del GUI. Este fichero .m
inicializa el GUI y contiene un marco para todos los callbacks del GUI (las órdenes que se ejecutan
cuando el usuario interactúa con un elemento del GUI). Usando el editor de MATLAB podremos
añadir código a los callbacks para realizar las funciones que queramos asignarles.
El beneficio que proporciona el uso de GUIs es evidente, ya que permiten al usuario ejecutar
cómodamente código desarrollado en MATLAB sin necesidad de cumplir la incómoda sintaxis
funcional necesaria cuando se trabaja desde la línea de órdenes. A diferencia de la ejecución de
funciones o scripts de MATLAB, la ejecución de GUIs no predetermina el flujo de ejecución del
código. Es el usuario, a través de su interacción con el GUI, el que determina el orden en que se
ejecutan los diferentes comandos y funciones desarrolladas. Otra diferencia importante es que la
ejecución no termina cuando finaliza la ejecución del script o función, sino que el GUI permanece
abierto, permitiendo al usuario invocar la ejecución de ese u otro código desarrollado.
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 76
4.2. Intercambio de datos entre el
archivo .fig el archivo .m
4.2.1. SENTENCIAS GET Y SET
La asignación u obtención de valores de los componentes se realiza mediante las sentencias
get y set. Por ejemplo, si queremos que la variable utpl tenga el valor del Slider1 escribimos:
utpl= get(handles.slider1,'Value');
Notar que siempre se obtienen los datos a través de los identificadores handles. Para
asignar el valor de la variable utpl al statictext etiquetada como text1 escribimos:
Set (handles.text1,'String',utpl); %Escribe el valor del Slider en static-text
Así, en general, para conocer el valor de un determinado elemento de la interfaz gráfica se
utiliza la función get que obtiene el valor de la propiedad especificada del elemento con identificador
“id”:
get(id, 'propiedad')
De la misma manera si se necesitara variar el contenido de una propiedad de un elemento
se haría con la siguiente instrucción:
set (id, ‘propiedad’, valor)
Estas instrucciones se utilizarán muy a menudo en las distintas funciones que se realizan en
la interfaz. Se pueden observar en los distintos ficheros .m y con diferentes funcionalidades como
pueden ser:
� Obtener el valor de una propiedad de un elemento para realizar una función concreta (ejemplo: establecer nuevos valores de tensiones y corrientes positivas y negativas en la fuente).
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 77
� Cambiar de color un elemento de la interfaz para resaltar alguna información (ejemplo: cuando se encienden y se apagan las fuentes de tensión positiva y negativa).
� Ocultar o hacer visible algún botón o característica concreta (ejemplo: cambiar la imagen de play a pause del toogle botton).
4.2.2. MANEJO DE DATOS ENTRE LOS ELEMENTOS DE LA APLICACIÓN Y EL ARCHIVO .M
Todos los valores de las propiedades de los elementos (color, valor, posición, string…) y los valores
de las variables transitorias del programa se almacenan en una estructura, los cuales son accedidos mediante
un único y mismo identificador para todos éstos. El identificador se asigna en:
handles.output = hObject;
handles, es nuestro identificador a los datos de la aplicación. Esta definición de identificador
es salvada con la siguiente instrucción:
guidata(hObject, handles);
guidata, es la sentencia para salvar los datos de la aplicación.
Nota: guidata es la función que guarda las variables y propiedades de los elementos en la estructura
de datos de la aplicación, por lo tanto, como regla general, en cada subrutina se debe escribir en la
última línea lo siguiente:
guidata(hObject,handles);
Esta sentencia nos garantiza que cualquier cambio o asignación de propiedades o variables
quede almacenado.
Por ejemplo, si dentro de una subrutina una operación dio como resultado una variable
nombre para poder utilizarla desde el programa u otra subrutina debemos salvarla de la siguiente
manera:
handles.nombre= nombre;
guidata(hObject,handles);
La primera línea crea la variable nombre a la estructura de datos de la aplicación apuntada
por handles y la segunda graba el valor.
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 78
4.2.3. PROGRAMACIÓN DEL FICHERO .M DEL GUI E INTERCAMBIO DE DATOS ENTRE CALLBACKCS:
4.2.3.1. Programación del fichero .m del GUI:
Después de diseñar el GUI, podemos programar el fichero .m asociado en el editor de
MATLAB. El GUIDE genera automáticamente este fichero a partir del diseño la primera vez que se
salva o ejecuta el GUI. El fichero .m del GUI se encarga de las siguientes tareas:
� Inicializa el GUI. � Contiene código para realizar las tareas necesarias antes de que aparezca el
GUI en pantalla, como la creación de datos o gráficos.
� Contiene las funciones callback que se ejecutan cada vez que el usuario hace clic en un componente.
Cada callback es una subfunción que inicialmente es sólo una definición de función vacía.
Nosotros debemos añadir código a los callbacks para proporcionarle operatividad al GUI.
4.2.3.2. Cómo compartir datos entre los Callbacks:
Podemos hacerlo almacenando los datos en la estructura handles. Todos los
componentes del GUI comparten la misma estructura handles. Todos los callbacks generados por el
GUIDE reciben esta estructura como argumento.
Para gestionar los Callback es preferible que se haga por medio de funciones que mediante
cadenas de caracteres que contengan comandos de Matlab. Esta es una idea importante a la hora
de programar con Matlab. Lo mismo se puede decir respecto a los ficheros de comandos *.m que no
son funciones: siempre será preferible utilizar funciones.
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 79
Las funciones de Matlab tienen su propio espacio de trabajo y la información necesaria para
realizar su tarea les llega por uno de los siguientes caminos:
� Por medio de los argumentos con los que se llama la función, que lo usaremos en las llamadas a distintas funciones aunque esto no se puede usar tan fácilmente para pasar parámetros entre distintos Callback.
� A través de variables globales (técnica que conviene evitar en la medida de lo posible).
� Es también posible que la propia función se las arregle para encontrar de alguna manera la información que necesita, bien buscándola en algún recurso (un fichero, una variable accesible) al que se tenga acceso, bien llamando a otras funciones que se la proporcionen.
En los Callback de Matlab hay que recurrir con mucha frecuencia a la tercera posibilidad: las
funciones tienen que buscar la información que necesitan y para ello lo que se ha hecho ha sido
inicializar las variables a un cierto valor en el inicio de la interfaz y guardarlo en un fichero *.mat.
Cuando se necesita el valor de esa variable en cualquier parte de la interfaz, se recupera la variable
mediante el comando load y si se varía el valor que tenía se salva mediante un save con lo que ya
tenemos el nuevo valor cargado para cuando se quiera utilizar de nuevo.
De esta manera se han creado todas las variables con las que se trabaja en la interfaz.
Como se necesitaron un gran número de variables eran muchos ficheros *.mat los que teníamos en
la carpeta del programa, lo que hicimos fue crear CloseRequestFcn(hObject, eventdata, handles) de
manera que cuando se cerraba la interfaz, se ejecutaba dicho callback cuya función es borrar uno a
uno los distintos ficheros que a su vez se generaron al iniciar el guide.
Cuando se ejecuta el GUI y el usuario hace clic en uno de los controles, como puede ser,
por ejemplo, un botón, MATLAB ejecutará el callback especificado por la propiedad Callback del
componente. A continuación de añadir el código deseado en la función es importante no olvidar
incluir la llamada guidata(hObject,handles), que hace que las modificaciones que hemos hecho
queden almacenadas.
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 80
4.3. Funciones empleadas para leer y
escribir en el equipo
4.3.1. Software de comunicación con la fuente
Las funciones que se han diseñado para intercambiar instrucciones directamente con la
fuente de tensión y poder así desarrollar de manera adecuada todo el entorno gráfico con múltiples
aplicaciones, son las siguientes:
� fuenteDC1 � fuenteDC2 � connect_fuenteDC � build_GPIB_object_fuente � send_command_ fuenteDC1 � send_command_ fuenteDC2 � send_query_ fuenteDC1 � send_query_ fuenteDC2
Destacamos que las funciones fuenteDC1 y fuenteDC2 son las principales, mientras que el
resto de las funciones son rutinas que se ejecutan mediante llamadas que se realizan desde las
funciones principales.
A continuación, se muestran las funciones principales (fuenteDC1, fuenteDC2):
function [V1med, I1med]=fuenteDC1(Vin_neg)
% build GPIB object
[StatusConnect,fuente] = connect_fuenteDC('GPIB');
% Canal 1, conseguimos tensiones negativas
[SentCommand] = send_command_fuenteDC1(fuente,Vin_neg);
[SentQuery,V1med,I1med] = send_query_fuenteDC1(fuente);
delete(fuente)
clear fuente
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 81
function [V2med, I2med]=fuenteDC2(Vin_pos)
% build GPIB object
[StatusConnect,fuente] = connect_fuenteDC('GPIB');
% Canal 2, conseguimos tensiones positivas
[SentCommand] = send_command_fuenteDC2(fuente,Vin_pos);
[SentQuery,V2med,I2med] = send_query_fuenteDC2(fuente);
delete(fuente)
clear fuente
A continuación, mostramos el código de las restantes funciones, que son las que realmente
establecen la comunicación entre el equipo y el PC.
% function [StatusConnect,fuente] = connect_fuenteDC(varargin)
% *************************************************************************
% This function returns an object for the remote instrument by means of the
% configuration information given by the user. Missing information is
% filled up with default values.
%%
% param protocol type of protocol used (GPIB)
% If protocol is GPIB:
% param ParamStruct.GPIB.board board number
% param ParamStruct.GPIB.primaddr primary address
% param ParamStruct.GPIB.secaddr secondary address (optional)
% return StatusConnect StatusConnect = 0, if object could not be created. StatusConnect = 1, if object was
%created successfully.
% return InstrObj The object which was created for the newly connected remote instrument.
%**************************************************************************
function [StatusConnect,fuente] = connect_fuenteDC(varargin)
StatusConnect = 0;
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 82
% default values:
ParamStruct.protocol = 'GPIB';
ParamStruct.GPIB.board = 0;
ParamStruct.GPIB.primaddr = 5;
% checking number of arguments
if (nargin <1)
fuente = build_GPIB_object_fuente(ParamStruct);
return;
end
% check if first argument is a string
if (ischar(varargin{1}) ~=1)
error('First Parameter must be a string defining the protocol type ''GPIB''');
end
% selecting protocol
switch (upper(varargin{1}))
case 'GPIB'
ParamStruct.protocol = 'GPIB';
otherwise
error('Protocol type must either be ''GPIB''');
end
% setting GPIB board address or build TCPIP object with given address or name
if (nargin > 1)
if (isequal(ParamStruct.protocol,'GPIB'))
ParamStruct.GPIB.board = checkint(varargin{2});
end
end
% set primary address of instrument
if (nargin > 2)
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 83
ParamStruct.GPIB.primaddr = checkint(varargin{3});
end
% set secondary address of instrument
if (nargin > 3)
ParamStruct.GPIB.secaddr = checkint(varargin{4});
end
% build GPIB object
[StatusConnect, fuente] = build_GPIB_object_fuente(ParamStruct);
A continuación, mostramos la función build_GPIB_object_fuente, que como su propio
nombre indica es dónde se incluyen las instrucciones adecuadas para construir el objeto fuente.
% % function - building a GPIB object
function [StatusConnect, fuente] = build_GPIB_object_fuente(ParamStruct)
try
if isfield(ParamStruct.GPIB,'secaddr')
fuente = gpib('agilent', ParamStruct.GPIB.board,
ParamStruct.GPIB.primaddr,'SECOND',ParamStruct.GPIB.secaddr);
fopen(fuente);
fclose(fuente);
else
fuente=visa('agilent','GPIB0::5::0::INSTR');
fopen(fuente);
fclose(fuente);
end
catch
disp('Object creation failed.');
fuente = 0; return
end
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 84
fuente.OutputBufferSize = 10000000;
fuente.InputBufferSize=8000;
StatusConnect = 1;
Destacamos, que las funciones que mostramos a continuación, son aquellas que nos
permiten escribir valores en el bus GPIB y enviárselos al equipo, estableciendo por tanto dicho valor
en la fuente de tensión.
% function [SentCommand] = send_command_fuenteDC1 (InstrObj,tension_1)
% *************************************************************************
% This function sends SCPI commands to remote instruments.
% @param InstrObj Object for remote instrument created by fuenteDC1
% @return SentCommand SentCommand = 0, if command could not be transmitted.
% SentCommand = 1, if command was sent successfully.
%**************************************************************************
function [SentCommand] = send_command_fuenteDC1(InstrObj,tension_1)
SentCommand = 0;
% open connection and send command
try
fopen(InstrObj);
fprintf(InstrObj, 'VSET 1, %6.2f\n', -tension_1);
fclose(InstrObj);
catch
disp('Could not open connection or write command. Recheck the connection settings.');
disp('Maybe there is already an open connection to the device.');
return
end
SentCommand = 1;
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 85
La siguiente función es completamente análoga a la anterior, sólo que está diseñada para
que nos podamos comunicar la fuente de tensión positiva:
% function [SentCommand] = send_command_ fuenteDC2 (InstrObj,tension_2)
% *************************************************************************
% This function sends SCPI commands to remote instruments.
% @param InstrObj Object for remote instrument created by fuenteDC2
% @param strCommand The SCPI command string.
% @return SentCommand SentCommand = 0, if command could not be transmitted.
% SentCommand = 1, if command was sent successfully.
%**************************************************************************
function [SentCommand] = send_command_fuenteDC2(InstrObj,tension_2)
SentCommand = 0;
% open connection and send command
try
fopen(InstrObj);
fprintf(InstrObj, 'VSET 2, %6.2f\n', tension_2);
fclose(InstrObj);
catch
disp('Could not open connection or write command. Recheck the connection settings.');
disp('Maybe there is already an open connection to the device.');
return
end
SentCommand = 1;
A continuación, mostramos las dos últimas funciones que hemos implementado para
interactuar directamente con la fuente de tensión. El código es muy similar al de la función
send_command, sólo que en este caso además de escribir en el bus GPIB también leemos del bus
mediante las instrucciones:
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 86
fprintf(InstrObj,'VOUT? 1');
vout1=fscanf(InstrObj,'%s');
% function [SentQuery,V1med,I1med] = send_query_fuenteDC1 (InstrObj)
% *************************************************************************
% This function is used to transmit queries to a remote instrument.
% @param InstrObj Object for remote instrument created by fuenteDC1.
% @return SentQuery SentQuery= 0, if query could not be transmitted.
% SentQuery = 1, if query was sent successfully.
%**************************************************************************
function [SentQuery,V1med,I1med] = send_query_fuenteDC1(InstrObj)
SentQuery = 0;
% open connection and perform query
try
fopen(InstrObj);
fprintf(InstrObj,'VOUT? 1');
vout1=fscanf(InstrObj,'%s');
V1med=str2num(vout1); % Vout_neg medida expresada en V
fprintf(InstrObj,'IOUT? 1');
iout1=fscanf(InstrObj,'%s');
I1med=str2num(iout1)*1e3; % Iout_neg medida expresada en mA
fclose(InstrObj);
catch
disp('Could not open connection or write command. Recheck the connection settings.');
end
SentQuery = 1;
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 87
La siguiente función es completamente análoga a la anterior, sólo que está diseñada para
que nos podamos comunicar la fuente de tensión positiva:
% function [SentQuery] = send_query_fuenteDC2 (InstrObj)
% *************************************************************************
% This function is used to transmit queries to a remote instrument.
% @param InstrObj Object for remote instrument created by fuenteDC2.
% @return SentQuery SentQuery= 0, if query could not be transmitted.
% SentQuery = 1, if query was sent successfully.
%**************************************************************************
function [SentQuery,V2med,I2med] = send_query_fuenteDC2(InstrObj)
SentQuery = 0;
% open connection and perform query
try
fopen(InstrObj);
fprintf(InstrObj,'VOUT? 2');
vout2=fscanf(InstrObj,'%s');
V2med=str2num(vout2); % Vout_pos expresada en V
fprintf(InstrObj,'IOUT? 2');
iout2=fscanf(InstrObj,'%s');
I2med=str2num(iout2)*1e3; % Iout_pos medida expresada en mA
fclose(InstrObj);
catch
disp('Could not open connection or write command. Recheck the connection settings.');
end
SentQuery = 1;
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 88
Como vemos, Matlab dispone de un grupo de comandos denominados de entrada/salida que
actúan sobre ficheros y permiten abrir y cerrar ficheros, leer y escribir en ficheros, controlar la
posición en un fichero y exportar e importar datos. En concreto, los comandos que hemos usado se
definen como:
fclose: Cierra uno o más ficheros.
fopen: Abre un fichero u obtiene información acerca de ficheros abiertos.
fprintf: Escribe datos formateados en un fichero.
fscanf: Lee datos formateados de un fichero.
En concreto, hemos empleado los comandos fprintf y fscanf para mandar instrucciones a la
fuente, que como sabemos son comandos de Entrada/Salida con formato.
En primer lugar, hemos establecido la conexión con el equipo mediante la llamada a la
función conect_fuenteDC, donde a su vez hacemos una llamada a la función
build_GPIB_object_fuente, dentro de la cual empleamos la instrucción:
fuente = visa('agilent','GPIB0::5::0::INSTR');
Ya que, como se vio en el apartado 2.4.2., con esta instrucción creamos el objeto visa que
mediante el bus GPIB, nos permite controlar el equipo.
Una vez establecida la comunicación mediante el bus GPIB entre el PC y el equipo, abrimos
un fichero con el que nos comunicaremos con la fuente, para ello usamos la función fopen:
fopen(InstrObj)
A partir de ese instante, ya podemos empezar a mandar las instrucciones mediante los
comandos fprintf (para mandar las instrucciones) y fscanf (para leer la información que mandamos
desde los dispositivos al PC). A modo de ejemplo:
fprintf(InstrObj, 'VSET 1, %6.2f\n', -tension_1);
Por último, es necesario cerrar el fichero para acabar la comunicación con el equipo.
fclose(InstrObj);
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 89
Además, hemos hecho uso de bifurcaciones mediante las sentencias TRY…CATCH…END.
La construcción try…catch…end nos permite gestionar los errores que se pueden producir en tiempo
de ejecución. Su forma es la siguiente:
try
sentencias 1
catch
sentencias 2
end
En el caso de que durante la ejecución del bloque de sentencias 1 se produzca un error, el
control de la ejecución se transfiere al bloque de sentencias 2. Si la ejecución transcurriera
normalmente, sentencias 2 no se ejecutaría nunca.
También, hemos empleado variables bandera para visualizar en la función principal de
llamada si el try se ejecuta correctamente en cada caso:
SentCommand = 1;
SentQuery = 1;
En caso contrario, permanecen a cero que es su valor de partida.
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 90
4.4. Aspectos generales de la
herramienta software implementada
En este apartado vamos a exponer soluciones a las que se ha llegado para problemas
puntuales que han ido surgiendo a lo largo del desarrollo del proyecto. Son detalles que pueden ser útiles para la realización de otra interfaz o para seguir trabajando sobre ésta.
Explicaremos cómo se han implementado en Matlab una serie de opciones que le hemos ido
añadiendo a la interfaz que la hacían más dinámica y más fácil de usar.
4.4.1. Introducir imagen en un icono
En la pantalla principal de la aplicación nos aparecen una serie de botones que nos permiten acceder a las distintas opciones implementadas en la interfaz:
� Ajustes/Configuración � Gráficas temporales � Barrido � Guardar resultados � Apagar el programa � Botones de cargar datos de las tensiones de entrada � Botones Pausar/Reanudar � Botones de ON/OFF para cada canal de la fuente � Botón OFF
Todos los botones mencionados son del tipo Push button, excepto los botones de ON para cada canal de la fuente que son del tipo Check box y los Botones Pausar/Reanudar que son del tipo Toogle button.
A su vez, si hacemos click en cada uno de estos botones del panel principal de la aplicación
veremos cómo emergen nuevas ventanas con muchas más aplicaciones, pero todo esto ya lo abordaremos en el siguiente capítulo.
Nuevamente destacamos las excepciones de los botones de ON para cada canal de la
fuente y de los Botones Pausar/Reanudar. Los primeros activan cada canal de la fuente de tensión, siendo el canal 1 para la fuente de tensión negativa y el canal 2 para la fuente de tensión positiva, el activar/desactivar cada canal implica varias salvedades que comentaremos en el apartado siguiente debido a la amplitud de aplicaciones que engloba. Los segundos sirven para pausar y reanudar la
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 91
actividad de los gráficos que se visualizan en la misma pantalla principal en tiempo real y que muestran el comportamiento de cada canal de la fuente.
Pues bien, no todos los botones de la pantalla principal tienen imágenes, muchos de ellos simplemente indican mediante texto la aplicación a la que se refieren. Otros sin embargo, como en el caso de los botones:
� Guardar resultados � Botones de cargar datos de las tensiones de entrada � Botón OFF � Pausar/Reanudar � Leds de encendido y apagado de cada canal de la fuente
Sí contienen imágenes intuitivas de su aplicación. En estos casos, para poner la imagen en el botón, tenemos que tenerla cargada en la carpeta donde se encuentran todos los ficheros de la interfaz. El formato que se ha elegido para las imágenes es el JPG, por ser un estándar muy conocido, ocupa poco espacio y es de una calidad buena.
Veamos mediante un ejemplo cómo hemos cargado las imágenes:
%ponemos a OFF los leds b = imread('led_rojo1.jpg'); %se lee la imagen y se carga en variable imagen set(handles.botonoff1,'Cdata',b); % carga la imagen en el elemento
correspondiente de la intefaz Esta misma filosofía se ha seguido a lo largo de la realización de toda la interfaz, intentando
poner una imagen en los botones que indiquen de forma visual lo que representan. A su vez también podemos poner una imagen como fondo del panel principal de la interfaz
de la siguiente manera:
axes(handles.axes1) a = imread('tech1.jpg'); image(a); axis off;
En nuestro caso también hemos colocado imágenes en los axes de los “displays”.
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 92
4.4.2. BOTONES PERSONALIZADOS
La interfaz gráfica de usuario de MATLAB nos permite personalizar la presentación de nuestros botones como lo muestra la figura siguiente.
Para lograr esto, procedemos como describíamos en el apartado anterior. Pero, para personalizar aún más, se puede hacer aparecer el nombre del botón cuando se
acerca el cursor, simplemente llenando el campo TooltipString en el Property Inspector. Veamos esta curiosa propiedad mediante un ejemplo de nuestra interfaz. Por ejemplo, para el botón de apagado de los dos canales de la fuente de tensión,
modificando correctamente en el Property Inspector:
Obtenemos, nuestro botón perfectamente personalizado:
Destacamos, que todos los botones de la interfaz gráfica están personalizados, para hacer aún más intuitivo el uso del programa creado al usuario.
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 93
4.4.3. Valores por defecto
Dada la gran amplitud de aplicaciones con las que cuenta la herramienta software que hemos creado, debemos destacar que a la hora de realizar cualquier medida entre bornas de la fuente para un transistor o cualquier otro dispositivo electrónico (adelantamos que en el capítulo 6 analizaremos en detalle varios casos de medida mediante el uso de este software), al arrancar la interfaz creada, ésta toma ciertos valores por defecto, valores que por supuesto hemos escogido pensando que para un primer contacto con la interfaz serían los más adecuados. No obstante la interfaz está diseñada de tal forma que permite al usuario de manera muy intuitiva cambiar estos valores si es necesario. Todo ello se ha diseñado con el fin de facilitarle al usuario lo máximo posible su trabajo en el laboratorio en las posibles medidas u otras aplicaciones que desee realizar ayudándose de esta potente y ampliable herramienta software.
A continuación, describiremos las partes de la interfaz donde entran en juego los valores por
defecto. Comenzamos:
En el panel principal de la herramienta software que hemos creado contamos con un botón llamado: Ajustes/ Configuración que da paso a una nueva ventana (un nuevo GUIDE), la cual se muestra a continuación:
Como puede verse, esta ventana nos da paso a escoger entre dos opciones:
� Valores límite � Tiempo de refresco
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 94
4.4.3.1. Valores límite
Si seleccionamos el primer Radio Button (Valores límite), emergerá una nueva ventana (un nuevo GUIDE):
La cual nada más abrirse muestra los valores por defecto que le hemos asignado tanto al voltaje como a la intensidad, de manera que si queremos modificar dichos valores establecidos a priori, bastará con que nos posicionemos en los cuadros de edición que nos convenga y una vez modificados los valores haremos clic en Aceptar. En ese momento el programa nos indicará las especificaciones de los valores límite de la fuente mediante el siguiente mensaje:
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 95
Para que podamos comprobar que efectivamente no sobrepasamos los valores límite del equipo. Aún así, tras esto el programa nos pedirá que nos reafirmemos y le aseguremos que queremos efectuar el cambio tal y como vemos:
No obstante, si recordamos en la ventana de Establecer Valores límite de tensión y corriente
había otro Push Button llamado Restablecer Valores, el cual tal y como su propio nombre indica nos permite en cualquier otro momento volver a cambiar los valores de tensión y corriente:
4.4.3.2. Tiempo de refresco
En el panel principal de control del software existen dos gráficos que se activan con los
Botones de ON (Check box) para cada canal de la fuente. Estos dos gráficos muestran en tiempo real el comportamiento en tensión del dispositivo que se encuentre conectado en ese momento a la fuente de tensión. Contamos un gráfico para cada canal de la fuente, de forma que el usuario pueda visualizar en cualquier instante el consumo que se produce en el dispositivo que se esté midiendo.
De esta forma, decidimos añadir a la interfaz gráfica el concepto de tiempo de refresco.
Mediante el tiempo de refresco, el programa actualiza cada 10 segundos todas las salidas de las que dispone, es decir, cada 10 segundos el programa lee del bus GPIB ambas salidas de la fuente (lee tanto el canal 1 como el canal 2), guardando en un buffer de memoria hasta 5 minutos del comportamiento del dispositivo que queramos estudiar, refrescando todas sus salidas cada 10 segundos. Por supuesto, durante el transcurso de estos 10 minutos el usuario puede modificar las tensiones positivas y negativas que quiera aplicar al dispositivo electrónico que decida medir, incluso puede variar el montaje, etc. Pero toda la potencia de aplicación que permite esto ya se irá exponiendo en los dos próximos capítulos.
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 96
Lo que más nos interesa saber del tiempo de refresco además de lo ya comentado, es que los gráficos temporales de voltaje del panel principal se refrescan cada 10 segundos por defecto, es decir, cada 10 segundos, el programa lee del bus GPIB los nuevos valores de salida de tensión y corriente de ambos canales de la fuente o bien sólo de uno de ellos, según guste el usuario.
Por tanto, durante el desarrollo de una medida puede resultarle bastante útil al usuario ver
estos cambios de lectura con más dinamismo y rapidez por diversos motivos (ya veremos en el capítulo 6 hasta qué punto nos benefició el hecho de poder modificar la lectura de las salidas de la fuente positiva y negativa).
Pero, ¿cómo podemos variar el tiempo de refresco del programa? Como el resto de
aplicaciones desarrolladas, es muy sencillo. Veámoslo, mediante un ejemplo:
1. Pulsamos el botón de Ajustes/Configuración de la pantalla principal del programa,
entonces emergerá una nueva ventana (nuevo GUIDE).
2. Seleccionamos el Radio Button de Tiempo de refresco en esta nueva ventana.
3. Tras esto, inmediatamente nos aparecerá en la pantalla el siguiente mensaje:
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 97
Como vemos, el propio software nos avisa de que el tiempo de refresco
preestablecido es de 10 segundos, y nos da la opción de poder modificarlo o bien
mantenerlo.
4. Consideremos el caso en que queramos modificar el tiempo de refresco a 2 segundos, entonces pulsaremos Sí y nos aparecerá la siguiente ventana:
Donde como vemos, ya hemos introducido el nuevo valor de refresco deseado.
5. Por último, sólo hace falta pulsar el OK y se modificará esta opción en todo el software.
Destacar, que el usuario podrá modificar sin problemas el tiempo de refresco tantas veces
como lo prefiera.
4.4.4. Explorador de Windows
Un objetivo que se ha tenido siempre presente en este trabajo era que el resultado debería ser algo fácil de manejar y muy intuitivo. Resulta interesante ver cómo crear con Matlab un Browser o Explorador para distintas funciones que se realizan en la interfaz como pueden ser seleccionar una carpeta para guardar las medidas realizadas, o bien seleccionar una carpeta para cargar algún tipo de fichero como puede ser el de un barrido realizado anteriormente para generar gran multitud de gráficos.
Las instrucciones para generar un browser en Matlab son las siguientes:
directoryname = uigetdir('c:\MATLAB6p5\work'); handles.directorio=directoryname; guidata(hObject,handles)
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 98
Figura1. Browser de Windows
De esta manera en la variable directorio se tiene la dirección que el usuario ha elegido siguiendo la ruta en el browser mediante el ratón que resulta más cómodo.
4.5. Interfaz de la fuente de tensión
En este apartado vamos a ver todos los conceptos que se han tenido en cuenta a la hora de
programar la funcionalidad de la fuente de tensión. Ello implica que veremos también todos los problemas a los que tuvimos que enfrentarnos en el diseño de algunas de las peculiaridades de la herramienta software y cómo conseguimos darles una solución lo más acorde posible a las necesidades que se nos plantearon. Asimismo, comentaremos también las limitaciones del software y dejaremos abierta la posibilidad de subsanar dichas limitaciones en futuras investigaciones.
La forma de mandar instrucciones al equipo es la misma que previamente se comentó en el
capítulo 2 (ver apartado 2.4.2). Para ver las distintas instrucciones que se pueden mandar a la fuente nos remitimos al anexo 3 y al apartado 2.5 del capítulo 2.
4.5.1. Programación del encendido y apagado de la fuente
Un aspecto importante a controlar es el encendido y apagado de la fuente de tensión, porque se puede dar el caso de quedar encendida la fuente y conectar manualmente otro dispositivo
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 99
que no acepte los valores cargados, dañándose por tanto el equipo. Por tanto, veremos cómo se ha intentado evitar esto.
En primer lugar, al iniciar la herramienta software, una de las primeras funciones que se
ejecuta de forma automática es el poner ambos canales de la fuente de tensión a ‘0’ voltios, que es lo que entenderemos por apagar la fuente, ya que el apagado total se debe hacer de forma manual en el botón ON/OFF del propio equipo. Es decir, al iniciar la herramienta software mandamos ‘0’ voltios a la fuente escribiendo en el bus GPIB, mediante las llamadas a las funciones principales vistas en el apartado 4.3 de este mismo capítulo. Así, para poner a cero la fuente de tensión basta con indicar:
fuenteDC1(0) fuenteDC2(0)
De esta forma ya tenemos a cero tanto la fuente de tensión positiva como la negativa, con lo
que consideramos ambas fuentes apagadas.
4.5.1.1. Opciones software para el apagado del equipo
Dada la complejidad en el diseño de nuestra herramienta, existen varias formas de apagar la fuente de tensión, las cuales desglosamos a continuación:
1. Mediante el uso de los botones de ON/OFF para cada canal de la fuente:
De esta forma, mediante el uso de ambos Check box podemos gestionar de forma independiente el encendido y apagado de cada canal de la fuente de tensión.
Tal y como podemos ver en la siguiente figura basta con deseleccionar los
botones para apagar el/los canales que nos interesen.
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 100
2. Botón OFF:
Tal y como su propio nombre indica este botón nos permite apagar el equipo, más concretamente si hacemos clic sobre este botón apagamos los dos canales de la fuente de tensión, reseteando todos los valores de las variables leídas del quipo mediante el bus GPIB. Además de producirse un apagado del equipo (entendiendo por apagado del equipo el poner a ‘0’ voltios ambos canales de la fuente de tensión) y un reset de todas las variables leídas de la fuente, también se produce un cambio en la apariencia física de la interfaz, ya que este botón produce un OFF automático de ambos displays de la interfaz así como de los cuadros de edición y una puesta en rojo de ambos leds.
3. Mediante el botón de Apagar el Programa:
Como se intuye al pulsar este botón se cierra el programa completamente (muy similar al apagado del propio Windows).
Cerrar el programa significa entre otras cosas el apagado completo del equipo conectado al PC y, por supuesto de toda la interfaz software.
4.5.2. Chequeo de los valores introducidos en la fuente
Previamente a la conexión de cualquier dispositivo externo a la fuente sobre el que queramos realizar una medida, hemos de establecer los valores límites tal y como se expuso en el apartado 4.4.3.1. Ahora bien, la fuente de alimentación posee sus propios valores de tensión límites, los cuales vienen dados por el propio fabricante del equipo, por tanto, hemos de trabajar siempre respetando el máximo y el mínimo valor de tensión que admite la fuente de alimentación.
Como la fuente de alimentación con la que estamos trabajando posee dos canales, los
cuales hemos destinado a la programación de dos fuentes de alimentación, una positiva y otra negativa, tendremos que controlar los valores que introduzca el usuario en ambos casos.
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 101
Así, hemos diseñado el software de tal forma que si el usuario introduce cualquier valor de tensión positiva o negativa que sobrepase los límites superior e inferior dados por el fabricante del equipo, nuestro software genera un ERROR, de manera que el valor de tensión introducido por el usuario en la interfaz no es enviado a la fuente de tensión a través del bus GPIB.
Para una mayor claridad, veamos un diagrama de flujo que nos resume cómo se gestiona el
chequeo de los valores de tensión de entrada en la interfaz para el caso de la fuente de tensión negativa (el caso de la fuente de tensión positiva es análogo):
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 102
Primero, ponemos la fuente a 0V en los casos en los que el valor de tensión que ha introducido el usuario no sea correcto. Para notificárselo al usuario, en la casilla donde introdujo el valor de tensión de entrada aparece un mensaje que pone ERROR. Con lo que el usuario debería de introducir un valor correcto de tensión antes de continuar con la medida.
El diagrama de flujo se corresponde con el canal 1 del equipo (fuente de tensión negativa),
por tanto, comprobamos que se cumple –V1med<Vmin_neg y hacemos otras comprobaciones. Como comentábamos el diagrama de la fuente 2 es similar pero teniendo en cuenta que se le exigen valores positivos (Vin_pos>0) y las comprobaciones se harán con V2med.
.
De igual manera, la protección en corriente es una opción que tiene la fuente de tensión que hace que si el valor de corriente supera al que tiene establecido la protección de corriente, se pone la fuente a 0, de tal manera que se evita dañar el dispositivo. La protección en corriente se aplica cada vez que se emplea el software ya que hemos tenido en cuenta esta opción en el diseño de la herramienta.
4.6. Displays
La herramienta software que hemos diseñado dota al cuadro de mandos de control de la
fuente de dos displays o gráficos temporales que representan en todo instante el valor leído de la fuente de tensión.
La interfaz goza de dos displays, uno para cada canal de la fuente, asegurando por tanto al
usuario un gran dominio sobre la lectura de la medida que esté realizando en el laboratorio. Cada display tiene asociado un botón de Pausar/Reanudar implementado mediante un
toogle button, además del propio botón de iniciar el funcionamiento de la fuente (el check box de ON/OFF de cada canal).
4.6.1. Funcionamiento de los displays Cada uno de los displays se activa al hacer clic en el botón ON de la fuente
correspondiente. Su uso es muy intuitivo, tan sólo tienen algún matiz que detallaremos a continuación. Aún así, la propia interfaz siempre le indica al usuario cómo actuar. Veámoslo con detalle:
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 103
Figura 2. Cuadro de mandos principal Cada uno de los displays arranca nada más hacer clic en el botón ON del canal de la fuente
que desee activar el usuario. A partir de ese instante, los displays aparecen activos en los cuadros de edición correspondientes al canal seleccionado y por supuesto, el display muestra un valor constante de ‘0’ voltios frente al tiempo en todo momento ya que como sabemos al arrancar el software se pone a ‘0’ voltios el equipo, como ya se vió en el apartado 4.5.1.
Cada display, se refresca cada 10 segundos por defecto (a menos que el usuario lo
modifique), por tanto, el programa lee el valor de tensión correspondiente a cada uno de los canales de la fuente para poder mostrarlo por pantalla.
En la siguiente figura podemos ver el comportamiento que acabamos de describir:
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 104
Para el diseño de los displays hemos hecho uso de axes y no de figures. Veamos el porqué. Cuando nos enfrentamos al diseño de los displays, partimos de la idea de que queríamos
implementar unos gráficos temporales asociados a cada canal de la fuente, los cuales fuesen capaces de representar en todo instante de tiempo el valor de tensión leído a través del bus GPIB para cada caso, es decir, queríamos que nada más hacer clic en el botón de ON de cada canal de la fuente, ya fuese la de tensión positiva y/o negativa, pudiésemos ver el comportamiento temporal de la tensión de forma independiente para cada canal mediante el uso de dos gráficos distintos y, que por supuesto al apagarse cada uno de los canales de la fuente también se apagasen los displays.
Pues bien, ha sido todo un reto el implementar estos displays en el GUIDE principal de
nuestra herramienta software, ya que para generar un gráfico temporal de estas características Matlab ya posee SIMULINK.
De hecho investigamos si sería factible el importar datos desde nuestra herramienta
software a Simulink, también intentamos el uso de simulink desde matlab con la creación de modelos (sistemas), etc; pero fue imposible de implementar de esta forma, ya que optásemos por una opción u otra no conseguíamos hacer el uso del display transparente al usuario que era una de las premisas de las que partíamos. Era demasiado engorroso tener que abrir esta herramienta de Matlab aparte de nuestro propio software, el tener a ambos abiertos en pantalla e intercomunicándose entre sí era inviable.
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 105
Nosotros queríamos que esta herramienta ayudase al máximo al usuario en su trabajo en el laboratorio, facilitándole todo lo posible su labor y no complicándosela aun más. Por ello, durante el diseño de estos gráficos también descartamos totalmente el uso de figures, ya que las características de un figure no permiten en absoluto la implementación que deseábamos, dado que sólo admiten representaciones estáticas de una función. Por tanto, la única opción viable era usar un axes.
Pero, la toma de esta decisión, rápidamente nos condujo a numerosas complicaciones,
porque el hecho de poner no uno, sino dos axes en el cuadro de mandos principal funcionando a la vez implicaba innumerables problemas de ejecución del software. Citaremos algunos de ellos:
1. En primer lugar, si recordamos la jerarquía de objetos gráficos de Matlab expuesta en el capítulo 3, podemos ver que tanto los controles (botones), los ejes (axes) y los menús están al mismo nivel jerárquico, es decir, todos tienen la misma prioridad durante la ejecución de un programa incluido por supuesto en una misma ventana, y éste por supuesto, era nuestro caso. Teníamos dentro de una misma ventana más de una decena de controles y además pusimos dos ejes, que tenían que empezar a ejecutarse como resultado de una invocación realizada desde uno de estos controles y, adicionalmente tenía que permitir también que el usuario pudiese invocar cualquier otro de los controles que teníamos implementados en nuestro cuadro de mandos principal. Todo un reto, que pudimos solucionar.
Figura 3. Jerarquía de objetos gráficos de Matlab
2. Queríamos tener ambos axes interactuando a la vez. Esto fue imposible de
solventar del todo, pero aún así el resultado obtenido ha sido muy bueno.
Vamos a ver las soluciones a las que llegamos y cómo lo hicimos viable:
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 106
Dada la gran cantidad de problemas a los que nos enfrentábamos sin obtener buenos resultados, al principio, nos planteamos incluso el generar dos nuevos GUIDES a partir del cuadro de mandos principal, para que así jerárquicamente los dos nuevos axes fuesen objetos hijos de algún objeto padre del cuadro de mandos principal y no interfiriesen a los controles del mismo. Pero esta idea no era la solución óptima debido a que implicaba que el usuario tendría que tener tres GUIDES (ventanas) a la vez abiertos cada vez que decidiese ejecutar el programa.
Finalmente, tras numerosas investigaciones se nos ocurrió una idea novedosa que permitía al usuario un uso totalmente transparente de la aplicación diseñada, minimizándole las molestias y permitiéndole aprovechar al máximo todo el potencial del software diseñado.
La gran respuesta al problema fue el uso de muchas variables globales, ya que
como sabemos una variable definida como global en el interior de una función es accesible separadamente para el resto de las funciones y para el espacio de trabajo base línea de comandos. Si la variable global no existe, la primera vez que se define en la sentencia GLOBAL, se inicializará como la matriz vacía. Si ya existe una variable con el mismo nombre que la que se está definiendo como global, MATLAB emite un mensaje de peligro y cambia el valor de la variable a enlazar como global.
No obstante, para evitar errores en la ejecución de un software tan complicado como
el nuestro siempre se recomienda el no usar variables globales. Pero, dado que no teníamos otra alternativa hemos optado por usar estas variables.
Para prevenir errores adicionales de ejecución, hemos hecho que todos los controles
del cuadro de mandos principal que podían interferir con la ejecución de los displays, puedan ver las variables globales.
Las únicas funciones del cuadro de mandos principal que son capaces de modificar
los valores de las variables globales que se han empleado son las siguientes:
� Activar_fte_pos_Callback (asociada al botón ON de la fuente positiva) � Activar_fte_neg_Callback (asociada al botón ON de la fuente negativa) � Pause_play_pos_Callback (asociada al botón Pausar/reanudar de la fuente
positiva) � Pause_play_neg_Callback (asociada al botón Pausar/reanudar de la fuente
negativa) � Salir_Callback (asociada al botón OFF)
Así, en el interior de la función Activar_fte_pos_Callback, al comienzo de dicha
función, tenemos definidas:
global Activar_fte_pos Activar_fte_pos=1;
global parada
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 107
parada=1; global fte_pos global fte_neg fte_neg=1;
Mientras, que al final de la misma función tenemos:
Activar_fte_pos=0; fte_neg=0;
Análogamente, en el interior de la función Activar_fte_neg en su comienzo, tenemos:
global Activar_fte_neg Activar_fte_neg=1; global fte_pos fte_pos=1; global fte_neg global detener detener=1;
Y al final de esta función tenemos:
global Activar_fte_neg Activar_fte_neg=0; fte_pos=0;
Como se puede intuir, lo que hemos hecho es usar estas variables como variables bandera, para que no se interfieran los controles con los ejes. En el resto de las funciones nos encontramos códigos similares donde cambiamos los valores de las variables globales bandera que nos interesen o simplemente los cargamos únicamente con el pretexto de leer si dichas variables están activas o no, para saber qué parte del código de la función en cuestión debemos ejecutar.
4.6.2. Botón Pausar/Reanudar
Cómo ya se comentó en apartados anteriores se trata de un toogle button, con la
siguiente apariencia física:
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 108
Decidimos poner un toogle button para ahorrarnos el poner dos push button, ya que
necesitábamos un botón que nos permitiese parar el funcionamiento del display y otro que
nos permitiese reanudar su funcionamiento, independientemente de que el /los canales de la
fuente se encontrasen activos, ya que si un canal de la fuente se encuentra activo significa
que se están leyendo los valores de salida del equipo cada t segundos.
4.6.3. Cómo actúan los displays si están activos ambos canales de la fuente
El único problema que no ha podido solucionarse al desarrollar la herramienta software es
tener a ambos displays refrescándose a la vez, cuando se encuentren activos ambos canales de la
fuente de alimentación.
Es decir, cuando el usuario activa un canal de la fuente de alimentación (por ejemplo, la
fuente de tensión positiva), inmediatamente empieza a funcionar el display asociado a dicho canal,
pero si en ese mismo momento, el usuario decide activar también el otro canal de la fuente (por
ejemplo, la fuente de tensión negativa), porque desee por ejemplo ver el comportamiento de un
transistor en concreto, pues no podrá tener a ambos displays refrescándose a la vez en el cuadro de
mandos principal, debido a la jerarquía de objetos gráficos de Matlab, donde tendrá prioridad el
display correspondiente al último canal de la fuente que haya sido activado por el usuario.
Dado que el usuario puede no recordar esta premisa cuando se ponga a medir cualquier
dispositivo en el laboratorio o incluso desconocerla, hemos dotado al software de unos avisos que
emergen en pantalla cuando sea necesario.
Así, si por ejemplo el usuario activa primero el canal positivo y luego activa el canal negativo,
visualizará en pantalla el siguiente aviso:
Como podemos ver, el aviso es muy claro, si el usuario quiere volver a ver en tiempo real cómo varía la tensión positiva debe pausar el último display activado, que en este caso se corresponde con la fuente negativa, es decir, tendría que pausar el display negativo. Ahora bien, si el usuario, por el contrario lo que quiere es dejar de ver el comportamiento en tiempo real de la fuente
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 109
de tensión positiva y pasar a observar en pantalla principal el comportamiento de la fuente de tensión negativa, entonces tendría que pausar el display de la positiva (o incluso no hacer nada, ya que el último display que empieza a funcionar es el que posee la prioridad de ejecución). Veamos cómo sería la apariencia del cuadro de mandos principal en el instante en que
estando la fuente positiva ya activa, el usuario introduce un valor de tensión negativo, activando el
segundo canal de la fuente (y, por tanto, el display negativo):
Análogamente, en el caso en que estuviese activa la fuente de tensión negativa y el usuario
decidiese introducir un valor de tensión positivo en el otro canal de la fuente de alimentación emergería el siguiente aviso:
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 110
Es decir, a partir de ese instante el usuario sólo puede ver el comportamiento en tiempo real de la tensión positiva frente al tiempo (por ser el último canal en activarse el positivo). Si el usuario desea volver a ver en tiempo real cómo cambia el comportamiento de la tensión negativa frente al tiempo, tendrá que pausar el display positivo, o bien, si desea continuar viendo cómo varía el comportamiento de la fuente de tensión positiva, debería de pausar el display de la fuente de tensión negativa para evitar errores de ejecución.
Ahora vemos la importancia del botón Pausar/Reanudar, ya que nos permite Activar/Desactivar en cualquier momento el display que deseemos o incluso desactivar ambos displays, ya que queramos o no los displays empiezan a correr nada más activar cualquier canal de la fuente de alimentación. Recordemos además, que los displays deben ayudar al usuario en su labor en el laboratorio y no complicársela aún más. Y, el software que hemos diseñado, aunque los displays estén pausados, no deja de leer valores de salida continuamente de la fuente de alimentación a través del bus GPIB, ya que hemos dotado al programa de un gran potencial de representación gráfica. Así, desde que se activan los canales de la fuente se empiezan a almacenar todos los valores de salida leídos desde la fuente de alimentación en unos buffers de memoria que posteriormente podemos
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 111
jugar a visualizar frente al tiempo, haciendo clic sobre el botón de gráficas temporales. Realizar distintos barridos, etc. Es más, aunque el usuario no haga uso de ningún tipo de representación gráfica, puede ser consciente en tiempo real de lo que está ocurriendo durante la medición, gracias a los cuadros de edición de lectura de medidas en tiempo real de cada una de las variables de salida, los cuales se activan también automáticamente al hacer clic en los botones de ON de cada canal y sólo se desactivan si apagamos el propio canal de la fuente.
Debemos destacar también, que el botón de pausar los displays es muy útil cuando queremos hacer por ejemplo, un Barrido. Ya que por las prioridades en la jerarquía de objetos de Matlab, sabemos que ambos están al mismo nivel y, si no pausamos el/los display/s que se encuentren activo/s en ese momento y hacemos clic en el botón de Barrido directamente, cada vez que el/los display/s se refresquen, emergerá en pantalla el cuadro de mandos principal mostrando los nuevos valores de los displays y esto puede resultar muy incómodo. Además, si estamos en pleno uso de cualquier otro control del cuadro de mandos principal (los cuales suelen llevarnos al uso de otras ventanas que emergen a partir de ellos), ni siquiera en esos instantes nos resulta útil
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 112
ver los displays, por ello, lo mejor que podemos hacer es pausarlos momentáneamente hasta que nos vuelvan a resultar útiles.
4.7. Gráficas temporales
Una vez tenemos suficientes resultados de la medida almacenados en los buffers, puede
resultar muy útil visualizar el comportamiento del dispositivo medido frente al tiempo para entender
bien su funcionamiento, de ahí la importancia de la opción de mostrar gráficas temporales.
Para acceder a esta opción basta con hacer clic en el siguiente botón:
Este botón es del tipo push button y es accesible desde el cuadro de mandos principal de
nuestro programa.
Para dibujar las gráficas temporales hemos usado la representación estándar de Matlab,
dibujándolas en una ventana “figure”. Concretamente, hemos aprovechado una misma ventana, para
visualizar cuatro gráficos temporales a la vez, mediante el comando subplot:
subplot(m,n,p): Divide la ventana gráfica en mxn subventanas y coloca el gráfico
corriente en la ventana p-ésima, empezando a contar por la parte superior izquierda
y de izquierda a derecha hasta acabar la línea, para pasar a la siguiente.
Así, conseguimos visualizar todos los gráficos temporales en una misma ventana, lo cual,
nos proporciona más orden gráfico y agilidad a la hora de usar el software. De esta forma, si por
ejemplo, sólo tenemos activa la fuente positiva sólo visualizaremos las variables de salida
procedentes de este canal y tendremos todas las variables de salida asociadas a la fuente negativa
a cero.
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 113
A continuación, detallamos cuáles son las variables que podemos visualizar frente al tiempo
al pulsar el botón de Gráficas temporales:
� Tensión positiva frente al tiempo � Tensión negativa frente al tiempo � Intensidad positiva frente al tiempo � Intensidad negativa frente al tiempo
Y mostramos un ejemplo en el que sólo se encontraba activa la fuente positiva, por ello, tan
sólo vemos el comportamiento temporal de la tensión y corriente positiva, mientras que las salidas
de la fuente negativa permanecen a cero:
La ventaja de crear una figura de Matlab para dibujar las gráficas es que podemos tratar lo que nos dibuja, podemos cambiar su color, ponerle leyenda, cambiar límites de los ejes, etc.
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 114
4.7.1. Funcionamiento El uso de esta opción del panel principal es bastante intuitivo como el resto del programa,
pero aún así comentaremos un par de aspectos importantes. Como indicábamos anteriormente, basta con hacer clic en el botón Gráficas temporales para
que nos aparezca en pantalla el siguiente aviso:
Basta con pulsar OK e inmediatamente después nos aparece en pantalla una ventana con la
siguiente apariencia física:
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 115
Esta ventana, nos exige que introduzcamos los límites temporales entre los que deseamos
visualizar las cuatro gráficas de salida que nos puede mostrar la herramienta software. Debemos
tener cuidado, al introducir los tiempos, ya que como máximo los buffers del software que hemos
diseñado pueden albergar información de salida de hasta cinco minutos. De esta forma, tenemos un
límite temporal de cinco minutos para almacenar el resultado del comportamiento del dispositivo
medido en el laboratorio.
Si el usuario quisiera ver más de cinco minutos de comportamiento, el gráfico mostraría
valores nulos frente al tiempo una vez sobrepasados los cinco minutos. El usuario por tanto puede
visualizar gráficamente cualquier margen temporal entre cero y cinco minutos, los valores
temporales se introducen en segundos.
Una vez introducidos los límites temporales entre los que se desean visualizar los gráficos,
hacemos clic en el botón Cargar Datos, el cual se muestra a continuación:
Como podemos ver nada más posicionarnos sobre el botón, podemos ver un mensaje que
nos indica para qué sirve dicho botón tal y como se explicó en la sección 4.4.2 de este mismo
capítulo. Pues bien, nada más pulsar este botón emerge la ventana que contiene todos los gráficos
temporales que es capaz de mostrar esta herramienta.
Capítulo 4…..................Implementación de la herramienta software
Mª España Borrero Serrano Página 116
4.8. Diagrama de flujo de los
principales programas utilizados
En este último apartado del cuarto capítulo presentamos un diagrama de flujo a modo
resumen de los ficheros que se utilizan a partir del panel principal del programa, para ver de forma más gráfica el funcionamiento interno del mismo y poder entenderlo mejor, en caso de emplear como base este software en futuras líneas de investigación.