Implementación de

Proyectos con myRIO

Worldwide Technical Support and Product Information
ni.com
National Instruments Corporate Headquarters
11500 N Mopac Expwy Austin, Texas 78759-3504 USA Tel: 512 683 0100
Worldwide Offices
Andean and Caribbean +58 212 503-5310, Argentina 0800 666 0037, Australia 1800 300 800, Austria 43 662 45 79 90 0, Belgium 32
0 2 757 00 20, Brazil 55 11 3262 3599, Canada 800 433 3488, Chile 800 532 951, China 86 21 5050 9800, Czech Republic/Slovakia
420 224 235 774, Denmark 45 45 76 26 00, Finland 358 0 9 725 725 11, France 33 0 1 48 14 24 24, Germany 49 89 741 31 30,
Hungary 36 23 501 580, India 1 800 425 7070, Ireland 353 0 1867 4374, Israel 972 3 6393737, Italy 39 02 413091, Japan 81 3 5472
2970, Korea 82 02 3451 3400, Lebanon 961 0 1 33 28 28, Malaysia 1800 887710, Mexico 01 800 010 0793, Netherlands 31 0 348
433 466, New Zealand 0800 553 322, Norway 47 0 66 90 76 60, Poland 48 22 3390150, Portugal 351 210 311 210, Russia 7 495 783
68 51, Singapore 1800 226 5886, Slovenia/Croatia, Bosnia/Herzegovina, Serbia/Montenegro, Macedonia 386 3 425 42 00, South Africa
27 0 11 805 8197, Spain 34 91 640 0085, Sweden 46 0 8 587 895 00, Switzerland 41 56 200 51 51, Taiwan 886 2 2377 2222, Thailand
662 278 6777, Turkey 90 212 279 3031, U.K. 44 0 1635 523545, Uruguay 0004 055 114
To comment on National Instruments documentation, refer to the National Instruments Web site at ni.com/info and enter the
info code feedback.
© 2013 National Instruments Corporation. All rights reserved.
Important Information
Warranty
The media on which you receive National Instruments software are warranted not to fail to execute programming instructions, due to defects in materials and
workmanship, for a period of 90 days from date of shipment, as evidenced by receipts or other documentation. National Instruments will, at its option, repair or
replace software media that do not execute programming instructions if National Instruments receives notice of such defects during the warranty period. National
Instruments does not warrant that the operation of the software shall be uninterrupted or error free. A Return Material Authorization (RMA) number must be obtained
from the factory and clearly marked on the outside of the package before any equipment will be accepted for warranty work. National Instruments will pay the
shipping costs of returning to the owner parts which are covered by warranty. National Instruments believes that the information in this document is accurate. The
document has been carefully reviewed for technical accuracy. In the event that technical or typographical errors exist, National Instruments reserves the right to
make changes to subsequent editions of this document without prior notice to holders of this edition. The reader should consult National Instruments if errors are
suspected. In no event shall National Instruments be liable for any damages arising out of or related to this document or the information contained in it. EXCEPT AS
SPECIFIED HEREIN, NATIONAL INSTRUMENTS MAKES NO WARRANTIES, EXPRESS OR IMPLIED, AND SPECIFICALLY DISCLAIMS ANY WARRANTY OF
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. CUSTOMER’S RIGHT TO RECOVER DAMAGES CAUSED
BY FAULT OR NEGLIGENCE ON THE PART OF NATIONAL INSTRUMENTS SHALL BE LIMITED TO THE AMOUNT THERETOFORE PAID BY THE
CUSTOMER. NATIONAL INSTRUMENTS WILL NOT BE LIABLE FOR DAMAGES RESULTING FROM LOSS OF DATA, PROFITS, USE OF PRODUCTS,
OR INCIDENTAL OR CONSEQUENTIAL DAMAGES, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. This limitation of the liability of National
Instruments will apply regardless of the form of action, whether in contract or tort, including negligence. Any action against National Instruments must be brought
within one year after the cause of action accrues. National Instruments shall not be liable for any delay in performance due to causes beyond its reasonable control.
The warranty provided herein does not cover damages, defects, malfunctions, or service failures caused by owner’s failure to follow the National Instruments
installation, operation, or maintenance instructions; owner’s modification of the product; owner’s abuse, misuse, or negligent acts; and power failure or surges, fire,
flood, accident, actions of third parties, or other events outside reasonable control.
Copyright
Under the copyright laws, this publication may not be reproduced or transmitted in any form, electronic or mechanical, including photocopying, recording, storing in
an information retrieval system, or translating, in whole or in part, without the prior written consent of National Instruments Corporation. National Instruments
respects the intellectual property of others, and we ask our users to do the same. NI software is protected by copyright and other intellectual property laws. Where
NI software may be used to reproduce software or other materials belonging to others, you may use NI software only to reproduce materials that you may reproduce
in accordance with the terms of any applicable license or other legal restriction. BSIM3 and BSIM4 are developed by the Device Research Group of the Department
of Electrical Engineering and Computer Science, University of California, Berkeley, and copyrighted by the University of California.
Trademarks
CompactDAQ, CompactRIO, LabVIEW, National Instruments, and NI, ni.com are trademarks of National Instruments Corporation. Refer to the Terms of Use section
on ni.com/legal for more information about National Instruments trademarks. Other product and company names mentioned herein are trademarks or trade names
of their respective companies.
Patents
For patents covering National Instruments products, refer to ni.com/patents.
Some portions of this product are protected under United States Patent No. 6,560,572.
WARNING REGARDING USE OF NATIONAL INSTRUMENTS PRODUCTS
(1) NATIONAL INSTRUMENTS PRODUCTS ARE NOT DESIGNED WITH COMPONENTS AND TESTING FOR A LEVEL OF RELIABILITY SUITABLE
FOR USE IN OR IN CONNECTION WITH SURGICAL IMPLANTS OR AS CRITICAL COMPONENTS IN ANY LIFE SUPPORT SYSTEMS WHOSE
FAILURE TO PERFORM CAN REASONABLY BE EXPECTED TO CAUSE SIGNIFICANT INJURY TO A HUMAN.
(2) IN ANY APPLICATION, INCLUDING THE ABOVE, RELIABILITY OF OPERATION OF THE SOFTWARE PRODUCTS CAN BE IMPAIRED BY
ADVERSE FACTORS, INCLUDING BUT NOT LIMITED TO FLUCTUATIONS IN ELECTRICAL POWER SUPPLY, COMPUTER HARDWARE
MALFUNCTIONS, COMPUTER OPERATING SYSTEM SOFTWARE FITNESS, FITNESS OF COMPILERS AND DEVELOPMENT SOFTWARE USED TO
DEVELOP AN APPLICATION, INSTALLATION ERRORS, SOFTWARE AND HARDWARE COMPATIBILITY PROBLEMS, MALFUNCTIONS OR
FAILURES OF ELECTRONIC MONITORING OR CONTROL DEVICES, TRANSIENT FAILURES OF ELECTRONIC SYSTEMS (HARDWARE AND/OR
SOFTWARE), UNANTICIPATED USES OR MISUSES, OR ERRORS ON THE PART OF THE USER OR APPLICATIONS DESIGNER (ADVERSE FACTORS
SUCH AS THESE ARE HEREAFTER COLLECTIVELY TERMED “SYSTEM FAILURES”). ANY APPLICATION WHERE A SYSTEM FAILURE WOULD
CREATE A RISK OF HARM TO PROPERTY OR PERSONS (INCLUDING THE RISK OF BODILY INJURY AND DEATH) SHOULD NOT BE RELIANT
SOLELY UPON ONE FORM OF ELECTRONIC SYSTEM DUE TO THE RISK OF SYSTEM FAILURE. TO AVOID DAMAGE, INJURY, OR DEATH, THE
USER OR APPLICATION DESIGNER MUST TAKE REASONABLY PRUDENT STEPS TO PROTECT AGAINST SYSTEM FAILURES, INCLUDING BUT
NOT LIMITED TO BACK-UP OR SHUT DOWN MECHANISMS. BECAUSE EACH END-USER SYSTEM IS CUSTOMIZED AND DIFFERS FROM
NATIONAL INSTRUMENTS' TESTING PLATFORMS AND BECAUSE A USER OR APPLICATION DESIGNER MAY USE NATIONAL INSTRUMENTS
PRODUCTS IN COMBINATION WITH OTHER PRODUCTS IN A MANNER NOT EVALUATED OR CONTEMPLATED BY NATIONAL INSTRUMENTS,
THE USER OR APPLICATION DESIGNER IS ULTIMATELY RESPONSIBLE FOR VERIFYING AND VALIDATING THE SUITABILITY OF NATIONAL
INSTRUMENTS PRODUCTS WHENEVER NATIONAL INSTRUMENTS PRODUCTS ARE INCORPORATED IN A SYSTEM OR APPLICATION,
INCLUDING, WITHOUT LIMITATION, THE APPROPRIATE DESIGN, PROCESS AND SAFETY LEVEL OF SUCH SYSTEM OR APPLICATION.

ni.com/myRIO | 2
Índice
Índice ............................................................................................................................................................................. 3
Software requerido ....................................................................................................................................................... 4
Hardware requerido ...................................................................................................................................................... 4
Introducción a National Instruments LabVIEW ............................................................................................................. 5
La ventana de inicio en LabVIEW .............................................................................................................................. 5
¿Qué es NI myRIO? ................................................................................................................................................... 7
Ejercicio 0: Introducción ............................................................................................................................................... 8
Parte A: Conectando el NI myRIO ............................................................................................................................. 8
Parte B: Creando un proyecto de LabVIEW ............................................................................................................ 10
Parte C: Creando un proyecto de LabVIEW ............................................................................................................ 12
Ejercicio 1. Cree su primer proyecto con NI myRIO .................................................................................................... 20
Introducción: Ejecutando código en tiempo real en el dispositivo NI myRIO ........................................................ 20
Desarrollo ............................................................................................................................................................... 20
Ejercicio 2a: Crear un código de tiempo real para correrlo en un dispositivo NI myRIO ............................................ 24
Ejercicio 2b: Crear un código de tiempo real para correrlo en un dispositivo NI myRIO ............................................ 30
Ejercicio 2c: Desafíos opcionales................................................................................................................................. 33
Desafío 1 ................................................................................................................................................................. 33
Desafío 2 ................................................................................................................................................................. 33
Desafío 3 ................................................................................................................................................................. 33
Diseño de Control y Simulación en LabVIEW .............................................................................................................. 34
Ejercicio 3a: Diseñar un sistema de control simulado que se ejecute en la máquina de desarrollo. ......................... 34
Ejercicio 3b: Diseñar un sistema de control simulado que pueda correrse en el procesador de NI myRIO ............... 39
Ejercicio 3c: Trasladarse de una simulación al mundo real......................................................................................... 40
Ejercicio 3d: Ejercicio opcional .................................................................................................................................... 44
Field-Programmable Gate Arrays (FPGAs) .................................................................................................................. 45
Ejercicio 4: Explore la personalidad por defecto del NI myRIO FPGA ......................................................................... 46
Recursos y pasos a seguir ............................................................................................................................................ 48
Kits de accesorios ................................................................................................................................................... 48
Guía NI myRIO Project Essentials............................................................................................................................ 48
Soporte de C para NI myRIO ................................................................................................................................... 48
Comunidad NI myRIO ............................................................................................................................................. 48
Hardware personalizado para NI myRIO ................................................................................................................ 48
Pasos siguientes ...................................................................................................................................................... 49

