CAPÍTULO 4

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.



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).



� 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.



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.



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.



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



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;



% 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)



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



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;



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('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:



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);



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


end

SentQuery = 1;



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);



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


end

SentQuery = 1;



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);



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.



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



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”.



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.



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



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:



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.



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:



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)



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



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.



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.



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):



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:



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:



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.



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:



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



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:



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



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:



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



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



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.



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.



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:



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.



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.

CAPÍTULO 4

Documents

Transcript of CAPÍTULO 4