práctica 8 estructuras de programación en labview · pdf filecontrol donde se...

Instrumentación Ingeniería Mecatrónica

Práctica #8 Estructuras de programación en LabVIEW Ing. Mario Alberto Camarillo Ramos

1

Práctica 8

Estructuras de programación en LabVIEW

Objetivo de la práctica

Al terminar esta práctica, el discente será capaz de: Conocer las diferencias entre un ciclo FOR y un ciclo

While, conocer cómo los registros de corrimiento obtienen el

valor de iteraciones anteriores, conocer cómo se ejecuta la estructura CASE, conocer cómo se ejecuta la estructura SECUENCE, conocer cómo se utiliza la función MATHSCRIPT y, generar programas utilizando las diferentes estructuras

antes mencionadas.

Material: Computadora con LabVIEW Profesional versión 8.0 en

adelante (preferentemente 8.6) Introducción En esta práctica se crearán VIs sencillos para incorporar las estructuras de programación en LabVIEW. Dichas estructuras son FOR, WHILE, CASE, SECUENCE y MATSCRIPT. Marco teórico Las estructuras son representaciones gráficas de los casos que se presentan en lenguajes de programación de texto. Se utiliza una estructura en el diagrama a bloques para repetir segmentos de código ó para ejecutar código bajo alguna condición o en un orden específico.



2

