You are on page 1of 21

LA FRMULA NODO

Objetivo
Saber el funcionamiento del formula nodo, as como su
funcionamiento.

En esta prctica utilizaremos una funcin llamada formula nodo, la cual


nos ayuda a hacer las funciones u operaciones de una manera ms
rpida y lo mejor es que hace un programa de manera ms pequea.
Ahora bien en la primera prctica se tiene resolver una ecuacin de
segundo grado mediante la frmula general, esta es

x=b

b24 ac
.
2a

Y este programa tambin tiene que decir si la solucin es compleja o


real, mediante indicadores leds.
Para empezar lo que se tiene que poner es el nodo formula est la
encontramos en el panel de diagrama. Como se muestra en la imagen.

Una vez seleccionado lo que tenemos que hacer es colocar las variables
tanto de entrada como de salida a nuestro nodo, esto lo hacemos en la
parte derecha para las entradas y las izquierdas para salida. Tenemos
que poner 3 variables de entrada, que sern a b y c. y posteriormente
colocarlarle a esas entradas unos controles numricos, ya que los
valores de a, b y c los iremos cambiando a nuestros gustos.

Ahora para agregar las salidas hacemos lo mismo, solo que esta vez
seleccionamos add output, y las salidas estn en el lado izquierdo, que
en este caso solo sern dos, ya que las funciones cuadrticas solo tienen
dos soluciones (X1 y X2). Y a estas le conectamos unos indicadores
numricos.

Una vez agregado tanto las entradas como salidas, se procede a escribir
el programa. Para escribir el programa en u nodo, es muy parecido al
lenguaje c, solo que ms fcil, ya que no se declaran variables, as que
nos ayudamos de operaciones como sqrt, para hacerlo, quedando as.
Podemos dividir la expresin de tal modo que lo que se hace dentro de
la raz sea otra variable de salida y llamarla z. ya que si esta expresin
nos da un numero negativo podemos decir que la solucin es compleja y
si es un numero positivo, la solucin es real.

Ahora por ultimo tenemos que colocar los indicadores que nos harn
saber si la solucin es real o compleja. Solo a nuestra variable de salida
z, le cableamos unos comparadores, diciendo que si z es >= a 0, nuestra
solucin es real pero si z es < 0 la solucin es compleja. Quedando de la
siguiente manera.

Por ultimo en el panel frontal, ordenamos nuestro programa de una


manera que se vea esttica, y comprobamos que efectivamente
funcione.

Suma, Resta, Multiplicacin y Divisin de Nmero Complejos.


Para esta prctica se tiene que recordar cmo se realiza las operaciones
con nmeros complejos. Y lo que se quiere es seleccionar con un Knob,
la operacin que se quiera realizar. Todo esto obviamente utilizado el
nodo formula.
As que para comenzar el programa tenemos que colocar un Knob en
nuestro panel frontal. Y ese Knob debemos colocarle etiquetas con
nombres de Suma, Resta, Multiplicacin y Divisin lo cual en
prcticas anteriores se hizo.

Una vez eso lo siguiente es conectar ese Knob a un case para que este
se convierta en un multicase, y as tener en cada caso un nodo formula,
el cual sumara o multiplicara, los nmeros respectivamente. Tendremos
desde el caso 0 hasta el 3, en cada caso colocaremos un nodo frmula.

Ahora a los nodos debemos agregarle 4 entradas llamndolas a, bi y c,


di, recordmonos que un nmero complejo esta constituido de una parte
real (a y c) y una parte imaginaria (bi y di). De ah las 4 entradas de
nuestro nodo. En seguida tenemos que poner solo dos salidas a nuestros
nodos ya que nuestro resultado solo ser un numero complejo, a estas
salidas las llamamos X y Y. Mencionar que esto solo ser para el caso 0
y 1.

Y a estas salidas tenemos que conectarle los 4 controles numricos y


dos indicadores numricos. Tenemos que cuidar que tanto los
indicadores como los controles numricos queden fuera de nuestro case,
ya que si los dejamos dentro tendremos que crear variables locales de
estos, para que se puedan realizar la operacin.

