1

TABLA DE CONTENIDOS

1 ESTRUCTURA CASE _________________________________________________ 4

1.1 Partes de Estructura CASE _______________________________________________ 5

1.1.1 Nombre del caso __________________________________________________________ 5
1.1.2 Selector del caso __________________________________________________________ 5
1.1.3 Espacio para código _______________________________________________________ 7

1.2 Creación de casos para la Estructura Case __________________________________ 7

1.3 Caso Default (Defecto)__________________________________________________ 8

1.4 Eliminación y Duplicación de Casos _______________________________________ 8

1.4.1 Eliminación de Casos_______________________________________________________ 8
1.4.2 Duplicación de Casos ______________________________________________________ 9

2 ESTRUCTURA WHILE _______________________________________________ 11

2.1 Partes de una Estructura While _________________________________________ 12

2.1.1 Código _________________________________________________________________ 12
2.1.2 Terminal de Iteración _____________________________________________________ 12
2.1.3 Terminal de Condición ____________________________________________________ 12
2.1.3.1 Stop if true _________________________________________________________ 13
2.1.3.2 Continue if true _____________________________________________________ 13

2.2 Función Wait (ms) ____________________________________________________ 14

2.3 Bucles Infinitos _______________________________________________________ 14

2.4 Túneles _____________________________________________________________ 15

2.5 Realimentación de estructura While _____________________________________ 16

3 ESTRUCTURA FOR _________________________________________________ 18

3.1 Partes de una estructura FOR ___________________________________________ 19

3.1.1 Terminal N ______________________________________________________________ 19
3.1.2 Espacio para código ______________________________________________________ 19
3.1.3 Terminal de iteración _____________________________________________________ 19

3.2 Temporización en la estructura FOR______________________________________ 20

3.3 Terminal de Condición para el bucle FOR _________________________________ 20

4 REGISTROS DE DESPLAZAMIENTO ____________________________________ 22

4.1 Inicialización de Registros de Desplazamiento _____________________________ 23

4.1.1 No Inicializados __________________________________________________________ 23
4.1.2 Inicializados _____________________________________________________________ 23

1
5 TUNELES en bucles labview _________________________________________ 25

5.1 Last Value ___________________________________________________________ 25

5.2 Indexing ____________________________________________________________ 26

5.3 Concatenating _______________________________________________________ 26

5.4 Condicional __________________________________________________________ 26

6 BIBLIOGRAFIA ____________________________________________________ 28

2
Tema 02

ESTRUCTURAS DE EJECUCIÓN

LabVIEW cuenta con estructuras de programación que le permiten al desarrollador crear

secuencias de ejecución para realizar programas cada vez más completos.

Iniciaremos la presente sesión aprendiendo las estructuras de ejecución más utilizadas dentro
de los programas hechos en LabVIEW. Adicional, se explicará el concepto y uso de los registros
de desplazamiento en las estructuras de ejecución que lo permitan. Hacer uso de las estructuras
de ejecución es de suma importancia, porque usted podrá:

▶ Crear programas con una ejecución programada de tareas y operaciones.

CAPACIDAD
Realiza un programa a partir del uso de estructuras de ejecución y bucles que le permita
programar tareas u operaciones siguiendo una secuencia de ejecución definida.

TEMÁTICA
1. Estructura Case.

2. Estructura While.

3. Estructura For.

4. Registros de desplazamiento.

5. Tuneles en bucles LabVIEW

3
1 ESTRUCTURA CASE

Es una estructura que dependiendo del valor que tome una condición, integrada en la estructura
CASE, puede realizar diferentes tareas. La estructura CASE es utilizada donde el programa o el
usuario tiene que tomar una decisión. La situación más simple de estas decisiones será la de
hacer algo o no hacerlo y la decisión será tomada con un VERDADERO (TRUE) o FALSO (FALSE)
proveniente de alguna variable booleana.

Dentro de LabVIEW se puede encontrar la estructura CASE de la siguiente manera:

1. Se abre el Block Diagram.

2. Se hace clic derecho sobre cualquier parte del espacio de trabajo.
3. Elija Programming > Structures > Case Structure.

4
 4. Se ingresa la nueva estructura en la zona que se desee.

1.1 Partes de Estructura CASE

La estructura CASE consta de 3 partes básicas:

1.1.1 Nombre del caso

En esta parte aparece el valor que debe tomar la condición para ejecutar el código que contiene
esa parte de la estructura CASE.

1.1.2 Selector del caso

