ESCUELA SUPERIOR POLITECNICA DEL CHIMBORAZO
FACULTAD DE INFORMATICA Y ELECTRONICA
INGENIERIA ELECTRONICA Y AUTOMATIZACION
SOFTWARE PARA LA INGENIERIA
INTEGRANTES:
JOHNNY JACOME (541)
MARCELO PULLAPAXI (542)
CURSO:
TERCERO “B”
DOCENTE:
Ing. Jonny Guaiña
FECHA:
27/11/2019
1
Índice
1. TEMA.....................................................................................................................................................1
2. Objetivos...............................................................................................................................................1
2.1. Objetivo General..........................................................................................................................1
2.2. Objetivo especifico.......................................................................................................................1
3. Marco Teórico.......................................................................................................................................1
3.1. Nodo de expresión.......................................................................................................................1
3.2. Nodo de fórmula..........................................................................................................................2
3.3. Nodo de LabVIEW MathScript......................................................................................................3
4. Planteo de ejercicio 1............................................................................................................................5
4.1. Resolución de ejercicio 1..............................................................................................................5
4.2. FUNCION Y PROPIEDADES............................................................................................................8
4.2.1. SUMADORES........................................................................................................................8
4.2.2. BUCLE WHILE.......................................................................................................................8
4.2.3. MATHSCRIPT NODE.............................................................................................................9
4.3. GRAFICA DE LA SIMULACIÓN.......................................................................................................9
4.4. Problema propuesto....................................................................................................................9
4.4.1. Solución...............................................................................................................................9
5. Conclusiones.......................................................................................................................................10
6. Bibliografía..........................................................................................................................................10
Tabla de Gráficas
Figura 1: “Arquitectura” básica de un nodo de script en LabVIEW...............................................................1
Figura 2: Uso de funciones numéricas para representar una expresión.......................................................1
Figura 3: Uso del nodo de expresión para simplificar el código en la figura 2..............................................2
Figura 4: Ejemplo de nodo de fórmula..........................................................................................................2
Figura 5: Datos generados por el script de nodo de fórmula........................................................................2
Figura 6: Formato de nodo de LabVIEW MathScript.....................................................................................3
Figura 7: Cálculo de números de Fibonacci en código G...............................................................................3
Figura 8: Cálculo de números de Fibonacci en LabVIEW MathScript............................................................4
Figura 9: function Fibonacci en Matlab.........................................................................................................4
Figura 10: Formato de nodo de LabVIEW MathScript...................................................................................5
Figura 11: 4 Vertical Fill Slide.........................................................................................................................5
Figura 12: Insertar un Tank............................................................................................................................6
Figura 13: Sumatoria de ingredientes...........................................................................................................6
Figura 14: Importar Script de control............................................................................................................7
Figura 15: Buscar e Importar el archivo del Script.........................................................................................7
Figura 16: Agregar una entrada a MathScript...............................................................................................7
Figura 17: Agregar una Salida a MathScript..................................................................................................8
Figura 18: Añadimos un Numeric Indicator...................................................................................................8
Figura 19: Gráfica de la simulación................................................................................................................9
Figura 20: Problema propuesto, solución......................................................................................................9
2
INTRODUCCION
Labview (Laboratory Virtual Instrumentation Engineering Workbench) es una
plataforma y entorno de desarrollo para diseñar sistemas en un lenguaje de
programación gráfico, un poco parecido a Simulink, denominado lenguaje G. Es
totalmente compatible con MATLAB, incluso posee herramientas para la programación
en lenguaje propio de MATLAB. Los programas desarrollados reciben el nombre de
instrumentos virtuales y es muy fácil de usar. Cuenta con múltiples librerías para la
programación y simulación de diversos sistemas, incluyendo los de procesamiento
digital de señales.
Una definición común es que "un lenguaje de script, lenguaje de script o lenguaje de
extensión es un lenguaje de programación que controla una aplicación de software". Los
programas escritos con un lenguaje de scripting generalmente están basados en
comandos e interpretados, no compilados, una razón por la que suelen ser más lentos
que los programas creados en C, C ++, G y otros lenguajes de programación que
ejecutan código compilado y optimizado. Los lenguajes de secuencias de comandos
generalmente siguen una sintaxis específica, y las reglas no son muy flexibles en
algunos casos. Sin embargo, debido a que estos lenguajes de secuencias de comandos
están basados en texto y muchos de ellos se basan en estándares abiertos que utilizan
reglas y comandos simples para ejecutar tareas complejas, tienen un espacio en la
comunidad académica y científica. También son muy populares en la creación y
administración de páginas web, por lo que los profesionales de informática y TI las usan
comúnmente en proyectos relacionados con la web.
3
1. TEMA
Descripción del uso de scripts en LabVIEW.
2. Objetivos
[Link] General
Explicar el uso de scripts en el desarrollo de LabVIEW a través de un nodo de
Mathscript.
[Link] especifico
Consultar sobre todas las opciones de nodo para usar el script en LabVIEW.
Desarrollar paso a paso como importar y exportar el script en un archivo txt.
Ejemplificar cada uno de los métodos con varias comparaciones, entre el uso
de bloques de funciones y los scripts.
3. Marco Teórico
La arquitectura básica de un nodo de script en LabVIEW se muestra en la Figura 1. Por
lo general, las entradas y salidas son opcionales.
Figura 1: “Arquitectura” básica de un nodo de script en LabVIEW
[Link] de expresión
Use un nodo de expresión para calcular expresiones que contienen una sola variable.
Los nodos de expresión son útiles cuando una expresión tiene solo una variable, pero
por lo demás, es complicada.
Considere esta simple expresión:
x * x + 33 * (x + 5) (1)
1
Figura 2: Uso de funciones numéricas para representar una expresión
Puede simplificar este código drásticamente utilizando un nodo de expresión. El
siguiente código proporciona la misma funcionalidad que el diagrama de bloques
anterior:
Figura 3: Uso del nodo de expresión para simplificar el código en la figura 2
[Link] de fórmula
Los nodos de fórmula son mucho más extensos y potentes que los nodos de expresión y
tampoco pueden considerarse un lenguaje de secuencias de comandos porque están más
orientados a la resolución de fórmulas y se limitan a un conjunto de funciones y
operadores. Sin embargo, los Nodos de Fórmula están incluidos en esta lista debido a
sus similitudes con otros lenguajes de secuencias de comandos (y con la sintaxis del
lenguaje C) y porque es un nodo conveniente basado en texto que puede usar para
realizar operaciones matemáticas en el diagrama de bloques de LabVIEW.
Figura 4: Ejemplo de nodo de fórmula
En la Figura 4, el código define un número entero ( i ) y una matriz ( numArry );
entonces, un bucle for usado con la función rand genera 100 números aleatorios.
Finalmente, LabVIEW traza los valores de salida en un gráfico de forma de onda, como
se muestra en el siguiente panel frontal.
2
Figura 5: Datos generados por el script de nodo de fórmula
No hay límite para el número de variables o ecuaciones permitidas en un Nodo de
Fórmula, y puede declarar y usar una variable dentro del Nodo de Fórmula sin
relacionarlo con un cable de entrada o salida. Las variables pueden ser escalares
numéricos de coma flotante cuya precisión depende de la configuración de su
computadora. También puede usar enteros y matrices de valores numéricos para las
variables. Un punto a considerar es que el Nodo de Fórmula no admite tipos de datos
complejos o el tipo de datos de matriz.
[Link] de LabVIEW MathScript
LabVIEW MathScript es un lenguaje de script basado en texto que puede usar para
escribir funciones y scripts para usar en la Ventana LabVIEW MathScript o el Nodo
MathScript. La sintaxis de LabVIEW MathScript en los nodos MathScript tiene el
siguiente formato:
Figura 6: Formato de nodo de LabVIEW MathScript
Puede llamar a funciones desde un nodo MathScript. Si llama a una función desde un
Nodo MathScript que podría cambiar la lista de ruta de búsqueda de MathScript en
tiempo de ejecución o podría introducir nuevas variables en tiempo de ejecución,
aparecerá un glifo de advertencia (signo amarillo) en el Nodo MathScript.
El siguiente ejemplo utiliza una función para calcular los números de Fibonacci según
lo especificado por el usuario. Primero, se presenta la versión del código G; luego, se
presenta la versión LabVIEW MathScript, que incluye un glifo de advertencia.
La versión del lenguaje de programación G es la siguiente:
3
Figura 7: Cálculo de números de Fibonacci en código G
El código equivalente de LabVIEW MathScript es el siguiente:
Figura 8: Cálculo de números de Fibonacci en LabVIEW MathScript
El glifo de advertencia en la Figura 8 indica un cambio de ruta utilizado para el
archivo .m . Tenga en cuenta que LabVIEW Run-Time Engine y las aplicaciones que
implementa en objetivos en tiempo real no son compatibles con los nodos MathScript
con glifos de advertencia. Si un VI incluye un Nodo MathScript con un glifo de
advertencia, debe eliminar el glifo de advertencia del Nodo MathScript antes de crear
una aplicación independiente o una biblioteca compartida.
El nodo MathScript anterior llama a una función F, que se guarda en un archivo .m con
el siguiente script:
4
Figura 9: function Fibonacci en Matlab.
Puede crear este archivo utilizando la Ventana LabVIEW MathScript o un editor de
texto ASCII como el Bloc de notas de Microsoft [Link]én puede combinar el
uso de nodos MathScript con ciertos módulos y kits de herramientas de LabVIEW. Por
ejemplo, el Módulo de Diseño y Simulación de Control de LabVIEW hace que el
espacio de estado, la función de transferencia y los modelos de ganancia de polo cero
estén disponibles para su uso en el Nodo MathScript (ver Figura 10) y el nodo del script
Xmath. Debe tener instalado el Módulo de Diseño y Simulación de Control de
LabVIEW para usar estos modelos.
Figura 10: Formato de nodo de LabVIEW MathScript
4. Planteo de ejercicio 1
Se desea simular el precio de cierto producto determinado, donde su precio dependerá
de la cantidad de tres ingredientes del producto, siendo la cantidad de ingrediente
directamente proporcional al precio del producto. Para lo cual cada ingrediente será con
un indicador Vertical Fill Slide y la cantidad total del producto con un Tank además
colocar un numeric indicator que nos mostrara el precio del producto bajo las siguientes
condiciones si la cantidad de producto es menor que 5 el precio es de $1, si es >5 el
5
precio es de $2. Para estas condiciones se pide sea realizado importando un script desde
un MathScript.
[Link]ón de ejercicio 1
PASO 1
Dentro de nuestro Front Panel necesitaremos de 4 Vertical Fill Slide que controlara la
cantidad de cada ingrediente.
Figura 11: 4 Vertical Fill Slide
PASO 2
Para visualizar la cantidad de producto total necesitaremos de un Tank que almacenera
la suma de todos los ingredientes.
Figura 12: Insertar un Tank
PASO 3
Para que nuestro almacenamiento varié dependiendo la cantidad de ingredientes
debemos ir a nuestro Block Diagram y utilizar la función Add que sumara los 4
ingredientes y que finalmente este resultado se conectara con el Tank que representa
nuestro almacenamiento y poder visualizar la sumatoria.
6
Figura 13: Sumatoria de ingredientes.
PASO 4
Para controlar el precio del producto importaremos un Script para lo cual utilizaremos la
estructura MathScript Node que nos permitirá utilizar sentencias condicionales. Para
importar un Script damos clic derecho en el cuadro de la función MathScript y
seleccionamos la opción import.
Figura 14: Importar Script de control.
PASO 5
Seleccionamos el archivo del script y damos clic en OK y se importa lo que tenemos
guardado en ese Script.
7
Figura 15: Buscar e Importar el archivo del Script.
PASO 6
Dentro de esta estructura MathScript necesitaremos una entrada “a” y una salida “p”
que se las puede obtener dando clic derecho en los extremos y seleccionar Add Input o
Add Output donde estas variarán dependiendo las necesidades del ejercicio.
Figura 16: Agregar una entrada a MathScript
Figura 17: Agregar una Salida a MathScript.
PASO 7
8
Dentro de nuestro Front Panel colocaremos un numeric indicator que nos mostrará el
precio del producto, para ello dentro de nuestro Block Diagram conectaremos nuestra
salida “p” al numeric indicator que permitirá visualizar el precio en nuestro Front Panel.
Figura 18: Añadimos un Numeric Indicator.
[Link] Y PROPIEDADES
4.2.1. SUMADORES
Toma dos valores numéricos, los mismos que pueden ser constantes numéricas o una
constante y una entrada convertida a decimal. Se la utiliza en el caso de querer agregar
un nuevo valor para representar.
4.2.2. BUCLE WHILE
Permite repetir una acción controlada por una cantidad finita de veces que se activa
cuando se añade un botón de pare.
4.2.3. MATHSCRIPT NODE
Permite importar y exportar script además de usar estructuras de repetición.
[Link] DE LA SIMULACIÓN
9
Figura 19: Gráfica de la simulación.
[Link] propuesto
En una empresa de leche se tiene tres tanques de le leche para los cuales se desea que se
ponga un indicador numérico para mostrar el contenido de cada uno de ellos. Además
de ello se desea colocar un indicador tipo meter en donde se muestre la media de los tres
tanques de leche. Para lo cual se pide se lo realice importando el proceso desde un script
y usando MathScript Node.
4.4.1. Solución
Figura 20: Problema propuesto, solución.
5. Conclusiones
Un uso de scripts es automatizar la inspección del código para garantizar el
cumplimiento de las pautas de estilo y prácticas de programación efectivas,
detectar errores comunes y mejorar el rendimiento, la funcionalidad y la
capacidad de mantenimiento.
10
Los scripts se encargan de cumplir las funciones de combinar componentes,
interactuar con el sistema operativo o con el usuario, controlar un determinado
programa o aplicación.
6. Bibliografía
Bitter, R. M. (2017). LabVIEW: Técnicas avanzadas de programación . . Crc Press.
Travis, J. y. (2007). LabVIEW para todos: la programación gráfica es fácil y divertida . .
Prentice Hall.
Vizcaíno, J. y. (2011). LabVIEW: Entorno gráfico de programación . Marcombo.
11