ni.com/myRIO | 3
Software requerido
• LabVIEW for myRIO 17
• Controlador NI myRIO
• Xilinx Tools 14.4

Hardware requerido
• NI myRIO
• Kit de Inicio de NI myRIO o tablilla proporcionada por el instructor

ni.com/myRIO | 4
Introducción a National Instruments LabVIEW
Los estudiantes y educadores necesitan tener cierta comprensión de
LabVIEW antes de intentar tareas como la construcción de una aplicación
en tiempo real o la personalización de una FPGA. Para ayudar a desarrollar
este conocimiento, NI diseñó este taller práctico para aquellos que no
tienen experiencia en LabVIEW. Sin embargo, no es un sustituto de la
capacitación formal y no cubre todos los menús, botones o funciones en
LabVIEW
Las aplicaciones en LabVIEW imitan la apariencia de instrumentos reales
(como multímetros, generadores de señal, osciloscopios), por lo que son
llamados instrumentos virtuales o VIs. Todas las aplicaciones de LabVIEW
tienen un panel frontal, un panel de ícono / conector y un diagrama de
bloques. El panel frontal sirve como la imitación de la interfaz de usuario
en el mundo real del dispositivo que el VI está definiendo. Los
programadores pueden representar los datos que el instrumento está
analizando en múltiples formas.
El panel de ícono / conector es análogo a los terminales o conectores en un instrumento en el mundo real
que se conectan a otros dispositivos. Los VIs pueden llamar a otros VIs (conocidos como subVIs) que están
todos conectados, y, a su vez, cada uno de esos subVIs puede contener más VIs similar a llamar a las
funciones en un lenguaje de programación basado en texto. Por último, el diagrama de bloques es donde
el programador crea realmente el código. A diferencia de los lenguajes de programación basados en texto
tales como C, Java, C ++ y Visual Basic, LabVIEW utiliza íconos en lugar de líneas de texto para crear
aplicaciones. Debido a esta diferencia clave, el control de ejecución está a cargo de un conjunto de reglas
para el flujo de datos en lugar de secuencial. Los cables que conectan los nodos (elementos de codificación)
y VIs en el diagrama de bloque determinan el orden de ejecución de código.
En resumen, los VIs de LabVIEW son gráficos, impulsados por el flujo de datos y la programación basada
en eventos, y son multiobjetivos y multiplataforma. También tienen la flexibilidad orientada a objetos y
características multithreading y de paralelismo. Los VIs se pueden implementar en tiempo real y en FPGA.

La ventana de inicio en LabVIEW

Utilizando el DVD de LabVIEW que viene con el dispositivo NI myRIO, siga las instrucciones para instalar
LabVIEW y cualquier complemento que haya adquirido. Active los productos utilizando el Asistente para la
activación del producto. El software debe estar listo para su uso.
En Windows, Ud. puede abrir LabVIEW desde el menú de inicio, ya sea desde el atajo de LabVIEW o
buscando “LabVIEW” en el cuadro de búsqueda.
Cuando el ejecutable de LabVIEW inicia y todos los complementos se hayan cargado, aparecerá la ventana
de inicio de LabVIEW myRIO.
Desde la ventana de inicio, Ud. puede crear proyectos y VIs nuevos, abrir un trabajo existente o acceder a
algún ejemplo que se encuentre dentro del NI Example Finder.
Para acceder a esta ventana seleccione VIEW»Getting Started Window desde cualquier VI. Otras opciones
adicionales se encuentran disponibles en la parte inferior de la ventana. Cada opción lo vinculará a
información útil, tutoriales, ejercicios y soporte para usar dispositivo NI myRIO. Aproveche estos enlaces
mientras aprende a navegar por el entorno de LabVIEW.

ni.com/myRIO | 5
 Ventana de inicio de LabVIEW

Parte de la filosofía NI myRIO es cerrar la brecha entre el verdadero problema y su solución al reducir el
número de problemas intermedios tanto como sea posible. Evite las confusiones como "El síndrome del VI
blanco" (ser abrumado por el diagrama de bloques en blanco) mediante el uso de la ventana de introducción,
al encontrar ejemplos, crear proyectos a partir de plantillas y tomar ventaja de los foros en línea y soporte.
Cuando se trata de sistemas y problemas sencillos, muchos usuarios e ingenieros de NI ya han creado
material que hace exactamente lo que el sistema en cuestión requiere o algo muy similar. Reinventar la
rueda puede ser doloroso, pero con el poder de LabVIEW y la red de ingenieros y científicos que crean
código para soportar la plataforma, se puede evitar eso.

ni.com/myRIO | 6
¿Qué es NI myRIO?
El diseño embebido del dispositivo NI myRIO fue creado
para que los estudiantes realicen “ingeniería del mundo
real” en un semestre. Contiene un procesador
programable dual-core ARM Cortex-A9 de 667 MHz y un
FPGA que permite desarrollar sistemas y resolver
problemas de diseño complicado de manera más rápida,
todo en una forma compacta. El dispositivo NI myRIO
está basado en el SoC Zynq-7010, un sistema
programable para liberar todo el poder de un sistema de
LabVIEW, ya sea en una aplicación de tiempo real o al
nivel de un FPGA. En lugar de usar grandes cantidades
de sintaxis, depuración de código de tiempo o el
desarrollo de interfaces de usuario, los estudiantes
pueden utilizar el paradigma de la programación gráfica
de LabVIEW para centrarse en la construcción de sus
sistemas y la solución de sus problemas de diseño y sin
la presión añadida de una herramienta pesada.
NI myRIO es una herramienta de enseñanza
reconfigurable y reutilizable que ayuda a los estudiantes
a aprender una gran variedad de conceptos de ingeniería,
así como proyectos de diseño completos.
Utilizando herramientas de tiempo real, FPGA y
capacidades integradas de comunicación inalámbrica,
junto con la memoria integrada, los estudiantes pueden
desplegar aplicaciones de forma remota y ejecutarlos "headlessly" (sin conexión a un ordenador remoto).
Tres conectores (dos NI myRIO Expansion Port [MXP] y un NI Mini System Port [MSP]) envían y reciben
señales desde los sensores y circuitos que los estudiantes necesitan en sus sistemas. Cuarenta líneas de
E/S digitales, con el apoyo de SPI, PWM, entrada de codificador de cuadratura, UART e I2C; ocho entradas
analógicas de una sola terminal; dos entradas analógicas diferenciales; cuatro salidas analógicas unipolares;
y dos salidas analógicas con referencia a tierra permiten la conectividad a un sinnúmero de sensores y
dispositivos y control de programación de sistemas. Toda esta funcionalidad está construida y
preconfigurada en la FPGA por defecto. En última instancia, estas características ayudan a los estudiantes
hacer la ingeniería del mundo real en este momento, desde los vehículos de radiocontrol hasta la creación
de dispositivos médicos independientes.
Amigable con estudiantes y completamente funcional desde el primer uso, el dispositivo NI myRIO es fácil
de configurar, y los estudiantes pueden determinar fácilmente su estado de funcionamiento.
Una configuración para el FPGA se implementa en el dispositivo desde la fábrica, así que los principiantes
pueden comenzar con una base funcional sin tener que programarla para lograr el funcionamiento de sus
sistemas . Sin embargo, el poder de las E/S reconfigurable (RIO) se hace evidente cuando los estudiantes
comienzan a personalizar el FPGA y moldear el comportamiento del dispositivo a la aplicación. Gracias a la
escalabilidad del dispositivo los estudiantes pueden usarlo desde cursos introductorios de sistemas
embebidos hasta clases diseño de sistemas de control de último año.

ni.com/myRIO | 7
Ejercicio 0: Introducción
Parte A: Conectando el NI myRIO
Asegúrese de encender el dispositivo NI myRIO utilizando el adaptador de corriente que viene con él.
Conecte el extremo USB tipo B del cable USB en el dispositivo NI myRIO. Y el otro extremo del cable al
puerto USB de su ordenador.
Sin iniciar LabVIEW o NI MAX, si el dispositivo está encendido, el sistema operativo debe reconocer el
dispositivo NI myRIO e instalar y configurar los controladores correspondientes. Una vez completado esto,
en el sistema operativo Windows, debería iniciar automáticamente el monitor USB NI myRIO como se
muestra a continuación.

NI myRIO USB Monitor

En la ventana del NI myRIO USB Monitor aparece el número de serie del dispositivo, la dirección IP y varias
opciones a elegir.
1. Abrir el asistente de inicialización (Launch the Getting Started Wizard)
Con el asistente se puede observar el estado de funcionamiento del dispositivo. Al iniciar el asistente
se muestran todos los dispositivos myRIO conectados y al seleccionar uno se establece la conexión,
se verifica que el firmware esté actualizado y en caso de ser necesario realizará la actualización.
Posteriormente, se ofrece la opción de renombrar el dispositivo y se muestra una ventana similar a un
panel frontal que se puede utilizar para observar la funcionalidad del acelerómetro, para apagar y
prender los LEDs que trae integrados el dispositivo y para hacer pruebas con el botón personalizable
por el usuario.

ni.com/myRIO | 8
Como se muestra en la siguiente imagen, la pantalla final del asistente presenta dos opciones:
• Start your first project now: se abre un tutorial similar al proyecto del ejercicio 2 de este seminario.
• Go straight to LabVIEW: seleccionando esta opción, se abre la ventana de inicio de LabVIEW.

