Programación en LabVIEW

Indices Índice

1

Introducción

2

Tema I Conceptos básico s

4

Tema II LabVIEW básico bási co

9

Tema III Tipos de datos simples sim ples

29

Tema IV Contro l de flujo flu jo de progr ama en LabVIEW. LabVIEW. Estruc turas repetiti vas.

55

Tema V Más estruc turas de cont rol de fluj o.

79

Tema VI Tipos de datos complejos. comp lejos. arreglos y clusters clu sters

95

Tema VII Contro les form a de onda. impl ementación de func iones en LabVIEW LabVIEW

117 117

Tema VIII VIII Trabajo con ficheros fic heros

142

Tema IX. Tarjetas de adqui sici si ción ón de datos dato s (PCL-818L). (PCL-818L).

161

Tema X Trabajo con puert o serie seri e en LabVIEW

200

Tema XI Trabajo con co n puert o paralelo paralel o en LabVIEW

213

Tema XII Comuni Comu nicaci cación ón TCP-IP TCP-IP en LabVIEW

221

Tema XIII Comuni Comu nicaci cación ón DDE

235

Departamento de de Au Automática y Computación

Valery Mo Moreno Ve Vega & Adel Fe Fernández Pr Prieto

Introducción: En esta monografía el lector encontrará una introducción a algunos temas relacionados con la instrumentación instrumentación virtual y específicamente específicamente sobre la herramienta herramienta de programación programación LabVIEW. Los temas abordados comprenden: 1. LabVIEW básico a. Los Instrumentos virtuales. b. Los conceptos de control e indicador. c. El ambiente de desarrollo. d. Tipos de datos simples. e. Estructuras de control de flujo. f. Tipos de datos complejos. g. Confección de funciones (subVI). h. Trabajo con ficheros. 2. LabVIEW avanzado a. Trabajo con tarjetas de adquisición de datos. b. Trabajo con puerto serie y paralelo. c. Trabajo con TCP-IP. d. Trabajo con DDE. El primer tema es necesario como introducción a cualquier lenguaje de programación, y en el mismo se abordan los conceptos en que se basa la programación gráfica. Es de destacar que en la programación gráfica todo esta muy ligado a la iconografía con que se representan los diferentes elementos. Un lector que esté acostumbrado a los lenguajes por comandos, llega a identificarse con las palabras claves que forman determinado lenguaje, por ejemplo: un for, int, switch en C++, sin embargo, con LabVIEW este concepto cambia, para ahora asociar una forma o icono en vez de un conjunto de caracteres con las palabras claves. LabVIEW es un lenguaje de programación construido sobre la base de objetos, sin embargo no es posible construir nuevos objetos, como pudiera hacerse con otros lenguajes como C++, Java, Pascal etc, es por ello que la manera de construir aplicaciones es a través de una metodología de programación estructurada, utilizando como recurso la implementación de funciones, que en este caso se denominan “SubVI”. El presente trabajo comienza con una breve explicación de los conceptos básicos relacionados relacionados con esta herramienta de trabajo, para luego exponer la totalidad de los temas mediante ejercicios resueltos, que el lector puede realizar desde su computadora personal o laboratorio. De esta manera se introducen los tipos de datos, las sentencias de control de flujo y la biblioteca de funciones básica y especializada, a través de ejemplos. También a lo largo de estos temas se proponen ejercicios como estudio independiente. independiente. El segundo tema que aquí hemos denominado como LabVIEW avanzado, no incluye ni mucho menos todos los temas que por este nombre pudieran estar. Simplemente nos a parecido que se salen del modulo básico de esta herramienta. Es de destacar que el trabajo con las tarjetas de adquisición de datos se realiza basado en la PCL-818L, esta es solo una, de muchísimas variantes que existen actualmente en el mercado, sin embargo, el estudio detallado que se hace de la misma, y la metodología de diseño de su controlador, controlador , nos parece un punto de partida práctico que puede ser utilizado por los interesados para generalizarlo a tarjetas de otros fabricantes. Quedan fuera temas tan interesantes como el estudio de las funciones de análisis matemático, el uso de filtros para señales de entrada. Además, el estudio de los DataSockets que se basan en el protocolo TCP-IP. También el trabajo con OLE/Active X y la conexión con Bases de Datos profesionales. Sin embargo, ya el volumen de esta edición es suficiente mente largo. Es de destacar que su estructura esta completa, siguiendo una secuencia donde lo aprendido sirve de base a lo que se aprende y donde ningún concepto queda fuera de lo que se ha abordado anteriormente.

http://visualinformatica.blogspot.com

2



Introducción: En esta monografía el lector encontrará una introducción a algunos temas relacionados con la instrumentación instrumentación virtual y específicamente específicamente sobre la herramienta herramienta de programación programación LabVIEW. Los temas abordados comprenden: 1. LabVIEW básico a. Los Instrumentos virtuales. b. Los conceptos de control e indicador. c. El ambiente de desarrollo. d. Tipos de datos simples. e. Estructuras de control de flujo. f. Tipos de datos complejos. g. Confección de funciones (subVI). h. Trabajo con ficheros. 2. LabVIEW avanzado a. Trabajo con tarjetas de adquisición de datos. b. Trabajo con puerto serie y paralelo. c. Trabajo con TCP-IP. d. Trabajo con DDE. El primer tema es necesario como introducción a cualquier lenguaje de programación, y en el mismo se abordan los conceptos en que se basa la programación gráfica. Es de destacar que en la programación gráfica todo esta muy ligado a la iconografía con que se representan los diferentes elementos. Un lector que esté acostumbrado a los lenguajes por comandos, llega a identificarse con las palabras claves que forman determinado lenguaje, por ejemplo: un for, int, switch en C++, sin embargo, con LabVIEW este concepto cambia, para ahora asociar una forma o icono en vez de un conjunto de caracteres con las palabras claves. LabVIEW es un lenguaje de programación construido sobre la base de objetos, sin embargo no es posible construir nuevos objetos, como pudiera hacerse con otros lenguajes como C++, Java, Pascal etc, es por ello que la manera de construir aplicaciones es a través de una metodología de programación estructurada, utilizando como recurso la implementación de funciones, que en este caso se denominan “SubVI”. El presente trabajo comienza con una breve explicación de los conceptos básicos relacionados relacionados con esta herramienta de trabajo, para luego exponer la totalidad de los temas mediante ejercicios resueltos, que el lector puede realizar desde su computadora personal o laboratorio. De esta manera se introducen los tipos de datos, las sentencias de control de flujo y la biblioteca de funciones básica y especializada, a través de ejemplos. También a lo largo de estos temas se proponen ejercicios como estudio independiente. independiente. El segundo tema que aquí hemos denominado como LabVIEW avanzado, no incluye ni mucho menos todos los temas que por este nombre pudieran estar. Simplemente nos a parecido que se salen del modulo básico de esta herramienta. Es de destacar que el trabajo con las tarjetas de adquisición de datos se realiza basado en la PCL-818L, esta es solo una, de muchísimas variantes que existen actualmente en el mercado, sin embargo, el estudio detallado que se hace de la misma, y la metodología de diseño de su controlador, controlador , nos parece un punto de partida práctico que puede ser utilizado por los interesados para generalizarlo a tarjetas de otros fabricantes. Quedan fuera temas tan interesantes como el estudio de las funciones de análisis matemático, el uso de filtros para señales de entrada. Además, el estudio de los DataSockets que se basan en el protocolo TCP-IP. También el trabajo con OLE/Active X y la conexión con Bases de Datos profesionales. Sin embargo, ya el volumen de esta edición es suficiente mente largo. Es de destacar que su estructura esta completa, siguiendo una secuencia donde lo aprendido sirve de base a lo que se aprende y donde ningún concepto queda fuera de lo que se ha abordado anteriormente.


2



Esta edición un poco abre una primera puerta a la escasez de bibliografía que existe alrededor del Lenguaje de programación LabVIEW. Sabemos que estos lenguajes son susceptibles de actualizaciones, pero también el hecho de que los temas abordados son los suficientemente básicos, incluyendo aquellos que se denominaron como avanzados, nos da suficiente paz, como para pensar que este volumen se pueda utilizar por algunos años, no diez o veinte, pero si hasta tres años. Esperamos disfrute y encuentre útil esta monografía. Es ese el deseo de los autores.

Los autores.


3



TEMA I Conceptos Básicos Primeramente antes de entrar en que es el LabView vamos a conocer nuevos conceptos acerca de la Instrumentación Virtual. Semánticamente virtual es algo aparente, que no es real pero que se comporta como tal. En la actualidad se manejan términos como los de instrumentación virtual, laboratorio virtual, ambientes virtuales, y realidad virtual. No se debe confundir laboratorio virtual con instrumento virtual aunque existe una estrecha relación. Se habla de laboratorio virtual cuando se simula un proceso o sistema que se parece y se comporta como un proceso o sistema real, para poder observar su comportamiento. Se habla de instrumento virtual cuando se emplea la computadora para realizar funciones de un instrumento clásico pudiendo agregarle al instrumento otras funciones a voluntad. A pesar de esta pequeña diferencia, un laboratorio con instrumentos virtuales es un laboratorio virtual. En el campo de la instrumentación quien introdujo por primera vez el termino virtual fue la compañía National Instrument en 1986, al elaborar un programa que de manera simple y gráfica permitiera simular un instrumento en una PC, con lo cual dio origen al concepto de instrumento virtual; definido como “un instrumento que no es real, corre en una computadora y tiene funciones definidas por programación”. El instrumento tradicional ya está definido, con capacidades de entrada/salida de señales y una interfaz de usuario fija. El fabricante define la funcionalidad del instrumento, el usuario no puede cambiarla. Dada la arquitectura abierta de los PCs y las estaciones de trabajo, la funcionalidad de los instrumentos virtuales esta definida por el usuario. Además, la capacidad de procesamiento de los instrumentos virtuales es superior a la de instrumentos estándares, debido a la rápida evolución de la tecnología de los PCs y de las estaciones de trabajo como resultado de las grandes inversiones inversiones que se efectúan en la industria. En 1986 National Instruments introdujo LabView 1.0 con el propósito de proveer una herramienta de software que permitiera a los ingenieros desarrollar sistemas a la medida de sus necesidades, del mismo modo que la hoja de cálculo permitía a los hombres de negocios analizar datos financieros. Este nombre LabView viene de las siglas en ingles Laboratory Virtual Instrument Engineering Workbench. La versión del LabView 6.1 y los requerimientos mínimos son: 1. 32 MB de RAM RAM y 65 MB de HD / Parcial, Parcial, 300MB 300MB Completa. Completa. 2. Incluye Windows NT 4.0 o superior ¿Que es el LabView?. El LabView es un programa para el desarrollo de aplicaciones de propositos generales, tales como el C, el Basic, el Pascal.

Herramientas de Desarrollo de Software

Ambiente de desarrollo

+ Lenguaje de

Programación

Figura1: Esquema general


4

Departamento de Automática y Computación

Valery Moreno Vega & Adel Fernández Prieto

Ambiente de Desarrollo Todo ambiente de desarrollo testa formado por los siguientes elementos. Es importante que se busque y se practiquen con frecuencia ya que esto permite que el desarrollo de las aplicaciones se realice con mayor rapidez y calidad. Depuración Puntos de ruptura. •

•

Ejecución paso a paso .

•

Ventana de seguimiento a variables

Fac ilidades de desarrollo •

•

•

Panel frontal: Para observar el estado de las pantallas que estamos desarrollando. Paletas de funciones y controles para adicionar a nuestro proyecto. Herramientas para alinear los controles y funciones.

L enguaje de Programación. LabVIEW usa el lenguaje de programación gráfico Lenguaje G. Las posibilidades son normalmente las mismas que presenta cualquier lenguaje de programación: 

Sentencias (Gráficos) de control de Flujo y repetitivas.



Posibilidad de declaración de variables.



Modularidad a través de la confecció n de funciones. Trabajo con los eventos y

propiedades de los controles y variables. 

Incluye bibliotecas de funciones exten didas para cualquier tarea de programación.



Basado en objetos pero no permite nuevas declaraciones.



Mecanismos de conexión con lenguaje C y C++ y DLL.

Algo muy característico de LabVIEW y es por ello que se considera una herramienta para el desarrollo de instrumentos virtuales, es su extensa biblioteca de funciones especializada en la adquisición, acceso a buses de campo, procesamiento matemático y procesamiento de señales 

Tarjetas de adquisición de datos



Bus GPIB.



Entrada/ Salida (Puerto serie y paralelo). Arquitectura VISA.



Análisis de señales.



Almacenamiento de d atos.



Comunicación (TCP-IP, UDP y otros).



Matemáticas.

¿Cómo se tr abaja con el LabVIEW? Los programas en LabVIEW son llamados Instrumentos Virtuales (y son salvados con la extensión .VI). Los programas de LabVIEW constan de un panel frontal y un diagrama de bloques. En el panel frontal se diseña la interfaz con el usuario, viene a ser la cara del VI y en el diagrama de bloques se programa en lenguaje G el funcionamiento del VI.


5



Programas de LabView (*.vi)

Panel Frontal

• Diseño de interfaz • Cara del

+

Diagrama Bloques

• Lenguaje G • Lógica del programa

instrumento virtual El Panel Front al

El panel frontal de un VI es una combinación de controles e indicadores. Los controles son aquellos elementos que entregan datos al diagrama en bloques desde el panel frontal por entrada desde teclado o con el mouse, simulan los dispositivos de entrada de datos del VI y pasan los datos al diagrama en bloque del VI. Los indicadores son aquellos elementos que entregan datos al panel frontal desde el diagrama en bloques para ser visualizados en el display, simulan los dispositivos de salida de datos del VI que toman los datos desde el diagrama en bloque del VI. Para adicionar controles o indicadores al panel frontal se seleccionan estos de la paleta de controles que se encuentra en una ventana flotante y a la cual se accede a través de accionar el botón derecho del ratón sobre el panel frontal. A los controles e indicadores se les puede cambiar el tamaño, la forma, y la posición, además cada control o indicador tiene un pop-up menú en el cual se pueden cambiar varios atributos o seleccionar diferentes opciones. Los controles:  Entregan datos al diagrama en bloques por mediación del teclado o el ratón,  Simulan dispositivos de entrada de datos del VI

Los indicadores  Muestran datos en el panel frontal desde el diagrama en bloques para ser visualizados  Simulan los dispositivos de salida de datos del VI.

El Diagrama en Bloque s


6





La ventana Diagrama almacena el diagrama en bloques del VI, el código fuente gráfico (Lenguaje G) del Instrumento Virtual.



Se construye este diagrama con bloques funcionales denominados nodos, conectándose o uniéndose entre sí según sea el objetivo.



Estos nodos realizan todas las funciones específicas necesa rias para el VI y controlan el flujo de la ejecución del VI.

Tipos de Datos en LabView Long Word Byte Long Unsigned Word Unsigned Byte Unsigned Extended Double Single Complex Extended Complex Double Complex Single Cadena(String) Arreglos(Array) Grupos (Cluster) Path Device

Tabla 3.1 Tip os de Datos en LabView I32 32 (4 bytes) -2147483648 hasta 2147483647 I16 16 (2 bytes) -32768 hasta 32767 I8 8 (1 bytes) -128 hasta 127 U32 32 (4 bytes) 0 hasta 4294967295 U16 16 (2 bytes) 0 hasta 65535 U8 8 (1 bytes) 0 hasta 255 EXT 96 (12 bytes) -1.00E–507 hasta 9.00E+515 DBL 64 (8 bytes) -5.00E-324 hasta 1.70E+308 SGL 32 (4 bytes) -1.40E-45 hasta 3.40E+38 CXT 192 (24 bytes) -1.00E–507 hasta 9.00E+515 CDB 128 (16 bytes) -5.00E-324 hasta 1.70E+308 CSG 64 (8 bytes) -1.40E-45 hasta 3.40E+38 abc 1 byte/caracter Conjunto de Caracteres ascii. Según el tipo de los elementos del arreglo [...]

¿Cómo se declaran los t ipos d e variables numéricas ? •

• •

•

Cuando se pone un control o indicador en el panel f rontal, LabView pone un terminal correspondiente a este control o indicador en el diagrama en bloque. Este terminal desaparece solo cuando se borra el control o indicador. Los enlaces o alambres son los caminos de los datos entre los termina les fuente y los terminales destino. No se permite enlazar dos terminales fuentes ni dos terminales destinos, y si se permite enlazar un te rminal fuente a varios terminales destino.

Configuración


Representación

7



Variables locales Las variables locales permiten hacer lecturas y escrituras sobre el control o indicador al cual está asociado.

// esto es C int a = 0 ; //declaración a = x +y *z; // escritura m = a* c; // lectura


8



TEMA II LabVIEW Básico •

•

•

Familiarizarse con el entorno de trabajo de LabView, la pantalla de diseño o panel frontal, y la pantalla o ventana de flujo de programa. Conocer los principales indicadores y botones y las acciones más comunes de los mismos. Conocer las teclas de acceso directo y las pr incipales opciones de la ayuda y de la ejecución del programa.

Ejercicio 1: Elabore un programa en LabView que permita conectar a un termómetro y un tanque dos controles de sintonía de manera tal que cuando varíen su valor el nuevo adquirido se refleje en los indicadores tipo termómetro y en el tipo tanque. Solución: Cuando se ejecuta LabView por primera vez aparece una pantalla similar a la siguiente:

En esa pantalla podemos seleccionar varias opciones entre las cuales están el abrir un nuevo Intrumento Virtual (New VI), abrir uno ya existente, buscar ejemplos, demos, tutoriales, etc. Para crear un nuevo programa (VI) damos clic en el botón continuación aparece una ventana simular a la que se presenta a continuación:


. A

9



La primera pantalla que aparece es el panel frontal o ventana de diseño de la aplicación mientras que la que aparece en segundo plano es la ventana de flujo de programa o de diagrama. Recuerde que puede conmutar entre uno y otro. Compruébelo con la combinación Ctrl+E. Muchas veces es conveniente organizar las dos ventanas de forma tal que se dividan la pantalla cada una en una mitad. Esto facilita el desarrollo del programa. Para lograr dicha distribución LabView dispone de la combinación Ctrl+T (también se puede realizar mediante la opción del menú Windows/Tile Left and Right). Una vez que se realiza esta acción se obtiene la siguiente distribución:


10



Ya estamos listo para comenzar a darle solución al ejercicio. Primero seleccionemos los controles que podremos. Para ello seleccionamos mediante un clic la ventana izquierda (panel frontal) y a continuación damos clic derecho. Debe aparecer un menú emergente llamado controls . Seleccionamos en controls la primera de las opciones, que se llama numerics y se representa en el menú controls con el símbolo algo similar a:


. Aparecerá

11



Observe que en ambas ventanas, la de Controls y la Numeric, en el caption de las mismas aparece el nombre de la ventana precedido de una especie de tachuela, o sea, . Este símbolo aparece aquí porque si queremos dejar la ventana fija (para evitar que cada vez que se quiera poner un nuevo control tengamos que dar clic derecho y buscar la opción que nos interesa) podemos hacerlo cambiando el ¨estado¨ de la tachuela dando clic encima de ella. Como en esta aplicación vamos a ubicar más de un control y algunos indicadores, dejemos fija la ventana de Numeric . Si se procede a ubicar el puntero del mouse en la tachuela que aparece justo antes de numeric en el caption de la ventana del mismo nombre se observa que dicha tachuela cambia de posición o forma:

y si en ese momento damos clic obtenemos:


12