Como los elementos anteriores (práctica #6), las estructuras cuentan con terminales que permiten la conexión entre ellas y otros elementos dentro del diagrama a bloques. Al tener información en estas terminales las estructuras se ejecutarán inmediatamente y generarán información de salida cuando termine su ejecución. Cada estructura cuenta con un borde (orilla) particular, y puede ser redimensionado para abarcar alguna parte del código que se desee ejecutar, claro, de acuerdo a la función de cada estructura. El código dentro de una estructura de programación se le conoce como subdiagrama. Las terminales que proveen información hacia dentro y fuera de la estructura se les conoce como túneles. Un túnel es una conexión en el borde (orilla) de la estructura. LabVIEW proporciona estructuras de programación (FunctionsStructures) para realizar diferentes procesos; entre dichas estructuras se encuentran:

FOR.- Ejecuta un subdiagrama un número determinado de ocasiones.

WHILE.- Ejecuta un subdiagrama hasta que una condición se cumpla.

CASE STRUCTURE.- Contiene múltiples subdiagramas, de los cuales solo uno se ejecuta dependiendo de la variable de entrada a la estructura.

SECUENCE STRUCTURE.- Contiene uno o más subdiagramas, los cuales se ejecutan de manera secuencial.

MATHSCRIPT.- Realiza operaciones matemáticas utilizando variables definidas por el usuario ó de la misma estructura (Mathscript es similar a Matlab, pero integrado en LabVIEW).



3

El ciclo FOR

Figura 1.- Estructura para un ciclo FOR

Un ciclo FOR ejecuta un subdiagrama un número predeterminado de ocasiones. El valor en la terminal de conteo (loop count) indica cuántas ocasiones se repetirá el subdiagrama. Es posible asignar un valor conectando un valor desde afuera de la estructura al ícono N. La terminal de iteraciones (i) proporciona el número de iteraciones realizadas. Las iteraciones siempre empezarán en cero, es decir, durante la primer iteración la terminal proporcionará un cero y llegará hasta N-1 iteraciones. Ambas terminales (de conteo e iteración) son palabras enteras con signo. Si se conectara una variable de punto decimal a la entrada de conteo, LabVIEW la redondea y la obliga a que se encuentre en el rango. Un dato importante es que si se empieza con un número negativo o cero en la terminal de conteo, el subdiagrama no se ejecutará. El ciclo While

Figura 2.- Estructura para un ciclo WHILE



4

El ciclo WHILE ejecuta un subdiagrama hasta que una condición es cumplida, es decir, mientras se cumpla la condición. Dicha condición se encuentra en la terminal Loop condition, el cual es un valor booleano (verdadero o falso). El comportamiento predeterminado para la terminal es Stop if True, donde el subdiagrama se ejecuta hasta que la terminal reciba un valor VERDADERO. Cuando una terminal de condición es configurada como Continue if True, el ciclo WHILE ejecuta el subdiagrama hasta que la terminal reciba un valor FALSO. Debido a que la estructura revisa el valor presente en la terminal después de ejecutar cada iteración, el ciclo WHILE se ejecuta por lo menos una vez, lo cual es igual que un DO-WHILE en los lenguajes de texto convencionales.

Figura 3.- Controles para la terminal condicionante

Cabe señalar que si la terminal condicionante no se conecta a un valor, el VI no operará. Es posible crear un subdiagrama para revisar si existe un error o no utilizando la terminal condicionante de una estructura WHILE. Cuando se conecta un cluster de error a dicha terminal, solamente los valores de VERDADERO o FALSO pasan a la terminal. La terminal de iteraciones proporciona el número de iteraciones completadas; siempre empieza en cero y regresa a cada inicio de la iteración el valor de cero. Si se desea pasar información desde la primer iteración a la siguiente, es necesario colocar registros de corrimiento.


Registros de corrimiento en estructuras (ciclos)

Figura 4.- Registros de corrimiento en estructuras FOR y WHILE

Se utilizan los registros de corrimiento dentro de ciclos FOR y WHILE para transferir valores de una iteración a la otra. El comportamiento de los registros de corrimiento es similar al de las variables STATIC en los lenguajes de programación convencionales. Un registro de corrimiento aparece como un par de terminales que se oponen unas con otras en los extremos verticales de la estructura (FOR o WHILE). La terminal de la derecha contiene un símbolo semejante a un triángulo (o flecha) que apunta hacia arriba y almacena información después de que se termina una iteración. LabVIEW transfiere la información que se encuentre en esta terminal a la siguiente iteración. Para crear un registro de corrimiento es necesario colocarse sobre el borde de la estructura y presionar el botón derecho del ratón y seleccionar Add Shift Register.

Figura 5.- Creando un registro de corrimiento


5



6

Un registro de corrimiento transfiere cualquier tipo de dato y automáticamente cambia el tipo de dato del primer objeto que se encuentre conectado al mismo. La clase de dato que se encuentre conectada a la terminal de cada uno de los registros de corrimiento debe ser del mismo tipo. Es posible crear múltiples registros de corrimiento en una estructura (ciclo), además de poder tener más de una terminal izquierda (entrada) para retener más de un solo valor. Después de que el ciclo se ejecuta, el último valor guardado en el registro de corrimiento permanece en la terminal de la derecha. Si esta terminal se conecta hacia fuera de la estructura, esa conexión transferirá el último dato de la iteración en curso. Si no se inicializa el registro, el ciclo utiliza el valor que se encontraba al final del mismo o se utiliza el valor predeterminado si nunca se ha ejecutado. Estructuras de Casos (CASE Structures)

Figura 6.- Estructura CASE boolena

Una estructura CASE tiene uno o más subdiagramas, o casos. Solamente un subdiagrama está visible y la estructura ejecuta solo un caso a la vez. Un dato de entrada determina cuál subdiagrama se ejecutará. Esta estructura es similar al SWITCH o IF-THEN, IF-ELSE IF, IF-ELSE, de los lenguajes de programación tradicionales. En la parte superior de la estructura se encuentra la etiqueta del selector de casos. Esta etiqueta contiene los valores para los cuales cambiará cada subdiagrama, aplicando así cada caso. Las flechas a los costados indican los casos subsecuentes o anteriores; la flecha hacia abajo indica qué casos están presentes en la estructura.



7

La estructura CASE puede tener diferentes tipos de entradas, siendo estas booleanas (verdadero o falso), enteras (dato numérico), cadenas de carateres (código ASCII) o del tipo enumerado. Es necesario colocar un caso para cuando no se encuentre información pertinente en la entrada (caso predeterminado o “default”). Si no se hiciera esto, es responsabilidad del creador del VI señalar cada entrada para todos los casos. Por ejemplo, si existe una entrada entera de control donde se buscan los casos 1, 2 y 3, se debe especificar un caso predeterminado para cuando la entrada sea 4 o cualquier otro número entero.

Figura 7.- Casos numéricos enteros

Figura 8.- Casos con cadenas de caracteres

Figura 9.- Casos enumerados

Se pueden crear múltiples túneles de entradas y salidas para una estructura CASE. Las entradas estarán disponibles para todos los casos, aunque los casos no necesiten utilizar todas. Si embargo, se debe definir cada salida para cada caso. Cuando



8

se cree una salida (túnel) en un caso, dicha salida estará presente para todos los casos. Si una salida no está conectada, todos los túneles aparecen como cuadros blancos. Es posible definir diferentes fuentes de información para el mismo túnel en cada caso, pero el tipo de dato debe ser compatible para cada uno de ellos. En ocasiones es práctico utilizar el botón derecho del ratón en el túnel en cuestión y seleccionar Use Default If Unwired para utilizar el valor predeterminado para todos los túneles sin conectar.

Figura 10.- Selección de valor predeterminado en un túnel

Estructuras de secuencia (Stacked Sequence Structure)

Figura 11.- Estructura de secuencia

Una estructura de secuencia contiene uno o más subdiagramas, o tramas, las cuales se ejecutan de manera secuencial (recordar que en LabVIEW se ejecuta el código en paralelo). La etiqueta de la trama en la parte superior es muy parecida a la estructura CASE. La etiqueta de tramas contiene un número en el centro y flechas hacia la derecha e izquierda, las cuales permiten revisar cuál subdiagrama se ejecutó o



9

realizará. A diferencia de la estructura CASE, no es posible introducir valores a la trama; cada vez que se elimina, agrega o reestructuran las tramas, LabVIEW ajusta automáticamente el número de ellas. Una estructura de secuencia comienza desde la trama 0, luego la 1, después la 2, y así sucesivamente hasta que la última trama se ejecute. La estructura de secuencia no termina su ejecución o proporciona información hasta que la última trama termina.

Cabe señalar que no existirá ejecución hasta que todas las entradas (túneles) de la primer trama cuenten con información. Si se desea pasar información de una trama a la otra, es necesario crear una terminal local para que la información procesada pueda acceder a la siguiente trama.

Figura 12.- Túneles locales para pasar información de trama a trama

En general, se utiliza una estructura de secuencia para controlar la ejecución de los subdiagramas donde la información debe ser procesada antes que otro evento. Un nodo o terminal que recibe información depende de otro nodo para completar su ejecución y así sucesivamente. Estructura MathScript La estructura MATHSCRIPT es una función útil para ejecutar operaciones matemáticas en el diagrama a bloques. No es necesario tener acceso a código externo o aplicaciones adicionales, además de no tener que utilizar funciones aritméticas para crear ecuaciones complejas. No solo es menos compleja la creación de ecuaciones, también es posible utilizar



10

funciones conocidas en otros programas relativos a matemáticas (polyfit por ejemplo). MATHSCRIPT es muy similar a Matlab, por lo que es posible crear código (script) e importarlo a LabVIEW.

Cabe señalar que MATHSCRIPT solamente acepta variables de doble precisión (64 bits) por lo que será necesario (si así lo amerita) convertir variables de otro tipo a las requeridas. Es posible declarar variables dentro de la estructura o fuera. El colocar entradas o salidas de la estructura MATHSCRIPT es opcional, pero, si alguna es colocada, debe estar conectada a algún parámetro de entrada o función de salida.

Figura 13.- Entradas y salidas en MATHSCRIPT

Para empezar a ejercitar los conocimientos adquiridos, se realizarán cuatro VIs, uno por cada estructura de programación. Desarrollo El primer VI a realizar se llamará Número de iteraciones, el cual contará las iteraciones que necesita LabVIEW para obtener un número que se le ha solicitado. Para lograr el objetivo de este VI se utilizarán funciones que generarán números aleatorios hasta que se obtenga el valor requerido.


1)


