0 Labview Como Herramienta

LabVIEW como herramienta de programación de sistemas de
desarrollo de Instrumentos Virtuales para Ingeniería Electrónica
Edwin Gregory Hernández Díaz.

Mayo 2017.
Universidad Nacional Experimental del Táchira.

Departamento de Ingeniería Electrónica.
ii
República Bolivariana de Venezuela

Universidad Nacional Experimental del Táchira
Trabajo de Ascenso
LabVIEW COMO HERRAMIENTA DE PROGRAMACIÓN DE SISTEMAS

DE DESARROLLO DE INSTRUMENTOS VIRTUALES PARA
INGENIERÍA ELECTRÓNICA
Autor: Edwin Gregory Hernández Díaz

Fecha: Mayo, 2017
RESUMEN
La información que se describe en este trabajo tiene como objetivo principal enseñar la
programación en lenguaje gráfico LabVIEW para el desarrollo de Instrumentos Virtuales de
utilidad en la Ingeniería Electrónica, partiendo de aplicaciones a nivel básico, pasando a nivel
intermedio y finalizando con aplicaciones de nivel profesional-avanzado. Estas aplicaciones,
tienen utilidad para proyectos en la industria electrónica, también aplica para la enseñanza
académica en el área de automatización e instrumentación electrónica y proyectos de final de
carrera. Se desarrollan fundamentos de programación gráfica, medición y adquisición de datos,
control y simulación de instrumentos, análisis y registro de mediciones, conexión con hardware,
conexión con software, publicaciones Web, entre otros. El contenido se divide en dieciséis
capítulos, estructurados en conceptos de electrónica, algoritmos para desarrollar programas,
código de programación en LabVIEW, ejemplos de programas de aplicaciones electrónicas y
actividades complementarias. Se utiliza hardware de diversas empresas electrónicas, para
aplicaciones que requieran conexiones con variables físicas reales, también se analizan otros
programas de simulación para conexión e intercambio de datos con el sistema de desarrollo virtual.
El sistema de desarrollo se basa en el lenguaje de programación LabVIEW perteneciente a la
compañía National Instruments NI, los elementos de hardware son seleccionados de diferentes
fabricantes para operarlos y programarlos en LabVIEW, conformado por tarjetas DAQ de
adquisición de datos de NI, tarjeta electrónicas de ARDUINO, PLC Allen-Bradley Micrologix de
Rockwell Automation, y programas de aplicación como el Explorador de Medición y
Automatización de NI-MAX, Simulador de circuitos electrónicos NI-MULTSIM, RSLogix y
RSLinx de Rokwell Automation.
Palabras clave: Programación, LabVIEW, Adquisición de Datos, Instrumentos Virtuales,

Automatización Electrónica.
iii
Tabla de Contenidos
Introducción .................................................................................................................................. 1
Capítulo I Estrategias para la solución de problemas en programación................................. 4
Método de Desarrollo de Software ............................................................................................. 4
Elementos del Método de Desarrollo de Software ..................................................................... 5
Actividad Complementaria 1 ...................................................................................................... 8
Capítulo II Navegación en LabVIEW ....................................................................................... 10
Instrumentos Virtuales (VI) ...................................................................................................... 10
Comenzar un VI ........................................................................................................................ 11
Explorar Proyectos .................................................................................................................... 14
Partes de un VI .......................................................................................................................... 17
Ventana del Panel Frontal ......................................................................................................... 17
Ventana del Diagrama de Bloques ............................................................................................ 25
Paleta de Herramientas ............................................................................................................. 34
Actividad Complementaria 2 .................................................................................................... 35
Capítulo III Solucionar problemas de depuración para programas en LabVIEW.............. 41
Utilidades de la ayuda del LabVIEW ....................................................................................... 41
Corrección de los Broken VI o VI rotos .................................................................................... 46
Técnicas de Depuración ............................................................................................................ 48
Verificación y tratamiento de Errores ....................................................................................... 51
Capítulo IV Implementar un Instrumento Virtual VI ............................................................ 61
Diseñar la Ventana del Panel Frontal........................................................................................ 61
Tipo de datos en LabVIEW ...................................................................................................... 62
Código en LabVIEW ................................................................................................................ 79
Capítulo V Temporizadores y Gráficas de señales en los VI .................................................. 85
Temporizadores en los VIs ....................................................................................................... 85
Gráficas de datos en LabVIEW ................................................................................................ 87
Control de Imágenes 3D ......................................................................................................... 107
Actividad Complementaria 5 .................................................................................................. 115
Capítulo VI Estructuras fundamentales de lazos repetitivos de LabVIEW ....................... 120
Estructura cíclica While .......................................................................................................... 120
Estructura cíclica For .............................................................................................................. 126
Registro de desplazamiento (Shift Register) ........................................................................... 132
Actividad complementaria 6 ................................................................................................... 134
Capítulo VII Desarrollo de aplicaciones Modulares.............................................................. 138
Comprensión de Modularidad: ............................................................................................... 138
Creación de un SubVI: ............................................................................................................ 139
Capítulo VIII Estructuras fundamentales de selección en LabVIEW................................. 146
Función de Selección SELECT .............................................................................................. 147
Estructura de Selección de Casos CASE ................................................................................ 148
Estructura secuencial SEQUENCE........................................................................................ 152
Estructura de Eventos EVENT ............................................................................................... 157
iv
Estructura de tiempo TIMED.................................................................................................. 160

Estructura de Sustitución IN PLACE ELEMENT .................................................................. 163
Estructura DIAGRAM DISABLE .......................................................................................... 163
Estructura CONDITIONAL.................................................................................................... 164
Función Formula NODE ......................................................................................................... 165
Función MATHSCRIPTS NODE ........................................................................................... 169
Función MATLABSCRIPT .................................................................................................... 174
Capítulo IX Manejo de datos para estructuras complejas.................................................... 182
Arreglos Vectores ................................................................................................................... 182
Arreglos Matrices.................................................................................................................... 188
Arreglos Cluster ...................................................................................................................... 195
Capítulo X Almacenamiento de Datos .................................................................................... 202
Almacenamiento de Archivos de E/S ..................................................................................... 203
Almacenamiento de Bajo Nivel E/S ....................................................................................... 204
Almacenamiento de Alto Nivel E/S ........................................................................................ 209
Capítulo XI Adquisición de Datos DAQ ................................................................................. 219
Adquisición de Datos .............................................................................................................. 220
Comunicación con Hardware .................................................................................................. 231
Simulación de un dispositivo DAQ ........................................................................................ 247
Diseño de un Sistema de Medición con la Tarjeta DAQ ........................................................ 249
Actividad Complementaria 10 (Uso de los canales Análogos y Digitales de la DAQ) .......... 253
Capítulo XII Interfaz del LabVIEW con el Simulador Electrónico Multisim .................... 267
Conocer el Multisim ............................................................................................................... 268
Diseño de circuitos electrónicos con Multisim ....................................................................... 274
Crear un Sub VI en Multisim .................................................................................................. 277
Comunicar Multisim con LabVIEW ....................................................................................... 279
Actividad Complementaria 11 ................................................................................................ 281
Capítulo XIII Comunicación Arduino con LabVIEW .......................................................... 285
Introducción al módulo Arduino ............................................................................................. 286
Programación con Arduino ..................................................................................................... 290
Toolkit de LabVIEW para programación de Arduino ............................................................ 293
Programación de Arduino con LabVIEW............................................................................... 297
Actividad Complementaria LabVIEW-Arduino 12, 13, 14 y 15 ............................................ 299
Capítulo XIV Módulo de Control y Simulación .................................................................... 312
Toolkit de Control y Simulación............................................................................................. 313
Funciones del Diseño de Control ............................................................................................ 313
Funciones de la Simulación .................................................................................................... 321
Desarrollo de aplicaciones, basadas en las funciones de simulación de Sistemas Lineales
Continuos, Discretos y Sistemas no Lineales ......................................................................... 329
Actividad Complementaria 16 ................................................................................................ 338
Capítulo XV Publicación de Programas vía Web .................................................................. 345
v
Generación de páginas Web desde el LabVIEW .................................................................... 346

Acceso al Web Publishing Tool .............................................................................................. 347
Crear una página Web con el panel remoto ............................................................................ 348
Opciones de configuración ..................................................................................................... 353
Capítulo XVI Comunicación de un PLC con LabVIEW ..................................................... 356
Descripción de un PLC ........................................................................................................... 357
La Interfaz Humano Máquina (HMI) ..................................................................................... 361
Protocolo de comunicación OPC ............................................................................................ 361
Algoritmo de conexión LabVIEW-PLC vía OPC .................................................................. 362
Actividad Complementaria 17 PLC-LabVIEW ...................................................................... 371
Referencias Bibliográficas .......................................................................................................... 378
1
Introducción
La información que se describe en este material tiene como objetivo principal,

ofrecer al lector conceptos de programación, basados en el software para el sistema de
desarrollo de aplicaciones en lenguaje gráfico LabVIEW, que puedan ser de utilidad para
el desarrollo de aplicaciones en la Ingeniería Electrónica. Se establecen técnicas para
diseñar programas conocidos en LabVIEW como Virtual Instruments o VIs, se estudian
las técnicas de programación gráfica, características del lenguaje LabVIEW, construcción
de Vis, funciones de medición de datos, adquisición de datos, control de instrumentos,
registro de datos, análisis de mediciones, generación de informes, conexión con hardware,
elementos de simulación, conexión con software, publicaciones Web, entre otros.
El contenido desarrollado se divide en dieciséis capítulos, estructurados en

algoritmos para el desarrollo de programas, código de programación en LabVIEW,
ejemplos para programar aplicaciones de desarrollo y actividades complementarias para
aplicaciones básicas de electrónica, utilización de hardware de diversas empresas
electrónicas, para aplicaciones que requieran conexiones con variables físicas reales,
también análisis de otros programas de simulación para conexión e intercambio de datos
con el sistema de desarrollo de LabVIEW. El uso de tarjetas y dispositivos electrónicos,
facilitan el entendimiento de un gran número de aplicaciones, sin embargo, si no se dispone
del hardware, se puede completar los ejercicios con módulos de simulación de dispositivos
electrónicos presentes en la herramienta de programación gráfica.
El Programa LabVIEW y sus elementos de simulación pertenecen a la compañía

de desarrollo de software y hardware para automatización, instrumentación y control
National Instruments. Para un mejor aprovechamiento de los contenidos del material, se
requiere que el lector disponga de los siguientes elementos:
2
Un computador con un sistema operativo bajo Windows 8 o posterior.

Dispositivo de multifunción DAQ configurado como tarjeta de adquisición de datos
de National Instruments. De no disponer de DAQ, se pueden simular por software.
Generadores de señales y fuentes DC.
Multímetros, y Osciloscopios.
Sensores y dispositivos electrónicos para acondicionar señales.
Puerto de comunicación USB y su cable de conexión.
Sistema de desarrollo profesional LabVIEW Versión 2013 o posterior, en el
material se utilizan las versiones 2013 y 2016.
Tarjeta electrónica ARDUINO.
PLC Allen-Bradley Micrologix de Rockwell Automation.
Programa NI-MAX, Explorador de Medición y Automatización de National
Instruments.
Programa de simulación y diseño de circuitos electrónicos, NI-MULTSIM versión
2012 o posterior.
VI PACKAGE MANAGER 2012 o versión posterior, programa usado para
descargar grupos de herramientas de programación del LabVIEW.
RSLogix y RSLinx de Rokwell Automation.
El material facilita al lector aprender el lenguaje gráfico LabVIEW partiendo de un

nivel básico, pasando a un nivel intermedio y finalizando con aplicaciones de un nivel
profesional-avanzado. En los primeros capítulos el programador debe estar en capacidad
de entender los elementos básicos del LabVIEW y realizar algoritmos de aplicaciones
sencillas. En capítulos posteriores, aprenderá a manejar elementos de hardware y software
para formar sistemas de instrumentación electrónica, con procesos reales y simulados.
Finalmente se orienta al programador a desarrollar aplicaciones más complejas de utilidad
en la ingeniería electrónica y que exijan un buen dominio del software de programación y
el manejo del hardware respectivo. Los ejemplos de desarrollo se describen en forma
continua en los dieciséis capítulos, pero se dividen en Proyectos de Aplicación y
Actividades Complementarias.
3
A Continuación se describe brevemente el contenido plasmado en los dieciséis

capítulos, indicando sus respectivos niveles de dificultad. En el nivel básico, se desarrollan:
Capítulo I, define los conceptos para aplicar el Método de Desarrollo de Software y generar
código en un lenguaje de programación específico. Capítulo II, navegar por las diferentes
ventanas y elementos de programación de LabVIEW. Capitulo III, aprender los métodos
de depuración, manejo de errores y correcta ejecución de los programas. Capítulo IV,
programar Instrumentos Virtuales. Capítulo V, conocer los diferentes controles e
indicadores de LabVIEW y las funciones básicas de programación. Capítulo VII,
programación modular y creación de sub-funciones.
En el nivel intermedio se desarrollan: Capítulo V, presenta todos los elementos de

visualización gráfica especializados y objetos 3D. Capítulo VIII y IX, describen todas las
estructuras de programación fundamentales. Capítulo X, registro y almacenamiento de
datos.
En el nivel avanzado se desarrollan: Capítulo XI, definir y programar los módulos

de adquisición de datos y la simulación de tarjetas de adquisición de datos. Capítulo XII,
comunicación de LabVIEW con el simulador electrónico MULTISIM. Capítulo XIII,
conexión de LabVIEW con tarjetas electrónicas Arduino. Capítulo XIV, módulos de
control y simulación de procesos. Capítulo XV publicación de programas de LabVIEW via
Web. Capítulo XVI, comunicación de LabVIEW con un PLC.
4
Capítulo I
Estrategias para la solución de problemas en programación
Los lenguajes de programación se pueden utilizar para resolver problemas en

diversas áreas tecnológicas. Los programadores de computadoras utilizan métodos de
desarrollo de software para resolver problemas, siguiendo un método específico puede
ayudar a un programador a desarrollar un código para resolver con éxito un determinado
problema, un método permite que el código sea legible, escalable y modificable y de
aplicación a diversos lenguajes de programación.
El capítulo uno, define los conceptos para aplicar el Método de Desarrollo de

Software y generar código sin referenciar un lenguaje de programación específico. A
continuación se define la lista de los principales temas definidos en este capítulo:
-. Método de Desarrollo de Software.
-. Elementos del Método de Desarrollo de Software.
-. Actividad Complementaria 1.
Método de Desarrollo de Software
Este tema describe un conjunto de pasos específicos, llamados Método de

Desarrollo de Software, conformados por elementos que permiten al programador
simplificar la solución de problemas y crear una estructura básica para generar código de
programación, es una estrategia para el uso del programa gráfico LabVIEW, para generar
soluciones de software.
El Método de Desarrollo de Software completa los siguientes elementos: Definir el
problema, diseñar soluciones, utilizar algoritmos u organigramas, implementar el diseño,
probar la programación y finalmente mantener y actualizar los programas.
5
Elementos del Método de Desarrollo de Software
Definir el problema: Define el problema para poder abordarlo, identificando todos los
factores necesarios para trabajar y buscar una solución, se descartan factores que generen
algún error en la lógica de la programación y poder enfocarse en el objetivo principal del
problema que se debe resolver.
Diseñar soluciones: Después de definir el problema se diseña una solución, basada en el

esquema de un sistema con entradas y salidas. Parte de analizar el problema es identificar
las entradas y salidas del mismo, así como cualquier requisito adicional. Identificar las
entradas corresponde a los datos brutos que se desea procesar. Las salidas representan el
resultado del cálculo, procesamiento, u otra condición del proceso que genere una solución.
Los requisitos adicionales se consideran cualquier factor que podría influir en la solución
del problema. Después de determinar las entradas, salidas, y los requisitos adicionales, se
puede crear pasos o algoritmos, los cuales procesan las entradas y elaboran productos
finales.
Para explicar la fase del diseño de soluciones, se expone el ejemplo de un algoritmo

para controlar la temperatura interior y exterior de un horno en un proceso de medición de
temperatura:
Entradas del sistema: temperatura exterior y temperatura interior del horno.
Salidas del sistema: Según sea los casos a describirse a continuación, dependerá la salida
del sistema para la toma de decisión:
1. Si la temperatura interior no es igual a la temperatura exterior, continúan las
lecturas de temperatura.
2. Si la temperatura interior supera a la deseada, apague el voltaje a la bobina.
3. Si la temperatura interior es menor o igual a la deseada, encienda el voltaje de la
bobina.
4. Continuar con las lecturas de temperatura o salir del proceso.
6
Diseño de un diagrama de flujo: Un diagrama de flujo muestra los pasos para resolver el
problema. Los diagramas de flujo son útiles porque puede seguir procesos más complejos
que un algoritmo en una forma visual. La figura 1.1 muestra un diagrama de flujo del
algoritmo diseñado para el proceso de medición de temperatura del ejemplo anterior.
Figura 1.1. Diagrama de flujo para controlar la temperatura interior y exterior de un horno en un proceso
de medición de temperatura.
Diseño de un diagrama de transición de estados: Los diagramas de transición de estados

son un tipo específico de diagrama de flujo que indican claramente los estados de un
programa y lo que hace que el programa pase la transición de un estado a otro. Un diagrama
de transición de estados utiliza un círculo marcado para significar un estado de equilibrio
y una flecha marcada para indicar una transición o evento que produce el cambio a otro
estado. Un estado es una parte de un programa que satisface una condición, realiza una
acción, o espera un evento. Una transición es la condición, acción o evento que hace que
7
el programa pase al siguiente estado. El inicio del programa está representado con un
círculo sólido, el final del programa está representado con un círculo específico con un
borde claro. El diagrama de flujo anterior, se puede representar con el diagrama de
transición de la figura 1.2.
Figura 2.2. Diagrama de transición de estados para controlar la temperatura interior y exterior de un
horno en un proceso de medición de temperatura.
Aplicación: Es la fase de ejecución, se crea el código para el algoritmo, diagrama de flujo

o de transición. Al escribir código en un lenguaje basado en texto, el algoritmo se traduce
en cada línea de código, dependiendo del nivel de detalle que muestre el algoritmo. Para el
lenguaje de programación gráfica LabVIEW, el diagrama de flujo funciona casi de la
misma manera que la codificación. En capítulos posteriores, se desarrollarán técnicas de
diseño comunes y patrones, para la implementación de los programas de LabVIEW, desde
un diagrama de transición de estado o de un diagrama de flujo.
8
Prueba y verificación: Probar y verificar es una parte importante del desarrollo del
software. Se debe asegurar pruebas de la aplicación con datos lógicos e ilógicos que den
una solución. La prueba de datos lógicos verifica un resultado esperado, mientras que las
pruebas de datos ilógicos verifican si el código tiene buena respuesta en el manejo del error
eficaz.
Mantener y actualizar los programas: Es importante revisar la dinámica del sistema

programado, para ir anexando cambios y actualizaciones relevantes que mejoren la
respuesta de los programas y que contribuyan a mantener el proceso siempre activo.
Actividad Complementaria 1
Resuelve el siguiente problema por el Método de Desarrollo de Software sin utilizar

un programa específico. Primero se debe definir el problema, en el caso de estudio.
Definir el problema: Un sistema de monitoreo y detección de fallas de una variable de un

determinado proceso. El programa debe contar con adquisición de la variable del proceso,
analizar la variable para determinar si está en un rango alto o bajo con respecto a un rango
de operación, alertar al usuario si la variable sale de su rango de operación, tener una
interfaz gráfica y un registro de la variable cuando se presente una alerta, si el usuario no
detiene el programa, todo el proceso se repite.
Diseñar soluciones: El proyecto tiene como entradas, la variable del proceso y el rango de
operación, también debe manejar el ingreso de una variable que permita detener el
programa. Las salidas del proyecto corresponden a la visualización de la variable y el
mensaje de alerta si ocurre una medición de valores fuera del rango de operación.
El diagrama de transición de estado, se muestra en la figura 1.3, se elige de modo

que todos pueden seguir el mismo conjunto de instrucciones, sin embargo, puede que no
sea la mejor solución para el problema.
9
Figura 3.3. Diagrama de transición de estados para controlar el rango de operación de una variable en
un proceso.
Aplicación: Se recomienda el lenguaje de programación gráfico LabVIEW, para codificar

los pasos definidos en el diagrama de transición de estados.
Prueba y verificación: El proceso debe ser evaluado para diferentes rangos de valores que
estén dentro y fuera del rango de operación, que permita verificar la efectividad del
algoritmo y ver su respuesta ante valores erróneos de operación.
10
Capítulo II
Navegación en LabVIEW
El lenguaje de programación gráfica desarrollado en este material, se basa en el

software de programación LabVIEW de National Instruments. Se explora el entorno de
programación LabVIEW, incluyendo manejo de paneles de programación, uso de los
menús, barras de herramientas, paletas de herramientas, paleta de funciones, ayuda,
cuadros de diálogo, entre otros. También da una orientación para la compilación de un
programa de aplicación básico, conocido en LabVIEW como un Instrumento Virtual (VI).
Los temas a desarrollar se definen con detalles a continuación:
-. Instrumentos Virtuales (VI).
-. Comenzar un VI.
-. Explorador de Proyectos.
-. Partes de un VI.
-. Ventana del Panel Frontal.
-- Ventana del Diagrama de Bloque.
-. Paleta de Herramientas.
Instrumentos Virtuales (VI)
Los programas de LabVIEW son llamados Instrumentos Virtuales, o VIs, su

apariencia y funcionamiento imitan instrumentos físicos, tales como osciloscopios
multímetros, generadores, entre otros. LabVIEW contiene VIs con funciones para adquirir,
analizar, visualizar, almacenar datos y varias herramientas para ayudar a generar código de
programación. En este material se trabaja con aplicaciones basadas en la versión
LabVIEW 2016 (ver figura 2.1) y algunas herramientas desarrolladas en la versión
LabVIEW 2013.
11
Figura 2.1. Ventana de presentación LabVIEW 2016.
Comenzar un VI
Al iniciar cualquier versión del LabVIEW, aparece una ventana de introducción,

que despliega un menú de selección para crear nuevos VIs, Proyectos, abrir archivos,
ejemplos propios del programa, archivos de ayuda, entre otros. También puede acceder a
recursos del LabVIEW, tales como manuales, temas de ayuda y recursos en línea a través
del enlace https://www.ni.com. En la figura 2.2 se observa la ventana de introducción.
Figura 2.2. Ventana de introducción LabVIEW 2016.

12
Creación y apertura de un VI: Se puede comenzar un programa en LabVIEW partiendo

de los siguientes tres casos, un VI en blanco o Proyecto, un VI o Proyecto existente para
modificarlo y una plantilla a partir de la cual se puede utilizar para comenzar un nuevo VI
o Proyecto. Para abrir un VI nuevo, seleccione New VI de la opción File del menú principal
de la ventana de introducción y aparece los dos paneles de programación, que se requieren
para programar un VI, ambos paneles se observan en la figura 2.3.
Figura 2.3. Paneles de programación del LabVIEW.
Los paneles de programación corresponden a dos ventanas que por defecto tienen
los colores gris y blanco, ambos paneles se requieren para crear un VI, la ventana gris sirve
como interfaz de usuario del programa, la ventana blanca se utiliza como el editor del
código de programación del VI.
La creación de un VI a partir de una plantilla (figura 2.4) se puede realizar,

seleccionando de la opción File menú principal de la ventana de introducción el comando
New…, desplegando diferentes Vis ya programados que pueden ser modificados para
ajustarlo a las necesidades del usuario.
13
Figura 2.4. Selección de plantillas del LabVIEW.
Para guardar un nuevo VI, seleccione del menú principal de cualquiera de los panel
de programación, la opción File>>Save. Si el archivo ya está almacenado y fue
modificado, seleccione la opción Save As, para acceder al cuadro de diálogo de la figura
2.5. Desde el cuadro de diálogo se puede crear una copia de la VI o eliminar el VI original
y reemplazarlo con el nuevo, renombrarlo o duplicarlo en una nueva ruta o localización.
Figura 2.5. Guardar VI del LabVIEW.

14
Explorar Proyectos
Los proyectos son sistemas completos que pueden agregar diferentes VIs, ser usado
en red por diferentes usuarios, manejar variables compartidas entre diferentes programas,
enlazar y configurar el hardware que se utilice en los VI programados, entre otras
aplicaciones. Los VI son simples ventanas de programación que forman funciones que
pueden ser enlazadas en un proyecto o que pueden trabajar en forma independiente.
Cuándo se guarda un proyecto en LabVIEW se crea un archivo de proyecto

(.lvproj), que incluye referencias a los archivos del proyecto, información de configuración,
construcción e implementación. Aplicaciones avanzadas del uso de los proyectos, incluyen
la creación de bibliotecas compartidas, trabajar con LabVIEW Real-Time, que define
elementos de tiempo real (RT), o los módulos FPGA para compuertas programables o
asistente digital personal PDA.
Para abrir un nuevo proyecto desde la ventana de introducción, seleccione Create

Project en el menú de la ventana de introducción, aparece un nuevo menú que identifica
las distintas aplicaciones que se pueden programar en diferentes áreas y con presencia o
ausencia de hardware. Si lo que se desea es abrir un proyecto vacío, se selecciona la función
que se observa en la figura 2.6.
Figura 2.6. Ventana de crear proyecto en LabVIEW 2016.

15
Al crear un nuevo proyecto aparece la ventana explorador de proyectos como se

muestra en la figura 2.7, la cual incluye los siguientes elementos por defecto:
Proyecto de raíz: Contiene todos los elementos del explorador de proyectos, define la
etiqueta de proyecto raíz para asignar nombre de archivo para el proyecto.
Mi PC: Representa el equipo local como un elemento del proyecto.
Dependencias: Incluye ítem que requieres los Vis del proyecto.
Construir-Especificaciones: Incluye configuraciones fuentes para las Application
Builder, que permiten construir especificaciones para configurar aplicaciones
independientes y ejecutables, es decir, los archivos (.Exe), bibliotecas compartidas (Dll),
instaladores y archivos Zip.
Figura 2.7. Ventana del explorador de proyecto en LabVIEW.
Cuando se agrega elementos al proyecto, LabVIEW crea un elemento adicional en

la ventana del explorador de proyectos para representar el nuevo elemento. Cada elemento
también incluye las secciones dependencias y construir especificaciones.
Barras de herramientas del explorador de proyectos: Están conformadas por cuatro

barras de herramientas como en la figura 2.8, las cuales están definidas como: Standard,
Project, Build Specifications y Source Control. La herramientas estándar son los
16
elementos tradicionales de cualquier menú de herramientas, usadas para incluir elementos

al proyecto, la barra de proyectos son características particulares del proyecto actual, las
otras dos barras de herramientas se relacionan con los archivos ejecutables y con código
fuente de programación.
Figura 2.8. Menú de herramientas de la ventana del explorador de proyectos en LabVIEW.
Adición de elementos a un proyecto: Puede agregar diferentes elementos, aplicaciones,

VIs existentes a un proyecto, para ello se requiere seleccionar con el botón derecho del
mouse, la opción My Computer, de la ventana explorador de proyectos y agregar las
aplicaciones requeridas, tal como se observa en la figura 2.9.
Figura 2.9. Selección de aplicaciones del explorador de proyectos en LabVIEW.

17
Eliminar elementos de un proyecto: Se puede eliminar elementos de la ventana

explorador de proyectos de las siguientes maneras:
1. Haga clic en el elemento que desea eliminar y seleccione remover del proyecto.
2. Seleccione el elemento que desea eliminar y pulse <Supr>.
3. Seleccione el elemento que desea eliminar y haga clic en el botón eliminar en la
barra de herramientas estándar.
Guardar un proyecto: Puede guardar un proyecto de LabVIEW de las siguientes maneras:

1. Seleccione archivo »Guardar proyecto.
2. Seleccione proyecto »Guardar proyecto.
3. Haga clic derecho en el proyecto y seleccione guardar en el menú contextual.
4. Haga clic en el botón guardar proyecto de la barra de herramientas del proyecto,
debe guardar los archivos nuevos, no guardados en un proyecto antes de poder
guardar el proyecto.
Partes de un VI
Los VIs de LabVIEW, representan funciones de programación y visualización de

datos, contiene tres componentes principales: la ventana del Panel Frontal, el Diagrama de
Bloques, y el Panel de Icono o Conectores.
Ventana del Panel Frontal
Al abrir un nuevo o existente VI, aparece la ventana del Panel Frontal con un fondo
de color gris, sirve como interfaz de usuario para el VI, presenta una serie de elementos
que permiten trabajar cómodamente para crear el entorno gráfico del programa. Los
Elementos identificados en la pantalla de panel frontal son los siguientes:
1. Panel Frontal o Front Panel Windows: Es la ventana donde se ubican los objetos que
sirven de interfaz para ingresar datos y mostrar resultados al usuario. Es una pantalla de
color gris por defecto como se muestra en la figura 2.10, donde están las variables de
18
entrada y salida del programa, conocidas como controladores e indicadores y se pueden

manipular mecánicamente cuando estén ubicadas sobre el Panel Frontal y el programa esté
en modo de compilación.
Figura 2.10. Panel Frontal del VI de LabVIEW.
2. Barra de herramientas o Toolbar: Cada ventana del VI tiene una barra de herramientas
asociado con él. En la parte superior del Panel Frontal, aparecen una serie de botones que
conforman la barra de herramientas para ejecutar y editar los VIs. La figura 2.11 muestra
la barra de herramientas que aparece en la ventana del Panel Frontal.
Figura 2.11. Barra de herramientas del Panel Frontal del VI de LabVIEW.
En las tablas 2.1, 2.2 y 2.3 se observan cada uno de los elementos que conforman
la barra de herramientas, se hace una explicación detallada de la operación de cada Icono
y se muestra su respectiva imagen.
19
Tabla 2.1. Botón de ejecución Run.

Descripción Icono
Botón Run para ejecutar el VI. LabVIEW compila el VI, si es necesario. Puede
ejecutar un VI si el botón Run aparece como una flecha blanca, tal como se
muestra en la figura. La flecha blanca sólida indica también que se puede usar el
VI como un subVI si se crea un Panel Conector para el VI.
Botón Run mientras el VI se está ejecutando, el botón aparece como se muestra
en la figura de color negro y con unas secuencias que representan el movimiento
de la flecha.
Botón Run mientras se está ejecutando es un subVI, el botón Run aparece como
se muestra en la figura con un color blanco y línea negra y de forma secuencial
que refleje movimiento.
Botón Run cuando en el programa aparece un error o cualquier otro factor que no
lo deja ejecutar, la flecha aparece de color gris y rota, por lo general en el proceso
de edición del VI, mantiene esa imagen. Si ya se editó el programa y aún contiene
errores, el botón ejecutar todavía aparecerá roto y no se podrá ejecutar. Para esos
casos se hace clic en este botón Run, y el compilador automáticamente muestra
una ventana con la lista de todos los posibles errores y advertencias que no dejan
ejecutar el programa.
Botón Run Continuously, es usado para ejecutar el VI en forma continua hasta
que se detenga o se haga una pausa en la ejecución. La figura muestra una flecha
en forma cíclica en color blanco mientras no se active esta aplicación.
Botón Run Continuously, cuando se está ejecutando el VI en forma continua, La
figura muestra una flecha en forma cíclica en color negro indicando que está activa
la aplicación.
Tabla 2.2. Botón de pausa y detener Pause y Stop.

Descripción Icono
Botón Pause, si se hace clic en el botón pausa inmediatamente se detiene el
flujo de datos de un VI, LabVIEW destaca en la ventana del diagrama de
bloques la ubicación en la que quedo el flujo de información durante la
ejecución. El botón pausa aparece en rojo cuando está activo.
Botón Abort Execution, se utiliza para detener el VI cuando está en

ejecución. Si más de un VI están en ejecución, se atenúa el botón de detener
de los SubVI, quedando solo disponible el del VI principal, el cual al ser
activado detiene todos los demás subVIs. Debe tomar la precaución al utilizar
el botón detener, ya que detiene el VI inmediatamente, antes de que el VI
termina la iteración actual. Esto puede generar que se anule un VI que utiliza
recursos externos, como hardware, podría dejar los recursos en un estado
desconocido al no restablecer o liberar de manera adecuada el VI.
20
Tabla 2.3. Otras aplicaciones.

Descripción Icono
El Menú desplegable que se observa en la figura,
permite cambiar la configuración del texto
seleccionado en un VI, incluyendo la fuente, tamaño,
estilo y color.
Menú Align Objects se utiliza para alinear los objetos
a lo largo de los ejes, incluyendo borde vertical,
horizontal, superior, inferior izquierda y derecha.
Menú Distributes Objects, distribución espacial de

objetos de manera uniforme.
Menú Resize Objects, menú de selección para

cambiar el tamaño de varios objetos del panel frontal,
incluyendo cambiar objetos para configurarlos con el
mismo tamaño.
Menú Reorder, se utiliza para ordenar objetos que se

superponen entre sí y que se desea definir cuál es el
objeto que va en la parte de frente o la parte posterior
del panel.
Botón Search, utilizado como un buscador o
explorador para los diferentes archivos de ayuda del
LabVIEW o para abrir algún VI o SubVI, del
programa que se requiera en el instante.
Botón Show Context Help Window, es un enlace que

permite visualizar la ventana de ayudas textuales del
LabVIEW.
3. Paleta de Controles ó Controls Palette: Es una ventana de objetos que contiene todos
los elementos de datos de entrada o controles y los elementos de datos de salida o
indicadores gráficos, utilizados como interfaz para la transferencia de datos y la
presentación de la pantalla principal del programa, así como se muestra en la figura 2.12.
21
Figura 2.12. Paleta de controles del Panel Frontal del VI de LabVIEW.
Controles e indicadores: Se crea la ventana del Panel Frontal con controles e indicadores,
que son los terminales de entrada y salida interactivas de los VIs. Los controles son perillas,
botones, diales y otros dispositivos de entrada. Los indicadores son pantallas gráficas, Leds
y otros elementos.
Los controles simulan entrada de instrumentos, dispositivos y suministros de datos

al diagrama de bloques de los VIs. Los indicadores simulan dispositivos o instrumentos de
salida y muestra los datos que se generan en el diagrama de bloques de los VIs. Cada
control o indicador tiene un tipo de datos asociado con él, estos datos pueden ser numéricos,
booleanos, cadena de caracteres, entre otros.
Controles e indicadores numéricos: El dato numérico puede representar números de

diversos tipos, tales como entero, real, complejo. Los dos objetos numéricos comunes son
el control numérico y el indicador numérico, como se muestra en la Figura 2.13, para
introducir o cambiar los valores en un control numérico, se hace clic en el botón de
incremento y decremento, también con el cursor se hace doble clic sobre del número y se
introduce el nuevo valor.
22
Figura 2.13. Control e indicador numérico del LabVIEW.
A continuación se observa en la figura 2.14, el menú de los diferentes controles e

indicadores numéricos que presenta el LabVIEW en la Paleta de Control del Panel Frontal.
Figura 2.14. Paleta de controles e indicadores numéricos del LabVIEW.
Controles e indicadores booleanos: El tipo de datos booleanos se representa con sólo dos
valores, como verdadero (TRUE) y falso (FALSE), también se puede asumir como
encendido (ON) y apagado (OFF), en algebra booleano se puede hablar también de dos
valores lógicos 1 y 0. En la figura 2.15, se observan diferentes controladores e indicadores
booleanos. Los objetos booleanos simulan interruptores, botones pulsadores y Leds.
23
Figura 2.15. Controles e indicadores booleanos del LabVIEW.
A continuación se observa en la figura 2.16, el menú de los diferentes controles e

indicadores booleanos que presenta el LabVIEW en la Paleta de Control del Panel Frontal.
Figura 2.16. Paleta de los controles e indicadores booleanos del LabVIEW.
Controladores e indicadores cadena de caracteres: El tipo de datos cadena de caracteres

es una secuencia de caracteres ASCII. Se pueden utilizar controles de cadena para recibir
mensajes de texto desde el usuario, como un nombre de usuario o contraseña. Los objetos
de cadena más comunes son tablas y cuadros de entrada de texto, como se muestra en la
figura 2.17.
24
Figura 2.17. Controles e indicadores cadena de caracteres del LabVIEW.
A continuación se observa en la figura 2.18, el menú de los controles e indicadores

cadenas de caracteres que presenta el LabVIEW en la Paleta de Control del Panel Frontal.
Figura 2.18. Paleta de los controles e indicadores cadena de caracteres del LabVIEW.
Menús de Acceso Directo de controles e indicadores: Los objetos de LabVIEW están

asociados a los menús de Acceso Directo, se utilizan los elementos del menú para cambiar
la apariencia o comportamiento de los objetos del Panel Frontal y del Diagrama de Bloques.
Para acceder a dichos menús, se hace clic sobre el objeto como se muestra en la figura 2.19.
Figura 2.19. Menú de Acceso Directo de controles e indicadores del LabVIEW.

25
Cuadro de diálogo de las propiedades de un objeto: Los objetos en la ventana del Panel
Frontal tienen cuadros de diálogo de propiedades, se utilizan para cambiar la apariencia o
el comportamiento de los objetos. Al hacer clic en un objeto, se selecciona Properties en
el menú de acceso directo y se abre el cuadro de dialogo de propiedades, tal como se
observa en la figura 2.20. La mayoría de opciones son similares a las opciones disponibles
en el menú de acceso directo para dicho objeto.
Figura 2.20. Cuadro de diálogos de las propiedades de controles e indicadores del LabVIEW.
Ventana del Diagrama de Bloques
La ventana del Diagrama de Bloques de la figura 2.21 es la que contendrá el código

de programación de los diferentes VI, establece la interfaz entre los objetos que se
visualizan en el Panel Frontal y las funciones o comandos de programación. Los elementos
que forman el Diagrama de Bloques incluyen las terminales de los controladores e
indicadores del Panel Frontal, los subVIs o funciones personalizadas, las funciones de
programación propias de LabVIEW modificables y no modificables, los VI Express, las
constantes, estructuras cíclicas, propiedades de objetos de atributos de nodos
programables, variables locales, globales, cables o alambres de conexión para transferir
datos entre los diferentes bloques, entre otros elementos.
26
Figura 2.21. Ventana del Diagrama de Bloques del VI en LabVIEW.
Los terminales de controladores e indicadores en el Diagrama de Bloques: Cuando se

utiliza la palabra terminal en el Diagrama de Bloques, se referencia cualquier objeto del
Panel Frontal que pueda servir como entrada de datos o controlador (Input) y salida de
datos o indicador (Output), estos terminales se conectan o alambran con las diferentes
funciones de LabVIEW para establecer un proceso y generar resultados. La característica
distintiva de los terminales de los controladores con respecto a los indicadores es el borde
alrededor del terminal. Los controles tienen un borde grueso y los indicadores tienen un
borde fino. El terminal se puede visualizar con o sin vista del Icono. En la figura 2.22 se
observa terminales con Icono y sin Icono de cuatro tipos de variables diferentes.
Figura 2.22. Terminales indicadores y controladores.

27
Funciones de programación en el Diagrama de Bloques: Son bloques que tienen

Conectores de entradas y salidas de datos y son capaces de realizar operaciones específicas
cuando se está compilando un VI para generar resultados. Son similares a las funciones y
subrutinas en lenguajes de programación basados en texto y se pueden clasificar en:
Funciones propias de LabVIEW no modificables: Son propias del programa y no se

pueden editar, no presentan Panel Frontal ni Diagrama de Bloques y las mayorías se
observan de color amarillo.
Funciones propias de LabVIEW modificables: Son propias del programa y si se pueden

editar, representándolas comúnmente como Sub rutinas o SubVIs, al hacer doble clic sobre
la función abre un VI, con Panel Frontal y Diagrama de Bloques editables.
Funciones propias de LabVIEW VI Express: Son propias del programa y son

ejecutables no se puede ver su código fuente. Presentan Panel Frontal del programa en
compilación, pero no muestra un Diagrama de Bloque que permita visualizar el código de
programación. El VI Express aparece siempre de color azul claro, para diferenciarlo de las
demás funciones. Los VI Express también tienen la propiedad de expandir su bloque para
poder intercambiar datos de entrada y salida con el resto de las variables del VI.
Funciones propias de usuario o programador: Son creadas por el programador y pueden

ser editadas. Presentan Panel Frontal y Diagrama de Bloques, con el código de
programación definido por el usuario, se pueden clasificar también como SubVIs,
programados por el usuario. En la figura 2.23 se muestran algunas funciones de
programación.
28
Figura 2.23. Funciones de programación en el diagrama de bloques.
Cables o hilos de conexión: Los objetos del diagrama de bloques transfieren sus datos
través de cables o hilos de conexión. Los cables conectan los terminales de los
controladores e indicadores con las diferentes funciones. Cada cable tiene una única fuente
de datos, pero se puede cablear a muchos VIs y funciones que requieran el mismo tipo de
dato. Los cables son de diferentes colores, estilos, y espesores, dependiendo del tipo de
datos que a través de él circule. En la tabla 2.4 se observan diferentes tipos de datos y el
color y ancho del alambre asignado por el programa a cada dato.
Tabla 2.4. Hilos de conexión y tipo de datos.

Tipo de Dato Color Escalar Vector Matriz
Numérico Azul
Entero
Numérico Naranja
Real
Booleano Verde
Cadena de Rosa
Caracteres
Clouster Rosa
Datos Azul
Dinámicos
Cable roto Negro
29
Un cable roto aparece como una línea discontinua negra con una X roja en el medio,
los cables rotos ocurren por diferentes razones, por ejemplo, cuando se tratar de conectar
dos objetos con tipos de datos incompatibles o cuando la dimensión del dato tampoco
coincide, es decir, no puede cablear una salida de matriz a una entrada numérica o
viceversa. La dirección de los cables debe ser correctos, se debe conectar los cables a una
sola entrada y al menos una salida. Los hilos que se encuentran en líneas discontinuas, se
pueden eliminar por completo del Diagrama de Bloques seleccionando la tecla de acceso
directo CTRL B, LabVIEW automáticamente elimina todos los enlaces rotos o con errores.
Al mover un objeto seleccionado cerca de otros objetos en el diagrama de bloques,

LabVIEW dibuja automáticamente el cable y la aplica como conexión valida o muestra la
ruta de las posibles conexiones válidas, para que el usuario la seleccione. Cuando se suelta
el botón del puntero para colocar el objeto en el diagrama de bloques, LabVIEW conecta
automáticamente los cables. Para cablear objetos en forma manual se espera que el cursor
tenga la forma de cableado, la cual es semejante a un carrete de hilo, selecciona el terminal
a cablear y recorre el trayecto hasta el otro terminal o función a conectar. Se puede sacar
ramificaciones o nodos del cableado para llevarlos a otros objetos o terminales de salida.
El flujo de datos: Aparece en el diagrama de bloques, y es el método que utiliza LabVIEW,

para conectar y transferir información entre las funciones y los terminales conectados por
medio de hilos o cables. Las funciones se ejecutan cuando se han recibido todos los datos
de entrada necesarios y pueden producir datos de salida a otras funciones o terminales con
indicadores en el diagrama de bloques. El flujo de datos, se ejecuta desde la izquierda a
derecha, evaluando primero los controladores que introduzcan datos, luego estos datos
pasan a las respectivas funciones y finalmente las funciones arrojan resultados que se
pueden visualizar en los indicadores. El hilo de los datos conectados asume el mismo color
que el tipo de dato.
Ejemplo de Aplicación 1: Realizar una aplicación que convierta la temperatura de grados

Centígrados a grados Fahrenheit.
30
Desarrollo: El programa requiere de una variable de entrada o Input para introducir los
grados Centígrados, también requiere de una variable de salida Output para ver el valor de
temperatura en grados Fahrenheit. Para procesar los datos se requiere dos funciones
matemáticas suma y multiplicación que permitan hacer la conversión de grados de la
temperatura. En la ecuación 2.1 y 2.2 se observa el modo matemático para la conversión.
Definición de entradas y salidas:

Input = Centígrados (Variable numérica tipo entero).
OutPut = Fahrenheit (Variable numérica tipo entero).
Función:
℉= ∙ ℃ + 32 Ec. 2.1
Equivale a
℉ = 1,8 ∙ ℃ + 32 Ec. 2.2
Los controles e indicadores se pueden observar en el Panel Frontal y la ecuación de

conversión en el diagrama de bloques como se muestra en la figura 2.24, también se
observa los enlaces de los operadores con los respectivos terminales de entrada y salida de
datos. La dirección del flujo de datos a través de los alambres o hilos de conexión se da
desde los terminales controladores, hasta los terminales de los indicadores.
Figura 2.24. Panel Frontal y Diagrama de Bloques del Ejemplo de Aplicación 1.

31
Paleta de Funciones: Contiene las herramientas utilizadas para programar el VI en el

Diagrama de Bloques. Se accede desde el menú del Diagrama de Bloques, seleccionando
la opción View>>Functions Palette, también se ingresa colocando el cursor sobre la
página blanca del Diagrama de Bloques y haciendo clic en el botón derecho del ratón. La
Paleta de Funciones se divide en varias categorías, puede mostrar y ocultar categorías para
adaptarse a sus necesidades, tal como se muestra en la figura 2.2.
Figura 2.25. Paleta de Funciones del Diagrama de Bloques.
La figura 2.25 muestra el valor por defecto que presenta la Paleta de Funciones, al
seleccionar cualquier Icono o lista, se despliega un menú completo de funciones o VIs,
relacionados con el tema seleccionado, la ventana presenta una especie de anclaje en la
esquina superior del recuadro del menú, esto permite que una vez seleccionado el submenú,
pueda ser anclado y quedar completamente en dominio de la ventana. La Paleta de
Funciones presenta internamente un menú como lo muestra la figura 2.26, donde se puede
utilizar dos aplicaciones generales, la primera es la opción activa un buscador muy parecido
al explorador de Windows, que permite conseguir en forma directa funciones y controles
tanto para el Diagrama de Bloques como para el Panel Frontal.
32
Figura 2.26. Paleta de Funciones con el buscador de funciones.
La segunda opción de la Paleta de Funciones, muestra una serie de comandos

utilizados para la visualización de las funciones en cuatro categorías posibles, la categoría
tipo árbol, sólo texto, iconos y texto mezclado, solo iconos. Estas categorías se muestran
en la figura 2.27.
Figura 2.27. Formas de presentación de la Paleta de Funciones.
Barra de Herramientas del Diagrama de Bloques: De igual forma que en el Panel

Frontal, aparecen en el Diagrama de Bloques una serie de botones que conforman la barra
de herramientas
.
33
Figura 2.28. Barra de herramientas del Diagrama de Bloques.
Se puede observar que la barra de herramientas de la figura 2.28, presenta algunos

botones de ejecución que tienen la misma función de los explicados previamente en la
ventana del Panel Frontal. En la tabla 2.5, se explican los botones exclusivos del Diagrama
de Bloques, estos elementos son de gran utilidad para la depuración del programa, ya que
actúan en modo compilación, permitiendo un recorrido detallado de todos los elementos
que se estén ejecutando en el Diagrama de Bloques.
Tabla 2.5. Botón de ejecución de la barra de herramientas.

Descripción Icono
Botón Highlight Execution, Esta función permite una ejecución secuencial del
programa a baja velocidad de transmisión de datos. Se puede observar el flujo de
datos en el Diagrama de Bloques entre los diferentes terminales y las funciones,
mostrando los valores ejecutados sobre las líneas de cada cable. Cuando se hace
clic en el botón se activa el bombillo que aparece en la figura y el programa corre
lentamente en dicho modo. Para desactivar la ejecución se hace nuevamente clic
en el botón hasta que el bombillo se apague.
El Botón Retain Wire Values, la aplicación retiene los valores del cable en
diferentes puntos del flujo de datos durante la ejecución, de modo que cuando se
coloca un punto de prueba en el cable pueda retener inmediatamente el valor más
reciente de los datos que pasan por el cable. Debe ejecutar con éxito el VI al menos
una vez antes de que pueda retener los valores. Cuando se pone un punto de prueba
en el cable aparece un cuadro de dialogo, que muestra el valor donde se puso el
nodo o punto de prueba.
Los Botones Step Into, Step Over y Step Out se utilizan para correr los VIs en
modo paso a paso, el primer botón INTO, se usa para arrancar el flujo de datos en
los terminales de entrada y pone en pausa en programa, es decir, se ejecuta la
primera acción y se detiene en la próxima acción del VI. El botón OVER, da un
paso en la acción de ejecución del programa, adelanta el flujo de datos a la acción
siguiente y se pone en pausa esperando la siguiente activación. El botón OUT, se
usa para terminar de ejecutar el nodo actual y la pausa hasta que el VI termine de
ejecutarse y se atenúe el botón
El Botón Clean Up diagram, Esta aplicación ordena los elementos del
diagrama de bloques, los ubica en la parte superior izquierda de la pantalla,
recorta la longitud de los alambres definiendo los caminos más cortos y
ordenados para la conexión.
34
Paleta de Herramientas
Se utiliza para crear, modificar y depurar VIs. Es un modo de funcionamiento

especial del cursor de la computadora que permite cambiar su operación, dándole la figura
de un Icono correspondiente a la herramienta seleccionada. LabVIEW elige
automáticamente la herramienta basado en la ubicación del cursor, cuando la Paleta de
Herramientas está en modo automático. Para acceder a la paleta de herramientas se debe
ingresar al menú del Panel Frontal o Diagrama de Bloque la ruta View>>Tools Palette. En
la figura 2.29 se muestra la paleta de herramientas en modo manual y automático.
Figura 2.29. Paleta de herramientas en modo automático y manual.
Tabla 2.5. Elementos de la Paleta de Herramientas.

Descripción Icono
El Botón Operate Value, cuando el cursor se convierte en el Icono mostrado a la
izquierda, se está utilizando la herramienta valor de operación para activar todos
los controladores que están ubicados en el panel frontal.
El Botón Position/Size/Select, cuando el cursor del ratón se convierte en el Icono
mostrado en la figura, se está utilizando la herramienta
selección/tamaño/posición, para seleccionar, copiar, mover o eliminar un objeto
y poder cambia el tamaño de los objetos. Por ejemplo, en la imagen anterior
vamos a cambiar el tamaño de la perilla y seleccionar el interruptor para moverlo.
El Botón Edit Text, es una herramienta de etiquetado cuando el cursor asume el
Icono mostrado a la izquierda, Se utiliza para introducir valores en un controlador
o también para editar o crear etiquetas libres, esta herramienta también se puede
utilizar pare seleccionar un texto ya creado y cambiarle sus propiedades de forma.
35
El Led Verde que se observa encendido en la Paleta de Herramientas de la figura

2.29, indica que está trabajando en modo automático y LabVIEW seleccionará en forma
autónoma el cursor que requiera. Si el Led aparece apagado el usuario debe seleccionar en
forma manual cualquiera de las aplicaciones que necesita activar en el cursor. En las tablas
2.5 y 2.6 se describen todos los elementos de la paleta de herramientas.
Tabla 2.6. Otros elementos de la Paleta de Herramientas.

Descripción Icono
El Botón Connect Wire, es una herramienta de cableado que hace al cursor
asumir el Icono mostrado a la izquierda, esta herramienta se utiliza para conectar
los terminales de controladores e indicadores con las diferentes funciones de
programación en la ventana del Diagrama de Bloques. Cuando el ratón se
posiciona sobre el punto de un terminal de salida o de entrada o sobre un alambre,
el cursor accede automáticamente a la herramienta de cableado.
El Botón Automatic Tools Selection, permite acceder automáticamente a las
operaciones de, posicionamiento, etiquetado, y cableado directamente desde el
mismo cursor sin la necesidad de abrir la Paleta de Herramientas. Si el botón
aparece con un Led verde encendido está en modo automático y se puede acceder
a los elementos sin seleccionarlos de la barra de herramientas. Si el Led está
apagado está en modo manual y se debe seleccionar cada herramienta para
poderla utilizar o aplicar al programa.
El Botón Object Shortcut Menu, permite acceder al menú contextual de un
objeto.
El Botón Scroll Windows, permite el desplazamiento a través de las ventanas sin
utilizar las barras de desplazamiento.
El Botón Set/Clear Breakpoint, establece un punto de interrupción en los VIs,
entre los cableados que unen a las funciones con los terminales, detiene el
programa y se mantiene en pausa en dicho punto de interrupción.
Con los conocimientos hasta ahora vistos se requiere construir un VI que represente
las tareas más utilizadas en LabVIEW para los procesos de adquisición de datos en
ingeniería electrónica, recuerde que los VI del LabVIEW, son orientados a tareas de
adquisición y procesamiento de datos, para procesos reales. Utilice el Método de
Desarrollo de Software, para esta actividad.
Definir el problema: Se plantean el objetivo general y los objetivos específicos.

36
Objetivo general: Crear un VI simple que lleva a cabo la adquisición, análisis y

presentación de una variable física.
Objetivos específicos: Adquirir una onda sinusoidal durante un periodo de muestreo de
0,1 segundos, determinar y mostrar valor medio, registrar los datos, y mostrar la onda
sinusoidal en un gráfico.
Diseñar soluciones: Definir primero las entradas y salidas del problema y seguidamente
el diagrama de flujo (figura 2.30).
Input: La entrada para este problema es un canal analógico de una tarjeta de adquisición
de datos para recibir la onda sinusoidal.
Output: La salidas incluyen un gráfico de los datos sinusoidales y un archivo de registro
de los datos.
Diagrama de Flujos:
Figura 2.30. Diagrama de flujo de la Actividad Complementaria 2.
Aplicación: Desarrollo del programa.

37
Desarrollo: El programa presenta tres funciones de programación, las cuales, se explicaran

brevemente, ya que se está usando algunas aplicaciones sin haber profundizado en el
código de programación gráfica de LabVIEW:
1. Proceso de Adquisición de Datos: Utiliza una función VI Express de LabVIEW
para adquirir la onda sinusoidal con un período de muestreo de 0,1 segundos.
2. Configuración: Se configura la tarjeta de adquisición con los parámetros que
muestra el VI Express como se muestra en la figura 2.31, luego se define los
canales de la tarjeta de adquisición, los rangos de tensión, el tipo de señal,
muestras, frecuencia de muestreo, entre otros.
Figura 2.31. Vi Express y configuración de los parámetros del VI Express para adquisición de datos.
3. El VI Express es una función que se encarga de revisar la señal de entrada analógica de

un módulo de adquisición de datos, el cual para este caso se escogió el DAQ USB6001 de
la National Instruments, en la figura 2.32 se observan el diagrama de conexión y el
hardware seleccionado.
38
Figura 2.32. Hardware de la aplicación de adquisición de datos.
3. Análisis de datos: De nuevo se utiliza un VI Express, el cual calcula los datos

estadísticos de la señal sinusoidal, entre ellos su valor promedio. A continuación
en la figura 2.33 se observa el VI Express y su respectivo panel de configuración.
Figura 2.33. VI Express y sus parámetros de configuración, para calcular el valor promedio de la señal.
4. Proceso de Almacenamiento de Datos: Se procede a utilizar una función VI

Express, propia de LabVIEW para guardar datos en un archivo tipo texto (txt y
39
lvm) o Exel (xlxs). En la figura 2.34 se observa el VI Express y el panel de

configuración.
Figura 2.34. VI Express y su configuración, para generar un registro de la señal.
Prueba y verificación: Manejo de resultados.

Resultados: Los Datos se registraron en la dirección seleccionada en el panel de
configuración y con la extensión .lvm. El archivo se observa en la figura 2.35.
Figura 2.35. Tabla de datos adquiridos, con extensión .lvm.

40
En el Panel Frontal de la figura 2.36 se muestra dos controladores, uno tipo pantalla
para observar la señal adquirida en función del tiempo, y otro tipo numérico para ver su
valor promedio.
Figura 2.36. Panel Frontal de la Actividad Complementaria 2.
El código de programación, se observa el diagrama de conexión de los subVIs de

la figura 2.37, con sus respectivas funciones y terminales de entrada y salida.
Figura 2.37. Código de programación de la Actividad Complementaria 2.

41
Capítulo III
Solucionar problemas de depuración para programas en LabVIEW
Para ejecutar un VI, deben estar correctamente conectadas todas las funciones y
estructuras con los datos correctos en cada uno de los terminales, a veces se presentan
inconvenientes que no permiten la ejecución de la función o que un VI produzca datos
erróneos o inesperados. Cuando se presenten situaciones que dificulten la ejecución de los
VI, se puede configurar el LabVIEW para identificar los problemas que se presenten en la
ejecución y encontrarlos en el flujo de datos que pasa a través del Diagrama de Bloques.
En este capítulo se desarrollan temas relacionados con las utilidades de ayuda del
LabVIEW y los mecanismos de depuración de programas para solucionar los
inconvenientes de no ejecución de un VI. Los temas a desglosar son los siguientes:
-. Utilidad de la ayuda del LabVIEW.
-. Corrección de los VI rotos o Broken VIs.
-. Técnicas de Depuración.
-. Verificación y tratamiento de Errores.
Utilidades de la ayuda del LabVIEW
LabVIEW utiliza diferentes formatos de ayuda para permitir al usuario identificar

las funciones y terminales ubicadas en las paletas de funciones y controles del programa,
permite revisar las bases teóricas de cada elemento y editar o modificar rutinas de
programación que trae en forma depurada el LabVIEW. A Continuación se procede a
identificar cada uno de los enlaces de ayuda que maneja el programa.
42
Show Context Help: Es una opción que se encuentra en el menú de ayuda del LabVIEW,
muestra información básica de cada objeto o función, con tan sólo mover el cursor sobre
el objeto, está disponible en las ventanas del Panel Frontal y Diagrama de Bloques. Hay
dos formas de acceder al Show Context Help, una es a través de un icono ubicado en las
paletas de herramientas del Panel Frontal y Diagrama de Bloques como se muestra en la
figura 3.1; la otra es a través del menú de ayuda o pulsando <Ctrl-H> para acceso directo.
Figura 3.1. Modos de acceso al Show Context Help.
La ventana Show Context Help abre un cuadro de dialogo que muestra un Icono
para subVIs, funciones, constantes, controles e indicadores, la ventana despliega
información textual con el nombre de los terminales, tipo de datos y una breve explicación
de la aplicaciones del objeto seleccionado, esta ventana se observa en la figura 3.2.
Figura 3.2. Ejemplo de la ventana del Show Context Help.

43
En la parte inferior de la ventana del Show Context Help, se pueden observar tres
Iconos que tienen las funciones explicadas en la tabla 3.1:
Tabla 3.1. Iconos de la ventana Show Context Help.

Descripción Icono
Show Optional Terminal, es un botón que se utiliza para mostrar terminales
ocultos y la ruta donde se encuentra el menú de ayuda que se está desplegando.
El botón Lock, se utiliza para bloquear el contenido actual de la ventana de ayuda

de contexto. Cuando el contenido se bloquea, al mover el cursor sobre otro objeto
no cambia el contenido de la ventana.
El botón Detailed Help permite acceder a la base de datos del LabVIEW Help,
que corresponde a una gran base de datos con toda la información detallada de
las funciones y terminales del programa.
LabVIEW Help: La ventana LabVIEW Help del menú de ayuda del LabVIEW, disponible
en las ventanas del Panel Frontal y del Diagrama de Bloques, como se muestra en la figura
3.3. Con esta ayuda se puede acceder a una gran base de datos que describe detalladamente
cada función con sus terminales de entrada y salida y algunos ejemplos.
Figura 3.3. Acceso al LabVIEW Help.
El LabVIEW Help, genera los siguientes recursos: Recursos de documentación en

línea que se pueden imprimir, documentos para ayudar a los nuevos usuarios y
experimentados. Incluyendo PDF, versiones de todos los manuales de LabVIEW y recursos
de apoyo técnico en el sitio Web de National Instruments. En la figura 3.4 se muestra la
base de datos de LabVIEW help.
44
Figura 3.4. Base de datos del LabVIEW Help.
NI Example Finder: Se encuentra disponible en el menú de ayuda del LabVIEW, con esta
ayuda se accede a una gran base de datos formada por problemas o subVIs ejecutables que
abarcan las diferentes áreas de conocimiento que maneja el LabVIEW. La figura 3.5
muestra la ventana que contiene la opción para acceder a los ejemplos de LabVIEW.
Figura 3.5. Acceso al NI Example Finder.
En la opción Find Examples se encuentra un gran número de problemas resueltos

con su respectivo código de programación, que le permite al usuario editarlos y
modificarlos para ajustarlos a sus requerimientos, también se puede acceder a ejemplos de
45
VIs en línea a través de su página Web. En la figura 3.6 se observa el menú del NI Example
Finder con los diferentes programas por contenido que se encuentran archivados en el
LabVIEW.
Figura 3.6. Ventana del NI Example Finder.
Web Resources: El acceso a los recursos Web para buscar manuales del hardware y del
software, se puede hacer desde el menú de ayuda del LabVIEW. Ejemplos de VIs, soporte
técnico, productos, cursos y eventos en los que se pueden acceder desde está función. La
figura 3.7 muestra la ventana que contiene esta opción.
Figura 3.7. Acceso al NI Web Resources.

46
El programa le direcciona al siguiente URL http://www.ni.com/support/esa/, la cual

inmediatamente le accede a todas las aplicaciones ofertadas por la empresa fabricante. En
la figura 3.8 se muestra algunos productos que oferta la empresa NI además del soporte
técnico.
Figura 3.8. Acceso a la página web del NI Web Resources.
Corrección de los Broken VI o VI rotos
Si un VI no se ejecuta, el botón de compilar se coloca de color gris oscuro y la

flecha aparece rota. Esto ocurre cuando hay errores presentes que limitan la ejecución del
VI, normalmente pueden ser errores por una mala conexión. Si el botón todavía aparece
roto cuando se completa todo el cableado del diagrama de bloques, se debe verificar otras
posibles causas del VI.
Las advertencias no detienen la ejecución del VI, pero los errores si rompen la
ejecución del VI, se deben corregir los errores antes de poder activar la función. Cuando el
botón Run está roto se puede hacer clic sobre él y aparece una ventana como la figura 3.9
llamada Error list, que contiene la lista de las posibles advertencias y errores del programa.
47
Figura 3.9. Ventana del Error list.
La ventana permite identificar el error, lo describe y plantea la causa para buscar

solución, también tiene una ventana adicional donde detalla y explica la codificación del
error. Si se hace clic en la lista del error o en el botón de mostrar error, el programa
inmediatamente salta al Diagrama de Bloques y selecciona la ruta donde está ocurriendo
cada error, en la figura 3.10 se observa un error generado por error en el cableado y es
encontrado por la selección del error en la ventana Error list.
Figura 3.10. Ejemplo de un error identificado por el Error list.

48
La lista de errores muestra todos los errores que se presenten en un VI, incluyendo
los SubVI que estén dentro del VI. La sección de errores muestra los nombres de todos los
elementos que estén en memoria y que tienen errores. Si dos o más elementos tienen el
mismo nombre, esta sección atiende la aplicación específica para cada elemento. La
sección de errores y advertencias enumeran los errores y advertencias en el VI, así facilita
la selección de cada elemento que presente error.
Causas comunes del Broken VI: La siguiente lista contiene las razones más comunes por
las que un VI se rompe o impide su ejecución:
• Alambre o cable suelto sin conectar
• El Diagrama de Bloques contiene un cable roto debido a una posible conexión entre
diferentes tipos de datos.
• Un terminal de una función del diagrama requiere conexión y está sin conexión.
• Datos inadecuados conectados a un terminal de una función.
• Un subVI mal editado y que se guardó con error.
• Uno de las razones anteriores ubicada dentro del subVI, que es llamado en el VI
principal.
Técnicas de Depuración
Si un VI no está roto, pero se obtiene datos inesperados, puede utilizar las siguientes
técnicas para identificar y corregir problemas en el Diagrama de Bloques del VI:
Variables de Error de las funciones: La mayoría de funciones propias del LabVIEW,

manejan terminales de entrada y salida para detectar errores internos de las funciones, por
lo tanto, se debe conectar este parámetro de error a cada función que lo requiera y
conectarle un indicador que permita visualizar donde y que tipo de error ocurre. También
se puede utilizar estos parámetros de error en los VIs personalizados o programados por el
usuario. En la figura 3.11, se observa los terminales de error de un VI de LabVIEW.
49
Figura 3.11. Ejemplo de los terminales de error de una función.
Botón Highlight Execution: Es un botón de la barra de herramientas del Diagrama de

Bloques, que permite una ejecución secuencial del programa a baja velocidad de
transmisión de datos. Se puede observar el flujo de datos en el Diagrama de Bloques entre
los diferentes terminales y las funciones, mostrando los valores ejecutados sobre las líneas
de cada cable y poder detectar el error. En la figura 3.12, se observa el botón Highlight
Execution, ubicado en la barra de herramientas del Diagrama de Bloques.
Figura 3.12. Botón Highlight Execution.
Ventana de Context Help: Se utiliza para comprobar los valores por defecto para cada
función y subVI en el Diagrama de Bloques, está aplicación ya fue explicada en
previamente en este capítulo. En la figura 3.13, se observa el botón Show Context Help,
ubicado en la barra de herramientas del Diagrama de Bloques y del Panel Frontal.
Figura 3.13. Botón Show Context Help.
Los Botones Step Into, Step Over y Step Out: Utilice estas opciones para correr los VIs
en modo paso a paso, el programa se ejecuta función por función y así se poder detectar el
error del VI. En la figura 3.14, se observa el botón Step Into, Step Over y Step Out, ubicado
en la barra de herramientas del Diagrama de Bloques.
50
Figura 3.14. Botones Step Into, Step Over y Step Out.
Botón Probe Data: Función de la Paleta de Herramientas, usado para probar los valores
de datos en cualquier punto del alambrado y definir si existen datos inesperados. En la
figura 3.15, se observa el botón Probe Data, ubicado en la paleta de herramientas.
Figura 3.15. Botón Probe Data.
Valores indefinidos o inesperados: Determinar si los datos que una función envía al
programa, son indefinidos o inesperados, esto sucede a menudo con los valores numéricos.
Los datos no definidos, aparecen en el programa como NaN (no número), el cual representa
un valor de punto flotante no válido, operaciones como la raíz cuadrada de un número
negativo pueden producen este tipo de dato. Inf (infinito) representa un valor de punto
flotante no válido, por ejemplo, la división de un número por cero. Las representaciones de
estos datos están en conformidad con la norma estándar IEEE 754, para aritmética binaria
de punto flotante. En la figura 3.16, se observan los indicadores numéricos con los
mensajes correspondientes a datos indefinidos.
Figura 3.16. Controladores numéricos con datos indefinidos.

51
Representación numérica de los controles e indicadores: Es necesario comprobar la

coincidencia en la representación numérica de terminales de entrada y salida, por ejemplo
evitar conexión de números de punto flotante con números enteros o viceversa ya que la
representación puede modificar el dato esperado.
Determinar lazos cerrados: Un lazo cerrado inadvertidamente puedan ejecutar cero

iteraciones y producir matrices vacías que se considera un error.
Prueba del orden de los elementos de un Cluster en los puntos de origen y destino: los
Cluster son un arreglo de datos de diferentes tipos, el cual se detallará en capítulos
posteriores, sin embargo los elementos que los componen deben coincidir en el orden que
fueron generados.
Verificar inicialización de un Shift register: Es una función que almacena valores de

lazos repetitivos para usarlos en ciclos siguientes. Este punto se tocará en capítulos
posteriores, sin embargo su no inicialización es una fuente de error.
Verificación y tratamiento de Errores
Verificar errores es primordial para establecer la buena operación del programa, se

debe asegurar que la aplicación procese correctamente los datos y genere soluciones
lógicas. Si se presentan resultados que provienen de errores, el programa debe tener la
capacidad de tratar todos los errores definiendo su origen, causa y consecuencias. No
importa qué tan seguro se está del procedimiento de un VI, no se puede predecir los
problemas que pueda encontrar el usuario, es por ello que se requiere de un mecanismo
para comprobar errores, el cual defina la razón de la generación de estos.
Gestión automática de errores: Cada error tiene un código numérico y un mensaje de

error correspondiente, por defecto LabVIEW maneja automáticamente cualquier error, si
un VI se ejecuta y presenta el error, el programa suspende inmediatamente la ejecución
52
destacando el subVI o la función donde el error se generó y muestra un cuadro de diálogo

de los posibles errores y advertencias. Para deshabilitar o habilitar nuevamente el manejo
automático de errores en un VI, se debe seleccionar desde el Panel Frontal o Diagrama de
Bloques la siguiente ruta File »VI Properties o CTRL L y seleccionar las opciones de
Ejecución del VI, tal como se observa en la figura 3.17. Las propiedades de ejecución
muestran por defecto la activación de la función corregir automáticamente los errores, si
se desea deshabilitar debe cambiar la opción.
Figura 3.17. Selección de la gestión automática o manual de errores.
Para desactivar la manipulación automática de errores o eliminar los diálogos de

referencia de los errores, debe acceder a la siguiente ruta Tools»Opcions y seleccionar de
la lista de menú la propiedad Diagrama de Bloques. En la figura 3.18, se observa un cuadro
de dialogo para manipular las opciones para el manejo de errores.
53
Figura 3.18. Opción de la configuración del manejo de errores.
Control manual de errores: Se puede seleccionar otros métodos de manejo de errores,

LabVIEW permite llevar las decisiones del manejo de los errores al Diagrama de Bloques
del VI, además se puede utilizar elementos de la paleta de funciones del Diagrama de
Bloques como en la figura 3.19, que permiten detectar errores y crear diálogo de errores
personalizados que puedan ser vistos por el usuario.
Figura 3.19. Paleta de funciones para el manejo de errores programados por el usuario.
Los VIs o funciones devuelven errores de las formas: El error identificado en un

código numérico y el error representado en una estructura de Cluster de error. Típicamente
las funciones utilizan códigos de errores numéricos, en la figura 3.20, se observa la ayuda
de LabVIEW que nos permite identificar el manejo de los códigos de error.
54
Figura 3.20. Menú de ayuda del LabVIEW para identificar código de errores.
Los Cluster de error son estructuras que manejan tres tipos de datos (numérico,
booleano y cadena de caracteres) para tratar en forma manual los errores de cada función
de programación y así identificar donde está su ocurrencia. Se plantea una estructura que
utilice como error de entrada a la función (Error IN) y una estructura que se utiliza como
error de salida de la función (Error OUT), si ocurre el error dentro de la función los datos
del Cluster cambian y manda la información requerida para tratar el error. En las figura
3.21, se puede ver para una determinada función los Cluster de error de entrada y salida.
Figura 3.21. Cluster de error de entrada y salida de una función.
Casi todas las funciones que utilizan I/O, entradas y salidas de datos con hardware,
manejan este tipo de estructura para retornar la información de los errores. Los errores en
un Cluster pueden incluir comprobación del error en operaciones especiales (Registro de
datos, comunicación serial, adquisición de datos, entre otros), y proporcionar un
mecanismo para controlar los errores apropiadamente. Los componentes que forman el
Cluster de error son los siguientes:
55
• Estado o Status, es un valor booleano que informa con un TRUE si se ha producido un

error. Su valor por defecto es FALSE.
• Código o Code, es un entero de 32 bits que identifica el error numéricamente. El código
de error por defecto es igual a cero.
• La fuente ó Source, es una cadena que identifica dónde se produjo el error.
A medida que el VI se ejecuta, pasa el Cluster de error de una función a otra. Si

LabVIEW no encuentra ningún error, la función se ejecuta normalmente. Si LabVIEW
detecta un error, el Cluster cambia de información y el error pasa a la entrada de la siguiente
función, sin ejecutar esa parte del código.
Revisar el desarrollo del siguiente VI y generar los procedimientos para verificar y

corregir errores. Utilice el Método de Desarrollo de Software, para esta actividad.
Definir el problema: Generar un programa, prueba de errores.VI, que tiene una serie de
errores que el usuario debe detectar y corregir usando las herramientas explicadas en este
capítulo. A continuación se observa en la figura 3.22, el Panel Frontal y el Diagrama de
Bloques del programa.
Figura 3.22. Panel Frontal y Diagrama de Bloques del programa prueba de errores.
56
Diseñar soluciones: Utilizar las técnicas de depuración de errores.
Aplicación: En el VI se observa que el botón de correr está roto, es decir, modo Broken,
por lo tanto presenta errores y no se puede ejecutar. En el programa se ve dos indicadores
un control y dos funciones propias del LabVIEW y un SubVI. También se puede ver que
hay enlaces rotos. Para permitir que LabVIEW detecte los errores en modo automático, se
procede hacer clic en el botón de correr y debe aparecer el cuadro de dialogo de la lista de
errores como aparece en la figura 3.23.
Figura 3.23. Ventana de lista de errores de la Actividad Complementaria 3.
Se observa una lista de errores presente en el subVI, apareciendo un cuadro que

detalla el error y en algunos casos con sugerencias para corregir. Se selecciona uno de los
errores de la lista, al hacer doble clic sobre el error, el programa se traslada al Diagrama de
Bloques y sobresalta el error identificado, así como se muestra en la figura 3.24.
57
Figura 3.24. Identificar error en el Diagrama de Bloques, seleccionado de la lista de errores.
Repitiendo el paso anterior, se corrigen cada uno de los errores que presenta el VI.
El primer error del Error list, resalta el SubVI llamado raíz prueba errores.vi, se hace
doble clic sobre el subVI y se observa el Panel Frontal y Diagrama de Bloques para detectar
el error, así como se muestra en la figura 3.25.
Figura 3.25. Identificar error del subVI.
También aparece el botón correr modo roto, por lo que se repite el procedimiento
de definir la lista de errores, pero ahora dentro del subVI. Una vez corregido el error el
botón de correr del SubVI retorna a su estado de operación normal (figura 3.26).
58
Figura 3.26. Corregir error del subVI.
En la figura 3.27 se presenta un error y muestra que la función de multiplicar no

presenta uno de sus dos terminales conectado, por lo que se procede a conectar el terminal.
Figura 3.27. Corregir segundo error del VI.
El tercer error se observa en la salida del operador de multiplicar, el resultado no

fue conectado a un terminal de un indicador sino de un controlador. Proceda a cambiar el
59
controlador por un indicador. Se puede seleccionar el terminal del controlador en el

diagrama y hacer clic con el botón derecho como aparece en la figura 3.28, ver el menú de
propiedades del terminal y buscar la propiedad que dice cambiar a indicador.
Figura 3.28. Corregir tercer error del subVI, cambiar controlador a indicador.
Se observa nuevamente en el Diagrama de Bloques, se verifica la conexión de los

cables que faltaban y se revisan los botones de ejecutar para verificar que el programa se
puede compilar en la forma adecuada.
Prueba y verificación: Proceda a compilar el programa y sométalo a prueba de datos para

verificar si existen algunos otros errores o advertencias (Figura 3.29).
Figura 3.29. Programa con todos los errores corregidos.

60
La figura 3.29 muestra el programa funcionando correctamente, asume un número

aleatorio, lo multiplica por 10, le suma 100 y le calcula la raíz cuadrada. Se recomienda
utilizar las herramientas del diagrama de bloque de ejecución lenta y de paso a paso, como
se observa en la figura 3.30, para poder ver con detalle el flujo de los datos.
Figura 3.30. Programa corriendo en modo Highlight Execution.

61
Capítulo IV
Implementar un Instrumento Virtual VI
Este capítulo presenta los fundamentos para implementar el código gráfico en

LabVIEW y diseñar un VI. Se realiza un recorrido por los diferentes conceptos definidos
en los capítulos anteriores, para llegar al diseño de una interfaz de usuario, se define el uso
de los diferentes tipos de datos y su procesamiento, las características, propiedades y
atributos de los diferentes controladores e indicadores y finalmente se procede a crear un
primer ejemplo de programación en LabVIEW, para una aplicación de procesamiento de
datos usado en los procesos reales de Ingeniería. Los temas a desarrollar son los siguientes:
-Diseñar la ventana del Panel Frontal.
-Tipos de datos de LabVIEW
-Código LabVIEW.
-Actividad Complementaria 4.
Diseñar la Ventana del Panel Frontal
En la fase de diseño lo primero que se debe identificar son las entradas y salidas del
problema. Esta identificación conduce directamente al diseño de la ventana del Panel
Frontal, recuerde que el Panel Frontal es la interfaz de usuario del programa. Se puede
identificar las entradas de datos del problema partiendo de las siguientes condiciones:
• Datos provenientes de una tarjeta de adquisición de datos.
• Datos provenientes de un archivo o base de datos.
• Datos introducidos por el usuario al manipular los controles del Panel Frontal.
Se Puede identificar las salidas de datos del problema partiendo de las siguientes
condiciones:
• Datos que se envían a una tarjeta de adquisición de datos.
62
• Datos que se registran en un archivo o base de datos.

• Datos visualizados por el usuario en los diferentes indicadores del Panel Frontal.
Se observa que los controladores e indicadores representan los elementos

fundamentales para interactuar con el usuario, a continuación se describe los diferentes
tipos de datos que se utilizan en los elementos de entrada y salida.
Tipo de datos en LabVIEW
Existen muchos tipos de datos que se pueden trabajar en LabVIEW, los datos más
comunes están representados por los valores numéricos, booleanos y las cadenas de
caracteres. Cada tipo de dato se relaciona con un color específico y contienen una gama
amplia de elementos que establecen las interfaces con el usuario. Los elementos se pueden
clasificar en controles e indicadores y se ubican en el Panel Frontal, cada elemento genera
un terminal en el Diagrama de Bloques, con el mismo color que representa el tipo de dato,
los controladores e indicadores se diferencian según el tipo de dato, para los elementos
básicos los datos numéricos, representan números de diversos tipos, pueden ser enteros,
reales y complejos con diferentes representaciones. Estos elementos se encuentran en la
Paleta de Control del Panel Frontal, observada en la figura 4.1, en el submenú Modern.
Los controles e indicadores van desde displays sencillos, hasta instrumentos de medición
básicos como: Tanques, termómetros, metros, barras de desplazamiento, intensidad de
color, perillas, entre otros.
Figura 4.1. Panel Frontal submenú Modern.

63
En la figura 4.2, se observan algunos controladores e indicadores numéricos

ubicados en el Panel Frontal.
Figura 4.2. Controladores e indicadores numéricos.
El tipo de dato booleano representa solo variable de dos estados o niveles posibles.
Estos niveles LabVIEW los asume como verdadero y falso. Cada controlador puede asumir
diferentes representaciones según la acción mecánica que se le programe. Estos elementos
se encuentran en la Paleta de Control del Panel Frontal en el submenú Modern, van desde
interruptores, pulsadores, botones, Leds, entre otros. En la figura 4.3, se observan algunos
controladores e indicadores booleanos ubicados en el panel frontal.
Figura 4.3. Controladores e indicadores booleanos.
El tipo de dato cadena de caracteres o string, son cualquier tipo de carácter que
abarca letras, números, símbolos, entre otros. Cada controlador o indicador puede asumir
diferentes representaciones según el formato que se le asigne en sus propiedades. Estos
elementos se encuentran en la Paleta de Control del Panel Frontal en el submenú Modern,
64
los controles e indicadores van desde líneas de texto, path o enrutadores, entre otros. En la
figura 4.4, se observan algunos controladores e indicadores de cadenas de caracteres
ubicados en el Panel Frontal.
Figura 4.4. Controladores e indicadores cadena de caracteres.
Algunos datos se presentan en forma combinada, tal es el caso de los datos tipo
Enum y Ring, es una combinación de tipo de datos numéricos enteros con cadenas de
caracteres y pueden representar una lista de valores. Los controladores Enum se consiguen
en la Paleta de Control opción Modern, incluyen menú y listas desplegables para ingresar
caracteres y retornan al Diagrama de Bloques un número entero. Para editar los campos de
un Enum, se selecciona el controlador se va a las propiedades del mismo y selecciona la
opción edit ítem. En la figura 4.5, se observa como editar el ítem de un Enum para un
ejemplo de un controlador que representa los días de la semana y cada día representa un
número entero.
Figura 4.5. Controladores Enum y su configuración.

65
Datos dinámicos: El tipo de datos dinámico almacena la información generada o adquirida

por un VI Express como se muestra en la figura 4.6. Los VI Express son funciones sin
código interno, es decir VI ejecutables que presentan un panel de configuración. El tipo de
datos dinámicos aparece como un terminal de color azul oscuro. La mayoría de los VI
Express aceptan y retornan datos dinámicos, puede conectar el tipo de datos dinámicos a
cualquier indicador o entrada que acepte valor numérico, forma de onda, o datos booleanos.
Figura 4.6. Datos dinámicos.
La mayoría de los VIs y funciones en LabVIEW no aceptan los datos dinámicos,

para utilizar dichos datos en estos VIs o funciones, se debe utilizar un convertidor de dato
dinámico a tipo de dato común y viceversa. Se utiliza el convertidor Dynamic Data
Express VI para convertir los datos dinámicos a datos tipo numérico, booleanos, gráficos,
vectores y matrices. El convertidor se consigue en la paleta de funciones, funciones Express
y se busca la función Signal Manipulation, seleccionando los convertidores que se
muestran en la figura 4.7.
Figura 4.7. Convertidores de datos dinámicos o datos normales y viceversa.

66
Cuando se selecciona el convertidor de datos dinámicos a datos normales, aparece

el cuadro de diálogo que se observa en la figura 4.8, donde se muestra las opciones que
permiten especificar el formato de los datos y definir la estructura en que se van a presentar.
Figura 4.8. Convertidores de datos dinámicos o datos normales.
Cuando la conversión se realiza de datos normales a dinámicos, también se presenta

un cuadro de dialogo como se muestra en la figura 4.9, el cual permite configurar la
conversión para generar datos dinámicos.
Figura 4.9. Convertidores de datos normales a datos dinámicos.

67
En el ejemplo de la figura 4.10, se observa cómo se utiliza el convertidor de datos

para llevar una señal sinusoidal generada por un VI Express a un vector numérico.
Figura 4.10. Ejemplo de los convertidores de datos dinámicos.
Utilidad de los controles e indicadores: Al elegir los controles e indicadores, se debe

verificar que son los adecuados para el tipo de dato o tarea que desea realizar, por ejemplo,
cuando se quiere determinar la velocidad de un motor se utiliza un indicador de velocidad
numérico como se muestra en la figura 4.11, con su respectivo terminal con el color que
referencia el tipo de dato.
Figura 4.11. Ejemplo de indicador de velocidad.
Cada controlador dependiendo del tipo de aplicación, va estar acompañado de una

escala que define el rango de valores de operación y también de una etiqueta para darle
nombre al elemento. Las etiquetas ayudan al usuario a identificar la función del control e
indicador, también permite identificar el terminal del elemento en el Diagrama de Bloques.
A parte de la etiqueta, cada elemento presenta un subtítulo llamado Caption, el cual ayuda
a describir con detalle el control o indicador solamente en el Panel Frontal.
68
Se configura los valores predeterminados para los controles, por ejemplo, si

requiere que un controlador cuando inicie el programa tenga un valor diferente de cero, se
asigna el valor que requiere el controlador e ingresar en el menú del Panel Frontal la opción
Edit »Make Selected Values Default, se guarda los cambios y el controlador asume el
nuevo valor por defecto. El controlador de la figura 4.10, se configura para que arranque
por defecto con el valor de 4, así como muestra la figura 4.12.
Figura 4.12. Ejemplo de indicador de velocidad con valor inicial y menú de configuración.
Cada control e indicador posee diferentes elementos que se pueden ver o no en el

Panel Frontal y en el Diagrama de Bloques, si se ubica el cursor sobre el controlador, y se
hace clic en el botón derecho, aparece un menú desplegable donde están todas las funciones
y propiedades de ese control, ver figura 4.13. La primera línea de ese menú, presenta las
diferentes etiquetas que se pueden anexar al control en el Panel Frontal.
Figura 4.13. Menú desplegable de las propiedades del controlador seleccionado.
Funciones y propiedades de los controladores: El menú que se despliega sobre el

controlador describe las propiedades de funcionalidad y apariencia del mismo, para el
ejemplo del controlador de velocidad se observan propiedades como label, que da la
69
etiqueta o nombre al controlador. Caption, es un subtítulo para dar una descripción del
control. Unit Label, da la unidad física que va llevar el controlador. Digital Display,
muestra el valor del controlador en un control numérico. Ramp le agrega una barra de
intensidad de color al controlador. En la figura 4.14 se ve el controlador, con algunas de
las funciones seleccionadas.
Figura 4.14. Algunas propiedades del controlador seleccionado.
En el menú desplegable, se encuentran otras funciones como Find Terminal, al

seleccionar esa aplicación el programa salta al terminal del diagrama de bloques. Change
to Control, Cambia un control a indicador o viceversa. La aplicación Make Type Def, es
una opción para editar y configura el controlador cambiando algunas de sus características
por defecto. Al seleccionar dicha aplicación, se crea un subVI configurable del controlador
que permite modificar las propiedades incluso agregar imágenes que no pertenezcan al
LabVIEW. En la figura 4.15, se observa el panel de configuración de esta opción y la
imagen que asume el controlador en el diagrama de bloques.
Figura 4.15. Venta de configuración del controlador con Make Type Def y su terminal.
70
La función Description and Tip, agrega un texto para describir el controlador y un

mensaje corto que aparece en el cursor cuando se coloca sobre el objeto del panel frontal.
Tal como de observa en la figura 4.16 con el mensaje “CONTROLADOR DIGITAL”.
Figura 4.16. Vista sobre el controlador del mensaje incluido en la función Description and Tip.
La función Replace, se utiliza para remplazar un objeto por otro objeto del panel.
Data Operation, utiliza un menú que contiene los valores por defecto para reiniciarlos o
cambiarlos. Advanced, abre un menú de funciones relacionadas con configuración de las
teclas de navegación, enlaces directos, visibilidad del controlador, entre otros. Las
funciones Fit Control y Scale Object, escalan objetos del panel, son atributos del
controlador, que ajustan las dimensiones del controlador a la pantalla del Panel Frontal y
establecer unas líneas de marca para centrar el objeto con respecto a otros elementos.
Algunos atributos de la ventana de propiedades del controlador, son de uso

específico de ese control, ya que dependen de su funcionalidad, por ejemplo el atributo
Add Needle, añade una ajuga extra a un controlador, tal como se observa en la figura 4.17.
Figura 4.17. Función Add Needle, ´para el controlador seleccionado.

71
La función Create, permite al controlador crear los siguientes elementos: Variable

local, referencia, propiedad de nodo e invocar un nodo. A continuación se observa en la
tabla 4.1 la explicación de cada uno de los atributos que se le anexan al controlador.
Tabla 4.1. Función Create.

Descripción Icono
Variable local: es una copia del terminal del controlador o indicador que
se crea en el diagrama de bloques y que genera una réplica del valor que
asume el controlador o indicador, sin estar conectado al mismo.
Referencia: Devuelve una referencia del VI actual, de un controlador o

indicador del VI. Se utiliza esta referencia para acceder a las propiedades
del VI, control o indicador asociado.
Propiedad de Nodo: Establece todas las propiedades de formato del

objeto, enlaza el controlador o indicador a un gran número de
propiedades dando la posibilidad de manipularlas dentro del diagrama
de bloques, por ejemplo, el atributo Visible, si se modifica puede
cambiar el controlador de visible a invisible, solo cambiando el valor
booleano del atributo de Verdadero a Falso.
Invoke Node: Invoca un método o una acción sobre una referencia. La

mayoría de los métodos o acciones tienen asociado varios parámetros.
La función Representation. Establece la representación en dígitos que utiliza la

variable del controlador, es una propiedad que varía según el tipo de controlador. Para los
valores de representación numérica se tienen disponible diferentes opciones dependiendo
del rango de operación de los datos y su capacidad, para el caso de los datos booleanos
dependen de su accionar mecánico, y para los datos tipo cadena de caracteres también se
72
definen diferentes formatos de ingreso. A continuación se presentan las tablas 4.2, 4.3, 4.4
y 4.5, que describen todas las representaciones de los diferentes tipos de datos.
Tabla 4.2. Representación de datos numéricos reales y complejos.

Terminal Dato Bit de Dígitos Rango
Numérico Almacenamiento decimal Aproximado
Precisión 32 6 número positivo mínimo y máximo:

simple, 1.40e-45 y 3.40e + 38
punto número negativo mínimo y máximo:
flotante -1.40e-45 y -3.40e + 38
Precisión 64 15 número positivo mínimo y máximo:

doble, 4.94e-324 y 1,79E + 308
flotante -4.94e-324 y -1.79e + 308
Precisión 64 15 a 20 número positivo mínimo y máximo:

extendida, 6.48e-4966 y 1.19e + 4932
flotante -6.48e-4966 y -1.19e + 4932
Complejo 64 6 Para cada parte tanto la real e

de imaginaria tiene:
precisión número positivo mínimo y máximo:
simple, 1.40e-45 y 3.40e + 38
flotante -1.40e-45 y -3.40e + 38
Complejo 128 15 Para cada parte tanto la real e

doble, 4.94e-324 y 1,79E + 308
flotante -4.94e-324 y -1.79e + 308
Complejo 256 15 a 20 Para cada parte tanto la real e

extendida, 6.48e-4966 y 1.19e + 4932
flotante -6.48e-4966 y -1.19e + 4932
73
Tabla 4.3. Representación de datos numéricos enteros.

Terminal Dato Bit de Dígitos Rango
Numérico Almacenamiento Decimal Aproximado
Punto fijo 64, o 72 si Varía según Varía según configuración de

incluye un estado configuración usuario
de desborde de usuario
Byte 8 2 –128 a 127

entero con
signo
palabra 16 4 –32.768 a 32.767

entero con
signo
Largo 32 9 –2.147.483.648 a 2.147.483.647

entero con
signo
cuadrado 64 18 –1e19 to 1e19

entero con
signo
byte entero 8 2 0 a 255

sin signo
palabra 16 4 0 a 65.535
entero sin
signo
largo 32 9 0 a 4.294.967.295
entero sin
signo
cuadrado 64 19 0 a 2e19
entero sin
signo
128-bit 128 19 Tiempo mínimo: 01/01/1600

marca de 00:00:00 UTC
tiempo tiempo máximo: 01/01/3001
00:00:00 UTC
74
Tabla 4.4. Representación de datos booleanos por acción mecánica.

Terminal Descripción
switch when pressed: Cambiar cuando se pulsa. Cambia el estado del botón de
pulsación y permanece allí hasta que de nuevo pulse el botón.
switch when released: Cambiar cuando se libera. Cambia el estado de liberación del
botón. Permanece allí hasta que el botón sea de nuevo liberado.
Switch until released: Cambiar hasta que sea liberado. Cambiar el estado del botón
cuando se pulsa, y cambia el estado nuevamente cuando se suelta el botón.
Latch when pressed: Enganchar cuando se pulsa: cambio de estado en la pulsación

de botón y cambiar de nuevo cuando el control es leído por LabVIEW.
Latch when released: Enganchar cuando se libera. Cambio de estado de liberación

del botón y lo regresa de nuevo cuando el control es leído por LabVIEW.
Latch until released: Enganchar hasta que sea liberado. Cambiar el estado con la
pulsación del botón y cambia de nuevo cuando se libera y es leído por LabVIEW.
Tabla 4.5. Representación de cadena de caracteres.

Tipo de Descripción Ejemplo
Visualización
Normal Representación normal de “Ejemplo prueba caracteres 123*+-”
Display cualquier tipo de carácter usado
en los controles de LabVIEW
‘\’ Codes Muestra los códigos de barra “C:\Users\Edwin\Desktop\LabVIEW\Libro
Display invertida para todos los LAB”
caracteres. Usados en
direccionamiento.
Password Muestra un asterisco (*) para “********************”
Display cada carácter incluyendo
espacios.
Hex Display Muestra el valor ASCII de cada “5468 6572 6520 6172 6520
carácter en hexadecimal. 666F 7572 2064 6973 706C 6179
2074”
Cada variable presenta un menú de opciones que definen sus propiedades

características, y que se puede acceder al hacer clic derecho sobre la variable y seleccionar
75
la opción Properties. En la figura 4.18, se presenta la ventana de propiedades para un

controlador tipo numérico y se describen algunas de sus funciones:
Figura 4.18. Ventana de propiedades del controlador numérico.
Apariencia: Son las propiedades que modifican la forma en que se visualiza el controlador
en el panel frontal
Tipo de datos y entrada de datos: Ya se describió anteriormente, se presentan 16

formatos para los datos y establece los rangos de operación de datos para los controles e
indicadores.
Formato de visualización: Representa las propiedades de visualización de los datos, para

el caso numérico indica la notación, el número de dígitos, precisión, entre otros.
Documentación: Incluye comentarios y mensajes sobre el controlador
Enlace de datos: El enlace de datos permite enlazar llamadas a datos externos.

76
Editor de Menú: Existe otro formato para ingresar y manejar datos en el programa, el
Edit Menú (Figura 4.19), se presenta como una mezcla de un Enum y un string, se encarga
de generar controladores de tipo menú en el Panel Frontal, y los transfiere al diagrama de
bloques como una cadena de caracteres en una variable definida como Item Tag. El editor
es una herramienta del LabVIEW para personalizar el menú del Panel Frontal, esta es una
forma de presentar las funciones de forma más ordenada y utilizando menos espacio,
también permite crear accesos directos del teclado para los elementos del menú. Para crear
el menú, y que se active en el momento que se ejecute el VI, se debe hacer el procedimiento
que se desarrollará en el siguiente ejemplo:
Ejemplo de Aplicación 2: Crear un ejemplo de un menú personalizado que contenga la

información que se presenta en la tabla 4.6:
Tabla 4.6. Ejemplo Aplicación 2, editor de menú.

Operaciones Aplicaciones Opciones
Suma Ctrl+S Guardar Ayuda
Resta Abrir Ctrl+A Ejemplos Ctrl+E
Multiplicación Cerrar
División Ctrl+D Salir
Desarrollo: Se van a ejecutar una serie de pasos para aprender a utilizar la herramienta
Edit Menu, es una aplicación que trae LabVIEW para estructurar el menú de la misma
forma que se presentan en cualquier aplicación de software. A continuación se define el
algoritmo a seguir.
1. Hacer clic en el siguiente enlace del editor de menú del Panel Frontal del VI a programar
Edit»Run-Time Menu.
2. Al seleccionar Run-Time Menu, aparece la ventana de configuración del editor de menú

que se observa en la figura 4.19.
77
Figura 4.19. Ventana del editor de menú.
3. El editor tiene establecido por defecto el menú activo del Panel Frontal, para personalizar
el menú cambie en la barra de herramientas en el editor, la opción default por custom.
4. Para proceder a crear el menú del ejemplo, se procede a formar columna por columna.
La primera columna tiene como cabecera el titulo Operaciones, se introduce ese título en
la ventana principal en blanco del editor de menú, tal como se muestra en la figura 4.20.
5. Después de introducir el título, seleccionar el botón de la barra de herramientas con el

símbolo (+), para saltar de línea. Como la siguiente línea es un subtítulo, va dentro del
menú opciones, se debe presionar el botón de la flecha amarilla que se orienta a la derecha,
para crear un tabulador que indique que la próxima palabra va dentro del menú opciones.
Figura 4.20. Introduciendo los campos del menú.
6. En los bloques del lado derecho del editor, hay cuatro campos que deben ser llenados e
indican la propiedad de cada línea del menú o Item, la figura 4.21 muestra estos campos.
78
El primer campo indica el tipo de Item, el segundo el nombre del Item en el menú, para el
caso de ejemplo debe ser Suma, el tercer campo el Item Tag, este campo representa el
caracter o string que el menú le va a pasar al Diagrama de Bloques del VI cuando sea
seleccionado. Aparecen también dos bloques de selección Enable para ver si el menú está
habilitado y Checked equivalente al símbolo (√). También aparece el campo shortcut, para
seleccionar la tecla de enlace directo.
Figura 4.21. Configurando las opciones de selección del editor de menú.
7. Se procede a llenar las otras líneas del menú siguiendo el mismo procedimiento. En la
barra Preview, se puede ver cómo va quedando el menú, como se muestra en la figura 4.22.
Figura 4.22. Aplicación incluida en el editor de menú.

79
8. Finalmente se guardar en el disco duro con la extensión Run Time Menu (*.rtm), para
el ejemplo prueba.rtm. Una vez guardado el programa, el sistema pregunta si desea
guardar y enlazar al VI actual, el usuario debe hacer clic en aceptar.
Pruebas y Resultados: Una vez enlazado el menú al VI, se procede a compilar el

programa y se verifica que el menú debe aparecer ligado al Panel Frontal, como se observa
en la figura 4.23.
Figura 4.23. Vista del menú del Ejemplo de Aplicación 2.
Código en LabVIEW
A continuación se establecen los criterios de programación que se han venido

estudiando, para desarrollar un programa en LabVIEW que permita identificar el uso de
las ventanas de Panel Frontal, Diagrama de Bloques, controladores, indicadores, flujo de
datos y algunas funciones de procesamiento para los tres tipos de datos básicos. A lo largo
de este material, se va a utilizar el Método de Desarrollo de Software, estudiado en el
capítulo I, para abordar cualquier problema planteado y poder desarrollar el programa en
código gráfico. Se puede resumir los pasos necesarios para realizar un programa:
Definir el problema: Se plantean el objetivo general y los objetivos específicos.

80
Diseñar soluciones: Definir entrada INPUTS y salidas OUTPUTS del problema, se puede
acompañar de pasos o algoritmos, diagrama de flujos, o diagrama de transición de eventos.
Aplicación: Desarrollo del programa, generar código en LabVIEW.
Prueba y verificación: Pruebas, resultados, mantenimiento y actualización el programa.
Para Generar Código LabVIEW, se debe crear la ventana del Panel Frontal con los
elementos que van a representar las entradas y salidas del sistema. En la ventana del
Diagrama de Bloques se plantean los procedimientos a seguir en el programa y la ubicación
de las funciones o comandos de programación. Acá se debe establecer enlaces entre los
terminales formados por los elementos del Panel Frontal y las diferentes funciones de
programación.
Desarrollar un programa que monitoree e identifique las fallas de un proceso de

medición de temperatura. Se basa en desarrollar el primer VI, aplicando el código de
programación LabVIEW y las aplicaciones vistas hasta este capítulo.
Definir el problema: Crear un programa que detecte un nivel bajo y un nivel alto de
temperatura, en un rango definido por un usuario y que genere una advertencia a través de
un mensaje textual en un indicador y que un led muestre un alto en el momento de la falla.
Diseñar soluciones: Se van a manejar los recursos de identificar las entradas INPUTS y
salidas OUTPUTS de datos, para ello se genera una tabla de identificación de variables,
así como se observa en la tabla 4.7. La figura 4.24, muestra como recurso opcional el
diagrama de flujos para estructurar el programa.
81
Tabla 4.7. Identificar INPUTS y OUTPUTS.

Nombre Función Tipo de Propiedad
dato
Temperatura INPUT Control Numérico
Real punto flotante
Valores de 0 a 200 °C
Temperatura Máxima INPUT Control Numérico Real punto flotante
Temperatura Mínima INPUT Control Numérico Real punto flotante
Advertencia Texto OUTPUT Indicador Cadena de Normal Display
caracteres Valores:
- Temperatura Normal.
- Temperatura Alta.
- Temperatura Baja.
Advertencia Led OUTPUT Indicador Booleano Indicador Tipo Led.
Valores:
ON ROJO.
OFF VERDE.
Diagrama de flujo:
Figura 4.24. Diagramas de flujo de la Actividad Complementaria 4.

82
Aplicación: Lo primero que se va diseñar es la ventana del Panel Frontal, se procede a

buscar tres controladores numéricos para la temperatura y los valores máximos y mínimos
de temperatura. Para los mensajes de salida se ubican indicadores tipo string o cadenas de
caracteres, donde se representan los mensajes de temperatura alta y baja y un indicador
booleano tipo Led que mostrara su activación en rojo cada vez que se presenten valores de
temperatura fuera del rango de operación normal y se mantiene en verde si no se presenta
la activación de la alarma. En la figura 4.25, se observa el Panel Frontal de la aplicación.
Figura 4.25. Panel Frontal del problema de medición de temperatura.
En el diagrama de programación se debe conectar cada uno de los terminales a las

funciones que cumplan con las operaciones reflejadas en el Diagrama de Bloques, Se
utilizan en el código de programación, las funciones de selección basadas en operaciones
de comparación mayor ¿qué? o menor ¿qué?, esto se puede comparar a un estructura IF
THEN, ELSE, en un lenguaje de programación tipo texto.
Para hacer la selección y comparación utilizamos de la Paleta de Funciones, el

submenú comparadores y se extrae las funciones de la tabla 4.8:
83
Tabla 4.8. Funciones utilizadas en la Actividad Complementaria 4.

Función Definición de la función
Menor ¿qué?: Se utiliza para comparar dos variables y decidir cuál
es la menor. Su salida es booleana y se activa en alto si se cumple
la condición.
Mayor ¿qué?: Se utiliza para comparar dos variables y decidir cuál
es la mayor. Su salida es booleana y se activa en alto si se cumple
la condición.
SELECT: Se utiliza para decidir cuál de dos variables de entrada
se va a ver reflejada en la salida. Presenta una variable de control
booleano, que dependiendo de su nivel refleja a la salida una u otra
variable, es parecido al funcionamiento de un multiplexor en
dispositivos electrónicos digitales.
Diferente ¿qué?: Se utiliza para comparar dos variables y decidir
si son diferentes. Su salida es booleana y se activa en alto si se
cumple la condición.
Según el algoritmo y las funciones de código de LabVIEW, se tiene el Diagrama

de Bloques de la figura 4.26:
Figura 4.26. Diagrama de Bloques y código de programación.
Prueba y verificación: Verificar el programa para valores de temperatura que estén en un

rango de 0 a 100 °C, se establece como temperatura mínima 10°C y como temperatura
máxima 90°C, se prueban valores que activen las alarmas, como se muestra en la figura
4.27.
84
Figura 4.27. Pruebas del problema de aplicación.

85
Capítulo V
Temporizadores y Gráficas de señales en los VI
En este capítulo, se estudian los temporizadores para control de tiempo y retardos

programados en LabVIEW. También se definen las funciones gráficas de LabVIEW, dando
explicación detallada sobre los indicadores de forma de onda y todos sus elementos de
configuración, para mejorar la visualización. . Los temas a desarrollar son los siguientes:
-.Temporizadores en los VIs.
-. Gráficas de datos en LabVIEW.
-. Control de Imágenes 3D.
Temporizadores en los VIs
Controlan el tiempo de ejecución de una función o laso repetitivo, introduce

intervalos de tiempo entre ciclo y ciclo, por ejemplo, para generar pulsos en una tarjeta de
adquisición de datos, con una determinada frecuencia, estableciendo el tiempo de envió de
datos de cada pulso y sus ciclos de trabajo. También para recibir información de una señal
analógica en una tarjeta de adquisición de datos con un número de muestras por intervalo
de tiempo, se debe recurrir nuevamente a los temporizadores para controlar la ejecución.
Funciones de espera: Permiten que el VI se detenga por el intervalo de tiempo que defina
la función. Ayuda al procesador realizar otras tareas durante el tiempo de espera, dichas
funciones utilizan el reloj en milisegundo del sistema operativo del computador. Para
ubicar las funciones de espera se accede a la paleta de funciones del Diagrama de Bloques
y seleccionar las funciones de temporización Timing, como se observa en la figura 5.1, en
las tabla 5.1 y 5.2, se presenta la explicación de las funciones de temporización más
utilizadas en LabVIEW.
86
Figura 5.1 Funciones de temporización desde la paleta de funciones del Diagrama de Bloques.
Tabla 5.1. Funciones de temporización.

Wait Until Next ms Multiple: La función supervisa un contador en

milisegundos y espera hasta que el contador de milisegundos alcanza un
múltiplo de la cantidad que se le especifique. La función se utiliza para
sincronizar actividades y tiempo de ejecución de un lazo.
Wait: Es una función de espera en milisegundos que activa un contador y
espera que él llegue a la cantidad especificada como dato de entrada. Esta
función garantiza que un ciclo se ejecute en un tiempo muy cercano a la
entrada que se especifique.
Tick Count: Devuelve el valor que utiliza el temporizador para los
milisegundos al terminar la ejecución de un lazo o una función.
Time Delay Express: Se
comporta similar a la
función de Wait, pero con la
pantalla de ejecución de un
VI Express y con retardos
programados en segundos.
Elapsed Time: El tiempo

transcurrido indica la
cantidad de tiempo que
transcurre después de una
hora de inicio especificada.
Este VI permite que no se
pierda tiempo y que el VI se
continúe ejecutando.
87
Tabla 5.2. Funciones de temporización fecha y horas.

Get Date/Time String: Convierte un valor de referencia de tiempo o un valor

numérico a una cadena de caracteres que define la fecha y hora en la zona
horaria configurada para el equipo. Tiene varios formatos para retornar los
parámetros de fecha y tiempo requeridos por el usuario.
Get Date/Time In Seconds: Devuelve registro de tiempo de hora actual.

Calcula el registro de tiempo utilizando el número de segundos transcurridos
desde 12:00a.m, Viernes, 01 de enero 1904, como Tiempo Universal.
Seconds To Date / Time: Convierte un valor de registro de tiempo o un valor
numérico a un grupo de valores de tiempo.
Date / Time To Seconds: Convierte un grupo de valores de tiempo a un valor

de registro de tiempo o un valor numérico.
Format Date/Time String: Muestra un valor de registro de tiempo o un valor

numérico, con el formato que se especifique mediante una serie de códigos de
formato de tiempo.
Gráficas de datos en LabVIEW
En el área de Electrónica se procesa muchos datos que representan señales o formas

de onda, la cual requiere de representación gráfica para poder entender mejor su
comportamiento. A continuación se detallan las gráficas adecuadas para señales de uso en
electrónica Analógica y Digital. Se citan y explican los gráficos, WaveFormChart,
WaveFormGraph, XYGraph, Intensity Chart, Intensity Graph, Digital
WaveFormGraph, Mix Signal Graph, 2D Graph y 3D Graph. En la figura 5.2 se observa
la paleta de control seleccionando los diferentes elementos gráficos de LabVIEW, se le
asigna un número a cada gráfico para proceder a su respectiva explicación.
88
Figura 5.2 Funciones gráficas desde la paleta de control del Panel Frontal.
WaveFormChart (1): Es un indicador numérico gráfico, utilizado para mostrar datos

muestreados a una determinada velocidad. En este indicador se visualizan más de una
gráfica, acepta datos en forma escalar o como vectores y matrices para un determinado
número de muestras, mantiene un historial de datos, a partir de las actualizaciones
anteriores. La longitud del historial del gráfico es de 1.024 puntos de datos. La frecuencia
de envío de los datos al gráfico determina la frecuencia de la señal en el gráfico. En la
figura 5.3, se observa el indicador WaveFormChart y los elementos que lo conforman.
Figura 5.3 Gráfica de forma de onda WaveFormChart.

89
Los elementos del gráfico, se visualizan, al hacer clic derecho sobre la imagen en
el menú Visibles Item. A continuación se explican las operaciones de cada elemento.
Etiqueta (Label): Define el nombre del indicador gráfico.
Leyenda del Gráfico (Plot Legend): Define las características de visualización de la señal
a graficar, permite cambiar el color, añadir señales al indicador, tipo de línea, ancho y punto
de la señal, tipo de gráfico, entre otros. Para añadir señales, se expande el cuadro de leyenda
del gráfico. Sobre cada gráfica se puede cambiar todas sus características en forma
independiente, haciendo clic sobre la respectiva gráfica. Presenta diferentes modos de
presentación, por ejemplo, para trabajar con dos señales una blanca que se observe en forma
continua y otra roja que se observe con puntos discretos, se accede al menú de cada señal
y ajusta los parámetros de color y estilo de punto, como se ve en la figura 5.4.
Figura 5.4. Gráfica de forma de onda WaveFormChart, para dos señales con su leyenda.
Indicador digital (Digital Display): Muestra el último valor numérico recibido en el

indicador gráfico, utiliza indicador numérico de punto flotante para mostrar el valor real.
Leyenda de la Escala (Scale Legend): Establece propiedades que corresponde a las

coordenadas del gráfico, define etiquetas, escala, numero de muestras, entre otras
propiedades de coordenadas X,Y. Añade rejillas de diferentes colores a las componentes
X,Y. En la figura 5.5, se muestra una señal con escala y rejillas.
90
Figura 5.5. Gráfica de forma de onda WaveFormChart, para una señal con escala y rejillas.
Paleta de la Gráfica (Graph Palette): Presenta un conjunto de funciones para aumentar,

disminuir, o trasladarse a lo largo de la pantalla de la señal. Sirve para analizar algunas
regiones de la pantalla y visualizar en forma aumentada los valores de la señal, como se
observa en la figura 5.6.
Figura 5.6. Gráfica WaveFormChart, con la paleta de la gráfica.
Escala X y Y: Representan los valores de amplitud, muestras y la señal respectivamente.
Barra de desplazamiento X: Permite desplazar la señal a lo largo del eje X, cuando el

número de muestras supera el campo estándar de 1024.
Advanced»Update Mode: Permite configurar el modo de actualización para mostrar

nuevos datos. Se selecciona el menú del gráfico y se busca la opción, se observan tres
modos utilizados para visualizar datos:
91
Strip Chart: Registra datos de forma similar como ocurre en una banda de cinta de papel,
desplazándo continuamente de izquierda a derecha. Es el modo por defecto, ver figura 5.7.
Scope Chart: Desplaza el gráfico de izquierda a derecha, para cada nuevo valor va trazando
el valor nuevo a la derecha del último valor. Cuando la trama alcanza el borde derecho del
área de la pantalla de trazado, se borra la trama y comienza de nuevo el trazado desde la
izquierda, ver figura 5.7. La pantalla hace el barrido de forma similar a un osciloscopio.
Sweep Chart: Trabaja similar al Scope Chart, excepto que muestra los primeros datos en
la derecha y los nuevos en la izquierda, separados por una línea vertical roja, ver figura 5.7.
Figura 5.7. Modos de visualización del gráfico WaveFormChart.
Para Realizar gráficos múltiples, los datos se pueden agrupar en valores numéricos
escalares, donde cada valor numérico representa un solo punto para cada una de las
gráficas. Esto se puede realizar a través de un enlace llamado Bundle, ubicado en el
Diagrama de Bloques y utilizado para estructuras de datos definidos como Cluster. Si se
quiere pasar múltiples puntos por un gráfico, se debe cablear los valores numéricos como
vectores y agrupar con la función Bundle, en la figura 5.8 se muestra esta función. Los
Cluster y la función Bundle se explicaran con detalles en un capítulo posterior.
Figura 5.8. Función Bundle, utilizada para múltiples gráficas.

92
WaveFormGraph (2): El gráfico de forma de onda muestra una o más graficas de

mediciones uniformemente muestreados. Representa las funciones de la forma y=f (x), con
puntos distribuidos a lo largo del eje x, tales como adquisición de señales variables en el
tiempo. En la figura 5.9, se observa en el Panel Frontal un indicador gráfico de
WaveFormGraph.
Figura 5.9. Indicador Gráfico WaveFormGraph.
El indicador gráfico WaveFormGraph, presenta las mismas aplicaciones que el

indicador WaveFormChart, pero trae opcionalmente la rejilla en la pantalla divididas en
macro rejillas con una línea más gruesa en color verde por defecto y mini rejillas con una
línea más delgada y un color verde menos intenso, cada macro rejilla está dividida por
cuatro bloques formados por la mini rejilla tanto en el eje X como en el Y.
También tiene otra función opcional, utilizada para el manejo de cursores, en la

figura 5.9, se puede ver que el indicador gráfico incluye una ventana donde define la
leyenda del cursor dando los puntos exactos de X y Y que correspondan a la selección
tomada por el cursor. El cursor se representa en la pantalla con dos líneas amarillas que
interceptan el punto en estudio, para mover el cursor se agrega un botón extra que al hacer
clip permite orientar las líneas amarillas del cursor en pantalla.
93
WaveformGraph para una sola señal: Acepta varios tipos de datos para graficar una sola
señal. El gráfico acepta un vector de varios valores y los interpreta como los datos que
corresponden a los puntos de la gráfica, incrementa automáticamente el índice X partiendo
de X = 0. El gráfico también acepta un Cluster que contenga un valor inicial de X o un ΔX
y el grupo de datos correspondientes a Y. También acepta formas de onda con datos de
tiempo que incluyan la hora de inicio y un Δt.
WaveformGraph para múltiples señales: El gráfico acepta varios tipos de datos para la
visualización de múltiples señales, acepta una matriz con los valores en donde cada fila de
la matriz es una sola señal. Si se hace la matriz transpuesta cada columna pasa a tener los
datos de la señal. El gráfico interpreta los datos como puntos de la señal e incrementa el
índice X de uno en uno comenzando en X = 0. El gráfico también acepta un Cluster con
un valor inicial de X un ΔX y una matriz 2D de datos de Y. El gráfico interpreta los datos
de la matriz Y como los puntos de la señal e incrementa el índice X por ΔX a partir del
valor inicial de X. Este tipo de datos es útil para la visualización de múltiples señales que
se muestrean a la misma frecuencia.
WaveformGraph para datos dinámicos: Acepta datos dinámicos, lo que permite que se
utilice como indicador gráfico de los VI Express. Los datos dinámicos incluyen la
información asociada con la señal y con atributos que pueden definir el nombre de la señal,
la fecha y hora que fue adquirida, entre otros. Cuando el dato dinámico incluye un simple
valor numérico, el gráfico representa el valor simple y automáticamente da formato a la
escala X como marca de tiempo. También acepta datos dinámicos cuando se procesan
múltiples señales. Cuando el tipo de datos dinámico incluye múltiples señales, el gráfico
muestra cada una de las señales simples y automáticamente da formato a la leyenda de la
escala X para todas las señales.
Gráficos XY (3): Permite graficar funciones representadas por un conjunto de puntos

agrupados de manera uniforme o no incluidos en la muestra. El gráfico XY muestra señales
que contienen cualquier número de puntos, también acepta varios tipos de datos, puede
94
aceptar un Cluster que contenga un vector X y un vector Y, para introducir los datos de
cada coordenada. También acepta una arreglo de puntos, donde un punto es un Cluster que
contiene un valor de X y un valor Y. El gráfico XY acepta un arreglo de datos complejos
en los que la parte real se traza en el eje X y la parte imaginaria se traza en el eje Y. La
figura 5.10 muestra un ejemplo de indicador gráfico XY, para el caso de una sola señal.
Figura 5.10. Indicador Gráfico XY para una sola señal.
Grafico XY para múltiples señales: El gráfico XY acepta un arreglo de señales, donde

cada señal es un Cluster, que contiene un arreglo de X y un arreglo de Y. También acepta
una arreglo de Cluster de señales, donde cada señal es un arreglo de puntos y cada punto
es un Cluster, que contiene un valor de X y un valor Y. También acepta un arreglo de
Cluster para datos complejos, en los que la parte real se traza en el eje X, y la parte
imaginaria se traza en el eje Y. La figura 5.11, muestra un ejemplo de gráfico XY para
múltiples señales.
Figura 5.11. Indicador Gráfico XY para múltiples señales.

95
Gráficos XY para datos dinámicos (4): LabVIEW presenta un VI Express igual al de la

figura 5.12, correspondiente a la construcción de un gráfico XY, solicita como datos de
entradas los valores dinámicos de X y de Y, y genera la salida en el indicador clásico del
modo XY, ya sea para una o múltiples señales.
Figura 5.12. VI Express del Gráfico XY.
Gráficos de intensidad Graph y Chart (5 y 6): Se utiliza la gráfica intensidad para mostrar
datos 3D en un plano 2D, mediante la colocación de bloques de color en el plano cartesiano,
por ejemplo, puede utilizar un gráfico de intensidad para mostrar los datos que modelen
patrones de temperatura y relieve de un terreno donde la magnitud representa la altitud. El
gráfico de la intensidad acepta una matriz 3D de números, cada número en la matriz
representa un color específico. Los índices de los elementos de la matriz 2D dan los lugares
de la trama de los colores, tal como se observa en el ejemplo de la figura 5.13.
Figura 5.13. Trama de colores de un gráfico de intensidad.

96
Gráfico de intensidad Chart (5): Después de trazar un bloque de datos en un gráfico de

intensidad, el origen del plano cartesiano se desplaza a la derecha del último bloque de
datos. Cuando se procesan datos nuevos, los valores de los nuevos datos aparecen a la
derecha de los valores de los datos antiguos. Este comportamiento es similar al
comportamiento de un WaveFormChart. En la figura 5.14, se muestra un gráfico de
intensidad chart.
Figura 5.14. Ejemplo de un gráfico de intensidad Chart.
Gráfico de intensidad Graph (6): El gráfico de intensidad Graph trabaja igual que el
gráfico de intensidad Chart, excepto que no conserva los valores de datos anteriores y no
incluye los modos de actualización, ver figura 5.15.
Figura 5.15. Ejemplo de un gráfico de intensidad Graph.

97
Los colores por defecto que trae el grafico de intensidad es la escala que va del
blanco al negro pasando por las diferentes tonalidades de azul. Se puede cambiar el color
del gráfico de intensidad modificando los atributos del eje Z, el cual define la coordenada
del color del gráfico. Se puede crear la propiedad de nodo del gráfico en el Diagrama de
Bloques, con la función de atributo que se observa en la figura 5.16.
Figura 5.16. Atributo del eje Z de un gráfico de intensidad.
El atributo permite cambiar los colores del gráfico de intensidad seleccionando

entre la amplia gama de colores que maneja el LabVIEW, el cual se muestra en la figura
5.17 e identificados por un parámetro numérico.
Figura 5.17. Panel frontal manipulando el atributo Z de un gráfico de intensidad.
Graficas de señales Digitales (Digital Waveform Graphs) (7): La gráfica de forma de

onda digital se utiliza para mostrar los datos de señales digitales, sobre todo cuando se
trabaja con diagramas de tiempo en analizadores lógicos. El gráfico acepta ondas y arreglos
de datos digitales como entrada, traza el bus de datos de las señales digitales de entrada,
personaliza la gráfica de forma de onda digital para mostrar un bus digital, líneas digitales,
o una combinación de bus y línea digital. Si se conecta un arreglo de datos digitales en la
que cada elemento del arreglo representa un bus de datos, el gráfico muestra por separado
cada elemento del arreglo como una línea de datos digitales, por ejemplo, si se tiene un bus
98
de datos el cual presenta 6 líneas de datos que van desde la línea 0 hasta la línea 5, cada
línea tiene aproximadamente 9 bits de información, tal como se observa en la figura 5.18.
Figura 5.18. Líneas de datos digitales con 9 bits de información.
Al utilizar el grafico de datos digitales, se divide cada uno de los buses de datos y
la gráfica por separado, mostrando seis líneas con los respectivos estados que asumen cada
bit, tal como se muestra en la figura 5.19.
Figura 5.19. Bus de datos de las 6 líneas de información.
Ejemplo de Aplicación 3: Una de las aplicaciones más comunes para el área de sistemas
Digitales, es la conversión de un vector de números reales a binarios y mostrar las
representaciones binarias de esos números en el indicador gráfico de datos digitales.
Realizar la Conversión Análogo-Digital (CAD) de un arreglo de datos.
99
Desarrollo: Se debe utilizar en el Diagrama de Bloques funciones de conversión de datos

analógicos a digitales, como se muestra en la figura 5.20, indicando el número de bits
utilizados en la conversión de los rangos máximos y mínimos, según el número de bits, por
ejemplo para 8 bits, 255 como el valor máximo y 0 como el mínimo.
Figura 5.20. Conversión de datos Análogos a Digitales CAD.
Después de hacer la conversión se procede a utilizar el indicador grafico como el

ejemplo de la figura 5.21, para señales digitales y así ver el bus de datos para los 4 canales
de datos numéricos de 8 bits.
Figura 5.21. Bus de datos de las 8 líneas de información de los 4 canales de datos.
100
Gráfico de señales Mixtas (Mix Signal Graph) (8): El gráfico de señal Mixta muestra al
mismo tiempo, datos de señales analógicas y digitales y acepta todos los tipos de datos
usados por los gráficos WaveFormGraph, XY Graph y Digital WaveForm Graphs. Un
gráfico de señal Mixta tiene dos áreas de trazado de gráficas, un área de trazado sólo para
señales digitales y uno para señales analógicas, se pueden graficar múltiples señales
analógicas y digitales por área de trazado, pero no se puede mezclar una señal analógica y
una digital en una misma área de trazado. Al agregar múltiples graficas en un área de
trazado, el programa define una sola escala en Y para todas las gráficas, la escala en X es
compartida para las dos áreas de trazado. Para poder armar las diferentes áreas de trazado
se debe crear un Cluster, que concatene los arreglos de datos de las diferentes señales
analógicas y digitales por medio de la función Bundle. En la figura 5.22, se muestra un
indicador gráfico para señales mixtas.
Figura 5.22. Indicador gráfico de señales Mixtas analógicas y digitales.
Gráficas 2D: Utiliza los datos de valores XY para trazar puntos en la gráfica y conectar
los puntos, formando una vista de la superficie bidimensional de los datos. Con gráficos en
2D se puede visualizar los datos bidimensionales de gráficos XY porque todos los gráficos
2D son gráficos XY. Los Gráficos 2D se pueden clasificar en:
101
Compass Plot (9): Es un gráfico que genera vectores con su valor de magnitud, desde el
centro de una circunferencia expresada en grados de 0° a 360°. Ver la figura 5.23.
Figura 5.23. Función e indicador gráfico 2D del Compass Plot.
Error Bar Plot (10): Grafica una barra de error sobre un punto por encima y debajo de un
gráfico lineal. La figura 5.24, muestra la aplicación de VI.
Figura 5.24. Función e indicador gráfico 2D del Error Bar Plot.
Feather Plot (11): Gráfico que emanan vectores de puntos igualmente espaciados a lo largo
de un eje horizontal, como el de la figura 5.25.
102
Figura 5.25. Función e indicador gráfico 2D del Feather Plot.
XY Plot Matrix (12): En la figura 5.26, se muestra un gráfico con las filas y columnas de
un gráfico de dispersión.
Figura 5.26. Función e indicador gráfico 2D del XY Plot Matrix.
Gráficas 3D (14): Existe señales que requieren un análisis más complejo, y presentar sus
datos en indicadores gráficos 3D, por ejemplo, distribución de superficie, volumen de una
103
señal, figuras geométricas en el espacio, entre otros. Para presentar los datos en 3D,
LabVIEW incluye un grupo de indicadores gráficos, que se encuentran ubicados en la
paleta de control del Panel Frontal, tal como se observa en la figura 5.27.
Figura 5.27. Función 3D desde la palea de control del Panel Frontal.
Scatter (a): Muestra en el plano cartesiano valores estadísticos, de la relación entre dos
grupos de datos. Ver figura 5.28.
Stem (b): Muestra la respuesta como un impulso y organiza los datos por su distribución.
Ver figura 5.28.
Figura 5.28. Función e indicador gráfico 3D Scatter y Stem.

104
Comet (c): Crea gráfico animado con un circulo que sigue los puntos de los datos Ver
figura 5.29.
Surface (d): Gráfico de datos con una superficie de conexión. Ver figura 5.29.
Figura 5.29. Función e indicador gráfico 3D Comet y Surface.
Contour (e): Gráfico de señales con líneas de contorno. Ver figura 5.30.
Mesh (f): Grafica de una superficie de conexión con espacios abiertos. Ver figura 5.30.
Figura 5.30. Función e indicador gráfico 3D Contour y Mesh.

105
Waterfall (g): Genera un gráfico de la superficie de los datos y el área en el eje Y por
debajo de los puntos de los datos. Ver figura 5.31.
Quiver (h): Genera un gráfico de vectores normales a la superficie. Ver figura 5.31.
Figura 5.31. Función e indicador gráfico 3D Waterfall y Quiver.
Ribbon (i): Genera un gráfico de líneas paralelas a la superficie. Ver figura 5.32.
Bar (j): Genera un gráfico de barras verticales. Ver figura 5.32.
Figura 5.32. Función e indicador gráfico 3D Ribbon y Bar.

106
Pie (k): Genera un gráfico de torta. Ver figura 5.33.
3D Surface Graph (l): Dibuja un gráfico de superficie en el espacio 3D. Ver figura 5.33.
Figura 5.33. Función e indicador gráfico 3D Pie y 3D Surface Graph.
3D Parametric Graph (m): Dibuja superficie paramétrica en espacio 3D. Ver figura 5.34.
3D Line Graph (n): Dibuja una línea en el espacio 3D. Ver figura 5.34.
Figura 5.34. Función e indicador gráfico 3D Parametric Graph y 3D Line Graph.

107
ActiveX 3D Surface Graph, Parametric Graph y 3D Curve Graph: Estos tres tipos de
indicadores gráficos, tienen las mismas funciones que los tres anteriores pero utilizan
tecnología ActiveX 3D, que se define como un contenedor de programas externos sobre el
panel frontal del LabVIEW. Ver figura 5.35.
Figura 5.35. Función e indicador gráfico 3D Activex.
Control de Imágenes 3D
Las pantallas de control de imagen 3D se utilizan para representaciones gráficas de

los objetos en 3D y crear escenas. Una escena es un objeto 3D o una colección de objetos
en 3D que se pueden ver en la ventana de control de imágenes que aparecen en la paleta de
gráficos del Panel Frontal (13). Al diseñar una escena, puede generar varios objetos en 3D
y especificar su orientación, la apariencia y la relación con otros objetos dentro de la
escena. Puede configurar características de la escena, el estilo, la ubicación de una fuente
de luz y el control de una cámara para interactuar con la escena 3D. La figura 5.36, muestra
un control de imagen en 3D que contiene una simple escena 3D.
108
Figura 5.36. Imagen 3D de un cubo.
Crear un Objeto: Los objetos 3D, que aparecen en una escena, son gráficas de objetos
físicos, es un conjunto de vértices que existe en el espacio 3D y cualquier conexión que
pueden o no existir entre esos vértices. Cuando se crea una escena 3D se crea uno o más
objetos en 3D, utilizando la función crear objeto (Create Object) que ubicada en las
funciones de gráficas de la Paleta de Funciones, la cual se muestra en la figura 5.37.
Figura 5.37. Función para crear objetos 3D.
Después de crear un objeto 3D, debe definir su apariencia, para ello debe configurar
los siguientes atributos:
Geometría: Especifica la forma de un objeto 3D, cubos, esferas, conos, cilindros, etc.
También puede utilizar mallas para crear objetos geométricamente más complejos. La tabla
5.3, muestran algunos objetos con imagen 3D.
109
Tabla 5.3. Geometría de los objetos 3D.

Objeto Función VI Imagen 3D
Cubos
Esferas
Cilindros
Conos
Texto: Si un objeto no tiene una geometría definida, puede aplicar el texto al objeto para
crear un objeto de texto. Al igual que los objetos con geometrías definidas, el texto aparece
cuando se hacen la escena 3D. En la tabla 5.4, muestra un objetivo tipo texto en 3D.
110
Tabla 5.4. Objetos de texto 3D.

Objeto Función VI Imagen 3D
Texto
Se puede utilizar transformaciones y texturas para cambiar el tamaño, la

orientación, la ubicación o apariencia de la superficie de un objeto 3D en una escena 3D.
Aplicación de transformaciones: Una transformación cambia la orientación o la

apariencia de un objeto 3D de acuerdo a una regla matemática. Se pueden aplicar las
siguientes tres transformaciones a los objetos 3D:
Traslación: Consiste en mover el objeto a una nueva ubicación en la escena 3D. Para
especificar la nueva ubicación para el objeto 3D, se define un vector de coordenadas del
objeto, como se muestra en la figura 5.38.
Figura 5.38. Función de translación para crear escenas 3D.

111
Rotación: Cambia la orientación del objeto 3D. Para especificar la nueva orientación, se
define un eje alrededor del cual gira el objeto y un ángulo alrededor del eje por el cual se
produce la rotación, tal como muestra la figura 5.39.
Figura 5.39. Función de rotación para crear escenas 3D.
Las funciones de rotación X, Y y Z, se utilizan para rotar alrededor de cada eje

especifico, como muestra la figura 5.40.
Figura 5.40. Función de rotación para los ejes X,Y y Z, para crear escenas 3D.
Escalar: Cambia el tamaño del objeto 3D. Para especificar la nueva escala, establece los
factores X, Y, Z y planos de la escena 3D a los que desea cambiar el tamaño del objeto, tal
como se muestra en la figura 5.41.
112
Figura 5.41. Función de escalar para crear escenas 3D.
La aplicación de texturas: Cambia el aspecto de la superficie de un objeto 3D

envolviendo una imagen 2D alrededor del objeto 3D, por ejemplo, puede activar una esfera
como un planeta, mediante la aplicación de una imagen 2D que represente la superficie del
planeta.
Para hacer una textura de una imagen 2D, sobre una esfera se procede a realizar los
siguientes pasos Se referencia o se crea el objeto 3D, luego se activa la escena con la
propiedad que se quiere aplicar al objeto para este caso textura, seguido se configura el VI
de textura, al cual se le debe cargar la imagen 2D indicando la dirección de la imagen, se
crea la escena de textura y se procede aplicar dicha superficie a la escena del objeto 3D,
finalmente se visualiza la imagen compuesta, como se muestra en la figura 5.42 y 5.43.
Figura 5.42. Aplicación de texturas.

113
Figura 5.43 Ejemplo de una textura de imagen 2D sobre un objeto 3D.
Ejemplo de Aplicación 4: Crear una escena con varios objetos 3D y visualizar la escena
3D utilizando el control de cámaras.
Desarrollo: Se pueden relacionar más de un objeto 3D en una escena, para ello se procede
a configurar los siguientes pasos:
1. Crear los objetos 3D que se desean relacionar en una escena, para ellos debe escoger
las figuras geométricas (cuadrado y esfera), y la función crear objeto para
referenciar la escena.
2. Se le incluye la función de trasladar objeto para uno de los objetos, en este caso
para la esfera.
3. Se selecciona el VI, adicionar objetos y se mantiene la referencia del evento.
4. Finalmente se lleva al control 3D picture para visualizar las dos imágenes.
En la figura 5.44, se observa el control de imagen 3D y el Diagrama de Bloques,

donde se visualizan y se programan los dos objetos.
114
Figura 5.44. Ejemplo de una escena con dos objetos 3D.
Para visualizar las escenas 3D, se debe configurar los controles de la cámara, para
ello se debe hacer clic derecho sobre el 3D picture del Panel Frontal, y en el menú
desplegable seleccionar controles de cámara, se presentan cuatro opciones, tal como se
Figura 5.45. Visualizar una escena con dos objetos 3D usando el controlador de cámaras.
Por defecto no aparece ningún control seleccionado, se puede seleccionar las

cámaras esféricas, de vuelo, orientada, auto gráfico, las cuales presentan diferentes
perspectivas de visualización de la imagen. En la figura 5.46, se observan los objetos de la
escena 3D bajo la perspectiva de la cámara esférica:
115
Figura 5.46. Visión de una escena desde la perspectiva de la cámara esférica.
La siguiente actividad, se basa en las utilidades Gráficas del LabVIEW. Visualizar

en un gráfico mixto una señal analógica sinusoidal de 4 V y las señales de salida de cada
uno de los canales del convertidor ADC de 8 bits.
Definir el problema: Desarrolle un programa que genere una señal sinusoidal de 4 V de

amplitud, que se pueda procesar en un convertidor análogo digital de 8 bits de resolución.
Diseñar soluciones: Definir variables de entrada y salida de datos, tabla 5.5.

dato
Amplitud INPUT Control Numérico Real punto flotante
Valores de -4 a 4 V
Numero de muestras INPUT Control Numérico Real punto flotante
Valores de 0 a 8
Señal analógica OUTPUT Indicador Numérico Gráfica de señales mixtas.
Señales digitales OUTPUT Indicador Numérico Gráfica de señales mixtas.
Datos Muestreados OUTPUT Indicador Vector Real punto flotante
Numérico Valores de -4 a 4 V
Amplitud INPUT Control Numérico Real punto flotante
Valores de -4 a 4 V
116
Aplicación: Diseñe un Panel Frontal que tenga el indicador de señales Mixtas analógicas
y digitales, además que presente dos controladores para ingresar el número de muestras y
la amplitud de la señal, también se le agregan dos indicadores tipo arreglo vectorial, para
ver los datos analógicos y digitales de entrada y salida del convertidor, tal como se muestra
en la figura 5.47.
Figura 5.47. Panel Frontal requerido para la aplicación.
En el diagrama de programación de la figura 5.48, se trabaja con un ciclo repetitivo

FOR, que indica el número de muestras que se le va enviar a la señal y la resolución en
cada muestra. En el interior del FOR, se genera con una función matemática elemental de
la onda sinusoidal y se le indica con un controlador numérico su valor de amplitud.
Figura 5.48. Diagrama de bloques, generación de la señal sinusoidal.

117
La variable tipo entero de color azul I, evalúa muestra por muestra la función
sinusoidal, se utiliza un operador de multiplicación para llevar el valor máximo de la
función al valor de amplitud deseado por el usuario. La salida de la multiplicación se
redondea para establecer la resolución en un voltio y tener antes del convertidor solo
números enteros. En la figura 5.49 se observan los datos muestreados.
Figura 5.49. Indicador vectorial de los datos muestreados.
Se procede a realizar la conversión de los valores de amplitud generados por la

señal, para ello se requiere de un VI, que realiza la conversión de señales analógicas a
digitales con un determinado número de bits por conversión asumiendo el signo del valor
de amplitud, tal como se observa en la figura 5.50.
Figura 5.50. Datos analógicos, convertidor ADC y datos digitalizados.
Se selecciona un gráfico mixto observado en la figura 5.51, para señales analógicas

y digitales y para muestrear todos los canales y la onda de entrada.
118
Figura 5.51. Indicador gráfico mixto de las señales analógicas y digitales.
Cada una de las líneas del gráfico digital, corresponden a los valores de la tabla
dada por el convertidor análogo digital ADC. La señal analógica puede mejorar su
resolución dependiendo del número de muestras. El diagrama de bloques de la figura 5.52,
muestra la conexión de los indicadores tipo arreglo y el indicador gráfico mixto; queda
codificado de la siguiente manera.
Figura 5.52. Código de programación de la Actividad.

119
Prueba y verificación: Se verifica la conversión de cada uno de los 8 valores del vector
numérico y se calcula el valor equivalente en su salida digital, por ejemplo el valor de
amplitud de 4V, en digital según la conversión dada por digito de 2n, debe ser el equivalente
de 22 el cual corresponde al 000 0100 sin considerar el signo, tal como se observa en la
figura 5.53.
Figura 5.53. Prueba de la Actividad.

120
Capítulo VI
Estructuras fundamentales de lazos repetitivos de LabVIEW
Las estructuras son representaciones gráficas de los lazos que se utilizan como
funciones básicas en los lenguajes de programación, se encargan de repetir el código que
se programe en el interior de la estructura dependiendo de una condición específica. Tienen
terminales que los conectan a otros bloques del diagrama y se ejecutan automáticamente
cuando se dispone de datos de entrada y envían datos a la salida cuando finaliza la
ejecución. Cada estructura tiene un borde distintivo, de tamaño variable para encerrar la
sección del Diagrama de Bloques que se ejecuta de acuerdo con las reglas de la estructura.
La sección del Diagrama de Bloques dentro de la estructura de borde se llama subdiagrama
y los terminales que alimentan datos dentro y fuera de las estructuras son llamados túneles.
En este capítulo, se desarrollan estructuras de lazos repetitivos, los comandos

normalmente usados para los lazos son While, For y Shift Register. Todos son estándar en
los diferentes lenguajes de programación, acá se explica detalladamente su configuración,
las aplicaciones más comunes y orientadas a la Ingeniería Electrónica. Los temas a
desarrollar en este capítulo son los siguientes:
-. Estructuras cíclica While.
-. Estructuras cíclica For.
-. Registro de desplazamiento (Shift Register).
Estructura cíclica While
La estructura While, repite el código presente en el interior de su estructura hasta

que se cumpla una condición definida por el programador. La figura 6.1 muestra la
121
estructura While en LabVIEW, como se debe expresar en un diagrama de flujo y su

equivalente al código en lenguaje de texto.
Figura 6.1. Estructura While en distintos formatos.
El While se encuentra en la paleta de funciones en el bloque de las estructuras,

como se observa en la figura 6.2.
Figura 6.2. Estructura While en la paleta de funciones.
Cuando se selecciona la estructura While, se despliega al tamaño que se requiera

según la cantidad de código que quede dentro del lazo. La estructura viene acompañada de
los dos botones observados en la figura 6.3, que sirven como controladores del lazo.
122
Figura 6.3. Botones de control del While del LabVIEW.
El botón rojo detiene el While, siempre y cuando reciba un valor booleano

verdadero que permita activarlo. Se puede cambiar el comportamiento y el aspecto del
terminal del condicional, haciendo clip sobre el terminal y cambiar la condición para
detener con un valor falso o seguir mientras sea verdadero, en este caso cambia el Icono de
un botón rojo a uno verde con una flecha rotando tal como se observa en la figura 6.4.
Figura 6.4. Botones para detener el While.
El botón de contador de lazo (figura 6.5), se comporta como un contador ascendente

que arranca en cero e incrementa su valor en uno cada vez que se repita el lazo.
Figura 6.5. Botón para contador de ciclos en el While.
Ejemplo de Aplicación 5: Utilice el Método de Desarrollo de Software para evaluar la

estructura repetitiva While.
Definir el problema: Diseñe un programa que evalué un número aleatorio entre 0 y 1000
y verifique si es igual a un número definido por el usuario. Cuando el programa consiga el
número, debe indicar cuantas iteraciones hizo para conseguirlo.
123
Diseñar soluciones: Definir variables de entrada y salida de datos (Tabla 6.1) y se procede
hacer un diagrama de flujos (Figura 6.6), previo a la codificación del programa.

Nombre Función Tipo de dato Propiedad
Numero a Comparar INPUT Control Numérico Real punto flotante
Numero aleatorio OUTPUT Indicador Numérico Real punto flotante
Numero de iteraciones OUTPUT Indicador Numérico Real punto flotante
Figura 6.6. Diagrama de flujo de la aplicación.
Aplicación: Lo primero a diseñar es la ventana del Panel Frontal (Figura 6.7), se buscan
dos indicadores numéricos para los valores de la variable aleatoria y el contador de
iteraciones y un controlador numérico para incluir el número a comparar.
124
Figura 6.7. Panel Frontal de la aplicación.
En el Diagrama de Bloques se debe conectar cada uno de los terminales a las

funciones que cumplan con las operaciones requeridas. El código de programación necesita
funciones matemáticas de operaciones básicas, multiplicar, redondear, incrementar,
variable aleatoria y una función de comparación que genera una salida booleana. La tabla
6.2 explica las funciones utilizadas.
Tabla 6.2. Funciones utilizadas en la aplicación.

Random: Se utiliza para generar valores aleatorios de números
reales entre 0 y 1.
Multiplicación: Se utiliza para multiplicar dos variables numéricas

y retorna el resultado del producto.
Redondeo al valor más cercano: redondea un número real a su

valor más cercano convirtiéndolo en entro sin decimales.
Igual que?: Se utiliza para comparar dos variables y decidir si son

iguales. Su salida es booleana y se activa en alto si se cumple la
condición.
Incremento +1: Se utiliza para incrementar en uno, cualquier valor
numérico.
Según el algoritmo y las funciones de código de LabVIEW, se tiene el Diagrama

de Bloques de la figura 6.8:
125
Figura 6.8. Diagrama de Bloques y código de programación de la aplicación.
Prueba y verificación: Se definen diferentes números a comparar y se visualiza la cantidad

de iteraciones, la cual varía incluso para un mismo número debido a la naturaleza aleatoria
de la función Random. El resultado de la comparación se utiliza como condición para
activar el botón de stop del While. Se puede utilizar diferentes estrategias de programación
para resolver este programa, otra forma puede ser comparando en función de la no igualdad
de los números y activando el stop del While con una variable falsa.
Túnel de la estructura While: La estructura While se define como túnel, los puntos de
entrada y salida de la pared del While, es donde se puede pasar información a la estructura
antes de comenzar su función repetitiva, o sacar información de la estructura al finalizar el
lazo. Por ejemplo en el caso de la aplicación anterior, el número a comparar puede ser un
dato de entrada que se define fuera de la estructura y que por medio del túnel pasaría su
valor una sola vez, es decir, una vez que el dato pase por el túnel así sea cambiado en el
controlador siempre va mantener el primer valor. También se puede asumir el indicador
del número de iteraciones como un valor de salida de la estructura y pasarlo como un túnel
de salida que solo se visualice en el momento que se salga del While. En la figura 6.9 se
observa el túnel de entrada y salida de la estructura.
126
Figura 6.9. Código de programación de la aplicación con la presencia de túneles de entrada y salida.
Estructura cíclica For
La estructura For repite el código presente en el interior de su estructura un número

de N veces definido por el programador. La figura 6.10, muestra la estructura For en
LabVIEW, como se debe expresar en un diagrama de flujo y su equivalente al código en
lenguaje de texto.
Figura 6.10. Estructura For en distintos formatos.

127
El For también se encuentra en la paleta de funciones en el bloque de las

estructuras, tal como se observa en la figura 6.11.
Figura 6.11. Estructura For en la paleta de funciones.
Al seleccionar el For, se puede desplegar en pantalla al tamaño que se requiera

según la cantidad de código que quede dentro del lazo. La estructura viene acompañada de
dos botones que sirven como controladores del lazo uno para el valor final y el otro para el
incremento en forma ascendente tal como se observa en la figura 6.12.
Figura 6.12. Estructura For y sus elementos.
El Valor N, es un valor numérico tipo entero que define el número de iteraciones

que va a ejecutar el lazo. El botón i, es el contador de lazo, es un contador numérico tipo
entero que se comporta como un contador ascendente que arranca en cero e incrementa su
valor en uno cada vez que se repita el lazo hasta N-1.
128
La estructura While en cada ciclo genera resultados que se visualizan

inmediatamente en el mismo ciclo, los resultados de los ciclos anteriores no se pueden
visualizar directamente. La estructura For si tiene la posibilidad de visualizar en un arreglo
de datos de todos los resultados que se generarón en cada uno de los ciclos de las N
iteraciones. Por lo tanto se puede confirmar que la salida de datos de una estructura For
queda representado por un arreglo de datos.
Ejemplo de Aplicación 6: Una aplicación de lazo For, se requiere para evaluar la función
trigonométrica coseno de X (COS(X)), para un determinado número de valores de X.
Desarrollo: Se puede utilizar la estructura For, donde el valor de X es representado por la

variable incremental i, y el número de valores lo define N. Se puede visualizar en un
indicador numérico cada uno de los valores de la función COS(X), pero también se puede
crear una salida tipo vector con un túnel de salida en la pared del For, que muestre los
valores de la función COS(X) de las N iteraciones. Con este vector se puede graficar la
función utilizando una de las herramientas gráficas vistas en capítulos anteriores. En la
figura 6.13 se observa el código del programa.
Figura 6.13. Ejemplo del uso de la estructura For.
En el Diagrama de Bloques de la figura 6.13, se observa la presencia del túnel de

salida que cambia el dato de un escalar a un arreglo de datos de todas las iteraciones. El
Panel Frontal se observa en la figura 6.14.
129
Figura 6.14. Panel Frontal del ejemplo de la estructura For.
For Anidados: Si se requiere generar un arreglo de datos de más de una dimensión, por
ejemplo una matriz, se puede generar una estructura anidada de For, es decir, un For dentro
de otro For y se asume la salida del For externo como el elemento de N dimensiones. El
siguiente ejemplo muestra cómo trabajar con For anidados.
Ejemplo de Aplicación 7: Utilice el Método de Desarrollo de Software para evaluar la

estructura repetitiva For.
Definir el problema: Se requiere construir una matriz de valores booleanos que resulten
de comparar un número aleatorio con su valor intermedio, es decir, utilizar la función
aleatoria de 0 a 1 y comparar si es mayor o menor a 0,5. Los valores que resultan de la
comparación se utilizan para crear una matriz booleana de ocho filas y diez columnas.
Diseñar soluciones: Se identifican señales de entrada y salida del programa (Tabla 6.3) y
se procede hacer un diagrama de flujos previo a la codificación del programa (Figura 6.15).

Filas INPUT Control Numérico Entero
Columnas INPUT Control Numérico Entero
Vector Booleano OUTPUT Indicador Booleano Vector de Leds
Matriz Booleana OUTPUT Indicador Booleano Matriz de Leds
130
Aplicación: Se diseña el Panel Frontal del programa (Figura 6.16), se agregan dos
controladores numéricos para definir el número de filas y columnas de la matriz, y se
agregan dos indicadores de salida uno correspondiente a un vector que refleja la última fila
de la matriz, ubicado a la salida del primer For, y la matriz corresponde el indicador de
salida del For externo, ambos son del tipo booleano.
En el Diagrama de Bloques se debe conectar cada uno de los terminales a las

funciones que cumplan con las operaciones requeridas. El código de programación necesita
131
funciones matemáticas de operaciones básicas: multiplicar, redondear, incrementar,

variable aleatoria y una función de comparación que genera una salida booleana. En la
Tabla 6.4 se explican algunas de las funciones.

Random: Se utiliza para generar valores aleatorios de números
reales entre 0 y 1.
Mayor que?: Se utiliza para comparar dos variables y decidir cuál
es la mayor. Su salida es booleana y se activa en alto si se cumple
la condición.
Código de programación en LabVIEW, que se tiene en el Diagrama de Bloques

(Figura 6.17).
Prueba y verificación: El proceso de generar vectores y matrices utilizando estructura de

lazos For, es muy común cuando se desean levantar graficas de datos muestreados y se
conoce con exactitud el número de muestras, para el caso de estudio se utiliza los For
anidados para establecer la matriz en base a las dimensiones seleccionada por el usuario.
Se observa los leds en diferentes estados de operación, conformando una matriz de 8 filas
y 10 Columnas.
132
Registro de desplazamiento (Shift Register)
Cuando se está evaluando un resultado de una función y se desea utilizar ese

resultado en un lazo o ciclo posterior, es necesario almacenarlo o registrarlo para
transferirlo al ciclo actual, por ejemplo, calcular el valor promedio de una temperatura que
se adquiere de una tarjeta de adquisición de datos, tomando siempre los últimos cinco
valores adquiridos. Para desarrollar este ejemplo debe existir un ciclo repetitivo que
adquiera por ciclo un valor de temperatura, y se debe recordar los datos de las cuatro
iteraciones anteriores para sumarlo al valor actual y definir una temperatura promedio.
Los registros de desplazamiento, son capaces de transferir los valores de una

iteración de un lazo anterior al lazo siguiente, permitendo enlazar terminales de diferentes
tipos de dato y asumen el color del dato que le sea enlazado en la tabla 6.5 se observa los
estados del Shift Register en función del tipo de dato.
Tabla 6.5. Estados de los elementos del Shift Register.

Elementos Condición del elemento
Registro de desplazamiento sin datos conectados.
Registro de desplazamiento con valor de datos numéricos reales, pueden

ser escalares, vectores o matrices.
Registro de desplazamiento con valor de datos numéricos enteros, pueden

ser escalares, vectores o matrices.
Registro de desplazamiento con valor de datos booleanos, pueden ser

escalares, vectores o matrices.
Registro de desplazamiento con valor de datos cadena de caracteres,

pueden ser escalares, vectores o matrices. También si los datos son clouster
asume ese color.
133
Los registros de desplazamiento son comúnmente utilizados en las estructuras

básicas de lazos repetitivos While y For. Para crear un registro de desplazamiento se debe
realizar el siguiente procedimiento:
• Se debe buscar en la Paleta de Funciones la estructura cíclica adecuada, se debe
escoger entre la estructura While o la estructura For, dependiendo de lo que se
requiera en el programa.
• Al tener la estructura en el diagrama de bloques, se ubica el cursor sobre la pared
de la estructura y se hace clic sobre el botón derecho del ratón, para desplegar el
menú de propiedades de la estructura. Se busca la propiedad ADD SHIFT
REGISTER, como se observa en la figura 6.18.
Figura 6.18. Incluir Shitf Register en lazos repetitivos.
• Al seleccionar ADD SHIFT REGISTER, se crean dos conectores del registro de

desplazamiento, que se representan con un bloque con una flecha ascendente para
ingresar datos y un bloque con una flecha descendente para extraer datos. Para
Conectar datos al registro de desplazamiento se busca el terminal y se envía el dato
al bloque de la flecha ascendente de la pared de la estructura, este dato se trasladará
al bloque de salida de la flecha descendente en el siguiente ciclo. Es importante que
en el primer ciclo se inicialice el valor del registro de desplazamiento, esto se debe
hacer fuera de la estructura cíclica (Figura 6.19).
Figura 6.19. Enlazar e inicializar un Shitf Register.

134
• Si se desea utilizar más registros de desplazamiento se pueden hacer siguiendo los

mismos procedimientos anteriores, con cualquier tipo de dato.
• También se presentan casos donde se requiera más de un valor posterior, por
ejemplo, si desea promediar los cinco últimos valores de una variable, el registro
de desplazamiento permite expandir su salida a tantos valores anteriores como
requiera el usuario, es importante inicializar cada uno de los nuevos bloques de
salida que van aparecer en el registro de desplazamiento (Figura 6.20).
Figura 6.20. Incluir varias entradas a un Shitf Register.
Actividad complementaria 6
Diseñar una aplicación para aumentar y disminuir dimensiones de los datos

utilizando For.
Definir el problema: Construya dos señales matemáticas SEN(X) y COS(X), utilizando

For y las funciones matemáticas trigonométricas seno y coseno, el valor de X crea dos
vectores con las funciones trigonométricas, graficarlas en un indicador gráfico utilizando
ambas funciones en un arreglo matricial. Luego proceda a extraer el vector fila de la matriz
generada y un valor escalar del vector extraído.
Diseñar soluciones: Se identifican las señales de entrada y salida del programa, como en
la tabla 6.6.
135

Filas INPUT Control Numérico Real punto flotante
Columnas INPUT Control Numérico Real punto flotante
Escalar de Amplitud OUTPUT Indicador Numérico Real punto flotante
Vector Seno OUTPUT Indicador Vector Numérico Real punto flotante
Vector Coseno OUTPUT Indicador Vector Numérico Real punto flotante
Matriz de Ambas OUTPUT Indicador Matriz Numérico Real punto flotante
Funciones
Aplicación: Genere dos vectores con los datos de cada señal y graficarla en conjunto, se
pueden llevar las salidas de las funciones hasta el túnel de salida y allí haciendo clip en el
botón derecho del ratón se selecciona del menú desplegable la opción crear indicador, el
LabVIEW por defecto crea indicadores tipo vector. Para graficar las señales construir un
arreglo y buscar un indicador tipo WaveFormGraph para múltiples variables. En la figura
6.21 y 6.22, se observa el desarrollo de la actividad propuesta.
Figura 6.21. Diagrama de Bloques y código de programación de la Actividad.
Figura 6.22. Panel Frontal de la Actividad.

136
Genere una matriz 12x12 de la señal SEN(X), utilizar un For anidado, que permita
definir en cada columna los valores de la amplitud y por fila repetir los mismos valores
(Figura 6.23 y 6.24).
Figura 6.24. Matriz en el Panel Frontal de la Actividad.
Extraiga la fila 4 y 8 de la matriz 12x12 generada, llevar la matriz generada

nuevamente a un For a través de un túnel de entrada, al For se le indica en el valor de N
el número de la columna que se desea extraer. Para este caso se debe hacer dos ciclos For
uno para la fila 4 y otro para la 8. Extraiga el elemento 5 de las filas extraída en el punto
anterior, se hace idénticamente que en el paso anterior pero con un For anidado en cada
una de las filas extraídas, indicándole al N el número del elemento a extraer. En la figura
6.25 se muestra el desarrollo de esta actividad.
137
Prueba y verificación: Se observa en el Panel Frontal de la figura 6.26, los elementos

extraídos de la matriz.
Figura 6.26. Matriz, vector y escalar en el Panel Frontal de la Actividad.

138
Capítulo VII
Desarrollo de aplicaciones Modulares
El tema a desarrollar en este capítulo, está relacionado con las técnicas para el crear
aplicaciones modulares basadas en el procedimiento requerido para crear funciones
virtuales o SubVIs. Las aplicaciones modulares conllevan a una serie de pasos para crear
SubVIs personalizados que reducen el espacio de la pantalla de programación y generar
modularidad en la estructura del programa. Los temas a desarrolla en este capítulo son los
siguientes:
-. Comprensión de Modularidad.
-. Creación del SubVI.
Comprensión de Modularidad:
Los Instrumentos Virtuales están formados por un Panel Frontal y un Diagrama de

Bloques, pero también debe definir su propio Icono y Panel de Conexión para convertirlo
en una función o subVI que puede ser utilizado en otro VI o subVI, es decir, un subVI es
un Instrumento Virtual que puede ser utilizado como función dentro de otro VI.
A medida que los programas se hacen más complejos y requieren de gran cantidad
de elementos, es necesario aplicar procesos de modularidad para reducir espacios y
establecer funciones con rutinas específicas. Es por ello que se debe introducir el concepto
de subVI en un diagrama de programación, ya que ellos permiten formar funciones propias
que ordenan el programa y da la opción de ser reutilizadas en cualquier otra parte del
programa o en otros Instrumentos Virtuales. Se suele comparar la Modularidad, con la
creación de subprogramas en un lenguaje normal de programación de texto, en la figura
7.1, se observa el equivalente de un SubVI a una función.
139
Figura 7.1. Ejemplo de comprensión de Modularidad.
Creación de un SubVI:
Existen dos Formas de crear SubVI, una desde el Diagrama de Bloques y otra desde
el Panel Frontal. Ambos casos llegan al mismo objetivo pero por el Diagrama de Bloques
suele ser más fácil que por el Panel Frontal. Para crear un Sub VI desde el Diagrama de
Bloques, se puede explicar referenciando una de las Actividades Complementarias de los
capítulos anteriores.
Ejemplo de Aplicación 8: Se analiza el programa que adquiere un valor de temperatura y

determina un rango de operación basado en un valor máximo y mínimo de temperatura, si
la temperatura está fuera del rango de operación manda un mensaje de texto indicando la
falla presente. También el programa se anexa una función para calcular el valor promedio
de temperatura, basado en los cuatro últimos valores de la medición de temperatura.
Desarrollo: El programa se basa en la Actividad Complementaria 4. En figura 7.2, se

observa el panel frontal del programa de temperatura y el significado de los diferentes
controladores e indicadores del panel, para este caso la temperatura se adquiere de una
variable aleatoria o función ramdon.
140
Figura 7.2. Panel Frontal de la aplicación de temperatura.
En Diagrama de Bloque de la figura 7.3, se anexan cuatro funciones adicionales

que no estaban presentes en la Actividad Complementaria 4, hay presente cinco círculos
los cuatro primeros definen funciones específicas adicionales del programa:
1. Variable aleatoria que determina el valor de temperatura
2. Determinar el valor promedio de los 4 últimos valores de la temperatura medida.
3. Función que determina hora y fecha del sistema.
4. Retardo del tiempo de muestreo de los valores de temperatura.
5. Procedimiento para verificar el rango de operación de la temperatura y generar los
mensajes de alarmas ante la presencia de fallas en su valor de operación.
Figura 7.3. Diagrama de Bloques del Ejemplo de Aplicación de temperatura.

141
Las funciones 2 y 5 correspondientes al valor promedio y el procedimiento para

generar las alarmas de comparación, las podemos convertir en SubVI desde el diagrama de
bloques, realizando el siguiente procedimiento:
Seleccionar los elementos que van a formar el subVI sin atrapar los indicadores y
controladores. En la figura 7.4, se observa la selección para ambos casos.
Figura 7.4. Selección de elementos para crear subVI desde el Diagrama de Bloques.
Después de seleccionar los elementos a convertir en subVI, se procede a seleccionar

del barra de menú EDIT > Create SubVI, como se observa en la figura 7.5.
Figura 7.5. Selección del menú para crear subVI.
Al Seleccionar Create SubVI, se forman dos bloques que representan las funciones
que fueron seleccionadas por el usuario, tal como se observa en la figura 7.6.
142
Figura 7.6. Diagrama de Bloques del Ejemplo de Aplicación de temperatura con los subVI creados.
Internamente cada bloque contiene los mismos elementos de la selección, para abrir
el subVI dar doble clic sobre la imagen de la función llamada Icono y se abre un nuevo
Panel Frontal y Diagrama de Bloques que representa la estructura del nuevo VI, tal como
se muestra en la figura 7.7.
Figura 7.7. Icono, Panel Frontal y Diagrama de Bloques de cada uno de los subVI creados.
Un Icono es una representación gráfica de un VI. Puede contener texto, imágenes,

o una combinación de ambos. Debe hacer doble clic sobre la imagen del Icono ubicado en
la esquina superior derecha del Panel Frontal, aparece un editor de imágenes, como se
143
muestra en la figura 7.8, el cual permite diseñar o cargar figuras que sirven como etiqueta
del icono y personalizarlo, así se diferencia de las demás funciones.
Figura 7.8. Editor de imágenes del Icono del subVI.
Después de editar las imágenes procede a guardarlas para cada subVI, y verificando
en el programa principal que estos bloques cambien a la imagen creada para los SubVI. Se
observa que se guarda con el adjunto al nombre de subVI, ver figura 7.9.
Figura 7.9. Panel Frontal e Icono del uno de los subVI creado.
Por último se puede observar en la figura 7.10, el programa con los dos SubVI y se
procede a correr para verificar la correcta ejecución.
Figura 7.10. Diagrama de Bloques con los subVI creados.

144
Para crear un Sub VI desde el Panel Frontal, se puede explicar con el Ejemplo de
Aplicación 1, la conversión de temperatura de °C a °F.
Ejemplo de Aplicación 9: Se desea convertir una temperatura adquirida en °C a °F,

utilizando un SubVI que realice la conversión.
Desarrollo: Crear el control e indicador que se va utilizar como entrada y salida de datos
en el Panel Frontal. El control se utiliza para ingresar el valor de temperatura en °C y el
indicador para visualizar la temperatura en °F. Para definir el control e indicador como
elementos de un subVI, deben crearse dos Conectores uno de entrada para el controlador y
uno de salida para el indicador. El Conector es una serie de terminales que corresponden a
los controles y a los indicadores de un VI, donde se definen las entradas y las salidas a
cablear para utilizarlo como un subVI. Se encuentra ubicado al lado del Icono en el Panel
Frontal. Se establecen las conexiones del subVI, asignando el control e indicador del Panel
Frontal, a los terminales del Conector. Los Conectores de entrada se colocan en los bloques
del lado izquierdo del recuadro y los de salida al lado derecho. Para definir una conexión,
se selecciona uno de los cuadros vacíos del Conector con el cursor y luego se selecciona el
control o indicador que se le desea asignar. En la figura 7.11, se observa cómo quedaría
seleccionado para el ejemplo de la conversión de temperatura.
Figura 7.11. Conectores del subVI relacionados con los terminales de entrada y salida de datos.
Se procede a cambiar la imagen del Icono de la misma forma que se realizó en el

problema anterior y se guarda el subVI, para que ajuste los cambios efectuados. Luego se
procede a llamar el subVI guardado, desde la Paleta de Funciones del Diagrama de Bloques
145
en la opción de seleccionar VI, se busca en el directorio del computador donde se guardó

el subVI y se carga en el Diagrama de Bloques. En la figura 7.12, se observa el programa
con el subVI en ejecución
Figura 7.12. Programa principal y SubVI.
Todos los VI están estructurados internamente por varios subVI y funciones propias
de LabVIEW, que tienen prioridades y jerarquías de ejecución. Por ejemplo para el caso
del sistema de alarmas de temperatura, usando el comando VI HIERARCHY ubicado en
el menú de herramientas del LabVIEW (Figura 7.13), permite ver la jerarquía de estas
funciones y su diagrama de conexiones internas.
Figura 7.13. Jerarquía del programa principal.

146
Capítulo VIII
Estructuras fundamentales de selección en LabVIEW
Las estructuras fundamentales de LabVIEW, se basan en las estructuras cíclicas y

de selección, estas últimas son utilizadas para activar una acción de diferentes posibilidades
que tiene el programa cuando se presenta un evento que requiera atención. Se establecen
rutinas de programación que generan diferente resultados y que se activan cuando el
usuario especifica por algún método de selección el código de programación que desea
ejecutar, por lo general una rutina de selección se ejecuta una sola vez y después requiere
verificar nuevamente el terminal de control, para revisar una nueva instrucción.
En este capítulo se desarrollan estructuras básicas de programación, los comandos

usados son la función IF-THEN-ELSE referenciada como SELECT, CASE,
SEQUENCE, EVENT, TIMED, DIAGRAM, CONDITIONAL, entre otras; son estándar
en los diferentes lenguajes de programación y algunas propias del lenguaje gráfico, se
explica su configuración, aplicaciones más comunes y varios ejemplos orientados a la
Electrónica. También se explica un grupo de funciones que aparecen dentro de la Paleta de
Funciones llamadas FORMULA NODE, MATHSCRIPT y MATLABSCRIPT, las cuales
se pueden definir como estructura que evalúan y ejecutan en su interior lenguaje de
programación modo texto. Los temas que se desarrollan en este capítulo son los siguientes:
-. Función de Selección SELECT.
-. Estructuras de Selección de Casos CASE.
-. Estructuras Secuencial SEQUENCE.
-. Estructuras de Eventos EVENT.
-. Estructuras de Tiempo TIMED.
-. Estructura de Sustitución IN PLACE ELEMENT
-. Estructura DIAGRAM DISABLE.
-. Estructura CONDITIONAL.
147
-. Función Formula NODE.

-. Función MATHSCRIPT.
-. Función MATLABSCRIPT.
Función de Selección SELECT
Antes de comenzar analizar en detalles las estructuras de Selección, vamos a

explicar el funcionamiento de la función de Selección SELECT. Como ocurre en los
lenguajes de programación de texto, existe una herramienta básica de selección dado por
los comandos IF, THEN, ELSE, estos comandos definen una condición que puede tener
en su forma más básica dos opciones, verdadera y falsa. (IF) si se cumple la condición es
verdadera y se ejecuta una rutina (THEN), si no se da la condición es falsa y se ejecuta otra
rutina (ELSE). LabVIEW maneja la función SELECT (Figura 8.1), para reemplazar el IF
del lenguaje texto. Es simplemente una función que presenta tres terminales de entrada,
dos del tipo numérico, booleano o cadena de caracteres, donde se establece la rutina que se
quiere ejecutar y una de tipo booleano donde se define la condición a evaluar.
Figura 8.1. Función de Selección SELECT.
Cuando la selección maneja más de dos condiciones, se puede trabajar con

SELECT anidados, es decir, la salida de una selección, se conecta a la entrada de otra. En
los casos de muchas condiciones a evaluar se recomienda trabajar con estructuras de
Selección de Casos.
148
Estructura de Selección de Casos CASE
La estructura de Selección CASE (Figura 8.2), contiene múltiples subdiagramas y

ejecuta el programa que se codifique en un subdiagrama, dependiendo del valor de entrada
que se le pase a la variable de control. La variable de control es una entrada que puede ser
de cualquier tipo de dato y se ubica en la pared de izquierda de la estructura. Una estructura
de Casos tiene más de un subdiagrama, sólo un subdiagrama es visible en un determinado
momento y la estructura ejecuta sólo un caso a la vez, define una variable de control para
seleccionar el caso está variable puede ser numérica, booleana o cadena de caracteres. Por
defecto el selector es tipo booleano y solo define dos subdiagramas uno TRUE o verdadero
y uno FALSE o falso. Si se intercambia el tipo de dato de la variable de control se
incrementa el número de subdiagramas, siempre va existir una ventana por defecto
identificada por la palabra DEFAULT, allí permanece el programa mientras no se active
la selección de un caso.
Figura 8.2. Estructura de Selección CASE.
Los CASE presentan túneles de entrada y salida de datos y se pueden crear

múltiples túneles para una estructura CASE. Las entradas están disponibles para todos los
casos pero no necesariamente los casos van a utilizar cada entrada, sin embargo, se debe
definir un túnel de salida para cada caso, por ejemplo si un caso tiene un túnel de salida
149
pero hay otro caso que no tiene conectado el mismo túnel, el programa no se puede correr
y genera un error. El túnel ya sea de entrada o salida asume el color de la variable que está
conectando, si se presenta un error el túnel aparece en color blanco, cuando la salida está
cableada correctamente en todos los casos el túnel de salida asume un color sólido. En la
figura 8.3, se muestra la estructura de selección del CASE.
Figura 8.3. Estructura de Selección CASE, túnel de salida.
Ejemplo de Aplicación 10: Objetivo, desarrollar un programa que corrija la falla

presentada en La Actividad Complementaria 4, la falla se presenta si el usuario introduce
un rango de temperatura mínima mayor que el rango de temperatura máxima o viceversa.
un mensaje textual en un indicador y en un led que se encienda en el momento de la falla.
Si el usuario carga mal los datos del rango de temperatura, presente un mensaje en pantalla
que le indique al usuario que invirtió el valor de los rengos de temperatura de operación
para que corrija esa posible falla.
salidas OUTPUTS de datos, para ello se genera una tabla de identificación de variables,
como la tabla 8.1. Se utiliza como recurso opcional el diagrama de flujo (Figura 8.4), para
estructurar el programa.
150

dato
Temperatura INPUT Control Numérico
Real punto flotante
Advertencia Texto OUTPUT Indicador Cadena de Normal Display
caracteres Valores:
- Temperatura Normal.
- Temperatura Alta.
- Temperatura Baja.
Valores:
ON ROJO.
OFF VERDE.
Advertencia Texto OUTPUT Indicador Cadena de Ventana del sistema con un
caracteres mensaje en cadena de caracteres

151
Aplicación: Se anexa una estructura CASE que se activa cuando la comparación de los
rangos máximos y mínimos de temperatura activen una variable booleana que se utilizará
como control del CASE. Un caso tendrá el programa que determina los valores y alarma
de temperatura, y el otro caso tendrá el mensaje de error que le indica al usuario que se
invirtieron los valores del rango de operación de temperatura. Para completar la aplicación
requerida se le anexan al programa la estructura CASE y una función para enviar mensajes
de error al usuario, estas aplicaciones se muestran en la tabla 8.2.

Estructura Case: Estructura de selección de casos, controlada por

una variable booleana para establecer dos subdiagramas, uno
verdadero y el otro falso.
Button Dialog: Abre un cuadro de dialogo con un mensaje tipo

cadena de caracteres cuando es activado, se cierra la ventana
cuando se presiona el botón del cuadro de dialogo.
Según el algoritmo y las funciones de código de LabVIEW, se tiene el siguiente

diagrama de bloques de la figura 8.5, para los casos de error:
Figura 8.5. Código de programación de la aplicación para la presencia del error.

152
En el caso que no se presente el error el programa debe correr idéntico a como se

programó inicialmente, el código de programación para este último caso se presenta en la
figura 8.6.
Figura 8.6. Código de programación de la aplicación si no hay error.
Prueba y verificación: En la figura 8.7, se puede observar el mensaje que se le muestra al

usuario cuando se da el error, bloquea la aplicación y sólo la deja ejecutar de nuevo cuando
se corrija el error.
Figura 8.7. Mensaje del error mostrado al usuario.
Estructura secuencial SEQUENCE
Una estructura de Secuencia es parecida a la de casos, pero con la diferencia que

una vez llamada la estructura se van a ejecutar cada uno de los casos en forma secuencial,
es decir, si tengo cuatro casos se ejecutaría desde el primero hasta el cuarto, uno por uno,
con la posibilidad de transmitir datos de un caso a otro a través de los llamados túneles.
153
La estructura de Secuencia se puede clasificar en: Estructura de Secuencia Plana

FLAT SEQUENCE y estructura de secuencia de Pila STACKED SEQUENCE, ambas
estructuras se muestran en la figura 8.8 y 8.9. La estructura de Secuencia Plana, muestra
todos los marcos de una vez y ejecuta de izquierda a derecha, cuando todos los valores de
datos conectados a un marco están disponibles y hasta que el último cuadro se ejecute. Los
valores de los datos dejan cada marco cuando el marco termina de ejecutarse, si se requiere
añadir más marcos se selecciona el menú desplegable haciendo clip con el botón derecho
sobre la estructura y buscando la función de añadir secuencia.
Figura 8.8. Estructura de Secuencia de Plana Flat Sequence.
La estructura de Secuencia de Pila, se ejecuta marco por marco se apilan idéntico a

la estructura de Casos, tienen una etiqueta que enumera cada marco o ventana con el
número 0 luego el siguiente con el número 1 y así sucesivamente hasta que el último marco.
Figura 8.9. Estructura de Secuencia de Pila Stacked Sequence.
Las estructuras secuenciales no son muy recomendadas en LabVIEW, ya que no

permiten aprovechar el paralelismo inherente del LabVIEW, ellas garantizan el orden de
ejecución pero limita las operaciones paralelas.
154
Ejemplo de Aplicación 11: Objetivo, desarrollar un programa que establezca una

comunicación serial.
Definir el problema: Crear un programa que configure el puerto de comunicación serial

y escriba caracteres en el puerto definido por el usuario y finalice la comunicación. El
programa debe detectar cualquier posible error en la comunicación de datos.
Diseñar soluciones: Se van a manejar los recursos de identificación de las entradas

INPUTS y salidas OUTPUTS de datos, para ello se genera una tabla de identificación de
variables dada en la tabla 8.3. Se utiliza como recurso opcional el diagrama de flujo (Figura
8.10), para estructurar el programa.

Configuración Serial INPUT Control Cluster 5 variables tipo entero:
-. Velocidad de Comunicación.
-. Bits de Datos.
-. Paridad.
-. Bit de parada.
-. Control de Flujo
Puerto de INPUT Control String Cadena de caracteres a escribir en
Comunicación el puerto serial.
Caracteres INPUT Control String Real punto flotante
Aplicación: Se utiliza la estructura FLAT SEQUENCE CASE la cual permite activar en

forma secuencial los diferentes pasos requeridos en la comunicación serial. El primer paso
155
debe estar conformado por la configuración del puerto de comunicación y la selección del
puerto. Finalizado este paso en forma secuencial se procede a ejecutar el subVI de escritura
en puerto serial, indicando la cadena de caracteres a trasmitir al puerto, la ruta del puerto y
un posible error en la comunicación. La siguiente secuencia debe cerrar la comunicación
serial y finalmente imprimir el mensaje de error si se presenta. En la tabla 8.4, se describe
brevemente la estructura y subVIs utilizados en este ejemplo.

Flat Sequence Structure: Una estructura de Secuencia está
formada por una serie de subdiagramas que se ejecutan
secuencialmente de izquierda a derecha.
Visa Configure Serial Port: Es un VI utilizado para configurar
todos los parámetros de la comunicación serial, indicando la
velocidad, bits de datos, paridad, bit de parada y control de flujo.
Visa Write: Es un VI utilizado para escribir la data en el puerto de
comunicación VISA seleccionado.
Visa Close: Es un VI utilizado para cerrar el puerto de
comunicación VISA seleccionado.
Simple Error Handler: Indica y describe la presencia de un error
en un subVI.
Según el algoritmo y las funciones de código de LabVIEW, se tiene el siguiente

diagrama de bloques de la figura 8.11, para la estructura de secuencia en la
comunicación con el puerto serial.
Figura 8.11. Código de programación de la aplicación.

156
Prueba y verificación: En la figura 8.12, se puede observar el Panel Frontal del programa,
donde se configura y selecciona el puerto de comunicación y también el mensaje en
caracteres que se desea escribir en el puerto, si no se detecta error el mensaje se escribe en
el puerto seleccionado.
Si se presenta algún error en la comunicación, el último bloque de la secuencia

manda un mensaje al usuario, donde define el tipo de error y detecta la posible causa. En
la figura 8.13 se observa de error provocado por error en la librería de configuración del
puerto VISA.
Figura 8.13. Mensaje del error mostrado al usuario.

157
Estructura de Eventos EVENT
Una estructura de Eventos, tiene uno o más subdiagramas o casos de eventos. La

estructura de Eventos espera hasta que ocurre un evento, y luego ejecuta el caso apropiado
para manejar ese evento. Se debe conectar de un valor de tiempo de espera de la terminal
en la parte superior izquierda de la estructura para especificar el número en milisegundos
que la estructura espera por un evento. El valor predeterminado es -1.
Se puede configurar un solo caso de evento para manejar múltiples eventos, pero
sólo uno de estos eventos en el caso de eventos puede ocurrir a la vez. Debe colocar la
estructura de Eventos en un lazo While para manejar múltiples eventos. Los eventos
pueden originarse desde la interfaz de usuario, puertos externos I/O, etc. Los eventos
incluyen clic del ratón, pulsaciones de teclas y así sucesivamente. Los eventos externos de
I/O pueden incluir temporizadores, hardware, señal de la adquisición de datos o cuando se
produce una condición de error.
Componentes de la estructura de Eventos: A continuación se muestran los elementos

que conforman una estructura de evento, ver figura 8.14:
1. La etiqueta selector de eventos específica el caso de evento que se está ejecutando.
Para ver otros casos, hacer clic en la flecha hacia abajo junto al nombre del caso.
2. El terminal Timeout especifica el número de milisegundos para esperar un evento
antes que culmine el tiempo de espera.
3. Terminales de eventos dinámicos, aceptan una referencia o Cluster para registro de
eventos o eventos dinámicos.
4. El nodo de datos de eventos identifica los datos que el LabVIEW retorna al
programa cuando se produce un evento.
5. El nodo filtro del evento, identifica los datos del evento que se pueden modificar
antes de que la interfaz de usuario puede procesar esos datos.
6. La estructura Evento utiliza también los llamados túneles, sin embargo, no se tiene
que cablear salidas al túnel de la estructura en todos los casos de los eventos.
158
Figura 8.14. Estructura de Eventos y sus componentes.
Crear una estructura de Eventos: En el siguiente esquema se muestran los pasos para
crear o generar eventos personalizados o eventos de usuario.
Paso 1: Utilizando la función CREATE USER EVENT (Figura 8.15), retorna la referencia
de un evento de usuario, se puede utilizar para registrar un evento o para generar un evento,
ella requiere como información de entrada el nombre del evento y el tipo de dato del evento.
Figura 8.15. Función Create User Event.
Paso 2: Si se toma la opción de registro de evento, se utiliza la función REGISTER FOR

EVENT (Figura 8.16), esta función registra dinámicamente uno o más eventos de usuario.
159
Figura 8.16. Función Register For Event.
Paso 3: La referencia de salida del registro de eventos se lleva a la estructura de eventos,

y se conecta al terminal de eventos dinámicos, también se despliega dentro de la estructura
los datos del nodo del evento para acceder a los elementos asociados a ese evento. La
estructura de Evento debe estar dentro de una estructura repetitiva While para que este
constantemente monitoreando el momento en que se presente el evento.
Paso 4: Para generar un evento se utiliza la función GENERATE USER EVENT (Figura
8.17), se enlaza el evento creado y le asocia data al evento para cada evento registrado.
Figura 8.17. Función Generate User Event.
Paso 5: Para eliminar el registro del evento referenciado, se utiliza la función

UNREGISTER FOR EVENTS (Figura 8.18), y automáticamente elimina todos los
registros asociados al evento.
Figura 8.18. Función Unregister For Events.
Paso 6: El paso siguiente a eliminar el registro de los eventos, para ello se utiliza la función
DESTROY USER EVENT (Figura 8.19), destruyendo todo los eventos referenciados.
160
Figura 8.19. Función Destroy User Event.
Utilizando las funciones anteriores, se puede estructurar un programa para el uso

de eventos, de la forma que se observa en la figura 8.20:
Figura 8.20. Estructura completa para crear y utilizar eventos.
Estructura de tiempo TIMED
Ejecuta una o más subdiagramas secuencialmente en cada iteración del bucle en el

período de tiempo que se especifique. Definen estructuras semejantes al While y al
SEQUENCE, dividiendo al lazo TIMED en dos estructuras diferentes, la estructura
TIMED LOOP donde el subdiagrama es semejante al While con ciclos que son repetitivos,
y la estructura TIMED SEQUENCE donde el subdiagrama es semejante a la estructura
SEQUENCE con ciclos que no son repetitivos y que se ejecutan en forma secuencial. En
la figura 8.21, se muestran las estructuras TIME LOOP y TIME SEQUENCE.
161
Figura 8.21. Estructuras de tiempo TIMED LOOP y TIMED SEQUENCE.
El TIMED LOOP, se utiliza, para desarrollar VIs con sincronización de rangos de

tiempo, precisión de tiempo, ejecución de un lazo cerrado, procesos con características que
cambian dinámicamente, o varios niveles de prioridad de ejecución de tiempo.
Las estructuras TIMED, presentan nodos de entrada y salida como se ve en la figura 8.22.
Figura 8.22. Estructura de tiempo TIMED.
Nodo de Entada: Presenta cuatro conectores básicos, como se muestra en la figura 8.23:
• Source Name: Especifica el nombre de la fuente del temporizador a utilizar para
el control de la estructura.
• Offset: Especifica la longitud de tiempo que el Timed espera para la ejecución.
• Priority: Específica cuándo la estructura se ejecuta en el Diagrama de Bloques en
relación con otros objetos del Diagrama de Bloques.
162
• Processor: Especifica el procesador que desea controlar la ejecución. El valor

predeterminado es -2, lo que significa LabVIEW automáticamente asigna un
procesador. Para asignar manualmente un procesador, introduzca un número entre
0 y 255, donde 0 representa el primer procesador.
Figura 8.23. Nodo de entrada del TIMED.
Al hacer doble clip sobre el nodo de entrada, se abre una ventana donde se pueden
configurar con más facilidad los parámetros del TIMED LOOP y SEQUENCE, como se
observa en la figura 8,24
Figura 8.24. Configuración de los parámetros del TIMED.
Nodo de Salida: propaga los valores de error y los valores de ejecución de las diferentes
estructuras del TIMED en ejecuciones previas y actuales, ver figura 8.25.
163
Figura 8.25. Nodo de salida del TIMED.
Estructura de Sustitución IN PLACE ELEMENT
Estructura que permite sustituir valores de elementos, cuando se operan en el

interior de una matriz, cluster, forma de onda, elementos de registro de datos, sin que el
compilador copie y mantenga los valores en la memoria. Dicha operación aumenta la
eficiencia de la memoria y el VI, para agregar una estructura de datos se hace clic en el
borde de la estructura y seleccione el nodo que coincide con la operación que desea realizar.
En la figura 8.26, se observa la estructura IN PLACE ELEMENT con y sin elementos.
Figura 8.26. Estructura de sustitución IN PLACE ELEMENT.
Estructura DIAGRAM DISABLE
Tiene uno o más subdiagramas, o casos, de los cuales sólo el subdiagrama que sea
habilitado ENABLED se ejecuta. En la figura 8.27, se observa las condiciones de la
estructura, puede utilizar un túnel para enviar o recibir información fuera de la estructura
y desactiva los subdiagramas que estén como DISABLED.
164
Figura 8.27. Estructura DIAGRAM DISABLE.
Estructura CONDITIONAL
Tiene uno o más subdiagramas, dependiendo de la configuración de las condiciones

de los subdiagrama, se utiliza la estructura cuando se desea desactivar secciones específicas
de código en el Diagrama de Bloques basado en alguna condición definida por el usuario.
Cuando se hace clic en el borde de la estructura, se selecciona la función Edit Condition
For This Subdiagram, este comando permite editar la condición para el subdiagrama y
poder configurar las condiciones en el cuadro de diálogo que se observa en la figura 8.28
con los valores descritos en la tabla 8.5.
Figura 8.28. Estructura CONDITIONAL.

165
Tabla 8.5. Configuración Estructura CONDITIONAL.

Comando Definición Valor
TARGET_TYPE Especifica en qué plataformas o en que Windows, FPGA,
tarjetas se ejecuta el subdiagrama. Embedded, RT, Mac,
Unix, Pocket PC y DSP
TARGET_BITN Especifica el valor de bits de la plataforma 32
ESS en la que se ejecuta el subdiagrama. 64
RUN_TIME_EN Especifica si el subdiagrama se ejecuta True
GINE cuando se crea una aplicación independiente False
del LabVIEW o una biblioteca compartida
que utiliza el LabVIEW Run-Time Engine.
Función Formula NODE
Se utiliza cuando se desea evaluar una o varias ecuaciones matemáticas complejas

en LabVIEW o funciones de programación básicas, las conexiones de nodos puedan
manejar muchas funciones aritméticas o comparativas, se puede desarrollar ecuaciones en
un ambiente matemático y después integrar las ecuaciones en la aplicación. La Formula
Node es una estructura basada en lenguaje de texto familiar para programadores en
Lenguaje C.
Se pueden crear los terminales de entrada y de salida de datos del Formula Node,
como muestra la figura 8.29, haciendo clic derecho en el borde de la estructura y
seleccionando añadir entrada o añadir salida del menú contextual, los nombres de los
terminales representan las variables que se manejan en las ecuaciones, al introducir las
ecuaciones en la estructura debe verificar que cada declaración de ecuación debe terminar
con un punto y coma (;).
Figura 8.29. Función Formula Node.

166
El siguiente ejemplo ilustra cómo se puede utilizar la estructura Formula Node

para la toma de decisiones, se observa dos maneras diferentes de usar una la sentencia IF,
ambos códigos de programación producen el mismo resultado. El ejemplo calcula la raíz
cuadrada de una variable X y arroja el resultado de la raíz en una variable Y, si los valores
de X son menor a cero, el resultado es -99999, tal como se observa en la tabla 8.6:
Tabla 8.6. Ejemplo de la función Formula Node, para la raíz cuadrada de un número.
Valor de X Resultado de la raíz cuadrada de X
En la figura 8.30, se muestra el Diagrama de Bloques utilizando la función de

FORMULA NODE para el caso de la raíz cuadrada, asumiendo dos soluciones diferentes.
Figura 8.30. Función Formula Node para ña raíz cuadrada de un número X.

167
Ejemplo de aplicación 12: Dibujar la curva característica de corriente en función del

voltaje, del diodo semiconductor de Silicio
Definir el problema: Diseñe un programa que grafique la ecuación de corriente del diodo
en función del voltaje partiendo de la ecuación de corriente del modelo real del diodo
semiconductor (ecuación 7.1):
= ∙ −1 Eq. 7.1
La corriente del diodo se define como ID, la corriente de arrastre del diodo o
corriente en inverso se define como Io, el valor de tensión de la unión semiconductora en
función de temperatura del diodo se define como Voltaje Térmico VT, el valor de voltaje
de polarización se define con la letra V. Las constantes son la corriente de arrastre que se
puede asumir como: Io=1x10-9 Amp y VT=26 mV. La ecuación 7.1 define la curva
característica del diodo para diferentes voltajes de polarización.
salidas OUTPUTS de datos, para ello se genera tabla 8.7 de identificación de variables. Se
utiliza como recurso opcional el diagrama de flujo de la figura 8.31, para estructurar el
programa.

Voltaje de Polarización INPUT Control Numérico Real punto flotante
Corriente del Diodo OUTPUT Indicador Numérico Real punto flotante
Curva del Diodo OUTPUT Indicador Grafica WAVEformGRAPH

168
Figura 8.31. Diagrama de flujo de la Aplicación.
Aplicación: Se diseña el Panel Frontal con dos indicadores para los valores de la variable
de entrada de voltaje y los valores de salida de corriente, el primero numérico y el segundo
gráfico. El código del programa utiliza una estructura cíclica For para generar el barrido
de voltaje de la ecuación y la estructura Formula Node, para evaluar la ecuación
matemática que describe el modelo de la corriente del diodo. En la figura 8.32, se observa
el diagrama de bloques y código de programación para esta aplicación.
169
Prueba y verificación: En la figura 8.33, observa la curva característica de la ecuación del

diodo, verificando el comportamiento de la corriente para los diferentes valores de
polarización.
Función MATHSCRIPTS NODE
El Nodo de LabVIEW MathScript, Utiliza el módulo de Ingeniería MathScript RT,

que permite crear y procesar Scripts o secuencias de comandos matemáticos basados en
texto, es una estructura similar al FORMULA NODE. Los Scripts se crean utilizando la
sintaxis del LabVIEW MathScripts, basada en términos matemáticos de programación
estándar, en términos generalizados, de uso común, descriptivos abreviaturas,
concatenaciones de términos estándar, entre otros. En la figura 8.34, se observa el
170
MathScripts Node, para el procesamiento de una matriz, con operaciones matemáticas

estándar, acompañadas de una lógica de programación de ciclos repetitivos, observe que
los comandos estándar de programación aparecen en color azul.
Figura 8.34. Función MathScripts Node.
Los terminales de los datos de entrada y salida se anexan en los bordes de la

estructura, haciendo clic sobre el botón derecho y desplegando el menú corto que presenta
las funciones de adicionar entradas y salidas. En la ventana del Script, se utilizan funciones
de programación matemáticas estándar que procesan las variables de entrada y generan un
resultado, estas funciones por lo general aparecen en color azul en el editor de texto. Los
MathScripts Node contienen unos mensajes de advertencia, que implica que el programa
está ejecutándose con un mínimo chequeo de errores y un tiempo de edición y ejecución
más lento para el nodo MathScript.
Ejemplo de aplicación 13: Resolver la ecuación de onda de Schrodinger's, utilizando el

MathScript Node.
Definir el problema: Utilizar el MathScript Node para resolver la ecuación de

Schrodinger's que describe a una partícula atrapada en una barrera de potencial finito, el
usuario debe tener control del potencial de la barrera (Vo), ancho de la barrera (L), la masa
del electrón (Mo) y el número cuántico (N). Debe observar de salida la función de onda y
de la densidad de probabilidad, específicamente en la ancho de la región de –L a L marcada
por un cursor rojo.
171
Diseñar soluciones: Se definen las entradas y salidas de la aplicación, como se muestra en

la tabla 8.8, y para este ejemplo se va a utilizar el diagrama de transición de estados (Figura
8.35).

Voltaje Vo INPUT Control Numérico Real punto flotante
Ancho Barrera L INPUT Control Numérico Real punto flotante
Número cuántico INPUT Control Numérico Entero
Masa del Electrón INPUT Control Numérico Real punto flotante
Energía OUTPUT Indicador Numérico Real punto flotante
Densidad de probabilidad OUTPUT Indicador Grafica WAVEformGRAPH
Función de Onda OUTPUT Indicador Grafica WAVEformGRAPH
Diagrama de transición de estados:
Figura 8.35. Diagrama de transición de estados de la aplicación.

172
Aplicación: Se plantea la ecuación de Schrodinger's que describe a una partícula atrapada

en una barrera de potencial finito, y se precede a Identificar la región de análisis, ver figura
8.36.
Figura 8.36. Región de análisis para la ecuación de Schrodinger's.
En la figura 8.37, se plantea el panel frontal indicando los elementos que se definen
como variables de control y los indicadores gráficos.
Se establece la lógica de programación, evaluando la ecuación de Schodinger´s,

para definir la función de onda y densidad de probabilidad de la partícula. Para ello se
utiliza la estructura NODE MathScripts (Figura 8.38), los detalles de la ecuación de onda
y de la función de probabilidad no se incluyen en las referencias.
173
Figura 8.38. Función de onda y densidad de probabilidad en el MathScripts para la aplicación.
En la figura 8.39, se muestra el diagrama de Bloques usando funciones para el

manejo de cursores sobre la gráfica y un segundo Nodo MathScripts para inicialización de
variables de la ecuación de onda.
Figura 8.39 Diagrama de bloques y código de programación de la aplicación.

174
Prueba y verificación: Al evaluar la ecuación de onda se genera los resultados de la

gráfica 8.40, para los diferentes valores de Vo de menor a mayor potencial:
Figura 8.40. Resultados del comportamiento de la función de onda y la densidad de probabilidad.
Función MATLABSCRIPT
El MATLABSCRIPT (Figura 8.41), es un nodo parecido al MATHSCRIPT, pero

utiliza comandos y funciones propias del Matlab que permite aprovechas las funciones
propias del programa, debe tener instalado el software Matlab en el equipo, porque los
nodos de Script invocan el servidor del software Matlab para ejecutar Scripts escritos en
la sintaxis del lenguaje Matlab. LabVIEW utiliza la tecnología de funciones ActiveX para
implementar Scripts de MATLAB, que sólo están disponibles en Windows.
175
Figura 8.41. Función MatlabScript.
Se analiza el programa que adquiere un valor de temperatura y determina un rango

de operación basado en un valor máximo y mínimo de temperatura, pero se anexa una
nueva variable correspondiente al nivel de llenado de un tanque. Utilice el Método de
Desarrollo de Software
temperatura, en un rango definido por un usuario, el programa debe mostrar el valor de
temperatura en °C ó °F dependiendo del requerimiento del usuario. También debe detectar
el nivel del tanque para definir un rango normal o alto. Se debe generar una advertencia a
través de un mensaje textual que indique las fallas presentes de temperatura y nivel, en un
indicador de texto y en un Led que se encienda en el momento de ocurrencia de cualquier
falla. Mantenga la advertencia sí el rango de operación de temperatura está invertido, es
decir, sí el nivel máximo está por debajo del nivel mínimo de temperatura.
Diseñar soluciones: En la tabla 8.9, se definen las entradas y salidas de la aplicación y

para la Actividad Complementaria se va a utilizar nuevamente el diagrama de transición
de estados de la figura 8.42, para definir la secuencia de programación.
176

dato
Temperatura INPUT Control Numérico Real punto flotante
Nivel Alto INPUT Control Numérico Real punto flotante:
Valores de 500 a 1000 ml
Selector Temperatura INPUT Control Booleano Booleano:
Valor ON/OFF
Nivel INPUT Control Numérico Real punto flotante:
Valores de 0 a 1000 ml
Advertencia Texto OUTPUT Indicador Cadena de Normal Displa y Valores:
caracteres - Temperatura Normal
Y Nivel Normal.
- Temperatura Alta Y
Nivel Normal.
- Temperatura Baja Y
Nivel Normal.
- Temperatura Normal
Y Nivel Alto.
- Temperatura Alta Y
Nivel Alto.
- Temperatura Baja Y
Nivel Alto.
Advertencia OUTPUT Indicador Booleano Indicador Tipo Led.
Temperatura Led Valores: ON ROJO.
OFF VERDE.
Advertencia Nivel OUTPUT Indicador Booleano Indicador Tipo Led.
Led Valores: ON ROJO.
OFF VERDE.
Indicador de OUTPUT Indicador Numérico Real punto flotante
Temperatura °C ó °F Valores de 0 a 200 °C
177
Diagrama de transición de estados:
Figura 8.42. Diagrama de transición de estados de la Actividad Complementaria 7.

.
Aplicación: Se diseña la ventana del Panel Frontal como se muestra en la figura 8.43,
procediendo a buscar tres controladores numéricos para la temperatura, el termómetro y
los otros dos para el rango de operación máximo y mínimo de temperatura, se anexan dos
controles numéricos de nivel, uno representado por un tanque y otro que define el rango
máximo de nivel. Para las variables de salida se agrega un indicador tipo cadena de
caracteres que contiene los mensajes de alarmas de nivel y temperatura. Cada vez que se
presente una alarma se debe encender un Led, por lo que se requiere dos indicadores tipo
booleanos para alarmas de temperatura y nivel. Finalmente se anexa un indicador numérico
donde se muestra el valor de la temperatura en °C ó en °F dependiendo de otro control
booleano tipo interruptor, que le permita al usuario seleccionar el modo de visualización
de la temperatura.
178
Figura 8.43. Panel frontal de la Actividad Complementaria 7.
La estructura de programación utiliza funciones propias o sub vi para facilitar las

operaciones en el Diagrama de Bloques, lo primero que se define en el programa es la
función de error, si el usuario invierte los rangos máximos y mínimos de temperatura, se
usa una función de comparación y se llama al subVI programado para el error. La función
de error utiliza una estructura CASE, la cual se activa cuando ocurre el error y manda un
mensaje de cuadro de dialogo tal como se observa en la figura 8.44.
Figura 8.44. SubVI personalizado para determinar el error de inversión de los rangos de temperatura y su
estructura interna. .
179
Si el error no ocurre o se corrige se procede a verificar los niveles de operación de

la temperatura y el nivel. Para el nivel se puede hacer directo con una función de
comparación y un SELECT, debido a que se presenta una sola alarma “NIVEL ALTO”. El
resultado del comparador nos sirve para encender el Led de alarma de nivel. La figura 8.45,
muestra el código de programación para determinar el nivel del tanque.
Figura 8.45. Código de programación para determinar el nivel del tanque.
Para la temperatura hay dos alarmas a monitorear, por lo que se procede con
SELECT anidados, y se crea un subVI que ejecute la función de comparación y retorne el
resultado del mensaje de alarma y la señal del Led. En la figura 8.46, se observa el código
de programación de las alarmas de temperatura y la estructura interna del SubVI.
Figura 8.46. Código de programación para determinar alarmas de temperatura y estructura interna del
SubVI de alarmas.
180
La función de la figura 8.47, corresponde al selector de temperatura para definir en

la unidad que se desea visualizar, entre °C y °F. La función de conversión de °C a °F, se
programa utilizando la estructura FORMULA NODE, donde se evalúa la ecuación
matemática que realiza la conversión de temperatura.
Figura 8.47. Código de programación Para convertir temperatura de °C a °F y código del SubVI.
El código de programación se mantiene en el interior de una estructura repetitiva

While que se detiene con el botón de stop, como se observa en la figura 8.48.
Prueba y verificación: Se realizan diferentes pruebas, primero se asume una falla en los
valores del rango de entrada de temperatura máxima y mínima, para visualizar mensaje de
error, que se muestra en la figura 8.49.
181
Figura 8.49. Prueba de la inversión del rango de temperatura.
Después se corrige la falla, y se procede a variar los valores de temperatura para

un rango de nivel del tanque normal y luego valores de temperatura para un nivel del tanque
alto. También se realizan pruebas de temperatura en grados Centígrados y Fahrenheit. En
las figuras 8.50 y 8.51, se establecen algunas de las pruebas que verifican el
funcionamiento del programa.
Figura 8.50. Prueba de la activación de alarma de temperatura.
Figura 8.51. Prueba de la activación de alarma de nivel.

182
Capítulo IX
Manejo de datos para estructuras complejas.
El manejo de datos para estructuras complejas formadas por elementos de

diferentes tipos de datos, son de gran utilidad cuando se desea trabajar con datos similares
sometidos a operaciones repetitivas. Se definen y se manejan los comandos Arrays para la
generación de un vector de cualquier tipo de dato, Matrix para generar estructuras de mayor
dimensión formadas por los elementos de los vectores y Cluster para generar estructuras
con elementos formados por diferentes tipos de datos en un solo arreglo.
Los arreglos se componen de elementos y dimensiones. Los elementos son los datos
que lo conforman y la dimensión es la longitud, la altura, o profundidad que lo define. Los
arreglos los podemos establecer en vectores y matrices, un vector se establece como un
arreglo de una dimensión formado por (231)-1 elementos; una matriz puede tener más de
una dimensiones y un máximo de (231)-1 elementos por dimensión si la memoria lo
permite. Se puede construir vectores y matrices numéricas, booleanas, cadena de
caracteres, forma de onda, Cluster, entre otras. En el caso de los Cluster pueden tener el
comportamiento similar de un vector pero sus elementos se pueden componer de diferentes
tipos de datos, incluso vectores y matrices. Los temas de este capítulo son los siguientes:
-. Arreglos Vectores.
-. Arreglos Matrices.
-. Arreglos Cluster.
Arreglos Vectores
Los arreglos se conforman por dos contenedores de datos, uno externo que se
acompaña de un selector de posición para ubicar el elemento del arreglo, y uno interno
donde se puede ver el tipo de dato y los diferentes elementos del arreglo. A continuación
183
se observa en la figura 9.1, el arreglo con un conector de datos numérico interno en este
caso representado por un control numérico tipo real. Por defecto se puede apreciar el
arreglo con un solo elemento, el cual pertenece a la posición que indique el selector; si se
requiere visualizar todos los elementos del arreglo se puede expandir el tamaño de la
estructura en forma horizontal o vertical para apreciar todos los elementos.
Figura 9.1. Arreglo de un controlador numérico.
LabVIEW presenta tres mecanismos para crear vectores, uno desde el Panel Frontal
y dos desde el Diagrama de Bloques, a continuación se describen las tres técnicas:
Desde el Panel Frontal: se accede a la Paleta de Control y se busca la función de ARRAY

(Figura 9.2), MATRIX & CLUSTER, se selecciona ARRAY.
Figura 9.2. Paleta de Controles del Array.

184
El conector seleccionado equivale al contenedor de estructura de N dimensión tal

como se puede ver en la imagen 9.3.
Figura 9.3. Contenedor de Arreglos sin definir tipo de datos.
Se procede a buscar en la Paleta de Control el indicador o controlador que se desea

utilizar con el vector, se selecciona y coloca en el interior del contenedor de la estructura
ajustándose al tipo de dato booleano, numérico o cadena de caracteres. La figura 9.4,
muestra los arreglos para distintos tipos de datos.
Figura 9.4 Arreglos para diferentes tipos de datos.
Desde el Diagrama de Bloques usando el lazo For: Se selecciona la estructura cíclica

For, la estructura genera a la salida por defecto es un vector, como lo muestra la figura 9.5,
con el número de elementos que se le asigna al ciclo repetitivo.
Figura 9.5. Vector generado por un lazo For.

185
Desde el Diagrama de Bloques con BUILD ARRAY: Se selecciona la Paleta de

Funciones, ver figura 9.6, y se busca la opción ARRAY, donde se encuentran ubicadas
todas las funciones para crear vectores, estructurar y procesar los elementos que conforman
un vector.
Figura 9.6. Paleta de funciones de los arreglos.
Se selecciona la función BUILD ARRAY (Figura 9.7), la cual se requiere para crear
un vector enlazando componente por componente para definir la estructura. Se puede
expandir dependiendo del número de elementos que se le desean agregar al vector, al
conectar los diferentes elementos de entrada, deben corresponder al mismo tipo de datos y
la función genera la estructura tipo vector a su salida, se puede con el botón derecho del
cursor seleccionar crear indicador y el programa genera la estructura de salida tipo vector.
Figura 9.7. Función Build Array.
Como se observó en la tercera técnica para crear vectores, se utiliza la Paleta de

Funciones y los comandos relacionados con los arreglos. En la tabla 9.1, se describe la
utilidad de algunas de las funciones utilizadas para procesar los elementos de un arreglo.
186
Tabla 9.1 Funciones de Arrays y ejemplos.

Función Ejemplo
Tamaño del Arreglo: Retorna el número
de elementos de un vector. La entrada es el
vector y la salida el tamaño.
Indexar arreglo: Se utiliza para extraer

elementos de un vector. Las entradas
corresponden al vector y al número del
elemento a indexar y la salida retorna el
valor del elemento.
Remplazar elementos del arreglo: Se

utiliza para sustituir elementos del vector.
Las entradas corresponden al vector, la
posición, y el nuevo elemento. La salida
retorna el vector con el nuevo elemento.
Ejemplo de aplicación 14: Crear un programa para girar e invertir el giro de un motor.
Definir el problema: Crear un regulador que mueva un motor en sentido horario o anti
horario, asumiendo que el motor se alimenta de 4 bits que tienen un código que rota en un
bit cada movimiento, dependiendo del sentido de giro del motor a la derecha o a la
izquierda. Utilizar vector booleano
187
Diseñar soluciones: Definir las variables de entrada y salida del programa, tal como se
muestra en la tabla 9.2

Bits del código de giro INPUT Control Array Booleano
Velocidad de giro INPUT Control Numérico Real punto flotante
Bits del código de giro OUTPUT Indicador Array Booleano
Aplicación: Se crea un Panel Frontal con un vector booleano de cuatro elementos que
represente los bits de control del motor, se activan 2 bits y se dejan 2 en bajo para simular
el código que requiere el motor para iniciar su movimiento. Se procede a crear un regulador
que permita dar cinco pasos en sentido horario y cinco pasos en sentido anti horario para
asignar el número de veces que va rotar el motor y el sentido. Se utiliza el comando rotación
de vector de las funciones de Arrays, para generar el movimiento de los bits que controlan
el giro del motor. E la figura 9.8, se muestra el código de programación para la propuesta
de esta aplicación.
Figura 9.8. Código de programación de la aplicación.
Prueba y verificación: Se ejecuta el programa probando los diferentes puntos de rotación

del motor en sentido horario y anti horario, comprobando la rotación correspondiente al
código definido para los 4 bits, como se muestra en la figura 9.9.
188
Figura 9.9. Prueba de la inversión de giro del motor.
Arreglos Matrices
Los arreglos cuando presentan más de una dimensión los podemos plantear como
matrices, igual que en el caso de los vectores; la matriz se conforma por dos contenedores
de datos uno externo que se acompaña de un selector de posición para ubicar el elemento
y uno interno donde se puede ver el tipo de dato y los diferentes elementos del arreglo.
Para el caso de la matriz el selector externo se le agrega una dimensión, esto se hace
ubicando el cursor sobre el selector numérico y en el menú desplegable seleccionar la
opción añadir dimensión, quedando el contenedor como se observa en la figura 9.10.
Figura 9.10. Contenedor de Arreglos con dos dimensiones.
La matriz se puede representar con una tabla como se muestra en la figura 9.11, la
cual identifica los elementos por filas y columnas, al contenedor de la matriz se le introduce
el elemento con el tipo de dato correspondiente, por defecto se puede apreciar la matriz
189
con un solo elemento, el cual pertenece a la posición que indique los dos selectores (uno
de fila y el otro de columnas). Si se requiere visualizar todos los elementos del arreglo se
puede expandir el tamaño de la estructura en forma horizontal y vertical para apreciar todos
los elementos.
Figura 9.11. Elementos del arreglo matricial para dato numérico.
. LabVIEW facilita cuatro mecanismos para crear matrices, a continuación se

describen las técnicas:
Desde el Panel Frontal: Acceder a la Paleta de Control y buscar la función ARRAY,

MATRIX & CLUSTER, seleccionar ARRAY, para escoger el conector, y añadir una
dimensión desde el menú desplegable. Luego proceder a buscar en la Paleta de Control el
indicador o controlador a utilizar en la matriz; se selecciona y se coloca en el interior del
contenedor de la estructura e inmediatamente la estructura se ajusta al tipo de dato, ver
figura 9.12.
Figura 9.12. Arreglos de matrices para diferentes tipos de datos.

190
Desde el Panel Frontal para Matrices Reales y Complejas: Acceder a la Paleta de

Control de la figura 9.13, buscar la función ARRAY, MATRIX & CLUSTER y seleccionar
Matriz Real o Compleja.
Figura 9.13, Panel de Control para seleccionar las Matrices Reales y Complejas.
El comando seleccionado, genera una matriz numérica de tipo Real y Compleja,

como muestra la figura 9.14, con un formato en el Panel Frontal más amigable para el
usuario.
Figura 9.14. Matrices reales y complejas.
Desde el Diagrama de Bloques con la estructura cíclica For: Se hace un lazo anidado
con dos For uno dentro del otro, la primera estructura genera a la salida por defecto un
vector y la segunda estructura genera una matriz, el N del For interno corresponde a las
filas y For externo las columnas. La figura 9.15, muestra matrices generadas por for
anidados.
191
Figura 9.15. Matrices generadas por For anidados.
Desde el Diagrama de Bloques con la función Build Matrix: Seleccionar la Paleta de

Funciones buscar ARRAY allí se busca la función MATRIX, selecciona la función Build
Array (Figura 9.16), la cual se requiere para crear un arreglo enlazando componente por
componente para definir la estructura; se puede expandir dependiendo del número de
elementos que se le desean agregar al arreglo. Al conectar los diferentes elementos de
entrada deben ser tipo vector y corresponden al mismo tipo de datos, la función genera la
estructura tipo matriz a su salida, se puede con el botón derecho del cursor seleccionar crear
indicador y el programa genera la estructura de entrada tipo vector y salida tipo matriz.
Figura 9.16. Matrices generada por Build Array.
Como se observó en la última técnica para crear matrices, se utiliza la Paleta de

Funciones y los comandos relacionados con los arreglos. En la tabla 9.3, se describe la
utilidad de alguno de los comandos utilizados para procesar los elementos de una matriz.
Tabla 9.3 Funciones de Arrays para matrices y ejemplos.
192
Función Ejemplo
Tamaño de la matriz: Retorna el número
de filas y columnas de una matriz
Cambiar tamaño de la matriz: Se utiliza

para modificar el número de filas y
columnas de una matriz.
Matriz transpuesta: Calcula la transpuesta

de una matriz, invierte filas por columnas.
Obtener y establecer elementos de una

matriz: El primero se utiliza para obtener
los elementos seleccionados de una matriz.
El segundo remplaza elementos dentro de
la matriz.
193
Ejemplo de aplicación 15: Crear un conteo decimal ascendente y descendente.
Definir el problema: Crear una pantalla de Leds, para visualizar un conteo ascendente y
descendente en decimal de 0 a 9, con un tiempo controlado para el cambio de digito.
Utilizar matriz booleana.
muestra en la tabla 9.4.

Selector de conteo INPUT Control Interruptor Booleano
Velocidad del conteo INPUT Control Numérico Real punto flotante
Pantalla de Leds OUTPUT Indicador Array Matriz Booleano
Aplicación: En la figura 9.17, se crea un Panel Frontal con una matriz booleana de 9x8
que represente la pantalla de Leds. También se crea un control tipo interruptor para
seleccionar el modo de conteo y un control numérico para indicar el retardo en segundos
que va permanecer cada digito en pantalla.
Figura 9.17. Panel frontal de la aplicación 14.
Se utiliza el lazo For, para realizar el conteo decimal, el contador “i” del lazo For,
se programa para que realice un conteo ascendente y descendente con un SELECT
194
controlado por el controlador booleano tipo interruptor, y se utiliza una estructura CASE
para definir el valor de la constante numérica que se va imprimir en la pantalla de Leds. Se
introduce el control numérico para controlar el retardo de tiempo que dura cada digito en
cambiar. En la figura 9.18, se observa la programación para la aplicación 14.
Figura 9.18. Código de programación de la aplicación 14.
Las constantes que se imprimen en las pantallas de Leds, deben configurarse en

forma independiente para cada uno de los dígitos del conteo decimal en este caso valores
que van del 0 al 9. En la figura 9.19, se observa la constante correspondiente al digito 3.
Figura 9.19. Constante booleana del digito 3, para la pantalla de Leds.
Prueba y verificación: El programa debe ejecutar en los modos ascendentes y

descendentes, como se muestra en la tabla 9.5, los cuales son controlados por el interruptor
booleano, utilizando un regulador de velocidad numérico tipo perilla para incrementar o
disminuir la velocidad del conteo.
195
Tabla 9.5 Resultados.

Modo Respuesta
ASCENDENTE
DESCENDENTE
Arreglos Cluster
Cuando se requiere unificar elementos de diferentes tipos de datos y que tengan

diferentes dimensiones se puede utilizar un Cluster (Figura 9.20). Igual que en el caso de
los arreglos, el Cluster se conforma por un contenedor de datos donde se puede ubicar sus
elementos y se pueden agregar elementos con diferente tipo de dato y dimensiones.
Figura 9.20. Contenedor de Cluster.
Al contenedor se le introduce elementos con diferente tipo de datos y dimensiones,

para ello se selecciona cada controlador en la paleta de controles y uno a uno se van
ubicando en el interior del contenedor de Cluster, tal como se observa en la figura 9.21.
196
Figura 9.21. Elementos de un Cluster.
LabVIEW presenta varias vías para crear Cluster. A continuación se describen las
técnicas que lo permiten hacer, desde el Panel Frontal y desde el Diagrama de Bloques:
Desde el Panel Frontal: En la Paleta de Control se busca la función de ARRAY, MATRIX

& CLUSTER, se selecciona Cluster para escoger el contenedor, luego procede a buscar en
los indicadores o controladores que se desean utilizar y se introducen en el contenedor.
Desde el Panel Frontal con función de ERROR: Se busca en la Paleta de Control la

función de ARRAY, MATRIX & CLUSTER, se selecciona ERROR IN si se requiere un
Cluster de controlador o ERROR OUT si se desea un Cluster de indicador, estos Cluster
son los utilizados por las funciones propias de LabVIEW para el manejo de errores de
entrada y salida de las funciones. El Cluster de error presenta un dato booleano de status,
un dato numérico para asignar código al error y un dato tipo cadena de caracteres para
describir el error y el procedimiento a ejecutar, sin embargo si se desea agregar o eliminar
elementos se puede hacer de la misma forma como se hizo en la técnica anterior. En la
figura 9.22, se observa el Cluster de Error.
Figura 9.22. Cluster de error para controlador e indicador.

197
Desde el Diagrama de Bloques: Se selecciona la Paleta de Funciones y se busca la opción

CLUSTER, CLASS & VARIANT, donde se encuentran ubicadas todas las funciones para
crear Cluster. La función BUNDLE se puede utilizar para crear o modificar un Cluster,
adjuntando elemento por elemento ya sea por tipo de dato o por nombre. La función
UNBUNDLE realiza el procedimiento contrario, desarma un Cluster y extrae cada uno de
los elementos que lo conforman. En la tabla 9.6, se describe las funciones elementales
Bundle y Unbundle.
Tabla 9.6 Funciones Bundle y Unbundle.

Función Ejemplo
BUNDLE: Crear o modificar un Cluster de
diferentes tipos de datos.
UNBUNDLE: Descomponer un Cluster y

desarmar los diferentes tipos de datos.
Existen otro grupo de funciones que facilitan las operaciones con los Cluster, en la
tabla 9.7, se observan algunas de esas funciones.
198
Tabla 9.7 Funciones de los Cluster.

Función Ejemplo
BUNDLE BY NAME: Se utiliza para
remplazar uno o más elementos de un
Cluster.
UNBUNDLE BY NAME: Extraer un

elemento de un Cluster.
Construir Arreglos de Cluster: Se utiliza

la función para construir un arreglo de un
tipo de datos como un Cluster.
Conversión de Arreglos a Cluster y

viceversa: Convierte Arreglo de un tipo de
dato a Cluster y viceversa.
Utilizar la función Cluster, para el manejo de errores.
Definir el problema: Utilizar el Cluster de error para verificar el error de un VI Express

que genere señales analógicas con un rango de frecuencia variable.
199
Diseñar soluciones: Variables de entrada y salida del programa, en la tabla 9.8.

Frecuencia INPUT Control Numérico Real punto flotante
Fase INPUT Control Numérico Real punto flotante
Función de Onda OUTPUT Indicador Grafica WAVEformCHART
Aplicación: En la figura 9.23, se crea un Panel Frontal con un indicador gráfico para
visualizar una señal sinusoidal y dos controles numéricos que permitan variar la frecuencia
y la fase de una señal generada por un VI Express. Se utiliza un Cluster para indicar la
presencia de un error del VI Express.
El VI Express del Simulador de señales, se consigue en la paleta de funciones del

Diagrama de Bloques en la función de procesamiento de señales (Figura 9.24).
Figura 9.24. Paleta de funciones del VI Express del generador de señales.

200
Al colocar el VI Express, se expande un Panel Frontal donde se configurar las

características relevantes de la señal, tipo de onda, amplitud, frecuencia, fase, frecuencia
de muestreo, offset, en la figura 9.25, se muestra la configuración del VI Express.
Figura 9.25. Panel de programación del VI Express del Simulador de Señales.
El While se utiliza para el generador de señales y se le coloca dos controladores

numéricos para la fase y la frecuencia. En la salida del VI Express se ubica un indicador
tipo gráfico para visualizar la onda de salida, según el teorema de Nyquist la frecuencia de
muestreo de una señal debe ser por lo menos 100 veces mayor que la frecuencia de la señal,
esto quiere decir que si el usuario introduce valores de frecuencia que no cumplan el
teorema se genera un error interno del VI Express que se puedo visualizar en un Cluster
de error. En el momento que el Error se produzca, se detiene el ciclo While, por lo que se
recomienda con la función UNBUNDLE extraer el Estatus del error que está representado
por un valor booleano y utilizarlo como control del While. En la figura 9.26, se muestra la
programación para la actividad complementaria 8.
201
Figura 9.26 Código de programación de la Actividad Complementaria 8.
Prueba y verificación: En la tabla 9.9, se ejecuta el programa para valores de frecuencia

que cumplan y no cumplan con el Teorema de Nyquist, mostrando los mensajes del Cluster
de Error.
Tabla 9.9 Resultados.

Frecuencia Respuesta
F=100 Hz
Se observa que la onda es muestreada sin
ninguna restricción, el Cluster del Error
No define ningún código de error y el
estatus está habilitado
202
Capítulo X
Almacenamiento de Datos
Los sistemas reales están formados por un gran número de variables que requieren
ser procesadas y analizadas para obtener estrategias de control y monitoreo de datos. En
los capítulos anteriores se han desarrollado técnicas de programación para el procesamiento
de datos, sin embargo, los datos adquiridos y procesados requieren en la mayoría de los
casos ser registrados o almacenados para hacer un análisis detallado de los mismos y
permitir definir comportamientos en los procesos monitoreados.
En este capítulo, se explican las técnicas para registrar datos de mediciones reales
o simuladas, almacenar información y poder utilizarla en análisis posteriores a la
adquisición; se utiliza la técnica de almacenamiento de archivos. Las operaciones de
registro o almacenamiento de datos de medición se componen de funciones tales como:
Crear archivos de datos, abrir y cerrar archivos de datos, lectura y escritura de datos en
archivos binarios y de texto, documentos en formato de hoja de cálculo, mover y cambiar
nombre de los archivos y directorios, entre otros. LabVIEW maneja un tipo de registro para
datos de mediciones definido con la extensión *.Lvm, el cual permite escribir a o leer en
archivos de medición del LabVIEW (LabVIEW Measurement Files).
El almacenamiento de datos en LabVIEW, consiste en registrar o leer datos de un

archivo, como una operación de E/S que implica el proceso que va desde la apertura o
creación, lectura o escritura, cierre y verificación de errores. Los temas a desarrollar son
los siguientes:
-. Almacenamiento de Archivo de E / S.
-. Almacenamiento de Bajo Nivel E / S.
-. Almacenamiento de Alto Nivel E / S.
-. Actividad complementaria 9.
203
Almacenamiento de Archivos de E/S
El arreglo o almacenamiento de archivos de entrada y salida, cumple funciones de

registro o lectura de datos de un archivo, basados en el siguiente proceso:
1. Abrir un archivo para indicar que existe y reside en una dirección.
2. Crear un nuevo archivo, debe especificar una ruta o responder a un cuadro de
diálogo para dirigir LabVIEW la ubicación del archivo.
3. Procedimiento de leer o escribir en el archivo para plasmar los datos medidos que
se desean registrar en el formato de almacenamiento adecuado o cargar datos
previamente almacenados para procesarlos en el programa.
4. Cierre del archivo después de utilizarlo si no se va a procesar más información.
5. Verificar errores que detecten cualquier anomalía en el proceso de compresión.
En la figura 10.1, se observa los bloques que define el proceso de almacenamiento

de archivos, se observa que el paso 2 debe estar en el interior de una estructura repetitiva
condicionada por el usuario o por la presencia de algún error.
Figura 10.1. Almacenamiento o arreglo de archivos.
Los archivos que se crean para registrar datos de mediciones pueden tener los
siguientes formatos: Binario, ASCII, LVM, y TDM.
204
Los archivos Binarios representan el formato estándar de todos los otros formatos
de archivo.
Los archivos ASCII son es un tipo específico de archivo Binario que se componen
del código ASCII, que es una norma utilizada por la mayoría de los programas, en
LabVIEW también se le denominan archivos de texto.
Los archivos LVM es el estándar de medición de LabVIEW (.lvm). Tiene un

formato que permite apertura con aplicaciones de hoja de cálculos en editores de texto. El
archivo .lvm incluye información adicional, tal como la fecha y hora de la generación de
los datos, el formato de archivo es ASCII específicamente creado para LabVIEW.
El archivo TDM es un tipo específico de archivo binario creado para productos de

National Instruments. En realidad se compone de dos archivos separados: una sección
XML que contiene los atributos de los datos y un archivo Binario para formas de onda.
Almacenamiento de Bajo Nivel E/S
El almacenamiento de Bajo Nivel, cumple estrictamente los cuatro pasos del

proceso de almacenamiento de archivos, es decir, crear o abrir archivo, lectura o escritura,
cierre y chequeo de errores. Establece una conexión y transferencia de datos en forma
secuencial que permita la correcta ejecución del almacenamiento. En la siguiente imagen
se puede ver las funciones requeridas para cumplir los pasos del proceso de comprensión
de archivos, estas funciones se utilizan para tipo de datos binarios ASCII, los datos de
escritura o lectura son tipo cadena de caracteres o string, por lo que se requiere establecer
procesos de conversión de datos de numérico a string si la muestra está representada por
datos de medición real o simulados. Las cuatro funciones para el almacenamiento a Bajo
Nivel se explican en la siguiente tabla 10.1.
205
Tabla 10.1. Funciones de almacenamiento a Bajo Nivel.

Función Descripción
Abrir, crear o remplazar archivo:
1. Ruta de archivo. Define la ubicación raíz del
archivo o la ruta para crearlo.
2. Operación. Define si es para crear, abrir o
remplazar.
3. Acceso. Si es archivo de solo lectura, solo
escritura o ambos.
4. Ruta de referencia. Mantiene la ruta del
archivo para la siguiente función.
5. Error IN y OUT. Errores que se presente en
el interior de la función.
Escribir en archivo texto:
archivo donde se va a escribir los datos
medidos.
2. Datos. Tipo cadena de caracteres que
representa los datos medidos a registrar.
Leer de archivo texto:
archivo donde se van a leer los datos
registrados.
2. Conteo. Número máximo de caracteres o
líneas que lee la función.
3. Datos. Tipo cadena de caracteres que
representa los datos extraídos en la lectura.
Leer de archivo texto:
archivo a cerrar.
206
Ejemplo de aplicación 16: Almacenamiento de archivos a Bajo Nivel.
Definir el problema: Registrar en un archivo, valores aleatorios de temperatura, para

valores entre 0°C y 100°C, muestrear por un minuto cada segundo, visualizarlos en una
gráfica tipo chart. Utilice el proceso de almacenamiento de archivos de Bajo Nivel.
Definir el problema: Definir las variables de entrada y salida del programa (Tabla 10.2).

Temperatura entre 0 y 100°C OUTPUT Indicador Numérico Real punto flotante
Tiempo de muestreo INPUT Control Numérico Real punto flotante
Visualización de Temperatura OUTPUT Indicador Grafica WAVEformCHART
Aplicación: En la figura 10.2, se crea el Panel Frontal con el indicador de termómetro para
visualizar el valor actual de temperatura y un indicador gráfico para el registro de los
valores de temperatura muestreados, adicionalmente se le adjunta un indicador numérico
para mostrar el número de datos muestreados.
Se utiliza una variable aleatoria para escalar el valor de la temperatura a un rango

de operación entre 0°C y 100°C, la cual debe convertirse de dato numérico a cadena de
207
caracteres para poderla almacenar a Bajo Nivel. También se agrega un temporizador de1
segundo con un While condicionado por un comparador que limite a 60 muestras en un
minuto. Se anexan las funciones de almacenamiento de Bajo Nivel para establecer los
pasos fundamentales, crear, escribir y cerrar el archivo. Recuerde que las funciones de crear
y cerrar archivo deben ejecutarse una sola vez, por lo que deben ubicarse fuera del ciclo
repetitivo While. La función de escritura debe hacerse cada segundo por un minuto por lo
que se requiere estar en el interior del While. Debe indicar en la función crear archivo la
ruta donde se van a crear o guardar los datos y asumir la operación respectiva. El valor de
la ruta debe pasarse a las funciones de escritura y cierre debido a que está en un ciclo
repetitivo, debe utilizar un Shift Register, para mantener activa la información de la ruta
del registro. En la figura 10.3, se observa la programación para la aplicación 15.
Figura 10.3. Código del programa de la aplicación 15.
Finalmente se procede a enlazar las señales de error de las funciones de registro de

datos, la señal de error es tipo Cluster por lo que se puede utilizar la función UNBUNDLE
para extraer el estatus y detener el While en caso de que se produzca un error interno en la
función de escritura. En la figura 10.4, se observa la programación de la aplicación 15,
incluyendo el Cluster del error.
208
Figura 10.4. Código del programa de la aplicación 15, incluyendo el Cluster del Error.
Prueba y verificación: En la figura 10.5, se ejecuta el programa y se observa el muestreo

por segundo durante un minuto de los valores aleatorios de temperatura. Después de
recoger todas las muestras, se procede abrir el archivo modo texto de la figura 10.6, para
verificar si se registraron los datos de la medición.
Figura 10.5. Registrar los valores de temperatura de la variable aleatoria.
Figura 10.6. Registrar los valores de temperatura en el Bloc de notas.

209
Almacenamiento de Alto Nivel E/S
Las funciones de Alto Nivel generan subVI que agrupan los pasos del proceso de
almacenamiento de archivos relacionados con crear, remplazar, abrir, escribir y cerrar
archivo; estos VIs no son tan eficientes como el de Bajo Nivel para los casos que requiere
trabajar los procesos individuales, por ejemplo si se requiere trabajar con registros dentro
de un lazo repetitivo se recomienda utilizar archivos de Bajo Nivel, si el registro es en una
operación única se puede utilizar el archivo de Alto Nivel.
Los archivos de Alto Nivel incluyen funciones que manejan diversas estructuras de
datos numéricos que facilita el ingreso de la data a las funciones de escritura y lectura y no
requieren conversión de datos. Se ubican en la Paleta de Funciones FILE I/O, incluye dos
funciones propias y dos VI Express. En la tabla 10.3, se presentan dos tablas, la primera
describen los VI propios para el almacenamiento de Alto Nivel, y la segunda los VI Express
que permiten registrar datos de Alto Nivel con el manejo de hojas de cálculo.
Tabla 10.3. Funciones de almacenamiento a alto nivel.

Registra los datos medidos, en una hoja de cálculo,
convierte una matriz 2D o un vector 1D a una cadena
de texto y escribe la cadena a un archivo ASCII o
añade la cadena a un archivo existente.
Extrae datos desde la hoja de cálculo de un

determinado número de líneas o filas de un archivo
de texto numérico y convierte los datos a una matriz
2D o un vector 1D.
210
Los VI Express están representado por funciones (Tabla 10.4), con archivos
ejecutables que generan un Panel Frontal donde se pueden establecer los valores de
configuración tanto para escritura como para lectura de archivos.
Tabla 10.4. Funciones de almacenamiento de Alto Nivel con VI Express.

Escribe en un archivo de medición de datos, es un VI
Express que escriba datos en varios formatos de
archivo, entre ellos:
1. archivo de texto basado en la medición de
datos LVM.
2. Archivo binarios TDMS.
3. Archivo binarios con formato de medición
TDM.
4. Archivos formato Exel. XLXS.
Con una serie de elementos de formato, que incluye
cabecera de la hoja de datos.
Lee y recupera una señal o datos desde en un archivo
de medición de datos, en alguno de estos formatos:
1. archivo de texto basado en la medición de
datos LVM.
2. Archivo binarios TDMS.
3. Archivo binarios con formato de medición
TDM.
Ejemplo de aplicación 17: Almacenamiento de archivos de Alto Nivel.
Definir el problema: Registrar a través de la compresión de Alto Nivel, la adquisición de

tres tipos de señales más una señal de ruido. Visualizar este grupo de señales en una gráfica
y en una tabla para cada uno de los valores muestreados.
211

Amplitud de Onda Seno INPUT Control Numérico Real punto flotante
Amplitud de Onda Cuadrada INPUT Control Numérico Real punto flotante
Amplitud de Onda Triangular INPUT Control Numérico Real punto flotante
Frecuencia de Onda Seno INPUT Control Numérico Real punto flotante
Frecuencia de Onda Cuadrada INPUT Control Numérico Real punto flotante
Frecuencia de Onda Triangular INPUT Control Numérico Real punto flotante
Tabla de Datos OUTPUT Indicador Tabla Arreglo de String
Botón de Stop INPUT Control Interruptor Booleano
Visualización de Temperatura OUTPUT Indicador Grafica WAVEformGRAPH
Aplicación: En la figura 10.7, se crea el Panel Frontal con el indicador gráfico y la tabla
de datos para visualizar las tres señales a generar, adicionalmente se crean controladores
tipo perilla para los valores de amplitud y frecuencia de cada señal, en este caso ondas
sinodal, cuadrada y triangular, más una señal de ruido. Se define un número de muestras
de 50 y se muestrea en un intervalo de 1 segundo.
La estructura de programación se basa en generar las cuatro señales y establecer un

arreglo matricial con los valores de las señales, donde cada columna corresponda a los
datos de una señal. Las señales se extraen de la Paleta de Funciones de procesamiento de
212
funciones y el grupo de generación de señales. Las señales se enlazan a la función de

construir arreglo para formar la matriz compuesta por los datos de las cuatro señales
muestreadas, es recomendable hacerlo dentro de un lazo While con un retardo de tiempo
de 1 segundo por muestra hasta un máximo de 50 muestras como condición para detener
el ciclo repetitivo. En la figura 10.8, se observa la programación para la aplicación 16.
Figura 10.8. Código del programa de la aplicación 16.
En el siguiente paso se procede a realizar la transpuesta de la matriz para establecer

los datos de las señales por columna y se envían el archivo de escritura en texto Write to
Spreadsheet, para guardar el archivo en modo texto. Es importante direccionar la ruta para
que el programa no abra constantemente la solicitud de guardar archivo, ya que esto genera
un error que puede crear conflicto en la aplicación debido a que en cada lazo repetitivo del
While se está solicitando la apertura del archivo. Se utiliza el VI Express Build Table para
construir y visualizar la tabla del Panel Frontal directamente de la matriz creada con el
grupo de las cuatro señales. Es importante recordar que se necesita convertir la matriz
numérica en datos dinámicos para que el VI Express pueda reconocerlo y procesarlo. En
la figura 10.9, se observa el código de programación completo.
213
Figura 10.9. Código del programa de la aplicación 16, incluyendo el registro y la tabla de datos.
Prueba y verificación: En la figura 10.10, se procede a verificar la generación de las

señales y si son registradas adecuadamente en el archivo de texto y visualizadas en la tabla.
Figura 10.10. Panel frontal de la aplicación 16 y block de notas de las señales registradas.
214
A continuación se anexa al programa de monitoreo de fallas del proceso de

medición de temperatura, un registro de fallas en archivo TXT, para verificar la ocurrencia
de alarmas indicando la fecha y hora de activación y el valor de temperatura registrado.
un mensaje textual en un indicador y en un Led que se encienda en el momento de la falla,
este mensaje debe guardarse en un archivo modo texto y registrar la fecha y hora de
ocurrencia de la falla.
Diseñar soluciones: Definir las variables de entrada y salida del programa, como se
muestra en la tabla 10.6 y se acompaña del respectivo diagrama de flujos para crear la
estructura del programa, ver figura 10.11.
Tabla 10.6 Identificar INPUTS y OUTPUTS.

Temperatura INPUT Control Numérico Real punto flotante
Advertencia Texto OUTPUT Indicador Cadena de
Normal Display
caracteresTemperatura Normal.
Temperatura Alta.
Temperatura Baja.
ON ROJO.
OFF VERDE.
Fecha OUTPUT Indicador Cadena de Normal Display
caracteres Día, Mes y Año.
Hora OUTPUT Indicador Cadena de Normal Display
caracteres Hora
Minutos
Segundos
215
Figura 10.11. Diagrama de Flujos de la Actividad Complementaria 9.
Aplicación: En la figura 10.12, muestra la ventana del Panel Frontal diseñada, se le anexa
indicadores tipo string, para la fecha y hora del sistema, para complementar los datos del
registro de fallas.

216
En el diagrama de programación se debe conectar la función GET DATE TIME de

las funciones de temporización, la cual genera dos indicadores tipo cadena de caracteres
con la fecha y hora actual del sistema.
El registro en archivo se va hacer con la estructura de almacenamiento de archivos

de Bajo Nivel, donde se requiere hacer por separado las funciones de abrir o crear archivo,
copiar en archivo y cerrar archivo. Según se observó en los puntos anteriores, se utiliza un
ciclo repetitivo condicionado para registrar los datos en archivo, también se puede observar
que para este caso específico los datos a registrar son en su mayoría cadenas de caracteres.
El procedimiento es el siguiente, seleccionamos las funciones de crear, escribir y cerrar
archivos de compresión a Bajo Nivel, colocar solamente la función de escritura en el
interior del While, interconectar la ruta de origen del archivo a crear o remplazar entre
todas las funciones utilizando un SHITF REGISTER para mantener la ruta activa dentro
del lazo While. En la figura 10.13, se observa la programación de la actividad
complementaria 9.

217
Cada vez que se active la alarma es cuando se debe registrar la información en el

archivo texto, por lo que se requiere una estructura de casos para que no registre en los
casos que la falla no esté presente. Los datos a registrar son falla, temperatura, fecha y hora;
de esos datos el único que debe convertirse de numérico a cadena de caracteres es el valor
de la temperatura medida. Se utiliza la función concatenar cadena de caracteres para formar
un solo grupo de caracteres, incluyendo saltos de página, ver figura 10.14.
Figura 10.14. Código de programación final de la Actividad Complementaria 9.
Prueba y verificación: En la figura 10.15, se ejecuta el programa y se procede a verificar

el registro de las fallas presentes durante un intervalo de monitoreo de temperatura, en el
archivo raíz tipo texto, que se designa para tal fin.
218
Figura 10.15. Archivo del Block de notas, con el registro de toda la información de la falla presentada.
219
Capítulo XI
Adquisición de Datos DAQ
Los sistemas automatizados en la industria requieren la conversión de señales

físicas de procesos reales a datos, que sirven como información de las variables del proceso
que se ejecuta en un procesador. Las variables físicas se someten a un acondicionamiento,
digitalización, encriptación en un protocolo de comunicación de datos y se procesan en una
computadora que representa una interfaz de usuario para el monitoreo y control de datos.
En este capítulo, se establecen definiciones básicas en el área de instrumentación

electrónica, donde se explican las diferentes etapas de un sistema de adquisición y
procesamiento de datos; se describen los módulos de adquisición de datos DAQ utilizados
por LabVIEW para establecer la comunicación con sensores y actuadores que miden y
controlan las variables físicas de procesos reales, se plantean diseños de procesos de
adquisición y generación de señales en los puertos de entradas Analógicos, Digitales y
ancho de pulso PWM, de los DAQ. Las tarjetas de adquisición de datos usadas en los
ejemplos se basan en los modelos DAQ 6009 y 6216 USB, sin embargo se explica el
proceso para trabajar con tarjetas de adquisición de datos simuladas, lo que permite elegir
tarjetas de otras series basadas en otros protocolos de comunicación y permitiendo
establecer la conexión con el programa que procesa los datos. A continuación se describen
los temas que se abarcan en este capítulo con su respectiva prioridad.
-. Adquisición de Datos.
-. Comunicación con Hardware.
-. Simulación de un dispositivo DAQ.
-. Diseño de un Sistema de Medición con la Tarjeta DAQ
-. Actividad Complementaria 10 (Uso de los canales Análogos y Digitales de la DAQ).

220
Adquisición de Datos
La adquisición de datos DAQ, es el proceso de medición en una PC de un fenómeno

eléctrico o físico de voltaje, corriente, temperatura, presión, sonido entre otros. La
adquisición de datos utiliza una combinación de hardware modular y software flexible para
transformar una computadora en un sistema de medición y control definido por el usuario,
si bien cada sistema de adquisición tiene una funcionalidad única para servir a las
necesidades específicas de la aplicación, todos los sistemas comparten componentes
comunes, que incluyen señales, sensores, acondicionamiento de señales, el hardware DAQ
y una computadora con el software de aplicación, tal como se observa en la figura 11.1.
Figura 11.1. Sistema de Adquisición de Datos.
El proceso parte de una señal física, un sensor que la convierte en una señal eléctrica
o electrónica, un acondicionador que la ajusta al nivel de operación requerido para la
adquisición de datos, un módulo de adquisición para digitalizar y convertir la señal en
datos, un protocolo de comunicación y un computador para procesar los datos. Se puede
desglosar las fases del sistema de adquisición de datos de la siguiente manera:
Señales: Es una variable física, cuyos valores de magnitud o variación en el tiempo

contienen información. La señal requiere de un instrumento o dispositivo para extraer la
221
información. En electrónica se establecen dos tipos de señales que son las utilizadas en los
procesos de adquisición de datos, señales Analógicas y señales Digitales.
Señales Analógicas: Estas señales son en función del tiempo y presentan variaciones que
les puede dar una periodicidad o establecer diferentes niveles de operación, esto hace que
defina tres características principales que son el nivel, la forma y frecuencia. Se establecen
tres tipos de señales Analógicas, Continúas o DC, variables en el dominio del tiempo y
variables en el dominio de la frecuencia, en la figura 11.2, se observan los tipos de señales
Analógicas.
Figura 11.2. Señales Analógicas.
Señales Digitales: Una señal Digital no puede tomar cualquier valor con respecto al
tiempo. La información útil que se puede medir a partir de una señal digital incluye el
estado y la frecuencia. El estado de una señal digital es esencialmente el nivel de la señal,
encendido o apagado, alto o bajo. El observar el estado de un interruptor, abierto o cerrado,
es una aplicación común que muestra la importancia de conocer el estado de una señal
Digital. La frecuencia de una señal digital se define cómo el cambio de estado de la señal
con respecto al tiempo. Un ejemplo de medición de la velocidad o frecuencia de una señal
Digital incluye determinar la rapidez de giros del eje de un motor.
Se establecen dos tipos de señales digitales: Señales On-Off, las cuales están sujetas
a cambiar de estado ante cualquier respuesta o perturbación y Tren de Pulsos las cuales
222
dependen de un valor de frecuencia de la señal y de un ciclo de trabajo relacionado con el

ancho de pulso de la señal. Estas últimas usadas en la modulación por ancho de pulso
PWM. En la figura 11.3, se observan la señal On-Off y la señal por Tren de Pulsos
Figura 11.3. Señales Digitales.
PWM: La modulación por ancho de pulsos (PWM), es una técnica que se utiliza para variar
el ancho del ciclo positivo de una señal periódica, es decir, modifica el ciclo de trabajo de
una señal periódica. El objetivo de la técnica es controlar el nivel de energía entregado por
la señal o transmitir información por un medio de comunicación bajo ciertos criterios. El
ciclo de trabajo (D) se puede expresar con una función matemática que relacióna el tiempo
que dura el ciclo positivo de una señal (τ), entre el periodo de la señal (T), ver ecuación
11.1.
τ
=
T
Ec. 11.1
Sensores: Son dispositivos que se encargan de realizar la conversión de un valor físico a

un valor diferente que resulte más fácil de medir (en la mayoría de los casos un parámetro
eléctrico por variación de voltaje, corriente o impedancia). Los sensores se pueden
clasificar según la magnitud física que quiere detectarse y según su principio de
funcionamiento. Otra clasificación son los sensores activos y pasivos, los pasivos necesitan
energía externa para su activación y sensores activos generan a sus salidas señales
223
eléctricas en forma de tensión, corriente o carga sin la necesidad de alimentación eléctrica.

En la tabla 11.1, se puede observar algunos sensores clasificados según la magnitud física
que se requiere medir:
Tabla 11.1. Sensores.
Fenómeno Transductores
Temperatura Termocuplas, RTD, Termistor.

Luz Foto Sensores.
Sonido Micrófonos.
Fuerza y Presión Galgas extensiométricas, Transductores Piezoeléctricos.

Posición y Desplazamiento Potenciómetros, LVDT, Codificadores Ópticos.
Aceleración Acelerómetros.
pH Electrodos de pH.
Acondicionamiento de señal: A veces, los sensores generan señales demasiado difíciles

o peligrosas para medir directamente con un dispositivo de adquisición de datos, por
ejemplo, cuando se trata de alta tensión, ambientes ruidosos, medición de señal
simultáneas, entre otras; el acondicionamiento de señales es esencial para que un sistema
de adquisición de datos sea eficaz, debido a que maximiza la precisión y permite a los
sensores operar adecuadamente y garantiza la seguridad. A continuación se puede
referenciar algunos de estos acondicionamientos.
Amplificación: Son circuitos que aumentan el nivel de voltaje para adaptarse mejor al
rango de operación de los canales analógicos de los módulos de adquisición de datos,
aumentando así la resolución de la medición y la sensibilidad de la señal, ver figura 11.4.
224
Figura 11.4. Amplificación de Señales.
Atenuación: Es lo opuesto a la amplificación, necesario cuando los voltajes adquiridos son

más allá del rango de entrada de los módulos de adquisición, ver figura 11.5.
Figura 11.5. Atenuación de Señales.
Aislamiento: Consiste en aislar los dispositivos de las etapas de acondicionamiento de

señales, medición y fuentes; sin que tengan una conexión física, mediante el uso de
transformadores, medios ópticos o capacitivos y técnicas de acoplamiento, ver figura 11.6.
Figura 11.6. Aislamiento de Señales.

225
Filtrado: Elementos que se utilizan para discriminar una determinada frecuencia o gama
de frecuencias de una señal y modificar algunas de sus propiedades, ver figura 11.7.
Figura 11.7. Filtrado de Señales.
Linealización: Es necesario cuando los sensores producen señales de voltaje que no están
linealmente relacionadas con la medición física. Es el proceso de interpretar la señal del
sensor y hacer con acondicionamiento de señales mediante hardware o software, ver figura
11.8.
Figura 11.8. Linealización.
Excitación: La excitación, es un valor de energía que se requiere para muchos tipos de

transductores, por ejemplo, las galgas extensiométricas, acelerómetros, termistores y los
detectores de temperatura por resistencia (RTD) requieren un voltaje externo o corriente
de excitación.
226
Compensación Cold-Junction: Compensación de unión fría (CJC) es una tecnología

requerida para mediciones precisas de termopares. La temperatura medida en el termopar
para dos metales diferentes que generan diferencia de voltaje, ver figura 11.9.
Figura 11.9. Compensación de unión fría. .
Bridge Completion: Son usados para compensación en los puentes de Wheatstone.

Un puente de Wheatstone se utiliza para medir resistencias desconocidas mediante el
equilibrio de los demás elementos resistivos del puente. Estos están constituidos por cuatro
resistencias que forman un circuito cerrado, siendo una de ellas la resistencia a medir y otra
la resistencia variable que compensa el puente, ver figura 11.10.
Figura 11.10. Compensación por puente.
DAQ hardware: El módulo de adquisición de datos para la instrumentación electrónica,

debe estar compuesto por una serie de funciones que le permitan interactuar con el mundo
real y con el operador, se puede plantear como el puente entre la adquisición de las
227
variables físicas del proceso y la visualización y control de las mismas en un entorno virtual
(software). El hardware o módulo de adquisición de datos (DAQ), actúa como la interfaz
entre una PC y señales del mundo exterior. Funciona principalmente como un dispositivo
que digitaliza señales analógicas entrantes para que una PC pueda interpretarlas como
datos, utilizando un protocolo de comunicación para trasmitirla. Los tres componentes
claves de un dispositivo DAQ usado para medir una señal son: el circuito de
acondicionamiento de señales, convertidor analógico-digital (ADC) y un bus de
comunicación de datos con la PC.
Funciones Principales del DAQ: A continuación se describe las funciones que se destacan
al momento de utilizar el módulo DAQ:
1. Encaminar la señal controlando la conexión de la señal de entrada a las distintas

opciones internas del instrumento.
2. Convertir la señal analógica a una forma de datos que pueda ser procesados por un
ordenador.
3. Generar señales convirtiendo los datos del ordenador a señales que puedan
interactuar con el mundo real.
4. Transformar datos generados por instrumentos en un formato que pueda ser
transmitido por un bus estándar.
5. Sincroniza las acciones del instrumento con sus propias funciones internas.
Componentes de las DAQ: A continuación se describen algunas componentes que

conforman el DAQ:
1. Entradas Analógicas, especificando parámetros como la velocidad de muestreo,
resolución, rangos dinámicos, ruido, no linealidad, distinguir las entradas
diferenciales de las unipolares.
228
2. Convertidores Análogo-Digitales, se debe considerar el muestreo de la señal

según el criterio de Nyquist, así se mejora la velocidad de muestreo y se tiene
una resolución razonable.
3. Margen Dinámico de entrada, define el rango de entrada que hace referencia a

los niveles mínimo y máximo de tensión que el convertidor puede cuantificar.
4. Sistemas de Multiplexado, es una técnica para medir varias señales de entrada

a través de un convertidor utilizando muestreo simultáneo.
5. Salidas Analógicas, requiere un convertidor Digital-Análogo que define la

calidad de la señal de salida (tiempo de establecimiento y resolución).
6. Entradas y salidas Digitales, se utilizan para el control de procesos con

respuestas discretas, el número de canales, capacidad de transmisión y
posibilidad de protocolos.
7. Circuitos de Conteo y Temporización de entradas y salidas, utilizada en

procesos de conteo ocurrente de un hecho digital, medidas temporales de pulsos
digitales, generación de señales cuadradas y pulsos, etc.
Bus PC: Los dispositivos DAQ se conectan a una PC a través de una ranura o puerto, el
bus de la PC sirve como la interfaz de comunicación entre el dispositivo DAQ y la PC para
pasar instrucciones y datos medidos. Los DAQ trabajan con los bus de PC más comunes
USB, PCI, PCI Express, Ethernet y Wi-Fi para comunicación inalámbrica. Hay varios tipos
de buses y cada uno de ellos ofrece diferentes ventajas para diferentes tipos de aplicaciones.
Todos los buses de la PC tienen un límite de la cantidad de datos que pueden ser
transferidos en un cierto periodo de tiempo, esto se conoce como el ancho de banda del bus
y generalmente es especificado en megabytes o gigabytes por segundo (MB/s) o (GB/s).
Dependiendo del bus que escoja, el ancho de banda total puede ser compartido entre varios
dispositivos o dedicado a ciertos dispositivos. En la tabla 11.2, se observa las diferentes
DAQ que presenta la National Instruments, según el bus de datos.
229
Tabla 11.2. Tarjetas DAQ de National Instruments.

Tarjeta Descripción
PCI: El bus de Interconexión de Componentes Periféricos
(PCI) es uno de los buses internos más comunes usados. Su
evolución en velocidad se consagra con el PCI Express.
PXI: Las extensiones de PCI para Instrumentación (PXI)

fueron desarrolladas para llenar la brecha entre sistemas de
PC de escritorio y sistemas VXI y GPIB de alto rendimiento.
PXI, mantiene este estándar abierto y presenta la
especificación PXI Express para proporcionar tecnología
PCI Express de transferencia de datos a la plataforma PXI.
El Bus Serial Universal (USB): fue originalmente diseñado

para conectar dispositivos periféricos como teclados y mouse
con PCs. Sin embargo, ha demostrado ser útil en varias
aplicaciones, incluyendo medidas y automatización. USB
ofrece una conexión económica y fácil de usar entre los
dispositivos de adquisición de datos y las PC.
Ethernet: Como un bus para DAQ, Ethernet es ideal para

realizar medidas portátiles o distribuidas a distancias más
allá de 5 m de un cable USB. Un solo cable Ethernet puede
alargar los 100 m antes de necesitar un Hub, interruptor o
repetidor. Esta distancia en combinación con una gran
variedad de redes, hacen a Ethernet una opción ideal para
medidas distribuidas para ubicaciones remotas.
Inalámbrico: La tecnología inalámbrica amplía la

flexibilidad y la portabilidad de la adquisición de datos
basada en PC para aplicaciones de medidas dónde los cables
son inapropiados o poco prácticos. Existen diferentes
tecnologías inalámbricas. La más popular es IEEE 802.11
(Wi-Fi). Wi-Fi es una de las tecnologías inalámbricas más
fáciles de instalar.
230
En la figura 11,11, se muestra la estructura del bus de comunicación de datos

internos y externos al procesador basado en las tecnologías fabricadas por la National
Instruments.
Figura 11.11. Bus de datos de las tarjetas DAQ manejadas por National Instruments.
Computadora / Software: Una PC con software programable controla la operación del

dispositivo DAQ y es usada para procesar, visualizar y almacenar datos medidos.
Diferentes tipos de PCs son usadas en diferentes tipos de aplicaciones. Una PC de escritorio
se puede utilizar en un laboratorio por su poder de procesamiento, una laptop se puede
utilizar por su portabilidad o una PC industrial se puede utilizar en una planta de producción
por su robustez. El ordenador tiene tres componentes principales que afectan a las
capacidades de gestión de datos: El procesador, la memoria RAM, y el disco duro. El
procesador es la parte del ordenador que interpreta y ejecuta las instrucciones, en la
mayoría de los nuevos ordenadores son de múltiples núcleos, es decir, el equipo puede
utilizar dos o más procesadores independientes actuales (llamados "núcleos") para leer y
ejecutar las instrucciones del programa. Los criterios de selección se pueden estimar por la
portabilidad, la robustez del PC y la modularidad del PC, sobre todo si se está trabajando
en múltiples aplicaciones, también es un factor importante a considerar el sistema
operativo ya que le da la capacidad para operar de manera determinista, es decir, las
aplicaciones se pueden ejecutar de acuerdo a los requisitos de tiempo precisos. Un sistema
231
operativo de tiempo real es determinista el usuario define el orden y el tiempo de los

procesos. Esto le da más control sobre su aplicación y la capacidad de ejecutar con mayor
rapidez que con un sistema operativo no determinista.
Comunicación con Hardware
El Sistema de adquisición de datos es una arquitectura formada por hardware que

se complementa con una serie de aplicaciones de software que permiten establecer la
comunicación y conversión de la información en datos. A nivel de hardware se describir la
arquitectura en seis elementos concatenados como se observa en la figura 11.12:
Figura 11.12. Hardware del sistema de adquisición de datos.
Una señal eléctrica que representa la información de una variable o proceso físico,
un bloque de conexión de los terminales para los puestos de entrada y salida análogas y
digitales que se desean procesar (muchas veces este bloque viene adjunto en la DAQ),
cable de conexión dependiendo del protocolo de comunicación, una tarjeta de adquisición
de datos externa o interna al procesador, dependiendo de la aplicación y flujo de
información requerida. Finalmente el computador o procesador de datos, el cual debe tener
instalados los programas manejadores de la comunicación de datos y el análisis y
procesamiento de los mismos, este procesador debe tener alguna forma de mostrar los
resultados generados durante el proceso.
232
Los DAQ se encargan de transferir las señales analógicas y digitales de un entorno

de medición al computador o viceversa, conectan el computador a través de diferente bus
de comunicación como los PCI, PCI Express, USB, Ethernet, WiFi y PXI para sistemas
de medición complejos. Si no se dispone de un DAQ, se puede simular utilizando el
software Explorador de Medición y Automatización (NImax) para hacer creer al
computador que tiene una conexión real con un DAQ y así proceder a ejecutar la aplicación.
Una vez conectado el módulo DAQ con cualquier bus de comunicación seleccionado o
configurada la DAQ como una tarjeta simulada, se debe proceder a la configuración de los
manejadores de la tarjeta, para sincronizar la comunicación, la lectura y escritura de los
diversos puertos de entrada y salida analógicas y digitales. Para configurar la
comunicación, se puede hacer de diferentes formas, a continuación se describen diferentes
métodos para el manejo y configuración de la DAQ.
Modulo NI-DAQmx de LabVIEW para comunicarse con las tarjetas DAQ: Para
establecer los manejadores de comunicación de las DAQ, se presenta en LabVIEW
funciones o subVIs para establecer y configurar la comunicación con cualquier dispositivo
conectado al computador. Las funciones NI-DAQmx se encuentran en la Paleta de
Funciones en DAQmx Data Acquisition. El controlador NI-DAQmx presenta la interfaz
de programación de aplicaciones (API) en su configuración de hardware y software,
despliega funciones para el control de dispositivos de medición, crear un canal de
comunicación, establecer el modo de lectura y escritura de datos, arrancar la adquisición,
pausar y detener la adquisición, limpiar los canales de comunicación, entre otra variedad
de elementos de configuración en el proceso de adquisición para una tarjeta especifica.
Dentro de las funciones del NI-DAQmx, incluye el DAQ Asistente para configurar
en forma directa cada uno de los canales y tareas de medición para un dispositivo (Esta
función se define más adelante), soportan diferentes conjuntos de dispositivos reales y
simulados, en la tabla 11.3, se describen algunas de las funciones del DAQmx.
233
Tabla 11.3. Funciones del DAQmx.

Crear Canal de Adquisición: Selección de la función del
canal. Menú desplegable que define que función tiene el
canal a seleccionar.
-. Configurar terminal. Define los diferentes modos de
configuración de la adquisición, Diferencial, NRSE no
referenciado, Pseudodiferencial y RSE referenciado.
-. Valores máximos y mínimos. La referencia de amplitud en
el canal.
-. Tarea y asignar nombre. Define un canal virtual y su
nombre dentro de la estructura del programa.
-. Canal Físico. Define el número del canal real de la DAQ.
-. Escala personalizada. Escala ajustada por el programador.
-. Unidad. Especifica la unidad física a utilizar.
Leer del Canal de la DAQ: Permite seleccionar de un menú

desplegable el canal de lectura que se requiere monitorear.
Regresa como dato numérico real, el valor de la señal medida
en el canal seleccionado.
Escribir en el canal de la DAQ: Permite seleccionar de un

menú desplegable el canal de escritura que se desea utilizar.
Se envía un dato numérico real, y se transfiere el valor al
canal de salida seleccionado.
Comenzar, detener y limpiar la Adquisición en la DAQ:

Permiten seleccionar el inicio de la adquisición, detenerla en
el momento que se requiera y limpiar la última data del canal.
Normalmente se programan en esa secuencia
Modos de configuración para Adquisición Analógica de la DAQ:

Sistema de medición diferencial: Un sistema diferencial (Figura 11.13), no tiene ninguna
de sus entradas atadas a una referencia fija como tierra. Un sistema de medición diferencial
234
es similar a una fuente de señal flotante en el sentido de que la medición se realiza con
respecto a una tierra flotante que es diferente de la tierra del sistema de medición.
Figura 11.13. Sistema de medición diferencial.
Sistemas de medición de un solo extremo, referenciados y no referenciados: Son

similares a las fuentes conectadas a tierra en que la medida se hace con respecto a tierra.
Un sistema de medición de un extremo referenciado (RSE) mide voltaje con respecto a
tierra. La figura 11.14, muestra un sistema de medición de un solo extremo con referencia
de 8 canales.
Figura 11.14. Sistema de medición de un solo extremo referenciado RSE.
En los sistemas de un extremo no referenciado (NRSE), todas las mediciones se

realizan con respecto a un solo nodo (AISENSE), pero el potencial en este nodo puede
variar con respecto a la tierra del sistema de medición, ver figura 11.15.
235
Figura 11.15. Sistema de medición de un solo extremo no referenciado NRSE.
Sistema de medición Pseudodiferencial: Combina algunas características de un canal de

entrada diferencial y un canal de entrada de un solo extremo referenciado (RSE). El sistema
de medición expone los lados positivo y negativo del canal, conectando las entradas
positiva y negativa a las salidas respectivas de la unidad bajo prueba. La entrada negativa
está ligada a tierra del sistema a través de una impedancia relativamente pequeña. En la
figura 11.16, se observa el sistema de medición Pseudodiferencial.
Figura 11.16. Sistema de medición Pseudodiferencial.
Ejemplo de aplicación 18: Controlar la velocidad de un motor DC real.
Definir el problema: Generar con el NI-DAQmx una señal PMW con un ciclo de trabajo
positivo variable que sirva para controlar la velocidad de giro de un motor DC, utilizando
una tarjeta DAQ de National Instruments. Se requiere un puerto de salida PWM, para ello
se selecciona la tarjeta DAQ 6216 con puerto USB. En la figura 11.17, se muestra el control
para un motor DC.
236
Figura 11.17. Control del motor DC por una señal PWM.
Tabla 11.3 Identificar INPUTS y OUTPUTS.

Duty cicle positivo INPUT Control Numérico Real punto flotante
Duty cicle negativo INPUT Control Numérico Real punto flotante
Señal PWM INPUT Control Contador de pulso Puerto DAQ PWM
Status OUTPUT Indicador Led Booleano
Aplicación: Una de las salidas de generadores de pulso de la DAQ 6216, se encargaran de

crear la señal PWM que debe ir al motor para poder controlar su velocidad de giro. En la
figura 11.18, se observa el diagrama de programación del ejemplo, se utilizan las funciones
de crear el canal para una generación de pulsos, comenzar la adquisición, tiempo de espera
durante la adquisición y limpiar el canal de salida después de generar el pulso.
Figura 11.18. Código de programación de la aplicación del control del motor DC por una señal PWM.
237
Prueba y verificación: El programa configura la generación del pulso como una señal en
función del tiempo, controlando el período del ciclo positivo y negativo. La salida definida
como status 2 representada por un Led, permite reconocer si se produce un error en la
generación de la señal. En la figura 11.19, se observa el Panel Frontal del programa, con
pruebas de movimiento del motor para diferentes anchos de pulso de la señal PWM.
.
El DAQ Assistant Express VI en LabVIEW: El VI Express DAQ Assistant, es una forma

directa de generar una interface de comunicación y configuración de los canales de
medición de la tarjeta de adquisición de datos. Existe un menú de configuración que facilita
el proceso de conexión con los canales de adquisición y finalmente el programa establece
la configuración y crea un VI Express con los nodos de entrada y salida establecidos en la
configuración. En la figura 11.20, se observa los pasos para establecer la configuración de
una tarea de adquisición, usando el DAQ Assistant:
Paso 1: Ubicar el DAQ Assistant en la Paleta de Funciones DAQmx Data Acquisition.
Figura 11.20. VI Express del DAQ Assistant.

238
Paso 2: Se coloca sobre el diagrama del VI Express DAQ Assistant, y se abre

inmediatamente el panel de configuración de la figura 11.21, con un menú que le indica al
usuario seleccionar la tarea de configuración, en este caso si se va a realizar una adquisición
o generación de señales.
Figura 11.21. Menú de configuración del DAQ Assistant.
Paso 3: Si se necesita adquirir o generar señales se despliega una lista de las variables
disponibles en los canales de adquisición, como se muestra en la figura 11.22.
Figura 11.22. Configuración de la adquisición y generación de señales en el DAQ Assistant.

239
Paso 4: Si por ejemplo se requiere una adquisición o generación analógica, se despliegan

las posibles variables físicas que se pueden medir con los DAQ, tal como se muestra en la
figura 11.23.
Figura 11.23. Configuración del tipo de señal para la adquisición y generación en el DAQ Assistant.
Paso 5: Se puede seleccionar una adquisición analógica de voltaje, para una tarjeta DAQ
USB 6009, la cual debe estar conectada al computador o configurada como una tarjeta
virtual. Deben aparecer todos los canales de entrada analógicos que presenta la tarjeta, se
debe seleccionar el canal que se desee utilizar y proceder a finalizar la configuración.
También para una generación analógica de voltaje, en la DAQ USB 6009. Deben aparecer
todos los canales de salida analógicos que presenta la tarjeta, se debe seleccionar el canal
que se desee utilizar y proceder a finalizar la configuración, ver figura 11.24.
240
Figura 11.24 Configuración de los canales para la adquisición y generación en el DAQ Assistant.
Paso 6: Para el caso de la adquisición analógica, se abre un menú de configuración de la

señal indicando los rangos de amplitud, frecuencia, frecuencia de muestreo, numero de
muestras, modos de configuración, entre otros y acompañados de la forma de onda de la
señal a muestrear, en esta ventana se puede ejecutar la adquisición en línea. En la figura
11.25 se observa la ventana del menú de configuración para adquisición analógica.
Figura 11.25. Parámetros para la adquisición en el DAQ Assistant.

241
Paso 7: También se puede observar en el menú de adquisición analógica, el diagrama de

conexión del cableado con los puertos utilizados de la tarjeta DAQ seleccionada. En la
figura 11.26 se observa el cableado de conexión indicando los canales físicos del puerto de
datos seleccionado en la configuración.
Figura 11.26. Pines de conexión para la adquisición en el DAQ Assistant.
Paso 8: Para el caso de la generación analógica, también se observa un menú de

configuración de la señal a generar, tal como se muestra en la figura 11.27, indicando los
mismos elementos de configuración del caso anterior, excluyendo la forma de onda de la
señal a generar, en esta ventana se puede ejecutar la generación en línea.
242
Figura 11.27. Parámetros para la generación en el DAQ Assistant.
Paso 9: El programa compila la configuración del puerto seleccionado y procede a crear el

respectivo VI Express, ya sea para la adquisición o la generación analógica, ver figura
11.28.
Figura 11.28. VI Express generados en el DAQ Assistant.
Paso 10: Después de crear una conexión, puede hacer doble clic en DAQ Assistant Express
VI para editar la conexión. Para la medición o generación continua es necesario colocar un
lazo While alrededor del DAQ Assistant Express VI.
243
Paso 11: Seleccionando el cursor derecho sobre el VI Express, aparece un menú

desplegable donde se puede seleccionar la opción generar código NI-DAQmx y
automáticamente convierte el VI Express con su configuración en el respectivo código
DAQmx, ver figura 11.29.
Figura 11.29. Código DAQmx generado por el DAQ Assistant.
Explorador de Medición y Automatización (MAX): Siempre que se instale un

dispositivo de adquisición de datos DAQ se debe verificar que el dispositivo sea reconocido
por el LabVIEW, la configuración para las DAQ de las series NI se realizan
automáticamente, ya que el programa detecta y ejecuta los manejadores de la comunicación
entre el DAQ y el software. Si las tarjetas son de otros fabricantes debe proceder a instalar
manualmente los driver de configuración y verificar si existen algunas herramientas o
funciones de programación de LabVIEW para ese modelo de tarjeta. El Explorador de
Medición y Automatización MAX (Figura 11.30), es un administrador de configuración
que verifica todo el hardware instalado en el computador, detecta y configura todos los NI
DAQ reales o virtuales que presente el equipo.
244
Figura 11.30, Explorador de Medición y Automatización MAX.
El MAX abre un programa de exploración, tal como se muestra en la figura 11.31,

en la que se puede ver todos los dispositivos enlazados al sistema y anexar nuevos
elementos que se deseen conectar al computador. Presenta una barra de exploración con
los elementos del sistema, seleccionando la función de dispositivos e interfaces, muestra
varias pestañas con los diferentes dispositivos reconocidos por el sistema, tanto los reales
como los virtuales.
Figura 11.31. Ventana de Explorador del MAX.
Si se selecciona alguna de las NI-DAQ en lista, se observa las características

relevantes de la tarjeta seleccionada entre ellas se observa las características del dispositivo,
245
nombre, modelo, fabricante, calibración, y funciones de verificación de conexión del

dispositivo, tal como se observa en la figura 11.32.
Figura 11.32. Características de una DAQ en el MAX.
También se puede hacer un test de pruebas de los diferentes canales de adquisición

de entrada y salida que posee la tarjeta, Analógicos, Digitales y Contadores. Todos con
señales simuladas que se reflejan en los diferentes canales de adquisición, en la figura
11.33, se observan algunos paneles de prueba.
Figura 11.33. Paneles de prueba de los puertos de una DAQ en el MAX.

246
Para el dispositivo DAQ seleccionado, el MAX presenta toda la información de

los terminales de conexión físicos de la tarjeta, con su respectiva numeración por canal.
En la figura 11.34, se observa la descripción de la DAQ 6009 USB.
Figura 11.34. Terminales de conexión de entrada y salida de una DAQ en el MAX.
También se pueden asignar algunas tareas de adquisición a los canales, en la figura

11.35, se muestra la ventana del VI Express DAQ Assistant para configurar un canal de
adquisición o generación.
Figura 11.35. Asignación de tareas de configuración de puertos de una DAQ en el MAX.

247
Simulación de un dispositivo DAQ
Si el programador inicialmente no tiene una tarjeta DAQ real o requiere proceder a

realizar pruebas de conexión y medición antes de seleccionar un tipo específico de tarjeta,
puede optar por la aplicación de Simulación de DAQ, que presenta el explorador MAX.
Esta aplicación de simulación realiza los mismos pasos de configuración de una DAQ real
y la establece como una tarjeta virtual anexa a los dispositivos e interfaces del computador.
Sobre esta tarjeta DAQ simulada se puede proceder a realizar las mismas pruebas de
comunicación, adquisición y generación, que se realizan en una tarjeta real. A continuación
se presenta los pasos que se deben realizar para crear una tarjeta de adquisición DAQ
virtual, en este caso simularemos la USB 6216:
Paso 1: Del menú de exploración MAX, se selecciona el cursor derecho sobre la opción
dispositivo e interfaces, se hace clip sobre crear nuevo dispositivo y se selecciona
Simulated NI-DAQmx Device or Modular Instrument, tal como se muestra en la figura
11.36.
Figura 11.36. Asignación de tareas de configuración de puertos de una DAQ en el MAX.

248
Paso 2: En la figura 11.37, aparece un listado de todos los dispositivos que se pueden
configurar con el LabVIEW instalado. De la serie M, se busca la tarjeta DAQ USB 6216.
Figura 11.37. Serie M, de las DAQ USB en el MAX.
Paso 3: En la figura 11.38, el dispositivo aparece anexo en la lista de dispositivos e

interfaces conectados al computador, se visualizan y se activan las características y todas
las ventanas de configuración y prueba de la tarjeta en el explorador MAX. Ya la tarjeta
está disponible para programar desde LabVIEW los canales de adquisición y generación
de todos sus puertos.
Figura 11.38. Tarjeta simulada DAQ 6216 en el MAX.

249
Diseño de un Sistema de Medición con la Tarjeta DAQ
Los Sistemas de medición en la instrumentación electrónica están conformados por

tarjetas de adquisición de datos con características especiales, aplicadas a los diferentes
sensores encargados de traducir variables físicas a señales eléctricas. En este punto se
realiza todo el proceso requerido para implementar un sistema de medición de tensión o
fuerza con celda de carga.
Una celda de carga es un sensor que convierte la tensión o fuerza mecánica en una
señal eléctrica que puede ser medida en un sistema de adquisición de datos. Una de las
celdas más comúnmente utilizada son las galgas Extensiométricas, la cual utiliza una
matriz de galgas para medir la deformación de un componente de una estructura. Para el
transductor de fuerza, se utilizan las galgas montadas sobre un diafragma de forma que al
aplica presión miden una deformación del diafragma que es proporcional a la tensión. En
la figura 11.39, se muestra una galga Extensiométricas metálica adhesiva.
Figura 11.39. Galgas Extensiométricas.
La tensión sobre la galga genera cambios mínimos de resistencia, por lo que

requiere utilizar un circuito acondicionador de señal para mejorar los cambios de la
resistencia. La configuración del circuito más común en una célula de carga se llama puente
de Wheatstone (Figura 11.40), y se compone de cuatro ramas resistivas con una tensión de
excitación que se aplica a los extremos del puente.
250
Figura 11.40. Puente de Wheatstone.
Desde el punto de vista de análisis de circuitos se debe establecer un voltaje de

salida Vo dado por la ecuación 11.2:
= − #∗
!
" !
Ec.11.2
El uso de una configuración de puente completo aumenta la sensibilidad del circuito

a los cambios de deformación, mejorando la precisión en las medidas. Los fabricantes
deben proporcionan la curva de calibración de cada celda de carga para correlacionar el
voltaje de salida con una cantidad específica de la fuerza. Para trabajar con el puente de
Wheatstone se debe proporcionar una fuente de tensión constante que alimente el puente,
los valores típicos de excitación se dan entre los 3 a 10V, a mayor tensión de excitación
mayor tensión de salida, pero también mayores errores de medición. La salida de las del
puente es relativamente pequeña, Por lo tanto se debe adicionar un acondicionador de señal
formado por amplificadores operacionales para amplificar la señal y así incrementar el
nivel de resolución de la medida.
Cuando se instala un puente aparece un pequeño voltaje denominado Offset, que se

puede presentar debido a pequeñas variaciones de las resistencias del puente. Existen
distintos modos en que un sistema puede manejar la tensión de Offset inicial ya sea por
compensación por software, el cual la anula a nivel de programación; o un circuito de
anulación del Offset, el cual utiliza un potenciómetro para ajustar físicamente la salida del
puente a 0V.
251
En la figura 11.41, se observa la tarjeta de adquisición adecuada para la medición

en galgas Extensiométricas es la DAQ NI 9237 serie C.
Figura 11.41. DAQ NI 9237.
El DAQ NI 9237 de la figura 11.42, tiene cuatro conectores RJ-50 que proporcionan
conexiones para cuatro puentes completos.
Figura 11.42. Conectores de salida de la DAQ NI 9237.
En el software Explorer MAX se anexa la tarjeta NI 9237 y se establece la tarea de

adquisición analógica para puente de Wheatstone con excitación, ver figura 11.43.
252
Figura 11.43. Configuración de la DAQ NI 9237 en el Explorador MAX.
En el software LabVIEW se procede a crear la aplicación para que el usuario

visualice el valor de medición del sensor, ver figura 11.44.
Figura 11.44. Panel frontal para medición del proceso completo con la DAQ NI 9237.
253
Actividad Complementaria 10 (Uso de los canales Análogos y Digitales de la DAQ)
Diseñar un sistema de Teleoperación bilateral para seguimiento de movimiento,

utilizando los canales Análogos y Digitales de la DAQ.
Definir el problema: Diseñar un prototipo de un sistema Maestro-Esclavo con un grado

de libertad que permita al sistema maestro, desplazar o frenar manualmente un objeto en
un eje X y que un objeto en el sistema mecánico imite el mismo movimiento en tiempo
real y a la misma velocidad. Si el objeto del sistema esclavo es frenado por el contacto con
un objeto el sistema maestro debe detectar y frenar el desplazamiento de su objeto.
Diseñar soluciones: El proceso de medición y generación de señales debe tener explícito

cada uno de los procedimientos a realizar dependiendo del tipo de señal. Diferentes tareas
de procesamiento de datos se pueden realizar en un mismo programa, utilizando una o más
de una tarjeta de adquisición; para una mejor comprensión del manejo de los diferentes
canales de adquisición y generación. Se procede a desarrollar un problema complejo que
se establezca el manejo de diferentes señales a través de una tarjeta DAQ, y que tenga la
capacidad de procesar un gran número de señales de entrada y salida en tiempo real. El
problema plantea un esquema de control bilateral, siendo las principales variables:
posición, velocidad y fuerza del operador en el sistema Maestro y fuerza del contacto del
entorno con el sistema Esclavo. El proyecto se divide en dos etapas de diseño, las cuales
se van a explicar por separado. Las etapas son diseño de Hardware y diseño de Software.
Aplicación:
Diseño del Hardware: Se establecer un mecanismo robótico de un grado de libertad,
formado con material de reciclaje encontrado en diferentes talleres tecnológicos de
reparación de equipos electrónicos, con piezas de equipos que ya se encuentran fuera de
servicio; se utiliza el mecanismo de carro deslizante de los cartuchos de tinta de las
impresoras Hp 670c, la cual consiste en una correa de cremalleras que permite a una base
254
de material de plástico definida como carro, se desplace horizontalmente en un eje definido,

con un coeficiente de fricción bajo y se deslice sobre un eje cilíndrico metálico. En la figura
11.45, se observa la impresora utilizada, el sistema de desplazamiento del carro deslizante
y una réplica exacta del mecanismo de desplazamiento horizontal del carro de los
cartuchos, para conformar un sistema Maestro-Esclavo con las mismas características.
Figura 11.45. Impresora Hp670c y su mecanismo de carros deslizantes duplicados para formar un sistema
Maestro-Esclavo.
El elemento actuador encargado de mover el sistema de desplazamiento es un motor

DC, conocido como motor de corriente continua de 24 V, C2162-60006, este motor se
presenta en el mecanismo de control de movimiento de los cartuchos de la impresora Hp
670c y controlado por un señal de ancho de pulso PWM. Es necesario establecer un tren
de pulsos con una amplitud que varía entre 0 y 24 V, con un ciclo positivo variable entre
un 0 y 100%.
Los motores DC utilizados, contienen el módulo acondicionador de potencia y de

inversión de giro llamado puente H, en este caso se trabaja con el L298. En la figura 11.45,
se observa el puente H. El módulo requiere de dos señales digitales para definir el sentido
de giro del motor.
255
Figura 11.45. Acondicionador puente H L298.
Se acondicionan dos elementos sensores en ambos mecanismos, conformados por

sensores de posición y de fuerza para determinar el desplazamiento de cada uno de los
carros y la fuerza de interacción con el entorno y con el operador. Los sensores de posición
son de infrarrojo, marca Sharp GP2Y0A02YK0F analógicos, ubicados en ambos
mecanismos frente al carro a lo largo del eje de desplazamiento, desde el punto inicial del
recorrido del carro y hasta un punto final del recorrido.
Los sensores de fuerza de la marca FlexiForce, se ubican sobre los carros móviles
del modelo maestro y esclavo respectivamente. Este sensor de fuerza se acondiciona con
una base circular de material acrílico para hacer incidir la fuerza de presión sobre un punto
específico. En la figura 11.45, se muestra los sensores de posición y fuerza.
Figura 11.45. Sensores de posición y fuerza.

256
Los circuitos de acondicionamientos para cada uno de estos sensores se hacen a

través de una serie de Amplificadores de Instrumentación, probados y simulados en
Multisim, tal como se muestra en la figura 11.46; que ajustan los niveles de tensión a los
requeridos por los canales analógicos de una tarjeta de adquisición de datos.
Figura 11.46. Circuitos acondicionadores de los Sensores.
El sistema de Teleoperación, utiliza un sistema de control central formado por una

tarjeta de adquisición de datos National Instruments DAQ 6216 USB, la tarjeta de
adquisición va a controlar cuatro canales de entrada analógicos, cuatro canales de salida
digitales y dos contadores o generadores de pulso. La tarjeta presenta comunicación serial
USB con la computadora y su entorno de programación en LabVIEW. La tarjeta va utilizar
cuatro puertos de entradas analógicas para adquirir la información de cada uno de los
sensores de posición y fuerza del sistema Maestro y Esclavo, estos valores se requieren
para establecer la ubicación en tiempo real de los carros en cada eje del desplazamiento
horizontal, y a su vez verificar la fuerza generada por el contacto del carro Esclavo con el
entorno y también la fuerza aplicada por el operador al carro Maestro.
Los cuatro canales digitales se utilizan como datos de salida para controlar el
sentido de giro y detener los motores DC del sistema Maestro y Esclavo, se requieren dos
entradas digitales para controlar la inversión de giro por motor, estos cuatro datos digitales
se envían al módulo L298 del puente H, que establecerá posteriormente la energía e
información que requiere los motores. Las dos salidas de generadores de pulso, se
257
encargaran de la señal PWM que debe ir a cada motor, para poder controlar su giro y
velocidad, estas dos señales también deben pasar por el puente H, para que se amplifiquen
en potencia. En la figura 11.47, se observa el sistema con los controladores del mecanismo
maestro y esclavo sin la ubicación de los sensores.
Figura 11.47. Hardware del sistema Maestro-Esclavo de Teleoperación.
Los elementos sensores que se ubican en cada uno de los carros, deben ir también
conectados al controlador central para establecer el respectivo lazo de control.
Diseño del Software: Para proceder a probar los diferentes elementos actuadores y
sensores del sistema Maestro-Esclavo, se programan en LabVIEW funciones específicas
para el manejo de los motores, el puente H, sensores de posición, sensores de fuerza, y para
establecer los procesos de calibración de los mismos.
El primer programa está formado por una función que se utiliza para regular la
velocidad y el cambio de giro de los de los motores DC de los sistemas Maestro y Esclavo,
ver figura 11.48.
258
Figura 11.48. Panel frontal del subVI para controlar los motores dc del sistema Maestro-Esclavo.
El programa consiste en configurar la comunicación con la tarjeta de adquisición

de datos, para manejar los cuatro canales digitales de salida que van al puente H o módulo
L298 y los dos canales de salida del generador o contador de pulsos que van a los motores;
se deben configurar por separado cada una de las aplicaciones que requieren el uso de la
tarjeta de adquisición de datos. En la figura 11.49, se observa el código de programación
en el Diagrama de Bloques del VI.
Figura 11.49. SubVI para controlar movimiento de los motores dc del sistema Maestro-Esclavo desde la
DAQ.
259
El segundo programa se encarga de los sensores de posición, tal como se muestra

en las figuras 11.50 y 11.51, acá se debe plantear la configuración de los canales analógicos
para recibir las señales de entrada de los sensores y presenta una función de conversión de
datos, la cual establece el modelo de una función matemática de polinomio que relacione
los niveles de tensión de entrada con los valores de posición en centímetros de la ubicación
del carro en el eje del sistema Maestro y Esclavo.
Figura 11.50. Panel frontal del subVI para controlar los sensores de posición del sistema Maestro-Esclavo.
Figura 11.51. Código del subVI para controlar los sensores de posición del sistema Maestro-Esclavo.
260
Para establecer el proceso de calibración y el modelo matemático, se realiza una

serie de mediciones de voltaje por cada centímetro de desplazamiento, luego se utiliza el
programa Excel, para levantar la curva de datos y definir la ecuación de polinomio que
describe el comportamiento de los sensores, tal como se muestra en la figura 11.51.
Figura 11.51. Calibración de los sensores de posición del sistema Maestro-Esclavo.
El tercer programa repite los mismos pasos del sensor de posición, pero aplicado
ahora a los sensores de fuerza.
Una vez comprobados todos los programas y verificada la comunicación con los
sensores y actuadores, se procede a comprobar su operación en dos procesos básicos de
control bilateral, asumiendo los mecanismos del desplazamiento horizontal de las
impresoras, como proceso real Esclavo y Maestro del sistema. La primera técnica de
control bilateral a probar se define Posición-Posición, este sistema de control para un grado
de libertad utiliza el error de posición de los sistemas Maestros y Esclavo para establecer
el control, basado en el Diagrama de Bloques de la figura 11.52.
261
Figura 11.52. Control bilateral Posición-Posición.
En el programa de la figura 11.53, se observa los parámetros de configuración de

los canales de adquisición y generación de datos, se configuran los canales Analógicos de
entrada para ambos sensores de posición y los cuatro canales de salida Digitales para el
control de giro de cada motor, también se configura los contadores de pulso para generar
la PWM de ambos motores, con un controlador variable para el ciclo positivo del pulso. Se
establecen controladores numéricos para los parámetros de ganancia del Maestro y el
Esclavo y las perturbaciones del lazo del control bilateral.
Este esquema funciona adecuadamente, aunque el seguimiento es lento debido a la

velocidad de respuesta del sistema Esclavo. Si se mejora la velocidad el sistema se hace
inestable, debido a que los sensores de posición presentan un rango de variación mínima
que es detectado por el lazo de control, generando una pequeña oscilación en el movimiento
del carro del sistema Esclavo.
262
Figura 11.53. Código de la técnica de control bilateral Posición-Posición, sobre el Sistema Maestro-
Esclavo, asumiendo las funciones que permiten actuar sobre los motores.
La segunda técnica de control bilateral a probar es Fuerza-Posición, este sistema

de control para un grado de libertad, utiliza el error de posición del Maestro y Esclavo y le
anexa la fuerza medida en el Esclavo para establecer el control. La medición de fuerza se
extrae de un sensor real de fuerza que realimenta el sistema.
263
Figura 11.55. Control bilateral Fuerza-Posición.
En el esquema de la figura 11.55, se agrega el sensor de fuerza, en el carro del

mecanismo Esclavo y se procede a medir el contacto del carro con un objeto fijo. El
movimiento nuevamente ocurre en el carro del mecanismo Maestro e inmediatamente el
lazo de control intenta ubicar el carro del mecanismo Esclavo en la misma posición, pero
si existe contacto con un objeto y es detectado por el sensor de fuerza, el carro del
mecanismo Maestro debe ofrecer resistencia al movimiento.
La fuerza que el operador aplica para mover el carro se puede definir como la
perturbación, el error de los valores de posición y la fuerza medida en el esclavo definen
las variables de control.
264
Figura 11.56. Código del programa del control bilateral Fuerza-Posición, sobre el Sistema Maestro-
Esclavo, incluyendo la información del sensor de fuerza.
En la figura 11.56, se observa el programa que igual al esquema de posición,

incluye los parámetros de configuración de los canales de adquisición y generación de
datos, se configuran los dos canales Analógicos de entrada para ambos sensores de posición
y para el sensor de fuerza, se configura los cuatro canales de salida Digitales para el control
de giro de cada motor, también se configura los contadores de pulso para generar la PWM
de ambos motores, con un controlador variable para el ciclo positivo del pulso. Se
establecen controladores numéricos para los parámetros de ganancia y perturbaciones del
lazo del control bilateral.
265
Prueba y verificación:
Pruebas del control bilateral Posición-Posición: El movimiento del operador ocurre
sobre el carro del mecanismo Maestro, inmediatamente el lazo de control intenta ubicar el
carro del mecanismo Esclavo en la misma posición. La fuerza que el operador aplica para
mover el carro se puede definir como la perturbación (τA) y el error de los valores de
posición define la variable de control. El esquema se prueba sin colisiones con el entorno
en el sistema Esclavo. Este esquema funciona adecuadamente, aunque el seguimiento es
lento debido a la velocidad de respuesta del sistema Esclavo. Si se mejora la velocidad el
sistema se hace inestable, debido a que los sensores de posición presentan un rango de
variación mínima que es detectado por el lazo de control generando una pequeña oscilación
en el movimiento del carro del sistema Esclavo. En la figura 11.54, se muestra el panel
frontal del VI para el control bilateral Posición-Posición.
Figura 11.54. Panel frontal del VI de control bilateral Posición-Posición sobre el Sistema Maestro-
Esclavo.
Pruebas del control bilateral Fuerza-Posición: Este esquema funciona, pero presenta los
mismos inconvenientes del esquema anterior, también se puede observar gran inestabilidad
en el sensor de fuerza usado, lo que se refleja con oscilaciones en el carro del sistema
266
Maestro. La respuesta al contacto con un objeto en el sistema esclavo, se representa en el

maestro con un movimiento opuesto al movimiento que el operador ejerce al tratar de
desplazar el carro. En la figura 11.57, se muestra el panel frontal del VI para el control
bilateral Fuerza-Posición.
Figura 11.57. Programa del sistema de control bilateral Fuerza-Posición.

267
Capítulo XII
Interfaz del LabVIEW con el Simulador Electrónico Multisim
La instrumentación electrónica se encarga de acoplar señales físicas reales con

procesadores de datos, muchas veces estas señales se deben someter a una serie de circuitos
Analógicos y Digitales que establezcan un acondicionamiento adecuado de la información.
Los acondicionadores de señales son circuitos electrónicos previamente diseñados y
simulados en programas dedicados a estas funciones y asegurar el buen funcionamiento de
estos circuitos; la National Instruments ofrece un programa de diseño electrónico conocido
como Multisim, el cual se utiliza para diseñar y simular circuitos electrónicos Analógicos
y Digitales y poder comunicarlos con los datos que sean requeridos en LabVIEW ya sea
para generación, adquisición o procesamiento de señales.
Este capítulo, describe el funcionamiento del Multisim y su conexión con

LabVIEW. En primer lugar se hace un breve reconocimiento del Multisim como
herramienta de diseño para circuitos electrónicos; luego analiza y simula algunos ejemplos
de circuitos Analógicos y Digitales; de seguida establece un protocolo de comunicación
entre el LabVIEW y Multisim. El enlace de Multisim y LabVIEW permite generar señales
en LabVIEW, y procesarlas en circuitos diseñados en Multisim, también comunica el
Multisim con los módulos DAQ a través del LabVIEW. Esto permite simular con datos
reales y los resultados de una simulación de circuitos convertirlos en una señal real. A
continuación se describen los temas que abarcan el capítulo con su respectiva prioridad.
-. Conocer el Multisim.
-. Diseño de circuitos electrónicos con Multisim.
-. Crear un Sub VI en Multisim.
-. Comunicar Multisim con LabVIEW.
.- Actividad Complementaria 11.
268
Conocer el Multisim
Multisim es un programa de diseño electrónico, en un entorno de simulación

SPICE, utilizado para simular, diseñar y analizar circuitos análogos y digitales en el estudio
de la ingeniería electrónica. Una de las funciones más importantes es optimizar los diseños
de circuitos para posterior generación de tarjetas electrónicas, también prueba de prototipos
que permitan realizar ajustes de parámetros para buscar resultados óptimos. El Multisim es
propiedad de National Instruments, los mismos fabricantes del programa LabVIEW, en la
figura 12.1, se observa la ventana de inicio del programa para la versión 14.0.
Figura 12.1. Programa de simulación electrónica Multisim 14.0.
Multisim presenta una ventana de programación, tal como la figura 12.2, formada
por una serie de bloques y menús desplegables que definen todas las herramientas que se
requieren para el diseño y simulación de circuitos electrónicos, además define las funciones
que sirven de interfaces con LabVIEW, estableciendo los parámetros de entrada y salida y
la función o SubVI que se generan para sincronizar y comunicar ambos programas. A
continuación se definen algunos de los elementos más relevantes del Multisim:
1. Presenta una etiqueta que define el nombre del proyecto a diseñar.

269
2. Presenta una ventana equivalente a una hoja o tablero de pruebas de circuitos, en

dicho tablero se montan y conectan los diferentes dispositivos que van a conformar
el circuito electrónico a simular.
3. Presenta una ventana de exploración donde se observan los diferentes circuitos que
conforman un proyecto, cada hoja de prueba es un diseño que se anexa a un
proyecto específico.
4. Presenta un menú vertical que contiene todos los instrumentos de medición y
generación que pueden ser utilizados en las diferentes simulaciones, acá hay
instrumentos específicos que están relacionados con el LabVIEW.
5. Presenta un menú de cabecera donde se encuentran las diferentes librerías de
componentes electrónicos utilizados en los diseños de circuitos, los alambres de
conexión, los botones de ejecutar la simulación, los diferentes esquemas de
presentación de los circuitos, y todas aquellas funciones de configuración y
simulación del programa.
Figura 12.2. Ventana principal del Multisim.
Para diseñar un circuito básico se deben considerar todos los elementos que
contengan el circuito, sus alambres de conexión, sus instrumentos de medición y los
270
respectivos generadores de señales. A continuación se observan los procedimientos para

ubicar cada uno de estos elementos del circuito.
Componentes: Multisim, presenta diversas librerías de componentes asociadas a los

fabricantes de los mismos, de allí se pueden extraer todos los elementos que se requieran
en la simulación, también permite agregar librerías adicionales para componentes que no
estén por defecto en el programa y diseñar componentes con requerimientos específicos.
En la figura 12.3, se observa las opciones para seleccionar componentes.
Figura 12.3. Menú para seleccionar componentes.
Al seleccionar alguno de los componentes se abre un menú con los códigos

correspondientes a los diferentes elementos a seleccionar. Por ejemplo si se desea
seleccionar un amplificador operacional 741, se accede al menú dela figura 12.4 y se
procede a buscar el dispositivo, ya sea por su tipo, código e imagen.
Figura 12.4. Ventana de búsqueda de componentes para el Amplificador 741.
Algunos componentes están directamente relacionados con el hardware de la

National Instruments, específicamente las tarjetas de adquisición de datos DAQ.
271
Generadores de señales: Los elementos para generar señales analógicas o digitales, se

consiguen en el menú de componentes, en la opción correspondiente a fuentes de corriente
y todo elemento de alimentación usado en el diseño de circuitos, ver figura 12.5.
Figura 12.5. Ventana de búsqueda de componentes para fuentes y generadores.
También se puede utilizar generadores de señales, ubicados en el menú vertical del

Multisim, como se muestra en la figura 12.6.
Figura 12.6. Generador de señales del menú vertical del Multisim.

272
Existen algunos generadores de señales en el menú vertical derecho de la ventana

principal de Multisim, que están directamente relacionados con las interfaces del
LabVIEW a través de subVIs, ver figura 12.7.
Figura 12.7. Generador de señales de LabVIEW ubicados en el menú vertical del Multisim.
Instrumentos de medición: En la barra vertical derecha de la ventana principal de

Multisim, se encuentran los diferentes instrumentos de medición Análogos y Digitales, ver
figura 12.8.
Figura 12.8. Instrumentos de Medición del menú vertical del Multisim.

273
De igual forma que los generadores de señales, se tienen diversos instrumentos de

medición relacionados con LabVIEW, tal como se muestra en la figura 12.9.
Figura 12.9. Instrumentos de medición de LabVIEW ubicados en el menú vertical del Multisim.
También hay una serie de puntos de prueba ubicados en el menú horizontal, para
realizar medición directa de voltaje y corriente en nodos y líneas de conexión del circuito,
ver figura 12.10.
Figura 12.10. Puntos de prueba para medición de voltaje y corriente.
Conectores o alambres: Una vez colocado los elementos sobre el tablero de trabajo, con
el cursor del ratón se puede hacer el alambrado o la conexión de los componentes, tal como
se muestra en la figura 12.11, para ello se debe ir a cada pin del componente seleccionarlo
y definir el pin siguiente a conectar.
274
Figura 12.11. Alambrado de componentes en Multisim.
Diseño de circuitos electrónicos con Multisim
National Instruments proporciona un enfoque integrado para el diseño electrónico

con NI Multisim para captura y simulación de circuitos. En este ejercicio se va construir
un circuito amplificador de tensión con un transistor bipolar BJT 2N3904 y un recortador
de onda con diodos. El objetivo principal de este ejercicio es familiarizarse con la facilidad
de uso del ambiente de NI Multisim así como sus capacidades de simulación y análisis.
Siguiendo los pasos de buscar y colocar elementos, generadores, instrumentos y enlaces de
conexión, se arman los siguientes circuitos.
Ejemplo de Aplicación 19: Diseñar circuitos electrónicos con Multisim.
Circuito N°1: Amplificador Emisor Común, con una polarización por divisor de tensión.
Consiste en un transistor controlado por corriente con dos valores de resistencia R1 y R2,
para establecer la corriente de la base y los valores de resistencias RE y RC del emisor y
colector para establecer la polarización y la ganancia en señales alternas de frecuencia
media. El circuito se acompaña de una fuente DC para su polarización, condensadores para
desacoplo de las señales AC y los valores DC; utiliza un generador de ondas para la señal
de entrada y un osciloscopio para visualizar la señal de salida amplificada.
Desarrollo: Armar el circuito amplificador con transistor BJT de la figura 12.12, buscando
cada uno de los elementos activos y pasivos en el buscador de dispositivos del Multisim y
conectándolos en el panel de pruebas, también se busca un instrumento de medición para
analizar la razón de amplificación del circuito.
275
VCC VCC
4V XSC1
Ext Trig
+
RC
R1 750Ω
_
A B
4kΩ _ _
+ +
C2 ES2
2 ES2
Q1 130µF 0
ES1 C1
ES1 1
V1 2N3904
100µF
2mVrms R2 3
1kHz 1kΩ
0° RE C3
0 0 250Ω 2.5mF
0 0
Figura 12.12. Amplificador Emisor Común, diseñado en Multisim.
Pruebas: Se realiza la simulación del circuito y se verifica el valor de salida del

amplificador en un instrumento de medición del Multisim, en este caso se trata de un
osciloscopio de 2 canales; la señal roja es la onda de entrada y la señal azul es la onda
amplificada con un desfasaje producto de la configuración emisor común para los
amplificadores de tensión. En la figura 12.13, se observa la señal de entrada y salida del
amplificador Emisor Común visto en un osciloscopio.
Figura 12.13. Señal de entrada y salida del amplificador Emisor Común con un osciloscopio del Multisim.
Circuito N°2: Recortador polarizado y no polarizado, con diferentes ramas de diodos

ubicados de tal forma que permitan variar la pendiente de la ecuación de transferencia que
relaciona el voltaje de entrada y salida de un circuito con diodos alimentado en AC.
276
Desarrollo: Armar el circuito recortador con diodos de Silicio, tal como se muestra en la
figura 12.14, buscando los elementos activos y pasivos del Multisim y conectándolos en el
panel de pruebas, buscar un instrumento de medición para la señal de salida recortada.
XSC1
Ext Trig
+
_
A B
+ _ + _
D1 V2
1 2 3 R2
1kΩ 5
1N4001 5V
V1 D3
1N4001
R1 D2
18Vrms 1kΩ 1N4001 6
60Hz
0° V3
15V
Figura 12.14 Circuito Recortador polarizado y no polarizado, diseñado en Multisim.
Pruebas: En la salida se desea observar la relación de transferencia, que relaciona el voltaje

de salida en función del voltaje de entrada para una alimentación AC. El osciloscopio se
debe poner en modo XY, para visualizar la ecuación de transferencia, tal como se muestra
en la figura 12.15.
Figura 12.15. Gráfica de la relación de transferencia del circuito con diodos.

277
Crear un Sub VI en Multisim
Los diferentes circuitos diseñados y analizados en Multisim se pueden enlazar con

los programas realizados en LabVIEW, a través de un protocolo de conexión que se puede
plantear en una serie de pasos que se van a describir a continuación:
Paso 1: Se diseña en el Multisim el circuito que se va a conectar con el LabVIEW. Para el

ejemplo un circuito recortador polarizado con diodo, como se muestra en la figura 12.16.
Figura 12.16. Circuito Recortador polarizado con diodo.
Paso 2: Se procede a buscar los conectores que van a servir de interfaz de comunicación
de entrada y salida del circuito con el LabVIEW, Para ubicar los conectores se debe buscar
en el menú PLACE la opción CONNECTORS y aparece el menú de la figura 12.17, se
debe seleccionar los terminales del Co-Simulador de LabVIEW.
Figura 12.17. Menú para localizar los conectores del Co-Simulador de LabVIEW.
278
Paso 3: Los terminales seleccionados para las señales de entrada y salida se conectan a los
componentes del circuito, tal como se muestra en la figura 12.18.
IO2 R1 IO3
1kΩ
D1
1BH62
V1
5V
Figura 12.18. Conectores de entrada y salida del Co-Simulador de LabVIEW.
Paso 4: Se debe buscar en el menú principal VIEW, la opción de visualización de los

terminales del Co-Simulador de LabVIEW. Se despliega una ventana de trabajo como la
que se observa en la figura 12.19, indicando los conectores y permitiendo cambiar su
configuración, también se observa una vista previa del subVI creado en Multisim para ser
ejecutado en LabVIEW.
Figura 12.19. Ventana de terminales del Co-Simulador de LabVIEW.
Paso 5: Se guarda el proyecto y el sistema queda referenciado con el nombre que le asigne
el programador con una estructura muy similar a los VI Express, luego se procede abrir
desde el LabVIEW, para establecer la conexión. En la figura 12.20, se muestra el SubVI
diseñado en Multisim.
279
Figura 12.20. SubVI diseñado en Multisim.
Comunicar Multisim con LabVIEW
Después de crear un SubVI en Multisim, se debe proceder a comunicarlo con el

programa de desarrollo de aplicaciones LabVIEW, los conectores de entrada y salida del
SubVI servirán como interfaz de datos entre el LabVIEW y Multisim. A continuación se
describe una serie de pasos que se deben ejecutar para enlazar un circuito Electrónico
diseñado en Multisim y su respectivo flujo de datos en LabVIEW.
Paso 1: En la paleta de funciones se ubica en la opción Control y Simulación, selecciona

del menú la opción Simulación, Luego procede a seleccionar un lazo conocido como
Control & Simulation Loop, y se procede a ejecutar la simulación externa con el
Multisim.En la figura 12.21, se observa el lazo de control y simulación en LabVIEW.
Figura 12.21. Lazo de control y simulación en LabVIEW.
Paso 2: Dentro del lazo de control y simulación se pueden agregar diferentes elementos de
programación que interactúen con el módulo externo creado en Multisim, generadores de
señales e instrumentos gráficos de medición, ver figura 12.22.
280
Figura 12.22. Elementos de control y simulación para interactuar con el SubVI creado en Multisim.
Paso 3: La función External Model del menú de simulación de la figura 12.23, es la

encargada de enlazar el programa externo o SubVI creado en Multisim y ajustarlo al código
de programación en LabVIEW.
Figura 12.23. Función External Model.
Paso 4: Por último se debe seleccionar el proyecto creado en Multisim y abrirlo dentro del
lazo de control y simulación y conectar los elementos que se requieran para generar flujo
de datos con el subVI, ver figura 12.24.
281
Figura 12.24. SubVI creado en Multisim, abierto en el lazo de control y simulación del LabVIEW.
Paso 5: Recuerde que las señales simuladas en Multisim deben ser observadas en
LabVIEW, lo que requiere que se establezca un Panel Frontal como el de la figura 12.25,
donde se pueda confirmar la efectividad en la simulación.
Figura 12.25. Panel Frontal con el indicador gráfico de las señales procesadas en Multisim.
Objetivo, simular una fuente de tensión AC a DC.

282
Definir el problema: Simular y diseñar en el Multisim una fuente de tensión AC-DC, que
convierta una señal sinusoidal de 120 Vrms, de 60 Hz a un valor fijo DC de 12 V. Utilizar
rectificador de onda completa, filtros capacitivos y un regulador de tensión con Zener. Se
requiere generar la señal AC en LabVIEW, enviarla a Multisim, diseñar la fuente en
Multisim y finalmente mostrar la salida DC en un indicador Gráfico del LabVIEW.
Diseñar soluciones: Definir las variables de entrada y salida del problema, tal como se

Voltaje AC onda Seno INPUT Control Gráfica WAVEformGRAPH
Voltaje DC OUTPUT Indicador Grafica WAVEformGRAPH
Aplicación:
Diseño en Multisim: Se establecen dos conectores del Co-Simulador del LabVIEW, uno
para la señal de entrada AC proveniente del LabVIEW y el otro como señal de salida DC
generada por el circuito de simulación en Multisim. En la figura 12.26, se diseña el circuito
del convertidor AC-DC.
Figura 12.26. Circuito convertidor AC-DC en Multisim.

283
Seguidamente se diseña el SubVI en Multisim que se conecta con los datos de

LabVIEW, ver figura 12.27.
Figura 12.27. Co-Simulador LabVIEW para interface con Multisim.
En la figura 12.28, se carga el SubVI en el LabVIEW dentro del lazo de control y

simulación, se le añade una señal Ac al terminal de entrada y un indicador gráfico al
terminal de salida.
Figura 12.28. Código de programación en LabVIEW para interface con Multisim.
Prueba y verificación: Se procede a correr la simulación en LabVIEW, observando el

correcto funcionamiento del circuito convertidor AC-DC, tal como se muestra en la figura
12.29.
284
.
285
Capítulo XIII
Comunicación Arduino con LabVIEW
El lenguaje de programación LabVIEW, es propiedad de la empresa National

Instruments, establece una serie de herramientas de programación que facilitan la
configuración y conexión con todos sus dispositivos y tarjetas de adquisición de datos con
diferentes protocolos de comunicación. Cuando se tienen módulos o tarjetas de adquisición
de otros fabricantes como por ejemplo Arduino, la conexión y configuración se realiza de
una forma más compleja, ya que en LabVIEW se deben programar los protocolos de
configuración, conexión y lectura de datos del nuevo hardware conectado al sistema, sin
embargo, National Instruments facilita una serie de Toolkits o herramientas de
programación, que representan un grupo de funciones o VI que facilitan la conexión con
hardware de otros fabricantes.
En este capítulo, se da un conocimiento breve de la plataforma de programación de

Arduino, el cual se presenta como un hardware y software disponible para conectarse
amigablemente con el LabVIEW; establecer una comunicación adecuada para resolver
problemas de medición y control en instrumentación electrónica. Se aprovecha las ventajas
que presentan los módulos de Arduino, relacionados con costo, plataforma, entorno de
programación además del software y hardware expandibles. Los temas son los siguientes:
-. Introducción al módulo Arduino
-. Programación con Arduino.
-. Toolkits de LabVIEW para programación de Arduino.
-. Programación de Arduino con LabVIEW.
-. Actividad Complementaria LabVIEW-Arduino 12, 13, 14 y 15.

286
Introducción al módulo Arduino
La marca Arduino representa una empresa de diseño de hardware compuesto de

tarjetas electrónicas basadas en microcontroladores, con un entorno de desarrollo (IDE) de
código abierto para la programación de cada placa. El software de programación utilizado
se conoce como Wiring similar al lenguaje C/C++. Las tarjetas presentan similitud a los
módulos DAQ pero representadas en módulos llamados Shields de Arduino, que
incrementa el número de aplicaciones y soluciones para automatización y transmisión de
datos. Las placas se pueden ensamblar sin dificultad, el software es gratuito y los diseños
de referencia pueden ser modificados y adaptados a las necesidades del usuario. Además
permite a los usuarios desarrollar programas llamados Sketch para el control de variables
de entrada y salida, sin conocer la arquitectura interna de la plataforma.
Arduino se convierte en una referencia de bajo costo para programación de sistemas

automatizados de control y monitoreo para un número reducido de variables y con
diferentes protocolos de comunicación. Toda la plataforma, tanto para hardware como
software, son liberados con licencia de código abierto. El hardware se basa en el
Microcontrolador Atmel, con sus respectivos puertos de entrada y salida Analógica y
Digital, con posibilidad de anexar placas de expansión para mejorar su potencialidad, las
tarjetas presentan diferentes protocolos de comunicación siendo la conexión USB una de
las más comunes.
Software del Arduino: Se programa en un entorno de desarrollo (IDE) basado en lenguaje

de programación Wiring, similar al programa en lenguaje de alto nivel C/C++, tiene los
siguientes componentes para elaborar el algoritmo: Estructuras, variables, operadores
matemáticos, lógicos y booleanos, estructuras de control (Cíclicas y condicionales) y
funciones. En la tabla 13.1, se observan algunos comandos de sus componentes de
programación:
287
Tabla 13.1. Funciones de programación de Arduino.

Funciones Componentes
Estructuras: funciones principales Setup(){} Código de configuración inicial.
que un programa en Arduino debe
tener. Loop(){} Se ejecuta luego del setup(), y se mantiene
hasta desconectar o desenergizar el Arduino.
Variables: Cambian su valor durante Booleano: Función Boolean variable =valor
la ejecución del programa Entero: Función int variable =valor
Carácter: Función char variable= valor
Operadores: Matemáticos, lógicos y Matemáticos:
booleanos = (asignar), % (modulo), + (suma), - (resta),
*(multiplicación) y / (división).
Booleanos: Se representan mediante símbolos,
utilizados dentro de un condicional If: &&(And),
ΙΙ(Or) y !(negación)
Comparación: Se utilizan generalmente dentro del
condicional If: == (igual a ), != (diferente de),
< (menor que), > (mayor que),
<= (menor o igual) y >= (mayor o igual).
Estructuras de control: Permiten If, Switch/case, For y While.
tomar decisiones y hacer repeticiones
de acuerdo a los parámetros de
programación.
Funciones: Conjunto de líneas de Funciones Digitales:
código que realizan una tarea
pinMode(); Configura el pin como entrada o salida.
específica y retornan un valor.
digitalRead (); Lee un pin digital.
digitalWrite(); Escribe un pin digital como 1 ó 0.
Funciones Análogas: Lectura y escritura de valores
análogos:
analogRead(pin); Lee un valor análogo de 0 a 1023.
analogWrite(pin, valor de PWM); Escribe un valor de
0 a 255
.
Hardware del Arduino: En la tabla 13.2, se referencian algunas tarjetas electrónicas de
la familia Arduino, Considerando su estructura más básica, representada por un
Microcontrolador, puertos de entrada y salida de datos Analógicos y Digitales y su puerto
de comunicación.
288
Tabla 13.2. Familia de tarjetas electrónicas de Arduino.

Descripción Tarjeta
Arduino Uno: Atmega 328, 14 entradas/salidas
Digitales (6 pueden utilizarse como PWM), 6
entradas Analógicas y un cristal de 16MHz,
cable USB. Voltaje de operación de 5V.Rango
de voltaje de 7 a 12V. Memoria Flash: 32KB.
EEPROM:1KB
Arduino Pro Mini 328: Atmega 168, diseñado

para montarse en placas bases, cuenta con 14
entradas/ salidas Digitales (6 pueden utilizarse
como PWM), 8 entradas Analógicas y una de
16MHz. Regulador 5V integrado, protección de
sobrecarga y contra inversión de polaridad. No
debe alimentarse con más de 9V.
Arduino Fio: Ideal para proyectos

inalámbricos. Atemega 328 a 8MHz, incluye el
Arduino Bootloader, compatible con baterías de
litio Polímeto. Cargador LiPo MAX1555
integrado. Botón Reset.
Arduino Nano: Permite realizar prototipos en

protoboard, conector Mini USB. Reset
automático al descargar el programa, regulador
de tensión integrado, conector ISCP para la
programación, pines con espaciado para
insertarlo directamente al protoboard.
Arduino Leonardo: Atmega 32U4, la placa
permite ser utilizada y programada como un
dispositivo de entrada, para emular un teclado,
ratón, etc. Tiene 12 entradas Analógicas, ya que
el puerto de comunicación USB es emulado,
deja el puerto serial hardware libre para la
programación. Tensión de funcionamiento: 5V,
alimentación recomendad: 7 a 12V. Canales
PWM: 7, velocidad: 16MHz.
En la figura 13.1, se muestran algunos elementos de expansión de Arduino son

conocidos como módulos Shields, y se utilizan para aplicaciones específicas, que permiten
aumentar la funcionalidad de las tarjetas:
289
Figura 13.1. Tarjetas de expansión o módulos Shields.
Descripción del módulo Arduino Uno: Para este capítulo se desarrollaran programas del
LabVIEW con el módulo de Arduino Uno, es uno de los más utilizados por principiantes,
también su costo es menor a otros módulos de la misma familia Arduino. Este módulo,
contiene una Paleta de Funciones completa configurada en LabVIEW, lo que facilita su
programación y conexión. El Arduino Uno presenta un conjunto de características que lo
hacen atractivo para procesos básicos de medición y control. En la figura 13.2, se identifica
cada uno de los elementos que conforman una placa del Arduino Uno.
Figura 13.2. Elementos de la placa Arduino Uno.

290
Elementos: Conector USB (1), Pulsador Reset (2), Pines de E/S Digitales y PWM (3), Led
Verde de placa encendida (4), Led naranja conectado al pin 13 (5), Atmega U2 encargado
de comunicación con PC (6), Led TX (Transmisor) y RX(Receptor) de comunicación serial
(7), Puerto ICSP para programación serial (8), Microcontrolador Atmega 328 (9), Cristal
de cuarzo de 16MHz (10), Regulador de voltaje (11), Conector hembra con centro + (12),
Pines de voltaje y tierra (13) y Entradas Análogas (14).
Programación con Arduino
El Arduino presenta un IDE como interfaz de programación, el cual se puede

descargar en la página oficial de Arduino https://www.arduino.cc/ . La interfaz de
programación establece una serie de opciones de configuración y conexión, además de la
zona de programación donde se estable el código y la zona de mensajes de compilación.
En la figura 13.3, se puede observar el IDE de Arduino.
Figura 13.3. IDE de Arduino.
En la zona de programación se compila el código, o se pueden cargar archivos

previamente editados, librerías propias, entre otros. La conexión de IDE con la placa
Arduino Uno, requiere algunos pasos de configuración, se debe indicar inicialmente el
modelo de placa Arduino, tal como se observa en la figura 13.4.
291
Figura 13.4. Configuración de la placa en el IDE de Arduino.
Posteriormente se indica el puerto de comunicación que está conectada la tarjeta,

tal como se muestra en la figura 13.5, para el caso de la placa Arduino Uno se presenta el
puerto de comunicación USB.
Figura 13.5. Configuración del puerto de comunicación del Arduino en el IDE de Arduino.
Ejemplo de aplicación 20: Enviar mensaje en una pantalla LCD, desde una placa Arduino.
Definir el problema: A continuación se requiere realizar una conexión del Arduino Uno
con una pantalla LCD, y establecer un mensaje de saludo que no supere los 16 caracteres
para una pantalla de 16x2.
Diseñar soluciones: Arduino cuenta con bibliotecas como “LiquidCrystal”, que permite
controlar periféricos como el display LCD, de esta manera mostrar mensajes en pantalla.
292
El LCD que se utiliza en el ejemplo tiene capacidad de caracteres de 16x2, es decir, 16

caracteres en dos filas. Los elementos de conexión de la pantalla son los siguientes:
RS (Register Select): Pin que controla la memoria del LCD, e indica que registro de la
memoria será el que se lee o escribe.
RW (Read/Write): Pin de lectura y escritura, que dirá si se escribe en memoria o si se lee
en cada momento.
E (Enable): Pin que habilita los registros.
DB0-DB7: Pines de datos, de los que se sacan los bits que llegan al registro.
Vo: Pin de contraste de la pantalla, para modificar el contraste de la pantalla.
Vdd: Pin de alimentación, normalmente +5V.
GND: Pin de conexión a tierra.
El circuito de conexión del Arduino y la pantalla LCD, se muestra en la figura 13.6.
Figura 13.6. Conexión del Arduino Uno y la pantalla LCD.
Aplicación: El código de programación que se debe descargar en el IDE, define la función

de conexión con la pantalla LCD y el mensaje de “Bienvenidos”, el cual se debe observar
en la pantalla como salida del programa.
Código del programa:

#include <LiquidCrystal.h> //Biblioteca necesaria para LCDs.
LiquidCrystal lcd(13,12,11,5,4,3,2); //Iniciar los pines a utilizar.
void setup() {
293
lcd.begin(16, 2); //Expresar el número de columnas y filas del LCD.

lcd.print(“Bienvenidos"); //Imprimir el mensaje deseado en el LCD.
}
void loop() {
lcd.setCursor(0,1); //Preparar el cursor en la columna 0 de la línea 1 //Esto indica donde
comenzara a imprimirse el texto.
}
Prueba y verificación: El mensaje de “Bienvenidos”, debe observarse en la pantalla LCD.
Figura 13.7. Mensaje de saludo en la pantalla LCD.
Toolkit de LabVIEW para programación de Arduino
El LabVIEW Permite la comunicación con la tarjeta Arduino a través, de una serie

de funciones propias alojadas en diferentes Toolkits que se pueden descargar y enlazar al
programa LabVIEW. De esta manera se puede utilizar las placas Arduino con la misma
facilidad que se hace con los módulos DAQ de National Instruments. El LabVIEW
presenta diferentes mecanismos para comunicarse con la placa Arduino Uno, el método
más básico es a través de los drivers del protocolo de comunicación serial; el Arduino Uno
tiene puerto de comunicación USB, por lo que pudiera comunicarse con el LabVIEW, a
través de una configuración de puerto serial para leer y escribir datos en dicho puerto. Para
ello se requiere tener en el LabVIEW instalado los driver del NI VISA, para comunicación
serial con Arduino.
El Toolkit que presenta LabVIEW para programación de Arduino Uno, se conoce

como LabVIEW interface for Arduino, esta herramienta permite crear un grupo de SubVIs
294
ubicados en la Paleta de Funciones del Diagrama de Bloques, donde están todos los
comandos de conexión directa del LabVIEW con los puertos de entrada y salida de la placa
Arduino Uno, más algunos programas referenciados a trabajar directamente con los
periféricos que se pueden conectar a la tarjeta. En la figura 13.8, se observa la paleta de
funciones del Toolkit de Arduino Uno e LabVIEW.
Figura 13.8. Paleta de funciones del Toolkit de Arduino Uno para LabVIEW.
Existe una forma segura de conseguir los kits de herramientas de programación, se

debe descargar un instalador de programas conocido como VIPM ( VI Package Manager),
programa encargado de un gran número de manejadores de herramientas para las diferentes
versiones del LabVIEW, el VIPM se puede descargar en forma gratuita del siguiente enlace
https://vipm.jki.net/get. Para el caso de estudio se descarga la versión 2016 del VIPM que
se muestra en la figura 13.9.
Figura 13.9. Instalador de programas VIPM 2016.
El VIPM, presenta una ventana de exploración como la que se observa en la figura

13.10, donde se ubican los diferentes programas de herramientas o Toolkit, para proceder
a descargar se debe realizar los siguientes tres pasos:
295
1. Elegir la versión del LabVIEW que se tenga instalado en el servidor.

2. Seleccionar los Toolkit a Descargar, ejemplo LabVIEW Interface for Arduino.
3. Seleccionar del menú el botón install package y proceder a la respectiva descarga.
Figura 13.10. Ventana de exploración del VIPM, para descargar Toolkit de Arduino.
Una vez que el sistema haya reconocido el Arduino, la programación se realiza con
el sketch que comunica la placa Arduino con LabVIEW, este sketch se instala con el
archivo LIFA_Base, en la ruta que se muestra en la figura 13.11.
Figura 13.11. Ruta del archivo LIFA_Base para comunicar Arduino con LabVIEW.
En el directorio LIFA_Base se encuentra el archivo LIFA_Base.pde, como se

muestra en la figura 13.12, el cual al abrir, se abrirán todas las librerías para programar en
la placa de Arduino Uno, de esta manera la placa podrá comunicarse con LabVIEW, luego
296
se procede configurar el IDE para la placa Arduino Uno y el puerto de comunicación. Ya

se puede programar sin inconvenientes desde el LabVIEW en la placa Arduino.
Figura 13.12. Archivo LIFA_Base en el IDE del Arduino.
Existen otro grupo de herramientas que se pueden descargar del VIPM, que también
pueden ser útiles para crear interfaces de programación de Arduino desde el LabVIEW:
Makerhub: Toolkits, que puede ser utilizado para programar el Arduino desde LabVIEW,
con la ventaja que puede ser aplicado para programar cualquier placa de la familia Arduino,
ver figura 13.14.
Figura 13.14. Paleta de funciones MakerHub.

297
Arduino Compatible: Se utiliza como un compilador de Arduino desde el LabVIEW. En

la figura 13.13, se muestra la paleta de funciones del Compiler for LabVIEW:
Figura 13.13. Paleta de funciones del Compiler for LabVIEW.
Programación de Arduino con LabVIEW
Para realizar la programación del Arduino desde el LabVIEW, se remplaza el

lenguaje de programación tradicional del Arduino, por el lenguaje Gráfico del LabVIEW.
El Toolkit de Arduino con LabVIEW, ofrece todas las herramientas para establecer una
comunicación y programación adecuada para la tarjeta Arduino Uno. En las tablas 13.3,
13.14 y 13.15, se muestran las funciones del Toolkit de Arduino en LabVIEW.
Tabla 13.3. Funciones de inicio y fin del Toolkit de Arduino.

Descripción SubVI
INIT, inicia comunicación con la placa Arduino,
configura la conexión LabVIEW-Arduino, con
elementos como la velocidad de baudios, el tipo de
placa, los bytes por packets, y un determinado
protocolo de comunicación para el caso del Arduino
Uno corresponde a serial USB
CLOSE, se encarga de cerrar la comunicación del

LabVIEW con la placa Arduino.
298
Tabla 13.4. Funciones de bajo nivel y de sensores del Toolkit de Arduino.

Descripción SubVI
LOW LEVEL, representa
un conjunto de funciones
relacionadas con las
lecturas y escrituras en los
diferentes puertos de
entrada y salida de datos
de la placa Arduino Uno.
SENSORS,
representa un conjunto de
funciones relacionadas con
los diferentes tipos de
elementos que se le
conectan a los puertos de
entrada y salida de la placa
Arduino. Establece una
forma directa de
comunicación con los
datos requeridos por
diferentes elementos
sensores y actuadores.
299
Tabla 13.5. Funciones de Ejemplos del Toolkit de Arduino.

Descripción SubVI
EXAMPLES,
representa un conjunto
de funciones
programadas en forma
completa, para trabajar
con circuitos básicos
configurados para los
diferentes tipos de
elementos sensores que
se discutieron en el
punto anterior.
Actividad Complementaria LabVIEW-Arduino 12, 13, 14 y 15
El Toolkit de LabVIEW para Arduino, presenta una serie de ejemplos que permiten
realizar las conexiones físicas con los elementos conectados a la placa Arduino Uno. Estas
aplicaciones son funciones programadas previamente, que facilitan la conexión con los
diferentes elementos sensores.
Actividad Complementaria 12: Objetivo, utilizar entrada analógica del Arduino.
Definir el problema: Leer un valor de tensión por el puerto de entrada analógica de

Arduino y mostrar la tensión en un indicador en LabVIEW.
Diseñar soluciones: Establecer las variables de entrada y salida de datos (Tabla 13.6), y el
diagrama de flujos del problema, tal como se muestra en la figura 13.15.
300

Pin de Entrada INPUT Control Numérico Entero
Voltaje OUTPUT Indicador Numérico Punto flotante
.
Figura 13.15. Diagrama de flujos de la Actividad Complementaria 12.
Aplicación: Para resolver este ejemplo se tienen todos los comandos que ofrece el Arduino
para la lectura de puertos analógicos, por lo que requiere las funciones de iniciar la
comunicación LabVIEW Arduino INIT (1), lectura de señal analógica ANALOG READ
(2), cerrar la comunicación con Arduino CLOSET(3), indicar la señal de Error(4) en la
comunicación. La lectura del puerto o pin analógico debe hacerse en un ciclo repetitivo
controlado por el usuario o por un período de tiempo definido. En la figura 13.16, se
muestra el algoritmo del programa.
301
Figura 13.16 Código de programación de Actividad Complementaria, VI de Arduino para puerto analógico.
El circuito electrónico que debe ir conectado al puerto Analógico del Arduino viene
configurado por defecto con la función. En la figura 13.17, se muestra la conexión de
hardware para la actividad complementaria 12.
Figura 13.17. Conexión del Hardware de Actividad Complementaria 12.
Prueba y verificación: El Panel Frontal del VI de ejemplo del LabVIEW de la figura

13.18, muestra el indicador de tensión Analógico. Tanto el Panel Frontal como el Diagrama
de Bloques del ejemplo, se puede modificar y personalizar a las necesidades del usuario.
302
Actividad Complementaria 13: Objetivo, Utilizar salida Digital del Arduino.
Definir el problema: Controlar un display de 7 segmentos para mostrar un conteo

ascendente en decimal de los números del 0 al 9, utilizando una configuración de display
cátodo común y con la Interfaz Arduino-LabVIEW. El intervalo de tiempo que debe durar
cada digito en pantalla puede ser configurado por el usuario, pero inicialmente debe ser de
tres segundos.
Diseñar soluciones: Establecer las variables de entrada y salida de datos, tal como se
muestra en la tabla 13.7, además de realizar el diagrama de flujos del problema, como se
muestra en la figura 13.19.

Temporizador INPUT Control Numérico Punto flotante
Conteo OUTPUT Indicador Numérico Entero

303
.
Aplicación: Para resolver este ejemplo se trabaja con puertos Digitales, ya que se requiere
activar los diferentes pines de salida del display 7 segmentos. Los pasos son los siguientes:
Comunicación LabVIEW Arduino, INIT (1), configuración del display 7 segmentos
SEVEN SEGMENT CONFIGURE (2), escribir el mensaje en el display 7 segmentos
SEVEN SEGMENT WRITE STRING (3), cerrar la comunicación con Arduino CLOSET
(4), Indicar señal de Error(5) en la comunicación, el mensaje a escribir debe previo realizar
un conteo ascendente de 0 a 9 con tres segundos de retardo. En la figura 13.20, se muestra
la programación de la actividad complementaria 13.
304
Figura 13.20. Código de programación de la Actividad Complementaria con los VI de Arduino 7 Segmentos.
El circuito electrónico que debe ir conectado al display de 7 segmentos y a los puertos

Digitales del Arduino viene configurado por defecto con la función. En la figura 13.21, se
muestra la conexión del hardware de la actividad complementaria 13.
Figura 13.21, Conexión del hardware de la Actividad Complementaria 13

305
Prueba y verificación: El Panel Frontal del VI de la figura 13.22, se observa el digito que
se debe enviar al Display 7 Segmentos y el tiempo de duración.
Actividad Complementaria 14: Controlar pantalla LCD con el Arduino desde LabVIEW.
Definir el problema: Controlar una pantalla LCD con la Interfaz Arduino-LabVIEW y

enviar un mensaje de “Bienvenida” en la pantalla.
muestra en la tabla 13.8, además utilizar un diagrama de flujo del problema, como se

Fila del LCD INPUT Control Numérico Entero
Columna del LCD INPUT Control Numérico Entero
Mensaje de texto INPUT Control Cadena de Caracteres Mensaje
Pines de Configuración INPUT Control Arreglo Numérico Cluster

306
.
Aplicación: Para resolver este ejemplo se trabaja con puertos Digitales, ya que se requiere
activar los diferentes pines de configuración de la pantalla LCD. Los pasos son los
siguientes: Estructura de eventos con funciones de comunicación LabVIEW Arduino INIT
(1), configuración de la pantalla LCD CONFIGURE (2), funciones de configuración del
mensaje, ubicación del cursor, intensidad, dirección, desplazamiento LCD SET CURSOR
(3), estructura de evento para posicionar cursor en el momento de recibir mensajes nuevos
LCD SET CURSOR (4), enviar en cadena de caracteres el mensaje e imprimir en pantalla
LCD PRINT (5), cerrar la comunicación CLOSET (6), indicar señal de Error (7) en la
comunicación. En la figura 13.24, se muestra la programación para el desarrollo de la
actividad complementaria 14.
307
.
Figura 13.24. Código de programación VI Arduino para configurar y programar pantalla LCD.
El circuito electrónico que va conectado a la pantalla LCD y a los puertos Digitales del
Arduino viene configurado por defecto con la función. En la figura 13.25, se muestra la
conexión en hardware del Arduino Uno que se utiliza en la actividad complementaria 14.
Figura 13.25. Conexión del hardware de la Actividad Complementaria 14.
Prueba y verificación: El Panel Frontal del VI de la figura 13.26, muestra el mensaje

como un string, los elementos de configuración de pantalla, incluyendo la posición de
impresión del mensaje en la pantalla LCD.
308
Actividad Complementaria 15: Controlar un motor paso a paso con el Arduino desde
LabVIEW.
Definir el problema: Controlar un motor paso a paso utilizando un puente H, para el

control de giro, velocidad y suministro de energía del motor, utilizar la Interfaz Arduino-
LabVIEW.
muestra en la tabla 13.9, además utilizar un diagrama de flujos del problema, ver figura
13.27.

Paso del movimiento INPUT Control Numérico Punto flotante
Velocidad del Paso INPUT Control Numérico Punto flotante
Regulador de Velocidad INPUT Control Numérico Punto flotante
Comenzar movimiento INPUT Control Botón Booleano
Detener movimiento INPUT Control Botón Booleano
Motor Activo OUTPUT Indicador Led Booleano
309
.
Aplicación: Para resolver este ejemplo se trabaja con puertos Digitales, y las señales PWM
requeridas para controlar el giro y velocidad del motor. Se utiliza una estructura de eventos
con las siguientes funciones: comunicación LabVIEW Arduino INIT (1), configuración de
los driver de comunicación con el motor paso a paso STEPPER CONFIGURE (2),
funciones de configuración de los datos de operación del motor paso a paso, numero de
pasos, velocidad de giro, entre otros STEPPER WRITE (3), función de ejecución del
movimiento del motor paso a paso STEPPER TOGO (4), cerrar la ejecución del motor
paso a paso STEPPER CLOSE (5), cerrar la comunicación del Arduino CLOSET (6),
indicar señal de Error (7) en la comunicación. En la figura 13.28, se muestra la
programación para la actividad complementaria 15.
310
Figura 13.28 Código de programación con los VI de Arduino para control del motor paso a paso.
El circuito electrónico que debe ir conectado al motor paso a paso, con el puente H
y los puertos Digitales y PWM del Arduino viene configurado por defecto con la función
y se muestra en la figura 13.29.
Figura 13.29. Conexión del hardware de la Actividad Complementaria 15.
Prueba y verificación: El Panel Frontal del VI de la figura 13.30, se muestra con un

regulador de la velocidad de giro del motor, que genera la activación de eventos en tiempo
real, y los indicadores de configuración del paso del motor.
311

312
Capítulo XIV
Módulo de Control y Simulación
En la ingeniera electrónica se estudia el monitoreo y control de procesos

industriales, basados en modelos matemáticos de los sistemas y en las diferentes técnicas
para diseñar lazos de control. El módulo de Control y Simulación de LabVIEW es un grupo
de funciones que permiten la simulación de los sistemas dinámicos lineales y no lineales
en el tiempo, continuos y discretos y establecen los lazos de control. El modelo matemático
a simular se realiza en un lazo de simulación muy similar a los diferentes lazos de
programación que maneja el LabVIEW; el lazo contiene elementos de configuración en
función del tiempo para la velocidad de la simulación y los algoritmos de solución de
ecuaciones.
Este capítulo, analiza el módulo de Control y Simulación del LabVIEW, para

definir los modelos matemáticos de diferentes sistemas dinámicos. Se inicia con una breve
descripción del Toolkit de Simulación y Control del LabVIEW, luego se explica con más
detalle el módulo de Control y el módulo Simulación y la configuración adecuada para una
simulación; finalmente se realiza un ejemplo de un sistema de control bilateral de un
sistema Maestro-Esclavo con herramientas del simulador. Temas:
-. Toolkit de Control y Simulación.
-. Funciones del Diseño de Control.
-. Funciones de la Simulación.
-. Desarrollo de aplicaciones, basadas en las funciones de simulación de Sistemas Lineales
Continuos y Discretos y los Sistemas no Lineales.
313
Toolkit de Control y Simulación
El Grupo de funciones de LabVIEW de Diseño de Control y Simulación, abarca las

funciones para establecer procesos de control y las funciones para generar simulación. El
Control implica el desarrollo y análisis de modelos matemáticos de sistemas físicos, para
conocer sus características dinámicas y crear controladores para lograr ciertas
características favorables al sistema. La Simulación es un proceso que implica el uso de
software para recrear y analizar el comportamiento de sistemas dinámicos y proporcionar
comportamientos que no se pueden replicar adecuadamente en la realidad. A continuación
se observa en la figura 14.1, el Toolkit de LabVIEW del Diseño de Control y Simulación,
indicando los elementos de Control y los elementos de Simulación.
Figura 14.1. Paleta de funciones del Control Design & Simulation de LabVIEW.
Funciones del Diseño de Control
El Diseño de Control es un proceso que implica el desarrollo de modelos

matemáticos de sistema físicos, analizando los modelos para conocer sus características
dinámicas y crear modelos de control que utilizan función de transferencia, espacio de
estado o ganancia de polos y ceros, analizar la respuesta del sistema en el tiempo, mapas
de polos cero y diagramas de Bode; También brinda la posibilidad de trabajar con sistemas
discretos y analizar el comportamiento del modelo en lazo abierto, y en lazo cerrado. En
314
la figura 14.2, se muestra la paleta de funciones del Control Design y la identificación de

algunas de las aplicaciones más recurrentes en el diseño de sistemas de control.
Figura 14.2. Paleta de funciones del Control Design de LabVIEW.
Las diferentes funciones del módulo de Diseño de Control, se pueden estudiar

partiendo del análisis del modelo de un determinado proceso. A continuación se realiza un
ejemplo que construya la función de transferencia de un proceso y se utilice algunas de las
funciones que permitan analizar la dinámica del proceso.
Ejemplo de Aplicación 21: Probar las funciones del módulo de Diseño y Control.
Actividad 1: Construir la función de transferencia de un proceso caracterizado por la

ecuación 14.1:
% & =
' "
!' ( '
Ec. 14.1
315
Se procede a construir el modelo de la función de transferencia a través, de las

funciones de construcción del modelo, ubicadas en la paleta de Diseño de Control,
seleccionando la función CD Construct Transfer Function Model.
La función requiere los coeficientes del numerador y el denominador como

variables de entrada, y genera a la salida la función de transferencia. En la figura 14.3, se
observa el Diagrama de Bloques y el Panel Frontal de la función de transferencia.
Figura 14.3. Función de transferencia a partir de la función Cd Construct Transfer Function Model.
Actividad 2: Realizar un lazo de realimentación de la función de transferencia de la

ecuación 14.1 con la función representada en la ecuación 14.2:
) & =&+1 Ec. 14.2
Figura 14.4. Lazo realimentado de la función.
En la figura 14.4, se diseña un lazo cerrado con las dos funciones de transferencia
G(S) y H(S), se modela la función de transferencia en lazo cerrado a través del menú de
316
Diseño y Control INTERCONNECTION MODEL, seleccionar la función CD

FEEDBACK. En la figura 14.5, se observa el Diagrama de Bloques y el Panel Frontal para
generar la función realimentada.
Figura 14.5. Código de programación y Panel Frontal de la función realimentada CD FEEDBACK.
Actividad 3: Calcular la respuesta en el tiempo para una función escalón y una función
impulso del sistema modelado en la actividad 1.
Se debe generar dos gráficos relacionados con la respuesta en el tiempo para la

respuesta al escalón y al impulso de la función de transferencia. Para ello se selecciona la
función del Diseño y Control TIME RESPONSE, y se elige la función para el escalón CD
STEP RESPONSE y para el impulso CD IMPULSE RESPONSE. En la figura 14.6, se
observa el Diagrama de Bloques para calcular la respuesta en el tiempo de la función G(S)
y su respectivo Panel Frontal.
317
Figura 14.6. Código de programación y Panel Frontal de la respuesta al escalón y al impulso de la función
de transferencia.
Actividad 4: Calcular la respuesta en frecuencia del sistema modelado en el ejemplo 1.
Se debe generar los gráficos más usados para la respuesta en frecuencia, el

diagrama de Bode, Nyquist, Nichols, márgenes de ganancia y fase, entre otros. Para ello se
selecciona la función del Diseño y Control FREQUENCY RESPONSE, y se eligen las
funciones CD BODE, CD NYQUIST, CD NICHOLS y CD GAIN AND FASE
MARGINS. En la tabla 14.1, se observa el código de programación del Diagrama de
Bloques para calcular los diferentes gráficos de la respuesta en frecuencia de la función
G(S) y sus respectivos gráficos del Panel Frontal para la respuesta en frecuencia.
318
Tabla 14.1. Respuesta en frecuencia del modelo de la actividad 4.

Definición Grafica
Código del Programa
Diagrama de Bode
Magnitud y Fase
Nyquist
Nichols
Márgenes de
Ganancia y Fase
319
Actividad 5: Realizar análisis de las características dinámicas del sistema modelado G(S).
Se debe generar elementos que permitan estudiar las características dinámicas del
modelo, las funciones más usadas son el lugar de las raíces, mapa de polos y ceros, entre
otros. Para ello se selecciona del Diseño y Control la función DYNAMIC
CHARACTERISTICS, y se elige la función del lugar de las raíces CD ROOT LOCUS y
el mapa de polos y ceros CD POLE-ZERO MAPS. En la figura 14.7, se observa el
Diagrama de Bloques para calcular las características dinámicas de la función G(S) y su
respectivo Panel Frontal para el lugar de las raíces y el mapa de polos y ceros.
Figura 14.7. Código de programación y Panel Frontal del lugar de las raíces y mapa de polos y ceros de la
función de transferencia.
320
Diseño de Control Interactivo: Es un VI Express, que permite diseñar lazos de control y

sus características dinámicas de un proceso en una forma amistosa, a través de un panel
ejecutable. El VI se conoce como INTERACTIVE CONTROL DESIGN, se encuentra en
la el menú Diseño de Control; Se selecciona la función a modelar como entrada del VI de
Control Interactivo y el programa procede a realizar todo el respectivo análisis y permitir
modificar los parámetros de control de una forma más amigable. En la figura 14.8, se
muestra la programación y Panel Frontal del Control Interactivo.
Figura 14.8. Código de programación y Panel Frontal del Control Interactivo.

321
Funciones de la Simulación
La simulación utiliza estructuras de programación para emular y poder diseñar y

analizar el comportamiento de los sistemas dinámicos. El módulo de Simulación de
LabVIEW se consigue en el grupo de funciones del CONTROL DESIGN AND
SIMULATION, se selecciona las funciones de SIMULATION; que contiene todas las
funciones y subVI utilizados para el diseño y simulación de procesos en forma
estructurada. A continuación se describe algunos de los elementos más resaltantes y
utilizados en la simulación de procesos.
CONTROL & SIMULATION LOOP: Lazo de simulación, es una estructura en cuyo

interior se colocan todas las funciones de la paleta de simulación. Tiene dos ventanas de
entrada y de salida utilizadas para definir los parámetros de la simulación, la ventana de
entrada puede desplegar una lista de todos los elementos de configuración relacionado con
el tiempo, el método, el paso y la tolerancia, tal como se observa en la figura 14.9.
Figura 14.9. Lazo de Control y Simulación.
El panel de configuración, permite conectar directamente los valores requeridos

para cada Item utilizando controladores. También se puede configurar los parámetros
haciendo doble clip sobre la imagen de la ventana superior de entrada, abriendo un menú
de configuración más amigable al usuario, tal como se muestra en la figura 14.10.
322
Figura 14.10. Configurar los parámetros de entrada de la simulación.
En la figura 14.11, se observa la ventana de salida de los parámetros de simulación,

genera una señal de error del lazo y presenta una ventana de configuración jerárquica del
modelo de acceso.
Figura 14.11. Configurar los parámetros de salida de la simulación.
SIGNAL GENERATION: Paleta de generación de señales para funciones que están

dentro del lazo de simulación, contiene señales de rampa, pulso, escalón, sinusoidal,
generador de ondas, entre otros. En la tabla 14.2, se muestran algunas funciones del
generador de señales y parte de su panel de configuración.
323
Tabla 14.2. Funciones del Signal Generation.

Función SubVI Panel de configuración
Escalón
Pulso
Rampa
Generador
de Señales
324
SIGNAL ARITHMETIC: Paleta de funciones aritméticas, que pueden ser procesadas con
las señales del simulador, contiene funciones de ganancia, sumatoria y multiplicador para
cualquier número de entradas. En la tabla 14.3, se muestran algunas funciones aritméticas
y parte de su panel de configuración:
Tabla 14.3. Funciones del Signal Arithmetic.

Ganancia
Sumatoria
Multiplicador
325
GRAPH UTILITIES: Paleta de indicadores gráficos para visualizar las señales de

generación que estén dentro del lazo de simulación, contiene el SimTime Waveform, que
se utiliza para trazar variables simuladas de forma continua en un gráfico tipo Chart del
LabVIEW, el cual se añade automáticamente cuando se ubica la función sobre el lazo de
simulación. También presenta la función Buffer XY Graph, que se utiliza para recopilar
arreglos de señales que se trazarán en un gráfico XY de LabVIEW, el cual también se
añade automáticamente cuando se ubica la función sobre el lazo de simulación. En la tabla
14.4, se muestran las funciones del indicador gráfico y parte de su Panel Frontal.
Tabla 14.4. Funciones del Graph Utilities.

Función SubVI Panel frontal
SimTime
Waveform
Buffer XY
Graph
CONTINUOUS LINEAR SYSTEMS: Paleta de los sistemas lineales continuos,

contiene funciones de integración, derivación, retardos, espacio de estado, función de
transferencia, controlador PID, filtro de Kalman, entre otras funciones utilizadas en los
sistemas lineales continuos. En la tabla 14.5, se muestran algunas funciones y sus paneles
de configuración.
326
Tabla 14.5. Funciones del Continuous Linear System.

Integrador
Retardo en el
tiempo
Espacio de
Estado
Función de
transferencia
PID
327
NONLINEAR SYSTEMS: Paleta de los sistemas no lineales, contiene funciones no

lineales de Fricción, Cuantización, Zona muerta, Limitadores de velocidad, Relé,
Saturación, Interruptor y Detección de cruce por cero, entre otras funciones utilizadas en
los sistemas no lineales. En la tabla 14.6, se muestran algunas funciones y sus paneles de
configuración.
Tabla 14.6. Funciones del Nonlinear System.

Zona muerta
Cuantización
Relé
Detector de
cruce por cero
328
DISCRETE LINEAR SYSTEMS: Paleta de los sistemas lineales discretos, contiene

funciones discretas del integrador, retardo, retención, espacio de estado, función de
transferencia, ganancia, filtros, entre otras funciones lineales discretas. En la tabla 14.5, se
muestran algunas funciones discretas y sus paneles de configuración.
Tabla 14.5. Funciones del Discrete Linear System.

Integrador
discreto
Espacio de
estado
discreto
Función de
transferencia
discreta
Filtro
discreto
329
Desarrollo de aplicaciones, basadas en las funciones de simulación de Sistemas

Lineales Continuos, Discretos y Sistemas no Lineales
Sistemas Lineales Continuos: Las funciones para operar sistemas lineales continuos,
permiten realizar aplicaciones para modelar los procesos y las dinámicas de los mismos. A
continuación se realiza un ejemplo de un sistema lineal continuo con aplicaciones de
espacio de estado y función de transferencia.
Ejemplo de Aplicación 22: Probar las funciones del módulo de Simulación de Sistemas
Lineales.
Planteamiento del problema: Utilizando las funciones de simulación, determinar las

ecuaciones de espacio de estado y la función de transferencia, para el circuito RLC de la
figura 14.12, analizar la respuesta de voltaje del condensador.
Figura 14.12. Circuito RLC.
Las ecuaciones de estado del circuito RLC, están representados por la ecuación
14.2 y 14.3:
0
"
* 1 0
#=, " . 0 # + 2"3 4 5
+ −/ −. +
Ec. 14.2
/
330
4 * 5 = 40 1 5 1
#
+
Ec. 14.3
Desarrollo:
1. Crear el Lazo de Control y Simulación, para poder trabajar con la funciones del
simulador y buscar en la paleta de Funciones, el menú de Simulación, los Sistemas Lineales
Continuos y seleccionar función de espacio de estado.
2. Construir las matrices de la función de espacio de estado, tal como se muestra en la
figura 14.13, según las condiciones planteadas en el diseño.
Figura 14.13. Función de espacio de estado del circuito RLC.
3. Para calcular la función de transferencia, como se muestra en la figura 14.14, se puede

utilizar las funciones de control para hacer la conversión del modelo de espacio de estado
a función de transferencia.
Figura 14.14. Código de programación, para calcular la función de transferencia del Circuito RLC.
331
4. La función de transferencia queda representada la siguiente ecuación 14.4.
H S =
! "
"' ( 8, ' ! "
Ec. 14.4
5. Seleccionar de las funciones de utilidades gráficas el indicador de forma de onda y

conectarlo a la salida de la ecuación de espacio de estado y de la función de transferencia.
6. Generar un tren de pulsos para visualizar la respuesta del sistema a una señal de entrada.
En la figura 14.15, se muestra la programación para la simulación del circuito RLC.
Figura 14.15. Código de programación, para la simulación del Circuito RLC.
7. Observar en el panel frontal la respuesta en el tiempo del sistema a la señal de pulso, tal
como se muestra en la figura 14.16; tanto para espacio de estado como para función de
transferencia, como se muestra en la figura 14.17.
Figura 14.16. Respuesta en el tiempo para el espacio de estado del Circuito RLC.
332
Figura 14.17. Respuesta en el tiempo de la función de transferencia del Circuito RLC.
Sistemas lineales Discretos: Las funciones para operar sistemas lineales discretos de igual
manera que los continuos, modelan las dinámicas de los procesos con aplicaciones de
espacio de estado y función de transferencia pero en el dominio discreto Z.
Ejemplo de Aplicación 23: Probar las funciones del módulo de Simulación de Sistemas
Discretos.
Planteamiento del problema: Utilizando las funciones de simulación, determinar las

ecuaciones de espacio de estado y la función de transferencia discretas, del circuito RLC
del ejemplo anterior y analizar la respuesta de voltaje del condensador.
Desarrollo:
1. Partiendo del ejemplo anterior, en la figura 14.18, se utiliza la conversión de espacio de
estado continuo a discreto y de función de transferencia continua a discreta, con un periodo
de muestreo de 100 ms.
333
Figura 14.18. Código de programación para convertir la función de espacio de estado y la función de
transferencia de continua a discreta, para el Circuito RLC.
2. En la figura 14.19, se observan los coeficientes, para poder cargar los modelos en la
simulación.
Figura 14.19. Parámetros de la función discreta de espacio de estado y transferencia del Circuito RLC.
3. Se crea el Lazo de Control y Simulación, para poder trabajar con la funciones del
simulador.
4. Buscar en la paleta de funciones, el menú de simulación, buscar los sistemas lineales
discretos y seleccionar función de espacio de estado y proceder a cargar los coeficientes
del modelo, tal como se muestra en la figura 14.20.
334
Figura 14.20. Coeficientes del modelo de espacio de estado, para la simulación del Circuito RLC.
5. Buscar en la paleta de funciones, el menú de Simulación los sistemas lineales discretos

y seleccionar función de transferencia y proceder a cargar los coeficientes del modelo,
como se muestra en la figura 14.21.
Figura 14.21. Coeficientes del modelo de la función de transferencia, para la simulación del Circuito RLC.
6, Seleccionar de las funciones de utilidades gráficas el indicador de forma de onda y

conectarlo a la salida de la ecuación de espacio de estado.
7, Seleccionar de las funciones de utilidades gráficas el indicador de forma de onda y
conectarlo a la salida de la función de transferencia.
8. Generar un tren de pulsos que sirva como señal de entrada de los modelos y que permita
visualizar la respuesta del sistema a una señal de entrada, como se observa en la figura
14.22.
335
Figura 14.22. Código de programación de la simulación de la respuesta del sistema lineal discreto del
Circuito RLC.
9. Observar en el Panel Frontal la respuesta en el tiempo del sistema a la señal de pulso

tanto para espacio de estado como para función de transferencia, tal como se muestra en la
figura 14.23.
Figura 14.23. Respuesta en el tiempo a la señal pulso de la simulación para el modelo de espacio de estado
y función de transferencia Discreto del Circuito RLC.
Sistemas no Lineales: Las funciones para operar sistemas no lineales, se utilizan en

aquellos procesos que presentan esa condición, por ejemplo funciones de conmutación y
de saturación.
336
Ejemplo de aplicación 24: Probar las funciones del módulo de Simulación de Sistemas
no Lineales.
Planteamiento del problema: Utilizando las funciones de Simulación no lineales,

determinar el comportamiento de una señal sinusoidal de 10 V, que alimenta a un
amplificador que satura en +5 V y -5 V. Graficar con la función no lineal de saturación, el
valor máximo y mínimo de saturación, cuando la señal sinusoidal supere los rangos de
saturación del amplificador. Graficar con la función de conmutación, una señal de pulsos
que conmute cada vez que la onda sinusoidal supere el valor de un voltaje umbral, también
una señal de pulsos cada vez que la onda sinusoidal supere los rangos de saturación del
amplificador.
Desarrollo:
1. Crear el Lazo de Control y Simulación, para poder trabajar con las funciones no lineales
del simulador.
2. Buscar en la Paleta de Funciones, el menú de simulación, buscar los sistemas no lineales
y seleccionar las funciones de conmutación y saturación.
3. La función de saturación equivale al amplificador con rangos máximos y mínimos de +5
Voltios y -5 Voltios para la saturación. En la figura 14.24, se muestra los parámetros de la
función de saturación.
Figura 14.24. Parámetros de la función de saturación.

337
4. Para los conmutadores, debe indicar el valor máximo y mínimo de amplitud del pulso a
generar y el valor de umbral con el cual se va a realizar la comparación para conmutar el
pulso. En la figura 14.25, se observa la configuración del conmutador.
Figura 14.25. Configuración del conmutador.
5. Se agrega la señal sinusoidal al sistema, como se muestra en la figura 14.26. Estas señales
se pueden extraer del generador de señales del simulador.
6. Se anexan un gráfico para la señal sinusoidal, la señal de umbral y los valores de
saturación.
7. Se anexa un segundo gráfico para ver los pulsos que genera el conmutador, cuando
cumple las condiciones programada.
Figura 14.26. Código de programación del sistema no lineal.

338
8. En la figura 14.27, se observan los resultados de cada grafico en el Panel Frontal

y se evalúa la función para una determinada frecuencia. En la figura 14.28, se
observan los pulsos generados por los conmutadores.
Figura 14.27. Señal de salida sinusoidal y los valores de saturación y umbral.
Figura 14.28. Pulsos generados por los valores de saturación y umbral.
Objetivo, aplicar control Supervisorio a un sistema Cliente –Servidor.
Definir el problema: Diseñar un control de retardos aleatorios para un sistema Cliente-

Servidor con un lazo de control Supervisorio con funciones fuera de línea.
Diseñar soluciones: El control Supervisorio, es una técnica de Teleoperación, la cual se

basa en un sistema Cliente-Servidor, con retardos de comunicación variables. En la técnica
339
se utilizan datos simulados, para poder predecir la respuesta de Teleoperación cuando el

tiempo de retardo es muy grande, tal que pueda producir perdidas de paquetes de
información importante del sistema. Se programa dos soluciones, una al lado del Cliente y
otra al lado del Servidor, la solución del lado del Cliente se basa en la predicción remota,
para ayudar al operador a anticipar los efectos de sus acciones (Simulación predictiva). La
solución del lado del Servidor, se basa en un análisis inteligente del contexto llevado a cabo
automáticamente por el Servidor para realimentar, sintetizar y componer resultados, que
pueden reducir el tiempo de reacción de los operadores.
Se aplica Teleoperación bilateral, con retroalimentación de fuerza y velocidad, se

utiliza una variable aleatoria, para simular el tiempo de retardo presente en el medio de
comunicación, cada vez que el tiempo de retardo supere un valor umbral la Teleoperación
tanto en el Maestro (equipo Cliente), como en el Esclavo (equipo Servidor), se cambia de
los datos enviados del Cliente al Servidor, por datos simulados en el mismo Cliente y en el
mismo Servidor respectivamente, tal como se observa en el diagrama de flujo de a la figura
14.29. Diagrama de flujo 1:
Figura14.29. Diagrama de flujo del sistema de Teleoperación Cliente Servidor predictiva.

340
El equipo Cliente o sistema Maestro, está compuesto por un conjunto de funciones

que se observan en el diagrama de la figura 14.30, la cual presenta la función de
transferencia que define al sistema Maestro, un elemento sumador que relaciona las
componentes de fuerzas que llegan al sistema Maestro (fuerza del operador y la fuerza
realimentad del sistema Esclavo), un integrador para definir la posición del Maestro, los
visualizadores de las variables del sistema Maestro (fuerza, velocidad y posición); para
generar la interfaz gráfica con el operador y también envía al sistema Esclavo o equipo
Servidor la variable de velocidad del esquema de control bilateral. Diagrama de flujos 2:
Figura14.30. Diagrama de flujo del sistema Maestro o Cliente.
El equipo Servidor o sistema Esclavo de la figura 14.31, está compuesto por la

función de transferencia que lo define, la función de transferencia que define al entorno.
Un elemento sumador que relaciona las componentes de velocidad que llegan al sistema
Esclavo (velocidad enviada por el sistema Maestro y la velocidad del sistema Esclavo); un
integrador para definir la posición del Esclavo, los visualizadores de las variables del
sistema Esclavo (fuerza, velocidad, posición y error de posición), el error de posición
(diferencia de la posición entre el Esclavo y el Maestro) y el medio de comunicación que
341
se encarga de enviar al sistema Maestro o equipo Cliente la variable de fuerza del esquema
de control bilateral. Diagrama de flujos 3:
Figura14.31. Diagrama de flujo del sistema Esclavo o Servidor.
El tiempo de retardo aleatorio define un valor de umbral permitido por el sistema

Cliente-Servidor, que asegure la estabilidad y transparencia de la Teleoperación. El valor
de umbral que se asume para la simulación es de 1.1 segundos, este tiempo puede ser
modificado por el usuario, dependiendo de los requerimientos de la simulación. Si el
tiempo de retardo en el control bilateral está por debajo del valor umbral, los datos de
fuerza y velocidad enviados entre el Maestro y Esclavo son los levantados por el sistema;
pero si el tiempo del retardo supera el valor umbral, los datos que se envían al Maestro o
al Esclavo son los simulados y generados por el modelo matemático, que define la
respuesta característica del sistema y puede predecir el comportamiento esperado.
342
En la figura 14.32, se presenta el algoritmo que define la selección, que realiza el

programa cuando se presenta el tiempo de retardo para la realimentación de la fuerza y
velocidad en el control bilateral. Diagrama de flujos 4:
Figura14.32. Diagrama de flujo del método de selección de datos según el tiempo de retardo.
Aplicación: En el Diagrama de Bloques del programa, se puede observar los modelos del
sistema Maestro y Esclavo definido en términos de la frecuencia, utilizando la
transformada de Laplace, los parámetros de posición, velocidad, fuerza y los retardos con
datos aleatorios que pueden afectar el proceso de comunicación entre los sistemas Maestro
y Esclavo. Todo el sistema se encuentra en el interior del Lazo de Simulación y Control,
las características del Input Node, asume los valores por defecto.
El programa utiliza las funciones del Continuous palette: Integrator (para definir
posición), Transfer Function (para los modelos matemáticos del maestro, esclavo y
entorno), Time Delay (para incluir los retardos), el SimTime Waveform (para la interfaz
gráfica) y los sumadores. También se puede visualizar en la figura 14.33, el código de
programación para una variable aleatoria que define los retardos de la línea de
comunicación y que activan un sistema de comparadores y selectores que toman la decisión
343
de cuando el sistema va ser manejado con datos reales o manejado a través de datos
simulados.
Figura14.33. Código de programación del sistema Cliente-Servidor.
Prueba y Verificación: Se observan en el Panel Frontal de programación de la interfaz

vista por el operador, donde se puede manipular la fuerza y observar los valores de posición
y velocidad que responden al estímulo (las variables del Maestro en blanco y las del
Esclavo en azul). Se comparan gráficamente las respuesta del sistema Maestro y Esclavo,
el error generado entre ambos y dos indicadores que establecen en que momento la
Teleoperación se está haciendo con valores reales o simulados. Es importante comentar
que la fuerza del operador, se introduce de un generador de pulsos simulando el esfuerzo
del operador. En el Panel Frontal de la figura 14.34, se observan los resultados de las
pruebas, se puede visualizar las tres ventanas que monitorean las componentes de fuerza,
344
velocidad y posición. La línea blanca define los parámetros del Maestro y la línea azul del
Esclavo, existe otra ventana que establece el error de posición en línea amarilla.
Se observa que para retardos por debajo del umbral, el seguimiento tiende a ser
muy preciso, cuando se aproxima al valor umbral, el Esclavo se aleja un poco de la
respuesta del Maestro y aumenta el error de posición, si se supera el umbral, se activa la
Teleoperación predictiva retornando a un seguimiento muy preciso.
Figura14.34. Panel Frontal en LabVIEW de Teleoperación bilateral con datos en tiempo real y simulado.
345
Capítulo XV
Publicación de Programas vía Web
En la actualidad el acceso instantáneo a la información, se ha convertido en una

necesidad para los usuarios de las diferentes tecnologías de comunicación. Los procesos
controlados por sistemas automatizados no escapan a la necesidad de ser accedidos en
forma remota y en tiempo real, basados en redes globales de comunicación de datos y por
medio de equipos de uso común como computadoras de escritorio, portátiles, celulares,
tabletas, etc. Hablar de redes globales es referenciar el uso de Internet como una red pública
que sirve de plataforma para comunicar dispositivos de campo de un sistema de control,
con un programa de monitoreo de un operador.
Este capítulo estudia las posibilidades que presenta el LabVIEW para procesar
datos en forma remota vía Web, es decir, cómo acceder a procesos remotos desde una
computadora utilizando Internet y que permita una conexión en tiempo real con algún
proceso que se requiera monitorear. Se puede establecer dos elementos importantes para
realizar exitosamente una conexión remota, el primer elemento corresponde a un
computador que funcione como un servidor de aplicación Web y que a su vez debe estar
conectado a los dispositivos electrónicos que se encarguen del proceso de monitoreo de
datos; el segundo elemento a un canal físico de comunicación, en este caso la Internet y un
grupo de computadores que se puedan conectar al servidor principal usando una dirección
Web. A continuación los temas que se desarrollan en este capítulo:
-. Generación de páginas Web desde el LabVIEW
-. Acceso al Web Publishing Tool.
-. Crear una página Web con panel remoto.
-. Opciones de configuración.
346
Generación de páginas Web desde el LabVIEW
El programa LabVIEW genera un Panel Frontal remoto, para que pueda ser
accedido desde cualquier equipo que se contacte vía Internet con un servidor Web propio
del LabVIEW. El panel remoto se visualiza utilizando algunos de los navegadores
comerciales que se utilizan en Internet, se debe diseñar páginas Web que permitan servir
como base de visualización de un panel remoto, esto conlleva a establecer un equipo con
aplicaciones de adquisición y monitoreo de datos, que a su vez que tenga la utilidad de un
servidor Web, donde se puedan visualizar las páginas Web en el navegador del equipo
remoto.
El panel remoto es una de las implementaciones de control remoto básicas en

LabVIEW, consiste en hacer accesible vía Web un SubVI; se utilizan cuando el SubVI
necesita publicación en Web, el acceso al SubVI se realiza mediante un navegador Web,
desde un equipo que requiera interactuar con el panel remoto y que no tenga instalado el
software de la aplicación LabVIEW. El acceso a un panel remoto se puede realizar de las
siguientes formas:
1. Incrustado en una página HTML, donde se puede ver y controlar el panel.
2. Por medio de una imagen instantánea estática en el navegador.
3. A través de un grupo de imágenes estáticas que se actualizan en un tiempo
determinado.
El primer modo de acceso es el que se va a explicar en este capítulo, es uno de los

más utilizados debido a la posibilidad de hacer control sobre el panel remoto, presenta
algunas limitaciones, entre las más resaltantes es que solo puede ser controlado por un
usuario a la vez, es decir, le traslada el control al equipo cliente; otra limitación es que no
están disponibles en todos los navegadores ya que para el despliegue de los mismos dentro
del navegador se vale del uso de plugins que no se encuentran disponibles para todas las
plataformas en especial para las móviles. Para realizar un panel remoto incrustado en una
347
página HTML, con monitoreo y control se debe estudiar una herramienta que presenta el
LabVIEW, conocida como Web Publishing Tool, la cual se describe en el siguiente punto.
Acceso al Web Publishing Tool
La herramienta de publicación de páginas Web, la conseguimos en el menú

principal del panel frontal, en Tools y selecciona Web Publishing Tool, se despliega una
ventana como la que se observa en la figura 15.1.
Figura15.1. Ventana del Web Publishing Tool.
En la figura 15.1 se puede observar los siguientes elementos de configuración:

Vi name: Nombre del SubVI, que se desea incrustar en la página HTML.
Viewing Mode: Modo de visualización, los tres modos de publicación del panel remoto
vía Web.
Show border: Para visualizar los bordes del recuadro del panel frontal, embebido en la
página Web.
Start Web Server: Arranca el servidor Web del programa LabVIEW.

348
Preview: Muestra en un pequeño recuadro la forma de diseño del documento HTML.
Crear una página Web con el panel remoto
Se procede a realzar un SubVI, que se pueda incrustar en un documento HTML,

usando el Web Server del LabVIEW. Para ello se realiza un ejemplo y una serie de pasos
para mostrar el panel frontal en una página Web de un navegador comercial.
Ejemplo de aplicación 25: Objetivo, crear un panel remoto de un proceso industrial que
se acceda vía página Web.
Definir el problema: Se desea realizar el sistema de monitoreo de una línea transportadora

de cajas para almacenar cajas en dos camiones de carga, el sistema está formado por una
banda transportadora que presenta una bifurcación en un determinado punto, la cual se
activa por unos sensores que cuentan la capacidad máxima de cajas que se pueden
almacenar en un camión y así proceder a mandar las próximas cajas al siguiente camión.
Una vez realizado el programa se desea incrustarlo en un documento Web, para que pueda
ser visualizado en forma remota a través de la Internet, es importante que el panel remoto
que se genera pueda ser controlado por el cliente para el encendido y apagado del proceso.
Diseñar soluciones: Para este ejemplo se describe brevemente la función del programa,
pero se centra en detallar los pasos requeridos para hacer una publicación Web de un
SubVI.
Aplicación: Se define un proceso de conteo de cajas de una banda transportadora que

presenta una bifurcación en dos líneas, se establecen elementos de comparación para que
la banda transportadora cambie la línea de carga cuando los camiones ubicados en cada
línea de carga copen la capacidad máxima. Primero el contador va monitorear la cantidad
de cajas que pasan por la banda transportadora principal y que se desvían a la línea 1,
349
cuando el camión de la primera línea se llene, el sistema traslada la carga a la línea dos y
comienza a llenar el otro camión.
Las cajas se utilizan objetos en 3D, representados por cubos solidos con un
desplazamiento horizontal equivalente a la longitud de las bandas transportadoras.
También presenta variables booleanas para controlar el arranque del motor de la banda
transportadora, para detener el proceso y para indicar el flujo de las cajas por cada línea
transportadora. En la figura 15.2, se muestra el Diagrama de Bloques de la aplicación.
Figura15.2. Código de programación de la aplicación 24.
El detalle de la programación no es de mayor relevancia en este ejemplo, lo que se

desea resaltar es como llevar el panel de la aplicación a su publicación remota vía Web. En
la figura 15.3, se visualiza el Panel Frontal de la aplicación, formado por la correa
transportadora con su bifurcación, los dos camiones, los sensores de cada banda, y el
encendido y apagado del motor de la banda transportadora.
350
Figura15.3. Panel frontal de la aplicación 24.
A continuación se van a definir una serie de pasos para crear y publicar el panel
remoto en la página Web:
Paso 1: Seleccionar del menú principal del Panel Frontal la opción Tools y selecciona Web
Publishing Tool, recuerde que debe estar activa en el Panel Frontal el VI que se desea
publicar vía Web en la opción VI name.
Paso 2: Seleccione el modo de visualización o Viewing Mode, para el caso del ejemplo se
requiere que el panel remoto quede incrustado en una página HTML y que permita hacer
control sobre los botones del panel. En la figura 15.4 se observa la configuración del panel.
Figura15.4. Ventana de configuración del panel remoto.

351
Paso 3: Anexar al documento HTML, la configuración requiere la presentación de la

página junto al panel remoto. Debe indicar el título de la página Web, el encabezado y pie
de página Web, tal como se observa en la figura 15.5. Luego seguir con la configuración.
Figura15.5. Ventana de configuración del documento HTML para el panel remoto.
Paso 4: En el siguiente paso de configuración, se define la librería donde se guarda la

página HTML diseñada, define el nombre y el URL para el acceso a Internet utilizando los
navegadores.
Paso 5: Se procede a encender el servidor Web de LabVIEW. Ver figura 15.6.
Figura15.6 Ventana de configuración, activar el Servidor Web del LabVIEW para el panel remoto.
352
Paso 6: Se puede hacer una vista previa de la página Web diseñada, tal como se muestra
en la figura 15.7, para verificar que todos los campos se llenaron en forma correcta. El
programa se enlaza directamente con un navegador y enlaza la página diseñada.
Figura15.7. Vista previa del panel remoto en un navegador comercial.
Paso 7: Se procede a guardar la página Web y el sistema permite hacer una conexión previa
de prueba para verificar las opciones de control y monitoreo.
Prueba y Verificación: Se observa en las pruebas que el control se transfiere al equipo

cliente y lo puede ejercer desde el navegador que aloja la página Web, se puede asignar un
navegador por defecto, en este caso se utiliza el Internet Explorer. El programa que se
ejecuta en el servidor queda inhabilitado hasta que el cliente seda el control al servidor o
agote su disponibilidad de tiempo del control remoto, también habilitando la opción de
conmutar el control desde el equipo servidor.
353
El programador debe tener la precaución de no dejar por tiempo indefinido el

control al equipo remoto, por lo que debe crear en la configuración parámetros de
restricción del control remoto. En la figura 15.8, se observa en el círculo rojo el mensaje
que indica que el control lo tiene el servidor o el cliente y en el círculo azul el menú que le
permite al servidor conmutar el control.
Figura15.8. Vista del panel cuando se conmuta el control a un equipo remoto.
Opciones de configuración
El programa permite personalizar la configuración del servidor y controlar el acceso

a las páginas Web que se publiquen en el equipo servidor. Para ejecutar la configuración,
se debe seleccionar en el menú principal la ventana Tools, seguidamente Options, y aparece
el menú que se observa en la figura 15.9, con las opciones de configuración del Servidor
Web y los VI remotos.
354
Figura15.9. Aplicaciones VI Server y Web Server para configuración desde el menú Options.
El Web Server configura el panel remoto, incluyendo elementos como el puerto

HTTP, la dirección, raíz de los documentos Web a publicar entre otros. También se pueden
configurar en esta opción, parámetros de configuración a los VI que se desean publicar en
forma remota, y permitir o negar el acceso remoto a través de algunos navegadores. En la
figura 15.10 se observa las opciones del Web Server, para configurar el panel remoto.
Figura15.10. Opciones del Web Server para configuración del panel remoto.
355
El VI Server, permite la configuración del protocolo de comunicación de red

TCP/IP, el número de puerto, el nombre del servidor, el DNS, la configuración del panel
como un objeto ActiveX en el documento HTML, los recursos del servidor permitidos al
VI. Las direcciones de red de las maquinas que pueden conectarse al servidor, los VI que
pueden ser accedidos y controlados de forma remota, entre otras aplicaciones. En la figura
15.11 se observa las opciones del VI Server, para configurar el panel remoto.
Figura15.11. Opciones del VI Server para configuración del panel remoto.

356
Capítulo XVI
Comunicación de un PLC con LabVIEW
Las industrias manejan un gran número de variables para los sistemas de monitor y
control, hacen uso de equipos electrónicos industriales, de mayor velocidad de
procesamiento, de gran cantidad de terminales de entrada y salida para manejo de un gran
número de variables, protocolos industriales de comunicación, robustez, entre otras
características relevantes para establecer un sistema automatizado completo. Estos
sistemas presentan la información de sus variables en programas visuales que sirvan de
interfaz de las máquinas con sus usuarios. El LabVIEW se puede utilizar como referencia
para establecer un interfaz humano máquina y poder visualizar, todas las variables
monitoreadas por equipos industriales con un protocolo de comunicación específico.
En este capítulo, se identifican los elementos de un sistema automatizado, el cual

incluye los controladores lógicos programables PLC como equipos ideales para tomar la
información de un gran número de variables en un proceso industrial; los sistemas de
adquisición supervisión y control de datos y las interfaces de usuario. También se va a
definir el protocolo de comunicación de datos OPC, como el encargado de realizar la
comunicación de los datos del PLC con el programa de interfaz con el usuario. Finalmente
se establece la comunicación de un PLC de marca comercial con el programa LabVIEW a
través del OPC, para establecer la interfaz de usuario. Los temas son los siguientes:
-. Descripción de un PLC.
-. La Interfaz Humano Máquina (HMI)
-. Protocolo de comunicación OPC.
-. Algoritmo de conexión LabVIEW-PLC vía OPC.

357
-. Actividad Complementaria 17 PLC-LabVIEW.
Descripción de un PLC
Los Autómatas programables o controladores lógicos programables PLC, son

equipos electrónicos robustos, que sirven para tareas de monitoreo y control en los
procesos industriales. Presentan tarjetas Electrónicas (hardware), correspondiente al
cerebro principal del equipo, componentes de suministro de energía, tarjetas para el manejo
de variables físicas a monitorear, tarjetas de comunicación de datos, entre otros; también
presenta programas específicos (software), que permite realizar las aplicaciones lógicas en
el manejo de las variables del equipo y establecer los algoritmos de control. Estos equipos
pueden ser programados por un usuario para realizar secuencias específicas siendo muy
utilizado en las empresas para automatizar procesos industriales.
Componentes de los PLC: A continuación se describen los elementos principales de

hardware que conforman los controladores lógicos programables.
Unidad central de proceso o de control CPU: La unidad de control consulta el estado de

las entradas y recoge de la memoria del programa la secuencia de instrucciones a ejecutar,
elaborando a partir de ellas las señales de salida u órdenes que se enviaran al proceso.
Memoria del autómata: Contiene todos los datos e instrucciones que necesita para
ejecutar la tarea de control.
Memoria interna: Es la encargada de almacenar datos intermedios de cálculo y variables

internas que no aparecen directamente sobre las salidas, así como un reflejo o imagen de
los últimos estados leídos sobre las señales de entrada o enviados a las señales de salida.
358
Memoria del programa: Contiene la secuencia de operaciones que deben realizarse sobre
las señales de entrada para obtener las señales de salida, así como los parámetros de
configuración del autómata.
Interfaces de entrada y salida: Establecen la comunicación del autómata con la máquina.

Para ello se conectan por una parte, las señales de proceso a través de los conectores
previstos y por otra parte, el bus interno del autómata.
Fuente de alimentación: Proporciona las tensiones necesarias para el buen

funcionamiento de los distintos circuitos electrónicos del sistema.
La figura 16.1 muestra un diagrama representativo de los elementos que componen

un autómata programable.
Figura16.1. Diagrama de bloques de un autómata programable.
Los PLC, manejan programas que permite crear y editar los algoritmos de control,
en leguajes de programación típicos de PLC’S, siendo uno de los más comunes el Ladder,
también llamado programación en escalera o lenguaje de esquema de contactos. Este
359
lenguaje funciona como un editor de programación para el usuario, permite la

configuración del PLC y el manejo de todos sus periféricos. La programación en escalera
o diagrama de contactos, es el lenguaje de programación más popular de los PLC, está
basado en los esquemas eléctricos de control clásicos; de este modo, con conocimientos
eléctricos básicos, es muy fácil adaptarse a la programación en este tipo de lenguaje. En la
figura 16.2 se puede ver el ejemplo de un programa realizado en lenguaje escalera con el
programa RsLogix 500 de Rockwell Automation, para el PLC Allen-Bradley.
Figura 16.2 Ejemplo de un diagrama escalera hecho en RSLogix 500.
El programa Multisim de National Instruments También tiene la opción de crear

los diagramas de escalera o Ladder, con la ventaja que permite simular las secuencias de
programación y aplicarlas algún proceso específico. A continuación se cita el ejemplo de
un diagrama de la escalera para controlar dos semáforos. Se observa el diagrama de
escalera en la figura 16.3, creado y guardado en una función conocida como bloque
jerárquico.
360
Figura 16.3 Ejemplo de un diagrama escalera hecho en Multisim.
En la ventana principal del Multisim, se diseña el circuito que representa el control

de los semáforos como se obseva en la figura 16.4, anexando el bloque jerárquico que
contiene la lógica de programación Ladder. Al correr la simulación se puede observar la
ejecución del programa en escalera.
Figura 16.4 Ejemplo del circuito de control de semáforos hecho en Multisim.

361
La Interfaz Humano Máquina (HMI)
Es un panel de programación encargado de mostrar al usuario en forma amigable,

la distribución del sistema monitoreado y proporcionar la interacción entre un humano y
una máquina. Es la que permite que el usuario u operador del sistema de control o
supervisión, interactúe con los procesos.
En ese capítulo el LabVIEW asume la función de una HMI con dos funciones,
primero ser una interfaz graficas de usuario (GUI), que permita la interacción con el
sistema de forma rápida e intuitiva, a través de dispositivos como un teclado o un ratón.
Segundo ser una Interfaz basada en Web que permita la entrada y salida de datos del
sistema utilizando páginas Web desde un navegador desde Internet.
Protocolo de comunicación OPC
El protocolo de comunicación OPC, es un estándar de comunicación en el campo

del control y supervisión de procesos industriales, ofrece una interfaz común para
comunicación que permite que componentes software individuales interactúen y
compartan datos. Es una solución abierta y flexible al clásico problema de
los drivers propietarios, ya que comunica dispositivos, controladores y aplicaciones sin
caer en los problemas habituales de las conexiones basadas en protocolos propietarios.
El protocolo OPC observado en la figura 16.5, requiere de un Servidor OPC, el cual

se puede definir como una aplicación que cumple de interfaz, comunicando por un lado
con una o más fuentes de datos utilizando sus protocolo nativos (PLCs, Modulos I/O,
controladores, etc.) y por el otro lado con Clientes OPC (SCADAs, HMIs, aplicaciones de
cálculos, etc.), formando una arquitectura Cliente/Servidor OPC. El Servidor OPC es el
Esclavo mientras que el Cliente OPC es el Maestro. Las comunicaciones entre el Cliente
OPC y el Servidor OPC son bidireccionales, lo que significa que los Clientes pueden leer
y escribir en los dispositivos a través de un Servidor OPC.
362
OPC elimina la necesidad de disponer de drivers específicos entre cada aplicación

y la fuente de datos. Un protocolo estándar de PLC puede ser compartido simultáneamente
por un HMI y una aplicación de registro de datos históricos mediante un conector OPC,
con el beneficio añadido de que el conector OPC requiere una única conexión con el PLC,
reduciendo así la carga del procesador.
Figura 16.5. Protocolo de comunicación OPC.
Algoritmo de conexión LabVIEW-PLC vía OPC
La National Instruments presenta una serie de autómatas programables, conocidos

como PAC, estos equipos ofrecen características similares a los PLC de otros fabricantes,
los PAC están diseñados con la tecnología de procesamiento reciente para resolver
problemas avanzados de control en entornos industriales y robustos. Un PAC de NI es
completamente programable con LabVIEW, un entorno integrado de desarrollo gráfico. En
la figura 16.6 se observa uno de los PAC de National Instruments.
363
Figura 16.6. PAC de National Instruments.
El NI CompactRIO, es un sistema completo de control que incluye el PAC de

National Instruments, sus módulos de E/S, el chasis, varias opciones de protocolos de
comunicación y el software de programación LabVIEW para la HMI. En la figura 16.7 se
observa el sistema Compact RIO.
Figura 16.7. Sistema Compact RIO con HMI en LabVIEW.

364
En el presente capítulo se va disponer de un PLC de otro fabricante, para probar

que se puede comunicar satisfactoriamente con LabVIEW, a través, del protocolo OPC. Se
selecciona un PLC de la Rockwell Automation, el PLC Allen-Bradley Micrologix. Se
utiliza el programa RSLinx Classic de Rockwell Automation, para permitir que el
controlador programable Allen Bradley acceda a las aplicaciones de configuración y
programación RsLogix y aplicaciones HMI (Interfaz operador-maquina).
El RSLinx es el software que permite la comunicación entre la computadora y el

PLC permitiendo el acceso a lectura y escritura de información del Micrologix. El
RSLogix, es un software que permite crear y editar nuevos programas de control en
leguajes de programación de PLC’S Ladder, funciona como un editor de programación,
permite la configuración del modo de comunicación con el PLC, puede descargar del
computador hacia el PLC y desde el PLC hacia el computador la programación en escalera
y tiene un menú que contiene toda la información de los bits de funcionamiento del PLC,
el cual trabajando en conjunto con otros paquetes de software permiten visualizar cual es
el estado de las variables en tiempo real cuando se ejecuta el programa.
Comunicación PLC Allen-Bradley - LabVIEW vía puerto Serial: Para establecer este
proceso se requiere tener instalados los programas RSLinx Classic, LabVIEW + Módulo
DSC instalado para habilitar la comunicación de variables mediante OPC, y el RSLogix
para verificar valores actuales del controlador. A continuación se describen los pasos para
generar la comunicación:
Paso 1 Establecer comunicación con el PLC en RSLinx:

• Abrir el Software RSLinx. Ver figura 16.8.
• Click en Communications-Configure drivers.
• En la ventana Available Driver Types, desglosar las opciones y seleccionar el tipo
de conexión (Serial o Ethernet según sea el caso), clic en Add New y presionar ok.
365
Figura 16.8. Ventana de Configure Drivers del RSLinx.
• Seleccionar la opción Auto-Configure y verificar en el cuadro de dialogo que la

conexión ha sido exitosa, allí se visualizan los parámetros de configuración de la
comunicación. Ver figura 16.9.
Figura 16.9. Ventana de los parámetros de configuración de la comunicación en el RSLinx.
Paso 2 Creación de Tópicos (Topic) en RSLinx:

• En RSLinx del menú principal, seleccionar la opción DDE-OPC y luego Topic
configuration, tal como se observa en la figura 16.10.
366
Figura 16.10. Ventana para crear tópicos en el RSLinx.
• Seguidamente hacer clic en NEW, para crear el nombre del tópico, es recomendable
que el nombre del nuevo tópico coincida con el nombre del programa del PLC en
RSLogix. Ver figura 16.11.
• Seleccionar el PLC en la parte derecha de la ventana dar clic en Apply y Done.
Figura 16.11. Configuración del tópico en el RSLinx.
Paso 3 Creación y extracción de variables del PLC en LabVIEW utilizando OPC

server:
• Abrir software LabVIEW.
• Crear un nuevo proyecto haciendo clic en Empty Project.
• Seleccionar dela barra de exploración My computer, New y luego I/O Server. Ver
figura 16.12,
367
Figura 16.12. Configuración del OPC en LabVIEW.
• Definir OPC cliente: Seleccionar OPC Client de la nueva ventana y dar clic en
continuar, como se observa en la figura 16.13.
Figura 16.13. Configuración del OPC Cliente en LabVIEW.
• Definir el OPC Servidor, seleccionar RSLinx OPC Server y dar clic en Ok, se
añadirá una nueva librería al proyecto que incluirá el OPC1 y que será utilizado
para guardar las variables. Ver figura 16.14.
368
Figura 16.14. Configuración del OPC Servidor en LabVIEW.
• Clic derecho sobre la nueva librería y seleccionar Create Bound Variables. Ver
figura 16.15.
Figura 16.15. Configuración para definir las variables del OPC en LabVIEW.
• En la ventana Create Bound Variables, se debe desglosar las siguientes opciones

en el orden que se describe: Project >> My computer >> Untitled Library1 (la
nueva libreria) >> OPC1 y seleccionar el tópico creado anteriormente en RSLinx
en este caso UNTITLED el nombres debe coincidir.
369
• Seleccionar la opción Online para visualizar las variables del PLC y añadirlas al
proyecto haciendo clic en Add, seguidamente selecciona OK para continuar. Ver
figura 16.16.
Figura 16.16. Ventana Crate Bound Variables en LabVIEW.
• Se añadirán las variables a la ventana de explorador de proyectos de LabVIEW.

Ver figura 16.17.
Figura 16.17. Variables del PLC en el Proyecto del LabVIEW.

370
Paso 4 Utilización de variables en el diagrama de bloques del LabVIEW:

• Seleccionar el tipo de dato al que corresponde cada variable haciendo clic derecho
sobre la variable luego propiedades – tipo de dato, como se observa en la figura
16.18.
Figura 16.18. Selección del tipo de dato para las Variables en el Proyecto del LabVIEW.
• Mantener presionado el clic izquierdo sobre la variable creada y arrastrarla al

Diagrama de Bloques para ser utilizada en el programa de desarrollo del HMI.
Ver figura 16.19.
Figura 16.19. Variables del PLC para ser usadas en el Diagrama de Bloques del LabVIEW.
371
Paso 5 Visualizar el estado de las variables en tiempo real:

Una vez ejecutado el proyecto, para poder ver las variables en el Panel Frontal es necesario
tener siempre abierta la ventana Distributed System Manager localizada en la pestaña de
herramientas (Tools), tal como se observa en la figura 16.20.
Figura 16.20. Ventana Dsitributed System Manager del LabVIEW.
Observaciones: El software RSLinx debe tener una licencia de tipo Gateway o profesional
para poder establecer comunicación vía OPC ya sea con LabVIEW u otro software que no
sean de Rockwell.
Actividad Complementaria 17 PLC-LabVIEW
Diseñar una HMI en LabVIEW de una línea de procesamiento de alimentos.
Definir el problema: Desarrollar un sistema de monitoreo remoto vía web, que permite
llevar a cabo la visualización de variables importantes del proceso de empaque de una línea
de alimentos controlado por un PLC.
372
Diseñar soluciones: Para lograr el monitoreo remoto se diseña una interfaz humano-
maquina (HMI) que permite visualizar de forma gráfica los parámetros del proceso de
empaque requeridos por la empresa para su supervisión.
La primera etapa se basa en la adquisición de señales en la máquina de empaque

haciendo uso de un controlador lógico programable PLC marca Allen-Bradley de
Rockwell, la segunda etapa se basa en la manipulación y programación de las variables
adquiridas a ser usadas en el desarrollo del HMI elaborado en el software LabVIEW de
National Instruments, estas variables se envían usando el protocolo OPC. En la tercera
etapa se realiza un diseño de comunicación que en conjunto con la arquitectura de red
actual de la empresa permite su acceso de forma remota utilizando Ethernet como protocolo
de comunicación
Aplicación: El proyecto se va a desarrollar en una serie de pasos a describir:
Paso 1 Selección del hadware y software requerido para la aplicación: Los elementos
requeridos se listan a continuación: Controladores lógicos programables PLC marca Allen-
Bradley, Módulos de expansión de entrada Digital, Switch Stratix 2000 para conexión a
red, Módulos convertidores Serie – Ethernet, Switches de entorno industrial, fuentes de
voltaje DC, Relés Electromagnéticos, Software de programación (LabVIEW, RSLogix,
RSLinx) y Computador para el servidor principal.
Paso 2 Instalación del hardware sobre el proceso: Las señales extraídas del proceso son
Digitales, por lo que se hace uso de un PLC Allen-Bradley modelo MicroLogix 1200 con
dos módulos de expansión de entada Digital Micrologix 1200. Para realizar la
interconexión y poder enviar datos desde el nivel de gestión donde se encuentran las
estaciones de trabajo hasta el nivel de control donde el autómata interactúa directamente
con el proceso, se utiliza un Switch Stratix 2000 conectado a la red de la empresa y de un
módulo convertidor Serie-Ethernet 1761-NET-ENI marca Allen-Bradley para
proporcionar la conexión desde el puerto serie del PLC a uno de los puertos del Switch.
373
En la tabla 16.1, se observan los diferentes dispositivos que conforman el

hardware del proceso.
Tabla 16.1 Hadware seleccionado para la aplicación.

Nombre Imagen
PLC Allen-Bradley Modelo

MicroLogix 1200
Módulos de entrada digital

Allen-Bradley MicroLogix
1200
Switch Allen-Bradley Stratix

2000 más Fuente de
alimentación 24V
Convertidor Serie-Ethernet
marca Allen-Bradley 1761-
NET-ENI
El diagrama de conexión completo de la arquitectura del hardware se puede

observar en la figura 16.21.
374
Figura 16.21. Arquitectura completa del hardware de la Actividad Complementaria 17.
Paso 3 Instalación y desarrollo del Software del proceso: El software RSLogix, se

utiliza para la programación del PLC en escalera Ladder o diagrama de contactos. El
LabVIEW se utiliza para el diseño de la pantalla de supervisión, debido a su facilidad para
compartir paneles frontales vía Web, garantizando así el acceso remoto al sistema.
Primero se realiza la programación del PLC en el RsLogix del autómata

programable tal como se observa en la figura 16.22, haciendo uso de las variables
seleccionadas, para registrar la información requerida por el sistema de forma ordenada, se
estructuro la lógica por etapas, una de estas etapas conforma la lógica contador de unidades
para monitorea en tiempo real la cantidad de unidades empacadas en el proceso. A
continuación se observa la programación de esta etapa lógica.
375
Figura 16.22. Parte del código de programación en escalera del PLC, en el RSLogix de Rockwell.
Una vez finalizada la etapa de programación del autómata, se lleva a cabo el

proceso de comunicación entre el PLC y LabVIEW, haciendo uso del estándar de
comunicación OPC, y el programa RsLinx, siguiendo cada uno de los pasos de
configuración descritos en el punto anterior. Para la lógica de conteo de unidades, se puede
observar en la figura 16.23, su variable transmitida en OPC y recibida en LabVIEW.
Figura 16.23. Variable OPC para el conteo de productos, en código de programación LabVIEW.
Luego de establecer la comunicación del PLC de forma exitosa con LabVIEW,

se elaborar la interfaz gráfica, que al igual que la programación del autómata, se establece
por etapas, integrando cada una de las variables obtenidas a los indicadores y gráficos
desarrollados y dispuestos para su visualización. En las figuras 16.24 y 16.25, se observan
el código de programación y el Panel Frontal del programa HMI en LabVIEW.
376
Figura 16.24. Código de programación de la aplicación en LabVIEW para la HMI.
Figura 16.25. Interfaz HMI de la aplicación en LabVIEW.
Finalmente se aplica el procedimiento visto en el capítulo anterior, para crear la

publicación remota del Panel Frontal.
377
Prueba y Verificación: Después de finalizada la HMI, se desarrollan una serie de pruebas

con el proceso para verificar la correcta adquisición de datos y que el sistema de
comunicación por medio del protocolo OPC se efectivo para llevar los datos al LabVIEW.
Los resultados muestran eficiencia en ambas etapas del proceso, considerando que es
monitoreo y el sistema solo recibe datos del PLC hacia la interfaz del LabVIEW.
Una vez finalizada la etapa de pruebas de monitoreo, se realiza la interconexión,

haciendo uso del Switch asignado y un punto de red, para habilitar el acceso de la
computadora encargada de procesar la información a la red local de la empresa, luego
haciendo uso de la herramienta Web publishing tool de LabVIEW, se activa el acceso vía
Web a el Panel Frontal del sistema de monitoreo. La ventana del navegador con el proceso
se observa con la figura 16.26.
Figura 16.26. Acceso a la Interfaz HMI de la aplicación vía Web.

378
Referencias Bibliográficas
Advanced Signal Processing Toolkit. NI Tutorial. Recuperado 09 de Noviembre de

2016, de http://zone.ni.com/reference/en-XX/help/372656C-01/.
Aracil, R. (2002) Teleoperación. III Jornadas de Trabajo Enseñanza vía Internet/Web de

la Ingeniería de Sistemas y Automática, Alicante, España.
Arduino C.A. Software IDE. Recuperado 10 de Octubre de 2016, de

https://www.arduino.cc /en/Guide/Environment.
Bao, Y. (2009) Application of LabVIEW in the Electronic Measurement Techniques

Course, JOURNAL OF CHANGZHOU INSTITUTE OF TECHNOLOGY, 22(6).
Bao, Y. & Jiang, X. (2011). Application of Virtual Instrumentation which Based on Lab
VIEW in Electronic Measurement Technology Course. International Conference on
Electronics and Optoelectronics (ICEOE). 978--61284-276-9 ©2011IEEE.
Bentley, J. (1993). Sistemas de medición principios y aplicaciones. Editorial Continental.
Bolton, W. (2010). Mecatrónica: Sistemas de control electrónico en la ingeniería

mecánica y eléctrica. Alfaomega Grupo Editor.
Boylestad, R., & Nasheslky, L. (2009). Electónica: Teoría de Circuitos y Dispositivos

Electrónicos. Prentice Hall.
Building a LabVIEW User Interface for a Simulink® Model with LabVIEW Simulation
Interface Toolkit. NI Tutorial. Recuperado 10 de Septiembre de 2016, de
http://www.ni.com/white-paper/3057/en/.
Calibration Quick Start Guide for FlexiForrce Sensors. Recuperado 10 de Agosto de

2016, de https://www.tekscan.com/support/faqs/how-do-i-calibrate-my-flexiforce-
sensor.
Chopra, N., Spong, M. & Lozano, R. (2004). Adaptive coordination control of bilateral
teleoperators with time delays. Proc. 43rd IEEE Conf. Decision Contr., 2004, pp.
4540-4547.
Creating an OPC UA Server Application and an OPC UA Client Application.

Recuperado 16 de Enero de 2017, de http://zone.ni.com/reference/en-
XX/help/371361N-01/lvdialog/web_publishing_tool_db/.
379
Datasheet L298. Recuperado 10 de Agosto de 2016, de

http://www.alldatasheet.com/view.jsp?Searchword=L298&gclid=CNHcqu-
GvtMCFQJAhgodH-EKOg.
Distance Measuring Sensors. Sharp. Recuperado 10 de Agosto de 2016, de

http://www.sharp-
world.com/products/device/lineup/selection/opto/haca/diagram.html?_ga=1.18019
5748.1094312978.1493069888.
Doering, E. (2015). Guía de Elementos Básicos para Iniciar Proyectos con NI myRIO.
National Instruments.
Domingo, A., Jordi, J. & Sánchez, F. (2001). Instrumentación Virtual. Adquisición,

procesado y análisis de señales. Edicions UPC.
Duan, X. & Changyun, M. (2008). Aplication of LabVIEW on teaching of electron

circuit[J]. FOREIGN ELECTRONIC MEASUREMENT TECHNOLOGY, 2008,
27(8).
Elegir un Dispositivo de Medidas de Termopares. NI Tutorial. Recuperado 2 de

Septiembre de 2016, de https://www.arduino.cc/en/Guide/Environment.
Elhajj, I., Xi, N. & Fung, W. (2000). Real-time control of internet based teleoperation
with force reflection. Intelligent Control and Automation. Proceedings of the 3rd
World Congress Publication: Page(s): 3761 - 3766 vol.5.
Evans B. (2007). Arduino Notebook. The Creative Commons.
FlexiForce force sensors. Teskan. Recuperado 10 de Agosto de 2016, de

https://www.tekscan.com/product-group/embedded-sensing/force-sensors.
Floyd, T. (2006). Dispositivos electrónicos. Limusa Editores.
Getting Started with Arduino and Genuino products. Recuperado 10 de Octubre de 2016,
de https://www.arduino.cc/en/Guide/HomePage.
Gillet, D., Salzmann, C. & Huguenin, P. (1999). Introduction to Real-time Control using
LabVIEW with an Application to Distance Learning. In: Swiss Federal Institute
of Technology Lausanne, Switzerland.
Gómez de Gabriel, J., Ollero, A. & García C. (2006). Teleoperación y Telerrobótica.

Pearson Educación S.A.
380
Guía para Medidas Más Comunes. NI Tutorial. Recuperado 1 de Septiembre de 2016, de

http://www.ni.com/white-paper/7136/es/.
Hambley, A. (2001). Electrónica. Pearson Educación S.A.
Haugen, F. (2007). Introduction to LabVIEW Simulation Module. TechTeach.
Hobaica, J. Señales y Sistemas en MATLAB y LabVIEW. Recuperado 8 de Septiembre

de 2016, de http://cnx.org/content/col11361/1.4/.
Introducción a la Co-Simulación Digital y Analógica entre NI LabVIEW y NI Multisim.

NI Tutorial. Recuperado 12 de Septiembre de 2016, de http://www.ni.com/white-
paper/13663/es/.
Isolation Technologies for Reliable Industrial Measurements. NI Tutorial. Recuperado 5

de Septiembre de 2016, de http://www.ni.com/white-paper/3546/en/.
Kamrani, E., Momeni H. & Sharafat, A. (2005). Modeling Internet Delay Dynamics for
Teleoperation. IEEE Conference on Control Applications Toronto, Canada.
Kitamura, K., Yashiro, D., & Ohnishi K. (2009). Bilateral Control using Estimated
Environmental Stiffness as the Master Position Gain University. Yokohama Japan
IEEE.
MakerHub For LabVIEW. Recuperado 15 de Octubre de 2016, de

https://www.labviewmakerhub.com/doku.php?id=libraries:linx:start.
Making a Thermocouple Measurement With NI LabVIEW. NI Tutorial. Recuperado 1 de

Septiembre de 2016, de http://www.ni.com/tutorial/14338/en/.
Measuring Strain with Strain Gages. NI Tutorial. Recuperado 1 de Septiembre de 2016,

de http://www.ni.com/white-paper/3642/en/.
MathScript RT Module. NI Tutorial. Recuperado 12 de Diciembre de 2016, de

http://zone.ni.com/reference/en-XX/help/373123C-01/.
National Instruments Corporation (2005). LabVIEW Fundamentals. NI Manual.
National Instruments Corporation (2010). Introducción al NI Multisim. NI Manual.
National Instruments Corporation (2007). LabVIEW Basics 1 Introduction course

Manual. NI Manual.
381
National Instruments Corporation (2007). LabVIEW Basics 2 Introduction course

Manual. NI Manual.
National Instruments Corporation (2008). LabVIEW PID Contol Toolkit User Manual.
NI Manual.
Niemeyer G. & Slotine, J. (2004). Telemanipulation with time delays. Int. J. Robot. Res.,
vol. 23, no. 9, pp. 873-890, September 2004.
NI-DAQmx C Reference Help. NI Tutorial. Recuperado 10 de Enero de 2017, de

http://zone.ni.com/reference/en-XX/help/370471AG-01/.
NI-DAQmx Simulated Devices. NI Tutorial. Recuperado 8 de Enero de 2017, de

http://zone.ni.com/reference/en-XX/help/370466AD-01/mxcncpts/simdev/.
Ogata, K. (2010). Ingeniería de control moderna. Prentice Hall.
Peidró, A., Rodríguez J., Azorín, J. y Reinos O. (2014). Implementación de una maqueta
de Control Bilateral 1 GDL con Arduino para Telerrobotica. XXXV Jornadas de
Automática ISBN-13: 978-84-697-0589-6, Valencia España.
Pulse Width Modulation (PWM) Using NI-DAQmx and LabVIEW. NI Tutorial.

Recuperado 10 de Septiembre de 2016, de http://www.ni.com/tutorial/2991/en/.
Qiyuan, S. & Xuan. (2008). Web-based Control System of a Mobile Manipulator over
Internet. First International Conference on Intelligent Networks and Intelligent
Systems.
Remote Panels in LabVIEW. Distributed Application Development. Recuperado 1 de

Febrero de 2017, de http://www.ni.com/tutorial/4791/en/.
Robotis Dynamixel Actuators in LabVIEW. NI Tutorial. Recuperado 10 de Septiembre

de 2016, de http://www.ni.com/white-paper/12557/en/.
Rockwell Automation (1996). Como obtener resultados con RSLINX CLASSIC.

Recuperado el 15 de Agosto de 2016, de
http://literature.rockwellautomation.com/idc/groups/literature/documents/gr/lnx-
gr001_-es-e.pdf.
Rockwell Automation (2008). Datos de tags y E/S en los controladores Logix5000. Allen
Bradley Manual de Programación.
Rockwell Automation (2008). Juego de instrucciones de SLC 500 y MicroLogix 1000.

Recuperado el 15 de Agosto de 2016, de
382
http://www.infoplc.net/files/descargas/rockwell/infoPLC_net_SLC500_MicroLog
ix_1000.pdf.
Roldán, J. y Gámiz, J. (2002).Dispositivos Electrónicos. RA-MA Editorial.
Ruiz, J.M. (2007). Manual de Programación Arduino. The Creative Commons.
Selecting an OPC Server. Recuperado 15 de Enero de 2017, de

http://zone.ni.com/reference/en-XX/help/370858M-
01/gfsopc/opc/hid_opcserverselectx/.
Tocci, R., Wildmer N. y Moss G (2007). Sistemas Digitales, Principios y Aplicaciones.

Prentice Hall.
VI Package Manager. Recuperado 30 de Septiembre de 2016, de https://vipm.jki.net/.
Web Publishing Tool Dialog Box. Recuperado 8 de Febrero de 2017, de

http://zone.ni.com/reference/en-XX/help/371361N-
01/lvdialog/web_publishing_tool_db/.

0 Labview Como Herramienta

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

0 Labview Como Herramienta

Uploaded by

Copyright:

Available Formats

LabVIEW como herramienta de programación de sistemas de

desarrollo de Instrumentos Virtuales para Ingeniería Electrónica

Edwin Gregory Hernández Díaz.

Universidad Nacional Experimental del Táchira.

República Bolivariana de Venezuela

LabVIEW COMO HERRAMIENTA DE PROGRAMACIÓN DE SISTEMAS

Autor: Edwin Gregory Hernández Díaz

Palabras clave: Programación, LabVIEW, Adquisición de Datos, Instrumentos Virtuales,

Estructura de tiempo TIMED.................................................................................................. 160

Generación de páginas Web desde el LabVIEW .................................................................... 346

La información que se describe en este material tiene como objetivo principal,

El contenido desarrollado se divide en dieciséis capítulos, estructurados en

El Programa LabVIEW y sus elementos de simulación pertenecen a la compañía

Un computador con un sistema operativo bajo Windows 8 o posterior.

El material facilita al lector aprender el lenguaje gráfico LabVIEW partiendo de un

A Continuación se describe brevemente el contenido plasmado en los dieciséis

En el nivel intermedio se desarrollan: Capítulo V, presenta todos los elementos de

En el nivel avanzado se desarrollan: Capítulo XI, definir y programar los módulos

Los lenguajes de programación se pueden utilizar para resolver problemas en

El capítulo uno, define los conceptos para aplicar el Método de Desarrollo de

Método de Desarrollo de Software

Este tema describe un conjunto de pasos específicos, llamados Método de

Elementos del Método de Desarrollo de Software

Diseñar soluciones: Después de definir el problema se diseña una solución, basada en el

Para explicar la fase del diseño de soluciones, se expone el ejemplo de un algoritmo

Diseño de un diagrama de transición de estados: Los diagramas de transición de estados

horno en un proceso de medición de temperatura.

Aplicación: Es la fase de ejecución, se crea el código para el algoritmo, diagrama de flujo

Mantener y actualizar los programas: Es importante revisar la dinámica del sistema

Resuelve el siguiente problema por el Método de Desarrollo de Software sin utilizar

Definir el problema: Un sistema de monitoreo y detección de fallas de una variable de un

El diagrama de transición de estado, se muestra en la figura 1.3, se elige de modo

Aplicación: Se recomienda el lenguaje de programación gráfico LabVIEW, para codificar

El lenguaje de programación gráfica desarrollado en este material, se basa en el

Instrumentos Virtuales (VI)

Los programas de LabVIEW son llamados Instrumentos Virtuales, o VIs, su

Figura 2.1. Ventana de presentación LabVIEW 2016.

Al iniciar cualquier versión del LabVIEW, aparece una ventana de introducción,

Figura 2.2. Ventana de introducción LabVIEW 2016.

Creación y apertura de un VI: Se puede comenzar un programa en LabVIEW partiendo

Figura 2.3. Paneles de programación del LabVIEW.

La creación de un VI a partir de una plantilla (figura 2.4) se puede realizar,

Figura 2.4. Selección de plantillas del LabVIEW.

Figura 2.5. Guardar VI del LabVIEW.

Cuándo se guarda un proyecto en LabVIEW se crea un archivo de proyecto

Para abrir un nuevo proyecto desde la ventana de introducción, seleccione Create

Figura 2.6. Ventana de crear proyecto en LabVIEW 2016.

Al crear un nuevo proyecto aparece la ventana explorador de proyectos como se

Figura 2.7. Ventana del explorador de proyecto en LabVIEW.

Cuando se agrega elementos al proyecto, LabVIEW crea un elemento adicional en

Barras de herramientas del explorador de proyectos: Están conformadas por cuatro

elementos tradicionales de cualquier menú de herramientas, usadas para incluir elementos

Figura 2.8. Menú de herramientas de la ventana del explorador de proyectos en LabVIEW.

Adición de elementos a un proyecto: Puede agregar diferentes elementos, aplicaciones,

Figura 2.9. Selección de aplicaciones del explorador de proyectos en LabVIEW.

Eliminar elementos de un proyecto: Se puede eliminar elementos de la ventana

Guardar un proyecto: Puede guardar un proyecto de LabVIEW de las siguientes maneras:

Los VIs de LabVIEW, representan funciones de programación y visualización de

Ventana del Panel Frontal

entrada y salida del programa, conocidas como controladores e indicadores y se pueden

Figura 2.10. Panel Frontal del VI de LabVIEW.

Figura 2.11. Barra de herramientas del Panel Frontal del VI de LabVIEW.

Tabla 2.1. Botón de ejecución Run.

Tabla 2.2. Botón de pausa y detener Pause y Stop.