Pantalla final del asistente “Getting Started with NI myRIO”

2. Ir a LabVIEW (Go to LabVIEW)

Seleccionando esta opción, se abre la ventana de inicio de LabVIEW.
3. Abrir el Monitor de E/S (Launch the I/O Monitor)
Al abrir el I/O Monitor, se accede a una interfaz donde se puede monitorear y realizar pruebas en cada uno de
los canales de entrada y salida del NI myRIO de forma amigable.

Panel frontal del monitor de E/S (I/O Monitor)

ni.com/myRIO | 9
4. Configurar el NI myRIO (Configure NI myRIO)
Seleccionando esta opción se abre el navegador de configuración de myRIO.
5. Do Nothing
Si LabVIEW ya se encuentra abierto y un proyecto es configurado para myRIO, Ud. puede utilizar esta
opción para cerrar el Monitor USB cuando una unidad es reconectada a la computadora de desarrollo.

Abriendo el asistente “Getting Started with NI myRIO”

Desde el Monitor USB, seleccione Launch the Getting Started Wizard y posteriormente Next. El asistente
se conectará a la unidad myRIO seleccionada y nos dará la opción de renombrar el dispositivo. Si la unidad
myRIO no tiene software instalado o este se encuentra desactualizado, la aplicación se encargará de instalar
el software más actualizado para su correcto funcionamiento. Después de esto se abrirá una ventana de
diagnóstico donde se podrán observar los valores que nos devuelve el acelerómetro en 3 ejes. Pruebe la
funcionalidad de los botones y encienda o apague los cuatro LEDs integrados.

Ventana del asistente “Getting Started del NI myRIO”

Ahora que ya se ha instalado y configurado el dispositivo myRIO, Ud. puede crear VIs de tiempo real y
ejecutarlos en el procesador en conjunto con los VIs de FPGA para aprovechar la gran capacidad de
procesamiento paralelo.

Parte B: Creando un proyecto de LabVIEW

Este ejercicio opcional es recomendado para nuevos usuarios de LabVIEW.
Objetivo: Crear un proyecto de LabVIEW.
Un proyecto de LabVIEW es requerido para desplegar código a dispositivos embebidos, tales como NI
myRIO. Adicionalmente, usando proyectos de LabVIEW, aunque sea para aplicaciones sencillas, es una
buena práctica de programación por que le ayuda a organizar la aplicación si ésta se convierte en algo más
complejo a futuro.
El Explorador de Proyectos de LabVIEW ayuda a gestionar todas las fuentes relacionadas con la aplicación.
Estas fuentes pueden incluir múltiples VIs, la interfaz de usuario, imágenes, documentos de textos,
archivos de configuración e información de desarrollo. La estructura del proyecto permite un rápido control
de archivos y dispositivos externos (targets).
ni.com/myRIO | 10
El Explorador de Proyectos de LabVIEW es similar a otros entornos de desarrollo integrados (IDEs).
LabVIEW es un lenguaje de plataforma cruzada con soporte comprensivo para complementos y librerías.
Usted puede escribir la mayoría de los VIs en función de la máquina de desarrollo y después redirigirlo
fácilmente a un dispositivo embebido de NI como el myRIO, ya que estos dispositivos ejecutan un sistema
operativo que funciona con las aplicaciones de LabVIEW y las bibliotecas complementarias.
La jerarquía de Explorador de proyectos de LabVIEW para un proyecto individual no refleja la organización
de los archivos de código fuente en el disco. Mover archivos en el proyecto no afecta la posición real de
éstos en el dispositivo de almacenamiento, sólo en la vista del Explorador de proyectos de LabVIEW.

TIP: Un target es cualquier dispositivo que puede correr un VI. Por ejemplo, su computadora de
desarrollo y su dispositivo NI myRIO son targets.
Complete los siguientes pasos para crear un proyecto nuevo:
1. Si aún no está abierto, abra LabVIEW.
2. Seleccione el botón de Create Project en la ventana de inicio de LabVIEW.
3. La ventana Create Project se abrirá y ofrecerá varias opciones. Usted puede explorar todas esas
funciones utilizando el link de More Information asociado cualquier plantilla de proyecto del cual está
interesado.
6. Por ahora, seleccione la opción Blank Project como punto de inicio del proyecto.
7. Después seleccione el botón Finish. Esto crea un proyecto vacío y abre el Explorador de proyectos de
LabVIEW.
4. Para guardar el nuevo proyecto:
a. Desde el explorador de proyectos de LabVIEW, seleccione File»Save.
b. Un cuadro de diálogo para guardar se abrir y pedirá un directorio de destino y un nombre para el
proyecto. Diríjase a Desarrollo de Sistemas con NI myRIO>>Ejercicios\Ejercicio 0 en su escritorio.
Nombre el Ejercicio 0 Proyecto.lvproj.
La ventana del Explorador de Proyectos de LabVIEW está mostrando un nuevo proyecto que está listo para
ser implementado con recursos y código fuente. El Explorador de Proyectos de LabVIEW ofrece un menú
estándar de opciones familiares (Archivo, Editar, Ver, etc.), junto con algunas opciones exclusivas para
LabVIEW. El Explorador de Proyecto de LabVIEW en sí tiene dos paneles: elementos y archivos. La pestaña
de Elementos muestra los archivos del proyecto organizados en una jerarquía, y la pestaña de Archivos
muestra dónde se encuentran almacenados en el disco duro.

Explorador de proyectos de LabVIEW

ni.com/myRIO | 11
En la pestaña de Elementos del Explorador de Proyectos, se puede ver la organización del proyecto. La raíz
del proyecto, el primer elemento de la lista, muestra en que proyecto se está trabajando.
Debajo de la raíz del proyecto, el siguiente nivel en el árbol contiene los “targets” a los cuales el proyecto
está destinado. Un proyecto en blanco coloca por defecto a la computadora de desarrollo. Debajo de “My
Computer”, se encuentran las especificaciones de construcción del proyecto. Las especificaciones de
construcción incluyen las configuraciones de compilación para las fuentes de distribución y otras
compilaciones en las herramientas y módulos de LabVIEW. Estas se utilizan a la hora de distribuir las
aplicaciones a colegios/clientes o para el despliegue de aplicaciones en sistemas embebidos.
El Explorador de Proyectos de LabVIEW se hace particularmente útil en el desarrollo de aplicaciones
complejas. Sin embargo, utilizar los proyectos, incluso para aplicaciones simples, es una buena práctica ya
que ayuda a gestionar la aplicación si se escala y se convierte en algo más complejo en el futuro.
Mantenga este proyecto abierto para que pueda utilizarlo en la siguiente sección.

Parte C: Creando un proyecto de LabVIEW

Este ejercicio opcional es recomendado para nuevos usuarios de LabVIEW
Objetivo:
• Experimentar la creación de una aplicación de LabVIEW desde cero.
• Familiarizarse con el ambiente de desarrollo de LabVIEW y sus conceptos fundamentales de
programación gráfica.
Para entrar a la parte de programación de LabVIEW, deberá de crear un VI nuevo. Para crear un VI que se
ejecute en nuestra máquina de desarrollo, haga clic derecho en “My Computer” y seleccione New»VI en
el Explorador de Proyectos de LabVIEW.

Creando un VI en blanco

Esto crea un VI en blanco dentro de My Computer en el proyecto. Este VI en blanco consiste en dos
ventanas: el Panel Frontal y el Diagrama de Bloques.

ni.com/myRIO | 12
 Panel Frontal (izq.) y Diagrama de Bloques (der.)

Guarde el nuevo VI seleccionando File»Save ya sea desde el panel frontal o del diagrama de bloques.
Cuando el cuadro de dialogo de guardar aparezca, dele un nombre significativo al VI.
Ahora que ya ha guardado el VI, puede crear el código de conversión de temperatura. Complete los
siguientes pasos para diseñar el VI:
1. Usted quiere que su código se ejecute de forma continua, y, al igual que los lenguajes basados en
texto, LabVIEW utiliza ciclos para ejecutar tareas de forma continua. Puede terminar los ciclos con un
botón en el panel frontal o mediante el uso de alguna condición para determinar cuándo se ha
completado una tarea.
Para este ejercicio, utilice un “While Loop” (Ciclo While) para monitorear continuamente la temperatura
en Fahrenheit para después convertirla a Celsius. Use un botón en el panel frontal para detener el
programa.
a. Cambie al diagrama de bloques ya sea seleccionando su respectiva ventana o presionando <Ctrl-
E> desde el panel frontal (Se puede utilizar este comando para cambiar rápidamente entre estas
dos ventanas).

TIP: Aprender atajos de teclado acelera la navegación a través del entorno de LabVIEW. Además
de hacerle ver como todo un experto de LabVIEW!

b. Clic Derecho en el diagrama de bloques para abrir la Paleta de Funciones. La paleta contiene todos
los nodos y VIs que se usan para programar en LabVIEW. Usted puede personalizar la Paleta, por
defecto todos los complementos y VIs están disponibles. Diríjase a
Programming»Structures»While Loop y seleccione While Loop.

Se puede observar como el cursor cambia al ícono de draw-loop.

ni.com/myRIO | 13
 Seleccionando un While Loop

c. Dibuje un While Loop en el Diagrama de Bloques. Haga clic izquierdo y arrastre el cursor para dibujar
un recuadro y crear el “loop”. Se puede redimensionar los ciclos colocando el cursor sobre el loop
y arrastrando uno de los ocho cuadrados azules para redimensionar.

Diagrama de Bloques con un While Loop

d. Regrese al panel frontal utilizando el atajo <Ctrl-E>. Haga clic derecho para abrir la Paleta de
Controles. Esta paleta contiene todos los elementos usados para crear la interfaz de usuario del VI.
Diríjase a Modern»Boolean»Stop Button.

ni.com/myRIO | 14
 Seleccionando el botón “Stop” (Detener)

e. Haga clic Izquierdo en el botón Stop en la paleta, arrástrelo al panel frontal y clic izquierdo en un
lugar apropiado.

TIP: Usted puede elegir entre diferentes apariencias (subpaletas clásica y plata) del botón de
Detener (Stop) en el sistema. Seleccione el botón que mejor se adapte a sus necesidades de interfaz de
usuario. También puede utilizar LabVIEW para crear controles personalizados.

Panel frontal con el botón de Detener

ni.com/myRIO | 15
 f. Cámbiese al diagrama de bloques y localice la terminal del botón de detener que acaba de aparecer.