11

Abra un nuevo Panel Frontal.

2) Genere en el Panel Frontal la figura 14. No se preocupe por los valores en los controles e indicadores, estos son valores que se asignarán después. Recuerde asignar nombres a los dos indicadores y al control numérico.

Figura 14.- Panel frontal para “Número de iteraciones”

a) “Número para simulación” es un control

numérico y especifica el número al cual se desea llegar. El indicador numérico “Número actual” señala el número que se ha procesado. El indicador numérico “Número de iteraciones” proporciona las ocasiones en que el ciclo se ha ejecutado.

b) Para asegurarse que el usuario no introducirá un dato que no corresponda con el formato de incremento (entero), se forzará a LabVIEW a tomar un valor entero. Para esto será necesario colocarse sobre el control numérico “Número para simulación” y presionar el botón derecho del ratón y seleccionar properties.

c) Dentro de este menú, se escogerá el submenú Data Entry donde se especificarán los números máximos y mínimos que se esperan del usuario. Así como obligar a la entrada a ser entera. Modifique los valores y opciones como se muestra en la figura 15 (no presione el botón OK).



12

Figura 15.- Modificación de parámetros de entrada

d) Después de realizar la modificación, se

establecerá una referencia para el control numérico. Dentro del menú de propiedades, escoja Documentation y redacte la descripción del control numérico (figura 16). Presione el botón OK.