Es donde se conecta la variable que será evaluada en la condición respecto al nombre del caso.

Este selector de caso, por defecto, toma un color verde indicando que está preparado para
recibir una variable de tipo booleana, sin embargo, la estructura case acepta cambios en el tipo
de dato para trabajar tanto con variable de tipo numérico como con variables de tipo string.

5
La estructura case puede aceptar cualquiera de los siguientes tipos de datos:

1. Booleanos (por defecto).

2. Enteros o Integers.
3. Strings.
4. Enumerated type values (enteros).

No acepta datos flotantes o valores doubles directamente. LabVIEW genera un punto de

coerción que condiciona esta variable convirtiéndola a alguno de los tipos de datos
mencionados. Usualmente cuando se trabaja con valores flotantes o doubles, el selector del
caso (Case Selector) lo convertirá a entero.

Automáticamente LabVIEW utiliza recursos y crea un buffer de datos para poder hacer el
tratamiento de esta información. Convierte y redondea el número (double) tomando como
referencia el valor 0.5. Si la parte decimal del número es mayor o igual que 0.5 se redondea hacia
el mayor entero más próximo, y si la parte decimal del número es menor que 0.5 se redondea
hacia el menor entero más próximo.

Lo recomendable para prevenir estos casos es realizar una conversión previa del tipo de dato de
la variable que ingresará al selector de caso (Case Selector), y así evitar el consumo extra de
recursos y la creación de buffer de datos.

6
1.1.3 Espacio para código
Es la parte que se utiliza para agregar el código que se requiera correspondiente a cada uno de
los casos.

1.2 Creación de casos para la Estructura Case

Para la creación de un nuevo caso dentro de la estructura Case se siguen los siguientes pasos:

1. Hacer clic derecho sobre el nombre del caso.

2. Ubicar las opciones de “Add Case After” o “Add Case Before”. Estás opciones permiten,
agregar un caso después (After) del que se indica en el nombre del caso, o agregar un caso antes
(Before) del que se indica en el nombre del caso respectivamente. Hacer clic sobre alguna de
ellas, de acuerdo a lo que se requiera.

7
3. Escribir un nombre (valor que debe tomar la condición) para el nuevo caso creado.

4. Programar dentro de espacio para el código las operaciones y funciones requeridas.

1.3 Caso Default (Defecto)

El código que se ingresa en este caso se ejecuta cuando la opción del selector del caso (Selector
Case) no se encuentra como un caso individual, quiere decir que el caso default se ejecuta si no
hay un caso definido para el valor que toma la variable de evaluada en el selector de caso (Case
Selector).

Si el valor de la variable que se ingresa al selector de caso fuera un valor diferente a los casos
creados en la estructura Case, por ejemplo, el número 5, al no tener registrado un valor de 5 en
el nombre del caso, se ejecutará el código que se encuentra en el caso Default.

1.4 Eliminación y Duplicación de Casos

Dentro de las opciones para manejar los casos de la estructura Case se encuentran dos opciones
útiles que se detallan a continuación.

1.4.1 Eliminación de Casos

Para realizar la eliminación de los casos creados dentro de la estructura Case, se sigue el
siguiente procedimiento:

8
1. Hacer clic derecho sobre el nombre del caso.

2. Ubicar la opción “Delete This Case”, esta opción eliminará el caso actual que se encuentre
mostrado en la estructura Case junto con toda la codificación hecha en el espacio para el código
de este caso. Hacer clic en esta opción, y se eliminará el caso.

1.4.2 Duplicación de Casos

El duplicado de casos es una opción muy útil cuando se requiere crear códigos bastante similares
para cada caso dentro de una estructura Case. Esta opción permite repetir o duplicar un caso,
creándose uno nuevo manteniendo el nombre del caso y la codificación hecha dentro de dicho
caso, lo cual nos brinda la ventaja de cambiar solamente el nombre del caso y alguna parte del
código y tener otro caso nuevo ya programado en menor tiempo.

Para utilizar esta opción se sigue el siguiente procedimiento:

9
1. Hacer clic derecho sobre el nombre del caso.

2. Ubicar la opción “Duplicate Case”. Hacer clic en esta opción, y se duplicará el caso. Quedando
un nuevo caso listo para ser editado.

10
2 ESTRUCTURA WHILE

Es una estructura que se repite mientras no se cumpla una condición. Lo que se repite dentro
de la estructura es una tarea o un segmento de código. Esta estructura es un tipo de bucle, un
bucle es una estructura de programación que se repite varias veces.

