Universidad Politécnica de Chiapas

Ingeniería Mecatrónica

Programación de periféricos

Catedrático:

Zúñiga Santiz Irving Geovanny

Alumno:

Alvarez Hernández Angel 191070

4to Cuatrimestre “C”

Reporte Práctica 3

21 de marzo de 2020., Suchiapa, Chiapas

1
 índice
1. Introducción .............................................................................................. 3
2. Marco teórico ............................................................................................ 4
I. ¿Qué es LabVIEW? ............................................................................... 4
II. Lenguaje gráfico .................................................................................... 4
III. ¿Qué es Arduino? .............................................................................. 5
IV. Resistencia ......................................................................................... 6
V. Led ......................................................................................................... 6
VI. Push button ........................................................................................ 7
3. Materiales ................................................................................................. 7
Electrónicos ................................................................................................. 7
Virtuales ....................................................................................................... 7
4. Procedimiento ........................................................................................... 7
5. Resultados ................................................................................................ 9
6. Conclusión .............................................................................................. 10
7. Anexos .................................................................................................... 11

2
 1. Introducción
El uso de programación para realizar distintas tareas que requieran de ciertos
requisitos, es decir, que realice una tarea específica con un buen rendimiento.
Requiere de un proceso especifico que se pueden realizar con ayuda de
programación.
Una de las herramientas que se usa en esta práctica es LabVIEW y como nos
daremos cuenta es un ejemplo de que lo que se le llama programación
grafica. Hay muchos más complementos que en conjunto complementan a
mejor manera el uso de esta herramienta por ejemplo el Arduino, que es el
que usaremos como una conexión externa para luego pasar a construir unos
circuitos, simularlos y ver lo que sucede, así también como se realiza la
comunicación con este complemento.
El programa de LabVIEW por sí solo no podrá comunicarse habrá que
descargarle e instalarle drivers que se añadirán a su librería y poder obtener
las herramientas que abrirá y cerraran la comunicación con Arduino, así como
funciones adicionales que nos servirán, algunas se mostraran en esta
práctica.

3
 2. Marco teórico
I. ¿Qué es LabVIEW?
LabVIEW de National Instruments es un Entorno de
desarrollo integrado especializado en informática industrial
y científica. Su particularidad es que se basa en el lenguaje
G (G por Gráfico), creada por Nacional Instrumentos que
es enteramente gráfica. Permite el desarrollo de Imagen 2.1
programas informáticos complejos facilitando al mismo
tiempo la programación y en consecuencia disminuir los plazos de desarrollo.
Gracias a sus librerías de funciones dedicadas a la adquisición de datos, la
instrumentación, al análisis matemático de las mediciones y la visualización,
LabVIEW se dedica especialmente a los bancos de pruebas y mediciones.
LabVIEW permite programar sobre mucho orienta diferentes. Lo mismo
sucede para el material y sobre todo la instrumentación. En efecto, con
LabVIEW y gracias a sus numerosas librerías, podrá intercomunicarse.
II. Lenguaje gráfico
Con LabVIEW, no se programa el software a escribir líneas de códigos con
una sintaxis compleja. La programación se hace con iconos los cuales
representan funcionalidades, ligados entre ellos por cables quienes
representan los flujos de datos (un poco a la manera de una tarjeta electrónica
con sus componentes y circuitos integrados).
Esta representación muy adornada del código es cerca de la concepción
como uno hace: con esquemas; eso, por supuesto, facilita mucho el trabajo
que necesita la programación del concepto. Esta abstracción del lenguaje
gráfico no requiere de ser un experto en programación para desarrollar
softwares sencillos. De igual forma, para software más complejos, el cliente
"profano" en programación, pero experto en su dominio, podrá leer y entender
la idea y así guiar el ingeniero experto en programación.

4
LINX de Digilent/LabVIEW
LINX es un proyecto de fuente abierta de Digilent y
está diseñado para facilitar el desarrollo de
aplicaciones embebidas usando LabVIEW. LINX
incluye VIs para más de 30 de los sensores
embebidos más comunes, así como APIs de
hardware agnóstico para tener acceso a periféricos
Imagen 2.2
como E/S digitales, E/S analógicas, PWM, I2C, SPI y
UART.

Ya sea que usted esté controlando de manera remota un chipKIT o Arduino