Ahora para el caso 0 y 1 en el nodo formula tenemos hacer la


operacin de suma y resta, para estos casos solo tenemos que sumar o
restar la parte real de nuestro nmeros (a, c) y la parte imaginaria (bi y
di). As que en nuestros nodos formulas pondremos lo siguiente para la
suma y resta.

Ahora para el caso de multiplicacin y divisin, como las operaciones


son un poco ms largas las dividimos en suboperaciones para hacer esto
ms fcil. Quedando de la siguiente manera.

Y as tendremos hecha las operaciones, por ultimo debemos colocar un


indicador string, quedando ste fuera del case, y dentro del case poner
una constante string, con el nombre de la operacin en turno, quedando
as.

Ya como ltimo paso, debemos ordenar en el panel frontal los


indicadores y controles, para que estos se vean de una manera esttica,
corremos el programa y vemos si ste efectivamente funciona.

Ordenar de menor a mayor los nmeros.


Para esta prctica tenemos ordenar 3 nmeros del menor hasta el
mayor, usando el nodo formula, para esto colocamos un nodo formula en
el diagrama de bloques y le colocamos tanto 3 entradas como 3 salidas,
como se muestra en la siguiente imagen.

Ahora para la programacin de esto, tenemos que usar la funcin if, ya


que con esta funcin podremos comparar si los nmeros son el mayor o
el menor de estos 3. Para saber que es el mayor tenemos que
compararlo con todos los dems al igual para saber si es el menor. Y si
no es ninguno de los 2 entonces por eliminacin sabemos que es el de
medio. Entonces lo haremos con la variable a.

Ya habiendo hecho con la variable a, procederemos a hacerlo con la


variable b y con la c respectivamente.

Por ultimo damos esttica a nuestro panel frontal y vemos si


efectivamente funciona.

Llenado y descarga de un tanque.


Ya como ultima prctica debemos hacer que un tanque se llene y se
vaci de manera automtica, y adems el usuario podr establecer los
valores mximos y mnimos a los cuales se puede llenar el tanque. Esta
prctica fue hecha con lenguaje G, debido a su complejidad. As que
para empezar en el panel frontal colocamos tanto los indicadores que
seran los tanques, como los controles numricos, donde indicaremos el
valor mximo y mnimo as como tambin un botn de inicio. Quedando
de la siguiente manera.

Ahora para hacer el llenado de tanque podemos ponerlo en un for para


que este con las iteraciones se empiece a llenar, conectado a n, el
control valor mximo, y as poder elegir valor mximo que el tanque
debe llenarse. Quedando de la siguiente manera.

Ahora ya tenemos lo que es el llenado de tanque, pero este lo debemos


meter en un flat secuence, ya que una vez que se llene, pasara a vaciar
el tanque, es por eso que lo pondremos dentro de un flat secuence.

Y ahora en el siguiente frame, pondremos la descarga del tanque, para


hacer esto tenemos que crear variables locales tanto como del control
mximo as como tambin del tanque y con un while, tenemos que
restar el valor mximo a las iteraciones del while, y comparar esas
iteraciones con el valor mnimo, para que el while se detenga, quedando
de la siguiente manera.

Despus tenemos que hacer que eso se repita infinitamente, asi que
para volver a llenar el tanque, en el siguiente frame ponemos otro
while, con las cuales a las iteraciones le sumaremos el valor mnimo,
puesto queremos que empiece a llenarse desde ese punto, y haremos
una comparacin de esas iteraciones con el valor mximo para que se
detenga en ese punto, todo
esto usando las variables locales
respectivas quedando el programa as.

Y como queremos que esos dos ciclos se repitan entonces los ponemos a
los dos frame dentro de un while para que lo haga infinitamente.
Quedando de la siguiente manera.

Y como queremos que este programa inicie al presionar un botn lo


ponemos dentro de un case y conectamos el boton al case, ya por ultimo
encerramos todo el programa en un while, para que este lo haga
infinitas veces. Quedando de la siguiente manera.

Ahora se verifica si efectivamente el programa funciona, si es as, esta