Los controles tipo sintonía son los que se identifican por knob y dial. Son los primeros que aparecen en la tercera fila de la pantalla anterior. Para incorporarlos a nuestro panel frontal simplemente los seleccionamos (el tipo de cursor debe ser el de selección que se comentó en conferencia) que es el que por defecto debemos tener en estos momentos. Si no es ese el que tenemos podemos cambiarlo visualizando la ventana de herramientas (opción windows/Show Tools Palette) y seleccionando el mencionado tipo de cursor. El procedimiento se muestra en las dos ventanas siguientes (el cursor seleccionado aparece “hundido” en comparación con el resto:


13



Continuando con la idea original de insertar los controles en el panel frontal, seleccionamos los de tipo sintonía (1ero y segundo de la tercera fila) en la paleta o ventana numeric mostrada en las figuras precedentes. La selección se realiza dando clic encima del de interés y colocándolo en el panel frontal (de la forma usual con que se hace esto en lenguajes visuales como el C++ Builder). Después de realizada la operación las pantallas deben tener una apariencia como sigue (se muestra el segmento de interés de las ventanas):


14



y:

Note que a medida que se introducen los controles en el panel frontal en la pantalla de diagrama (figura anterior) van apareciendo variables asociadas a los controles. Dichas variables se identifican con un nombre (el mismo del control, de manera que si se cambia en el control se cambia en la pantalla de diagrama). En dependencia del tipo de elemento numérico que se seleccione las variables declaradas serán de escritura (fijan valores) o de lectura (reciben valores). En este caso los controles del panel frontal tienen variables de escritura. Es


15



fácil identificar cuando una variable es de lectura o escritura pues LabView nos lo indica con una especie de saeta, que indica la dirección del flujo de los datos. En el ejemplo anterior ambas variables están representadas con los símbolos . Note que en dicho símbolo aparece la saeta indicando salida, o sea, escritura. En el símbolo anterior también se puede leer la cadena DBL que nos dice de que tipo de datos es esa variable. Cuando se estudien los tipos de datos simples veremos que este tipo (que por defecto tienen los controles) es el tipo Double. Los tipos de datos que se definen por defecto pueden cambiarse. Para ello seleccionamos la variable en la pantalla de diagrama y damos clic derecho. En el menú emergente que aparece buscamos la opción Representation :

Note que hay varios tipos de datos. El que actualmente está seleccionado aparece encerrado en un recuadro azul como en la figura anterior. Si se quiere seleccionar otro basta con seleccionarlo con clic izquierdo. Observe que en dependencia de la variable se podrá seleccionar para ella distintas representaciones o tipos de datos, pero no todos. En este caso hay varios tipos de datos que aparecen en gris (los últimos), indicándonos que no se admiten esos tipos para el actual elemento o control. Hagamos un cambio, y del tipo DBL por defecto que tiene llevémoslo a U8 que es un tipo de dato entero corto sin signo (8 bits, de 0 a 255 como posibles valores). Para ello seleccionamos en el menú de representation el elemento identificado como U8. Los cambios se manifiestan en la pantalla de diagrama cambiando el color de la variable para indicar el otro tipo (cada tipo tiene un color). Debemos obtener:


16



Note que en el panel frontal la escala del control también cambió para adaptarse al nuevo tipo de variable (por ejemplo, no tiene valores decimales pues es el control es de tipo entero). De igual forma (clic derecho sobre el control) la apariencia del control en el panel frontal y de su escala se puede modificar, así como algunas de sus propiedades. En las figuras que aparecen a continuación se ponen algunos ejemplos:


17




18



Otras opciones incluyen escalas logarítmicas ( Mapping ), espaciado arbitrario o uniforme, etc. El control también se puede redimensionar, o sea, el tamaño y posición inicial que aparece en el panel frontal son atributos que se pueden modificar en tiempo de diseño. Cada control lo indica de una manera fácil de identificar, usualmente mediante un rectángulo que encierra al control o parte de este durante el movimiento del mouse sobre el elemento. A continuación se muestra un ejemplo: Note que se han señalado cuatro esquinas. Moviendo el puntero del mouse para cualquiera de esas esquinas se puede modificar el radio de la circunferencia que representa el botón de sintonía. El resto de los elementos del control, excepto la etiqueta ( en este caso Dial) , se redimensionan al redimensionarse la circunferencia.

A continuación se representa al mismo elemento redimensionado.

Hasta este punto se han situado en la pantalla los elementos gráficos que harán la función de “controles”. Ahora corresponde seleccionar los indicadores que mostrarán su valor de acuerdo


19



a los controles. Estos indicadores están situados en la misma paleta, o sea en la paleta de controles numéricos. En este caso utilizaremos el indicador “Tank” y el “thermometer”, que se seleccionan de la siguiente manera:

Para luego obtener el siguiente diseño:

Para terminar y como se ha mencionado en los talleres, debemos colocar un botón que permita a los usuarios terminara la aplicación. Para ello debemos seleccionar este control de la paleta de funciones numéricas. Esto se realiza de la siguiente forma:


20



El diseño final del “Panel Frontal” queda:

Ahora corresponde trabajar en la ventana del diagrama en bloques. Para ello podemos utilizar las teclas de acceso rápido (Ctrl+E). En esta ventana debemos utilizar el lenguaje de programación G para establecer la lógica de nuestra aplicación. Antes de comenzar tenemos las cinco variables que corresponden a los cinco controles que hemos colocado en la pantalla. El código luce de la siguiente forma:


21



El primer código G que debemos programar es el necesario para comenzar y terminar la aplicación. Para ello se tiene el control “Stop Button” representado por la variable booleana “stop” (verde ), en la ventana del diagrama. Mientras esta variable sea verdadera se debe ejecutar nuestro programa. En caso contrario debe terminar la aplicación. Esta situación se modela en programación a través de un “ciclo while”. Para incorporar un “ciclo while” a nuestra aplicación se selecciona en la paleta de funciones el boton:

y luego se busca la opción “while loop”.

Una vez que se seleccione, debe irse a la pantalla del diagrama. Ahora el cursor de la aplicación cambia para indicarle que usted debe seleccionar el área que ocupará el ciclo, esto se realiza arrastrando el ratón de manera que seleccione el área necesaria, como ilustra la siguiente pantalla.


22



Al finalizar se obtiene la siguiente estructura de programa G:

Para finalizar el programa solo nos resta realizar las asignaciones correspondientes. Es fácil darse cuenta de que las variables que corresponden a los controles deben ser asignadas a las variables que representan a los indicadores. Para ello debemos utilizar el cursor que se puede obtener utilizando la tecla (Tab) o seleccionándolo directamente en la paleta de herramientas “tools Palette”. Una vez conectados el código queda como sigue:


23



Note que el flujo de los datos va desde el control hacia el indicador y note también que la representación gráfica de ambas variables pese a ser del mismo tipo de datos no es igual: El borde es más grueso en los controles que en los indicadores, así como la flecha es de salida en los primeros y de entrada en los segundos. Finalmente debemos conectar el control booleano a la condición de salida del ciclo do..While . Para ello debemos utilizar un “negador” ya que el botón por defecto está en falso. Para ello se utilizan los operadores boolenos que se encuentran en la paleta de funciones según se muestra debajo:

Al conectarlos queda de la siguiente forma:


24



Con ello queda resuelto el problema planteado. Sin embargo ahora debemos correr la aplicación, para ello se debe utilizar la barra de botones colocada en la ventana del diagrama:

permite ejecutar la aplicación, mientras qué el botón El botón ejecutar la aplicación. Para realizar una pausa debemos utilizar el botón

permite terminar de

, luego podemos utilizar los botones

para ejecutar paso a paso la aplicación. El primero ejecuta instrucción por instrucción, entrando en las funciones si las hubiera, mientras que el segundo si encontrara una función, la ejecuta como si fuera un solo paso. El tercer tipo de botón termina la ejecución paso a paso. que ejecuta la aplicación de manera continua pero Un botón muy interesante es introduciendo una demora entre instrucción e instrucción para que pueda depurarse la aplicación. Además se puede observar los valores asignados a las variables y funciones así como los valores devueltos por estas. Si quisiéramos utilizar una ventana de depuración se debe situar el ratón en una de las conexiones o asignaciones relacionadas con la variable que se debe depurar y dar clic derecho: A continuación seleccionar la opción “Probe” como se muestra a continuación:

Luego se ve el valor de la variable en una ventana contextual como la siguiente:


25



Si en el paso anterior a este hubiéramos seleccionado la opción “Set Breakpoint” entonces el código se ve de la siguiente forma:

Y la aplicación se ejecutará hasta este punto, interrumpiéndose antes de realizar la asignación. El segundo ejercicio que se propone para este laboratorio permitirá conocer los diferentes tipos de botones que existen en el Labview. Una vez realizado el mismo se deberá conocer cuando utilizar uno u otro en dependencia de la aplicación. Como toda aplicación esta debe comenzar con la realización del código necesario para ejecutar y terminar la aplicación. Para ello debe colocar un botón booleano de salida y realizar el código siguiente:

Ahora completamos la interfaz de la aplicación (Panel de Control) con los seis tipos de botones que se pueden colocar en LabView, además colocaremos seis “leds” que nos indicarán la manera en que funcionan estos tipos de botones. La interfaz debe quedar de la siguiente manera:


26



Luego usted debe programar la opción “Mechanical Action” de los tipos de controles voléanos, según se indica en el texto. Para ello debe dar clic derecho sobre el botón de la siguiente manera:

Luego en la ventana del código se asigna a cada botón un “led” que estará encendido solo cuando el valor del botón es verdadero. Esto queda así:


27



El funcionamiento de los tres primeros botones es muy parecido. En el primer caso el led se encenderá si se presione el botón, y permanecerá en ese estado hasta que se vuelva a presionar el botón. El segundo caso es idéntico pero en este caso cambiará cuando se deje de presionar el botón. En el tercer caso se encenderá el led mientras se tenga presionado el botón. Los siguientes tipos de botones tienen relación con el tiempo que demora el Labview en leer el cambio de estado de los botones. En el cuarto caso, inmediatamente después que se presione el ratón sobre el botón este cambiará de estado y permanecerá en él hasta tanto el Labview pueda leer el cambio de estado. Luego se retornará al estado anterior. La quinta variante es muy parecida pero en este caso el botón no cambiará de estado hasta que se deje de presionar el ratón. La sexta variante funciona de manera que el botón cambia de estado con solo presionar el botón y permanece encendido todo el tiempo en que se tiene presionado el ratón sobre le botón. Una vez que se suelte el ratón, el botón permanecerá en este estado hasta tanto el labview sea capaz de notarlo, luego se retornará al estado anterior. Para poder entender bien el funcionamiento de los diferentes tipos de botones, sobre todo los tres últimos, es necesario que ejecute la aplicación utlizando la herramienta de depuración que hace que el Labview lea con mayor lentitud los controles. Esto hace que se pueda observar claramente cuando es que se produce la lectura del estado de los botones por el labview.


28



TEMA III Tipos de Datos s impl es •

• •

Familiarizarse con el entorno de trabajo de LabView, la pantalla de diseño o panel frontal, y la pantalla o ventana de flujo de programa. Conocer los ti po de datos pr incipales: numéricos, bool eanos y de cadena. Conocer los operadores y f unciones básicas para el trabajo con los t ipos de datos simples.

Ejercicio 1: Elabore un programa en LabView que permita indicar el nivel de un tanque en un elemento gráfico de Labview. El valor del nivel varía entre 0 y 100 unidades y debe obtenerse a través de una función aleatoria. El programa debe indicar un estado de alarma cuando el nivel sobrepase un valor de referencia que los usuarios deben establecer. El estado de alarma se indicará por medio del color del elemento gráfico seleccionado: Azul: estado normal, Rojo: estado de alarma. Solución: Cuando se ejecuta LabView por primera vez aparece una pantalla similar a la siguiente:

En esa pantalla podemos seleccionar varias opciones entre las cuales están el abrir un nuevo Intrumento Virtual (New VI), abrir uno ya existente, buscar ejemplos, demos, tutoriales, etc. Para crear un nuevo programa (VI) damos clic en el botón continuación aparece una ventana simular a la que se presenta a continuación:


. A

29



La primera pantalla que aparece es el panel frontal o ventana de diseño de la aplicación mientras que la que aparece en segundo plano es la ventana de flujo de programa o de diagrama. Recuerde que puede conmutar entre uno y otro. Compruébelo con la combinación Ctrl+E. Pasos de la solución 1. Primero seleccionemos los controles que pondremos. Para ello seleccionamos mediante un clic la ventana izquierda (panel frontal) y a continuación damos clic derecho. Debe aparecer un menú emergente llamado “controls”. Seleccionamos en “ controls” la primera de las opciones, que se llama “ numerics” y se representa en el menú “ controls” con el símbolo Aparecerá algo similar a:


.

30



Como se puede observar el elemento “Tank” es el más indicado para representar el nivel que es requerido en el ejercicio. Para colocarlo en el “panel frontal” del instrumento virtual que estamos diseñando, debemos seleccionarlo en la paleta de controles y luego soltarlo en el “panel frontal”. El resultado es el siguiente:

Existen varias propiedades que podemos variar para este control. Para ello debemos dar clic derecho sobre el control y seleccionar por ejemplo la opción de mostrar el indicador digital, como se muestra en la figura siguiente:


31



2. Según el enunciado del problema debemos colocar la escala del tanque entre los valores de 0 y 100 unidades. Para ello debemos seleccionar el cursor en la paleta de herramientas o pulsar la tecla “tab”, hasta que el cursor en la pantalla quede de la siguiente manera: . Una vez que se tiene seleccionado este cursor se da doble-clic sobre el máximo valor de la escala del indicador “tank”, se cambia la escala de 10 a 100 y se presiona la tecla “enter”. Esto se realiza de la siguiente manera:

Paso 1

Paso 2

3. El otro elemento gráfico necesario para resolver este ejercicio es un control numérico para establecer la referencia de la alarma. De la misma manera que se seleccionó el elemento “Tank” ahora debemos seleccionar un control digital:

Luego la pantalla queda como sigue:


32



Obsérvese que el nombre del control queda seleccionado, si en este momento se utiliza el teclado, se puede cambiar directamente el encabezado del control. En este caso debemos colocar el nombre: referencia de nivel.

4. Para terminar la interfaz de usuario se debe colocar un botón “booleano” que permita terminar la ejecución de un programa. Esto se realiza en la paleta de controles seleccionando los elemento booleanos para luego escoger “Stop Button”:

La interfaz final queda como sigue:


33



Ya estamos en condiciones de programar, en base a los elementos gráficos seleccionados para nuestra interfaz, la lógica que dará solución a nuestro ejercicio. Para ello pasamos directamente a la ventana del diagrama (Ctrl+E).

6. El primer código G que debemos programar es el necesario para comenzar y terminar la aplicación. Para ello se tiene el control “Stop Button” representado por la variable booleana “stop” (verde ), en la ventana del diagrama. Mientras esta variable sea verdadera se debe ejecutar nuestro programa. En caso contrario debe terminar la aplicación. Esta situación se modela en programación a través de un “ciclo while”. Para incorporar un “ciclo while” a nuestra aplicación se selecciona en la paleta de funciones el boton:



34



7. Una vez que se seleccione, debe irse a la pantalla del diagrama. Ahora el cursor de la aplicación cambia para indicarle que usted debe seleccionar el área que ocupará el ciclo, esto se realiza arrastrando el ratón de manera que seleccione el área necesaria, como ilustra la siguiente pantalla.



35



8. El ciclo tiene dos variable implícitas: la iteración representada por

y la condición de

salida, representada por . Si negamos la variable booleana y la conectamos a la condición de salida, se construye la lógica necesaria para la ejecución y salida del programa. Para negar la variable booleana “stop” debemos utilizar los operadores booleanos que se seleccionan en la paleta de funciones como sigue:

9. Allí debemos seleccionar como nuestra la figura, el operdor “Not”. Y colocarlo en nuestra ventana del diagrama de la siguiente forma:

Antes de conectarlos

Después de conectarlos

10. El tipo de datos que representa a nuestro tanque y al controlador de referencia es por defecto Double . Pero esto se puede cambiar de la misma manera que se hizo en el laboratorio anterior. Antes de seguir debemos verificar que la variable “Tank” esté configurada como “indicador” y la variable “referencia de nivel” esté configurada como “control”. (Recordar la simbología)

11. Según el enunciado del ejercicio el tanque debe recibir el valor de nivel de una función aleatoria. En el caso de labview esta función se encuentra entre las funciones numéricas y se puede escoger como sigue:


36



12. Esta función brinda un valor aleatorio de tipo “double” entre 0 y 1. Sin embargo nuestra aplicación requiere que el nivel varía entre 0-100. Para ello debemos multiplicar la salida de esta función por el valor entero 100. Con ello se logra nuestro objetivo. La función de multiplicación se encuentra en la misma paleta de funciones numérica y se representa por el símbolo: que recibe dos valores y devuelve la multiplicación de ambos. Además de esta propia paleta debe utilizarse una constante numérica entera que contenga el valor 100 que será el otro elemento necesario. Después de colocar estas funciones y variables se obtiene el siguiente diagrama:

13. Ahora debemos conectar los elementos según la lógica a seguir. En nuestro caso queda como sigue:


37



En cada iteración del ciclo el resultado de la función aleatoria se multiplica por 100 y este valor se asigna a la variable que representa al control tanque. 14. Ahora debemos comparar el valor del tanque con la referencia entrada por el usuario. Si este valor es mayor que la referencia se cambiará el color del tanque a rojo, sino, el tanque será de color azul. Para ello es necesario una función de comparación, que se puede encontrar en la paleta de funciones “Comparison”:

Ahora la pantalla queda como sigue:

Para modificar el color del tanque debemos utilizar la propiedad FillColor selecciona de la siguiente manera:

que se

15. De clic derecho sobre la variable “Tank” y seleccione la opción Create, a continuación seleccione la opción “Property Node” según se muestra a continuación:


38



En la pantalla del diagrama se muestra el siguiente código:

16. En este caso la propiedad de la variable “tank”que se muestra por defecto es “Visible”, sin embargo si damos clic derecho sobre ella y seleccionamos la opción “Properties” y luego la opción “Fill Color” entonces nuestra propiedad se convierte en la que buscamos. El código es el que sigue:


39



17. Si se observa detenidamente podemos ver que la propiedad “Fill Color” de la variable “Tank” es de lectura, sin embargo se necesita variar la misma en dependencia del resultado de la comparación del valor y la referencia. Para cambiar esta propiedad a escritura debemos dar clic derecho sobre la misma y seleccionar la opción “Change To Write”. Con ello el resultado grafico es de

a

.

18. Para continuar nuestra aplicación es necesario un bloque de toma de decisión (bloque ifthen-else) que permita escribir un color u otro en dependencia del resultado de la comparación. Este bloque puede encontrarse en la “paleta de funciones”, específicamente en la paleta esta instrucción retorna el valor conectado en “t” o “f” “Comparison” la función “Select” en dependencia del valor de “s”. Si “s” es verdadero retorna “t”, en caso contrario retorna “f”. “t” y “f”pueden ser de cualquier tipo de dato. Al colocarlo en nuestro diagrama de bloque, podemos presionar Ctrl+H para obtener la ayuda contextual que se muestra debajo. El diagrama G ahora luce como sigue:


40



El valor que debe retornar la función “Select” debe ser Rojo, si la condición es verdadera y Azul si es falsa. Para ello es necesario utilizar constantes enteras que representen los colores deseados. 19. Esto es posible utilizando la paleta de funciones y escogiendo dos constantes “Color Box Constant”, una para el rojo y otra para el azul. La manera de hacerlo se muestra abajo.


41



El código queda como sigue:

20. Por defecto el color que toman es negro, para cambiar esto debemos tomar el cursor En la paleta de herramientas y presionar sobre la constante para escoger el color deseado. Esto se realiza de la manera mostrada arriba. El código queda como sigue:

Sin conexión

Con conexión

21. La aplicación está casi lista, ahora debemos ejecutarla, para ello presionamos el botón de menú y si se quiere ejecutar en modo de depuración se pueden escoger las variantes ya estudiadas. . Al ejecutarla podemos percibir la rapidez con que varia el nivel, para que sea más efectiva la simulación se puede introducir un bloque de demosra dentro del ciclo iterativo. 22. Para ello debemos ir a la paleta de funciones y utilizar la función “Wait Until Next ms Multiple” y colocar una constante de demora de 500 ms. Como se muestra a continuación.


42



Ejercicio 2 Elabore un programa en Labview que: dado el nombre y la edad de una persona. Elabore una cadena de salida que diga lo siguiente: Usted se llama: nombre y nació en el año: YYYY donde las cadenas subrayadas son: el nombre y la resta del año actual con la edad respectivamente. Para diseñar la interfaz de usuario de este programa debemos utilizar 1 controles de cadena para entrar el nombre, 1 control numérico de tipo entero sin signo, de 8 bytes, ya que la edad siempre es positiva y nunca mayor que 256 que es el entero más pequeño que se puede declarar y 1 indicador de cadena para la salida. Además debemos colocar un control booleano que permita terminar la ejecución del programa. Los pasos para construir la interfaz son los siguientes: 1. Abrir un nuevo VI, tal y como lo hicimos en los ejercicios anteriores. 2. Adicionar un control de cadena.

Selección del control

Panel Frontal

3. Adicionar un control numérico.


43




Panel Frontal

4. Cambiar el tipo de dato asociado con el control numérico.

6. Adicionar un indicador de cadena.


Panel Frontal

7. Adicionar un control booleano.


44




Panel Frontal

Ya estamos en condiciones de programar, en base a los elementos gráficos seleccionados para nuestra interfaz, la lógica que dará solución a nuestro ejercicio. Para ello pasamos directamente a la ventana del diagrama (Ctrl+E).

6. El primer código G que debemos programar es el necesario para comenzar y terminar la aplicación. Para ello se tiene el control “Stop Button” representado por la variable booleana “stop” (verde ), en la ventana del diagrama. Mientras esta variable sea verdadera se debe ejecutar nuestro programa. En caso contrario debe terminar la aplicación. Esta situación se modela en programación a través de un “ciclo while”. Para incorporar un “ciclo while” a nuestra aplicación se selecciona en la paleta de funciones el boton:



45



7. Una vez que se seleccione, debe irse a la pantalla del diagrama. Ahora el cursor de la aplicación cambia para indicarle que usted debe seleccionar el área que ocupará el ciclo, esto se realiza arrastrando el ratón de manera que seleccione el área necesaria, como ilustra la siguiente pantalla.


8. El ciclo tiene dos variable implícitas: la iteración representada por

y la condición de

salida, representada por . Si negamos la variable booleana y la conectamos a la condición de salida, se construye la lógica necesaria para la ejecución y salida del programa.


46



Para negar la variable booleana “stop” debemos utilizar los operadores booleanos que se seleccionan en la paleta de funciones como sigue:

9. Allí debemos seleccionar como nuestra la figura, el operdor “Not”. Y colocarlo en nuestra ventana del diagrama de la siguiente forma:

Antes de conectarlos

Después de conectarlos

10. La cadena de salida que queremos formar debe ser construida a partir de las variables que ya declaramos y de un conjunto de cadenas constantes. Una de ellas debe almacenar el valor “Usted se llama: ” otra el valor “Y nació en el año: ” para ellos se va a la paleta de funciones y se busca la paleta readicionada con el tratamiento de cadenas. A continuación se muestra su localización:


47



11. Se colocan dos controles del tipo y se selecciona el cursor en la paleta de herramientas se utiliza la tecla “tab”, hasta que el cursor en la pantalla quede de la siguiente manera:

para introducir el valor de las constantes como muestra la figura.

12. En este caso debemos concatenar cada una de las cadenas en el orden mostrado en la figura anterior. Además, hay que restarle al valor de la edad el año actual para obtener el año de nacimiento y este resultado añadirlo a las cadenas. Para ello se puede utilizar la función “Format Into String” que se encuentra:

13. Esta función retorna una cadena de caracteres que esta formada por cada uno de los elementos que se le pasan como parámetros. Estos parámetros pueden ser de cualquier tipo de dato simple (DBL, SGL, EXT, U8, U16, U32, I8, I16, I32) sin embargo el formato debe ser especificado de manera similar a como lo hace la función de C “printf” o sea : %d para enteros, %f para números con coma, %s para cadenas. En nuestro caso el formato será: “%s%s%s%d”, ya que son tres cadenas y un valor entero (el año). Para ello debe introducirse en el código de nuestro programa una constante de la misma forma que se realizó en el paso 11 y se inicializa así: %s%s%s%d para luego conectarla a la función según se muestra a continuación:


48



14. Como se observa esta función solo tiene una posible conexión de entrada pero eso es solo por el momento. Usted debe pararse justo en la base de la función y esperar a que cambie el tipo de cursor. Cuando esto suceda, debe presionar el botón izquierdo del ratón y arrastrar hasta tener exactamente cuatro entradas que deben coincidir con los tipos de datos seleccionados con anterioridad. El diagrama queda así:

15. Para obtener el año debemos introducir una constante numérica entera para almacenar el valor del año actual 2002 y un operador de resta desde la paleta de funciones numéricas. Al efectuar la resta del año menos la edad se tiene el año de nacimiento.

16 Ahora solo nos resta conectar las funciones con las variables para terminar. Para ejecutar e programa, presionamos el botón de menú y si se quiere ejecutar en modo de depuración se pueden escoger las variantes ya estudiadas. .

Ejercicio 3


49



Se desea construir un programa que permita desglosar una fecha introducida bajo el formato “DD/MM/YYYY”. El programa debe mostrar el día en un indicador de cadena; el mes, por su nombre, en un “ComboBox” y el año en un indicador de cadena. 1. Para realizar este ejercicio es necesario utilizar un control de cadena para introducir la fecha. Debemos utilizar los dos indicadores que mostrarán el día y el año. Estos controles se deben introducir de la misma manera que se hizo en el ejercicio anterior (pasos 2 y 6). Como en los ejemplos anteriores se debe colocar un control booleano que sirva para finalizar la aplicación. El resultado debe ser como se muestra a continuación.

2. Para mostrar el mes por su nombre debemos utilizar un indicador de tipo enumerado “Enum” que se encuentra en la paleta de controles bajo el botón “Ring & Enum”

3. Al introducir el elemento “Enum”, este toma la propiedad de control. Sin embargo, el uso que se le va dar es como indicador. Es por ello que se debe dar clic derecho sobre él y seleccionar la opción “Change To Indicator”. Ahora estamos listos para introducir cada uno de los doce meses del año. Para ello se selecciona el cursor en la paleta de herramientas o se utiliza la


50



tecla “tab” hasta que el cursor en la pantalla quede de la siguiente manera . Luego se coloca el cursor dentro del indicador y se introduce el primer nombre “enero”, para introducir otro mes se da clic derecho sobre el control y se selecciona la opción “Add Item After”. De esta manera se entran todos los nombres de los meses.

` La figura que se muestra encima es el “panel frontal” correspondiente a nuestro programa. En estos momentos estamos listos para programar el código que de solución a nuestro problema. Para ello debemos movernos hacia la pantalla del diagrama (Ctrl+E). Al igual que los ejercicios anteriores debemos programar en primer lugar el código G que nos permita terminar la ejecución de nuestro programa. Los pasos son similares a los vistos anteriormente y finalmente debe quedar de la siguiente forma:

Es de señalar que la variable correspondiente al indicador de tipo “Enum” es entera y cada mes tiene un número entero asociado. Para “enero” será el “0”, febrero el “1” y así sucesivamente.


51



4. Para desglosar la fecha es necesario encontrar el carácter “/” que limita el día del mes, y el mes del año. La función “Search/Split String” que se encuentra en la paleta de funciones permite encontrar un carácter específico dentro de una cadena. Esta función necesita como parámetros la cadena donde debe buscar, el carácter que se quiere encontrar y el desplazamiento a partir del inicio de la cadena donde se comenzará la búsqueda. La función retorna tres valores. La subcadena que se forma hasta el carácter que se busca, la subcadena a partir del carácter que se busca (incluyendo el carácter buscado) y el índice o desplazamiento donde se encontró el carácter.

El resultado de aplicar esta función a la cadena que contiene la fecha es el siguiente: Si la fecha es: 12/01/2005 Subcadena hasta el carácter “/”: “12” Subcadena restante: “/01/2005” 5. Para tomar el mes es necesario eliminar el primer carácter “/” de la cadena restante “/01/2005”y volver aplicar la función anterior. Para ello se puede utilizar la función “String Subset” que recibe como parámetros una cadena, la cantidad de caracteres que se quieren tomar y el desplazamiento o índice a partir de donde se tomara la subcadena.


52



6. El resultado de aplicar esta función a la cadena “/01/2005” es: “01/2005”. Ahora se debe repetir el paso 4 para obtener el mes. Sin embargo este resultado se debe mostrar en el control “Enum”. Como se dijo esta es una variable de tipo entera, por lo que debemos convertir el resultado de la función, que es una cadena con el número del mes, a un valor numérico entero. Para ello el labview cuenta con funciones de conversión de tipos. En nuestro caso esto se realiza con la función “Decimal String To Number” . El diagrama queda como sigue:

Para obtener el año se debe repertir el paso 5. con lo cu al se elimina el carácter “ /” y se obti ene el año. El diagrama final qu eda así:

Para ejecutar e programa, presionamos el botón de menú y si se quiere ejecutar en modo . Al correr el de depuración se pueden escoger las variantes ya estudiadas. programa se puede percibir que el mes que se obtiene está desplazado en uno con el que sería el correcto. Eso es así por que en la variable de tipo “Enum” el mes de enero tiene asignado el valor 0, este mes no existe. Para resolver este problema, después de la conversión de cadena a número se debe restar una unidad. El diagrama queda de la siguiente manera:


53




54



TEMA IV Control d e Flujo de progr ama en LabVIEW. Estruct uras repetit ivas. • • •

Lazos de contro l de progr ama (While y For). Shift Registers (Registros de Desplazamiento). Nodo fórmula. Visualización gráfica de datos.

Ejercicio 1: Realice un programa que permita encontrar el máximo de 100 números generados aleatoriamente. Represente gráficamente los números generados. Desarrollo: El ejercicio una vez terminado debe conducir a una representación en Lenguaje G como la que se muestra a continuación en la ventana de diagrama o código del LabView:

Veamos como desarrollar paso a paso dicho ejercicio. Primero, una explicación de lo que se nos pide. Se necesitan generar 100 números aleatorios, lo que implica utilizar un generador de números aleatorios y un lazo de control de programa o repetición que permita que ese generador de números aleatorios nos entregue 100 de dichos números. Cada vez que se nos entregue un número, o sea, con cada iteración del bucle o lazo, se debe comparar el número generado con el número máximo hasta ahora generado. Eso nos indica que debemos realizar una comparación que busque el máximo y almacenarlo para comparar en cada iteración con el nuevo número. Se nos pide que representemos gráficamente dichos números por lo que debemos agregar un gráfico a nuestro diseño encargado de plotear en cada iteración el número aleatorio a procesar. Como descomponer entonces con LabView dichas operaciones? 1. Primero debemos crear el lazo de control o bucle. Para ello seleccionamos de la paleta de funciones del LabView las funciones de estructuras y dentro de ella la del ciclo For. El ciclo for es el escogido porque en este caso necesitamos repetir la operación de comparación en la búsqueda de un máximo 100 veces, invariablemente. Si estuviéramos sujetos a alguna condición entonces deberíamos de haber seleccionado un lazo condicional, o sea, un While. La siguiente figura ilustra como hacer la selección:


55



2. Una vez que se ha puesto el ciclo for debemos definir el alcance del mismo. Se recuerda que un ciclo for en LabView siempre va desde 0 hasta N-1, siendo N el valor a definir. Aquí queremos realizar las operaciones 100 veces por lo que debemos definir para N un valor de 100. Esto se realiza creando una constante y conectándola con N. Es muy sencillo, la siguiente figura ilustra como hacerlo. El menú que allí aparece se obtiene dando clic derecho encima de N:

3. Cuando la constante se crea, aparece con valor 0. Debemos cambiar dicho valor y poner 100, como se muestra en la siguiente figura:


56



4. Necesitamos ahora generar un número aleatorio y compararlo con algún máximo. Por supuesto, el primer número aleatorio no tiene referencia de comparación, pero como debemos comparar dentro del ciclo for, basta con compararlo con el menor valor posible que se pudiera generar, en este caso 0, con lo cual garantizamos que el primer número aleatorio siempre será el primer máximo contra el cual comparar después los sucesivos que se generarán. LabView presenta un componente que realiza la comparación entre dos fuentes o números, y devuelve el mínimo valor de entre los dos y el máximo. La siguiente figura muestra como seleccionar dicho componente (Functions/Comparison/Max & Min):

Se inserta en la ventana de diagrama dentro del ciclo for:


57



5. Necesitamos ahora encontrar alguna función que genere números aleatorios. LabView tiene un componente en Functions/Numeric/Random Number (0-1):

Si quisiéramos generar un número aleatorio en un rango diferente podemos multiplicar el número generado con esta función por el valor máximo que queremos generar. Puede modificar el ejercicio como estudio independiente ahora intentando buscar el máximo de 100 números aleatorios en el rango de 0-50. Una vez introducidos en el diagrama el generador de números aleatorios y la función que devuelve el máximo entre dos números debemos entonces buscar la forma de almacenar el máximo que resulta de cada iteración para compararlo con el número generado en la siguiente iteración. Si se analiza bien esto lo que necesitamos es comparar el número generado en la iteración i (denotemos por n(i) a dicho número) con el máximo que resultó de la iteración i-1. Esta es una de las funciones que puede brindarnos el registro de desplazamiento o shift register de LabView.


58



El shift register desde el punto de vista de la programación es una estructura tipo arreglo asociada con lazos de control o bucles de programa como el for y el while y que almacena valores anteriores producidos en dichos lazos. Así, por ejemplo, si obtenemos como resultado de una iteración i un valor v(i) al final de dicha iteración, al comienzo de la próxima al i incrementarse en uno, dicho valor se almacena como v(i-1). Dos iteraciones hacia delante será v(i-2) y así sucesivamente. La siguiente tabla ilustra dicho concepto con ejemplos numéricos: Iteración 0 1 2 3 4 5 6

V(i) 5 3 0.7 1 -1 0 2

V(i-1) 5 3 0.7 1 -1 0

V(i-2) 5 3 0.7 1 -1

V(i-3) 5 3 0.7 1

V(i-4) 5 3 0.7

V(i-5) 5 3

y así sucesivamente.... 6. Para adicionar Shift Registers con LabView se selecciona la estructura for y se da clic derecho sobre ella. El siguiente menú aparece:

Al seleccionar de dicho menú la última opción, Add Shift Register (Adicionar registro de desplazamiento) se inserta en el diagrama como se muestra en la siguiente figura:

7. Antes de realizar las conexiones entre los elementos debemos además seleccionar algún componente que nos permita visualizar gráficamente los números aleatorios que


59



se van generando. Para ello nos vamos al panel frontal y con clic derecho visualizamos el siguiente menú:

Al seleccionar la opción Controls/Graph/Waveform Chart obtenemos un gráfico como el que se representa en la pantalla frontal de la siguiente figura, donde también se representa el contenido de la ventana de diagrama hasta este momento:

8. A continuación se realizan las conexiones entre los elementos. La salida del generador de números aleatorios se conecta al bloque de comparación de números, y a la entrada del control gráfico. El shift register de la derecha debe almacenar el último valor del máximo calculado y que se obtiene como salida del módulo de comparación. La siguiente figura muestra las conexiones a realizar:


60



9. Una vez realizadas estas conexiones el ejercicio está prácticamente concluido. Note que la primera vez que se compara en el bloque de comparación se hace entre un primer número aleatorio y el valor del shift register. Ya se explicó como funciona el shift register y debemos notar que antes de concluir la primera iteración no tenemos un valor con el cual comenzar para el shift register que adquiere uno al final de cada iteración. Eso nos indica que tenemos que inicializarlo, darle un valor inicial con el cual empezar y evaluar la iteración 0 . Note además que cuando se llega a la última iteración el valor actual que contiene el shift register es el del último máximo calculado, y por tanto el valor que debemos reportar como resultado. Es por ello que entonces debemos crear un indicador para visualizar el último máximo y una constante para definir la condición inicial del shift register. Las figuras que se muestran a continuación ilustran como hacerlo. Los menús que allí aparecen se obtienen al dar clic derecho encima de los shift registers.


61



El resultado final se muestra en la siguiente figura. Note que el valor inicial del shift register es 0.00 pues es el mínimo que puede tomar el número aleatorio y no afectará la selección del primer máximo.

10. Antes de ejecutar el programa es conveniente modificar algunos parámetros del gráfico, en particular los relacionados con los ejes, que debemos modificar para permitir la auto escala. Las figuras a continuación muestran la manera de hacerlo (siempre clic derecho en el objeto para obtener el menú):


62



11. Finalmente salvamos el ejercicio y lo ejecutamos. Un ejemplo de ejecución se muestra en la siguiente figura:


63



Por último, señalar que si queremos que el gráfico se represente más lentamente podemos incluir una demora (Functions/Time & Dialog/ Wait Until Next ms Multiple) o seleccionar el indicador de ejecución paso a paso. La siguiente figura muestra como quedaría el ejercicio para una demora de 50 milisegundos:

En la figura anterior también se a insertado otro indicador, llamado max(x,y). Que función tendría?

Ejercicio 2: En este ejercicio se propone realizar la descomposición de la fecha introducida en un control tipo Edit (Edición) de una manera más eficiente (comparada con la primera solución a este ejercicio que ya se vio en una guía anterior), haciendo uso de los shift registers. Desarrollo: En clases anteriores se ofreció una solución al problema de desglose de una fecha en sus componentes de día, mes y año. Aquella solución introducía algunos componentes para el procesamiento de cadenas que se encuentran dentro de las funciones de LabView. En dicha


64



solución los componentes se repetían, pero hay una forma más eficiente de resolverlo haciendo uso de los shift registers. La solución final se ofrece en la siguiente figura:

Se recuerda la función y terminales de los dos elementos principales involucrados:

Antes de pasar a una explicación más o menos detallada de como construir la solución en la pantalla de diagrama veamos algunos razonamientos de como proceder con los shift registers: 1. Se quiere dividir una cadena que representa la fecha en sus tres elementos constitutivos, o sea, el día, el mes y el año que la conforman. 2. La operación siempre es la misma: se extrae de la cadena una subcadena que representa un componente de la fecha (o el día, o el mes o el año) y se elimina de la subcadena que resulta de extraer dicho componente el separador /. 3. El proceso se repite 3 veces.


65



El punto 3 nos indica que podemos utilizar un lazo condicional, o sea, un while, pues siempre dentro del while se hará lo mismo (punto 2). La subcadena que representa el componente extraído debe almacenarse para brindar los resultados finales. Como entonces utilizar los shift registers? Quizá una manera en que podemos verlo es representando el proceso, para una fecha ejemplo, a través de las iteraciones. La siguiente tabla lo ilustra: Cadena inicial

Iteración

Componente resultante

8/02/2005 02/2005 2005

0 1 2

8 02 2005

Subcadena después extraído componente /02/2005 /2005 “”

Subcadena de después de el extraer el separador (/) 02/2005 2005 “”

Como se puede apreciar por cada iteración se obtiene un componente resultante, primero el día, después el mes y por último el año. Si denotamos por c(i) al componente resultante se puede ver que después de la iteración 2 c(i)=2005, c(i-1)=02 y c(i-2)=8. Dicha secuencia es la que precisamente nos pueden brindar los shift register si creamos los suficientes en el diagrama como para almacenar los valores c(i-2), c(i-1) y c(i). Necesitamos además de una iteración a otra almacenar la subcadena resultante después de extraer el separador que será la nueva cadena inicial con la cual trabajar en la próxima iteración. Veamos pues como hacerlo. 1. Primero debemos de crear el lazo condicional while en nuestra aplicación:

2. Debemos ahora definir la condición de parada. Queremos que el lazo funcione mientras la iteración no sea mayor que dos, por tanto, la condición de ejecución del while debe ser i<=2. La siguiente figura nos indica como quedaría (el componente de comparación aparece en Functions/Comparison/Less or Equal?):


66



3. En el panel Frontal debemos insertar un control de tipo String para poder teclear la fecha que se quiere descomponer (Controls/String & Path/String Control):

Note que en la siguiente figura el control generado en el panel frontal tiene asociado una variable que debemos ubicar fuera del lazo while pues es la cadena inicial que hay que descomponer. 4. Insertamos ahora en la ventana de diagrama el componente Search/Split String (Functions/String/Aditional String Functions/Search Split String):

5. Una vez introducido dicho componente se crea el primer shift register, que tendrá la función de almacenar la subcadena resultante después de cada iteración. En la siguiente figura aparece representado. A la función de dividir (Split) cadenas se le asigna en cada iteración la cadena inicial (ver tabla página 13) que está almacenada en el shift register (por ejemplo, si en la iteración que acaba de concluir quedó 02/2005 ese valor se almacena en el shift register de la derecha y cuando se incrementa i para iniciar una nueva iteración esa cadena (ahora, después de incrementada i es el resultado de la iteración i-1) LabView la pasa o ubica en el shift register de la izquierda para que sea usada en la iteración i).


67



Como ya mencionamos anteriormente, los shift register tienen que tener un valor inicial, para que sea el valor con el cual comienza a trabajar la iteración 0. En este caso el valor inicial es la cadena inicial introducida en el edit, o sea, la fecha completa que se quiere dividir. En la figura anterior se mostró la conexión que inicializa al shift register. 6. Una vez introducido este registro de desplazamiento hay que completar las entradas del modulo de división de cadena. Para ello se agregan dos constantes en la entrada, y se le dan, respectivamente, valores de / (que es el separador) y 0. Dichos valores le indican al Labview que la cadena que tiene en su entrada y que será dividida en dos se comenzará a explorar desde el primer elemento (elemento 0) hasta detectar el carácter /.

Esta función tiene dos salidas, la primera es la subcadena encontrada antes del carácter que divide la cadena de entrada en dos cadenas (en nuestro ejemplo /). La segunda salida es la cadena que se encuentra desde el separador hasta el final. Note que incluye al separador. Las dos salidas serán de utilidad, la que está delante del separador es el componente de la fecha que estamos separando (día, mes o año) y la segunda la que hay que seguir separando. Que hacer con la primera? Hay que almacenarla pues de lo contrario en la próxima iteración tendré otra componente resultante de la comparación que cambiará la salida de la función Search/Split String. 7. Para ello debemos utilizar un nuevo shift register, en este caso, uno que tendrá la función de los componentes resultantes. La siguiente figura indica la forma de insertarlo:


68



8. Que conectar al shift register que no aparece conectado en la figura anterior? Recuerde que será el encargado de almacenar la cadena que en la próxima iteración servirá de inicio para buscar el nuevo componente de la fecha. Note además que no se puede conectar directamente a la salida de la primera función (Search/Split Function) pues esa salida incluye todavía el separador (ver tabla pág. 13) y hay que eliminarlo. Para ello se usa la función que se representa en la siguiente figura (Functions/String/String Subset)

También se pudo utilizar una segunda función split, pero la que se ha escogido es la más representativa de lo que se quiere hacer puesto que recibe a su entrada una cadena y devuelve la subcadena que se encuentra desde la posición k hasta la l, donde k y l son otras entradas de la función. Nosotros queremos tomar la cadena que sale de la función Search/Split... y quitarle el separador, o sea, quedarnos con el subconjunto o subcadena que se encuentra desde la posición 1 (en la posición 0 está el separador hasta el final):


69



9. Ahora si podemos conectar la salida de esta función String Subset al shift register de su derecha:

10. Hasta aquí lo que está programado funciona bien pero no nos permite visualizar todos los resultados. El resultado se obtiene en el shift register que en la figura anterior no está conectado. Que componente se obtiene ahí después de concluida la última (i=3) iteración? La respuesta es que se obtiene el valor del shift register asociado (el de la parte derecha a su mismo nivel) en la iteración i-1. Cual es ese valor? Del ejemplo de la Tabla en la Página 13 podemos ver que es el año. Note que al final de la última iteración el valor del shift register asociado de la derecha era “”. Conectemos entonces un indicador tipo string al shift register no conectado hasta ahora (clic derecho, en el menú que aparece seleccionar Create/Indicator). Cambiando el nombre del indicador por el de año obtenemos:


70



11. Eso nos permite visualizar el año. Pero y el mes? Si el año fue el valor resultante en la iteración i-1, es de suponer que el mes es el valor resultante en la iteración i-2. Pero ese valor no lo tenemos almacenado. Hay que almacenarlo. Crear elementos del shift register para las iteraciones i-2, i-3, i-4,.... es fácil . Solo hay que agregar un elemento al shift register ya creado. La siguiente figura muestra como hacerlo. El menú que aparece en ella se obtiene con clic derecho sobre el shift register de la derecha (el conectado al indicador de año):

El resultado:

12. Debemos agregar otro nivel, (el de i-3) para el componente día de la fecha:


71



A cada nivel creado se le asocia el indicador de cadena correspondiente, de la misma forma que se hizo con el año:

13. Antes de concluir debemos realizar una operación más. Hay 3 elementos en el registro de desplazamiento asociado con el año, el mes y el día que no han sido inicializados. Que valor les corresponde? Aquí en realidad no tiene importancia el valor que le demos pues solo están conectados (los elementos del shift register) y por lo tanto el valor que al concluir el while mostrarán serán los componentes de la cadena fecha. Sin embargo, es una práctica sana inicializarlos, y por eso se hará, dándole un valor inicial de “” que indicará cadena vacía. La siguiente figura muestra como hacerlo:


72



La constante de cadena vacía se encuentra definida en la biblioteca de funciones de LabView Functions/String/Empty String constant. En la ventana o panel frontal nuestro diseño sería más o menos así. Para probar que nuestro programa se ejecuta debemos antes de ejecutarlo darle un valor inicial a la fecha que se descompondrá, editando en el control Fecha el valor:

Después de una ejecución, y para esa cadena se obtiene:


73



Ejercicio 3: Realice un programa en LabView que permita gráficar la función seno hasta que se oprima el botón parar. Desarrollo: Este ejercicio nos permitirá conocer como trabajar con el Nodo Fórmula. Que se nos pide? Graficar la función seno(x) hasta que se oprima un botón. Eso nos indica que debemos ubicar un lazo o bucle de repetición condicional, o sea, un while. La condición de parada del while la producirá el clic sobre un botón. Dentro del while debemos de estar evaluando, para cada iteración a la función seno(x). Que valor le damos a x? Podemos usar el mismo valor de la iteración i. El único problema es que el seno(x) espera el valor en radianes por lo que hay que convertir el valor de i a dicha unidad, y después calcular el seno. Este es un caso típico en que un nodo fórmula nos simplifica mucho el trabajo. Veamos la solución. 1. Primero comenzamos creando el ciclo while y un botón (ya se sabe como hacerlo de clases anteriores):

En la figura anterior aparece nuevo el elemento negado, que conecta al botón con la condición de ejecución del while. En clases anteriores vimos que se podía también cambiar la condición de ejecución del while con clic en ella: aparece un circulo rojo. En versiones anteriores a la 6.0 no existía dicha posibilidad. 2. Después de introducido el while se crea el nodo fórmula según se muestra en la siguiente figura:


74



3. Una vez creado el nodo fórmula tenemos que indicar cuales serán las variables de entrada de dicho nodo y cuales las de salida. Comenzando por las de entrada se adicionan de la siguiente manera (el menú aparece al dar clic derecho en el nodo fórmula):

4. A dicha entrada le damos el valor de nx:


75



5. Ahora debemos editar dentro del nodo fórmula el contenido de lo que se quiere calcular. Para este caso son 3 lineas. Note la similitud entre C++ o Matlab y el lenguaje que admite el nodo fórmula. Dicho nodo es compatible con ANSI C. 6. La fórmula convierte de grados a radianes y calcula el seno. El valor calculado lo devuelve en la variable y, que hay que declararla como salida del nodo de la misma forma que la entrada pero ahora seleccionando la opción Add Output. Una vez hecho esto se realiza la conexión entre el indicador de iteración i y la variable de entrada nx. La siguiente figura muestra como debe quedarnos la aplicación hasta este momento en la ventana de diagrama:

7. La salida, que se produce en cada iteración, podemos conectarla a un componente para plotear gráficos de la misma manera a como lo hicimos en el ejercicio 1:


76



La salida “y” del nodo fórmula se conecta al gráfico:

La figura que se muestra a continuación es el resultado de la ejecución del programa:


77




78



TEMA V Mas estructuras de control de flujo. • •

•

Dominar la estructura de cont rol CASE. (if-then-else ó switch[C++] ) Dominar la estructura “Secuence” para secuenciar el flujo de programa (alternativa a la programación por nodos). Dominar la estructura de manejo de eventos.

Ejercicio 1: Elabore un programa en LabView que permita calcular la raíz cuadrada a un número real. El programa debe analizar si valor introducido es menor que cero (situación de error) e indicar al usuario por medio de un cuadro de mensaje la situación. Solución: Como toda aplicación esta debe comenzar con la realización del código necesario para ejecutar y terminar la aplicación. Para ello debe colocar un botón booleano de salida y realizar el código siguiente:

Ahora debemos diseñar la interfaz de usuario de nuestra aplicación. Para ello simplemente colocamos un control numérico digital que reciba por parte del usuario el valor al cual se le calculará la raíz cuadrada. Además, debemos colocar un indicador (también digital en este caso) para visualizar el resultado de la operación. Esto queda de la siguiente manera:


79



Ya estamos listos para programar en “Código G” la lógica de nuestra aplicación. Por lo tanto utilizando (Ctrl+E) vamos a la pantalla del diagrama en bloques, que luce de la siguiente forma:

La operación de cálculo de la raíz cuadrada implica realizar una operación de comprobación antes de efectuarla, y esto depende del valor del número. Si este es positivo se puede hacer, sino debe indicarse un mensaje. Véase que existe una condición mediante la cual se bifurca el flujo de programa. Para ello es necesario utilizar una estructura clásica del tipo IF-THEN-ELSE, que el caso de labVIEW se denomina “Case Structure” y se puede obtener según se indica en las figuras siguientes:


80



Esta estructura está representada por un marco y un titular área donde se programa el código asociado a la condición de

que representa el

true: y el código asociado a la condición de false: . Note que usted puede conmutar entre uno y otro según desee utilizando las flechas, y que los elementos de código para uno u otro son diferentes.

Según nuestra lógica, si el valor numérico es positivo, se realiza la operación de raíz, esto se consigue utilizando las funciones numéricas como se muestra a continuación:


81



El código complementario, cuando no se puede efectuar la operación debido a que el número es falso, se reduce a colocar un cuadro de mensajes que alerte al usuario. Para ello se utiliza en la paleta de funciones un “One Button Dialog” y un “String Constant” según se observa a continuación:

Ahora solo nos resta realizar la comparación y conectarla a la estructura “case” para determinar cual de las dos acciones posibles se realizará en tiempo de ejecución. Para ello necesitamos comparar la variable correspondiente al control numérico relacionado con el valor a calcular. Sin embargo ya hemos utilizado el terminal asociado al mismo, por lo que debemos crear una variable local de ese control. Esto se hace dando clic derecho sobre la variable , seleccionando la opción “Create” y a su vez “Local Variable”. Usted debe recordar que las variables en LabVIEW pueden ser de escritura o lectura. Al crear una variable local estas son de escritura por defecto , aquí se utilizara para compararla y saber si es mayor que cero, por lo que no la modificaremos. En este caso hay que cambiarla para su tipo de lectura, esto se hace dando clic derecho sobre ella y seleccionando la opción “Change To Read”:


82



Para comparar el valor de la variable, se debe utilizar la función de comparación “Grater Or Equal To 0?” que se encuentra en la paleta de funciones. El resultado de esta comparación es “True” o “False” y sirve de condición a la estructura “Case” por medio del selector decidirá según su estado “booleano” cual código realizar.

que

Ya se está en condiciones de correr la aplicación, sin embargo usted se dará cuenta de que la ejecución de la aplicación no es “buena”. Cuando se introduce un valor negativo se ejecuta indefinidamente la opción de mostrar el cuadro de diálogo por lo que se bloquea la aplicación. Este problema se soluciona muy fácilmente introduciendo un botón de cálculo, según el cual se realizan las operaciones. Para ello se debe utilizar una estructura “case” más externa gobernada por el botón de cálculo.


83



Para obtener los resultados esperados la acción mecánica (Mechanical Action) debe colocarse en uno de los siguientes estados: Latch w hen Pressed Latch w hen Released Latch until Released • • •


84



Si no se utiliza este modo persisten los errores planteados al principio. ¡Compruébelo y obtenga conclusion es! Estudio Individual Realice una calculadora capaz de hacer las operaciones básicas de suma, resta, multiplicación y división entre dos números reales. Utilice un control de tipo “Menu Ring” para indicar la operación a realizar. Note que este elemento gráfico está representado por una variable de tipo y que según su valor debe realizarse una operación de las cuatro mencionadas. Además, debe utilizar dos controles para los operandos y un indicador para el resultado.

Ejercicio 2: Elabore un programa en LabView que permita animar un control de labVIEW. El control debe describir la figura geométrica de un cuadrado con aristas de 100 pixels. Solución:

Como toda aplicación esta debe comenzar con la realización del código necesario para ejecutar y terminar la aplicación. Para ello debe colocar un botón booleano de salida y realizar el código siguiente:


85



Ahora debemos escoger un control que sirva de figura de animación, en este caso se escogió el control booleano “Square LED” aunque pudo haber sido cualquier otro. Si no se desea ver la etiqueta asociada usted debe dar clic derecho sobre el control y desmarcar la opción “Label” dentro del submenú “Visible Ítems”.

Antes de comenzar a programar debemos analizar como enfrentar este ejercicio. Para animar el control se deben utilizar sus propiedades “Top” y “Left”, primera para moverse en dirección vertical y la segunda para moverse en dirección horizontal. Como se necesita variar las coordenadas del mismo de acuerdo a la siguiente secuencia de pasos: • • • •

Incrementar 100 veces en una unidad la propiedad “Left”. Incrementar 100 veces en una unidad la propiedad “Top”. Decrementar 100 veces en una unidad la propiedad “Left”. Decrementar 100 veces en una unidad la propiedad “Top”.

Es importante darse cuenta que para realizar cada una de estas acciones es necesario repetir 100 veces las acciones de incrementar o decrementar las propiedades según el caso. Para ello se debe utilizar la estructura “For Loop” según se muestra a continuación:


86



Esta estructura ya fue estudiada y su principal conexión es la variable que define la cantidad de iteraciones a realizar, que en nuestro caso es de 100 y se define dando clic derecho sobre el punto según las figuras siguientes:

Para realizar la primera de la acciones es necesario obtener la propiedad “Left”. Esto se realiza dando clic derecho sobre la variable y seleccionando la opción “Property Node” dentro de “Create”. Sin embargo usted debe verificar que esta acción crea por defecto propiedad “Visible” como se muestra en estas figuras:

Para obtener la propiedad “Left” se debe dar clic derecho sobre la propiedad por defecto y seleccionar la opción “Properties” que define la propiedad deseada. En nuestro caso se obtiene como se muestra a continuación.


87



Como debemos incrementar la propiedad “left” necesitamos otro nodo con esta propiedad, pero esta vez que sea de escritura. Para convertir la propiedad de lectura a escritura debemos dar clic derecho sobre ella y luego seleccionar “Change To Write”.

Para realizar la operación de incremento se utilizará la operación matemática de funciones numéricas. El código queda de la siguiente manera.

de la paleta

Ahora podemos ejecutar la aplicación y el control se moverá de izquierda a derecha 100 unidades. Sin embargo, este es el primero de los cuatro pasos necesarios. Es por ello que es útil introducir la estructura “Secuence” que ofrece varios marcos donde se puede programar, como su nombre lo indica una, secuencia de códigos que se ejecutaran paso a paso. Como el primero de ellos ya está programado nuestra secuencia incluirá el código ya programado para moverse verticalmente y hacia la derecha.


88



Para incluir hacia una nueva secuencia o marco (Frame) se selecciona la estructura “Secuence” y se hace clic derecho sobre ella, entonces se selecciona la opción “Add Frame After”.

¡NO SE ALARME!! Su código no ha desaparecido simplemente se ha superpuesto un nuevo marco para programar la secuencia siguiente. Usted puede volver al código anterior seleccionando las flechas del titular , que muestra el marco de trabajo actual y la cantidad de marcos o secuencias programadas. El código que se debe utilizar esta vez es muy parecido al anterior pero en este caso se utilizará la propiedad “Top” en vez de “Left”. Obtener esta propiedad es muy similar a obtener la anterior y esto se muestra a continuación:

El código para este caso queda de la siguiente manera:


89



Como se puede ver cada uno de los cuatro pasos es muy similar al anterior. Existe una forma fácil de reproducir el “Código G” programado en una secuencia para otra. Para ello se hace clic derecho sobre ella, y se selecciona la opción “Duplicate Frame”. Ahora solo debemos sustituir las operaciones de incrementar por decrementar ya que se quiere viajar de derecha a izquierda y de abajo hacia arriba. A continuación se ven los pasos 3 y 4 necesarios para cumplir los objetivos del programa.

Si alguno de los marcos no coincide con su orden correcto de ejecución usted debe seleccionar su marco correspondiente, luego dar clic derecho sobre su borde y ejecutar la opción “Make This frame” y establecer el orden que requiera según su lógica (Figura siguiente).


90



Estudio Individual Realice un programa que permita que un control se mueva en el panel frontal de manera que describa una circunferencia con un radio de 100 unidades. Recuerde que la ecuación de una circunferencia es Y2 = (R2 - X2).

Ejercicio 3: Elabore un programa en LabView que permita manipular el evento “Mouse Down” de un control booleano de LabVIEW para mostrar un cuadro de mensajes con el cartel “Hola Mundo !!” Solución: Como toda aplicación esta debe comenzar con la realización del código necesario para ejecutar y terminar la aplicación. Para ello debe colocar un botón booleano de salida y realizar el código siguiente:

El diseño de la aplicación es muy sencillo toda vez que solo es necesario introducir otro control booleano: la interfaz queda como sigue:

Para manipular el evento asociado con el “Botón OK” es necesario introducir la estructura de eventos que se encuadra en la paleta de funciones en la página “Structures”. Una vez que se selecciona como muestran las figuras se extiende su marco dentro del marco del ciclo “while” general.


91



Para introducir un manipulador de eventos se da clic derecho sobre uno de sus bordes y se selecciona la opción “Add Event Case”. A continuación se muestra una ventana de configuración tal y como se ve en las figuras siguientes:

En la parte inferor izquierda se muestran todos los controles que contiene nuestra aplicación, en este caso está el botón de salida “stop” y el botón “Ok Button”. Al seleccionarlo dando clic sobre él se muestran en la parte inferior derecha los posibles métodos que usted puede manipular. En nuestro caso será “Mouse Down”. Seleccione esta opción dando clic sobre él y luego presione “OK”.


92



Ahora usted puede notar que se añade un nuevo marco a la estructura de eventos con el titular: lo que quiere decir que todo el código que se coloque en su interior será ejecutado cuando ocurra el evento señalado en el mismo. En este caso “Mouse Down” sobre “OK Button”.

El código que hay que introducir es muy simple. Los pasos son los siguientes: Tomar una función de diálogo Una constante de cadena • •


93



El código final de la aplicación es el siguiente:

Estudio Individual Realice un programa que permita manipular el evento “Value Changed” (ocurre cuando cambia su valor) de un control de cadenas para que el color del texto que contiene conmute siempre entre dos colores que usted seleccione.


94



TEMA VI Tipos de Datos Complejos. Arreglos y Clusters Definici ón y Trabajo con A rreglos en LabView Definici ón y Trabajo con Clusters • •

Ejercicio No.1 Declarar un arreglo de números de una dimensión y colocar 10 elementos según el usuario decida. Obtener el valor promedio de ellos y asignar el quinto elemento a un control de tipo “Tank”. Reemplazar el tercer elemento con el octavo. Solución: Primero, realicemos el diseño general de la pantalla frontal de la aplicación. Necesitamos colocar un indicador tipo tanque (tank), y un arreglo de 10 elementos. El control tipo tanque ya sabemos donde encontrarlo, por lo que explicaremos directamente como crear el arreglo de 10 elementos. La siguiente figura muestra la primera parte, donde (a), (b) y (c) definen el orden (b y c ocur ren al mismo tiempo):

(b)

(a)

(c)

Observe que al colocar el arreglo en el panel frontal en la ventana de código se crea un arreglo sin tipo. El primer paso después de crear el arreglo es definirle un tipo, para lo cual debemos insertarle un indicador o un control dentro del arreglo creado. Esto se hace en la ventana o panel frontal, como se indica por pasos en la siguiente figura:


95



(a)

(c)

(d)

(b) En (d) se muestra lo qu e se refleja en la pantalla de dis eño después de haber ins ertado el control digital dentro del arreglo creado. El procedimiento es sencillo, como se indi ca en (a) se escoge el control adecuado, y se arrastra con el mouse hasta ubicarlo dentro del arrglo ( figura (b)), en ese momento LabView cambia la figura y le define el tipo al arreglo asociado al control. En un siguiente paso debemos lograr visualizar los 10 elementos del arreglo. Aunque esto no es necesario (note que existe el indicador de indice para poder movernos entre los elementos del arreglo, siempre que se pueda debe ofrecérsele al usuario la posibilidad de ver todos los elementos del arreglo. Para mostrar todos los elementos del arreglo basta con seleccionar al objeto y ubicar el mouse en la esquina inferior derecha, presionar el botón izquierdo del mouse (sin liberarlo) y moverlo hacia abajo 9 posiciones más. De esta manera obtendremos en el panel frontal algo similar a lo que se muestra en la siguiente figura:


96



Note que como no se han definido valores en el arreglo, estos aparecen en gris. A medida que se vayan definiendo dichos valores la dimensión efectiva del arreglo irá cambiando, hasta completar los 10 elementos. Para terminar el diseño del panel frontal debemos introducir un indicador tipo tanque y otro digital, este último nos servirá para indicar el promedio de los elementos del arreglo. El resultado final debe ser: Note que el indicador digital del promedio se ha editado para cambiar la etiqueta por defecto (numeric) y poner Promedio.

En la ventana de código después de estos pasos se han creado tres elementos, el arreglo, el indicador del tanque y el del promedio:


97



Ahora, debemos de programar nuestra aplicación. Empecemos por el promedio. Sabemos que tenemos 10 elementos en el arreglo, por tanto lo único que necesitamos es un ciclo para recorrer el arreglo e ir sumando los elementos. Una vez que estén sumados los elementos, ya fuera del ciclo, dividimos el resultado por 10. Para ir almacenando el resultado de la suma en cada iteración podemos utilizar los shift registers vistos en ejercicios anteriores. El valor inicial del shift register , antes de la primera suma, debe ser cero, para que no la afecte. El último valor almacenado en el shift register , justo cuando termina el lazo for es precisamente la suma, que entonces pasamos a dividir por 10. La siguiente pantalla muestra el resultado:

Por defecto, cuando uno conecta un arreglo a un lazo, LabView asume que el arreglo se va a indexar con la variable del ciclo, o sea, que para cada iteración se utilizará el elemento array[i] del arreglo declarado. Si no se quiere que suceda así podemos inhabilitar el indexado seleccionando el lazo for y dando clic derecho encima del nodo que representa el arreglo: En este ejercicio se quiere trabajar con el indexado por lo que no debemos inhabilitarlo. En caso de que se inhabilite, el ciclo recibe el arreglo completo, y no elemento a elemento, compruébelo!.


98



Ya tenemos una parte del ejercicio resuelto. Veamos ahora como conectar el elemento 5 del arreglo con el indicador tipo tanque ( tank). En este punto es conveniente realizar una observación importante. Al igual que en muchos otros lenguajes, LabView comienza a indexar los arreglos con 0, o sea, que el primer elemento tiene índice 0 . Esto significa que nuestro 5 elemento tiene el índice 0. Hay muchas funciones programadas en lenguaje G para trabajo con arreglos. Ellas se encuentran agrupadas en la paleta Functions/Array que se muestra a continuación:

Una de las funciones presentes en esta biblioteca o librería de funciones es la que dado un índice me devuelve el valor del elemento. Dicha función es la segunda comenzando por l a esquina superior izquierda:

La función espera como entrada que se le conecte un arreglo y al menos se le especifique un índice. Si se le especifica un índice solamente, entonces devolverá el valor del elemento en ese índice. Si se le especifica más de un índice devuelve un subarreglo con los valores de los elementos en esos subíndices. En nuestro caso necesitamos saber el valor del elemento 5, cuyo índice es 4, y una vez que tengamos dicho valor, lo conectamos directamente al indicador tipo tanque. La siguiente figura indica como hacerlo:


99



Si evaluamos hasta ahora lo que hemos hecho en el programa introduciendo valores ejemplos en el panel frontal para los distintos elementos del arreglo, tendremos un resultado como el que se muestra a continuación (note que los valores de los elementos del arreglo fueron 1,2,3,4,5,6,7,8,9,10):


100



La última parte del ejercicio es quizás la más compleja a primera vista, aunque veremos que no es difícil su programación. Qué queremos hacer? Simplemente intercambiar los valores de dos elementos de un arreglo. En cualquier otro lenguaje sería algo así como (se pone pseudocódigo, sin seguir una sintaxis particular): temp=array[2]; array[2]=array[7]; array[7]=temp; donde temp es una variable temporal que se usa para almacenar el valor del 3 elemento del arreglo antes de sobreescribir en él el nuevo valor. En el segmento de programa anterior es notable observar como no se puede hacer un paralelismo, o sea, la instrucción 2 no puede realizarse si no se ha realizado la primera pues de lo contrario perderíamos para siempre el valor inicial que tiene el 3er elemento del arreglo (array[2]). Esto nos da una idea de que el segmento se debe ejecutar secuencialmente, una acción primero y otras después . En LabView nosotros conocemos que podemos programar secuencias, pues hay una estructura de control de programa para realizarlas. Dicha estructura nos permite crear una variable local ( llamada sequence local ) que en este caso nos serviría para almacenar el valor inicial del 3er elemento y enviarlo a la siguiente secuencia para su uso (3era instrucción del pseudocódigo anterior). Por otra parte, ya conocemos como leer el valor de un elemento del arreglo, pero no sabemos como escribir un nuevo elemento. Para escribir un nuevo elemento del arreglo se utiliza otra función de la librería, que también se encuentra en functions/Array : Esta función recibe como parámetros de entrada el arreglo de dimensión n y el índice(s) del (los) elementos a reemplazar, así como el elemento o


101



subarreglo que reemplaza al original. Como salida devuelve el nuevo arreglo. Ya estamos listos para concluir el ejercicio. La siguientes figuras explican la manera de solucionarlo:


102



Con este primer paso se ha ejecutado la primera instrucción del pseudocódigo comentado anteriormente. Para la instrucción 2 se programa en el segundo cuadro de la secuencia:


103



y para la tercera, se utiliza el valor local que viene del primer frame o cuadro de la secuencia, de la siguiente manera:


104



Finalmente, hay que actualizar el valor del arreglo. Esto es muy importante puesto que si no se realiza los cambios no se hacen efectivos, o sea, al control Array declarado, hay que actualizarlo. Para esto, debemos escribir en un control utilizando LabView. En realidad la manera de hacerlo es sencilla. Debemos crear una referencia a dicha variable, o sea, una variable local copia de la misma para entonces poder actualizar mediante una escritura en esa copia de la variable local. Para esto, seleccionamos el arreglo y damos clic derecho, seleccionando la opción Create/Local v ariable :

LabView crea entonces una variable local: Arrastramos dicha variable hacia donde se encuentra programada la secuencia y la conectamos de la siguiente manera:


105



Esto concluye nuestra aplicación. A continuación se muestran dos pantallas, una antes de la simulación y otra después. Note como los elementos 3ero y 8vo han intercambiado sus valores:


106



Ejercicio No.2: Se desean generar tres arreglos de 10 elementos con las siguientes características: El Primero contendrá 10 números aleatorios El segundo el cuadrado de cada elemento aleatorio generado. El tercero la raíz de cada elemento aleatorio generado. También se desea ordenar cada uno de los arreglos de menor a mayor. • • •

Solución: Este ejercicio nos mostrará como ordenar arreglos. La primera parte puede hacerse con lo que sabemos de guías anteriores y con lo que aprendimos del primer ejercicio de esta guía. Primero crearemos los 3 arreglos, que en este caso los dispondremos en una fila en lugar de la columna creada en el primer ejercicio. Las siguientes figuras muestran el panel frontal y la ventana de código: Sugerencia: Para copiar objetos parecidos o iguales más de una vez, seleccione el objeto a copiar con el clic izquierdo del mouse presionado y la tecla Ctrl y arrastre el mouse. Observará como se crea un nuevo objeto copia del primero ☺


107



Hasta este momento no se ha introducido nada que no conozcamos. Hay un ciclo for que se ejecuta 10 veces, generando 10 números aleatorios. Cada número aleatorio se escala (el generador de números aleatorios lo genera en el rango de 0 a 1) hasta 100 y después en cada iteración se calcula el cuadrado y la raíz valor del número escalado. Dichas funciones se


108



encuentran en la misma biblioteca que el generador de números aleatorios, o sea, en Functions/Numeric. A la salida del for tendremos un arreglo de 10 elementos. En este caso, también está habilitado el indexado del arreglo, lo que quiere decir que en la salida del for tendré los 10 elementos generados, pues LabView para cada iteración va creando el elemento [i]. Si se inhabilita el indexado solamente se recibirá a la salida del ciclo for el último elemento, o sea, [n]. En nuestro caso queremos trabajar con el arreglo completo, por lo que la opción de indexado que por default implementa LabView se mantiene. Hasta aquí la primera parte del ejercicio. Si tal como está conectáramos los arreglos de indicadores Número, Cuadrado y Raíz , observaríamos en la pantalla frontal que una vez concluido el ciclo for los arreglos se actualizan, pero no ordenados. Para ordenarlos debemos introducir una función de la biblioteca de LabView para arreglos, llamada Sort 1D Array : Esta función espera un arreglo como entrada y devuelve el mismo arreglo ordenado.

Para concluir el ejercicio basta interponer entre la salida del ciclo y los arreglos de indicadores dicha función:

Finalmente mostramos la ejecución del programa elaborado. Note que están ordenados.


109



Ejercicio 3: Se desea declarar un arreglo de 5 elementos, donde cada elemento sea un Cluster con los datos de una persona (Nombre, Edad, sexo) y mostrar en pantalla: 1. Cuál es la menor edad entre todos 2. Cuál es el la cantidad de caracteres del nombre más largo. 3. Cuantas mujeres hay. Solución: Este ejercicio conviene analizarlo primeramente. Debemos crear una estructura que contenga 3 tipos de datos diferentes, un dato de tipo cadena para almacenar el nombre de la persona, otro de tipo numérico para su edad, y un tercero, que podríamos considerar booleano (dos posibles valores) para especificar su sexo. Después de creada la estructura debemos cr ear un arregl o para almacenar 5 variables de ese tipo de dato (estruct ura), y después hacer el resto de los anális is que se nos pi de. Note que los análisis se basan en la misma estructura y se pueden hacer de forma independiente, o sea, ninguno necesita el precedente del otro. Sin embargo, al final de este ejercicio se orientará como t area elaborar una solu ción utilizando una estruct ura de tipo sequence que quizá das mayor elegancia al código. Veamos la solución sin utilizar este tipo de estructura. Para crear la estructura se procede de forma similar a como se hace para los arreglos. En este caso debemos crear un Cluster, que es la estructura que tiene LabView para empaquetar datos de diferentes tipos. Para crear un cluster en el panel frontal, seleccionamos:


110



Una vez que el cluster está creado debemos indicar que tipos de datos contendrá. Esto se realiza de la misma forma que con los arreglos, o sea, creando los controles primero y arrastrándolos después dentro del cluster. Una vez que esto se realiza en el panel frontal debemos tener:

Ahora debemos crear el arreglo de clusters. Para ello creamos un arreglo y arrastramo s el cluster para dentro del arreglo, asignándole con ello un tipo a dicho arreglo.


111



No es necesario expandir el arreglo para ver los 5 elementos. Con el indicador de índice que se observa a la izquierda, en la esquina superior, podemos movernos dentro del arreglo para completar los datos de cada cluster. Para realizar la primera parte del ejercic io debemos de ser capaces de recorrer el arreglo de clusters extrayendo para cada elemento de dicho arreglo el campo edad , e ir comparando esa edad con el mínimo acumulado. Para recorrer el arreglo usaremos un ciclo fo r como ya es habitual, y para calcular el mínimo usaremos una función llamada Max & Min ya vista anteriormente ( Functions/Comparison/Max & Min ). Para almacenar el mínimo acumulado se usará, también como en anteriores ocasiones, un shift register , que al iniciarse el ciclo debe tener un valor lo suficientemente alto como para garantizar que el primer míni mo que se escoj a sea el de la edad almacenada en el prim er cluster del arreglo. Como extraer un campo de la estructura cluster? Para ello se utiliza una función llamada Unbundle que se encuentra en la biblioteca que tiene LabView para operaciones con estruturas tipo cluster (Functions/Cluster/Unbundle): Esta función recibe como entrada un cluster y devuelve a la salida los elementos que lo conforman.

La primera parte del ejercicio queda entonces resuelta de la siguiente manera:


112



Se entraron 5 valores de datos diferentes para completar cada cluster, que fueron: [Juan, 15, M], [Magdalena, 20, F], [Pedro, 11, M], [Juli a, 52, F] y [Ernesto, 40, M]. Note que en el ejercicio anterior no se le dio valor a N dentro del ciclo. En caso de que esto ocurra LabView realizará el ciclo hasta que revise todos los valores del arreglo, o sea, hasta que encuentre el último índice para el cual se introdujeron datos. La siguiente pantalla muestr a el resul tado para la menor edad (11 años):

La segunda parte del ejercicio consist e en indicar la cantidad de c aracteres del nombre más largo. Sin pensar en LabView podemos imaginar que la solución a este caso pasa por calcular la longitud de la cadena de nombre de cada cluster del arreglo y determinar entonces cual es la mayor longitud: dicha longitud corresponderá con el nombre más largo. Para determinar la longitud de una cadena de caracteres (nombre), utilizamos la función String Length (Functions/String/String Length) que tiene LabView en la biblioteca asociada a trabajo con cadenas: Esta función recibe como parámetro una cadena y devuelve como s alida su longitud.


113



El resto de la sol ución es muy p arecida a la del primer in ciso. Utilizando lo ya realizado en el primero, solamente debemos inc orporar a nuestro cic lo fo r un nuevo shift register para almacenar el valor máximo que se va calculando a medida que se analiza cada elemento del arreglo, y utilizar nuevamente la función Max & Min en este caso, tomando el máximo. La siguiente figura muestra el códig o del ejercicio hasta este momento:

Utilizando el mismo juego de valores se obtienen los siguientes resultados cuando se ejecuta el programa (Longitud nombre más largo 9, corresponde con Magdalena):

La ultima parte del ejercicio implica el tratamiento de una variable booleana. Debemos contar la cantidad de mujeres. La idea general, sin embargo, es la misma: recorrer el


114



arreglo y analizar un campo particular de cada elemento de este arreglo, o sea, el campo Sexo de cada cluster. Contar variables booleanas es muy sencillo. Podemos utilizar una sentencia if then else y en dependencia dependencia del valor inc rementar rementar o no un cont ador. En En pseudocódigo sería: sería: If (true) c++;

En LabVie LabView w cuando introduci mos botones booleanos booleanos (del (del tipo PushButton) tienen por defecto el valor de false. En este ejercicio hemos usado un botón de tipo desplazamiento, que inicialmente está en la posición de la izquierda, que hemos indicado con el sexo masculino, por lo que para nosotros el masculino representará el valor false del botón. Para contar la cantidad de mujeres entonces debemos recorrer el arreglo arreglo contando los botones cuyo estado es true. El código para implementar la sentencia if quedaría:

y

El código final se muestra en la siguiente figura:


115



que para el el juego de datos i ntroducido y ya mencionado da como resultado (2 mujeres, mujeres, Magdalena Magdalena y Ju lia):


116



TEMA TEMA VII Control es Forma de Onda. Implementación de Funcion es en LabVIEW LabVIEW • •

Apren Ap render der a util ut ilizar izar los lo s c ontr on trol oles es de d e ti po Forma For ma de d e Onda Aprend Ap rend er a realizar real izar func fu ncio iones nes (SubVI) (Sub VI) en LabVIEW. Lab VIEW.

Ejercicio Ejercicio 1: Generar tres arreglos de 100 elementos con las siguientes características  El Primero contendrá 100 números aleatorios  El segundo el cuadrado de cada elemento aleatorio generado.  El tercero la raíz de cada elemento aleatorio generado. a) Ordenar cada uno de los arreglos de menor a mayor. b) Mostrar en en una una gráfica WaveformChart WaveformChart los números que se están están genrando. genrando. c) Mostrar en una gráfica WaveformGraph los números generados generados d) Mostrar en una gráfica GraphXY los números generados de forma que se exprese “Numero Aleatorio” vs “Raíz” y “Numero Aleatorio” vs “Cuadrado” Solución: La primera parte de este ejercicio ya se realizó en el Laboratorio anterior solamente vamos a añadir la capacidad de mostrar gráficamente los resultados. La solución de la cual partimos es la siguiente:


117



Para que se ejecute de una mejor forma este ejercicio colocaremos un botón de cálculo con acción mecánica “Latch When Pressed” que decida cuando realizar los cálculos. El código es el siguiente:

Para resolver el inciso a) debemos colocar en el panel frontal una gráfica del tipo WaveFormChart. WaveFormChart. Esto se hace de la siguiente forma:


118



Cualquier valor asociado con la gráfica: Por ejemplo la etiqueta “Waveform Chart” o el valor “número” e pueden modificar utilizando el cursor escala en X o la Y.

, también se puede modificar tanto la

El código ahora muestra una variable de tipo DBL.


119



El control WaveformChart adicionará un punto a la gráfica con cada iteración del ciclo “For”. Ahora conectaremos la salida de la función aleatoria a la gráfica. El código es el siguiente:

Si corremos la aplicación: el resultádo gráfico puede ser el siguiente:


120



Como se observa es casi imposible ver el resultado gráfico debido a la escala. Hemos generado 10 números entre 0 y 1 y la escala X es de 0-100, mientras la Y es de -10-10. Para ajustar la escala podemos hacerlo directamente con el cursor o dando clic derecho sobre la gráfica y seleccionando “AutoScale X” y “AutoScale Y” dentro de “X Scale” y “Y Scale” respectivamente.

Ahora el resultado es:


121



Sin embargo sería bueno que esta misma gráfica pudiera también trazar las curvas de la “Raíz” y el “Cuadrado”. Para Añadir estas curvas es necesario que se introduzca a la misma un cluster donde cada uno de los elementos componentes sea un tipo de datos númerico simples (SGL, DBL, U16 …). Para construir el cluster utilizaremos la función “Bundle” dentro de las funciones de tipo “Cluster” en la Paleta de funciones. Al seleccionarla se muestra un elemento como este: .

Al conectarle dos entradas por ejemplo el número su raíz obtenemos el siguiente resultado de código:


122



También podemos añadir una tercera variable: “Cuadrado”. Para ello” debe expandir las entradas a la función “Bundle utilizando el cursor arrastra hasta obtener la entradas requeridas (3).

, situándolo en la parte centro-inferior y se

Ahora puede Ejecutar la Apli cación. Existen varias formas y colores para representar las gráficas para ello hay que utilizar el cursor , situarse en sus bordes y expandir el elemento derecha de la gráfica. El resultado es el siguiente:


en la parte superior

123



Utilizando el cursor colocamos los nombres representativos de cada curva y si damos clic derecho sobre uno de las curvas y seleccionamos la opción “Common Plots” podemos seleccionar entre seis variantes. Una de ellas es la que se muestra a continuación:

También puede seleccionar otras opciones como el Color. ¡Compruébelas!

Para realizar el inciso b) debemos colocar una gráfica del tipo WaveformGraph que se encuentra:


124



El código que genera por defecto es un tipo de datos : “Array” conectamos el arreglo ordenado número de la siguiente manera:

. Si ahora

Y después de realizar los ajustes de escala de la misma forma que se hizo con el tipo de gráfica anterior obtenemos el siguiente resultado:


125



La gráfica coloca los diez puntos ordenados que están contenidos en el arreglo de manera que estos comienzan en 0 con un paso de una unidad. A esto se le denomina X 0 y dX. Esto puede ser modificado si en vez de conectar directamente el arreglo a la gráfica utilizamos un cluster que posea X0(valor de inic io), dX(Paso), Arreglo de valor es. Colocar la conocida función “Bundle” con tres entradas”:

de la siguiente manera:

Note que esta gráfica acepta un tipo de datos complejo de tipo “cluster” donde el primer elemento será el valor a partir del cual colocará los valores del arreglo. El segundo elemento será con que intervalo los colocará y el tercero es el arreglo de los valores. El resultado es el que sigue:

Esta gráfica también puede trazar más de una curva. Para ello debe recibir un arreglo de clusters como el anterior. Por ejemplo podemos trazar también el valor de la raíz esto se realiza utilizando la función “Build Array”


126



Para expandir sus entradas utilizamos el cursor situándolo en la parte centro-inferior y se arrastra. . Ahora conectamos los clusters y el resultado a la gráfica:

El resultado es:


127



Observaciones: Este tipo de gráficos es muy útil cuando el eje X está vinculado con el tiempo de adquisición de muestras. Por ejemplo: X0: será el tiempo de inicio, dX: el intervalo de tiempo entre muestras y el “Array”: las muestras obtenidas. Para realizar el inciso c) debemos colocar una gráfica del tipo “GraphXY” esto se realiza:

Esta gráfica es de tipo de datos “Cluster” el cluster que recibe está compuesto por dos arreglos uno para el eje de las X y otro para las Y. Luego se trazan los puntos tomando (X,Y) los puntos según su índice dentro de los arreglos. En este ejemplo trazaremos la curva “número vs raíz” y las curvas “numero vs cuadrado”. Ya tenemos generados los arreglos correspondientes solo resta construir el cluster. Para ello utiulizamos la conocida función “Bundle” con dos entradas” de la siguiente manera:

El resultado es el siguiente:


128



Al trazar los puntos ordenadamente se tiene que el resultado es muy parecido a la función Y = Raiz(X). Para añadir más trazos se tiene que introducir un arreglo con tantos “clusters” como trazos se quiere. Esto se hace de manera similar al caso anterior. Si adicionamos la función Y=Cuadrado(X) el código queda:

Y el resultado:

Ejercicio 2 (crear una función)


129



Si analizamos el ejemplo 2 discutido en el laboratorio pasado podemos pensar que sería bueno tener una función que dada una cantidad “N” nos devolviera tres arreglos. El primero con N elementos aleatorios. El segundo con la Raíz de cada uno de los N elementos y el tercero con el cuadrado de cada uno de los N elementos. Para ello partimos del siguiente código:

Cuya interfaz gráfica es:

Nuestra función no es un programa por lo que eliminaremos el ciclo principal y su botón de terminar:


130



Para introducir la cantidad de elementos de los arreglos que debemos generar debemos sustituir la constante que define las iteraciones del ciclo “for” por un control que lo determine, luego queda:


131



Cuando se construye una función en Labview el panel frontal representa el prototipo de la función. Donde los controles hacen función de parámetros de entrada y los indicadores de parámetros de salida. En nuestro caso: Cantidad : parámetro de entrada Cuadrado : parámetro de salida Numero : parámetro de salida Raiz : parámetro de salida LabVIEW es un lenguaje gráfico, de ahí que nuestra función deba tener una representación gráfica definida por nosotros: Para ello se da doble clic en el icono de la parte superior derecha:

Entonces aparece un editor de iconos:

La interfaz es muy parecida al Paint de Windows. Aquí dibujamos nuestro icono y presionamos OK.


132



Ahora solo nos resta definir los parámtros. Para ello damos clic derecho en el icono de la parte superior derecha

y se selecciona la opción “Show Connector”

Entonces se muestra el siguiente icono que indica que tenemos un control y tres indicadores en nuestro panel frontal (prototipo). Si quisiéramos adicionar nuevos parámetros se selecciona la opción “Patterns”:


133



Solo nos resta vincular cada control e indicador con su correspondiente área en el icono. Esto se realiza únicamente en el Panel de control y seleccionando el cursor

. Usted debe marcar

el área del conector que va vincular con el cursor y luego seleccionar el control que servirá de parámetro al hacerlo el área antes de color blanco tomará el color del tipo de datos de variable asociada (naranja-azul-rosada-verde) Al seleccionar la base el panel frontal se ve así:


134



Luego conecta el indicador cuadrado:

Al conectar el Indicador Numero: Al conectar el Indicador Raíz: Guarde el código programado como: “Funcion.vi”. Ya tenemos la función! !! Ejercicio 3 Para utilizar la función programada en el ejemplo anterior, haremos un ejercicio que muestre una tabla donde la primera columna tenga el valor del cuadrado del número, la segunda columna tenga el valor del número y la tercera columna tenga el valor de la raíz del número. El código inicial contendrá un ciclo principal y un botón de calculo asociado a una estructura “case”:


135



Ahora añadiremos una tabla al panel frontal:


136



Para añadirle encabezado a las columnas se da clic derecho sobre la tabla y se selecciona la opción “Column Headers” dentro de “Visible Items” luego se escribe dentro del encabezado utilizando el cursor

:

Para introducir nuestra función dentro del código del programa se debe utilizar el icono de la extrema izquierda de la paleta de funciones:

Este abre un cuadro de dialogo para abrir un SubVI, usted busca “Funcion.vi” y lo abre. El código queda como sigue:


137



Ahora debemos colocar los parámetros de entrada. En esta caso la cantidad de números generados. Esto lo podemos hacer mediante una constante o un control. Lo haremos con una constante igual a 15:

Como se observa el control de tipo tabla está representado por una matriz de tipos de datos de cadena. Esta matriz debe ser cuadrada donde: Los elementos X 0,j de la matriz representan la fila 0 Los elementos X 1,j de la matriz representan la fila 1 Los elementos X i,0 de la matriz representan la columna 0. Los elementos X i,1 de la matriz representan la columna 1. • • • •

Para lograr nuestro objetivo debemos convertir nuestros arreglos en una matriz. Para ello se debe utilizar la función “Build Array”


138



Para expandir sus entradas utilizamos el cursor

situándolo en la parte centro-inferior y se

arrastra.

. Ahora conectamos los arreglos:

La matriz obtenida después de utilizar la función “Build Array” es una matriz numérica por lo que debemos convertirla a “cadena” para ello se utiliza la función “Number To Fraccional String” dentro de las funciones de cadena:


139



El código es el siguiente:

Si ahora conectáramos la salida de esta función a la tabla y ejecutáramos la aplicación podríamos comprobar que las filas están invertidas con las columnas. Para solucionar esto utilizaremos la función “Transpose 2D Array” de la paleta de funciones de “Array” que invierte la filas con las columnas:

El código final es:


140




141



TEMA VIII Trabajo con ficheros Conocer los contro les para el trabajo con f icheros. Conocer las funciones para el trabajo con f icheros. • •

Realice un programa que permita almacenar y leer los caracteres almacenados en un control tipo cadena del tipo Memo. Solución: Para la solución de este ejercicio debemos conocer dos funciones para trabajo con ficheros que respectivamente, leen y almacenan información en forma de caracteres ASCII desde/hacia un fichero. Estas funciones, contenidas en Functions/File I/O son:

La primera de ellas se utiliza para escribir caracteres a un fichero que se indica en el camino (file path). Si no se indica ningún camino entonces aparece una caja de diálogo de tipo Salvar Como (Save As...) que permite que el usuario especifique un nombre de fichero. En caso de que se especifique un fichero, entonces se debe especificar si se quiere agregar los datos indicados en la cadena de caracteres (character string) mediante una constante o control booleano en true o reemplazar los datos del fichero existente (constante o control booleano en false). Por último, si se especifica también mediante condición booleana (valor true) en la entrada convert eol? LabView convierte todos los caracteres de fin de linea que encuentre en la cadena a escribir en caracteres de fin de línea de LabView. Puede consultar la ayuda para conocer más sobre las diferencias entre el fin de línea de LabView y el del Sistema Operativo (Windows, Macintosh y Unix). Esta función tiene como salida el nuevo camino donde el fichero fue escrito. La segunda tiene entradas similares en cuanto al camino y a la interpretación del fin de línea, ahora en lectura, y además presenta dos entradas que indican la cantidad de caracteres a leer y el desplazamiento u offset dentro del fichero a partir del cual comienza la lectura. Si no se especifica camino también se abre una caja de diálogo del tipo Open. Esta segunda función tiene 4 salidas, la primera igual a la de la primera función revisada, la segunda conteniendo la cadena de caracteres leídos, la tercera (mark after read) indica la posición del puntero del fichero después de la lectura realizada (el puntero apuntando a la primera posición no leída) y por último, EOF? si se produce un intento de lectura después del final del fichero. Conociendo estas dos funciones el ejercicio tiene una solución directa. En la solución incluimos dos botones booleanos que indicarán cuando realizar la lectura o escritura de los datos contenidos en el control tipo cadena desde o hacia el fichero. En este caso no asumiremos nombre especifico para el fichero.


142



Lo primero que debemos realizar en el programa es el lazo de ejecución principal, que como ya hemos visto en otras ocasiones se muestra sin comentarios adicionales:

Se ha incluido un fragmento de la pantalla frontal para hacer notar que el caption o etiqueta original que presenta el botón ( stop) se ha cambiado por la etiqueta Salir . Hay dos formas de hacerlo, la primera, es creando un property node en modo escritura, y asignándole a la propiedad Boolean Text una constante con el nuevo nombre que se le quiera dar a la etiqueta del botón y una segunda forma más sencilla que se muestra a continuación: Se selecciona el botón en el panel frontal, y se da clic derecho. En el menú que se visualiza selecciona la opción con lo cual la etiqueta del botón queda libre y puede cambiarse el texto original ( Stop) por el nuevo deseado. Después, se debe volver a integrar el texto al botón seleccionándolo y en el menú que aparece al dar clic derecho seleccionar la opción . Agreguemos ahora los botones asociados con las opciones de cargar y salvar que debemos implementar en el ejercicio así como el control de tipo cadena. Debemos indicar como acción mecánica Latch when Released (opción por defecto para los botones tipo OK) Tras agregar los botones y editar el texto de la etiqueta debemos tener en el panel frontal:


143



Para agregar el control tipo cadena se inserta primero un string control:

(Functions/String & Path ) y después con el cursor se selecciona al objeto y desde la esquina inferior derecha se “estira” o redimensiona el mismo hasta el tamaño deseado, para lograr un espacio de edición lo suficientemente grande. La siguiente figura muestra como debe quedar:


144



Corresponde ahora programar las acciones de los botones Salvar y Cargar . Comencemos por el botón Salvar . Note que es un control de tipo booleano, por lo tanto, debemos indicar que acciones realizar cuando esté en true y que acciones realizar cuando esté en false. En este caso, los botones solo toman valor de true durante un período cuando se da clic sobre ellos. Es en este caso que se debe salvar o cargar el fichero. En su condición normal ( false) no se hace nada. El código quedaría de la siguiente forma:

Note que al no especificarse camino alguno, se abrirá una caja de diálogo al salvar el fichero. Para el caso de cargar debemos tener en cuenta que el área de edición de texto es el mismo tipo de control string utilizado para copiar su contenido en un fichero y por tanto, al ser un control, no acepta escritura directa. Sin embargo hay una forma de copiar en dicho control, y es creando una variable local que lo represente: al copiar en esa variable local de hecho se escribe en el control cambiando su contenido. Las siguientes figuras muestran los pasos para crear la variable así como el código que se programa para el botón Cargar :

La solución completa del ejercicio sería:


145



Ejercicio 2: Almacene en un fi chero el resultado del cálculo de la raíz y el cuadrado de 100 números generados aleatoriamente. El fichero debe ser tipo sabana (spreadsheet) y se debe además brindar la opción de cargar el fichero y visualizar su contenido. Puede hacer uso de la función creada en la Guía 6 de esta serie que calculaba la raíz y el cuadrado de un conjunto de números aleatorios cuya cantidad recibía como parámetro de entrada. Solución: La primera parte del ejercicio es similar a lo que hicimos en el primer ejercicio de esta guía. Un lazo While y dos botones adicionales, uno para Cargar los números desde un fichero y graficarlos y ot ro para generar y Salvar los datos en un fic hero. Las funciones de trabajo con fichero que se introducen en este ejercicio se presentan a continuación:


146



No se comentarán todos los campos puesto que se puede profundizar en ello haciendo uso de la ayuda, sin embargo, comentaremos algunos nuevos que aparecen aquí con relación y que no estaban presentes en las funciones del primer ejercicio. Los que se repiten aquí tienen la misma función que los comentados ya en el primer ejercicio. El formato aparece en estas funciones por primera vez. La especificación de formato es muy parecida a la que presenta el lenguaje C/C++. El % indica inicio de un especificador de formato, el punto decimal es un delimitador y el número que a continuación aparece es el número de lugares decimales con que quiere imprimirse el número. El tipo de dato se refleja en el 4to carácter. Por defecto se asume %.3f que significa números en formato de punto flotante (f) y con precisión de tres lugares después del punto (.3). En la entrada transpose de tipo booleano se debe poner true si se quiere trasponer el arreglo de números que se va a salvar a disco (o leer de él). El campo delimiter es también muy importante pues es la manera de indicarle a LabView el carácter o cadena que debe agregar (caso de escritura en fichero) entre número y número. En la operación de lectura es el que dicta lo que separa o delimita los números almacenados en el fichero que se quiere leer. Note además que ambas funciones pueden aceptar arreglos de una o dos dimensiones. Analizadas las funciones solo nos queda realizar el ejercicio. Como ya se mencionó, la primera parte, o sea, la colocación de los botones es sencilla y se hace sin comentarios adicionales:

Comencemos programando la opción de Generar y Salvar. Para ello recordamos que la función programada en la guía anterior devuelve el cuadrado (C), el número (N) y la raíz. El parámetro de entrada permite indicar la cantidad de números aleatorios a generarse. La solución que ofrecemos aquí salva los datos después que son generados en el camino y con nombre especificados por el usuario ya que no se especifica camino y LabView abre la ventana de diálogo para que se escoja:


147



Note que como la función devuelve elementos (cuadrado, número aleatorio, raíz) hay que construir el arreglo, que después recibe la función Write To SpreadSheet File. Como no se especifica separador ninguno LabView asume que es el Tab, o sea, espacio en blanco entre cada dato del arreglo. Puede cargar el fichero que se genera con el Block de Notas de Windows (observará que los datos se distribuyen por filas) o con el Excel (lo cargará en filas independientes); compruébelo!. Como estudio independiente se recomienda salvar los datos de forma ordenada, y con el carácter ‘;’ como separador. Note que se visualiza por filas, si se quiere por columnas debe en el campo Transpose de la función Write To SpreadSheet File indicar que se transponga asignándole un valor verdadero a dicha entrada. Para concluir el ejercicio debemos implementar la función de cargar y graficar. La solución que ofrecemos aquí carga los datos del camino y con el nombre especificados por el usuario ya que no se especifica camino y LabView abre la ventana de diálogo para que se escoja. Posteriormente los datos son graficados. Debe insertar en la pantalla frontal un gráfico del tipo XY Graph:

Conviene hacer varios comentarios en este momento. Primero, note que los datos se salvaron en el fichero como un arreglo de 2 dimensiones (una matriz) y que por tanto no pueden plotearse directamente en un gráfico de tipo XY Graph. Hay que realizar algunas operaciones antes de que estemos listos para gráficar. 1. Lo primero que se debe realizar es agrupar los datos convenientemente, ya que se quiere graficar en una misma pantalla los valores de los cuadrados de los números aleatorios (cuadrado vs número) y los valores de las raíces de los números aleatorios (raíz vs número). Debemos por tanto, separar o descomponer la matriz en arreglos apropiados. Para esto se toma el arreglo bidimensional que entrega a su salida la función Read from SpreadSheet File y se descompone en los 3 arreglos que conforman la matriz (cada uno en una fila, la primera con los cuadrados, la segunda con los números y la tercera con las raíces). Para esto se utiliza la función Index Array ya vista en guías anteriores. 2. Una vez que los arreglos están independientes (salidas de las funciones Index Array) se debe entonces agruparlos convenientemente. Para ello se utiliza la función Bundle (también vista en guías anteriores) que crea dos clusters, el primero con los arreglos {número, cuadrado} y el segundo con los arreglos {número, raíz}. 3. Una vez que los clusters están creados debe construirse un nuevo arreglo, esta vez, siendo cada elemento del arreglo los pares {número, cuadrado} y {número, raíz} que se plotearán cada uno en un gráfico independiente. La salida que se produce se ilustra a continuación:


148



Observe la gran densidad de líneas en cada uno de los gráficos. Esto se produce porque los arreglos se han ploteado tal y como se han leído del fichero, que a su vez se creo sin ordenar los elementos del arreglo. Podemos eliminar las líneas y plotear solamente los puntos si en la pantalla frontal seleccionamos la opción

Common Plots y dentro de esta la de puntos solamente (en la figura anterior enmarcada en un rectángulo azul) para cada gráfico. En ese caso la salida se verá:

que de esta forma indica mucho mejor las curvas características de la raíz(x) y de x 2. Las pantallas de código y frontal para este ejercicio finalmente quedan:


149



Como estudio independiente se recomienda comprobar el efecto que tiene el ordenar los arreglos a la hora de salvarlos o antes de graficarlos. La densidad de líneas que aparecía inicialmente en la pantalla frontal para el caso de que no estén ordenados desaparece y se observa una gráfica muy parecida a:


150



Ejercicio 3: Realice un programa que permita almacenar y cargar en y desde un fichero la siguiente tabla: Temperatura Habitación Consumo Eléctrico : :

24 1000 : :

F V : :

Solución: Las variables serán del tipo cadena de caracteres, valor son números de punto flotante y la Alarma indica si el valor específico de esa variable constituye una alarma ( true) o no (false). La realización de este ejercicio debe hacerse mediante el uso de las funciones generales de trabajo con ficheros, dado que los tipos de datos que se quieren incluir en el fichero son de diverso tipo. Comentemos primeramente de forma más o menos detallada algunas de las funciones que se usarán en este ejercicio por primera vez. Dichas funciones se encuentran en la biblioteca de LabView Functions/File I/O/Advanced File Functions . La primera que veremos será la función New File:

Veamos los parámetros y salidas de la función: 1. datalog type puede ser cualquier tipo de dato. Se puede crear y conectar a esta entrada un cluster formado por los tipos de datos que se guardarán en cada record del fichero en caso de que se quieran crear ficheros con diferentes tipos de datos. Para este caso LabView creará un fichero de records en el cual refnum es el número de referencia del fichero de datos. El valor por defecto, en caso de no especificarse nada es un fichero de bytes. 2. permissions especifica los permisos de acceso del sistema de archivo del Sistema operativo que serán asignados al nuevo directorio o fichero que se creará. Por defecto se asumen los permisos por defecto que asigna el sistema cuando se crea un fichero (archivo normal, escritura/lectura, etc.).


151



3. file path es el camino completo del fichero que se desea crear. Si file path se refiere a un archivo o directorio existente y overwrite es false entonces esta función no crea un nuevo fichero, sino que por el contrario, fija refnum al valor Not A Refnum y devuelve un error. 4. group contiene las definiciones de grupo del fichero o subdirectorio después que esta función se ejecute. Si group es una cadena vacía, la función utiliza las definiciones de grupo asociadas al usuario que lo creó. 5. deny mode especifica el grado en que pueden operar otros usuarios sobre este fichero de forma simultanea: a) Niega la lectura y la escritura en/del el fichero por otros usuarios. b) Permite la lectura pero niega la escritura del fichero por otros usuarios. c) Permite la lectura y escritura sobre el fichero por otros usuarios. Este es el valor por defecto. 6. error in describe las condiciones de error que ocurren antes de que este VI o función se ejecute. El valor por defecto es que no hay error. Si un error ocurre antes de la ejecución de esta función o VI entonces se pasa el valor de error in a error out. Esta función o VI se ejecuta normalmente solamente si no se producen errors antes de su ejecución. Si un error ocurre mientras se esté ejecutando entonces se ejecuta normalmente y fija su propio reporte de errores en error out. Se puede usar el Simple Error Handler (Manipulador Simple de Error) o el General Error Handler (Manipulador General de Error) de los VIs para visualizar una descripción del código de error. Use error in y error out para comprobar errors y para especificar el orden de ejecución conectando error out desde un nodo con error in en el siguiente nodo. Los campos de esta estructura son: a) status es true si un error ocurrió antes de que la función o VI se ejecutara y es false para indicar una advertencia o que no ocurrió un error antes de que esta función se ejecutara. Por defecto es false. b) code es el código del error o de la advertencia. Por defecto es 0. Si status es true, code es un código de error diferente de cero. Si status es false, code es 0 o un código de advertencia. c) source describe el origin del error o la advertencia y es, en la mayoría de los casos, el nombre del VI o función que produjo el error o la advertencia. Por defecto es una cadena vacía. 7. overwrite determina si la función reemplaza al fichero o retorna un error cuando el file path ya exista. Si overwrite is false (valor por defecto), la función devuelve un error de camino duplicado (duplicate path) . Si overwrite es true , la función reemplaza al fichero. 8. refnum es el número de referencia asociado con el nuevo fichero. Si file path hace referencia a un fichero o directorio que ya existe y overwrite es false, esta función fija el número de referencia a Not A Refnum. 9. error out contiene información de error. Si error in indica que se produjo algún error antes de la ejecución del VI o función, entonces error out contiene la misma información de error de error in. En caso contrario, describe el estado de error que produce la ejecución de esta función. De clic derecho en el indicador de error out del panel frontal y seleccione Explain Error en el menú que aparece para obtener más información acerca del error. Los campos que contiene son iguales a los de error in. Otra de las funciones que será de utilidad es:

Esta función tiene varios campos en la entrada. Prompt es una cadena que se visualiza en la caja de diálogo que aparece cuando se ejecuta la función, siendo el valor por defecto al cadena


152



vacía. Start path es el camino que inicialmente se quiere visualizar en la caja de diálogo. Si no se especifica ninguno LabView visualizará el último que se presentó con cualquier opción de diálogo de ficheros. Select mode (2) indica el tipo de fichero o directorio que se puede seleccionar con esta caja de diálogo. Por defecto el valor es 2, que significa que el usuario puede seleccionar lo mismo un fichero que exista o especificar uno que no exista para que sea creado. La tabla completa con los posibles valores puede verse en la ayuda de LabView. Default name es el nombre que se desea aparezca como nombre de fichero por defecto. Pattern limita a LabView a visualizar solamente los ficheros cuyo nombre cumplen con un determinado patrón. Datalog type restringe la visualización en la caja de diálogo a aquellos ficheros que cumplen el tipo o los tipos de datos contenidos en el Datalog especificado. Por otra parte, esta función el camino del fichero especificado en la caja de diálogo, y dos salidas adicionales para indicar si se seleccionó un camino y fichero existente ( true) y si no se canceló la ejecución de la caja de diálogo ( true cuando se cancela). El resto de las funciones a utilizar tienen campos parecidos a los comentados, o pueden fácilmente interpretarse de la lectura de la ayuda. Esta funciones son: , , , que respectivamente cierran un fichero, escriben en un fichero, abren un fichero, y leen de un fichero. Veamos la solución del ejercicio que descompondremos como en los casos anteriores en dos partes para su explicación. Primero, se programará el bloque que creará la tabla en un fichero. Para crear la tabla debemos en el panel frontal crear los clusters o records que se almacenarán en el disco. Ya conocemos como hacerlo. El resultado final en el panel frontal debe ser más o menos como se indica en la siguiente figura:

Debemos ahora crear las opciones generales del programa, o sea, los botones asociados a escribir tabla, leer tabla del fichero y salir del programa. Serán botones del tipo OK y STOP como mismo lo hemos hecho en otros ejercicios. Será un ciclo while con dos condicionales del tipo if then para el tratamiento de los botones de creación del fichero y de carga en la tabla. El resultado en la pantalla frontal será:


153



Y la de código:

La idea general que debemos seguir para salvar el fichero conteniendo la tabla es: 1. Se debe inicialmente indicar en que fichero se salvarán los datos. Esto implica la apertura de una caja de diálogo desde donde obtendremos el nombre del fichero a


154



crearse o del fichero ya creado donde se seguirán salvando los datos. Para esto podemos utilizar la función ya comentada File Dialog. 2. Se debe utilizar la función New File, también ya comentada, para definir al fichero, pues será un fichero que debe contener los records de cada fila de la tabla, o sea, los valores del cluster creado (variable, valor, estado). 3. Una vez definido el fichero debemos entonces utilizar un ciclo for para recorrer el arreglo de clusters salvando para cada iteración del for un elemento del arreglo (o sea, un cluster). 4. Una vez que concluya el ciclo for debemos cerrar el fichero. A continuación se muestran las pantallas de código que se van generando a medida que programamos cada uno de los 4 pasos mencionados anteriormente:

Trabajaremos con los valores por defecto que define esta función. La salida de esta función debe ser la entrada del segundo paso, o sea, de la función New File. Veamos el código completo del segundo paso y después haremos algunos comentarios importantes:

Note que se ha usado la función Bundle para definir el tipo de datos que contendrá el fichero. Los valores que se le asignen no son importantes, pues no se salvarán. La salida de este Bundle (record) solo se utiliza para indicar el tipo de dato a la función New File. Note además que se ha usado una constante en true para en la entrada overwrite del fichero para que en caso de que exista este se reemplace con los nuevos valores. El nombre del fichero y su camino provienen de la función Open Dialog. Veamos ahora como programar el ciclo, y después, también haremos algunos comentarios:


155



La función Write File ( ) escribe un elemento a la vez dentro del ciclo. La primera vez debemos indicar el manipulador del fichero (el refnum que devuelve la función New File) y posteriormente podemos usar el que devuelve la función Write File para las siguientes iteraciones del ciclo for. La tabla, conectada al ciclo, y con el indexado inhabilitado entregará para cada iteración un elemento del arreglo (o sea un cluster conteniendo {variable, valor, estado}). El ciclo for se ejecuta hasta N, siendo N la cantidad de elementos del arreglo, pues no se le ha especificado ningún valor. El cuarto paso no necesita comentarios adicionales. Simplemente se usa la función Close File para cerrar el fichero y con ello terminar la operación de escritura:

Veamos a continuación la segunda parte del ejercicio. Los pasos a realizar serán: 1. Se debe inicialmente indicar desde que fichero se salvarán los datos. Esto implica la apertura de una caja de diálogo desde donde obtendremos el nombre del fichero. Para esto podemos utilizar la función ya comentada File Dialog. 2. Se debe utilizar la función Open File, también ya comentada, para definir el tipo de fichero que se abrirá, pues será un fichero que debe contener los records de cada fila de la tabla, o sea, los valores del cluster creado (variable, valor, estado). 3. Una vez definido el fichero debemos entonces leer todos los datos del fichero y almacenarlos, cerrar el fichero y mediante un ciclo for darle el tratamiento necesario. En la solución que se muestra aquí el valor booleano del estado se transforma en los caracteres V y F para indicar si es alarma (V) o si no lo es (F). 4. Al final se debe visualizar en la Tabla los datos leídos. La solución para el primer y segundo paso se muestra a continuación:

Note que es similar al caso de guardar el fichero, aunque para este caso usando la función especifica de abrir fichero. El tercer paso se muestra a continuación, con comentarios adicionales después de la figura:


156



Note que una vez que el fichero es abierto (función Open File) es leído por la función File Read que entrega el arreglo de clusters leídos. Una vez que se lee del fichero este se puede cerrar. Note que a la función File Open se le conectó una constante numérica con un valor alto. La conexión se establece porque a la función File Open hay que especificarle el número de registros a leer. El número se pone lo suficientemente alto como para garantizar que todos los records se lean. Posteriormente se conecta el arreglo de clusters a un ciclo for . Fundamentalmente se hace para poder convertir el arreglo de clusters en un arreglo de cadenas para visualizar en la tabla. Note que la variable de tipo booleana se transforma y se crea un nuevo arreglo formado por 3 cadenas, una con el nombre de la variable, otra con el valor (convertido a cadena con la función y un tercer elemento siendo un carácter “V” ( true) o un carácter “F” (false) respectivamente). Para culminar el ejercicio con el cuarto paso, que es la visualización de la tabla debemos crear una tabla en el panel frontal. Para ello seleccionamos desde el panel frontal Controls/List & Table/Table :

Cuando se inserte la tabla, se debe habilitar la opción de mostrar el separador de la cabecera de la tabla:


157



Editando los campos cabeceras la tabla debe finalmente quedar insertada en el panal frontal de forma similar a como lo muestra la siguiente figura:

Para visualizar los elementos a la tabla basta con conectar la variable Tabla con la salida del ciclo for :


158



El ejercicio completo para la ventana de código (la frontal es la misma que se incluye en esta página) quedaría:

Estudio Independiente Realice las modificaciones necesarias al ejercicio 3 para poder escribir el arreglo completo en el fichero sin necesidad de un ciclo for . Nota: En la variante comentada en esta clase se incluye el ciclo for para explicar un ejercicio típico donde el uso del for sea necesario, pero no siempre lo es.


159



Realice una función que permita conocer cuantos elementos o records tiene un fichero. La entrada de la función debe ser el offset inicial del fichero a partir del cual se quiere contar la cantidad de elementos y debe devolver la cantidad de elementos que quedan hasta el fin del fichero.


160



TEMA IX. Tarjetas de Adq uisi ción de Datos (PCL-818L). Saber conf igurar la TAD PCL-818L. Saber obtener las señales de entrada de la tarjeta de TAD PCL-818L. Saber realizar conv ersiones a unidades de Ingeniería Enviar una señal de salid a a través del c anal analógico de la TAD PCL-818L. • • • •

Ejercicio 1: Realizar la configuración de la TAD PCL-818L. (Hacer una función reutilizable) Este ejercicio a diferencia de otros ya realizados tiene como objetivo la implementación de una función. Esto hace que para realizarlo solo es importante establecer cuales serán lo parámetros de entrada y cuales los de salida. Recordemos brevemente los pasos para configurar la TAD PCL-818L. 1. Establecer los rangos de entrada por software de la TAD PCL-818L. 2. Colocar las entradas analógic as que se utilizarán para obtener los datos. 3. Colocar el tipo de disparo que dará inicio de conversión. Vamos a diseñar el prototipo de nuestra función en LabVIEW. El prototipo de una función en labVIEW se define en el panel frontal. Los controles colocados harán la función de parámetros de entrada y los indicadores harán función de parámetros de salida. Realizar los tres pasos planteados arriba implica hacer escrituras en direcciones de memoria internas de la TAD PCL-818L. Estas direcciones se encuentran a partir de una dirección BASE que se configura en el conmutador SW1 y que puede variar entre los rangos 000h-3F0h. Esta base usualmente se trabaja en formato hexadecimal y será el primer parámetro de nuestra función. Para ello se coloca un control digital en el panel frontal y luego se cambia el tipo de dato para que sea un entreo d 16 bits sin signo U16. Además, se establece su formato dando clic derecho y seleccionado la opción “Format & Precision” que coloca un ventana de configuración.


161



En la ventana de configuración se selecciona Hexadecimal en el menú desplegable “Format:”. El panel frontal queda de la siguiente manera:

En código de la ventana es muy simple hasta este momento. Como debemos programar tres pasos para configurar la tarjeta, utilizaremos la estructura secuencial. El código queda de la siguiente forma:


162



Paso 1: La configuración de los rangos de entrada por software de la TAD PCL-818L está estrechamente relacionada con el estado del interruptor (jumper) 7 (JP7). A continuación se explican los detalles sobre el mismo. JP7: Presenta dos estados para seleccionar los rangos máximos de entrada en la conversión A/D. Si seleccionamos ±5 V en el interruptor esto quiere decir que el voltaje de entrada deberá estar entre los límites de -5 V y hasta +5 V. Si por el contrario seleccionamos ±10 V quiere decir que el voltaje de entrada deberá estar entre los límites de -10 V y hasta +10 V. Ahora bien una vez que se coloca el interruptor en uno de los estados es posible restringir este rango por programación. programación. • •

Para ±5 ±5 los rangos programables son de ±5, ±2.5, ±1.25, ±0.625. Si seleccionamos ± 10, los rangos programables son de ±10, ± 5, ± 2.5, ±1.25 ±1.25

Como se observa, independientemente del estado del interruptor JP7 existen 4 rangos programables en cada caso. Para codificar estos cuatro estados son necesarios dos bits, ya qué 22=4. Estos dos bits son los dos bits menos significativos del registro BASE+1 cuando se utiliza en forma de escritura (recuerde que su interpretación varía si se trata de una lectura). Las tablas siguientes muestran este resultado. BASE + 1 ( MODO ESCRITURA) Bi t

D7

D6

D5

D4

D3

D2

D1

D0

Value

N/A

N/A

N/A

N/A

N/A

N/A

G1

G0

N/A: no importa cual es su valor

Rango de Entrada JP = ±5 JP = ±10 ±5 ±10 ±2.5 ±5 ±1.25 ±2.5 ±0.625 ±1.25

Código del Rango G1 G0 0 0 0 1 1 0 1 1


163



Para programar esta paso es necesario que el usuario sepa cual es el estado del interruptor JP7. Luego nuestra nuestra función recibirá en en uno de los parámetros parámetros un valor entre 0 y 3 que se escribirá en la dirección de memoria BASE + 1. Para programar este paso añadimos un nuevo control que servirá como otro parámetro de entrada. Hasta este momento contamos con dos parámetros de entradas: BASE Código del Rango de entrada.

• •

El mejor control que representa este parámetro es una variable enumerada que devuelva: 0 (00 binario) rango (±5 o ±10) 1 (01 binario) rango (±2.5 o ±5) 2 (10 binario) rango (±1.25 o ±2.5) 3 (11 binario) rango (±0.625 o ±1.25) • • • •

Las variables enumeradas en labVIEW se encuentran de la siguiente forma:

Al colocar este control en el panel frontal solo se debe dar un valor semántico a cada valor entero para ello seleccionamos seleccionamos el cursor tipo y escribimos dentro del control el significado que tomará el valor entero “0” que en nuestro caso será: rango (±5 o ±10) . La interfaz queda:

Ahora debemos añadir un nuevo elemento. Esto se realiza dando clic derecho sobre el control y seleccionando la opción “Add Item After”. Al realizar esta operación se muestra el control vacio, osea listo para recibir otro valor. Seleccionamos Seleccionamos el cursor tipo


y

164



escribimos dentro del control el significado que tomará el valor entero “1” que en nuestro caso será: rango (±2.5 o ±5) . La interfaz queda:

Este paso se repita dos veces más, colocando los valores rango (±1.25 o ±2.5) y rango (±0.625 o ±1.25) correspondientes correspondientes al valor

2 y 3

respectivamente. respectivamente. Si queremos cambiar el valor del control seleccionamos seleccionamos el cursor y se escoge cualquiera de los valores tecleados con anterioridad. Esto se mustra a continuación:

El código que ejecuta este paso de la configuración es muy sencillo ya que el control BASE contiene la dirección de base de la memoria interna de la tarjeta. En nuestro caso debemos escribir en la dirección de memoria BASE+1 el valor obtenido de la variable enumerada “Rangos”.


165



Para escribir en memoria es necesario utilizar la función “Out Port” que se encuentra en la paleta de funciones según se muestra en la siguiente figura:

Si seleccionamos la ayuda de esta función vemos que es muy sencilla. Recibe la dirección de memoria y el valor a escribir. Además, debemos debemos indicarle si escribiremos un Byte o una palabra (word). En nuestro caso sabemos que los registros internos son de 8 bits por lo que no conectaremos conectaremos esta entrada que quedará en su estado por defecto (Byte). Es necesario explicar que el uso de esta función se limita a los sistemas operativos Windows 95, Windows 98. Para SO con tecnología NT se deben utilizar librerías externas. Llegado el caso las utilizaremos sustituyendo estas funciones por las necesarias. Es importante tener en cuenta que la TAD posee 16 canales y que cada uno de ellos puede tener un rango de entrada diferente es por esto que antes de escribir en la dirección de memoria BASE+1 un valor determinado debemos especificar a que canal va dirigido esta configuración. configuración. Esto se realiza utilizando el registro BASE+2. Los usuarios pueden decidir cual o cuales canales van a ser Configurados. Veamos como se interpreta este registro.


166



BASE + 2 (MODO ESCRITURA) Selección de Canales Bit

D7

D6

D5

D4

D3

D2

D1

D0

Value

CH3

CH2

CH1

CH0

CL3

CL2

CL1

CL0

Como existen 16 canales de entrada como máximo, codificar cada canal conlleva utilizar 4 bits ya que 24=16. CL0-CL3: indica el canal de inicio(start) (0-15). 16 canales en total CH0-CH3: indica el canal de parada (stop)(0-15). 16 canales en total Ejemplo: BASE + 2 (MODO ESCRITURA) Selección de Canales Bit

D7

D6

D5

D4

D3

D2

D1

D0

Value

0

1

0

1

0

0

1

0

Valor del registro: 52 hexadecimal o 82 en decimal. BASE + 2 (MODO ESCRITURA) Selección de Canales Bit

D7

D6

D5

D4

D3

D2

D1

D0

Value

0

0

1

1

0

0

1

1

Valor del registro: 33 hexadecimal o 51 en decimal. Para programar esta opción debemos tener dos controles que me brinden Canal Inicio (entre 015) y Canal de Parada (0-15) Nuevamente necesitaremos una variable enumerada que contenga los siguiente valores: Canal0 – 0 (0000 binario) Canal1 – 1 (0001 binario) Canal2 – 2 (0010 binario) . . . Canal15 – 15 (1111 binario)


167



Para entrar los valores se realiza el mismo procedimiento que para entrar los Rangos. El resultado será el mostrado en la pantalla siguiente:

Para obtener un valor de 8 bits que contenga la información de acuerdo al formato del registro BASE + 2, debemos realizar algunas operaciones. Canal de inicio: 0000 IIII (I entre 0 y 1) Canal de parada: 0000 PPPP (P entre 0 y 1)


168



La operación será rotar el valor del canal de Parada cuatro lugares de forma que quede: Canal de parada(Desplazado): parada(Desplazado): PPPP 0000 (P entre 0 y 1) Luego realizar la opresión OR entre el resultado anterior y el Canal de inicio: Canal de parada(Desplazado): parada(Despla zado): PPPP 0000 (P entre 0 y 1) Canal de inicio: + 0000 IIII (I entre 0 y 1) Registro BASE+2 PPPP IIII La operación de desplazamiento se realiza tomando el valor del canal de parada y multiplicándolo por 16. En este caso el usuario podrá escoger la cantidad de canales que desee de manera consecutiva. Sin embargo para definir el canal que se quiere configurar solo se toman en cuanta los bits correspondientes correspondientes al canal de inicio. La programación de este paso es compleja. Debemos configurar los canales especificados por el usuario. La cantidad esta dada por “Canal de Parada menos Canal de inicio” y inicio” y para cada uno de ellos de deben deben repetir los mismos pasos. El código pr eliminar es:

Observaciones: Véase que este ciclo se repetirá hasta que el registro de desplazamiento (shift regist er) contenga un valor i gual al valor del Canal de Parada. Parada. El ciclo contiene una estructura “Secuence” de dos partes una para colocar el canal que se quiere configurar y otra para establecer su rango. En una de las secuencias se debe incrementar el valor del registro de desplazamiento. •

•

•

Ahora solo resta programar los dos pasos que configuran cada canal para ello se coloca el siguiente código en la secuencia “0” dentro del ciclo:


169



Observaciones: En este caso solo es necesario necesario modificar modificar los cuatro bits bits menos significativos, ya que actúa como puntero al canal que se quiere modificar. En este caso cada uno de de estos canales tendrá el mismo rango de entrada. Usted puede modificar este código para que cada uno de ellos tenga una configuración diferente. ¡Hága ¡Hágalo lo c omo estudio individual! •

•

y como cada uno de estos canales tendrá la misma configuración entonces el código es:

En este paso se utiliza una variable del tipo “Add local secuence” para disponer del valor de la BASE en los siguientes posos. Paso 2: La configuración de los canales de entrada se realiza en el registro de escritura situado en la dirección BASE+2. Los usuarios pueden decidir cual o cuales canales van a ser utilizados. Es importante aclarar que este paso aunque es parecido al paso de configurar los canales, es sumamente necesario, ya que el hecho de configurar los canales no establece cuales canales se van a utilizar en el proceso de adquisición de datos. El trabajo es similar al anterior por lo que el código resultante es:


170



Observaciones: •

En este paso si es necesario necesario modificar modificar los bits correspondientes correspondientes al canal canal de inicio inicio y al canal de parada.

Para escribir comentarios en el código se utiliza el cursor

directamente sobre el diagrama.

Paso 3 Realizar el paso 3 implica modificar el Registro BASE+9, para configurar el tipo de disparo. La tarjeta presenta dos tipos básicos de disparo: • •

Por software Por Hardware

Si: ST1

ST0

Disparo

0 1 1

X 0 1

Disparo por Software Disparo por Hardware Disparo por ¿?

BASE + 9 (MODO ESCRITURA) Control Control Bi t

D7

D6

D5

D4

D3

D2

D1

D0

Value

NTE

I2

I1

0

X

DMAE

ST1

ST0

Ya que nuestro programa siempre realizará su trabajo con la Tarjeta dando inicio por software, nos limitaremos a configurarla siempre por software: Para ello: debemos escribir el valor 0 en este registro. Esto dará el resultado siguiente: INTE = 0 no interrupción I2 = 0 no interrupción I1 = 0 no interrupción I0 = 0 no interrupción


171



X = 0 no importa INTE = 0 DMA deshabilitado ST1 = 0 (inicio conversión software) ST0 = 0 (inicio conversión software) El código necesario para lograr este efecto es el siguiente:

Ya estamos en condiciones de terminar de programar nuestra función. De manera intuitiva la función no devuelve ningún valor, sin embargo la nuestra devolverá el valor que recibe de la BASE. Para ello colocamos un indicador numérico con las mismas características del control asociado a la BASE y se conectan entre sí. El panel frontal t el código “G” quedan de la siguiente forma:


172



Para dibujar el Icono correspondiente a la función damos clic derecho sobre la esquina superior

derecha ventana de edición:

y seleccionamos la opción “Edit Icon…”. Esto mustra la

Para editar el icono utilizamos las herramientas de la Izquierda (Parecidas al Paint de Windows). El Icono editado queda de la siguiente forma:


173



Ahora debemos buscar el patrón de conexión que utilizaremos. En nuestro caso serán cuatro variables de entrada y una de salida, para ello damos clic derecho sobre el ICONO y seleccionamos la opción “Show Connector”:

Solo nos resta vincular cada control e indicador con su correspondiente área en el icono. Esto se realiza únicamente en el Panel de control y seleccionando el cursor

. Usted debe marcar

el área del conector que va vincular con el cursor y luego seleccionar el control que servirá de parámetro al hacerlo el área antes de color blanco tomará el color del tipo de datos de variable asociada (naranja-azul-rosada-verde) Al seleccionar la base el panel frontal se ve así:


174



La secuencia queda de la siguiente forma:

Al conectar el control Rango: Al conectar el control Canal de Inicio: Al conectar el control Canal de Parada: Al conectar el Indicador BASE: Guarde la función programada como: “ConfigFuncion.vi”. Ya tenemos la función. Ejercicio 2: Hacer un programa permita configurar la TAD PCL-818L utilizando la función programada en el ejemplo anterior y obtenga una de las entrada analógicas especificadas por el usuario.

Como toda aplicación esta debe comenzar con la realización del código necesario para ejecutar y terminar la aplicación. Para ello debe colocar un botón booleano de salida y realizar el código siguiente:


175



La ejecución de esta aplicación tiene como primer paso la configuración de la tarjeta TAD PCL818L. Esto se realiza utilizando la función programada en el ejemplo anterior. Por lo tanto se utilizará una estructura secuencia donde antes de entrar al ciclo principal se hace la configuración.

Para configurar la tarjeta debemos agregar una secuencia pero esta vez utilizaremos la opción “Add Frame Before” de la estructura “secuence” ya que la configuración se realizará como primer paso. Para utilizar la función se debe utilizar el icono de la extrema izquierda de la paleta de funciones:

Este abre un cuadro de dialogo para abrir un SubVI, usted busca “ConfigFuncion.vi” y lo abre. El código queda como sigue:


176



Ahora debemos crear los controles para conectar a nuestra función. Para hacer esto no vamos a repetir los pasos del ejercicio anterior sino que los crearemos directamente a través de la función para ello seleccionamos el conector:

Al pasar por encima el conector sobre la función se visualizan los diferentes parámetros de entrada y salida según sean. Usted dará clic derecho sobre ellos y seleccionará la opción “Control” en caso de que sea un parámetro de entrada dentro de “Create”. Al parámetro de salida no se le aplicará esta operación.



177



El panel frontal ahora contiene los controles para configurar la aplicación, solo resta organizarlos:

Esta aplicación se realizará teniendo en cuenta que se recibirá información de un solo canal a la vez. Una vez que la aplicación está configurada apara obtener los valores de las entradas debemos realizar los siguientes pasos: 1. Dar inicio de conversión. 2. Esperar por fin de conversión.


178



3. Obtener el valor digital de 12 bits. 4. Convertir a unidades de ingeniería. Cada uno de estos pasos se programará en una estructura de secuencias dentro del ciclo principal de la aplicación:

Paso 1: Dar inicio de conversión es muy fácil, toda vez que debemos escribir cualquier valor en el registro de escritura BASE+0. Esto se realiza:


179



Ahora para simplificar la explicación haremos referencia a la estructura de secuencias más interna. Paso 2: Añadimos una secuencia más a la estructura “Secuence”. Para verificar el fin de conversión debemos leer el registro de estado BASE+8. BASE + 9 (MODO ESCRITURA) Control Bit

D7

D6

D5

D4

D3

D2

D1

D0

Value

EOC

N/A

MUX

NT

CN3

CN2

CN1

CN0

CN3-CN0: ¿? Si verificamos el manual de la tarjeta vemos que el bit D4 (INT) indica lo que buscamos: INT = 0 si la conversión A/D no se ha completado INT = 1 si la conversión A/D se ha completado Para esperar por el fin de conversión debemos programar un ciclo que repita el proceso de lectura del registro BASE+8 hasta tanto el bit 4 correspondiente al mismo esté en valor “1”. Para ello utilizaremos la función complementaria de “Out Port” que es “In Port” y que se encuentra en la paleta de funciones:

Para ganar en organización es preferible introducir dirección BASE a través de una variable local. La lectura es la siguiente: (Estructura de secuencia más interna)


180



El resultado de esta función un byte. Para poder obtener el bit 4 de la misma es necesariohacer la conversión de entero a arreglo de boolean. Por ejemplo el valor entero 82 en decimal representa el valor 52h en hexadecimal que al llevarlo a un arreglo booleano queda: Decimal 82 indice valor

Hexadecimal 52 7 false

6 true

5 false

4 true

Binario 0101 0010 3 false

2 false

1 true

0 false

Ahora podemos determinar si el bit 4 es verdadero o falso utilizando la conocida función que dado un indice devuelve su valor:

El código queda:


181



Solo se sale del ciclo si se obtiene el fin de conversión. Esto no está bien. Le pedimos que modifique el código como estudio independiente para que se introduzca un “time-out” definido por el usuario que permita salir del ciclo pasado este tiempo y se indique al usuario.

Paso 3. Ahora debemos obtener el valor que ya convertido. Se sabe que la precisión del conversor es de 12 bits. También es conocido que los registros de la tarjeta son de 8 bits. Es por esto que el valor convertido no cabe en un solo registro de lectura de la tarjeta y se necesitan los 8 bits del registro BASE+1 más los 4 bits más significativos del registro de lectura BASE+0. BASE + 0 ( MODO LECTURA) Bit

D7

D6

D5

D4

D3

D2

D1

D0

Value

AD3

AD2

AD1

AD0

C3

C2

C1

C0

ASE + 1 (MODO LECTURA) Bit

D7

D6

D5

D4

D3

D2

D1

D0

Value

AD11

AD10

AD9

AD8

AD7

AD6

AD5

AD4

C0-C3: Canal desde donde se obtuvo el valor de la entrada AD0-AD11: Valor de doce bits que define el valor convertido. Para almacenar el valor convertido es necesario una variable de 16 bits o sea del tipo (U16) la conversión siempre estará entre 0 y 2 12=4096. 0 -> corresponderá a -5 o -10 Volts. 4096 -> corresponderá a +5 o +10 Volts. Para obtener el valor convertido es necesario realizar las siguientes operaciones: Ejemplo BASE+0 = AAAA CCCC donde A y C representan un bit (0-1) BASE+1 = AAAA AAAA Variable de 16 bits = 0000 0000 0000 0000


182



1. Asignar a la variable de 16 bits el valor del registro BASE + 1 2. Desplazar 8 lugares hacia la izquierda el valor variable de 16 bits introduciendo 8 ceros de derecha a izquierda (multiplicar por 256) 3. Realizar una opresión de OR entre la variable de 16 bits y registro BASE + 0 4. liminar los 4 bits menos significativos de la variable de 16 bits introduciendo 4 ceros de izquierda a derecha (dividir por 16). Ejemplo: BASE+0 = 1011 0001 donde A y C representan un bit (0-1) BASE+1 = 1001 1010 Variable de 16 bits = 0000 0000 0000 0000 El resultado final debe llevarnos obtener el valor: 1001 1010 1011 (doce bits) Comprobemos: Operación 1 Variable de 16 bits = BASE+1 = 1001 1010 Resultado Variable de 16 bits = 0000 0000 1001 1010 Operación 2 Desplazar 8 lugares hacia la izquierda: Variable de 16 bits = 1001 1010 0000 0000 Operación 3 Realizar operación OR Variable de 16 bits BASE+0 Variable de 16 bits

1001 1010 0000 0000 OR 1001 1010 1011 0001

1011 0001

Operación 4 Eliminar 4 bits menos significativos (dividir por 16): Variable de 16 bits

1001 1010 0000 0000

Rotados Variable de 16 bits

0000 1001 1010 1011

Para realizar la programación debemos leer los registros BASE+0 y BASE+1. Esto e muy sencillo:


183



Utilizar un variable de 16 bits es lo mismo que convertir la salida a un variable de este tipo. Pero esto ya lo realiza por nosotros la función “In Port” claro está debemos saber que los 8 bits más significativos siempre estarán en “0” ya que el registro desde donde leímos es de 8 bits. Para desplazar 8 lugares hacia la izquierda el valor de BASE+1 debemos multiplicar por 256 (¡compruébelo con la calculadora de Windows !)

Ahora realizamos la operación OR entre BASE + 1 y el resultado anterior:

Finalmente Eliminamos los 4 bits menos significativos dividiendo por 16:


184



Ya tenemos el valor convertido.

Paso 4 para convertir a unidades de ingeniería debemos crear otro secuencia dentro de esta estructura y recibir el valor convertido desde la anterior a través de la opción “Add Secuence Local” El código queda como sigue:

La conversión depende del rango escogido. Esto depende de la configuración de Hardware a través del JP7 y luego de los rangos configurados por software. Por ejemplo si se sabe que este rango es ±10V sería Valor convertido = 0

implica -10V


185



Valor convertido = 4095 implica +10V Esto responde a una ecuación lineal y=mx+n donde:

x: valor convertido (0-4095) y: valor en unidades de ingeniería (-10 a 10) o (-)

si y2 = 10, x2 = 4095, y1 = -10,x1 = 0 m = y2 – y1 = 10 – (-10) = 20 x2 – x1 4095 – (0) 4095 n = -10V. y = (20/4095) *x -10V. Es fácil comprobar que si el rango es ±5V sería: y = (10/4095) *x -5V. Por lo qué si R es el rango: y = 2*R/4095*x – R. La programación de esto utilizando labview es sencilla si utilizamos el nodo fórmula con dos entradas: X (conversión) y R (rango). Como salida tendremos Y.


186



Para seleccionar los rangos de voltaje necesitamos que el usuario diga cual el la configuración del JP7. Para ello colocamos un control booleano en el panel frontal:

Ahora utilizaremos su estado para conmutar entre los rangos: Para programar los rangos podemos utilizar una matriz de valores reales constantes. Por ejemplo: 0

10,00 5,00

0

5,000 2,500 1,250 0,625

2,50

1,25

Este arreglo constante define los rangos posibles cuando se selecciona en el JP7 el valor ±10 V Este arreglo constante define los rangos posibles cuando se selecciona en el JP7 el valor ±5 V El arreglo constante se define en la paleta de funciones:


187



esto coloca en el código un elemento array sin tipo: 0

Para definir el tipo se busca un valor constante del tipo que se quiere definir, en este caso una constante numérica y se coloca dentro del elemento array:

0

0 El arreglo ahora aparece del tipo entero para convertirlo a real se da clic derecho sobre el y se selecciona la opción “Representation” y “Single Precision”


188


el arreglo queda

0


0

El código queda:

Note que la estructura

sirve para seleccionar uno u otro arreglo constante en dependencia

del valor del control que representa el JP7. Luego se selecciona el Rango con la función que devuelve un elemento del arreglo tomando como parámetro un arreglo y el índice. El control Rango e quien me define cual es el rango actual. Finalmente debemos colocar un indicador para mostrar el valor en unidades de ingeniería para ello vamos al Panel Frontal y seleccionamos el control “Meter”


189



Cambiamos su escala para representa el rango mayor entre -10 y 10.

El código queda:


190



Estudio Individual: Se sabe que por el canal 3 de la TAD PCL-818L se obtiene la señal proveniente de un sensor de nivel. El sensor de nivel brinda una señal de 4-20 mA, 4 mA si el nivel está en 0 metros y 20 mA si el nivel es de 50 metros. Se conoce que la TAD PCL-818L solo posee entradas en forma de voltajes. Para realizar la conversión se cuenta con una resistencia de 470 ohms. Realice un programa que presente el nivel en un indicador tanque. El programa debe obtener datos de nivel en una frecuencia de 500 ms. Debe almacenar estos valores en un fichero. El usuario debe poder ver los resultados históricos almacenados en una gráfica de tiempo contra valor de nivel obtenido. Ejercicio 3 Realice un programa que permita sacar un valor analógico de salida a través de la TAD PCL818L. Solución: Como toda aplicación esta debe comenzar con la realización del código necesario para ejecutar y terminar la aplicación. Para ello debe colocar un botón booleano de salida y realizar el código siguiente:

Para enviar un valor hacia la tarjeta TAD PCL-818L será a través de un botón. Este botón tendrá acción mecánica de tipo: “Latch When Pressed”. Cuando este botón esté en verdadero se ejecutará el código que enviará la salida si no la aplicación permanecerá inactiva. Esto queda de la siguiente forma:


191



Para escribir un valor de salida en la TAD se necesitan 3 pasos fundamentales: 1. Convertir de Unidades de Ingeniaría a Unidades del conversor 2. Escribir en el registro BASE+4 3. Escribir en el registro BASE+5 Para ejecutar cada uno de estos pasos utilizaremos la estructura “Secuence”. El código queda:

Paso 1 Para realizar este paso debemos tener en cuanta que para realizar una conversión D/A esta debe realizarse de acuerdo a una referencia. La TAD PCL-818L tiene dos formas para esto: Referencia Externa (valor entre -10 y 10 V) •


192


•


Referencia Interna

Para escoger una de ellas se utiliza el interruptor JP4. Si se escogiera Referencia Interna entonces se tienen dos variantes: Referencia 0-5 V Referencia 0-10 V • •

Para escoger una de ellas se utiliza el interruptor JP5. Aquí siempre se utilizará una de las referencias internas. Tomemos R como la referencia escogida. Se sabe que el conversor D/A tiene una precisión de 12 bits. Cuando se escribe en la tarjeta un valor de “2 12=4095” la salida analógica será de +R V. Cuando se escribe en la tarjeta un valor de “0” la salida analógica será de 0 V. La fórmula para realizar la conversión es contraria a la que ya conocemos:

x: valor en unidades de ingeniería (0 a R) y: valor a convertir (0-4095) si x2 = R, y2 = 4095, x1 = 0,y1 = 0 m = y2 – y1 = 4095 – (0) = 4095 x2 – x1 R – (0) R n = 0. y = 4095/R*x. Para implementar está fórmula utilizaremos nuevamente el nodo fórmula que recibirá el valor de X y R y devolverá Y. El código es el siguiente:


193



Para obtener el valor de R utilizaremos un botón booleano que indique el estado el JP5. La interfaz queda de la siguiente forma:



194



El control que dará el valor deseado a sacar por la TAD será el que se muestra a continuación:

El código ahora debe quedar:


195



Sin embargo al cambiar la Referencia debe cambiar también la escala del control. Esto se puede hacer utilizando las propiedades “Scale.Maximum” y “Scale.Minimum”. Para este caso solo modificaremos la primera ya que la segunda no cambiará. Para obtener la propiedad de un control se realizan los pasos ya conocidos. Luego para obtener esta propiedad se busca:

El código queda:


196



El valor convertido debe pasarse al siguiente paso:

Paso 2. El valor convertido es de tipo Bouble DBL y debemos convertirlo en un entero de 16 bits sin signo ya que sabemos que la tarjeta es de 12 bits. Para ello se utiliza la función de conversión a U16 de la paleta de funciones numéricas:


197



El código queda:

Ahora los doce bits deben quedar distribuidos de la siguiente forma: BASE + 4 ( MODO ESCRITURA) Bit

D7

D6

D5

D4

D3

D2

D1

D0

Value

DA3

DA2

DA1

DA0

X

X

X

X

BASE + 5 ( MODO ESCRITURA) Bit

D7

D6

D5

D4

D3

D2

D1

D0

Value

DA11

DA10

DA9

DA8

DA7

DA6

DA5

DA4

El valor que nosotros tenemos de 16 bits tiene el formato siguiente Valor 16 bits: 0000 AAAA AAAA AAAA (A valor binario 0-1) La primera operación que se debe realizar es introducir 4 ceros de derecha a izquierda (multiplicar por 16). Luego se tiene: Valor 16 bits: AAAA AAAA AAAA 0000 Véase que los 8 bits menos significativos corresponden al valor que se debe escribir en BASE+4 mientras que los 8 bits más significativos corresponden al valor a escribir en BASE+5.


198



La operación a realizar es la división con resto entre 256. El resultado será el valor colocado en BASE+5 y el resto el valor colocado en BASE+4.

Para hallar el cociente y el resto se utilizará la función numérica funciones numéricas:

que e halla en la paleta de

Es necesario realizar la escritura en BASE+4 y BASE+5 en dos pasos bien definidos ya que al efectuar la segunda escritura la TAD PCL 818L automáticamente realiza la conversión D/A y envía la salida. El próximo paso es muy sencillo:

Estudio individual: Realice un programa en LabVIEW que lea y escriba las entradas y salidas digitales de la TAD 818L.


199



TEMA X Trabajo con puerto serie en LABVIEW Saber configurar el puerto serie. Saber realizar lecturas del pu erto serie ut ilizando LabVIEW. Saber realizar escrituras del puerto serie utilizando LabVIEW. • • •

Ejercicio 1 Hacer un programa que permita, una vez configurado el puerto serie, enviar diez muestras de datos aleatorios que simulen lecturas de nivel en un tanque. El nivel varía entre 0 y 10 m. Arquit ectura VISA. VISA: Virtual Instrument Software Architecture. Aprobado para lograr estandarizar la manera de obtener y pedir datos desde y hacia instrumentos de medición (VXIplug&play Systems Alliance). Entre esta estandarización se incluyen los dispositivos de comunicación serie y paralelo. NI-VISA: Es la solución de “National Instruments” para VISA. Solución: Como toda aplicación esta debe comenzar con la realización del código necesario para ejecutar y terminar la aplicación. Para ello debe colocar un botón booleano de salida y realizar el código siguiente:

Es importante revisar cuales son lo parámetros de configuración del puerto serie: 4. 5. 6. 7. 8.

Establecer la velocidad de Tx y Rx (Baud rate). Establecer la cantidad de bits de datos del prot ocolo de intercambio serie. Establecer la cantidad de bits de parada del protoco lo de intercambio serie. Establecer la paridad del prot ocol o de intercambio serie. Establecer el número del puerto a través del cual se realizará el intercambio serie. 9. Establecer tamaño del buffer que almacenará los datos recibidos y/o transmitidos.

La ejecución de esta aplicación tiene como primer paso la configuración del puerto serie. Por lo tanto se utilizará una estructura secuencia donde antes de entrar al ciclo principal se hace la configuración.


200



Ahora debemos agregar una secuencia pero que se ejecute antes de que se entre en el ciclo principal de la aplicación, para ello se da clic derecho sobre la estrucura “secuence” y se selecciona la opción “Add Frame Before”. El código es:

Como es de esperar es una secuencia vacía. Antes de programar la configuración debemos introducir los controles necesarios. Para configurar el puerto a través del cual se recibirán y/o introducirán los datos es necesario utilizar un control de recursos denominado “VISA Resource Name” controles.


en la paleta de

201



Para los bits de parada utilizaremos un control “Enum” con los siguientes ítems: 1. 1 bits 2. 1,5 bits 3. 2 bits Para Paridad utilizaremos un control “Enum” con los siguientes ítems: 1. None 2. Odd 3. Even 4. Mark 5. Space Para Velocidad utilizaremos un control “Numeric” del tipo U16 Para Bits de datos utilizaremos un control “Numeric” del tipo U8 El panel Frontal queda diseñado de la siguiente manera:


202



Para configurar el puerto se utiliza la función de VISA diseñada para ello que se encuentra en la paleta de funciones bajo el nombre:“VISA Configure Serial Port” Como se muestra a continuación:

->

->

.

Después de conectada esta función El código es:


203



Ya tenemos configurado el puerto serie por lo que estamos listos para enviar datos a través del mismo. Según los requerimientos de la aplicación colocaremos un indicador de nivel que visualizará las mediciones aleatorias y un control booleano mediante el cual se generarán los datos y se enviarán al puerto serie. Además, colocaremos un indicador de tipo arreglo que contendrá las diez muestras generadas, de manera que podamos ver cuales han sido los datos enviados. La interfaz quedará de la siguiente manera:

La acción mecánica del botón “Enviar Datos” debe ser “Latch When Pressed”, ya que al pulsar este botón solo debe ejecutarse el código asociado una sola vez. Generar diez números aleatorios es un código conocido:


204



Observaciones: •

•

• •

Solo cuando se ejecute el botón “enviar datos” ejecutará el lazo generando 10 valores aleatorios. Cada valor aleatorio se visualizará en el indicador “tank” (si desea verlo debe introducir una demora en tiempo)!Hágalo¡ Al finalizar el ciclo obtendremos un arreglo de diez valores entre 0 y 10 El ciclo se repetirá al presionar el botón una sola vez debido a su acción mecánica.

Solo nos resta enviar estos valores a través del puerto serie. Para ello es necesario obtener la función indicada para ello

->

->

:

Esta función es muy sencilla toda vez que debemos pasarle el “recurso” abierto (previamente configurado) y la cadena de caracteres que se quiere escribir en el puerto serie. Para ello creamos una variable local a partir del control “VISA Resource Name” la conectamos al parámetro correspondiente:


205



Los datos que se enviarán deben estar en formato de cadena de caracteres, sin embargo, hasta este momento tenemos un tipo de dato arreglo. Por esta razón debemos realizar una conversión de tipos, para ello utilizaremos la función “Array To Spreadsheet String”:

Esta función convierte una arreglo de valores reales en una cadena cuyo contenido serán los números que pertenecen al arreglo separados por el tabulador “Tab” y con un formato de “%.2” que indica una precisión de dos valores después de la coma. El código final de la aplicación queda según se muestra a continuación:

Antes de finalizar debemos cerrar el recurso abierto. Para ello creamos otra variable local del recurso y creamos otra secuencia después del ciclo principal y utilizamos la función “VISA Close”


206



El código que se debe programar en esta última secuencia es muy simple:

Ejercicio 2 Realice un programa que permita leer los valores enviados al puerto serie de la computadora utilizando el ejemplo anterior. El programa debe graficar los valores obtenidos. Solución: Para dar solución a este ejercicio es necesario, de la misma manera que pasó en el ejercicio anterior, configurar el puerto serie. Es por ello que ahora partiremos de un código que ya se ha discutido:


207



Para leer la información que se recibe a través del puerto serie es necesario hacerlo siguiendo dos pasos: 1. Encuestar la cantidad de bytes recibidos utilizando la función “VISA Bytes at serial port” 2. Leer los bytes que se tienen utilizando la función “VISA Read” Sabemos que enviaremos 10 números menores que 10 en formato %.2f esto significa que recibiremos: 1*10 caracteres = 10 caracteres antes de la coma 2*10 caracteres = 20 caracteres después de la coma 1*10 caracteres = 10 caracteres coma en cada número 1*10 caracteres = 10 caracteres separadores 1 carácter fin de línea. Total = 51 caracteres. Es por esto que nuestro programa puede esperar a que estén los 51 bytes para luego efectuar una lectura completa. Para ello debemos encuestar mediante la función ya mencionada que se obtiene:


208



¡Cuidado! El icono mostrado en la paleta de funciones “G”

no es igual al icono mostrado en el código

.

Ahora debemos encuestar la cantidad de bytes hasta que su número sea 51:

Observaciones: •

•

•

Al igual que el ejemplo anterior debemos crear una variable local que corresponde al recurso configurado previamente. La función “VISA Bytes at serial port” devuelve la cantidad de bytes que llegan al puerto El ciclo no culminará hasta tanto no lleguen 51 bytes.


209



Una vez que se sale del ciclo es debido que existen 51 bytes y se ha recibido la totalidad de la información. Es por ello que se puede leer la información. Para ello se usa la función “VISA Read”

Esta función recibe como parámetros el recurso desde el cual se leerá y la cantidad de bytes que se leerán. Devuelve la cadena de caracteres leídos desde el puerto serie.

Observaciones: •

Fíjese que en este caso se está sacando fuera del ciclo “while” un valor simple (el último generado), y no el arreglo de valores generados.

Ahora solo resta convertir la cadena de caracteres en un arreglo de valores que sea capaz de trazarse en una gráfica “WaveformGraph”. Para ello se realiza el proceso inverso utilizando ahora la función “SpreadSheet String to Array”.


210



Observaciones:

•

•

•

La función “SpreadSheet String to Array” recibe por defecto un arreglo de dos dimensiones. En nuestro caso se utilizará un arreglo unidimensional, por lo que debemos especificar su tipo utilizando un arreglo constante [DBL]. El formato especificado debe coincidir con el de la aplicación precedente de manera que sean compatibles (%.2f) Debe incluir una secuencia, al igual que en el ejemplo anterior, que cierre el recurso abierto.

Para que se visualicen mejor los datos aquí también colocamos un indicador de tipo arreglo que muestre los valores recibidos. El panel frontal queda como sigue:


211



Indicaciones para ejecutar la aplicación. 1. Usted debe introducir los mismos parámetros de configuración entre una y otra aplicación de forma tal que el protocolo de la transmisión sea similar. 2. Debe correr la aplicación de escritura. 3. Luego debe correr la aplicación de lectura. 4. Presionar el botón enviar. 5. Comprobar la recepción. ¡Alerta! No es posible terminar la aplicación de lectura ya que siempre se queda encuestando los bytes en el puerto serie. ¡Obtenga una solución a este problema! Estudio individual: Realice un programa en LabVIEW que simule un Chat punto a punto utilizando el puerto serie. Asuma que los mensajes son siempre de tamaño fijo (50 caracteres) en caso de que sea menor debe completar con espacio


212



TEMA XI Trabajo c on puerto paralelo en LabVIEW Saber Trabajar con el p uerto paralelo. Saber realizar lectur as del puerto paralelo uti lizando LabVIEW. Saber realizar escrituras del puerto paralelo util izando LabVIEW. • • •

Ejercicio 1 Utilizando 7 Leds conectados a 7 pines del puerto paralelo, encender cada uno en orden secuencial. El programa debe repetir el ciclo hasta tanto el usuario lo desee. Arquit ectura VISA. VISA: Virtual Instrument Software Architecture. Aprobado para lograr estandarizar la manera de obtener y pedir datos desde y hacia instrumentos de medición (VXIplug&play Systems Alliance). Entre esta estandarización se incluyen los dispositivos de comunicación serie y paralelo. NI-VISA: Es la solución de “National Instruments” para VISA. Solución: Como toda aplicación esta debe comenzar con la realización del código necesario para ejecutar y terminar la aplicación. Para ello debe colocar un botón booleano de salida y realizar el código siguiente:

Es importante revisar cuales son las características del puerto paralelo: 10. Su conector pos ee 25 pines de salida. 11. De estos 25 pines hay 8 (del 2 al 9) que corresponden al puerto de salida que se encuentra generalmente en la direcc ión 378h. 12. Para que no ocur ra un error de escrit ura el puerto las señales corresp ondientes a “Papel Out” (pin 12) y “Busy” (pin 11) deben estar conectadas a tierra. De esta manera la computadora no percibe ningún error y envía la información.

Para configurar el puerto a través del cual se recibirán y/o introducirán los datos es necesario utilizar un control de recursos denominado “VISA Resource Name” controles.


en la paleta de

213



Ahora debemos añadir a nuestra interfaz un arreglo de Led que simulen el comportamiento de los leds reales que están conectados a cada uno de los pines del puerto paralelo. La interfaz quedará de la siguiente manera:

Antes de enviar los datos hacia el puerto paralelo debemos abrir una sesión VISA. Para ello debemos utilizar la función “Visa Open” que se encuentra en la paleta de funciones:


214



Esta función necesita el nombre del recurso que abrirá, en este caso el que proviene del control VISA. El código queda de la siguiente forma:

Solo necesitamos enviar datos a través del puerto paralelo. Para ello es necesario obtener la función indicada para ello

->


->

:

215



Esta función es muy sencilla toda vez que debemos pasarle el “recurso” abierto y la cadena de caracteres que se quiere escribir en el puerto.



216



La posición inicial de cada uno de los 7 pines que conectaremos estará dada de manera tal que el pin 2 tendrá valor 5 V o “1” lógico, mientras que los demás (3-8) estarán en 0 V o “0” lógico. Esto puede representarse por un arreglo constante de 7 variables booleanas. Luego debemos rotar este arreglo de manera tal que el valor verdadero que esta en el elemento inicial se desplace por cada una de las 7 posiciones. Para ello utilizaremos la funcion “Rotate 1D Array” que se encuentra:

Esta función recibe como parámetro la cantidad de elementos que debe rotar. El código que finalmente realiza lo que buscamos es el siguiente:


217



Observaciones: •

•

•

La función se encuentra la paleta de funciones matemática y devuelve el cociente y resto de la división entre los números. Queremos rotar el primer elemento del arreglo desde el lugar 0 hasta el 6. Estos son los resultados posibles que se obtienen de cada resto al dividir “i” entre 7. El resultado se indica en el arreglo de voléanos que simula los leds reales. El arreglo rotado es convertido en su correspondiente número entero y este a su vez en el carácter correspondiente debido a que la función “Visa Write” así lo requiere. Para realizar estas conversiones se utilizaron las funciones “Bolean Array to Number” situada en la Paleta de funciones booleanas y la función “Type Cast” que convierte un numero entero en su correspondiente carácter ASCII. Esta se encuentra en:


218



Antes de finalizar debemos cerrar el recurso abierto. Para ello creamos otra variable local del recurso y creamos otra secuencia después del ciclo principal y utilizamos la función “VISA Close”


El código final queda:


219



Estudio individual: Realice un programa en LabVIEW sea capaz de encender una lámpara de 7 segmentos.


220



TEMA XII Comunicación TCP-IP en LabVIEW • • •

Saber configu rar una Transmis ión TCP-IP. Saber realizar lect uras del puerto TCP-IP utilizando LabVIEW. Saber realizar escri turas en el puert o TCP-IP utili zando LabVIEW.

Ejercicio 1 Hacer un programa que permita, una vez configurado el puerto TCP-IP, enviar diez muestras de datos aleatorios que simulen lecturas de nivel en un tanque. El nivel varía entre 0 y 10 m. Solución: Como toda aplicación esta debe comenzar con la realización del código necesario para ejecutar y terminar la aplicación. Para ello debe colocar un botón booleano de salida y realizar el código siguiente:

Es importante revisar cuales son lo parámetros de configuración del puerto TCP-IP: 13. Establecer los parámetros del Servido r TCP-IP. a. Establecer el número de puerto desde donde se aceptarán conexiones. b. Crear el servic io. c. Esperar por que un cli ente se conecte. Por Convenio haremos que la aplicación servidora es la genera los datos. La ejecución de esta aplicación tiene como primer paso la creación del servicio. Por lo tanto se utilizará una estructura secuencia dónde, antes de entrar al ciclo principal, se crea el servicio TCP-IP.


221



Ahora debemos agregar una secuencia pero que se ejecute antes de que se entre en el ciclo principal de la aplicación, para ello se da clic derecho sobre la estructura “secuence” y se selecciona la opción “Add Frame Before”. El código es:

Como es de esperar es una secuencia vacía. Antes de crear el servicio debemos introducir un control donde se introduzca el número de puerto que identificará la conexión. Para ello utilizaremos un control “Numeric” del tipo U16 El panel Frontal queda diseñado de la siguiente manera:


222



Ahora debemos utilizar la función: “TCP Create Listener” que abre un puerto y lo reserva para la aplicación actual que hará función de servidora. Ella se encuentra en la paleta de funciones dentro de:

->

->

Ya está creado el servicio, sin embargo debemos utilizar otra función que permite esperar a nuestro programa hasta que un cliente se conecte. La función esta en la misma paleta y se denomina “TCP Wait On Listener”


->

->

223



El código de apertura es el siguiente:

Observaciones: A la salida de la función “TCP Create Listener” se obtiene un idéntificador de conexión que sirve de parámetro de entrada a la función “TCP Wait On Listener” A su vez la función “TCP Wait On Listener” devuelve este parámetro que debe utilizarse como referencia a la hora de escribir o recibir datos hacia o desde el cliente. Debe cuidar que la conexión se haga sobre el parámetro “Connection ID” y no sobre “ Listener ID Out” •

•

Ya tenemos abierto el puerto TCP-IP por lo que estamos listos para enviar datos a través del mismo. Según los requerimientos de la aplicación colocaremos un indicador de nivel que visualizará las mediciones aleatorias y un control booleano mediante el cual se generarán los datos y se enviarán al puerto. Además, colocaremos un indicador de tipo arreglo que contendrá las diez muestras generadas, de manera que podamos ver cuales han sido los datos enviados. La interfaz quedará de la siguiente manera:


224




Observaciones: •

•

Solo cuando se ejecute el botón “enviar datos” ejecutará el lazo generando 10 valores aleatorios. Cada valor aleatorio se visualizará en el indicador “tank” (si desea verlo debe introducir una demora en tiempo)!Hágalo¡


225


• •


Al finalizar el ciclo obtendremos un arreglo de diez valores entre 0 y 10 El ciclo se repetirá al presionar el botón una sola vez debido a su acción mecánica.

Solo nos resta enviar estos valores a través del puerto. Para ello es necesario obtener la función indicada para ello “TCP Write”

->

->

Esta función es muy sencilla toda vez que debemos pasarle el identificador de conexión abierto en la secuencia anterior y la cadena de caracteres que se quiere escribir en el puerto serie. El código es el siguiente:


226






227



Antes de finalizar debemos cerrar la conexión abierta. Para ello creamos otra secuencia después del ciclo principal y utilizamos la función “TCP Close Connection”



228



Ejercicio 2 Realice un programa que permita leer los valores enviados al puerto TCP-IP de la computadora utilizando el ejemplo anterior. El programa debe graficar los valores obtenidos. Parámetros del Cliente TCP-IP. 1. Establecer el número de puerto desde donde se aceptarán conexiones 2. Establecer la dirección IP del servidor que ofrece el servicio. Solución: Para dar solución a este ejercicio es necesario abrir una conexión TCP-IP en un servidor. Es por ello que ahora necesitamos un control con el número de puerto que identifica a la conexión además de un control de cadena que contenga la dirección IP deonde se encuentra el servicio el panel frontal es:

La función que abre una conexión en el servidor se denomina “TCP Open Connection” y se encuentra en la paleta de funciones: ”


->

->

229




230



Para leer la información que se recibe a través del puerto TCP-IP se utiliza la función “TCP Read”. Para ello es necesario pasar como parámetro la cantidad de bytes que se recibirán. Sabemos que enviaremos 10 números menores que 10 en formato %.2f esto significa que recibiremos: 1*10 caracteres = 10 caracteres antes de la coma 2*10 caracteres = 20 caracteres después de la coma 1*10 caracteres = 10 caracteres coma en cada número 1*10 caracteres = 10 caracteres separadores 1 carácter fin de línea. Total = 51 caracteres. Es por esto que nuestro programa puede esperar a que estén los 51 bytes para luego efectuar una lectura completa.

La función “TCP Read” ”

->


->

231



El código es:

Observaciones: •

•

Al igual que el ejemplo anterior debemos pasarle el identificador de conexión que se obtiene en la secuencia anterior. El ciclo no culminará hasta tanto no lleguen 51 bytes.



232



El Código es:

Observaciones:

•

•

•




233



Indicaciones para ejecutar la aplicación. 6. 7. 8. 9. 10.

Usted debe introducir el mismo número de puerto en una y otra aplicación. Correr la aplicación servidora (escritura). Correr la aplicación cliente (lectura). Presionar el botón enviar. La dirección IP en el cliente puede ser 127.0.0.1 en caso de que ambas aplicaciones se ejecutan sobre la misma PC.

Estudio individual: Realice un programa en LabVIEW que simule un Chat punto a punto utilizando el puerto TCPIP. Asuma que los mensajes son siempre de tamaño fijo (50 caracteres) en caso de que sea menor debe completar con espacios.


234



TEMA XIII Comunicaión DDE Realizar intercambio de datos a través del protocolo DDE. Ejercicio 1 Hacer un programa que publique diez muestras de datos aleatorios que simulen lecturas de nivel en un tanque. El nivel varía entre 0 y 10 m. Solución: Como toda aplicación esta debe comenzar con la realización del código necesario para ejecutar y terminar la aplicación. Para ello debe colocar un botón booleano de salida y realizar el código siguiente:

Es importante revisar cuales son los parámetros que permiten publicar datos utilizando el protocolo DDE: 14. Establecer los p arámetros del Servidor DDE. a. Crear el Servicio y el Tema b. Crear una Variable dentro del tema abierto c. Enviar Datos. Por Convenio haremos que la aplicación servidora es la genera los datos. La ejecución de esta aplicación tiene como primer paso la creación del servicio. Por lo tanto se utilizará una estructura secuencia dónde, antes de entrar al ciclo principal, se crea el servicio, tema y variable DDE.


235



Ahora debemos agregar una secuencia pero que se ejecute antes de que se entre en el ciclo principal de la aplicación, para ello se da clic derecho sobre la estructura “secuence” y se selecciona la opción “Add Frame Before”. El código es:

El servicio que crearemos se llamara “LabVIEWDDE”, dentro de este servicio crearemos un tema denominado “Datos” y una variable denominada “Valores” Las funciones DDE no están disponibles en la Paleta de funciones, por lo que debemos buscarlas nosotros mismos:

Para ello presionamos el botón: que se encuentra en la parte inferior de la paleta de funciones. Cuando se abra el cuadro de diálogo nos dirigimos hacia el camino: “C:\Program Files\National Instruments\LabVIEW 6.1\vi.lib\platform” y seleccionamos la biblioteca “dde.llb” que contiene las funciones que buscamos.


236



Al abrir una librería “.LLB” se muestra un cuadro como el siguiente:

Ahora debemos utilizar la función de la librería: “DDE Srv Register Server” que se encuentra en la parte inferior de la lista. Para colocarla en el codigo debe seleccionarla y presionar “OK” en el cuadro de diálogo. La ayuda asociada es la siguiente:

Además de esta función debemos usar la función DDE Srv Register Item” que se obtiene de forma similar a la anterior ya que se encuentra en la misma librería. Su ayuda es:


237



El código de apertura es el siguiente:

Observaciones: A la salida de la función “DDE Srv Register Server” se obtiene un idéntificador de conexión que sirve de parámetro de entrada a la función “DDE Srv Register Item” A su vez la función “DDE Srv Register Item” devuelve este parámetro que debe utilizarse como referencia a la hora de escribir o recibir datos hacia o desde los clientes DDE. •

•

Ya tenemos abierto el servicio DDE por lo que estamos listos para enviar datos a través del mismo. Según los requerimientos de la aplicación colocaremos un indicador de nivel que visualizará las mediciones aleatorias y un control booleano mediante el cual se generarán los datos y se enviarán al puerto. Además, colocaremos un indicador de tipo arreglo que contendrá las diez muestras generadas, de manera que podamos ver cuales han sido los datos enviados. La interfaz quedará de la siguiente manera:


238




Observaciones: •

•

• •

Solo cuando se ejecute el botón “enviar datos” ejecutará el lazo generando 10 valores aleatorios. Cada valor aleatorio se visualizará en el indicador “tank” (si desea verlo debe introducir una demora en tiempo)!Hágalo¡ Al finalizar el ciclo obtendremos un arreglo de diez valores entre 0 y 10 El ciclo se repetirá al presionar el botón una sola vez debido a su acción mecánica.


239



Solo nos resta enviar estos valores a través del servicio DDE. Para ello es necesario obtener la función indicada para ello “DDE Srv Set Item”

Esta función es muy sencilla toda vez que debemos pasarle el identificador del servicio e ítem abierto en la secuencia anterior y la cadena de caracteres que se quiere escribir en el puerto serie. El código es el siguiente:



240




Antes de finalizar debemos cerrar el ítem registrado y el servicio abierto. Para ello creamos otra secuencia después del ciclo principal y utilizamos las funciones “DDE Srv Unregsiter Item” “DDE Srv Unregsiter Service” que se obtienen de la misma forma que las anteriores. El código que se debe programar en esta última secuencia es muy simple:


241



Ejercicio 2 Realice un programa que permita leer los valores enviados DDE utilizando el ejemplo anterior. El programa debe graficar los valores obtenidos. Solución: Para dar solución a este ejercicio es necesario abrir una conexión DDE en un servidor. La función que abre una conexión en el servidor se denomina “DDE Open Conversation” y se encuentra en la misma librería de funciones que se utilizo en el ejercicio anterior:

Esta función necesita que se le pasen como parámetro el nombre del servicio y el tema o tópico que se utilizará, el código es el siguiente:


242



El siguiente paso es realizar la lectura de los datos que se reciben a través de esta conexión. Para ello creamos una secuencia posterior y luego nos posicionamos en un ciclo hasta tanto el usuario desee culminar el programa. El código queda:

Para leer la información que se recibe a través de DDE se utiliza la función “DDE Request”. Que se encuentra de nuavo el la librería de funciones. Esta función debe recibir el identificador de la conexión abierta y que variable de servidor va a leer. Si se recuerda del ejemplo anterior esta se llama “Variable”.

El código es:


243



Observaciones: •

Al igual que el ejemplo anterior debemos pasarle el identificador de conexión que se obtiene en la secuencia anterior.


El Código es:


244



Observaciones:

•

•

•




245

Programación en LabVIEW

Recommend Documents