Figura 16.- Descripción del control numérico “Número para simulación”

e) Coloque el cursor sobre el indicador

numérico “Número actual”, presione el botón derecho del ratón y seleccione la opción Description and Tip. Redacte lo señalado en la figura 17.



13

Figura 17.- Descripción del indicador “Número actual”

f) Repita el inciso e) pero ahora sobre el

indicador “Número de iteraciones” y redacte la información de la figura 18.

Figura 18.- Descripción del indicador “Número de iteraciones”

3) Para asignar el valor de 50 como predeterminado, es necesario colocarse sobre el control numérico “Número para simulación” y asignar el valor 50; presionar el botón derecho del ratón y seleccionar Data operations Make Current Value Default.

Figura 19.- Asignando valor predeterminado al control numérico



14

4) Terminado lo correspondiente al Panel Frontal, genere el

diagrama a bloques de la figura 20.

Figura 20.- Diagrama a bloques del VI “Número de iteraciones”

a) Coloque la función Random Number (0-1) que se encuentra en FunctionsProgrammingNumeric. Esta función producirá un número aleatorio entre 0 y 1.

b) Utilice una función de multiplicación (FunctionsProgrammingNumeric) para multiplicar el número aleatorio por 1000 (recuerde cómo crear constantes de la práctica #6, paso 6).

c) Coloque la función Round To Nearest que se encuentra en FunctionsProgrammingNumeric. Esta función redondea el número aleatorio multiplicado por 1000 al entero más cercano.

d) Ubique la función Equal? en FunctionsProgrammingComparison y colóquela en el diagrama a bloques. Esta función compara el número aleatorio con el “Número para simulación” y genera un TRUE (booleano) si es igual; si no lo es, produce un False.

e) Utilice una estructura WHILE y coloque todo el diagrama a bloques dentro del ciclo WHILE (FunctionsProgrammingStructuresWhile loop.



15

f) Coloque la función Increment (FunctionsProgrammingNumeric) y conecte el ícono de iteraciones con la función (pase a través del borde de la estructura). Después conecte la salida de la función con el indicador numérico “Número de iteraciones”. Esta función se agrega al código porque el ciclo WHILE comienza sus iteraciones en cero.

El cuadro azul que aparece en el borde de la estructura es

un túnel. Los túneles proporcionan información desde y hacia las estructuras. La información sale de la estructura cuando el ciclo termina. Cuando se cuenta con un túnel hacia la estructura (entrada), el ciclo se ejecuta solamente cuando existe información en el túnel.

5) Guarde el VI con el nombre de “Número de iteraciones”. 6) Colóquese en el Panel Frontal (Ctrl+E) y cambie el valor

de 50 en “Número para simulación”.

7) Ejecute el VI (Ctrl+R o la flecha). Cambie el número a otro y realice 5 ejecuciones con ese número.

8) Para observar cómo LabVIEW llega a este resultado, es

recomendable utilizar la opción Highlight Execution que se encuentra en el diagrama a bloques, en la forma de un foco.

Figura 21.- Highlight Execution para observar el paso de la información

9) Presione Ctrl+T para colocar ambas ventanas juntas y ejecute el VI. Posiblemente sea lenta la ejecución, por lo que deberá presionar el botón rojo de paro para detener la misma.



16

Figura 22.- Ejecución lenta del VI

10) Después de detener el VI, asigne al control numérico valores que se encuentren fuera del rango de simulación.

11) Cierre el VI.

En esta parte de la práctica se utilizará un registro de corrimiento en conjunto con una estructura FOR para tener acceso a información de iteraciones previas.

12) Genere el Panel frontal de la figura 23 (recuerde que son indicadores numéricos).

Figura 23.- Panel frontal Registro de Corrimiento



17

13) Genere el Diagrama a Bloques de la figura 24.

Figura 24.- Diagrama a Bloques para registro de corrimiento

a) Utilice la función de suma (ADD) que se encuentra en FunctionsProgrammingNumeric.

b) Genere constantes numéricas para el registro de corrimiento y el ciclo FOR (FunctionsProgrammingStructures) y asigne el valor de 0 y 10 como se muestra en la figura 24.

