Tipo: Libro impreso / Print book
Encuadernación / Binding: Tapa blanda / Paperback
Tamaño / Size: 17 x 23 cm
Páginas / Pages: 718
Resumen / Summary:
Autor / Author: José Rafael Lajara Viscaíno, José Pelegrí Sebastiá
Editorial / Publisher: Alfaomega
Entrega / Delivery : Nacional / International
Envio desde / Ships from: Colombia
Condición / Condition: Nuevo / New
Tabla de contenido / Table of contents: 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
8
LabVIEW: entorno gráfi co 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
9
Índice
3.2.6. Clusters .................................................................................... 96
3.2.7. Waveforms ............................................................................... 97
3.2.8. Referencias .............................................................................. 97
3.2.9. Variant ..................................................................................... 97
3.2.10. Dynamic ................................................................................ 98
3.3. Manipulación de datos ...................................................................... 98
3.3.1. Manipulación de bytes y bits ................................................... 98
3.2.3. Otras transformaciones ............................................................ 98
3.3.3. Type Cast ................................................................................. 99
3.4. Variables y propiedades .................................................................. 100
3.4.1. Variables locales .................................................................... 100
3.4.2. Variables globales .................................................................. 101
3.4.3. Variables compartidas ........................................................... 102
3.4.4. Nodos de propiedades y métodos .......................................... 103
3.4.5. Referencias ............................................................................ 105
3.5. Ejemplos ......................................................................................... 105
3.5.1. Ejemplo I: varios métodos para convertir
la representación ASCII a su valor ........................................ 105
3.5.1.1. Explicación teórica ................................................... 105
3.5.1.2. Código ...................................................................... 105
3.5.2. Ejemplo II: Carrera de fórmula 1 .......................................... 106
3.5.2.1. Explicación teórica ................................................... 106
3.5.2.2. Código ...................................................................... 107
3.5.2.3. Resultados ................................................................. 107
3.6. Ejercicios ........................................................................................ 108
3.7. Bibliografía ..................................................................................... 108
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
10
LabVIEW: entorno gráfi co de programación
4.4. Ficheros de imagen ......................................................................... 123
4.4.1. Ejemplo ................................................................................. 123
4.5. Ficheros de sonido .......................................................................... 124
4.5.1. Ejemplo I: Lectura de Þ chero y procesado ............................ 124
4.5.2. Ejemplo II: Adquisición y VIs Express ................................. 125
4.6. Acceso al registro de Windows ....................................................... 127
4.6.1. Ejemplo: Registro de LabVIEW ........................................... 128
4.7. Reports ............................................................................................ 128
4.7.1. Ejemplo: Generación de un Þ chero PDF ............................... 129
4.8. Storage ............................................................................................ 130
4.8.1. Ejemplo ................................................................................. 131
4.9. Datalog ............................................................................................ 132
4.9.1. Ejemplo ................................................................................. 133
4.10. Waveform ...................................................................................... 134
4.11. Ejercicios ...................................................................................... 134
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
11
Índice
5.5.3. Ejemplo III: Manejo de eventos ............................................ 152
5.5.3.1. Explicación teórica ................................................... 153
5.5.3.2. Código ...................................................................... 153
5.6. Ejercicios .................................................................................. 153
5.7. Bibliografía .............................................................................. 154
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
12
LabVIEW: entorno gráfi co 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
13
Índice
8.5. Ejemplos ......................................................................................... 225
8.5.1. Ejemplo I: Servidor de Telnet ............................................... 225
8.5.1.1. Explicación teórica de Telnet ................................... 225
8.5.1.2. Código ...................................................................... 225
8.5.1.3. Resultados ................................................................. 226
8.5.2. Ejemplo II: Transmisión de voz ............................................ 227
8.5.2.1. Explicación teórica ................................................... 227
8.5.2.2. Código ...................................................................... 227
8.5.2.3. Resultados ................................................................. 228
8.5.3. Ejemplo III: Obtener Þ cheros a través de HTTP ................... 228
8.5.3.1. Explicación teórica ................................................... 228
8.5.3.2. Código ...................................................................... 229
8.5.3.3. Resultados ................................................................. 230
8.6. Ejercicios ........................................................................................ 231
8.7. Bibliografía ..................................................................................... 231
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
14
LabVIEW: entorno gráfi co de programación
9.5.2. Ejemplo II: Controlar Decorations ........................................ 255
9.5.2.1. Explicación teórica ................................................... 255
9.5.2.2. Código ...................................................................... 255
9.5.3. Ejemplo III: Rendimiento de VI ............................................ 257
9.5.3.1. Explicación teórica ................................................... 257
9.5.3.2. Código ...................................................................... 257
9.5.3.3. Resultados ................................................................. 257
9.5.4. Ejemplo IV: Sistema distribuido con variables compartidas ... 258
9.5.4.1. Explicación teórica ................................................... 258
9.5.4.2. Código ...................................................................... 258
9.6. Ejercicios ........................................................................................ 260
9.7. Bibliografía ..................................................................................... 260
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
15
Índice
10.5.1. Ejemplo I: Eventos dinámicos .......................................... 289
10.5.2. Ejemplo II: Eventos de usuario ......................................... 290
10.6. Ejercicios ...................................................................................... 291
10.7. Bibliografía ................................................................................... 291
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
16
LabVIEW: entorno gráfi co 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
17
Índice
13.1.3. Splitters ............................................................................. 370
13.2. Localizar la interfaz ...................................................................... 370
13.3. Interactuando con el usuario programadamente ........................... 372
13.3.1. Menús personalizados ....................................................... 372
13.3.2. Teclado .............................................................................. 375
13.3.3. Drag & Drop ..................................................................... 376
13.4. XControls ...................................................................................... 377
13.4.1. Ejemplo: Polímetro virtual ................................................ 379
13.4.1.1. Explicación teórica ............................................. 379
13.4.1.2. Metodología ....................................................... 380
13.4.1.3. Resultados .......................................................... 383
13.5. Consejos para diseñar una interfaz ............................................... 383
13.5.1. Layout ............................................................................... 384
13.5.2. Tipografía .......................................................................... 385
13.5.3. Color .................................................................................. 386
13.5.4. Imágenes ........................................................................... 386
13.5.5 Otros ................................................................................... 387
13.6. Ejercicios ...................................................................................... 388
13.7. Bibliografía ................................................................................... 388
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
18
LabVIEW: entorno gráfi co de programación
14.4.3. Técnicas para mejorar el rendimiento ............................... 402
14.4.3.1. Cálculos inútiles ................................................. 403
14.4.3.2. No reinventar la rueda ........................................ 403
14.4.3.3. Tamaño de los datos ........................................... 404
14.4.3.4. Datos simples o complejos ................................. 405
14.4.3.5. Redimensionado de arrays ................................. 406
14.4.3.6. Cuellos de botella ............................................... 407
14.4.3.7. Variables y propiedades ...................................... 409
14.4.3.8. SubVI ................................................................. 409
14.5. Ejercicios ...................................................................................... 410
14.6. Bibliografía ................................................................................... 410
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
19
Índice
15.3.5.1. Explicación teórica ............................................. 426
15.3.5.2. Código ................................................................ 426
15.3.5.3. Resultados .......................................................... 427
15.4. Bibliografía ................................................................................... 428
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
20
LabVIEW: entorno gráfi co 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