El diagrama de flujo de la estructura o bucle while muestra la forma

en la que LabVIEW ejecuta dichas estructuras, evidenciando que
primero realiza la actividad o tarea y luego evalúa la condición. Si la
condición no se cumple se vuelve a ejecutar la tarea o actividad, si la
condición se cumple se finalizará la ejecución de la tarea o actividad.
El bucle se puede repetir cuantas veces sean necesarias hasta que se
cumpla la condición deseada que haga finalizar el bucle.

Otra particularidad de la estructura while en LabVIEW es que, de

acuerdo a su diagrama de flujo, se debe notar que al primero
realizarse la actividad o tarea y después evaluar la condición, la
actividad o tarea dentro de la estructura while se ejecutará al menos
una vez.

En LabVIEW la estructura while se ubica de la siguiente manera:

1. Se abre el Block Diagram.

2. Se hace clic derecho sobre cualquier parte del espacio de trabajo.
3. Elija Programming > Structures > While Loop.

4. Se ingresa la nueva estructura a la zona que se desee.

11
2.1 Partes de una Estructura While
Principalmente la estructura while consta de 3 partes:

2.1.1 Código
Es la parte que se utiliza para agregar el código que se desea repetir en cada iteración de la
estructura while.

ACTIVIDAD O TAREA

(PROGRAMA)

2.1.2 Terminal de Iteración

Es una variable de tipo entero, que se encarga de almacenar el número de veces que se ejecuta
la estructura o bucle while. Cuando la estructura while se ejecuta por primera vez, el terminal
de iteración (i) va a tener el valor de 0.

2.1.3 Terminal de Condición

Esta terminal tiene la función de evaluar la condición de la estructura while que nosotros
programemos, con la finalidad de encargarse de detener el bucle cuando esta condición alcance
un valor determinado.

La terminal de condición tiene 2 opciones:

12
2.1.3.1 Stop if true
Para de repetir el código del bucle while si se conecta un valor de verdadero a la terminal.
Mientras se tenga un valor de falso en el terminal el bucle se seguirá ejecutando y se detendrá
cuando el terminal encuentre un valor de verdadero (TRUE).

2.1.3.2 Continue If true

Se continúa repitiendo el código del bucle while mientras se mantenga conectado un valor de
verdadero al terminal. Se detendrá cuando encuentre un valor de falso (FALSE).

Para cambiar entre ambas opciones se hace clic derecho cobre el terminal de condición y se
ubican las opciones de “Stop if true” y “Continue if true”. Se cambia entre ambas opciones de
acuerdo a lo que se requiera en el programa.

13
2.2 Función Wait (ms)
La función wait dentro de una estructura o bucle while nos permite definir cada cuanto tiempo
se ejecutará la actividad o tarea que se haya programado dentro del bucle. En otras palabras,
cada cuanto se repite el bucle while.

El objetivo de utilizar la función wait dentro de un bucle es evitar el consumo excesivo de

recursos de la computadora. El no temporizar la ejecución del bucle y ejecutarla de esa manera
nos consumirá más del doble de recursos computacionales, y en programas grandes o complejos
se podría inducir a un error de ejecución o incluso a la detención total del sistema operativo de
la computadora en la que se ejecuta la aplicación. Es una buena práctica de programación utilizar
un temporizador para bucles en LabVIEW.

La función Wait se ubica de la siguiente manera:

1. Hacer clic derecho en cualquier parte del área de trabajo del Block Diagram.
2. Ubicar la ruta Functions > Programming > Timing > Wait (ms).

3. Ingresar la función dentro del bucle while y definir un tiempo de retardo. Este tiempo
está en milisegundos (ms).

2.3 Bucles Infinitos

Cuando se ejecuta un bucle while, el programa inicia la ejecución de lo que hay en el interior del
while, si la condición de paro está por fuera del while, el programa se quedará en un bucle
infinito y se deberá abortar la aplicación.

14
Tampoco se deben colocar valores constantes en el terminal de condición porque también
puede inducir a bucles infinitos y sobre carga de recursos de sistema.

2.4 Túneles
Se les conoce como túneles a los cables de conexión que llevan información que entra y sale del
bucle while. Los datos o información de entrada se cargan solo una vez al iniciarse el bucle while,
mientras que los datos o información de salida se cargan una vez finalizado el bucle while.
Mientras el bucle while se esté ejecutando no entran o salen más datos del mismo hasta
finalizar.