c) Para crear un registro de corrimiento, coloque el cursor en el borde del ciclo FOR y presione el botón derecho del ratón. Seleccione Add Shift Register.

Figura 25.- Colocando un registro de corrimiento en la estructura FOR

d) Al crear el registro de corrimiento se

genera una entrada y una salida. Como se



18

desea tomar la información solo de una salida, es necesario crear elementos adicionales. Por lo que deberá colocarse sobre el registro de corrimiento de entrada, presionar el botón derecho del ratón y seleccionar Add Element. Realizar la operación dos veces para tener los tres nodos de entrada.

Figura 26.- Creando elementos adicionales para el registro de

corrimiento

14) Guarde el VI como “Registro de corrimiento”.

15) Presione Ctrl+T. Active Highlight Execution del Diagrama a Bloques y ejecute el VI.

16) Modifique la constante para el registro de corrimiento y

para la suma a 1. Ejecute el VI.

17) Cierre el VI (no guarde los cambios).

En el siguiente VI se hará uso de la estructura CASE, aplicando a un simple proceso de calcular la raíz cuadrada de un número. Si la raíz existe se proporcionará un valor. De no existir (número imaginario), aparecerá un mensaje acorde a la situación.


18)


19

Genere el Panel Frontal de la figura 27 (un control y un indicador numérico).

Figura 27.- Panel Frontal para Raíz Cuadrada

19) Produzca el siguiente Diagrama a Bloques:

Figura 28.- Caso verdadero Raíz Cuadrada

a) Coloque una estructura de casos para los

eventos (FunctionsProgrammingStructures).

b) Utilice la función Greater or equal to 0? para evaluar si el número es mayor o igual a cero, recordando que el cero tiene raíz cuadrada (FunctionsProgrammingComparision), y conecte la salida a la entrada de la estructura CASE.

c) Coloque la función para realizar la raíz cuadrada dentro del caso verdadero (FunctionsProgrammingNumericSquare Root).

d) Se creará un mensaje para el usuario indicando que la operación es válida. Para ello se utilizará la función One Button Dialog (FunctionsProgrammingDialog &



20

User Interface) y se creará una constante de caracteres con la leyenda de la figura 28. Esta función cuenta con dos entradas, la selección será Message. Recuerde que para crear constantes directas a las funciones debe colocarse sobre el nodo en cuestión (Message), presionar el botón derecho del ratón y seleccionar CreateConstant (deberá ser de color rosa-morado la constante).

20) Genere el subdiagrama para el caso falso.

Figura 29.- Caso falso Raíz Cuadrada

a) Coloque el cursor sobre la etiqueta TRUE de

la estructura CASE y presione el botón izquierdo del ratón. Elija la opción FALSE.

b) Coloque el cursor sobre el túnel asignado al indicador numérico “Raíz cuadrada” y presione el botón derecho del ratón. Genere una constante numérica (CreateConstant) y asigne el valor de -999,999.



21

c) Realice el paso d) de la sección 19 para agregar un mensaje. Ahora se añadirá uno más (Button name “OK”) y el texto cambiará a como se muestra en la figura 29.

21) Guarde el VI con el nombre de “Raíz Cuadrada”. 22) Dirija la atención al Panel Frontal y ejecute el VI para

los siguientes valores: 0, 2, y -1.

23) Cierre el VI.

En el siguiente VI se hará uso del Stacked Sequence Structure para determinar cuánto tiempo le toma a LabVIEW (en milisegundos) igualar un número.

24) Abra el VI “Número de iteraciones” que realizó al inicio de la práctica.

25) Agregue un indicador numérico adicional como se muestra

en la figura 30.

Figura 30.- Indicador adicional “Tiempo de procesamiento (ms)”

26) Guarde el VI utilizando la opción SAVE AS… como “Tiempo de procesamiento”. Si aparece una pantalla como la de la



22

figura 31, seleccione CopySubstitute copy for original, presione Continue y guarde el VI en el lugar asignado para las prácticas.

Figura 31.- Guardando un VI con otro nombre

27) Seleccione el Diagrama a Bloques. Utilice la estructura

de secuencia apilada (FunctionsProgrammingStructuresStacked Sequence Structure) para incluir todo el código del VI.

28) Coloque el cursor sobre la parte superior de la

estructura y presione el botón derecho del ratón. Seleccione la opción Add Frame After para agregar una trama a la actual.