Haga clic izquierdo y arrastre la respectiva terminal a la terminal “condicional” que se encuentra
dentro del ciclo While, (Se localiza en la esquina inferior derecha del ciclo While) .
g. Cableé el botón de Detener a la terminal condicional dando clic izquierdo en la terminal de
“cableado” del botón de detener y después dando clic en la terminal de cableado de la condicional.
Un cable verde deberá aparecer entre los dos íconos. El color verde nos dice que valores booleanos
pueden pasar a través del cable. (Otro tipo de datos tienen cables de colores diferentes)

Ciclo While con la condición de Detener cableada

TIP: Las terminales, que son las representaciones de diagrama de bloques de objetos del panel
frontal, se pueden mostrar en dos estilos diferentes. Uno de ellos es más pequeño y más compacto. El
otro es más grande pero más descriptivo.

Puede cambiar entre estos dos estilos haciendo clic derecho en el terminal y seleccionando Ver como
ícono.

2. Cree ahora el control de Fahrenheit y el indicador de Celsius en el panel frontal.

a. Cámbiese al panel frontal y de clic derecho para abrir la paleta de controles. Diríjase a
Modern»Numeric»Numeric Control.
b. Coloque el control en el panel frontal haciendo clic izquierdo en la paleta, después mueva el cursor
sobre el panel frontal y nuevamente clic izquierdo para poder colocarlo.
c. Dese cuenta que el control esta etiquetado como “Numeric Control.” Este no es una etiqueta muy
descriptiva para dicho control. Renombre el control dando doble clic en la etiqueta y escriba
“Fahrenheit.”
d. Abra la paleta de control (Clic derecho) y diríjase a Modern»Numeric»Thermometer. Coloque el
termómetro en el panel frontal.

ni.com/myRIO | 16
 e. De la misma manera que se renombró el control “Fahrenheit”, renombre el indicador del
termómetro dando doble clic en la etiqueta. Escriba “Celsius”
f. Ahora añada un Led Virtual al panel frontal, este se ilumina cuando la temperatura cae bajo cero.
Coloque el Led en el panel frontal dirigiéndose a Modern»Boolean»Round LED.
g. Coloque el LED en el panel frontal.
h. Renombre el LED “Below Freezing?” (¿Bajo cero?)

Panel frontal con controles e indicadores

3. Con los debidos controles e indicadores del panel frontal, debe aplicar las matemáticas y la lógica para
convertir grados Fahrenheit a Celsius en el diagrama de bloques.
a. Cámbiese de nuevo al diagrama de bloques y observe los íconos nuevos de Fahrenheit, Celsius y
Below Freezing. Mueva el ícono de Fahrenheit dentro del ciclo While en la parte izquierda y del lado
derecho coloque Celsius y Below Freezing. Deje espacio suficiente entre los íconos para el código.

Diagrama de bloques con terminales de control sin cablear

ni.com/myRIO | 17
 b. Coloque un nodo de “resta” en el diagrama de bloques dando clic derecho para abrir la paleta de
funciones, después diríjase a Programming»Numeric»Subtract. Coloque el nodo justo a la derecha
del ícono de Fahrenheit.
c. Cableé la terminal de salida del ícono de Fahrenheit al nodo de Resta, a la terminal superior.
d. Haga clic derecho en la terminal inferior del nodo resta y seleccione Create»Constant.
e. Introduzca un valor de “32” en la constante.
f. Coloque un nodo de “Multiplicación” en el diagrama de bloques, dando clic derecho para abrir la
paleta de funciones, después diríjase a Programming»Numeric»Multiply. Coloque el nodo a la
derecha del nodo Resta.
g. Cableé la terminal de salida del nodo Resta a la terminal superior del nodo Multiplicación.
h. Coloque un nodo “División” en diagrama de bloques dando clic derecho y dirigiéndose a
Programming»Numeric»Divide. Coloque el nodo División por abajo del nodo Resta.
i. De clic derecho en la terminal superior del nodo división y seleccione Create»Constant. Asigne un
valor de “5” a esta constante.
j. Haga clic derecho en la terminal inferior del nodo división y seleccione Create»Constant. Asigne un
valor de “9” a esta constante.
k. Cableé la terminal de salida del nodo división a la terminal inferior del nodo Multiplicación.
l. Cableé la terminal de salida del nodo Multiplicación a la terminal de entrada del Indicador de Celsius.
m. Coloque un nodo “less than 0” (menor que cero) en el diagrama de bloques dando clic derecho y
dirigiéndose a Programming»Comparison»Less Than Zero? Coloque el nodo en alguna parte a la
derecha del nodo multiplicación.
n. Cableé la salida del nodo Multiplicación al nodo de “less-than-zero?” (menor que cero)
o. Cableé la salida del nodo less-than-zero? A la entrada del indicador de Below Freezing.

4. Ahora que ya ha escrito todo el código, ejecute el VI. Verifique que el VI haya sido cableado
correctamente comparándolo con el VI completo que se encuentra en la página siguiente.
a. Cámbiese al panel frontal utilizando <Ctrl-E>. Asegúrese de que pueda ver todos los controles e
indicadores en la pantalla.
b. Localice la flecha de ejecución en la barra de herramientas y de clic en ella para ejecutar el
programa.
c. Por omisión, el termómetro muestra solo valores de 0 a 100 (Usted puede cambiarlos dando doble
clic en la escala y asignando valores diferentes). Para este ejercicio introduzca valores en el control
de Fahrenheit para ver como el indicador de Celsius se va actualizando con el valor correcto de la
temperatura (en un intervalo de 0 a 100).
d. Mientras el código está corriendo, pruebe “execution highlighting” en el diagrama de bloques
dando clic en el botón: . Dese cuenta como la ejecución de su código se ralentiza y LabVIEW
anima el flujo de datos en su diagrama de bloques. Usted puede utilizar esta herramienta de
depuración para visualizar el movimiento de los datos y el orden en que se ejecutan sus funciones.
e. Cuando termine de usar el VI, puede detenerlo presionando el botón de Detener en el Panel Frontal.
5. Guarde y cierre el VI y el proyecto.
Al final de este ejercicio, usted debe sentirse bastante cómodo con el enfoque de programación gráfica. El
modelo de la LabVIEW hace que sea fácil de crear aplicaciones para varios dispositivos compatibles. En los

ni.com/myRIO | 18
próximos ejercicios del taller, utilice el mismo entorno para crear programas para el dispositivo NI myRIO.
Trabaje con las mismas estructuras, controles, indicadores y funcionalidad que usted hizo aquí para este
ejercicio.

Solución del ejercicio

ni.com/myRIO | 19
Ejercicio 1. Cree su primer proyecto con NI myRIO
Objetivo: Cree un nuevo proyecto con NI myRIO utilizando las plantillas incluidas en LabVIEW. Después
explore el código que se generó y obtenga su primera medición de un sensor a través de NI myRIO

Introducción: Ejecutando código en tiempo real en el dispositivo NI myRIO

El código en tiempo real se ejecuta en el procesador integrado en el dispositivo NI myRIO. Este código
puede recibir datos desde y enviar datos a la FPGA utilizando nodos de E/S de la FPGA, DMA FIFOs y
Express VIs. Las entradas y salidas de los conectores de expansión NI myRIO y el puerto NI Mini Systems
se comunican con el procesador a través de la FPGA. La FPGA será tratada en detalle más adelante; por
ahora, recuerde que la unidad NI myRIO se envía con una FPGA que está configurada para pasar todos los
datos de entrada y salida de datos desde y hacia los conectores físicos y dispositivos integrados (botones,
LEDs y acelerómetro) para el procesador que ejecuta el código de tiempo real.

Desarrollo
1. Desde la ventana de inicio de LabVIEW, seleccione el botón Create Project.

Creando un proyecto

2. En el panel de la izquierda, seleccione myRIO del árbol Templates (plantillas).

Plantillas NI myRIO

ni.com/myRIO | 20
3. El panel de la derecha muestra tres opciones: proyecto en blanco, proyecto myRIO y proyecto myRIO
FPGA. El proyecto en blanco es el mismo que se creó en el primer ejercicio del taller.
a. Utilice la plantilla de myRIO Project para crear un proyecto con la configuración predeterminada del
FPGA. Esta plantilla es muy útil para proyectos que no requieren toda la funcionalidad y configuración
del FPGA.
b. Utilice la plantilla myRIO Custom FPGA para hacer una configuración personalizada del FPGA en el
dispositivo NI myRIO. Por ejemplo, los tres conectores combinados ofrecen un total de 8 líneas de
E/S digitales con capacidad de PWM. Pero si usted desea conectar más dispositivos controlados por
PWM o más líneas PWM, puede reconfigurar el FPGA para soportar PWM en más de las líneas de
E/S digital. Esto aplica a otros protocolos de comunicación como I2C, SPI y otros.
4. Seleccione de la lista myRIO Project y presione el botón Next (siguiente).
5. Dele al proyecto un nombre significativo y seleccione un directorio apropiado en la Raíz del Proyecto
en el escritorio dentro de la ruta Desarrollo de Sistemas con NI myRIO>>Ejercicios\Ejercicio 1. Verifique
que el botón de Plugged into USB (conectado por USB) esta seleccionado y que nuestro myRIO
aparezca en la lista de la derecha.

Configurando un proyecto en LabVIEW

6. Seleccione Finish (terminar) cuando todo haya sido configurado correctamente.

Nota: Esta plantilla NI myRIO configura el dispositivo NI myRIO como un objetivo en el proyecto de
LabVIEW. Un concepto fundamental que hay que recordar es que cuando un VI se dirige a la unidad NI
myRIO, el código en el VI se ejecuta realmente en el dispositivo incluso si el panel frontal se está viendo
en el equipo de desarrollo. Esto se denomina modo de panel frontal interactivo, que está destinado
solamente para la depuración y el desarrollo.
Por lo general, en la forma final de la aplicación, el código está totalmente desplegado a una unidad NI
myRIO “no atada” (untethered), por lo tanto, los controles del panel frontal y los indicadores son
inaccesibles. Sin embargo, puede utilizar las variables compartidas de red (network-published shared
variables) o algún tipo de streaming de red inalámbrica para enviar / recibir datos a / desde un ordenador
central para su procesamiento adicional, visualización y almacenamiento.
Para este ejercicio, la unidad NI myRIO está atado al equipo de desarrollo, pues todavía se desea ejecutar
el código en su procesador. Esto significa que puede interactuar con el panel frontal del VI que se ejecuta
ni.com/myRIO | 21
en el procesador en tiempo real del dispositivo NI myRIO, y el motor de variable compartida de NI se
encarga de las comunicaciones de red necesarias para manejar la transferencia de datos. Para algunas
configuraciones de prueba y experimentales, el modo de panel frontal interactivo es adecuado y elimina la
necesidad de una comunicación de datos más complicada entre el anfitrión y el destino en tiempo real.