por USB/Serial, Ethernet o Wi-Fi o implementando VIs para ejecutar en
BeagleBone Black o Raspberry Pi 2/3, LINX y LabVIEW hacen más fácil
visualizar los datos con los que está trabajando, depurar su código y crear
aplicaciones embebidas avanzadas más rápido que antes.
El toolkit LINX es una herramienta que nos ayuda a enlazar Arduino con
LabVIEW, a través de un firmware (sketch) que debemos cargar nuestra
placa. Esto nos permite realizar la programación de nuestra placa Arduino en
LabVIEW.
III. ¿Qué es Arduino?
El Arduino es una placa basada en un microcontrolador ATMEL. Los
microcontroladores son circuitos integrados en los que se pueden grabar
instrucciones, las cuales las escribes con el lenguaje de programación que
puedes utilizar en el entorno Arduino IDE. Estas instrucciones permiten crear
programas que interactúan con los circuitos de la placa.
El microcontrolador de Arduino posee lo que se llama una interfaz de entrada,
que es una conexión en la que podemos conectar en la placa diferentes tipos
de periféricos. La información de estos periféricos que conectes se trasladará
al microcontrolador, el cual se encargará de procesar los datos que le lleguen
a través de ellos.

5
El tipo de periféricos que puedas utilizar
para enviar datos al microcontrolador
depende en gran medida de qué uso le
estés pensando dar. Pueden ser
cámaras para obtener imágenes,
teclados para introducir datos, o
diferentes tipos de sensores.
También cuenta con una interfaz de
salida, que es la que se encarga de
llevar la información que se ha
procesado en el Arduino a otros
periféricos. Estos periféricos pueden ser
pantallas o altavoces en los que Imagen 2.3
reproducir los datos procesados, pero
también pueden ser otras placas o controladores.
IV. Resistencia
La resistencia es un dispositivo eléctrico que tiene la
particularidad de oponerse al flujo de la corriente. Para
medir el valor de las resistencias se usa un instrumento
llamado óhmetro y las unidades en el S.I es el Ohm.
En general todo material presenta una resistencia
natural, la cual depende de su estructura interna, las
impurezas y composición atómica.
imagen 2.4
V. Led
Un led es un diodo semiconductor que, cuando recibe
tensión, genera luz. Un diodo, a su vez, es una válvula
de dos electrodos que permite el paso de la corriente
eléctrica en un único sentido.
Puede decirse que un led es una fuente lumínica.
Cuando se le aplica tensión a alguna de sus dos
terminales, la recombinación de sus electrones provoca
la liberación de energía en forma de fotones. imagen 2.5

6
 VI. Push button
Un pulsador o simplemente un botón es un mecanismo
de conmutación simple para controlar algún aspecto de
una máquina o un proceso. Los botones se hacen
típicamente de material duro, generalmente plástico o
metal. La superficie suele ser plana o conformada para
acomodar el dedo o la mano humana, de modo que
pueda ser deprimida o empujada fácilmente. Los botones
son más a menudo interruptores sesgados, aunque
incluso muchos botones no desviados requieren un
resorte para volver a su estado no empujado. imagen 2.6

3. Materiales
Electrónicos: led, push button (potenciómetro 100 k ohms o 10 k ohms
opcional), resistencias (220 ohms), protoboard, arduino uno clon y cables
jumper (10 cm y 20 cm).
Virtuales: while loop, stop, or, numeric constant, linx (open, close, digital
write, digital read, simple error handler.vi y leds (5)

4. Procedimiento
1.-Abrimos un nuevo proyecto en LabVIEW. Una vez adentro mandamos a
llamar a las herramientas (OPEN, CLOSE, DIGITAL WIRTE y DIGITAL
READ). de comunicación LINX>> (CLOSE, OPEN)>> PERIPHERALS>>
DIGITAL>> (WRITE, READ). (imagen 4.1,
4.2, 4.3).

>>
imagen 4.2

7
imagen 4.1

>>

imagen 4.3

2.- COM5 para OPEN, se obtiene la constante de error y se hacen las

conexiones como se muestra en la siguiente ilustración (imagen 4.4).

imagen 4.4
3.- Añaden un elemento BOOLENAO (ROUN LED) que va a obtener datos
del DIGITAL READ que va conectado al DIGITAL WRITE (imagen 4.5).

4.- Para terminar se le añade el

arreglo en el botón de paro
STOP como ya se ha venido
haciendo en las prácticas
anteriores (imagen 4.6).

imagen 4.5

8
 imagen 4.6

Imagen 4.7

5. Resultados

Imagen 5.8 circuito de la practica

imagen 2.7 panel frontal

9
 imagen 5.6 diagrama de bloques completo.

imagen 5.7

6. Conclusión
Establecer la comunicación mediante la obtención de una librería como la de
Linx para hacer la comunicación con Arduino es esencial ya que sin ella
simplemente no se podría realizar.
Se aprendió que se pueden realizar lecturas analógicas y digitales (entre
otras más funciones) para ser ejecutados en el programa según los datos que
se obtengan como entrada y modificarlas para mandarlas a las salidas donde
los actuadores realizaran su trabajo, en este caso el actuador fue el led.

10
 7. Anexos

imagen 7.1 armado del circuito. No se tenia al alcance

un push button, pero se utilizó un potenciómetro de imagen 7.2 prueba con el programa cargado a Arduino
100 K ohms.

imagen 7.3 vista amplia del circuito a la parte simulada imagen 7.4
en LabVIEW

11