genial, si no tendremos que verificar donde est el error.

Arreglos 1
Objetivo.
Conocer y usar los diferentes tipos de arreglo, y saber para que
funcionan cada uno.
Los arreglos constituyen una coleccin de datos los cuales pueden ser
utilizados posteriormente para cualquier operacin, asimismo se pueden
hacer diversas operaciones entre estas colecciones; a continuacin se
ver la creacin de arreglos simples.
Ejercicio 1. Crear un arreglo de tipo control
Como primer ejercicio debemos hacer un arreglo de dos filas y 5
columnas, para empezar en el panel frontal damos clic derecho y
seleccionamos array como muestra la imagen.

Ya seleccionado ahora tendremos que hacer que ese arreglo se vuela un


array de control, para hacer eso, solo tenemos que arratra un control
numrico dentro del array, y as automticamente se convertir en un
array de control.

Ahora para hacer ese arreglo ms grande, simplemente arrastramos de


una esquina del arreglo hacia la derecha para que tenga ms columnas.
Y arrastramos hasta tener nuestras 5 columnas como se muestra en la
siguiente imagen.

Para hacer ese arreglo tenga ms filas arrastramos hacia abajo en una
esquina del arreglo, lo hacemos solo hasta tener otra fila.

Ya por ultimo creamos las columnas de abajo como lo hicimos con las
filas, arrastramos hacia abajo y as tendremos nuestro arreglo de 2 filas
y 5 columnas.

Ejercicio 2.Crear un Arreglo de indicadores


Ahora en la prctica anterior vimos cmo se creaba un arreglo pero de
control, esta vez haremos un arreglo pero de indicador, es el mismo
procedimiento anterior. Seleccionamos un array. Y lo hacemos de tal
manera que quede de 5 columnas. Solo que ahora en vez de meter un
control numrico, introduciremos un indicador numrico. Y lo
arrastraremos hasta que tengamos 5 columnas, como se muestra en la
imagen

Ahora en el diagrama de bloques, pondremos un for, y en la n


pondremos el valor constante de 5, puesto que son 5 columnas las que
tenemos. Y pondremos un random nmero dentro del for y lo
conectaremos a nuestro arreglo, cuidando que el arreglo no quede
dentro del for. Como se muestra en la imagen.

Corremos el programa y vemos que los valores en cada columna son


aleatorias, gracias al random nmero.

Ejercicio 3. Modifique el programa anterior para que los datos


inicializados correspondan a los valores 5, 6, 7, 8,9.
Para hacer que el array tenga numero consecutivos y ya no los nmeros
aleatorios, simplemente borramos el randon nmero de nuestro ejercicio
anterior. Y conectaremos a las iteraciones del for, pero como las
iteraciones comienzan desde 0 y llegaran hasta 4, ya que nuestra n esta
desde 5. Si conectamos directo a las iteraciones tendramos nmero del
0 al 4, consecutivos, pero como queremos que sean del 5 al 9
consecutivos, a esas iteraciones le sumamos un 5 y la salida de esa
suma lo conectamos al arreglo.. Como se muestra en la imagen.

Corremos el programa y vemos que efectivamente


correspondan 5, 6, 7 ,8 ,9 respectivamente.

los

valores

Ejercicio 4. Crear un array de una dimensin de 10 elementos


conformado por nmeros enteros aleatorios comprendidos entre
0 y 250, graficarlos con Waveform Chart.
Ahora en este ejercicio tenemos que generar nmero aleatorios de o a
250, y esos valores graficarlos. Para empezar hacemos nuestro reglo de
indicadores, nuestro arreglo tiene que ser de 10 filas. Tiene que quedar
de la siguiente manera. Y creamos un ciclo for, y en la n ponemos el
nmero 10, puesto que sern 10 valores los que estarn en el arreglo.

Y como los nmeros que graficaremos sern aleatorios, tendremos que


poner dentro del for un random numeric, pero como queremos que sean
valores del 0 al 250, ese random tenemos que multiplicarlos por un
numero constante, este caso ser 250. Y la salida de esa multiplicacin
tenemos que conectarlo al arreglo, como se muestra en la imagen. Y en
el panel frontal, pondremos la grfica Waveform Chart, como se
muestra en la imagen.