LabVIEW Project Hierarchy

1. Expanda el dispositivo myRIO-1900 (xxx.xx.xx.x) con el explorador de proyectos de LabVIEW y abra el

VI: Main.vi dando doble clic sobre él.
2. Asegúrese de que el panel frontal contenga una Waveform Chart (Gráfica de funciones) y un botón de
Detener (Stop button)
3. Antes de ejecutar el VI, examine el diagrama de bloques, cámbiese a él presionando <Ctrl-E>.
4. Analice el código que se encuentra en el diagrama de bloques. La estructura alrededor del Ciclo While
que tiene un aspecto de cinta de película es llamada sequence structure. (estructura de secuencia)

Main.vi

Las sequence structures representan una forma de forzar la ejecución de su código. El código en cada
cuadro (frame) debe ejecutarse antes del otro (de derecha a izquierda), una vez terminado, el siguiente se
ejecuta, en estos casos se pueden usar tunnels (túneles) para pasar información a través de los cuadros.
Nota: También puede conseguir este comportamiento utilizando técnicas de programación de flujo de datos
apropiadas sin el añadido de una estructura de secuencia.

ni.com/myRIO | 22
 TIP: Los túneles son los pequeños puntos cuadrados que aparecen en los bordes de los ciclos,
marcos y estructuras de caso. Se pueden crear de forma automática con la herramienta de cableado al
conectar dos terminales separadas por una de las estructuras antes mencionadas, o se pueden conectar
de forma manual haciendo clic en el borde de una de las estructuras. Los túneles pasan los datos de
una estructura o de ciclo sólo cuando todo el código en el que la estructura haya terminado de ejecutarse.

a. El cuadro de inicio de la estructura de secuencia es el primero a ejecutar. La única acción que ocurre
en este marco es un clúster de error constante que se está creando y se pasa al siguiente fotograma
a través de un túnel. Pero este es un lugar apropiado para inicializar las variables, objetos de interfaz
de usuario y dispositivos de hardware.
b. El cuadro de "adquirir y procesar datos" recibe el clúster de error, y un ciclo While (llamado "Main
Loop") comienza a ejecutarse. Dentro del ciclo principal, un VI Express (la VI azul que dice
"Acelerómetro") se utiliza para adquirir datos desde el acelerómetro incorporado en el dispositivo NI
myRIO. Los datos leídos muestran en el indicador gráfico de forma de onda de aceleración (la tabla
en el panel frontal).
Observe el VI “wait (ms)” que se muestra en la esquina superior derecha del diagrama de bloques.

Este VI obliga al ciclo a ejecutarse cada 10 ms, dando el ciclo de una frecuencia de 100 Hz (suponiendo que
el código en el ciclo que puede ejecutar rápido).
Observe que el ciclo While no se ejecuta si el usuario hace clic en el botón de Detener en el panel frontal
o se produce un error durante la ejecución.
c. Cuando el Ciclo While termine de ejecutarse, se pasa el error y a través del cuadro de la estructura
de secuencia hasta el cuadro final. Utilice este cuadro para cerrar todas las referencias en el
dispositivo NI myRIO antes de salir del programa. Al agregar su propia funcionalidad personalizada,
puede utilizar este marco para cerrar las líneas de E / S y guardar o borrar datos.
5. Ahora que ya ha analizado la estructura del código, cambie al Panel Frontal presionando <Ctrl-E>. De
clic en la flecha de ejecución para correr el programa en el dispositivo NI myRIO.
6. Mueva el dispositivo NI myRIO para ver el cambio de valores en tiempo real, la gráfica de funciones
estará mostrando los resultados del acelerómetro.
7. Presione el botón STOP para salir del ciclo While terminar de ejecutar la estructura de secuencia.
8. Guarde y cierre esta aplicación.

Fin del Ejercicio 1

ni.com/myRIO | 23
Ejercicio 2a: Crear un código de tiempo real para correrlo en un dispositivo
NI myRIO
Objetivo: Desarrollar un VI para habilitar el control manual de un display de siete segmentos.

1. Conecte la placa de prueba con display de siete segmentos a la entrada B del conector MXP como se
muestra en la siguiente imagen.

Placa de prueba con display siete segmentos

2. Regrese a la ventana de inicio de LabVIEW cerrando todas las aplicaciones de LabVIEW que aun estén
abiertas. Ahora seleccione File»Open Project, diríjase a Desarrollo de Sistemas con NI
myRIO>>Ejercicios\Ejercicio 2 en su escritorio y abra Ejercicio 2.lvproj.
3. Abra Main.vi que se encuentra dentro de myRIO-1900 (xxx.xx.xx.x) en el explorador de archivos de
LabVIEW. Dese cuenta que el panel frontal ya ha sido creado para usted.
4. Abra el diagrama de bloques <Ctrl-E>.
5. Asegúrese que el subdiagrama de estructura de casos, “Manual Control”, se esté mostrando. Use las
flechas derecha e izquierda en la parte superior de la estructura de casos (case structure) para
desplazarse en los demás casos.

Main.vi

ni.com/myRIO | 24
 TIP: Los botones del panel frontal que representan los distintos segmentos del display se
construyen en una matriz de valores booleanos. Esto simplifica el cableado (se está ahora trabajando
con un solo cable en lugar de ocho cables individuales) y reduce los cálculos repetitivos (LabVIEW le
permite realizar el procesamiento en una matriz entera en lugar de tener que procesar cada elemento
de forma individual).
Observe que el cable que transfiere el arreglo es más grueso que los cables que transfieren al individuo,
elementos de datos escalares.

6. Debido a que el display de siete segmentos es “activo bajo” (los segmentos se iluminan cuando la
línea digital está en bajo), usted debe de invertir el arreglo booleano para asegurarse de que la interfaz
de usuario sea intuitiva.
a. De clic derecho en el diagrama de bloques y diríjase a Programming»Boolean»Not.
b. Coloque la compuerta Not a la derecha del túnel booleano en el borde de la estructura de casos.
c. Cableé el túnel booleano en la entrada de la compuerta Not.
d. Esta compuerta Not invierte todo valor booleano que se encuentre en el arreglo.

Estado Manual Control

7. Ahora que ha invertido todos los valores booleanos en el arreglo, es hora de desensamblar el arreglo
en sus elementos individuales originales.
a. De clic derecho y diríjase a Programming»Array»Index Array.
b. Coloque la función Index Array a la derecha de la compuerta Not.
c. Cableé la salida de la función Not a la entrada “array” de la función Index Array.
d. Poniendo el cursor sobre la función de Index Array, genera una pequeña caja azul en la esquina
inferior de la función, Arrastre la caja azul hacia abajo para expandir la función Index Array hasta
mostrar ocho elementos de salida.

Index Array

ni.com/myRIO | 25
8. Ahora que tiene acceso a los elementos individuales de arreglo booleano invertido, Usted debe de
enviar los valores a las líneas digitales del dispositivo NI myRIO. Estas líneas digitales están conectadas
físicamente al display de siete segmentos.
a. Haga clic derecho y diríjase a myRIO»Digital Out. Dese cuenta que la función contiene un borde azul.
Esto significa que es un VI Express, el cual se puede configurar con un menú muy simple en una
ventana emergente.
b. Coloque una función Digital Output a la derecha de la función Index Array. Esto abrirá la ventana de
configuración.
c. Por omisión solo un canal digital es mostrado: A/DIO0 (pin 11). Estamos hablando de una
entrada/salida digital (Digital IO Line) en la conexión A de MXP.
d. Utilizando el menú desplegable de “Channel” (para seleccionar las líneas digitales), cambie el canal
a B/DIO0 (Pin 11).
Ya que se ha seleccionado la primera línea digital, añada siete canales nuevos dando clic en el botón
Add Channel siete veces más. LabVIEW automáticamente incrementa el número de líneas digitales.
La ventana de configuración debe verse como la siguiente imagen.

Configure Digital Output

f. El VI Express automáticamente genera código de bajo nivel requerido para realizar esta tarea. Si
desea ver el código, presione el botón de “VIEW CODE”

ni.com/myRIO | 26
 Configure Digital Output. View Code

g. Si está de acuerdo con la configuración de un clic en OK.

9. Volviendo al diagrama de bloques, Usted deberá de conectar los valores Booleanos del Index Array a
la entrada booleana del “Digital Output”.
a. Cableé el primer elemento de la función Index Array a B/DIO0 (Pin 11).
b. Cableé el segundo elemento de la función Index Array a B/DIO1 (Pin 13).
c. Continúe de la misma manera hasta que los elementos de Index Array estén conectados s su
respectiva salida en Digital Output.

Digital Output Express VI

10. Para encaminarse en buenas prácticas de desarrollo, debe programar el VI para cerrar correctamente
si se produce un error.
a. Para lograr esto, cableé la terminal error out del VI Express Digital Output a la función Or que está
conectada a la terminal de Detener del ciclo while. El ciclo While detendrá el código si el usuario
presiona el Botón de Detener o que ocurra un error.

ni.com/myRIO | 27
 Conectando el error a la terminal de la condición de parada

TIP: No se preocupe si el cableado se ve más desordenado que la imagen de arriba. LabVIEW

incluye una función de limpieza automática que puede ayudar. Resalte la función Index Array y la salida
digital Express VI dibujando un recuadro alrededor de ellos con el cursor. Luego haga clic en el botón
Cleanup Diagram (Diagrama de Limpieza) en la barra de herramientas de LabVIEW.

11. Cuando el ciclo while se detiene, se deberá darle un reset al dispositivo NI myRIO para asegurarnos
que todos los canales regresen a sus valores iniciales por omisión.
a. Clic derecho, diríjase a myRIO»Utilities»Reset myRIO.vi.
b. Coloque el VI, Reset myRIO.vi a la derecha del Ciclo While.
c. Cableé la terminal de error out hasta el borde del Ciclo While. Note que LabVIEW crea
automáticamente un túnel para pasar información fuera del Ciclo.
d. Cableé la salida del túnel de error a la entrada de error del VI Reset myRIO.vi.