Figura 32.- Agregando una trama a la secuencia

29) Ahora tendrá una trama vacía con el número 1 en la

etiqueta superior. Genere el siguiente subdiagrama.



23

Figura 33.- Trama para procesar tiempo de ejecución

a) Utilice el reloj Tick Counts (ms) para saber

cuánto tiempo (en milisegundos) ha transcurrido desde el inicio de la ejecución (FunctionsProgrammingTimingTick Counts ms). Recuerde que el indicador adicional puede ser obstruido por la primer trama. Si no es posible encontrarlo, regrese a la trama 0, corte y pegue en la trama 1.

30) Guarde el VI. 31) Ejecute el VI con los siguientes valores: 1, 700, 751.

Para cada valor deberá ejecutar el VI en tres ocasiones. Observe el indicador de tiempo.

32) Cierre el VI.

Por último, se utilizará la estructura MATHSCRIPT para crear ecuaciones sencillas de conversión para temperatura. En este ejercicio se utilizará el VI creado en la práctica #6 (Convertidor Fahrenheit a centígrados).

33) Abra un nuevo VI. 34) Genere el siguiente Panel Frontal



24

Figura 34.- Convertidor de temperaturas

a) Utilice el termómetro como indicador

(ControlsModernNumericThermometer). b) Para obtener el valor numérico del

termómetro además del visual, coloque el cursor sobre el indicador de temperatura y presione el botón derecho del ratón. Seleccione Visible itemsDigital Display.

Figura 35.- Agregando indicadores digitales a los termómetros

c) Recuerde que para cambiar el aspecto de las etiquetas, primero se selecciona la etiqueta y después se utiliza el botón Application Font, que se encuentra al lado del ícono PAUSA.


35)


25

Genere el siguiente diagrama a bloques.

Figura 36.- Diagrama a Bloques del VI con MATHSCRIPT

a) Utilice la estructura MATHSCRIPT y escriba dentro de ella las siguientes ecuaciones: C=(F-32)/1.8; K=C-273.15; Debe colocar el punto y coma para señalar el final de la ecuación.

b) Coloque el cursor sobre la orilla izquierda de la estructura MATHSCRIPT y presione el botón derecho del ratón, seleccione Add Input y escriba la letra F. Para las salidas haga lo mismo pero ahora del lado derecho de la estructura, coloque C y K (remítase a la figura 13 si no recuerda cómo).

c) Presione el botón derecho del ratón para tener acceso a la paleta de funciones. Seleccione Select a Vi… y abra el subVI creado en la práctica anterior (Convertidor Fahrenheit a centígrados) y colóquelo sobre la estructura MATHSCRIPT.



26

Figura 37.- Utilizando un subVI

d) Conecte como se sugiere en la figura 36. e) Utilice una estructura WHILE para que el

código se repita hasta encontrar un evento que lo detenga (FunctionsProgrammingStructures)

f) Coloque el cursor sobre la terminal condicionante, presione el botón derecho del ratón y seleccione create control (revise la figura 3 si no recuerda cómo).

36) Modifique el Panel Frontal para que tenga la siguiente

presentación:

Figura 38.- Panel Frontal con botón de paro

37) Guarde el VI con el nombre “Convertidor de temperaturas”. 38) Ejecute el VI. 39) Asigne los siguientes valores: 32, 78, 90, 120, y 0.



27

Tarea: Con la información adquirida en esta práctica, genere un VI en el cual sea posible convertir grados Fahrenheit a Centígrados y Kelvin. Dicho VI deberá proporcionar una opción para cuando se desee observar la conversión de grados Centígrados y Kelvin por separado (es decir, solo uno a la vez). Se recomienda utilizar un interruptor para señalar cuál temperatura se está convirtiendo en el momento de la selección, además de asignar el nombre para cada temperatura en el interruptor (ControlsModernBooleanVertical Toggle Switch). Preguntas

1) ¿Cuáles son las diferencias entre una estructura WHILE y una FOR?

2) ¿Cómo se transfiere la información entre las iteraciones

de un ciclo?

3) ¿Cómo se ejecuta una estructura CASE?

4) ¿Cómo se ejecuta una estructura Stacked Sequence?

5) Cuando se utiliza la estructura MATHSCRIPT,¿qué sucede si una entrada tiene el mismo nombre que una salida?

práctica 8 estructuras de programación en labview · pdf filecontrol donde se...

Documents