EJEMPLOS CON LABVIEW CONVERSIÓN DE TEMPERATURA En este primer ejemplo el objetivo es crear un programa que permita al usuario introducir algún valor de temperatura ya sea en Kelvin, Fahrenheit o Kelvin y obtener las respectivas conversiones, para lograrlo hay diversas maneras. Se propone un programa sencillo con comandos básicos y posteriormente algunas mejoras utilizando diversos métodos. Para la versión más sencilla del programa se emplea una entrada (num ctrl) y dos salidas (num ind) para cada conversión, las cuales serán lo que el usuario podrá ver. Para la estructura del programa basta con utilizar diferentes funciones numéricas. Creación del programa básico Paso 1: Crear la interface del usuario en panel frontal (Front Panel)
Figura 1
En el panel frontal se tendrá entonces una entrada y dos salidas para cada unidad de temperatura, para que sea fácil de interpretar por el usuario las etiquetas de las salidas de cambian de Numeric a el nombre de las variables de temperatura a empelar.
Figura 2
Se puede ver en la figura 2 que podemos introducir diferentes unidades de temperatura y ver sus equivalencias en las unidades respectivas. Paso 2: Crear el programa para conversiones basándose en fórmulas establecidas. En este paso se emplean las funciones numéricas de programming:
Figura 3 Para este caso se emplearan Add (suma), Substract (resta)y Multiply (multiplicación), además el uso de Numeric Constant. Considerando las siguientes fórmulas: ° C=K −273.15
° C=
( ° F−32 )∗5 9
° F=
(° C∗9) + 32 5
° F=
( K∗9) −459.67 5
K=° C+273.15
K=
(° F+ 459.69)∗5 9
Las fórmulas se pueden introducir de manera sencilla pero algo laboriosa desde el Block Diagram, veremos el primer caso para convertir de Kelvin a °F y °C.
Figura 4 Como se puede observar, la fórmula para convertir a Fahrenheit primero hace una multiplicación por el factor 1.8 que es el cociente de 9/5 y a ese resultado se le resta otra constante (459.67). La secuencia es simple, la salida del numeric control “Kelvin K” entra al multiplicador, a su vez la salida de la multiplicación entra a la resta y finalmente llega al numeric indicator °F. En el caso de la conversión a °C la fórmula dice que solo hay que restar 273.15, la entrada de la resta es la salida de “Kelvin K” y una constante. Las constantes como se ha visto pueden introducirse con numeric constant desde las funciones numeric (figura 3). Sin embargo también pueden introducirse dando clic derecho a la entrada y seleccionando del menú emergente el comando “create”:
Figura 5
Cuando se acerca el cursor a la función suma se puede ver las dos entradas, al hacer clic derecho en alguna de ellas aparecerá un menú emergente y en el comando créate veremos tres opciones para introducir una constante, un control o un indicador, esto es útil cuando se trata de agilizar la creación de programas. El proceso de desarrollar las operaciones se realiza con las tres variables y sus conversiones, en la figura 4 se muestra la estructura para el caso de grados Kelvin, aquí se muestra la propuesta para la conversión Fahrenheit y Celsius:
Figura 6
Fácilmente se puede ver que la estructura es similar al primer caso siguiendo la secuencia de entradas y salidas, además, en la fórmula de °F se observa que podemos usar la misma constante de 0.5555555556 (factor derivado de la fórmula que se expresa como 5/9) en las dos multiplicaciones tal y como las salidas de los numeric control. Paso 3: Correr el programa y comprobar que las operaciones se realicen correctamente. Una vez que se tiene el programa completo se puede correr el programa y comprobar que haga las operaciones deseadas, para ejecutar el programa debemos ir al icono correspondiente que se ubica debajo de la barra de menús en el panel frontal o el diagrama de bloques:
El botón Run Continuously ejecuta el programa de manera continua para que se puedan ver los cambios de manera inmediata. Para poder interactuar con el programa es necesario ir al panel frontal:
Figura 7
Cuando se ejecuta el programa, el botón Run Continuously se torna color negro y el botón Abort Execution se habilita poniéndose de color rojo. En el programa podemos introducir valores en los numeric control manualmente, Para comprobar que el programa hace falta una referencia, por ejemplo el punto de congelación de agua o el cero absoluto: Unidad
K °C °F
Punto de congelación de agua 273.15 0 32
Cero Absoluto
0 -273.15 -459.67
Como se puede observar en la figura 7, las equivalencias coinciden bien con el punto de congelación, ahora con el cero absoluto:
Figura 8
Hasta ahora se ha analizado lo básico acerca de la estructura de un programa en Labview, sin embargo podemos hacer cambios dependiendo ciertas funciones que faciliten la elaboración de un programa y hacerlo más fácil de entender. Mejoras Al Programa De Conversión De Temperatura En primer lugar para facilitar al usuario la manera en como interactúa con el programa y reducir espacio, podemos utilizar un Tab Control, para acceder a él, en el panel frontal al acceder a las opciones con clic derecho buscamos “system”, buscamos en ele menú emergente el apartado “containers” y buscamos el “system tab control”
Figura 9
Figura 10
En el Tab Control se puede navegar a travez de pestañas para facilitar el uso del programa y no ocupar tanto espacio en la pantalla, para editar las características que vienen por default podemos cambiar el nombre de las páginas (Page 1 y 2 por default) y agregar más. Para cambiar el nombre, al igual que con las etiquetas, al hacer doble click sobre la pestaña podemos cambiar el nombre.
Figura 11.
Además, es posible agregar más pestañas seleccionado el tab control haciendo clic en el borde, de esta manera aparecerá una línea punteada alrededor de la figura, cuando esta seleccionado de esta manera, al hacer clic derecho tendremos un menú con diferentes opciones, entre ellas está la opción de agregar una página antes o después (add page after/add page before), tambien se pueden ver opciones para quitar o duplicar páginas. En la figura 12 podemos ver el menú emergente con las diferentes opciones.
En la figura 13 vemos como debería quedar el menú con 3 pestañas (tabs) para cada unidad de temperatura.
Figura 12
Figura 13
Teniendo las tres pestañas, para arrastrar los num control y num indicator hacemos clic cerca de uno o más y dejamos presionado el botón izquierdo, arrastramos el mouse hasta abarcar el área y soltamos el botón izquierdo, una vez que se han seleccionado los elementos que se quieren mover, al hacer clic y dejar presionado el botón, podemos arrastrar el mouse para mover todo el conjunto hasta la posición deseada, en este caso dentro del tab control.
1
2
3
4 Figura 14
La figura 14 muestra la secuencia para arrastrar los elementos dentro del Tab control, de esa manera teniendo cada unidad dentro de una pestaña, sin embargo esto solo es un cambio en el aspecto visual, la programación aún no ha cambiado, por lo que el siguiente paso en la mejora es cambiar la forma en la que se hacen las operaciones.
Para una programación más sencilla se emplean diferentes funciones como las de la categoría express. Dentro de estas funciones se encuentran las aritméticas y a su vez la función fórmula (Figura 15), la cual nos permite introducir la formula tal y como se han visto
anteriormente aunque existen diferentes métodos esta forma es sencilla pues no requiere tantos elementos.
Figura 15
En la fórmula tenemos una entrada y una salida, para hacer la conversión conectamos el num control a la entrada de la formula y la entrada del num indicator a la salida de la fórmula (Figura 16).
Figura 16
Una vez que se tienen las formulas conectadas, se procede a escribir las fórmulas haciendo doble click (Figura 17) sobre el ícono, dentro de las opciones podemos cambiar el nombre de la variable de entrada que por default es X1 a alguno más fácil de interpretar (Figura 17).
Figura 17
En el recuadro donde se escribe la fórmula no es necesario escribir “Result=” por lo que solo se escribe el procedimiento con la variable de entrada. Podemos dejar la variable como X1, aunque en este caso se dejó como K que es referente a Kelvin.
Figura 18
Para los casos de Fahrenheit y Kelvin es fácil copiar y pegar las fórmulas desde algún editor de texto o introducirla con el teclado. El programa resulta más fácil de entender con esta estructura y es fácil de editar en el futuro. El programa final en el diagrama de bloques se muestra en la figura 18, mientras que la versión final en el panel frontal luce como en la figura 14. CONTROL DE TEMPERATURA En el siguiente programa el objetivo es hacer un indicador de un sistema de aire acondicionado que puede ir desde ventilación hasta calefacción dependiendo un rango de temperaturas, al variar la temperatura se podrá ver en la pantalla cual es el estado del sistema: ventilación, normal o calefacción. Para hacerlo, al igual que el ejemplo anterior primero se propone una versión con funciones básicas y después se implementan mejoras con funciones más especializadas y una mejor interface. Propuesta con comandos básicos Paso 1: Crear la interface de usuario Para este primer paso se necesita un control numérico, pero en este caso un control que sea más intuitivo por ejemplo una perilla, en este caso se emplea un Dial. También se necesitan indicadores; uno para ver la variación de la temperatura y otro para denotar la función del sistema, para esto se pueden emplear leds.
Figura 1
En la figura 1 se tienen los elementos necesarios para que el usuario pueda cambiar la temperatura y ver los cambios, sin embargo aún hay que cambiar los parámetros del Dial y el Thermometer. Lo primero es ir a las propiedades de cada componente y establecer los nuevos parámetros. Para esto se consideran las temperaturas de trabajo máximo y mínimo, para este ejemplo se
propone desde 0 °C hasta 40 °C, con tres intervalos: de 0 a 15 °C la calefacción, de 15 a 25 °C normal y de 25 °C en adelante ventilación. Para acceder a las propiedades de un elemento se da clic en el borde de un elemento y cuando se ha seleccionado se da click derecho, en el menú emergente, en la parte inferior se encuentra la opción “properties”. En las propiedades encontramos distintas pestañas, para cambiar la escala: click en la pestaña Scale, en la cual se encuentran los limites inferior y superior, en este caso se cambiará el límite superior (Scale Range: Maximum). En este caso, el Knob/Dial y el Thermoemeter pueden tener un valor “Maximum” de 40 (Figura 2).
Figura 2
Una vez que se han cambiado las etiquetas y los valores de escala se acomodan los elementos y se ajustan los tamaños para que sea fácil de manipular y entender (Figura 3) El tamaño se modifica arrastrando el mouse mientras se hace click sobre alguno de los puntos (nodos) que se habilitan cuando se acerca el cursor a algún elemento, el tamaño puede ajustarse para mejorar la forma como se trabaja con el programa pues permite ver mejor los valores de las variables y la relación del indicador numérico y el control numérico.
Figura 3
Teniendo preparada la interface gráfica, ahora se procede a programar, el método más básico es utilizando comparadores y operaciones con boléanos. Para esto se emplean lasfunciones de las categorías “Comparison” (Figura 4) y “Boolean” que se encuentran dentro de programming.
Figura 4
En el caso de Boolean sólo se empleara la función “and”. Paso 2: Elaboración de la estructura del programa Lo primero por hacer es marcar los rangos, en primer se tiene el rango de 0 a 15 °C para lo cual se utilizan los comparadores “mayor que” y “menor que”, en este primer rango es: cuando la variable es mayor que 0 y menor que 15 entonces se trata de la calefacción. El comparador “mayor que” hará una comparación de a variable con una constante 0, el comparador “menor que” hará la comparación con una constante de valor 15. Para relacionar estas dos comparaciones y saber que la variable esta entre este rango se emplea una función booleana “and” para cumplir con la sentencia: “si es mayor a 0 y menor a 15”, si se cumplen las dos condiciones, entonces se tendrá una señal “true” o verdadera, de lo contrario habrá una señal “false”. Dado que los leds dependen de señales booleanas, entonces cuando la condición se cumpla, entonces el led permanecerá encendido hasta que esta condición ya no sea verdadera.
Figura 5
En la figura 5 se puede observar que desde el control que es la variable, pasa a los comparadores, en los cuales se interpreta como “X>=Y?” (es x mayor o igual a y), siendo “x” la variable que entra por la parte superior del comparador y “y” la variable o constante que entra por la parte inferior. De esta forma se han marcado los límites, también se aprecia la condición de “and” y su salida conectada al led que indica que en ese momento el sistema funciona como calefacción. De la figura anterior se puede ver que el termómetro está conectado al control, de esta manera se podrá ver un cambio en la temperatura de manera gráfica para dar una mejor presentación.
Figura 6
Haciendo las comparaciones correspondientes se tiene finalmente el programa como en la figura 6. Paso 3: Ejecución del programa Para comprobar que el programa hace lo que se desea se comprueba que los leds enciendan de acuerdo al cambio de la temperatura, la cual a su vez cambia de acuerdo al control manual. El programa deberá lucir como en la figura 7. En donde al mover la perilla el termómetro cambiara de forma paralela al control, a su vez los leds encenderán y apagaran de acuerdo al valor. Se pueden apreciar los tres casos (A, B y C) con los distintos cambios del programa.
A
B
C Figura 7
Hasta ahora se ha hecho el programa con comparaciones básicas, pero al igual que con el conversor de temperatura se puede hacer con una función de comparación que se encuentra dentro de la categoría “comparison” (Figura 8)
Figura 8
Una vez en el diagrama de bloques, la función comparación debe quedar conectada como en la figura 9, con la salida del control a la entrada (Operand 1) del comparador, y la salida (Result) a la entrada del led (en la figura 9 calefacción).
Figura 9
Para establecer los rangos se hace doble click sobre el ícono del comparador para acceder al menú de configuración. (Figura 10) e n donde se encuentra la opción “In Range” en donde se establece el valor máximo y mínimo (Maximum y Minimum). Para el primer caso el rango es 0 y 15.
Figura 10
Al insertar todas las comparaciones el programa queda como en la figura 11, siendo más fácil de modificar y entender. El programa sigue funcionando de la misma manera.
Figura 11
Podría haber métodos con programación para este ejemplo, pero en este caso el ejemplo se limita a estas funciones básicas, más adelante se analizan métodos de programación que pueden servir para idear un método para este ejemplo. CALCULADORA El ejemplo de la calculadora tiene como objetivo crear diversas formas en como introducir datos y trabajar con ellos en una estructura “case”, además de emplear funciones previamente analizadas. La estructura puede hacer diversas acciones dependiendo condiciones de entrada, por lo que en el programa que a continuación se analizará podrán introducirse valores por medio de control numérico o string.
Una calculadora sencilla es como en la figura 1, con un tab control para seleccionar el tipo de operación, los indicadores y controladores numéricos quedan dentro de cada pestaña y en el diagrama de bloques se distribuyen las diferentes operaciones de forma que sea entendible.
Figura 1
Pero en el ejemplo más básico hay alguno problemas, por ejemplo, se utilizan demasiados controles e indicadores numéricos, además, si se piensa en agregar más opciones, entonces habrá que agregar más elementos y el diagrama de bloques estará lleno de operaciones dispersas. Si pensamos en usar un par de controles numéricos y entrelazar de tal forma que siempre se hagan las operaciones, entonces sería muy difícil entenderlo. La navegación no es un problema con pocas opciones, pero podría ser incómodo navegar por muchas pestañas. Para mejorar, la estructura case es buena para empezar, reduciendo los controles e indicadores y facilitando la navegación. Paso 1: Crear una estructura case y ajustar parámetros para tener cuatro operaciones básicas. En este paso lo primero es insertar una estructura case desde la categoría “structures” (Figura 2). Una vez que se tiene la estructura hay que ajustar ciertos parámetros como los casos a considerar, por default están dos casos: true y false, los cuales se pueden controlar con un botón para navegar entre los dos estados. Para este ejemplo se requieren cuatros casos;
suma, resta, multiplicación y división. Antes de comenzar con la interface se analizan los casos y como se distribuyen las variables. Para agregar más casos, se da click derecho sobre alguno de los bordes y se selecciona la opción “Add Case After” o “Add Case Before” (Figura 2), esto se hace tres veces para tener los cuatro casos necesarios y uno para valores no especificados (Default).
Figura 2
Cada “case” significa una operación la cual se activa dependiendo la condición que se ponga en la parte superior de la estructura, esto también depende de entrada de la estructura, es decir, si se tiene en la entrada una cadena (string) entonces la comparación será: si la cadena del caso es igual a la de entrada, entonces se ejecuta dicho caso. Para el primer ejemplo se emplearan números, del uno al cuatro, siendo como en el primer ejemplo: 1=suma, 2=resta, 3=multiplicación y 4=división, quedando como en la figura 3.
Figura 3
Una vez que se tienen los casos de las operaciones con un número asignado se debe agregar un caso con valor 0 con la palabra “Default” como en la figura 4.
Figura 4
Considerando lo anterior, se procede a introducir las operaciones y las variables, quedando como en la figura 5. En donde desde el panel frontal se insertan dos controles numéricos y un indicador numérico. Como se puede ver hay una operación dentro de cada caso (Figura 6). En el caso 0 el recuadro queda vacío.
Figura 5
Figura 6 Paso 2: Hacer las conexiones y ajustes necesarios Después de tener las operaciones asignadas a cada caso podemos conectar las entradas y la salida, esto se hace en cada caso (Figura 10). Se debe tener cuidado de verificar los nodos en donde están las entradas y la salida (color rojo), porque esos nodos son los mismos en cada caso (Figura 8), una buena forma de hacerlo es conectar desde el indicador (Resultado) hasta la estructura, una vez que se tiene el nodo se pueden hacer las otras conexiones a partir de este (Figura 9).
Figura 7
Figura 8
Una vez hechas las conexiones, se debe configurar que al no estar conectado el nodo, entonces use el Default, esto es porque en el caso 0 para valores no especificados no hay conexión, por lo que el programa no hará ninguna operación en caso de ser mayor que
cuatro o 0 en la entrada. Para hacer esto, click derecho en el nodo de salida y habilitar la opción “use default if unwired” (Figura 9)
Figura 9
Figura 10
Desde el panel frontal podemos agregar un control numérico (Operación), en esta primera versión y con lo visto en la figura 3, se podrá elegir la operación ingresando el número correspondiente. El control numérico se conecta a la entrada del case como en la figura 10. Paso 3: Ejecución del programa En este paso se comprueba que el programa haga las operaciones, como referencia en este caso se emplea el 25 y el 5 porque es fácil ver sus valores: suma=30, resta=20, multiplicación=125 y división=5. Se puede ver en la figura 11 cada caso: A) Suma, B) Resta, C) Multiplicación y D) División.
A
B
C
D Figura 11
Hasta ahora la entrada de números para seleccionar la operación resulta confusa si no se tiene conocimiento previo de cómo está organizado el programa, si se quisiera hacer algo más intuitivo y cómodo para el usuario sería necesario agregar un menú con las diferentes opciones correspondientes a cada operación. Diferentes Formas De Trabajar Con La Estructura Case En La Calculadora Para lograr un mejor uso de la estructura case en este tipo de aplicaciones se puede usar un “menu ring” con el cual se puede crear un menú con diferentes valores numéricos pero con la ventaja de que se puede asignar un nombre a cada valor, es decir, el usuario solo vera las opciones: “suma”, “resta”, “multiplicación” y “división” y podrá seleccionar cualquiera, pero las condiciones del case seguirán siendo numéricas. Para introducir un “menu ring” se accede desde las opciones del panel frontal, en la categoría “Modern” esta una subcategoría llamada “Ring & Enum” (Figura 12), igual que otros elementos basta con hacer click sobre la opción deseada para visualizarla en el panel frontal. El menú por default no tendrá ninguna opción y habrá que asignarle valores y etiquetas para poder navegar por la calculadora.
Figura 12
En las propiedades del “menu ring” encontraremos diferentes pestañas, en primer lugar, para hacer que la calculadora se actualice en cuanto cambiemos de opción navegamos a la pestaña “Display Format” en esta pestaña habilitamos la opción “Automatic Fromatting” Figura 13.
Figura 13
Para editar las diferentes opciones que desplegará el menú, en la pestaña “Edit Items”, en la cual podremos agregar los necesarios haciendo click en botón “Insert”, cada vez que se inserta un nuevo ítem se podrá agregar un nombre, para este caso el cero se queda vacío para que el programa no haga nada cuando haya un valor cero, para los siguientes número considerando el orden de los casos se pone el nombre correspondiente a cada operación (Figura 14).
Figura 14
En caso de cometer algún error se puede navegar con los botones “Move Up”, “Move Down” o eliminar el ítem con el botón “Delete”. Lo importante es dejar el número correspondiente a cada operación. En el diagrama de bloques se puede conectar el Ring a la entrada de la estructura como muestra la figura 15.
Figura 15
Al ejecutar el programa el menú despliega las opciones para las operaciones, esto es más fácil de entender y es práctico (Figura 16)
Figura 16
Al hacer click en la operación deseada el resultado cambiará automáticamente. Para demostrar que es posible usar cadenas, es decir, las palabras que corresponden a cada operación, se harán unos cambios que permiten analizar el alcance de la estructura. En primer lugar, la entrada será un “Text Control”, y los casos tendrán como condiciones cadenas de caracteres. Lo primer que hay que hacer es introducir un “Text Control” (String) como en la figura 17.
Figura 17
En el diagrama de bloques, habrá que cambiar las condiciones y dejarlas como se propone en la figura 18. Además, es recomendable primero conectar el Text Control (en este caso llamado Operación) a la entrada de la estructura para que al digitar la condición, esta automáticamente se interprete como una cadena, es decir, la palabra que es la condición quede entre comillas: “SUMA”, otra recomendación para este ejemplo es utilizar mayúsculas para evitar uso de acentos y otras posibles causas de fallo.
Figura 18
Finalmente una consideración es ir a las propiedades del Text Control y en la pestaña “Appearance” habilitar la opción “Update Value While Typing” (Figura 19) para evitar que dar click fuera del recuadro después de digitar la operación.
Figura 19
Otra consideración es ampliar el tamaño del Text Control en el panel frontal para poder ver la palabra más grande, en este caso “MULTIPLICACION”
Como se puede ver en la figura 20, después de digitar la palabra correspondiente, automáticamente se ejecutará la operación.
Figura 20
Al final de este ejemplo de calculadora concluimos que la estructura case es útil para manejar menús y es posible emplear esta estructura en aplicaciones que se abordarán más adelante.
LLENADO DE TANQUES El objetivo del siguiente ejemplo es utilizar la estructura while y los conocimientos previos de comparadores y elementos básicos para indicar el llenado de un tanque como el caso del indicador de temperatura. La aplicación de un programa como el de este ejemplo nos permite ver las posibilidades en la industria, en este caso se puede tratar de alguna alarma pero puede extenderse a un control o análisis más complejo. Para comenzar con este ejemplo se analizará la estructura “while” la cual como se ha visto permite ejecutar una operación mientras la condición para que se detenga sea falsa. En primera instancia se considera un tanque que se llenará hasta que la condición sea verdadera, es decir, aumentará su nivel hasta que la condición se cumpla. Paso 1: Crear estructura while y plantear las condiciones iniciales. Para comenzar, en el diagrama de bloques se inserta una estructura while, la cual se encuentra en la categoría estructures de la paleta de funciones (Figura 1). En esta estructura necesitamos una condición que se cumpla para que el programa termine, en este caso se fijará un valor final con el cual se hará una comparación entre la iteración y dicha constante. Para que sea fácil ver el cambio se propone un valor de 100 como constante. Para hacer la comparación se utiliza la función “Equal?” de la categoría “Comparison”, en la comparación se crea una constante en la parte superior (letra “x”) y en la inferior (letra “y”) se conecta la iteración (Figura 2)
Figura 1
Figura 2
Con lo anterior el programa se ejecutará comenzando con i=0 hasta i=100, pues al ser verdadera la comparación, se mandará una señal verdadera al botón de paro. Sin embargo este programa es muy rápido y no hay forma de ver el cambio, para evitar que el programa sea tan veloz se utiliza un “timer” para retrasar el ciclo de ejecución, considerando que 1000 unidades es 1 segundo en este timer (milisegundos) es posible usar un valor de menos de 1000 para poder ver el cambio y al mismo tiempo agilizar el programa. En el ejemplo se utilizará un valor de 200 ms. El Timer se encuentra en las funciones de programming en la categoría “Timing”, el timer a utilizar es el “Wait” (Figura 3)
Figura 3
Al timer se le puede crear una constante con el valor propuesto de 200 (Figura 4)
Figura 4
Teniendo la estructura y los ajustes es posible introducir los indicadores visuales; el tanque y sus indicadores de nivel. Paso 2: Crear la interface de usuario En el panel frontal, en los indicadores numéricos está el ícono Tank como se muestra en la figura 5.
Figura 5
Para el primer indicador, basta con un tanque y tres leds que indicarán si el nivel es alto, medio o bajo, en las propiedades del tanque se cambia la escala desde 0 a 100 para que sea igual a la constante previamente establecida para el ciclo while (Figura 6). En el diagrama de bloques, el tanque se conecta a la iteración para que su nivel cambie de forma proporcional (Figura 7), para el caso de los leds se harán comparaciones como en el ejemplo del indicador de temperatura con tres diferentes rangos.
Figura 6
Figura 7
Los rangos a considerar serán: 0 a 20 nivel bajo, de 20 a 80 medio y de 80 a 100 nivel alto, en esta primer versión las comparaciones se harán con comparadores “mayor que” y “menor que” con un operador “and”. La finalidad de esta primera versión es ver la dinámica de la estructura y el comportamiento del programa en general. La comparación quedará como en la figura 8 siguiendo la metodología vista en el ejemplo anterior.
Figura 8
En esta versión solo hay un tanque y una comparación, además el tiempo del timer es preestablecido. Cabe destacar que todos los elementos del programa deben estar dentro de la estructura while. Paso 3: Ejecutar el programa En el panel frontal al ejecutar el programa se puede ver un aumento automático de nivel hasta llegar al máximo nivel, al hacerlo el programa se reiniciará (figura 9)
Figura 9
Se pueden hacer modificaciones en el programa para tener dos tanques y utilizar las iteraciones con un comparador para invertir el flujo.
Modificaciones Para Llenado Y Vaciado De Dos Tanques En esta segunda versión se empleará el comparador “Comparison” para evitar que el programa sea confuso, además se utilizarán algunas comparaciones para los tanques. Como primer paso para la mejora se coloca otro tanque y tres leds indicadores, esto se puede hacer fácilmente seleccionado el tanque y sus indicadores, presionar Ctrl+C y después Ctrl+V, al hacerlo se puede arrastrar la copia y acomodarlo en el espacio de trabajo como muestra la figura 10.
Figura 10
Teniendo ambos tanques, en el diagrama de bloques habrá que conectar la copia del tanque a la iteración de tal manera que mientras un tanque baja de nivel el otro aumente. La operación para el segundo tanque se hará con una función “Substract”, esta resta comenzará con la misma constante 100 (en la terminal x) y restará una cantidad dependiendo la iteración (Figura 11), es decir, si la iteración es 1, la salida es 100-1, si la iteración es 2, la salida es 100-2 y así consecutivamente hasta llegar a un resultado igual a cero.
Figura 11
En total el programa tendrá seis comparadores, y se hará un cambio poniendo un botón stop en el “loop condition”, de tal forma que al terminar la condición de llenado el programa siga indefinidamente permitiendo ver el último estado de ambos tanque hasta que se presione el botón Stop. El programa debe lucir como la figura 12.
Figura 12
Como se había planteado, en la figura se puede ver el botón Stop, los 6 comparadores y los dos tanques. Además en lugar de valor constante, el timer está gobernado por un control para cambiar el tiempo durante la ejecución del programa. Para cada comparación se ponen los rangos anteriormente definido como se había analizado anteriormente; doble click en el ícono del comparador, habilitando la opción “In Range” (Figura 13). Algo importante es notar como la salida de la Resta debe ser la entrada de tanto del Tank 2 como de los comparadores correspondientes al mismo tanque.
Figura 13
En la ejecución del programa se puede ver el comportamiento de los tanques, en la figura 14 se muestra el programa cuando comienza, cuando ambos tanques están a la mitad y cuando están completamente invertidos.
A B
C
Figura 14
Como se ve en las imágenes anteriores, el tiempo ahora se puede modificar y con ello cambiar la velocidad, también está el botón stop para detener o reiniciar el programa. Del programa podemos ver que la estructura While es útil para hacer más dinámico un programa y dar ciertas condiciones, ciertamente es una estructura básica que se podría emplear en diversas situaciones para control de procesos o aplicaciones en sistemas eléctricos.
SECUANCIA DE LEDS El objetivo del ejemplo a continuación es trabajar con secuencias usando estructuras como “While”, “Flat Sequence” y “Stacked Sequence”, de tal forma que se pueda controlar el sentido de la secuencia y la velocidad. Además se emplearan variables locales para facilitar la conexión de las terminales en el programa. Como primer ejemplo se realizará una secuencia con una estructura While y se controlará el sentido con una estructura Case. Para una secuencia básica, basada en comparaciones y el uso de las iteraciones del while es necesario usar comparadores “Equal to?”. En lo diferentes ejemplos se utilizarán cuatro leds que se podrán visualizar en el panel frontal, el control del sentido de la secuencia se controlará con un botón. Paso 1: Crear estructura While y estructura Case, y ajustar parámetros de control. Como primer paso en el diagrama de bloques se crea una estructura While, dentro se coloca un comparador “Equal to?” y la iteración del While se conecta a la terminal “y” del comparador (Figura 1). La salida se conecta al botón de condición de la estructura While
Figura 1
En la terminal “x” al hacer click derecho, en el menú emergente dentro de la opción “Create” se puede crear una constante (Constant), en la cual se asignará un valor de cuatro equivalente a los cuatro leds que se utilizarán (Figura 2). Como en ejemplos anteriores del While es importante poner un timer “Wait” con un control numérico. Una vez que se tiene el límite de iteraciones bien definido es hora de crear el control, para esto basta con una estructura Case con los valores predeterminados True y False con los que se cambiará el sentido. Teniendo la estructura el programa ahora lucirá como en la figura 2.
Figura 2
Con esto preparado, en el panel frontal es posible agregar los cuatro leds y un botón, los leds se distribuyen de tal forma que la secuencia se pueda controlar en sentido izquierdo o derecho, el panel frontal debe quedar como la figura 3.
Figura 3
El botón utilizado es un “Slide Switch” de la categoría Buttons en la paleta de herramientas. Paso 2: Realizar secuencia de Leds con las comparaciones necesarias En el diagrama de bloques se necesitan hacer algunas comparaciones entre la iteración y alguna constante equivalente al led que se quiere encender, esto es lo mismo a comparar la iteración i=1 con una constante 1, de tal forma que esta comparación sea verdadera en esa primera iteración, cuando i=2 entonces la comparación es falsa. Con base a esto se pueden
hacer otras tres comparaciones con las constantes 2,3 y 4 para cada led, además el límite previamente establecido es el número cuatro. Cuando la iteración llegue a cuatro el programa se reiniciará y será algo dinámico. Las comparaciones se hacen con “Equal to?” y las terminales “y” se conectan a la iteración como se muestra en la figura 4, además estas comparaciones se tendrán que hacer dentro de la estructura Case. En este paso, dentro de la condición True se hará que los leds enciendan en orden 1,2, 3 y 4, que es lo mismo a izquierda a derecha.
Figura 4
Aún no se han conectado la entrada de la estructura Case ni los leds, antes de hacerlo se insertan las constantes a cada comparador, para que sea fácil de entender se opta por iniciar desde arriba hacia abajo, una vez que se conectan las constantes, las salidas se conectan a las entradas de los leds en el orden adecuado como se ve en la figura 5.
Figura 5
Como se puede ver en la imagen, la entrada y los leds están conectados, estos elementos son los que se pueden visualizar en el panel frontal, como se vio en el ejemplo de la calculadora, ahora hay que ir a los nodos de conexión con las salidas y acceder al menú emergente haciendo click con el botón derecho sobre el nodo (Figura 6).
Figura 6
En cada nodo se habilita la opción “Use default If Unwired”, los nodos cambiarán de color como se ve en la figura 7.
Figura 7 En el caso con la condición False se repite el mismo procedimiento, pero ahora se considera que el orden de los leds se invierte, para lograrlo lo más fácil es cambiar el orden de las constantes de arriba hacia abajo a: 4,3,2 y 1, las conexiones quedarán igual, por lo que solo dependerá del orden de las constantes. Las condiciones del caso False quedarán como la figura 8. Se recomienda hacer las conexiones de este caso comenzando desde los nodos correspondientes a las salidas que se quedan marcados debido al caso anterior. Los dos casos se pueden ver mejor en la figura 9.
Figura 8
Figura 9
Paso 3: Ejecución del programa Al simular el programa hay que considerar lo siguiente: el botón Slide se mueve a la izquierda o derecha, cuando se desliza a la izquierda el valor que da es False, y a la derecha es True, por lo que cuando el botón este a la izquierda la secuencia que se ejecutará es la secuencia de leds del caso False que es de derecha a izquierda. En el caso de deslizar el botón a la derecha, la secuencia del caso True ejecutará la secuencia de izquierda a derecha. En la figura 10 se puede ver la secuencia con el botón en la posición izquierda
1
2
3
4
Figura 10 En la figura 11 la secuencia que se muestra es con el botón en la posición derecha, se puede ver que la secuencia lleva diferente sentido.
1
2
3
4 Figura 11
Esta secuencia presenta algunos problemas como las forma en la que se conecta con la estructura Case y el hecho de que demasiadas comparaciones dentro de la estructura podrían hacer difícil de editar el programa en caso de agregar más elementos. Uso De Variables Locales Las variables locales permiten que se utilicen varias veces la misma variable como es el caso de algún control numérico pero evitando tener que hacer una conexión tan compleja que podría confundir con tantos cables en el programa. Las variables locales se encuentran en la categoría “Structures” como se muestra en la figura 12. Las variables locales se pueden habilitar para lectura o escritura, en este ejemplo el programa utilizará las dos formas.
Figura 12
La variable local puede cambiar si es para leer el valor de otra variable o escritura para funcionar como salida, esto se puede ver mejor en el ejemplo que se presentará a continuación basándose en la secuencia de leds con la estructura While. Al hacer click derecho en la variable local podemos ver el menú que contiene ciertos parámetros que se pueden cambiar, en este caso lo importante es cambiar “Change to Read” o “Change to Write” (Figura 13)
Figura 13
En este caso la variable debe estar en Write, esto se puede saber si tiene entrada o salida, cuando la variable está en modo Read tendrá una salida pues es para lectura, si la variable
tiene una entrada entonces se trata de modo Write, lo que significa que la variable podrá modificar a la variable original.
Figura 14
Como se puede ver en la figura anterior, a la derecha una variable local Write y a la izquierda una en modo Read. Para la secuencia de leds ahora se eliminarán las conexiones entre los comparadores y las salidas en ambos casos (True y False), también se deben eliminar los nodos en caso de que queden en la estructura. Lo que sigue es insertar un total de cuatro variables locales en modo Write como se ve en la siguiente figura.
Figura 15
Teniendo las cuatro variables se puede asignar la variable a la que se está afectando, haciendo click en el símbolo de forma de casa en la variable se desplegará un menú indicando cuales son los elementos con los que podemos interactuar. En este caso se seleccionarán los leds 1, 2, 3 y 3 (Figura 16).
Figura 16
Es importante no copiar y pegar las variables después de que se les ha asignado un valor para evitar copiar las variables originales. Si se quiere copiar y pegar se recomienda cuando la variable aún no tiene variable asignada, esto se puede ver cuando tiene un signo de interrogación. Ahora se conecta la salida del comparador con cada variable local (Figura 17), lo que se hace con esto es hacer que los cambios que se hagan en la variable local, en este caso True o False, afectaran a la variable original que en este caso son los leds, lo que permite ver que no hace falta usar cables que pasen a través de la estructura.
Figura 17
Al ejecutar el programa se podrá ver que no hay cambios en la funcionalidad, pero se evita usar demasiados cables y conexiones. Para usar la variable local en modo Read se puede hacer un arreglo con la iteración conectandole un Numeric Indicator como se muestra en la figura 18.
Figura 18
Lo siguiente es quitar las conexiones de la iteración en ambas condiciones de la estructura Case y dejar únicamente el Numeric Control y la comparación con la constante de valor cuatro a la iteración. Una vez que se quitan todas las conexiones de la iteración con las comparaciones usadas para los leds, se inserta una variable local en modo Read (con una salida) como muestra la figura 19.
Figura 19
A la variable local se le asignará el valor del Numeric Control, en el ejemplo se llamará “iteración”, la salida se conectará a todos los comparadores, esto se hace en ambas condiciones de la estructura Case (Figura 20).
Figura 20
Cuando el programa está en ejecución, ahora también se puede ver el valor de la iteración (Figura 21). El funcionamiento del programa es el mismo, pero ahora es más compacto y puede quedar como en la figura 22.
Figura 21
Figura 22
Con lo visto hasta ahora es posible crear secuencias usando un While dependiendo de las iteraciones, también podemos ver que en este caso es conveniente usar comparadores simples pues no hay rangos, solo se trata de valores binarios. Secuencia De Leds Con Flat Sequence Para esta nueva forma de hacer secuencia tendremos que insertar una estructura “Flat Sequence” desde la categoría “Structures” (Figura 23). Esta estructura es útil para secuencias con pocos ítems pues puede extenderse mucho, pero es sencillo seguir el flujo de datos pues se basa en fotogramas. En cada fotograma se puede realizar alguna operación y cada fotograma se ejecutará hasta que el anterior termine por completo, en este caso la operación del primer fotograma será encender el primer led, cuando el primero se encienda el programa pasará al segundo fotograma.
Figura 23
Por default la secuencia incluye solo un fotograma (Figura 24), para agregar más fotogramas hay que hacer click derecho en un borde de la estructura, en el menú emergente podremos ver las opciones para editar la estructura, en las opciones se encuentra “Add Frame After” y “Add Frame Before” (Figura 25).
Figura 24
Figura 25
Se agregarán tres fotogramas más para tender un total de cuatro (Figura 26), esto es para encender un led en cada fotograma. Sin embargo para tener un control del sentido que siguen los leds es necesario una estructura Case, como en el primer ejemplo de la secuencia basta con los dos estados True/False de la estructura, en cada caso se debe introducir una secuencia Flat (Figura 27)
Figura 26
Como se puede ver en la figura 26 al seleccionar algún fotograma de forma individual se habilitan nodos de color azul que permiten cambiar el tamaño de los fotogramas. En un principio parece confuso editar el tamaño pero hay que recordar que los nodos del fotograma a editar deben estar habilitados.
Figura 27
Teniendo la estructura Case con dos Flat Sequence en cada caso, procedemos a insertar los leds en el panel frontal, también algún botón para controlar el sentido de los leds (Figura 28).
Figura 28
En el diagrama de bloques los leds no necesitan estar dentro de las estrcuturas, pues como se ha visto es posible utilizar variables locales. El programa en el diagrama de bloques hasta ahora luce como la figura 29
Figura 29
Considerando que cada fotograma debe tener alguna operación que completar para pasar al siguiente fotograma, significa que si se pone algún valor constante para encender el led, este
permanecerá encendido y por lo tanto no habrá ningún cambio notable y simplemente encenderán todos los leds sin apagar el led anterior. Para lograr la secuencia como en el ejemplo anterior se harán algunos arreglos con las variables locales. En el primer fotograma se insertan cuatro variables locales para los cuatro leds y un operador booleano para negación “Not” (Figura 30). En este primer fotograma hay que pensar en la secuencia automática, en este fotograma se realiza una operación sin considerar condiciones. Debido a esto se utilizará una constante booleana False para apagar todos los leds, y con el operador “Not” hacer que en el primer fotograma el primer led permanezca encendido.
Figura 30
Las variables locales estarán en modo Write para afectar a los leds (Figura 31)
Figura 31
Considerando que la secuencia se repite, entonces al iniciar se deben apagar los leds anteriores, es decir, los leds 2, 3 y 4, y mantener encendido el primer led, la conexión queda entonces como la figura 32.
Figura 32
A partir de ahora la secuencia tiene la primera operación, en el segundo fotograma hay que apagar el primer led y encender el segundo por lo que se utilizan dos variables locales para estos dos leds y una constante False para apagar el primer led, también se utilizará un operador Not como en el primer fotograma para encender el primer led quedando el programa como la figura 33.
Figura 34
Para los fotogramas siguientes se sigue la misma lógica: en el tercer fotograma se apaga el segundo led y se enciende el tercero, en el último fotograma se enciende el cuarto y se apaga el tercero, esto hará que la secuencia sea cíclica. El programa ahora lucirá como en la figura 35.
Figura 32
Para el caso de la secuencia invertida, habrá que repetir la misma metodología en el otro Case, la diferencia será que ahora cambiará el orden de las variables. Para una rápida comprensión se presenta el programa para el otro Case en la figura 33.
Figura 33
Lo último que hay que considerar es el tiempo, si se ejecuta el programa así la respuesta será muy rápida, por lo que en cada uno de los fotogramas se agrega un Timer (Wait) con algún valor para ver los cambios, en este ejemplo se usaran un valor de 300 ms, el programa finalmente quedará como la figura 34.
Figura 34
Al ejecutar el programa veremos la secuencia como en el caso del uso de la estructura while.
Figura 35
Esta versión de la secuencia de leds resulta útil en algunos casos pero presenta desventajas por el espacio que ocupa y puede confundir con la lógica que tiene, sus aplicaciones podrían ser más útiles en otro tipo de procesos. Secuencia De Leds Con Stacked Sequence A diferencia de la Flat Sequence, ahora los fotogramas son similares a una estructura Case, en donde por medio de un menú en la parte superior se puede navegar a través de los diferentes fotogramas. Para insertar una Stacked Sequence se puede acceder desde la categoría structures (Figura 36)
Figura 36
En un principio la Stacked Sequence parece exactamente lo mismo que Flat Sequence, se agregan más fotogramas de la misma manera pero al hacerlo aparece un menú en la parte superior con los diferentes fotogramas como en la figura 37.
Figura 37
Se han agregado un total de cuatro fotogramas que van desde cero a tres, como se ve en la figura 37 se puede navegar por cada uno de estos fotogramas. La lógica es la misma que en el caso de Flat Sequence, hasta terminar la operación del primer fotograma, entonces se ejecuta la operación del segundo fotograma, esto es consecutivo y la única condición es que termine la operación anterior. Por esta razón el programa no cambia, de nuevo se usaran cuatros leds, un botón y el Stacked estará dentro de una estructura Case como se muestra en la figura 38.
Figura 38
La programación quedará exactamente igual que con Flat Sequence, de nuevo se necesitan dos Stacked Sequence para cada Case (True y False). El programa quedará entonces como en la figura 39.
Figura 39 Se puede ver que la diferencia es como se navega por los fotogramas.
PROMEDIO El objetivo de este ejemplo es utilizar la estructura “For” y los arreglos “Array”, además comenzar a utilizar la estructura “Formula Node”. En el promedio se puede hacer de forma sencilla sumando dos números y a ese resultado sumándole otro valor hasta sumar todos los elementos, esto puede ser muy impráctico por lo que es un buen ejemplo de cómo hacer un programa con múltiples entradas que hace operaciones utilizando estos elementos.
Para el primer programa de promedio se hace uso de un ciclo For y un arreglo que permite ingresar valores en un arreglo similar a una matriz. El promedio se realizará con cinco elementos. Paso 1: Creación de ciclo For y ajustes básicos. La estructura “For Loop” es parte de las estructuras, al igual que un While realiza una operación hasta que se cumpla una condición, en este caso hasta que la iteración sea igual a un valor N. La estructura For luce como en la figura 1.
Figura 1
Para comenzar, en el panel frontal se inserta un Numeric Control con el que se podrá cambiar el valor de N, de esta manera se controla el número de iteraciones del programa, para el cálculo de promedio este valor controlará el número de elementos a considerar. Otra cosa que hay que agregar en el panel frontal es un arreglo “Array” que se encuentra en las herramientas “Modern” en la subcategoría “Array, Matrix & Cluster” (Figura 2).
Figura 2 El array es un elemento que puede contener varios Controles Numéricos y puede hacerlo de tal forma que en el diagrama de bloques solo aparece el símbolo del Array pero en el panel frontal se le pueden agregar una gran cantidad de datos. El array por default no tiene ningún elemento, se ve como en la figura 3. Una vez que se tiene el Array, se puede agregar dentro un Control Numérico desde la paleta de herramientas (Figura 4).
Figura 3
El Array con un elemento lucirá como la figura 5
Figura 4 Además, al posicionarnos en el arreglo aparecerán nodos para cambiar la dimensión como se ve en la figura 5. Con estos nodos se puede arrastrar un nodo inferior para agregar más filas o arrastrar un nodo del lado derecho para agregar filas.
Figura 5
En este caso se trabajará con más filas, para eso se arrastra el nodo inferior hacia debajo de forma que comiencen a aparecer más filas con más entradas (Figura 6)
Figura 6
Cuando se tengan los cinco elementos quedará como en la siguiente figura.
Figura 7
El panel frontal entonces debe contener el arreglo, un control numérico y un indicador numérico, deberá lucir como en la figura 8.
Figura 8
Una vez hecho esto se tienen los elementos necesarios para realizar la estructura del programa.
Paso 2: Conexión de los elementos y lógica del programa Lo que se necesita ahora es realzar la conexión entre el control numérico (en el ejemplo “elementos”) y la condición N de la estructura “For Loop”. Antes de comenzar a conectar hay que pensar en la lógica del programa. Cuando hablamos de un Array o arreglo entonces los valores que se leerán en el ciclo For son de forma ordenada correspondiente a cada iteración, es decir, una vez que se conecta el Array a la estructura, se leerán datos de forma ordenada: primero el elemento de la parte superior, luego el segundo y así hasta llegar a la quinta fila del Array. Sin embargo un problema aquí es que si se quiere hacer una suma con los valores del arreglo, significa que se necesita otro elemento en una de las terminales de la función “Add”, se necesita un registro o memoria para guardar el valor del primer elemento del arreglo y sumarlo al segundo elemento de manera consecutiva hasta que termine el ciclo. Los mismo pasa para el resultado de la suma, si se suman los dos primeros elementos, ese resultado debe guardarse para que se le sume un tercer elemento. Para hacer esto se emplea “Shit Registers” o registros de cambio, que guardan el último valor de entrada o salida. Para agregar valores de registro en el “For Loop” hay que hacer click derecho en el borde de la estructura y seleccionar del menú emergente la opción “Add Shift Register” (Figura 9).
Figura 9
Cuando se tienen los registros la estructura tendrá dos iconos en los costados con una flecha hacia arriba y otra hacia abajo. Los registros se ven como en la figura 10.
Figura 10
Con los registros ahora se pueden almacenar valores de entrada y salida. El siguiente paso es agregar la función suma “Add” y división “Divide”, la suma se hace dentro del For pues es una suma de los elementos que dependen de la iteración, la división queda fuera de la estructura pues el resultado final se divide entre el número total de elementos. El programa ahora debe tener los elementos que se ven en la figura 11.
Figura 11
Lo siguiente es considerar que el Shift Register necesita una entrada y una salida, el guardar la variable de entrada o salida lo hace de forma automática, pero se puede inicializar con algún valor, para el caso de la entrada se propone una constante de valor cero, de esta forma
al leer el primer valor de entrada le sumará un valor cero, cambiará el registro de cero a ese primer valor de entrada, este proceso lo hará hasta terminar el ciclo. La conexión de la terminal “y” de la función “Add” debe ser al Array, la terminal “x” estrpa conectada al Shift Register. La salida de la suma se conecta al Shift Register de salida para poder guardar el ultimo resultado de la suma. El programa hasta ahora deberá lucir como en la figura 12.
Figura 12
La división divide la terminal “y” entre la terminal “x” por lo que en la terminal “x” se conectará la misma entrada que la condición N. De esta forma, la suma se dividirá entre el número de elementos. Finalmente la salida de la división se conecta en el indicador (Promedio) quedando como en la figura 13.
Figura 13
Paso 3: Ejecutar el programa El programa será en un principio iniciará sin ningún valor, el usuario puede poner los cinco valores en el Array y especificar cuantos se consideran para el promedio. Considerando los cinco valores el programa luce como en la figura 14. En donde el Control Numérico “Elementos” tiene un número cinco y el usuario ha ingresado esos cinco valores en el Array
Figura 14
En ese ejemplo se consideran todos los valores y el resultado es 10, es decir, 50/5=10 Si se cambia el valor de la entrada “Elementos” a el número cuatro, el programa solo sacará el promedio de los primeros 4 elementos, en ese caso: 6, 2, 1 y 11 como se ve en la figura 15.
Figura 15
Como se puede ver, el resultado ahora es 5 pues 20/4=5 Esto permite ver que el ciclo for funciona como se había previsto anteriormente,
Sin embargo el ciclo For para este tipo de aplicaciones puede ser impráctico por las consideraciones que se deben tomar por las entradas y salidas, registros y los elementos usar. Promedio Con Formula Node Fórmula Node es una estructura que permite trabajar con un lenguaje de programación basado en C que resulta muy útil cuando se trabaja con muchos datos y ecuaciones complejas, muchos de los ejemplos vistos anteriormente pueden sintetizarse en un pequeño código y los elementos del panel frontal. El usuario debe tener un conocimiento básico de lenguaje C como tipos de datos, estructuras y sintaxis. Para acceder a la estructura se hace desde la categoría “Structures” en el diagrama de bloques, la estructura luce en un principio como la figura 16.
Figura 17
Básicamente la estructura es un simple recuadro en donde al hacer click en el centro se puede escribir el código basado en la sintaxis de lenguaje C. Para el promedio se necesita una entrada y una salida en la estructura. En el panel frontal basta con tener un indicador numérico y un array como en el caso anterior. Para agregar una entrada y una salida a la estructura se hace click derecho y en el menú emergente se buscan las opciones “Add Input” y “Add Output” (Figura 18)
Figura 18
Una vez que se haya agregado una entrada y una salida se pueden ver pequeños cuadros como en la figura 19.
Figura 19
En cada recuadro al hacer doble click se puede poner un nombre, en este caso se pondrá X en la entrada y Y en la salida. Asignando los nombres de la entrada y salida se pueden conectar los elementos del panel frontal: Control Numérico e Indicador Numérico, el programa luce como la figura 20.
Figura 20
Los siguiente es escribir el programa, para esto se consideran las variables necesarias para declararlas en el programa, la primera variable es la salida “y” pues su valor final depende de ciertas operaciones. Como se va a utilizar un ciclo for, se necesita una variable para guardar el entero que incrementara después de cada ciclo. La declaración de variables se hace con base a estándares de programación de Labview, esto es de la forma como se ve en la figura 20.
Figura 20
En donde int32 se refiere a los enteros y float a valores con decimales. Como se puede ver, después de la declaración de cada variable se pone “;”. Lo siguiente es escribir el ciclo for, en donde en orden se pone: valor inicial de iteración, condición y aumento, esto se delimita con paréntesis como se ve en la figura 21
Figura 21
Para delimitar lo que se ejecuta dentro del ciclo for se utilizan llaves, lo que se escriba dentro de las llaves será lo que formará parte del ciclo. El ciclo for permite tener iteraciones las cuales son necesarias para acceder a los datos del Array, como se mencionó anteriormente, el array es como una matriz, si la variable que se le asigno es “x” entonces la matriz es “x[i]” y por lo tanto se leerá el valor de “x” correspondiente a la fila dependiendo de la iteración, en este caso se delimito para los 5 elementos: “x[0]”, “x[1]”, “x[2]”, ”x[3]” y “x[4]”. Lo siguiente entonces es guardar el valor de la suma para cada iteración, se puede utilizar la variable “y” como se ve en la figura 22.
Figura 22
Después de hacer el ciclo cuya condición es “mientras i sea menor a 5” el programa saltará a la siguiente línea, en ese punto y debe dividirse entre 5, finalmente el programa queda como sigue.
Figura 23
Como se puede ver, el programa es muy pequeño y la cantidad de elementos es mínima, al ejecutar el programa se puede ver que la funcionalidad es la misma.
Figura 24
OBTENCIÓN DE RAICES (ECUACIÓN CUADRÁTICA) El objetivo de este ejemplo es usar la estructura Formula Node para crear un programa que pueda calcular las raíces de una ecuación de segundo orden. Para comenzar hay que pensar en la ecuación cuadrática que es: x=
−b ∓ √ b 2−4 ac 2a
Lo valores que el usuario puede ingresar son a,b y c de la fórmula: 2
ax + bx+ c=0 El programa puede tener raíces reales y complejas considerando el valor de:
√ b2−4 ac=0 √ b2−4 ac >0 √ b2−4 ac <0 Estas consideraciones se toman en cuenta para crear el programa. Paso 1: Crear interface de usuario Para crear el programa lo primero es insertar en el panel frontal los elementos que permiten al usuario ingresar datos, en este caso son controles numéricos a, b y c, también se introducen los indicadores para los resultados la raíz x1 y raíz x2. El panel frontal puede quedar como la figura 1
Figura 1
Una vez que se tiene el panel frontal con los elementos necesario, en el diagrama de bloques se puede crear la estructura y poner las respectivas entradas y salidas.
En el caso del led que dice si la raíz es compleja se necesita poner algún comparador para tener una salida booleana, en este ejemplo se puede usar un “Greater than zero?” pues si la entrada es mayor que cero entonces habrá una salida True, de lo contrario será False. Con esto se puede controlar el led con algún valor por ejemplo uno.
El diagrama de bloques luce como la figura 2.
Figura 2
Paso 2: Escribir el programa Para escribir el programa primero se consideran las variables, las principales son “x1”, “x2” y “c” para controlar el led. Pero también se pueden considerar otras variables para facilitar el programa, en este caso un valor de la raíz de la ecuación:
√ b2−4 ac
, esta variable se
llamará “r”, por ahora el programa solo dará valores de las raíces reales, si tiene un número complejo entonces solo encenderá el led. El programa con las variables declaradas se ve como la figura 3.
Figura 3
Para el programa en general lo primero es calcular “r” con el código: “((b*b)-(4*a*c));” y con este valor usar un condicional “if” para ver si se trata de una raíz compleja o real, el código queda como en la figura 4.
Figura 4
El condicional if también se delimita con llaves, dentro del if en este caso se escribirá el código para raíces reales, es decir, cálculo normal de raíces. Para esto el cálculo sigue la fórmula con el código: “x1=(-b+sqrt(r))/2” y “x2=(-b-sqrt(r))/2”. En el caso de que “r=0” entonces las raíces son iguales y se puede escribir como: “x1=-b/ (2*a)” y “x2=x1” Para el tercer caso con “r<0” se pondrá el valor de las raíces como 0 pero el valor de “cx=1” para encender el led. El código al final se ve como en la figura 5.
Figura 5
Cuando se ejecute el programa se necesitarán parámetros establecidos para saber si el programa hace lo que se pide, para eso se tienen tres conjuntos de valores para a,b y c para ver la respuesta a cada caso. Para r>0: a=1, b=6 y c=5, cuyas raíces reales son: x1=-1 y x2=-5 Para r<0: a=2, b=4 y c=3, cuyas raíces son complejas x1=-1+.7071i y x2=-1-.7071i Para r=0: a=2, b=4 y c=2, cuyas raíces son: x1=x2=-1 En la figura 6 se puede ver la respuesta con los diferentes casos A) respuesta a r>0, b) respuesta a r<0 C) respuesta a r=0.
A
B
C Figura 6
Para hacer la modificación en el programa que permita ver los valores de las raíces complejas se puede introducir en el panel frontal un par de indicadores numéricos para las raíces. En el diagrama de bloques ahora se pondrá un código para calcular la raíz compleja, por lo que se agregarán dos variables en la declaración en la parte superior (Figura 7).
Figura 7
En el panel frontal los indicadores se llaman “+i” y “-1”, estos se conectan a dos salidas de la estructura Formula Node quedando como en la figura 8.
Figura 8
Para calcular la raíz compleja se considera que: x 1=
−b √ b 2−4 ac + 2a 2a
x 2=
−b √ b2−4 ac − 2a 2a
Lo que significa que las partes reales y complejas son igual pero con diferente signo, en el caso de la parte compleja el valor de “r” es un valor negativo pero debido a que:
√−x= √ x∗√−1 donde √ −1=i La operación se hace normalmente con: sqrt(-r)/2 donde el signo negativo se pone para que r sea un número positivo. En el programa las variables de las raíces complejas se llaman “cr1” y “cr2” siendo negativo y positivo respectivamente. El código de las raíces complejas se ve en la figura 9.
Figura 9
Finalmente el programa se ve como en la figura 10
Figura 10
Al ejecutar el programa se puede ver que se obtienen los valores esperados: x1= -1+.7071i x2= -1-.7071i
Figura 11
En conclusión Formula Node es una herramienta muy útil y práctica cuando se trata de muchos datos y ecuaciones complejas que sería complicado meter en el programa con otras estructuras y métodos.