Ya tenindola grafica en el panel frontal, ahora nos vamos a diagrama de


bloques y conectamos la grfica a la salida la multiplicacin como se
hizo con el arreglo. Despus de eso corremos el programa y vemos que
efectivamente esos valores sean graficados.

Ejercicio 5. Obtener en el panel frontal otro array donde cada


elemento este multiplicado por una escala constante e igual a
10.
Primero en el panel frontal, creamos 2 arreglos de 7 columnas, que sean
arreglos de indicadores.

Despus en el diagrama de bloques, ponemos un ciclo for, con 7 en el


valor de n, puesto que sern 7 valores los que se tiene que mostrar en el
array. Los valores tiene que ser del 10 al 70, pero como nuestras
iteraciones solo nos dan del 0 al 6, le tenemos que sumar 1 a las
iteraciones y despus multiplicarlas por 10, para que los valores sean
del 10 al 70, para posteriormente conectar esa multiplicacin al primer
arreglo como se muestra en la imagen.

Ahora para el segundo arreglo, solo debemos multiplicar otra vez las
iteraciones por otro 10, para que as los valores correspondan de 100 a
700, y esa multiplicacin debemos conectarlo a al segundo arreglo como
se muestra en la imagen. Por ultimo corremos el programa y vemos si
efectivamente funciona correctamente.

Ejercicio 6. Generar un array de dos dimensiones (dos filas por


cinco columnas) con elementos numricos enteros entre 0 y 10.
Para empezar en el panel frontal creamos un arreglo de 10 columnas y 2
filas del tipo indicador como se muestra en la imagen.

Ahora lo que sigue es poner en ese arreglo, nmeros del 0 al 10, pero
tanto en la primera como en la segunda fila tiene que estar esos valores.
As que para hacerlo tenemos que poner dos ciclos for anidados, o sea
uno dentro del otro, en el primer for ponemos el nmero de filas en
donde se quieran representar los valores, en este caso ser el nmero 2
y en el for de adentro ponemos el nmero de columnas de nuestro
arreglo, en este caso el nmero 11, quedando de la siguiente manera.

Por ltimo conectamos el arreglo a las iteraciones del for de adentro a


nuestro arreglo, corremos el programa y vemos que efectivamente dos
de valores del 0 al 10, en las dos filas.

Ejercicio 7. Construir un VI que genere un array de tres filas, en


la primera con los primeros cinco nmeros, la segunda con el
cuadrado de dichos nmeros y la tercera con la raz cuadrada.
Ahora como ltima practica creamos un arreglo de 3 filas y 5 columnas
en el panel frontal, como se muestra en la siguiente imagen. Y en el
diagrama de bloques creamos dos for anidados, con el nmero 3 en n,
puesto que son 3 filas, y en el segundo for con 5 en n, puesto que son 5
columnas.

Ahora como queremos que en la primera fila solo se muestre nmeros


del 0 al 4, en la segunda que esos nmeros sean elevados al cuadrado, y
en la tercera que se le obtenga la raz, tenemos que poner un case
dentro del ciclo for, y conectarlo a las iteraciones del primer for, puesto
eso es lo que controla las filas de nuestro array, quedando como se
muestra en la imagen.

Y al conectar las iteraciones a nuestro case, este se convertir en un


mullicase, as que como en la primera fila queremos que se muestren
solo los nmeros del 0 al 4, conectaremos las iteraciones del for nuestro
arreglo, pero este ser para el caso 0. Y en primer caso a esas
iteraciones las elevaremos al cuadrado y por ltimo en el segundo caso,
obtendremos raz de esas iteraciones, para posteriormente conectarlo al
arreglo, quedando como se muestra en la imagen.

Por ltimo corremos el programa y vemos si efectivamente los valores


sean los correctos para las filas.

Si queremos invertir el arreglo solo ponemos un Transponed Array, y lo


conectamos a la salida de case, como se muestra en la imagen y lo
conectamos a otro arreglo, quedando de la siguiente manera.