TIP: El uso de cables para conectar elementos del diagrama de bloques forza el flujo de datos y se
asegura de que las funciones se ejecuten en un orden definido. Aquí el Reset myRIO.vi no puede
ejecutarse hasta que el ciclo While haya terminado y se hayan transmitido datos (en este caso el cluster
de error) a él. En esta aplicación, el cable de error asegura que el reset myRIO.vi es la última función a
ejecutar.

ni.com/myRIO | 28
12. Su diagrama de bloques ahora se encuentra completo. Asegúrese de que su código se vea parecido al
diagrama de bloques mostrado abajo. Guarde su código

Ejercicio 2A. Diagrama de Bloques Completo

13. De clic en la flecha de ejecución para desplegar el código de LabVIEW en el dispositivo NI myRIO.
Cambie al panel frontal e interactúe con los botones de la pestaña control manual. El Display de siete
segmentos deberá iluminarse de manera correcta.
14. Detenga el VI, manténgalo abierto para la siguiente sección.

Fin del Ejercicio 2a

ni.com/myRIO | 29
Ejercicio 2b: Crear un código de tiempo real para correrlo en un dispositivo
NI myRIO
Objetivo: Extender la funcionalidad de la aplicación para permitir al usuario girar un potenciómetro para
desplegar diferentes valores en el display de siete segmentos.
1. Regrese al diagrama de bloques y seleccione el caso Numeric Display en la estructura de casos. Tome
en cuenta que ese caso está vacío.

Caso Numeric Display

2. El primer paso será obtener lecturas de voltaje del potenciómetro en la tabla de circuitos incorporada
al conector B MXP. Para hacer esto necesita crear una entrada analógica.
a. De clic derecho y diríjase a myRIO»Analog In.
b. Coloque esta función en el caso Numeric Display. A continuación aparecerá una ventana emergente.
c. NI myRIO contiene 12 entradas analógicas diferentes. De forma similar a lo realizado para el VI Digital
Out que se creó anteriormente, primeramente debe seleccionar de que canal analógico quiere
adquirir datos. De clic en el menú Channel y seleccione B/AI1 (Pin 5).

Configurar Entrada Analógica

d. Siéntase libre de ver el código de bajo nivel generado por el VI Express, seleccione View Code
e. Clic en OK para regresar al diagrama de bloques.
3. El Express VI Analog Input adquiere voltajes desde el potenciómetro de la placa de circuitos conectada
al dispositivo NI myRIO a través del canal analógico AI1 del conector MXP B. El potenciómetro ha sido
cableado para producir un voltaje entre 0 V y 3.3 V. Usted deberá convertir esa lectura analógica a un
patrón digital que represente un digito numérico en el display de siete segmentos (números entre 0 y
9).
Para ahorrar tiempo se le ha creado una función de conversión. Esta función ha sido desarrollada como
un subVI (un VI que puede ser llamado por otro VI).
a. Dejando abierto el VI: Main (Exercise 2).vi, abra Ejercicio2.lvproj (en su barra de tareas).

ni.com/myRIO | 30
 b. Debajo del dispositivo myRIO target, hay una carpeta llamada subVI. Dentro de esta, hay un VI
llamado AI to LED Converter.vi. Esta es la función que ha sido creada previamente para este ejercicio.
Arrástrelo desde el explorador de proyectos al diagrama de bloques de Main (Exercise 2).vi

Agregar AI to LED Converter.vi

TIP: Los SubVIs son una gran manera de crear funcionalidad personalizada en LabVIEW. Estos no
sólo crean orden, código modular, sino que también comparten funciones personalizadas entre las
aplicaciones e incluso desarrolladores. Por ejemplo, se puede Visitar ni.com/community acceder a miles
de aplicaciones de ejemplo y subVIs personalizados que la comunidad LabVIEW genera.

4. Cableé la terminal B/AI1 (Pin 5) del Express VI Analog Input a la terminal Analog reading (In) del subVI
AI to LED Converter.vi.
5. Cableé la terminal LED Values (Out) del VI AI to LED Converter.vi al túnel booleano a la derecha de la
estructura de casos.

ni.com/myRIO | 31
 Numeric Display Terminado

6. La nueva funcionalidad esta lista para ser desplegada en el dispositivo NI myRIO. Guarde su código y
ejecute el VI.
7. En el panel frontal, tome en cuenta que la función de Control Manual sigue trabajando igual que antes.
Sin embargo, cuando seleccione la pestaña Numeric Display, será capaz de interactuar con el
potenciómetro que se encuentra en la tabla de circuitos para controla el valor que aparece en el display
de siete segmentos.

TIP: Mientras se ejecuta el código, cambie el diagrama de bloques y haga doble clic en el subVI AI
to LED Converter. Se abrirá el panel frontal del subVI. Interactúe con el potenciómetro para ver el cambio
en el display de siete segmentos. Para saber cómo funciona la conversión, cambie al diagrama de
bloques del subVI (<Ctrl-E>) para revisar el código detrás del subVI.

Fin del Ejercicio 2b

ni.com/myRIO | 32
Ejercicio 2c: Desafíos opcionales
Objetivo: Si termina los ejercicios anteriores antes que el resto del grupo, utilice este tiempo para ampliar
aún más la funcionalidad de la aplicación, completando los ejercicios de desafío siguientes.
• No hay instrucciones: Momento para que piense por su cuenta
• Obtenga experiencia en la manipulación de arreglos y sincronización de software en LabVIEW

Desafío 1
Cree una estructura de casos rotativa, en donde un solo segmento aparente moverse alrededor del display
de siete segmentos.

Habilite este modo cuando el usuario selecciona la pestaña Chase Sequence en el panel frontal.

Desafío 2
Genere un control para que el usuario pueda regular la velocidad.

Desafío 3
Permita al usuario revertir la dirección del chase sequence utilizando un botón en el panel frontal.
La tabla siguiente muestra como los segmentos son conectados individualmente a las líneas de entrada y
salida del dispositivo NI myRIO.

Pin B/DIO Terminal

a 0 11
b 1 13
c 2 15
d 3 17
e 4 19
f 5 21
g 6 23
dp 7 25

Usted puede elegir entre muchas formas para resolver estos desafíos, sin embargo, deberá considerar
algunos de los siguientes elementos útiles del diagrama de bloques.

La terminal de iteración
del ciclo While, Un arreglo Booleano de
incrementa con cada una dimensión, con un
iteración del ciclo valor verdadero
individual

Fin del Ejercicio 2c

ni.com/myRIO | 33
Diseño de Control y Simulación en LabVIEW
El Diseño de Sistemas de Control es un proceso que implica el desarrollo de modelos matemáticos para
describir un sistema físico, el análisis de los modelos para aprender acerca de sus características dinámicas
y la creación de un controlador para modificar ciertas características dinámicas. Los sistemas de control
contienen componentes que dirigen, mandan y regulan el sistema físico, que también se conoce como la
planta. Los Ingenieros de Control se centran tanto en el modelado como en la implementación de estos
sistemas de control para lograr una respuesta específica de la planta. Las plantas pueden variar en
complejidad desde un sistema simple amortiguado de masa-resorte o de resistencia-condensador (RC) de
circuito hasta los sistemas complejos utilizados en satélites. Los sistemas de control son tradicionalmente
modelados como diagramas de bloques.

Para crear controles en diagramas de bloques, como el que se muestra arriba, utilice el módulo Control
Design and Simulation, que añade varias funciones de control a LabVIEW. En concreto, se permite el
desarrollo de modelos de muchas plantas diferentes directamente en LabVIEW, incluyendo los modelos
de función de transferencia y espacio de estado (state & space).
El módulo Control Design and Simulation contiene un ciclo (loop) de Control y Simulación, que es un While
Loop con funcionalidad adicional para que los controles se ejecuten en segundo plano. Con el Ciclo de
Control y Simulación, puede construir controladores y modelos de plantas. Una vez que haya analizado un
controlador en la simulación, se puede reemplazar la planta simulada con entrada y salidas reales. Esto
permite analizar, simular e implementar sistemas de control, todo desde el entorno de LabVIEW.
También puede utilizar el Módulo LabVIEW Real-Time y NI myRIO para simular e implementar algoritmos
de control actuales. El Loop Rate, o qué tan rápido un ciclo de control ejecuta, es crucial para los controles.
Los controladores simples pueden requerir una frecuencia de actualización de sólo decenas de Hertz para
satisfacer sus especificaciones, pero los controladores más complejos requieren ejecutar código a
frecuencias en el orden de los kHz o superiores. El código que se ejecuta en LabVIEW Real-Time en un
dispositivo NI myRIO se puede ejecutar de forma rápida y con mucho mayor determinismo de código del
que pueda estar ejecutándose en una computadora con Windows.

Ejercicio 3a: Diseñar un sistema de control simulado que se ejecute en la

máquina de desarrollo.
Objetivo: Crear un controlador PI (proporcional integral) simple para controlar el voltaje a través de un
capacitor en un circuito RC simulado. Después modelar el circuito RC utilizando una función de
transferencia de Primer Orden.
1. Guarde y cierre cualquier VI o proyecto de LabVIEW que se encuentre abierto.
2. Nuevamente, para ahorrar tiempo, se le proveerá una aplicación como punto de inicio. Seleccione
File»Open Project y diríjase Desarrollo de Sistemas con NI myRIO>>Ejercicios\Ejercicio 3 en su
escritorio. Después abra el proyecto Ejercicio3.lvproj.

ni.com/myRIO | 34
3. Abra el VI Main (Exercise 3).vi dentro de My Computer en el Explorador de Proyectos de LabVIEW.
Debido a que este VI se encuentra en My Computer, se ejecutará en la máquina de desarrollo en lugar
del NI myRIO.
4. El panel frontal está casi terminado, pero en el diagrama de bloques hacen falta varios elementos, por
lo tanto, diríjase al diagrama de bloques. <CTRL+E>
5. Para ahorrar tiempo, un controlador PI ha sido construido para usted. Note que el código está rodeado
de un borde grueso de color negro, esto es un ciclo de Control y Simulación. Piense que es un While
loop que le permite usar una interfaz de Control y Simulación.
SI le interesa saber más de estas funciones, presione <Ctrl-H> para activar la ayuda y coloque el cursor
sobre la función que le interesa conocer. Clic en el link Detailed Help para dirigirse a la página complete
de ayuda en LabVIEW.

Ventana de Context Help

Debido a que el algoritmo de control ya se ha aplicado, cree una planta simulada simple utilizando una
función de transferencia de primer orden

