You are on page 1of 14

Índice

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

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

9
LabVIEW: entorno gráfico 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

10
Í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

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

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

13
LabVIEW: entorno gráfico 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

14
Í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

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

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

17
LabVIEW: entorno gráfico 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

18
Í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

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