15
La tarea que realiza este bucle while es sumar el valor numérico de la iteración en el que se
encuentra al número que se ingresó a la entrada del control Numeric. Sin embargo, el resultado
no será acumulativo, ya que en cada iteración el valor del resultado de la suma de la iteración
anterior se pierde, por lo tanto, el resultado que se mostrará al finalizar el bucle while será
únicamente el resultado de la última operación, en este caso 11 (valor de i) y 10 que fue la
variable de ingreso al while.

2.5 Realimentación de estructura While

La realimentación del bucle while se realiza mediante un bloque de función que se encuentra
dentro de las funciones de programación en LabVIEW. Esta realimentación sirve para almacenar
algún valor de variable de una iteración previa y llevarla a la iteración actual.

Este bloque de función se encuentra de la siguiente manera:

1. Hacer clic derecho en cualquier parte del área de trabajo del Block Diagram.
2. Ubicar la ruta Functions > Programming > Structures > Feedback Node.

3. Ingresar la función dentro del bucle while y realizar la conexión de la variable que se
desea realimentar en la siguiente iteración.

El resultado de esta arquitectura de conexión será la sumar el valor de la variable de control de

entrada las veces que indique el valor constante que compara el número de iteraciones. El valor

16
de esta constante es 2 lo que significa que, al empezar la variable de iteraciones en 0, el bucle
se ejecutará unas 3 veces. Por lo tanto, se sumará 3 veces el valor de la variable de entrada a la
estrutura while.

17
3 ESTRUCTURA FOR

Es una estructura de ejecución que repite un número determinado de veces una tarea o
segmento de código.

El diagrama de flujo de la estructura o bucle for muestra la forma en la que LabVIEW ejecuta
dicha estructura, evidenciando que primero realiza una comparación de variables en una
condición y en base al resultado de esta condición decide si ejecuta las tarea o actividad
programada. En caso de no cumplirse la condición (FALSE), se ejecuta la tarea programada; y en
caso de cumplirse la condición (TRUE), se finaliza el bucle for.

En LabVIEW la estructura for se ubica de la siguiente manera:

1. Se abre el Block Diagram.

2. Se hace clic derecho sobre cualquier parte del espacio de trabajo.
3. Elija Programming > Structures > For Loop.

18
 4. Se ingresa la nueva estructura a la zona que se desee.

3.1 Partes de una estructura FOR

La estructura o bucle for consta de 3 partes:

3.1.1 Terminal N
Es una variable de tipo entero que almacena la cantidad de veces que se repetirá la estructura
o bucle for.

3.1.2 Espacio para código

Es la parte que se utiliza para agregar el código que se desea repetir en cada iteración de la
estructura for.

ACTIVIDAD O TAREA

(PROGRAMA)

3.1.3 Terminal de iteración

Es una variable de tipo entero, que se encarga de almacenar el número de veces que se va
ejecutando la estructura o bucle for. Cuando la estructura for se ejecuta por primera vez, el

19
terminal de iteración (i) va a tener el valor de 0. Por lo tanto, al finalizar el bucle for este valor
del terminal de iteración será N – 1.

3.2 Temporización en la estructura FOR

Para la temporización del bucle for también debemos usar la función Wait (ms) que se explicó
en la estructura while. Esto se debe a que todo bucle debe tener un temporizador de ejecución
ya que de lo contrario se consumirán excesivos recursos del procesador de la computadora.

Los detalles del uso de la función Wait (ms) se encuentran en el apartado 2.2 Función Wait (ms)
de esta guía.

3.3 Terminal de Condición para el bucle FOR

La herramienta terminal de condición también está disponible para un bucle for. Esta
herramienta está diseñada para finalizar el bucle for cuando una determinada condición se
cumpla, independiente de si el bucle for se llegó a ejecutar o no el número de veces que se
indicó en el terminal N. En otras palabras, el bucle for tendría 2 formas de finalizar: por el
número de veces indicado en el terminal N o por alguna condición direccionada al terminal de
condición.

El terminal de condición en un bucle for se habilita de la siguiente manera:

20
1. Hacer clic derecho sobre el borde del bucle for.

2. Ubicar la opción Conditional Terminal. Hacer clic sobre la opción.

3. Seleccionar entre los condicionales Stop if true o Continue if true. Estos tipos de
condicionales se explican en la sección 2.1.3 Terminal de Condición de esta guía.
Programar la condición deseada. Se notará que el terminal N aparece con un punto rojo
para indicarle al programador que la opción de Conditional Terminal está activada.

21
4 REGISTROS DE DESPLAZAMIENTO

