Académique Documents
Professionnel Documents
Culture Documents
ADQUISICIÓN, PROCESAMIENTO Y
MONITORIZACIÓN DE SEÑALES VÍA XBEE EN
EL ENTORNO LABVIEW
Curso: 2017-2018
Fecha: 23/07/2018
A.P.M. de señales vía XBee en entorno LV 3.CÁLCULOS SOFTWARE
Índice
1 INTRODUCCIÓN ............................................................................................................. 6
2 ENTORNOS DE PROGRAMACIÓN .................................................................................. 7
2.1 ENTORNO ARDUINO UNO IDE “Integrated Development Environment” ............. 7
2.1.1 EDITOR DE CÓDIGO Y COMPILADOR ................................................................. 8
2.2 ENTORNO LabView .............................................................................................. 12
2.2.1 PROGRAMACIÓN EN LABVIEW ........................................................................ 12
3 CARGA DE LIBRERÍAS NECESARIAS PARA LA COMUNICACIÓN ................................... 17
3.1 DESCARGA SOFTWARE NECESARIO..................................................................... 17
4 PROGRAMACIÓN MICROCONTROLADOR ................................................................... 21
4.1 PROGRAMA MAIN ............................................................................................... 21
4.2 LIBRERÍA LIFA BASE COMUNICACIÓN ................................................................. 22
5 IMPLEMENTACIÓN DEL PROGRAMA LABVIEW ........................................................... 25
5.1 DIAGRAMA DE FLUJO ADQUISICIÓN EN LABVIEW .............................................. 25
5.2 DIAGRAMA DE FLUJO LECTURA SENSORES ......................................................... 26
5.2.1 LECTURA TEMPERATURA ................................................................................ 26
5.2.2 LECTURA ANEMÓMETRO ................................................................................ 27
5.2.3 LECTURA SENSOR LUMINOSIDAD ................................................................... 28
5.3 PROGRAMACIÓN MODULAR EN EL ENTORNO LABVIEW .................................... 29
5.3.1 PROGRAMA COMPLETO .................................................................................. 29
5.3.2 BLOQUE INIT.VI ............................................................................................... 30
5.3.3 BLOQUE CLOSE.VI ............................................................................................ 30
5.3.4 BLOQUE ANALOG READ .................................................................................. 31
5.3.5 BLOQUE MULTIPLICADOR ............................................................................... 32
5.3.6 BLOQUE COMPARADOR .................................................................................. 32
5.3.7 BLOQUE REPRESENTACIÓN BOOLEANO.......................................................... 33
5.3.8 BLOQUE BUNDLE ............................................................................................. 34
5.3.9 BLOQUE REPRESENTACIÓN GRÁFICA .............................................................. 35
5.3.10 BLOQUE DE ESCRITURA A FICHERO DE MEDIDA ......................................... 35
5.3.11 BLOQUE MERGE SIGNALS............................................................................ 36
5.3.12 ESTRUCTURA WHILE .................................................................................... 37
6 PANTALLA DE EXPLOTACIÓN ....................................................................................... 38
6.1 GRÁFICOS ............................................................................................................ 38
6.2 REPRESENTACIÓN DIGITAL DE LOS DATOS Y VARIABLES BOOLEANAS ............... 39
6.3 BOTÓN STOP ....................................................................................................... 40
EUITI BILBAO JULIO 2018 2
A.P.M. de señales vía XBee en entorno LV 3.CÁLCULOS SOFTWARE
7 RESULTADOS OBTENIDOS ........................................................................................... 41
7.1 PANTALLA DE EXPLOTACIÓN ............................................................................... 41
7.2 COMPARATIVA PANTALLA EXPLOTACIÓN-HOJA DE CÁLCULO ........................... 42
7.2.1 TEMPERATURA_1 ............................................................................................ 42
7.2.2 TEMPERATURA_2 ............................................................................................ 43
7.2.3 ANEMÓMETRO ................................................................................................ 43
7.2.4 SENSOR DE LUMINOSIDAD .............................................................................. 44
8 CONCLUSIONES ........................................................................................................... 44
9 BIBLIOGRAFÍA .............................................................................................................. 45
Índice de Tablas
Tabla 2.1. Tipos de variables ............................................................................................... 10
Tabla 2.2. Sintaxis Básica ..................................................................................................... 10
Tabla 2.3. Estructuras de Control ........................................................................................ 11
Tabla 2.4. Funciones Básicas ............................................................................................... 11
Tabla 5.1. Factores de multiplicación por entrada .............................................................. 32
Tabla 5.2. Valores Comparativos por Sensor ...................................................................... 33
1 INTRODUCCIÓN
2 ENTORNOS DE PROGRAMACIÓN
Arduino es una plataforma de hardware libre, su diseño como ya es sabido se basa en una
placa con un microcontrolador Atmel AVR. En su arquitectura, como ya se comentó en el
apartado anterior, dispone de varios puertos de entrada/salida, así como un entorno de
desarrollo de fácil empleo para el desarrollo de proyectos.
• Editor de código
• Un compilador
• Un depurador
• Constructor de interfaz gráfica
Los entornos de este tipo, son beneficiosos en el desarrollo paralelo global de las
aplicaciones, permitiendo de este modo la generación de determinadas librerías software para
uso público.
Según se aprecia en la Fig.2.2, el IDE de la plataforma Arduino está constituido por los
siguientes apartados:
• Editor de texto para escribir el código. El lenguaje propio es muy similar al C++
con lo que la adaptación se hace de manera muy natural.
• Área de mensajes. Al igual que en el resto de compiladores más comunes,
aparece una barra de mensajería en la que se reflejan los diferentes errores
posibles en la programación / diseño del programa.
• Visualizador de ejecución. En la parte lateral aparece un icono que permite
acceder a una pantalla de visualización de las variables. Esta acción se lleva a
cabo una vez que el programa ya está corriendo en el microcontrolador.
• Barra de herramientas con botones para las funciones comunes, selección del
puerto de comunicación, selección del dispositivo hardware que se va a
emplear etc.
La denominación empleada para definir los programas compilados en Arduino IDE “sketch”.
Un sketch puede ser compilado y cargado a la placa rápidamente pulsando el botón de la flecha
que se encuentra a la derecha del botón de confirmación.
• “Setup ()”: Acción que se ejecuta una única vez en el programa y configura la
placa Arduino empleada.
• “Loop ()”: Se trata del bucle de programación que se repetirá cíclicamente y
determina la ejecución.
Declaración de Variables
Variables
Concepto Nomenclatura Descripción
Booleana Bool Generalmente 1 Byte de memoria
Carácter Char Generalmente 1 byte 256
Entero sin signo Unsigned short int 2 Bytes (valores desde 0 a 65535)
Entero con signo short int 2 Bytes (valores desde -32768 a 32767)
Entero sin signo largo unsigned long int 4 Bytes (valores desde 0 a 4 294 967 295)
Entero con signo largo long int 4 Bytes (valores desde -2 147 483 648 a 2 147 483 648)
Doble Double 64 Bbits (valores desde 5e-324 a 1,7e-308
Coma flotante Float 32 bits (valores desde -3,4e38 hasta 3,4e38)
Sintaxis Básica
Sintaxis Básica
Concepto Nomenclatura
Cabeceras #define #include
Comentarios // /**/
Delimitadores ; {}
Operaciones Aritméticas - * / % +
Asignación =
Comparativos < > <= >= ==
Booleanas && || !
Operadores de bits & | ^ << >>
Compuestos != ++ -- += -= *=
Estructuras de Control
Concepto Nomenclatura
Condicionales if if…else switch case
Saltos for while do…while
Bucles (Cíclicos) goto return break
Tabla 2.3. Estructuras de Control
Funciones Básicas
Funciones Básicas
Concepto Nomenclatura Descripción
analogReference() Configuración tensión referencia de entrada
E/S Analógica analogRead() Lectura de señal analógica
analogWrite() Escritura en Pin analógico
pin Mode () Definición del comportamiento del pin como E/S
E/S Digital digitalWrite() Escritura en Pin Digital
digitalRead() Lectura de señal digital
delay() Definición de retardo del bucle
Tiempo
delayMicroseconds() Definición de retardo del bucle microsegundos
min(x, y) Calcula el mínimo de 2 números
max(x, Y) Calcula el máximo de 2 números
Matemáticas abs(x) Devuelve el valor absoluto
sqrt(x) Devuelve la raiz cuadrada de un número
constrain(x, a, b) Restricción a un rango
sin(rad) Calcula el Seno
Trigonométricas cos(rad) Calcula el Coseno
tan(rad) Calcula la tangente
Aleatoriedad randomSeed() Genera números aleatorios con semilla misma secuencia
lowByte() Extrae el Byte inferior (derecha)
highByte() Extrae el Byte superior (izquierda)
bitRead() Lectura de un cierto número de bits
Administracion Bits bitWrite() Escritura de un cierto número de bits
bitSet() Establece un valor 1 a un bit concreto
bitClear() Establece un valor 0 a un bit concreto
bit() Calcula el valor de un bit específico
attachlnterrupt() Activación Interrupción
Interrupciones
detachInterrupt() Desactivación Interrupción
En ocasiones y dependiendo del perfil del programador, que la herramienta sea tan
evidente en su programación, puede generar desconocimiento en el desarrollo de aplicaciones
complejas. El programador puede abstraerse de tal modo que desconozca lo que internamente
hacen los bloques.
Este hecho, permite al diseñador invertir más tiempo en el diseño y desarrollo de la interfaz
gráfica con la que va a interactuar el usuario final.
• Panel Frontal → Se trata de una interfaz gráfica muy útil para el usuario. En ella se
observan las variables implementadas en el diagrama de bloques y su comportamiento
durante la simulación. Como se puede observar, existen diferentes gráficos que
permiten simular indicadores analógicos y digitales. Empleando el denominado LabView
Real Time, sería posible implementar simulaciones en tiempo real útiles en
determinadas aplicaciones.
Dentro del diagrama de bloques, existen diferentes paletas para realizar la programación.
Cada una de ellas tiene un ámbito y de manera general estas serían las más representativas.
Paleta de Controles
https://www.arduino.cc/en/Main/Software
http://jki.net/vipm/download
http://www.ni.com/es-es/support.html
4 PROGRAMACIÓN MICROCONTROLADOR
Como se ha explicado con anterioridad, se carga la librería Lifa Base.Ino en el Arduino para
establecer la comunicación correspondiente con LabView. Vamos a ver en profundidad la
ejecución del programa que acciones contempla en el microcontrolador una vez cargado.
#include <Wire.h> “Librería que permite comunicarse con dispositivos I2C / TWC. En el caso del
Arduino Uno los pines correspondientes serían → A4(SDA), A5(SCL)”
#include <SPI.h> “Librería que permite la comunicación con dispositivos vía SPI puerto serie. En
el caso que nos aborda será la metodología que emplearemos en la comunicación”
#include <Servo.h> “Librería que permite a Arduino el control de los servomotores de tipo RC”
#include "LabVIEWInterface.h" “Librería que se explica luego para la comunicación”
void setup ()
{ “Inicialización del Puerto serie con la frecuencia predeterminada”
syncLV ();
}
“El bucle principal, se ejecuta constantemente en Arduino. Recibe y procesa los comandos
procedentes de LabView constantemente”
void loop ()
{ “Analiza los comandos recibidos de LabView y los procesa”
checkForCommand ();
if(acqMode==1)
{
sampleContinously ();
}
}
Como se puede observar en el flujograma, una vez que se inicia el programa, lo primero
que se hace es configurar el puerto de comunicación a través del cual se conecta el
microcontrolador (puerto COMX). A la vez también se realiza la configuración del tipo de
conexión y el dispositivo. En el apartado 5.2 se observará como se realizan las configuraciones
con la programación modular de LabView.
Una vez configuradas las entradas (acción que solamente se ejecutará una vez), se inicia el
proceso de lectura de las señales. En este caso y para simplificar el diagrama de flujo completo,
no se han pintado todas las acciones que lleva a cabo el programa por lo que a continuación se
adjunta un flujograma un poco más pormenorizado de la parte de la lectura. Se diferencian 3
apartados (lectura temperatura, lectura anemómetro y lectura sensor de luminosidad).
En el caso de la lectura del anemómetro, solo existe una consigna que limita la acción. Si el
viento en el entorno sobrepasa cierta velocidad (50 km/h), se ejecutará la acción de retraer el
toldo para el sol que se encuentra en la fachada del edificio. Al igual que en el caso anterior, a
futuro se podría implementar una salida que alimentara el motor del toldo.
En el caso de la lectura del sensor de luminosidad al igual que en el anemómetro, solo existe
una consigna que limita la acción. Si la luminosidad exterior baja de un grado porcentual
calculado empíricamente (no se basa en una variable física real ya que el grado de luminosidad
se ha calculado desde 0 a 100% del rango completo que abarcaba el sensor implementado.
Al igual que en los anteriores, a futuro se podría generar un actuador que habilite el
encendido de las luces cuando sobrepase el rango establecido.
El bloque analog read, es el encargado de tomar las muestras que adquiere el Arduino a
través de sus entradas. En cada ciclo completo de programa recibe una muestra por cada una
de las entradas. Estas se ejecutan en paralelo por cada ciclo y cada una de ellas procesa la
información correspondiente en los bloques posteriores que veremos a continuación.
Como se puede ver en la figura 5.7, en la configuración de los módulos de lectura analógica,
se define una constante que refleja el pin de la entrada correspondiente. En los ejemplos que
aparecen, van de [0-3] y cada una recibe la información correspondiente al sensor cableado en
cada entrada.
Por otra parte, también tienen conectadas virtualmente las líneas de error y comunicación
correspondientes a cada una de ellas.
Por último, aparece un conector naranja en la parte derecha de cada uno de ellos. En
LabView la cromática de los cables indica el tipo de variable que transportan y en el caso del
color naranja se trata de un valor de tipo float. Se trata del voltaje de entrada que se obtiene a
través de las entradas analógicas. Esta variable como se verá a continuación, va conectada a
unos operadores para cada una de las entradas que permitirán visualizar las gráficas en el Front
Panel.
El bloque multiplicador realiza la multiplicación escalar entre dos variables de tipo float
independientes. En el caso del proyecto desarrollado, se emplea para acomodar la señal de
entrada (que es una tensión variable en rangos diferente) al dato que se quiere mostrar
gráficamente.
Las conversiones por cada sensor son diferentes por lo que se han de implementar
diferentes multiplicaciones escalares para cada uno. Como se observa en la figura 5.8, una de
las entradas viene del bloque Analog Read (salida del voltaje Float) y la otra es un escalar con el
factor de multiplicación necesario. Los factores de multiplicación por cada una de las entradas
se exponen en la tabla adjunta.
El bloque comparativo permite, valga la redundancia, comparar dos valores de tipo float y
otorgar una salida Booleana otorgando el resultado. En el caso de ser afirmativo, la salida
otorgada por el bloque será un “Verdadero”, en caso contrario devolverá un “Falso”. En la figura
adjunta, 5.9, se representa la comparativa que realiza para la adquisición de los datos sensor de
temperatura 1.
En la tabla 5.2, aparecen las comparativas para cada una de las entradas. Dependiendo
del tipo de sensor se establecen unos limitantes para ejecutar las acciones.
Para evitar tener que emplear un bloque gráfico por cada entrada y con el fin de aunar los
gráficos en una representación combinada más acorde, se emplea el bloque Bundle.
Como se puede observar en la figura 5.11, a la entrada del bloque hay 4 variables float que
entran por cada uno de los 4 canales diferenciados y se extrae un único hilo. El hilo marrón y de
representación gruesa como aparece obedece al tipo forma de onda, ya que se unirá a posteriori
a un bloque de representación gráfica.
Como se puede observar existe una entrada a través de la cual se introducen las señales
provenientes de los sensores. Como solo se dispone de una entrada, se conectarán empleando
el bloque merge signals que se detalla posteriormente. La configuración del bloque
internamente se realiza de acuerdo a la figura 5.13.
El bloque merge signals permite unir en una única salida los siguientes tipos de señales,
así como reescalar la función para añadir más entradas:
Como se ha observado en la figura 5.4, que mostraba el programa completo, alrededor del
programa entre los bloques Init.VI y Close.VI, existe una estructura de tipo while. Esta
estructura, al igual que en el resto de lenguajes de programación existentes, se utiliza para
realizar operaciones repetitivas.
Por defecto, ejecutará el subprograma escrito en su interior hasta que la variable Booleana
que aparece al lado del punto rojo pase a convertirse en un “Falso”. El código equivalente en
programación sería:
Do
En este caso, la variable que genera la parada del bucle While, es un botón que aparece en
la pantalla de explotación como “Stop”. Eso permitirá en un momento dado parar la ejecución.
6 PANTALLA DE EXPLOTACIÓN
6.1 GRÁFICOS
La representación gráfica de las señales de cada sensor se realiza, como se puede observar,
de manera independiente para cada una de ellas.
Tal y como se ha comentado en la explicación del bucle “While” del apartado 5.3.12, la
condición que hace que se detenga la ejecución puede ser configurada como un botón de “Stop”
que aparezca en la pantalla de explotación. Esto es exactamente lo que se ha hecho y su
representación gráfica aparece en la figura 6.4.
7 RESULTADOS OBTENIDOS
Como se observa durante la ejecución del programa, se van registrando los datos en sendos
gráficos. El comportamiento de los sensores es parejo ya que se encuentran físicamente cerca
en la placa. La fuente de calor empleada para elevar la temperatura es un secador e incidía
directamente en los dos por eso el comportamiento parejo. Al llegar a la consigna superior,
como se observa en la figura, se da la acción de encender el climatizador.
Para el sensor de luminosidad, se pasaba la mano por delante forzando la sombra para ver
como a medida que disminuye la luminosidad, baja la medición en el gráfico.
𝑇 = 50 𝑚𝑠
Como se observa no es un registro muy rápido, pero para la aplicación que nos ocupa es
suficiente. Si se quisiera realizar un análisis más rápido, sería necesario realizar una
comunicación vía puerto paralelo.
Si tras extraer los datos en hoja de cálculo se grafican se obtiene el mismo resultado que
en la pantalla de explotación con lo que la extracción es óptima.
7.2.1 TEMPERATURA_1
60
50
40
30
20
10
0
99 299 499 699 899 1099
7.2.2 TEMPERATURA_2
60
50
40
30
20
10
0
99 299 499 699 899 1099
7.2.3 ANEMÓMETRO
120
100
80
60
40
20
0
99
1027
1056
1085
1114
244
389
534
128
157
186
215
273
302
331
360
418
447
476
505
563
592
621
650
679
708
737
766
795
824
853
882
911
940
969
998
100
80
60
40
20
0
99
1027
1056
1085
1114
244
505
766
128
157
186
215
273
302
331
360
389
418
447
476
534
563
592
621
650
679
708
737
795
824
853
882
911
940
969
998
Figura 7.4. Comparativa Sensor Luminosidad
8 CONCLUSIONES
9 BIBLIOGRAFÍA
• Essic. J. (2013). LabVIEW for Scientists and Engineers. New York. Oxford University Press.
• Swartch. M (2014). Programming Arduino with LabView. Packt Publising.
• Lozano Equisoain. D. (2017) Arduino Práctico. Anaya.
[1] https://www.arduino.cc/en/Main/Software
[2] http://jki.net/vipm/download
[3] http://www.ni.com/es-es/support.html
[4] https://www.arduino.cc/
[5] http://www.ni.com/es-es/support.html
[6] https://forum.arduino.cc/index.php?board=32.0
[7] http://www.avr-tutorials.com/digital/
[8] http://geekytheory.com/arduino-y-labview
[9] http://neutrongeek.wordpress.com/tag/control-de-le-con-arduino-y-labview/