TIP: Una función de transferencia es una representación matemática de la relación entre la entrada
y salida de un sistema lineal invariante en el tiempo. Ejemplos de sistemas de primer orden incluyen
sistemas de control de crucero y circuitos RC.
Sistema Mecanico de Primer Orden Sistema Electronico de Primer Orden

ni.com/myRIO | 35
Nuestro objetivo para este ejercicio es modelar un circuito RC simple como una función de transferencia.
La entrada al circuito es la caída de tensión en el circuito entero-u(t) en la figura siguiente. La salida de su
circuito es el voltaje a través del capacitor- y (t) en la figura siguiente. El siguiente modelo de función de
transferencia de los resultados del circuito en:

𝑉 (𝑠) 1
𝐻𝐶 (𝑠) = 𝑉 𝐶 (𝑠) = 1+𝑅𝐶𝑠
𝑖𝑛

Para su circuito, RC = constante de tiempo = 2.5. Implemente esta función de transferencia en LabVIEW.
a. Haga clic derecho y diríjase a Control Design and Simulation»Simulation»Continuous Linear
Systems»Transfer Function.
b. Coloque Transfer Function (función de transferencia) a la derecha del bloque de suma cuadrada.

Lazo de Simulación y Control

c. De doble Clic en transfer function para abrir la ventana de configuración.

Haciendo referencia de nuevo a la función de transferencia del circuito RC que se ha descrito
anteriormente, introduzca 2.5 (constante de tiempo del circuito RC) como el valor de denominador
a1. Observe que la previsualización de la función de transferencia se actualiza automáticamente.
d. Asegúrese de que la ventana de configuración de la función de transferencia (Transfer Function
Configuration Window) se vea similar a la imagen siguiente.

ni.com/myRIO | 36
 Configuración de Transferencia

e. Note que puede usar esta ventana de configuración para definir una función de transferencia más
compleja. Siéntase libre de hacer clic en el botón de ayuda (Help) para aprender otras opciones de
configuración.
f. De clic en OK.
6. Cableé la terminal de resultado (result) del bloque de sumatoria (summation block) a la entrada de u (t)
de la función de transferencia. Esto simula el voltaje de entrada a su circuito RC.
7. Cableé la salida de la función de transferencia (output y(t)) a la entrada superior de la función Build
Array. Esto simula el voltaje a través del capacitor.

Función de transferencia

8. Ahora que ya ha implementado su Planta (función de transferencia), necesita cerrar el ciclo de control
en el sistema de control. Cableé la salida (output y(t)) de la función de transferencia al Operador de
Resta de la función de sumatoria circular (summation function).

Lazo de retroalimentación
9. La aplicación ahora está completa. Guarde la aplicación y cámbiese al panel frontal, ejecute la aplicación.
Tenga en cuenta que la aplicación está corriendo en el procesador de la máquina de desarrollo.
Mientras la aplicación se está ejecutando, trate de interactuar con el control del punto de inicio (setpoint
control) y experimente con los valores de ganancia (control gain values).

ni.com/myRIO | 37
Utilice las ganancias por defecto (P=5, I=2):

Respuesta con valores por defecto

Incrementar P genera una respuesta más rápida, pero debido a esto, puede causar inestabilidades y
oscilaciones (P=50, I=2):

Respuesta con oscilaciones

Incrementando I se genera un decremento del error de estado estático, pero también se incrementa el
sobretiro (overshoot) y tiempo de establecimiento (settling time) (P=4, I=10):

Respuesta con overshoot

Fin del Ejercicio 3a

ni.com/myRIO | 38
Ejercicio 3b: Diseñar un sistema de control simulado que pueda correrse en
el procesador de NI myRIO
Objetivo: Despliegue el código de Diseño e control y Simulación en el dispositivo NI myRIO, para que así
corra con mayor determinismo.
1. Guarde y cierre el VI Main (Exercise3).vi y regrese al proyecto Ejercicio3.lvproj
2. Como se ha mencionado anteriormente, el VI Main (Exercise3).vi se encuentra en My Computer target.
Para desplegar el código en el procesador de NI myRIO, Usted simplemente debe de arrastrar el VI
Main (Exercise3).vi a NI myRIO (xxx.xx.xx.x).

Ejercicio3.lvproj

3. Haga doble clic en Main (Exercise3).vi para abrirlo y sin hacer alguna modificación al código, puede
oprimir la flecha de ejecución para que el VI se ejecute en el dispositivo NI myRIO.
4. Verá una ventana emergente que mostrará el progreso del desplegamiento. Cuando haya terminado,
el código se estará corriendo en el procesador del NI myRIO.
5. Detenga el VI, déjelo abierto para la parte final del ejercicio.

Fin del Ejercicio 3b

ni.com/myRIO | 39
Ejercicio 3c: Trasladarse de una simulación al mundo real
Objetivo: Ahora que el sistema de control se está corriendo en un dispositivo NI myRIO, usted tiene acceso
a entradas y salidas digitales del mundo real. En este ejercicio, removerá la Planta simulada y será
reemplazada con un circuito físico RC. Así mismo moverá el control del setpoint de software a hardware.
1. Quite el dial de Set Point del panel frontal y reemplácelo por con una función de entrada analógica, así
podrá controlar el setpoint (punto de inicio) del voltaje con un potenciómetro.
a. Cámbiese al diagrama de bloques del VI Main (Exercise3).vi.
b. Elimine la terminal de control de Set Point. Note que deja un “cable roto”. Un cable roto significa
que hay un error en el código, ya que en este caso ya no se está mandando información por el cable.
c. De clic derecho y diríjase a myRIO»Analog In.
d. Coloque esta función dentro del Control & Simulation Loop donde estaba la terminal de Set Point.
Aparecerá una ventana de configuración.
e. Haga clic en el menú desplegable Channel y seleccione B/AI1 (Pin 5).

Ventana de Configuración de Entrada Analógica

f. De clic en OK.
2. Volviendo al diagrama de bloques, cableé la salida B/AI1 (Pin 5) del VI Express Analog Input al cable
roto. Dese cuenta que el cable vuelve a la normalidad, dando a entender que ha resuelto el error anterior
conectando una fuente de información al cable.

Diagrama de Bloques del Ejercicio 3b

3. Regrese al panel frontal y ejecute el VI. Ahora será capaz de controlar el setpoint desde su circuito RC
simulado utilizando el potenciómetro conectado al dispositivo NI myRIO. Detenga el VI cuando haya
terminado.

ni.com/myRIO | 40
4. La parte final del ejercicio es remplazar la planta simulada con entradas y salidas analógicas, para así
poder interactuar con una planta real. (Circuito RC en físico)
a. Cambie al diagrama de bloques.
b. Para reemplazar la función de transferencia con entradas y salidas analógicas, debe de hacer espacio
en el diagrama de bloques. Arregle el código para incrementar la distancia entre el bloque de
sumatoria (summation) y la función de transferencia.

TIP: LabVIEW incluye un acceso directo que simplifica haciendo espacio en un diagrama de bloques.
Sólo tiene que mantener <Ctrl> y, a continuación, haga clic y mantenga pulsado el ratón en el área del
diagrama de bloques que desea hacer espacio. A continuación, arrastre el ratón en la dirección que desea
mover el código existente. Por último, suelte el botón del ratón.

Suelte el botón del mouse, y el código que

Mantenga presionado
Manteniendo esta alrededor se moverá en esa dirección
Ctrl y clic aquí
presionado, mueva el
cursor a la derecha

c. Borre la función de transferencia.

d. De clic derecho y diríjase a myRIO»Analog Out.
e. Coloque esta función a la derecha del bloque cuadrado de sumatoria (summation).
f. En las siguiente ventana de configuración, clic en el menú desplegable Channel y seleccione B/AO0
(Pin 2).

Ventana de Configuración de Salida Analógica

g. Haga clic en OK.

h. Cableé la terminal de resultado del bloque cuadrado de sumatoria a B/AO0 (Pin 2) del VI Express
Analog Output.

ni.com/myRIO | 41
 Modificación del Diagrama de Bloques

5. Ahora usted está enviando el valor de control al circuito RC utilizando una salida analógica. Finalmente,
Usted debe de cerrar el ciclo en el sistema de control midiendo la caída de voltaje a través del capacitor.
a. De clic derecho y diríjase a myRIO»Analog Input.
b. Coloque esta función a la derecha del VI Express Analog Output.
c. EN la siguiente ventana de configuración, clic en el menú desplegable Channel y seleccione B/AI0
(Pin 3).

Ventana de Configuración de Entradas Analógicas

d. Clic en OK.
e. De vuelta en el diagrama de bloques. Cableé la terminal B/AI0 (Pin 3) del Express VI Analog Input al
cable roto que conecta la terminal superior de la función Build Array al operando de resta del bloque
circular de sumatoria.

Diagrama de bloques Ejercicio 3c

6. El código ahora se encuentra completo. Guarde el VI.

7. Cambie al panel frontal e introduzca los siguientes valores al control Control Gains P=5, I=2
8. Ejecute el VI.

ni.com/myRIO | 42
 Ahora se encuentra Usted controlando una Planta Real, el circuito RC conectado en la tabla de
circuitos. Intente interactuar con el potenciómetro para ajustar el setpoint, después observe la caída
de voltaje a través del capacitor. Intente experimentar con las ganancias de control (control gains)
y cheque los cambios en la respuesta de control (control response).

Fin del Ejercicio 3c

ni.com/myRIO | 43
Ejercicio 3d: Ejercicio opcional
Si ha terminado correctamente el Ejercicio 3c antes que los demás, trate de modificar el código para que
muestre simultáneamente las respuestas de la planta simulada y la planta real en la misma gráfica.

TIP: Una forma simple para lograrlo es incluyendo dos algoritmos de control separados corriendo
en el mismo Control and Simulation Loop.
Fin del Ejercicio 3d