Es una herramienta de LabVIEW, que te permite llevar información de bucles anteriores a bucles
subsecuentes. Permite mantener información de iteraciones anteriores de un ciclo, para luego
trabajar o tratar dicha información en la iteración actual o iteraciones posteriores del ciclo. Se
pueden utilizar en cualquier tipo de bucles.

Para agregar un registro de desplazamiento seguimos el siguiente procedimiento:

1. Hacer clic derecho sobre uno de los bordes del bucle.

2. Ubicar la opción Add Shift Register. Hacer clic en la opción y se añadirá

automáticamente.

Finalmente, cuando lo cableamos toma el color del tipo de dato que direcciones a sus
terminales.

22
4.1 Inicialización de Registros de Desplazamiento
4.1.1 No Inicializados
Son llamados así porque no tiene ningún valor de entrada al registro de desplazamiento.

La particularidad de estos registros no inicializados es que cuando se ejecuta el bucle por

primera vez, se inicializa automáticamente en 0. Lo que significa que el resultado de ejecutar el
bucle for de la imagen por primera vez, el valor que se mostraría en el indicador será de 2. Sin
embargo, si nosotros ejecutamos nuevamente el bucle el valor con el que el registro de
desplazamiento se inicializa será el último valor que tomó en la ejecución previa es decir el
número 2, por lo tanto, el resultado de la segunda ejecución del bucle for será de 4. Y así
sucesivamente, es decir, el registro no se reinicia y se va acumulando inclusive si el VI se detiene.

4.1.2 Inicializados
Tienen un valor de entrada al registro de desplazamiento.

Estos registros iniciados se comportan de una forma distinta a los no iniciados. Con los registros
iniciados, cada vez que se ejecuta el bucle, el registro se inicializa con el valor que se le haya
asignado de entrada. Esto significa que no importa cuántas veces ejecutemos el bucle que se

23
observa en la imagen, al iniciarse todas las veces con el valor de 0, el resultado siempre será de
2.

Otra particularidad de los registros desplazamiento iniciados es que en caso el bucle no se

ejecute ninguna vez o este programado para ejecutarse 0 veces, el registro de desplazamiento
funcionará como un túnel. En otras palabras, el valor inicializado a la entrada del bucle pasará a
ser una salida.

24
5 TUNELES EN BUCLES LABVIEW

Ampliando la sección 2.4 Tuneles, se presentan los modos de trabajo de los túneles en LabVIEW.

Para cambiar entre los modos de trabajo de los túneles se sigue el siguiente procedimiento:

1. Hacer clic derecho sobre el túnel de salida creado en el bucle.

2. Ubicar la opción Tunnel Mode, y seleccionar entre los 4 modos de trabajo visualizados:
Last Value, Indexing, Concatenating y Conditional.

5.1 Last Value

En este modo el túnel da como resultado el valor de que haya tomado la dicha operación en la
última iteración. Es decir, da como salida el último valor que tomó después de finalizar la
ejecución del bucle.

25
5.2 Indexing
En este modo el tune brinda como salida un arreglo en el que se almacena cada valor que tomo
dicho túnel en cada iteración del bucle. Tendrá tantos elementos como iteraciones haya tenido
el bucle.

5.3 Concatenating
Este modo te permite formar un arreglo con las mismas dimensiones del arreglo de entrada. Se
puede utilizar para concatenar o unir arreglos de 2D a arreglos de 1D. Su principal uso es en
bucles anidados.

5.4 Condicional
Este modo te permite dar como salida el valor que tome el túnel en cierta iteración, siempre y
cuando es esta iteración se cumpla una condición determinada. Cuando lo activas, aparece un

26
pequeño terminal condicional en la parte inferior del túnel, dicho túnel solo se ejecutará si la
condición es TRUE.

Una particularidad de este modo es que puede ser acoplada a cualquiera de los otros modos de
túnel vistos previamente.

El resultado mostrará solo los valores que cumplan la condición programada, es decir, solo
mostrará los valores mayores a 5.

27
6 BIBLIOGRAFIA

National Instruments (2009). Control Design User Manual. National Instruments Corporation.

Yunus A. Cengel (2007). Transferencia de calor y masa. Un enfoque práctico. McGraw-Hill

Interamericana.

Jeffrey, T., & Jim, K. (2006). LabVIEW for everyone: graphical programming made easy and fun.
Prentice Hall PTR.

Bitter, R., Mohiuddin, T., & Nawrocki, M. (2007). LabVIEW: Advanced programming techniques.
CRC press.

28