Capítulo 1
Introducción a LabVIEW. Entorno ......................................................... 21
1.1. Entorno ............................................................................................. 22
1.2. Menús (paletas) ................................................................................. 26
1.2.1. Menú de herramientas ............................................................. 26
1.2.2. Controles ................................................................................ 27
1.2.2.1. Personalización de controles ...................................... 30
1.2.3. Funciones ................................................................................ 32
1.2.4. Personalización de los menús .................................................. 35
1.3. Creación de programas .................................................................. 36
1.4. Flujo de ejecución .......................................................................... 37
1.5. VI y subVI ..................................................................................... 39
1.5.1. Librerías ............................................................................... 43
1.5.2. PolimorÞsmo ........................................................................ 44
1.6. Proyectos ....................................................................................... 46
1.7. Depuración de código .................................................................... 47
1.8. Otras herramientas ......................................................................... 50
1.8.1. Snippet ................................................................................. 50
1.8.2. Opciones .............................................................................. 51
1.8.3. Jerarquía ............................................................................... 52
1.8.4. Ventana de navegación ......................................................... 52
1.8.5. Compilación masiva ............................................................. 53
1.8.6. Búsqueda y comparación ..................................................... 53
1.8.7. Seguridad ............................................................................. 53
1.8.8. Ejemplos .............................................................................. 54
1.9. Ejercicios ....................................................................................... 54
1.10. Bibliografía .................................................................................. 55
7
LabVIEW: entorno gráfico de programación
Capítulo 2
Estructuras ................................................................................................ 57
2.1. SEQUENCE ..................................................................................... 58
2.2. CASE ................................................................................................ 59
2.3. WHILE ............................................................................................. 61
2.4. FOR ................................................................................................... 64
2.5. EVENT ............................................................................................. 65
2.6. TIMED LOOP y TIMED SEQUENCE ............................................ 68
2.7. DISABLE STRUCTURE ................................................................. 71
2.8. FORMULA NODE ........................................................................... 72
2.9. Scripts ............................................................................................... 74
2.10. Ejemplos ......................................................................................... 76
2.10.1. Ejemplo I: Filtro promediador ........................................... 76
2.10.1.1. Explicación teórica .............................................. 76
2.10.1.2. Código ................................................................. 77
2.10.1.3. Resultado ............................................................. 78
2.10.2. Ejemplo II: Generación de números primos ...................... 79
2.10.2.1. Explicación teórica ............................................. 79
2.10.2.2. Código ................................................................ 80
2.10.2.3. Resultado ............................................................ 81
2.10.3. Ejemplo III: Bingo ............................................................. 81
2.10.3.1. Explicación teórica ............................................. 81
2.10.3.2. Código ................................................................ 81
2.10.3.3. Resultado ............................................................ 83
2.11. Ejercicios ............................................................................... 83
2.12. Bibliografía ........................................................................... 84
Capítulo 3
Tipos de datos ............................................................................................ 85
3.1. Tipos de terminales ........................................................................... 85
3.2. Tipos de datos ................................................................................... 87
3.2.1. Boolean ................................................................................... 88
3.2.2. Numeric ................................................................................... 88
3.2.3. Strings ..................................................................................... 91
3.2.3.1. Transformaciones número-texto ................................. 92
3.2.4. Path .......................................................................................... 94
3.2.5. Arrays ...................................................................................... 94
8
Índice
Capítulo 4
Ficheros .................................................................................................... 109
4.1. Ficheros de texto ............................................................................. 109
4.1.1. Ejemplo I: Ficheros de texto y binarios ................................ 113
4.1.2. Ejemplo II: Lotería ................................................................ 114
4.2. Ficheros de conÞguración ............................................................... 115
4.2.1. Ejemplo ................................................................................. 116
4.3. Ficheros XML ................................................................................. 117
4.3.1. Ejemplo I: Agenda ................................................................. 119
4.3.2. Ejemplo II: Buscador en la agenda ....................................... 121
9
LabVIEW: entorno gráfico de programación
Capítulo 5
Comunicación serie ................................................................................. 137
5.1. Introducción .................................................................................... 137
5.2. Historia ........................................................................................... 138
5.3. RS-232 ............................................................................................ 138
5.3.1. Conectores ............................................................................. 139
5.3.2. Puertos ................................................................................... 140
5.3.3. Handshake ............................................................................. 141
5.3.4. Otros estándares .................................................................... 141
5.4. Comunicaciones serie en LabVIEW ............................................... 142
5.4.1. VISA ...................................................................................... 145
5.5. Ejemplos ......................................................................................... 147
5.5.1. Ejemplo I: Comunicación con un microcontrolador ............. 147
5.5.1.1. Explicación teórica ................................................... 147
5.5.1.2. Código del microcontrolador .................................... 148
5.5.1.3. Código en LabVIEW ................................................ 149
5.5.1.4. Resultado .................................................................. 150
5.5.2. Ejemplo II: Control de un instrumento de laboratorio .......... 150
5.5.2.1. Explicación teórica ................................................... 150
5.5.2.2. Código ....................................................................... 151
5.5.2.3. Resultado .................................................................. 152
10
Índice
Capítulo 6
GPIB ......................................................................................................... 155
6.1. Introducción .................................................................................... 155
6.2. El estándar IEEE 488.1 ................................................................... 157
6.2.1. Cableado ................................................................................ 158
6.2.2. Handshake ............................................................................. 159
6.2.3. Funcionamiento ..................................................................... 160
6.3. El estándar IEEE 488.2 ................................................................... 162
6.4. SCPI ................................................................................................ 167
6.5. GPIB en LabVIEW ......................................................................... 169
6.5.1. VISA ...................................................................................... 172
6.5.2. Drivers ................................................................................... 173
6.6. Ejemplos ......................................................................................... 175
6.6.1. Ejemplo I: Escáner del bus .................................................... 175
6.6.1.1. Explicación teórica ................................................... 175
6.6.1.2. Código ...................................................................... 175
6.6.1.3. Resultado .................................................................. 176
6.6.2. Ejemplo II: Osciloscopio Tektronix TDS210 ........................ 177
6.6.2.1. Explicación teórica ................................................... 177
6.6.2.2. Código ...................................................................... 177
6.6.2.3. Resultado .................................................................. 183
6.6.3. Ejemplo III: Uso de VI Express, Instrument I/O Assistant ... 183
6.6.3.1. Explicación teórica ................................................... 183
6.6.3.2. Procedimiento ........................................................... 184
6.6.4. Ejemplo IV: Generador HP 33120A usando un driver .......... 186
6.7. Ejercicios ........................................................................................ 186
6.8. Bibliografía ..................................................................................... 187
11
LabVIEW: entorno gráfico de programación
Capítulo 7
Adquisición de datos ............................................................................... 189
7.1. Introducción ..................................................................................... 189
7.2. Adquisición de señales analógicas .................................................. 190
7.2.1. ConÞguraciones de terminales .............................................. 190
7.2.2. Conversión a digital .............................................................. 193
7.2.3. Procesamiento ....................................................................... 194
7.3. Tarjeta de adquisición de datos NI PCI-6221M .............................. 195
7.4. Measurement & Automation Explorer (MAX) ............................... 197
7.5. DAQ en LabVIEW ......................................................................... 199
7.5.1. DAQ Assistant ....................................................................... 203
7.6. Ejemplos ......................................................................................... 204
7.6.1. Ejemplo I: Crear un osciloscopio y un generador
de funciones con la tarjeta PCI-6221M ................................. 204
7.6.1.1. Explicación teórica ................................................... 204
7.6.1.2. Código ...................................................................... 204
7.6.1.3. Resultado .................................................................. 205
7.6.2. Ejemplo II: Medida de la temperatura ................................... 206
7.6.2.1. Explicación teórica ................................................... 206
7.6.2.2. Código ...................................................................... 208
7.6.3. Ejemplo III: Control de un motor paso a paso ...................... 209
7.6.3.1. Explicación teórica ................................................... 209
7.6.3.2. Código ...................................................................... 211
7.6.3.3. Resultados ................................................................. 212
7.7. Ejercicios ........................................................................................ 212
7.8. Bibliografía ..................................................................................... 214
Capítulo 8
TCP y UDP................................................................................................ 215
8.1. TCP/IP ............................................................................................. 215
8.1.1. Nivel de red ........................................................................... 217
8.1.2. Nivel de transporte ................................................................ 217
8.1.3. Nivel de aplicación ................................................................ 218
8.2. Arquitecturas habituales .................................................................. 219
8.3. TCP/IP en LabVIEW ...................................................................... 220
8.4. HTTP en LabVIEW ........................................................................ 222
12
Índice
Capítulo 9
VI Server y comunicaciones avanzadas ................................................ 233
9.1. Acceso remoto ................................................................................ 233
9.1.1. Paneles remotos ..................................................................... 233
9.1.2. Publicación en web ............................................................... 234
9.2. Enlaces de datos .............................................................................. 236
9.2.1. DataSocket ............................................................................ 237
9.2.1.1. API ............................................................................ 238
9.2.1.2. Método directo .......................................................... 239
9.2.2. Shared variables .................................................................... 240
9.2.3. Data Binding ......................................................................... 242
9.2.4. Networks Streams ................................................................. 243
9.3. VI Server ......................................................................................... 245
9.4. Servicios web .................................................................................. 249
9.4.1. Servicios web en LabVIEW .................................................. 251
9.5. Ejemplos ......................................................................................... 254
9.5.1. Ejemplo I: Chat ..................................................................... 254
9.5.1.1. Explicación teórica ................................................... 254
9.5.1.2. Código ...................................................................... 254
9.5.1.3. Resultados ................................................................. 254
13
LabVIEW: entorno gráfico de programación
Capítulo 10
Sincronización y multihilo ...................................................................... 261
10.1. Multihilo en LabVIEW ................................................................. 262
10.1.1. Sistemas de ejecución ....................................................... 263
10.1.2. Prioridades ........................................................................ 264
10.1.3. VI reentrantes .................................................................... 266
10.1.4. Pipeline .............................................................................. 268
10.1.5. Paralelismo ........................................................................ 270
10.2. Multinúcleo ................................................................................... 272
10.2.1. FOR ................................................................................... 272
10.2.2. TIMED LOOP ................................................................... 274
10.3. Sincronización .............................................................................. 275
10.3.1. Occurrences ....................................................................... 275
10.3.2. Semáforos .......................................................................... 276
10.3.3. NotiÞcaciones .................................................................... 277
10.3.4. Colas .................................................................................. 278
10.3.5. Rendezvous ....................................................................... 280
10.4. Problemas típicos de la programación multihilo .......................... 282
10.4.1. Condición de carrera ......................................................... 283
10.4.2. Inanición ............................................................................ 284
10.4.3. Inversión de prioridad ....................................................... 285
10.4.4. Interbloqueo ...................................................................... 287
10.5. Eventos ......................................................................................... 288
14
Índice
Capítulo 11
Modelos de programación ...................................................................... 293
11.1. Estructuras de interfaz de usuario ................................................. 293
11.2. Temporización ............................................................................... 296
11.3. Manejo de errores ......................................................................... 298
11.4. Máquinas de estado ....................................................................... 303
11.4.1. Máquinas de estados en LabVIEW ................................... 306
11.4.2. Ejemplo: Máquina expendedora ....................................... 310
11.4.2.1. Explicación teórica ............................................. 310
11.4.2.2. Código ................................................................ 312
11.4.2.3. Resultados .......................................................... 312
11.5. Comunicaciones ............................................................................ 313
11.5.1. Maestro/esclavo ................................................................. 313
11.5.2. Productor/consumidor ....................................................... 314
11.5.3. Ejemplo: keylogger ........................................................... 314
11.5.3.1. Explicación teórica ............................................. 314
11.5.3.2. Código ................................................................. 314
11.5.3.3. Resultado ............................................................ 315
11.6. Orientado a objetos ....................................................................... 316
11.6.1. Programación orientada a objetos en LabVIEW ............... 320
11.6.1.1. Ejemplo: Fichas de empleados ........................... 322
11.7. Scripting ........................................................................................ 326
11.7.1. Introducción ...................................................................... 326
11.7.2. XNodes .............................................................................. 328
11.7.3. Ejemplo I ........................................................................... 330
11.7.3.1. Código ................................................................ 330
11.7.4. Ejemplo II: Metaprograma ................................................ 331
11.7.4.1. Código ................................................................ 331
11.7.4.2. Resultado ............................................................ 333
11.8. Ejercicios ...................................................................................... 334
11.9. Bibliografía ................................................................................... 334
15
LabVIEW: entorno gráfico de programación
Capítulo 12
Código externo ........................................................................................ 335
12.1. Librerías externas .......................................................................... 335
12.1.1. CIN .................................................................................... 338
12.1.2. Librerías compartidas en LabVIEW ................................. 338
12.1.3. Ejemplo I: Creación de una DLL y su uso en LabVIEW .... 341
12.1.3.1. Explicación teórica ............................................. 341
12.1.3.2. Código en C++ ................................................... 342
12.1.3.3. Código en LabVIEW .......................................... 342
12.1.4. Ejemplo II: Wait ( s) ......................................................... 343
12.1.4.1. Explicación teórica ............................................. 343
12.1.4.2. Código ................................................................ 343
12.1.4.3. Resultados .......................................................... 345
12.1.5. Ejemplo III: CIN ............................................................... 346
12.1.5.1. Explicación teórica ............................................. 346
12.1.5.2. Código en C++ ................................................... 346
12.1.5.3. Código en LabVIEW .......................................... 347
12.2. Comunicaciones entre aplicaciones .............................................. 347
12.2.1. ActiveX ............................................................................. 347
12.2.1.1. ActiveX en LabVIEW ........................................ 348
12.2.1.2. Ejemplo: Creación de un control ActiveX
y su uso en LabVIEW ........................................ 350
12.2.2. .NET .................................................................................. 354
12.2.2.1. .NET en LabVIEW ............................................. 357
12.2.2.2. Ejemplo I: Creación de una librería
de clases .NET y su uso en LabVIEW ............... 357
12.2.2.3. Ejemplo II: Navegador Web ............................... 361
12.3. Creación de librerías y ejecutables con LabVIEW ....................... 363
12.4. Ejercicios ...................................................................................... 364
12.5. Bibliografía ................................................................................... 364
Capítulo 13
Optimización de la interfaz .................................................................... 365
13.1. Elementos del Panel Frontal ......................................................... 365
13.1.1. Otros tipos de gráÞcos ....................................................... 365
13.1.2. Subpaneles ........................................................................ 369
16
Índice
Capítulo 14
Optimización del código ......................................................................... 389
14.1. Diseño de la aplicación ................................................................. 389
14.2. Estilo del código ........................................................................... 393
14.2.1. Organización ..................................................................... 393
14.2.2. Comentar el código ........................................................... 394
14.2.3. VI ....................................................................................... 395
14.2.4. Cableado ............................................................................ 396
14.3. Control de código ......................................................................... 397
14.3.1. Ejemplo en LabVIEW ....................................................... 398
14.4. Mejorar el rendimiento ................................................................. 399
14.4.1. Herramientas ..................................................................... 399
14.4.2. Manejo de memoria .......................................................... 400
14.4.2.1. Buffers ................................................................ 400
14.4.2.2. In Place Element Structure ................................. 401
14.4.2.3. Paso de valores por referencia ............................ 401
17
LabVIEW: entorno gráfico de programación
Capítulo 15
Otras plataformas ................................................................................... 413
15.1. PDA ............................................................................................... 413
15.1.1. Ejemplo: Escáner de dispositivos Bluetooth ..................... 414
15.1.1.1. Explicación teórica ............................................. 414
15.1.1.2. Código ................................................................ 414
15.1.1.3. Resultados .......................................................... 415
15.2. FPGA ............................................................................................ 416
15.2.1. Ejemplo: Luces del coche fantástico en CompactRIO ...... 417
15.2.1.1. Explicación teórica ............................................. 417
15.2.1.2. Código ................................................................ 418
15.2.1.3. Resultados .......................................................... 419
15.3. Bus PXI ......................................................................................... 419
15.3.1. PCI .................................................................................... 420
15.3.2. PXI .................................................................................... 421
15.3.3. Ejemplo I: Lectura de los registros de conÞguración ....... 422
15.3.3.1. Explicación teórica ............................................. 422
15.3.3.2. Código ................................................................ 423
15.3.3.3. Resultado ............................................................ 424
15.3.4. Ejemplo II: Generación y adquisición de señales ............. 424
15.3.4.1. Explicación teórica ............................................. 424
15.3.4.2. Código ................................................................ 425
15.3.4.3. Resultados .......................................................... 425
15.3.5. Ejemplo III: Medida de capacidad .................................... 426
18
Índice
Capítulo 16
LabWindows/CVI ................................................................................... 429
16.1. Introducción .................................................................................. 429
16.2. Librerías ........................................................................................ 430
16.3. Generación automática de código ................................................. 431
16.4. Creación de GUI ........................................................................... 433
16.5. Manejo de eventos ........................................................................ 435
16.6. Ejemplo ......................................................................................... 437
16.6.1. Interfaz .............................................................................. 437
16.6.2. Lógica ................................................................................ 438
16.6.3. Resultados ......................................................................... 442
16.7. Ejercicio ........................................................................................ 443
16.8. Bibliografía ................................................................................... 443
Capítulo 17
Measurement Studio ............................................................................... 445
17.1. Introducción .................................................................................. 445
17.2. Clases y controles ......................................................................... 447
17.3. Ejemplos ....................................................................................... 448
17.3.1. Ejemplo I: GráÞcas ........................................................... 448
17.3.2. Ejemplo II: Filtros digitales y FFT .................................... 451
17.3.3. Ejemplo III: Proyecto web ................................................ 454
17.4. Ejercicio ........................................................................................ 457
17.5. Bibliografía ................................................................................... 457
19
LabVIEW: entorno gráfico de programación
Capítulo 18
Measurement Studio ............................................................................... 459
18.1. Introducción .................................................................................. 459
18.2. Ejemplos ....................................................................................... 460
18.2.1. Ejemplo I: Datos electrocardiográÞcos en un Þchero CSV ... 460
18.2.1.1. Navigator ............................................................ 460
18.2.1.2. View ................................................................... 462
18.2.1.3. Analysis .............................................................. 462
18.2.1.4. Report ................................................................. 464
18.2.1.5. Scripts .................................................................. 465
18.3. Conectividad con LabVIEW ......................................................... 467
18.4. Bibliografía ................................................................................... 467
Capítulo 19
TestStand .................................................................................................. 469
19.1. Introducción .................................................................................. 469
19.2. Ejemplo ......................................................................................... 471
19.2.1. Variables ............................................................................ 473
19.2.2. Estructuras ......................................................................... 474
19.3. Conectividad ................................................................................. 476
19.4. Herramientas avanzadas ............................................................... 476
19.5. Bibliografía ................................................................................... 477
20