ni.com/myRIO | 44
Field-Programmable Gate Arrays (FPGAs)
Un FPGA es un chip de silicio que funciona en torno a una matriz de bloques lógicos configurables
conectados a través de interconexiones programables. Puede configurar estos bloques lógicos para
procesar todas las compuertas lógicas básicas que vienen en circuitos integrados estándar y, en muchos
casos, una lógica más compleja. Los primeros FPGAs comercialmente viables fueron inventados por los
cofundadores de Xilinx Ross Freeman y Bernard Vonderschmitt en 1985. La clara ventaja del FPGA es que
se puede modificar la lógica a nivel de hardware sin necesidad de adquirir o modificar hardware físico y
circuitos integrados. Esto significa que usted puede diseñar la lógica personalizada para su sistema y volver
a configurar el FPGA para ejecutar la lógica en tiempo de ejecución. Usted desarrolla la "personalidad" del
FPGA en un entorno de software y luego implementar la personalidad en el nivel de silicio. Debido a la
naturaleza de FPGAs, las secciones individuales del chip que son independientes unas de otras pueden
ejecutarse en paralelo.
Un verdadero paralelismo significa que las tareas que se ejecutan en FPGA son verdaderamente
independientes y altamente deterministas. El determinismo es crítico en los controles, la robótica, la
mecatrónica y otras aplicaciones (un sistema típico desarrollado en un FPGA puede ser diseñado para
reaccionar a las entradas digitales en tan poco como 25 ns [40 MHz] y a veces más rápido). Algunos
ejemplos de las aplicaciones de LabVIEW FPGA incluyen adquisición de datos inteligente, control de ultra
alta velocidad, protocolos de comunicación especializados, liberar el CPU de tareas para dejar al procesador
para un análisis más complicado, la sincronización compleja, y las pruebas de hardware-in-the-loop.
Con la capacidad de reaccionar a los cambios en los datos de manera rápida, el FPGA le ayuda a diseñar
sistemas de calidad industrial y experimentos sin grandes inversiones en equipos industriales actuales.

Con el módulo LabVIEW FPGA, el proceso de programación de FPGAs es totalmente gráfico y contiene
compilación totalmente automatizada. Usted diseña la personalidad FPGA usando VIs de la paleta de
LabVIEW FPGA Module. Luego, cuando esté listo para compilar, LabVIEW genera los archivos VHDL
intermedios requeridos por el compilador de Xilinx, comienza el compilador, y pasa los archivos en él. Esto
produce un archivo de bits que se descarga a continuación en la memoria flash del chip FPGA para ser leído
en el tiempo de ejecución. Cuando el FPGA se ejecuta, lee este archivo de bits y luego se reconfigura
según las instrucciones del archivo.

ni.com/myRIO | 45
Ejercicio 4: Explore la personalidad por defecto del NI myRIO FPGA
Objetivo: Cree un nuevo proyecto para NI myRIO utilizando la plantilla Custom FPGA. Después explore la
personalidad del FPGA que se encuentra por omisión y considere como la modificaría para su aplicación.
1. Guarde y cierre cualquier aplicación abierta de LabVIEW para regresar a la ventana de inicio.
2. Seleccione Create Project.
3. En la ventana de Create Project, elija el punto de inicio para el proyecto en el panel de la izquierda. Ahí
seleccione myRIO.
4. En el recuadro correcto, seleccione myRIO Custom FPGA Project. el enlace “more information” que
se encuentra en la descripción de Custom FPGA Project, contiene una descripción de como configurar
el proyecto.
5. Seleccione Next para configurar el proyecto.
a. Dele al proyecto un nombre apropiado (por ejemplo Exercise 4 ), seleccione un destino para guardar
el proyecto (Desarrollo de Sistemas con NI myRIO>>Ejercicios\Ejercicio 4) y seleccione el dispositivo
NI myRIO que se encuentra conectado vía USB.
6. Seleccione Finish para crear el proyecto.
7. Cuando el explorador de archives de LabVIEW cargue el nuevo proyecto, My Computer y myRIO-1900
(xxx.xx.xx.x) aparecerán como targets.
8. Expanda el target NI myRIO y note el nuevo árbol “chassis”. Este árbol aparece en dispositivos que
contienen un FPGA. El FPGA está en el árbol chassis porque está integrado en el chasis de myRIO.

Proyecto Ejercicio4.lvproj
El papel principal del FPGA es que está manejando todas las E/S del dispositivo NI myRIO para que pueda
encontrar las E/S en este objetivo FPGA como elementos únicos en proyectos. La jerarquía del FPGA se
organiza en carpetas para que el usuario pueda saber dónde se encuentra cada nodo de E/S en el dispositivo
físico. Los dos conectores MXP, el conector de un MSP y el onboard tienen carpetas únicas. Las carpetas
se subdividen en el tipo E/S (analógico / digital) y los bancos físicos de E/S. Usted puede mover estas E/S
en el VI FPGA para leer o escribir en esa ubicación. Cualquier control o indicador en el panel frontal del VI
del FPGA se pueden escribir o leer desde el VI en tiempo real.

ni.com/myRIO | 46
9. Abra el VI myRIO-1900 Customized FPGA.vi para ver el código de envío que ese encuentra en el FPGA.
10. Explore el código.
El FPGA target tiene un reloj de 40 MHz configurado en el proyecto de LabVIEW. Cualquier VI creado en
esta parte del árbol se supone que es un VI FPGA, y LabVIEW restringe automáticamente las funciones y
tipos de datos permitidos en el VI. Puede crear un nuevo VI FPGA o modificar el valor predeterminado VI
FPGA.

El VI FPGA predeterminado que se envía con NI myRIO ejemplifica como manejar con seguridad los datos
de E/S del FPGA y prepararlo para ser pasado hasta el VI de tiempo real que se ejecuta en el procesador
ARM. La personalidad del FPGA por omisión maneja todas las entradas y salidas de ambos conectores
MXP y el conector MSP, incluyendo PWM, UART, I2C, SPI y codificador de cuadratura. Este VI de FPGA
por omisión es más que suficiente para aplicaciones básicas en las que los estudiantes trabajan (consultar
el manual de usuario NI myRIO para la asignación de señales por defecto de los conectores).
Para simplificar la arquitectura de proyectos, utilice la personalidad FPGA por omisión y programe
únicamente VIs Host de tiempo real (que se ejecuta en el procesador ARM en el dispositivo NI myRIO) y
Windows VIs (que se ejecuta en la máquina de desarrollo). Sin embargo, los proyectos avanzados pueden
beneficiarse del poder, el determinismo y el coprocesamiento habilitado por una VI FPGA VI.

11. Cierre y guarde el ejercicio

Fin del Ejercicio 4

ni.com/myRIO | 47
Recursos y pasos a seguir
Kits de accesorios
Usted puede comprar los kits de accesorios para facilitar la rápida realización de los proyectos con el
dispositivo NI myRIO. Ver precios y disponibilidad en ni.com/myRIO/accessories.
El Starter Kit incluye un protoboard (que se conecta a los puertos MXP), un kit de cables, LEDs,
interruptores, un altavoz, un micrófono, un motor de corriente continua, codificadores, un sensor de efecto
Hall y un elemento piezoeléctrico. Este kit está diseñado para que los estudiantes comiencen rápidamente
a construir circuitos simples y ampliar su comprensión de las entradas y salidas digitales y analógicas.
El Kit de Mecatrónica incluye todo el contenido del kit de inicio, más motores de corriente continua con
codificadores, un sensor de luz ambiental, un sensor ultrasónico, servomotores, una brújula, un controlador
de motor de corriente continua (puente H), un sensor de proximidad de infrarrojos, un giroscopio de tres
ejes de salida digital y un acelerómetro de tres ejes. Este kit está dirigido a estudiantes que están
construyendo robots de base o de los sistemas mecatrónicos para sus aplicaciones.
El Kit de Embedded Systems (sistemas embebidos) incluye una pantalla LCD UART, un sensor de
temperatura digital, potenciómetros digitales, un sensor de presión barométrica, un teclado, una matriz de
LED, un kit de RFID y una EEPROM SPI. Este kit está diseñado para estudiantes que construyen sistemas
para funcionar desde la computadora como Host (máquina de desarrollo).

Guía NI myRIO Project Essentials

La guía NI myRIO Project Essentials proporciona un recurso de aprendizaje multimedia para los estudiantes
que están completando los proyectos en todos los niveles. Este recurso fue diseñado para ayudar a los
estudiantes a comenzar a utilizar NI myRIO con una amplia variedad de sensores, actuadores y otros
componentes que utilizan el software LabVIEW. La guía se divide en el cableado, requisitos de E/S, teoría
de los dispositivos y la programación por más de 20 dispositivos diferentes comunes a proyectos NI myRIO.
Ver la guía en ni.com/myRIO/project-guide.

Soporte de C para NI myRIO

NI myRIO se basa en la tecnología de NI de E/S reconfigurable (RIO), que le da la capacidad de programar
tanto un procesador que ejecuta un sistema operativo en tiempo real y una FPGA personalizable. Además
del software LabVIEW, el procesador NI myRIO es totalmente programable en C o C++ utilizando la
personalidad del envío por omisión colocado en el FPGA. Más información en ni.com/myRIO/c-support.

Comunidad NI myRIO
Conéctese con otros usuarios de NI myRIO, vea proyectos y descargue códigos de ejemplo en
ni.com/community/myRIO

Hardware personalizado para NI myRIO

El add-on (tabla de circuitos) utilizado en los ejercicios de este taller fue diseñado usando NI Multisim y NI
Ultiboard. Puede encontrar los archivos de diseño para este foro, así como plantillas para comenzar a
diseñar su propio hardware personalizado para NI myRIO en la Comunidad
NI.https://decibel.ni.com/content/docs/DOC-36387

ni.com/myRIO | 48
Pasos siguientes
NI invierte en el éxito de los profesores y estudiantes que utilizan sus productos. Ahora que NI myRIO se
ha introducido y una idea del potencial de este dispositivo está comprendida, el siguiente paso es aprender
más acerca de los sistemas de LabVIEW y en tiempo real. NI ofrece muchos caminos para el aprendizaje
de cómo configurar correctamente el hardware, escribir código y desplegarlo. Los dos más accesibles son
los recursos en línea "Aprender LabVIEW" y "Aprenda RIO", que tienen la intención de enseñar al usuario
los conceptos básicos de LabVIEW. Puede acceder a estos recursos de forma gratuita
ni.com/students/learn. Tanto "Aprenda LabVIEW" y "Aprenda RIO" contienen tutoriales de vídeo y series de
ejercicios simples que pueden acelerar rápidamente la curva de aprendizaje del usuario. Estos dos módulos
son muy recomendables para todos los usuarios de NI myRIO.

©2016 National Instruments. All rights reserved. LabVIEW, National Instruments, NI, ni.com, and NI
miniSystems are trademarks of National Instruments. Other product and company names listed are
trademarks or trade names of their respective companies.

ni.com/myRIO | 49