control de dispositivos
TRANSCRIPT
UNIVERSIDAD POLITÉCNICA SALESIANA
SEDE GUAYAQUIL
FACULTAD DE INGENIERÍAS
Proyecto Final previo a la obtención del título de:
INGENIERO DE SISTEMAS
Oscar Michael Santistevan Guerrero
INGENIERO ELECTRÓNICO
Rubén Armando Puma Rodríguez
Roger Manuel Córdova Castillo
TEMA:
CONTROL INDUSTRIAL POR DISPOSITIVOS MÓVILES.
AUTORES
DIRECTOR
Ing. Raúl Álvarez.
Guayaquil, Agosto 7 del 2008
I
A U T O R Í A
Las ideas y contenidos expuestos en el presente proyecto, son de exclusiva
responsabilidad de los autores.
f.......................................................
Roger Manuel Córdova Castillo
f.......................................................
Rubén Armando Puma Rodríguez
f.......................................................
Oscar Michael Santistevan G.
Guayaquil, Agosto 7 del 2008
II
D E D I C A T O R I A
Al Ser Supremo que me inspiro en esta larga y difícil vida estudiantil, a mis queridos padres por sus principios, valores y apoyo incondicional, a mis hermanas, y aquel ser que me enseñó y me enseña a salir adelante siempre. Para todos ellos dedico este pequeño paso en mi vida profesional.
Roger
Este trabajo va dedicado con gran gratitud a todas aquellas personas que en su momento supieron apoyarme en mi fase estudiantil así como a mi madre que es pilar fundamental y motivo de superación para la culminación de mi carrera, a Dios que es el dador de sabiduría y a aquella persona especial que siempre estuvo y se mantiene junto a mí.
Ruben
A mi querida madre. A mi esposa quien incondicionalmente me brinda todo su apoyo.
Oscar
III
A G R A D E C I M I E N T O
A todo ese cuerpo docente con espíritu salesiano que
entregaron incondicionalmente su sabiduría, para
formarnos como personas de bien, y grandes
profesionales.
Roger Córdova C.
Rubén Puma R.
Oscar Santistevan G.
IV
CONTENIDO.
DECLARATORIA DE RESPONSABILIDAD
DEDICATORIA
AGRADECIMIENTO
ÍNDICE GENERAL
ÍNDICE DE FIGURAS
ÍNDICE DE TABLAS
1.- FUNDAMENTOS Y CONOCIMIENTOS GENERALES DEL HARDWARE Y COMUNICACIONES.
2.- HERRAMIENTAS DE DESRROLO PARA DISPOSITIVOS MÓVILES.
3.- DESARROLLO DEL PROYECTO: CONTROL INDUSTRIAL POR DISPOSITIVOS MÓVILES.
4.- BIBLIOGRAFÍA
5.- ANEXOS
6.- VOCABULARIO TÉCNICO
V
ÍNDICE GENERAL: 1. CAPÍTULO I:
Fundamentos y Conocimientos Generales de Hardware y Comunicación.
1.1 Introducción. ....................................................................................................... 1
1.1.1 Puerto Paralelo. ............................................................................................ 2
1.1.1.1 Historia. ................................................................................................. 2
1.1.1.2 Evolución .............................................................................................. 2
1.1.1.3 Registro del puerto paralelo. ............................................................... 4
1.1.1.4 Esquema interno del puerto paralelo. .................................................... 5
1.1.1.5 Conector del puerto paralelo. ................................................................ 5
1.1.1.6 Funcionamiento ..................................................................................... 6
1.1.2 Puerto Serie. ................................................................................................. 7
1.1.2.1 Historia. ................................................................................................. 9
1.1.2.2 Registro del puerto serie. ................................................................... 10
1.1.2.3 Conector del puerto serial. .................................................................. 10
1.1.2.4 Funcionamiento ................................................................................... 11
1.1.2.4.1 Formas de transmisiones serie: ..................................................... 12
1.1.2.4.2 Servicios BIOS de puerto serie .................................................... 14
1.1.2.5 Características Eléctricas. ................................................................... 15
1.1.2.6 Estándares ........................................................................................... 16
a.- Estándar RS-422 ..................................................................................... 16
b.- Estándar RS-485 .................................................................................... 17
1.1.2.7 Protocolos. ........................................................................................... 18
1.1.2.7.1 Protocolos Industriales: ................................................................ 18
a.- Protocolos ASCII. ............................................................................... 19
b.- Protocolo HART ................................................................................. 20
c.- Protocolo Modbus ............................................................................... 21
d.- Protocolo Bristol BSAP ...................................................................... 23
1.1.2.7.2 Protocolos de Comunicación. ....................................................... 24
a.- Protocolo BSC .................................................................................... 24
b.- Protocolo DDCMP ............................................................................. 25
c.- Protocolo HDLC ................................................................................. 26
1.1.3 Puerto USB. ............................................................................................... 26
1.1.3.1 Historia del puerto USB ...................................................................... 29
VI
1.1.3.2 Características generales del USB ..................................................... 31
a.- Fácil uso para los usuarios: .................................................................... 31
b.- Flexibilidad ............................................................................................ 31
c.- Ancho de banda isócrono ....................................................................... 31
d.- Robustez ................................................................................................. 32
e.- Implementación de bajo coste ................................................................ 32
1.1.3.3 Versiones del USB ............................................................................. 32
a.- Versión 1.0 ............................................................................................. 32
b.- Versión 1.1 ............................................................................................. 33
c.- Versión 2.0 ............................................................................................. 34
d.- Versión USB OTG ................................................................................. 36
e.- Versión 3.0 ............................................................................................. 38
1.1.3.4 Topología del bus ............................................................................... 39
1.1.3.4.1 La capa física ............................................................................... 40
a.- El host USB ........................................................................................ 41
b.- El controlador del host........................................................................ 42
c.- Dispositivos USB................................................................................ 43
1.1.3.4.2 La capa lógica .............................................................................. 45
1.1.3.4.3 La relación "Software del cliente-función" ................................ 46
1.1.3.5 Tipos de transferencias ........................................................................ 46
a.- Transferencias de control ....................................................................... 47
b.- Transferencias isócronas ........................................................................ 48
c.- Transferencias de interrupción ............................................................... 48
d.- Transferencias de bultos ("Bulk") .......................................................... 49
1.1.3.6 Parte Eléctrica del USB. ...................................................................... 49
a.- Identificación de la velocidad del dispositivo ........................................ 49
b.- Codificación de datos ............................................................................. 50
c.- Relleno de bits ........................................................................................ 50
d.- Sync ........................................................................................................ 50
e.- EOP ("End Of Packet") .......................................................................... 51
1.1.3.7 Parte Mecánica del USB. ................................................................... 51
a.- Cable estándar de quita y pon................................................................. 52
b.- Cable fijo de velocidad alta y media ...................................................... 52
c.- Cable fijo de velocidad baja ................................................................... 53
VII
1.1.3.8 Icono USB. ......................................................................................... 53
1.1.4 Radio Frecuencia. ...................................................................................... 53
1.1.4.1 El Espectro Electromagnético ............................................................. 54
1.1.4.2 Redes Inalámbricas ............................................................................. 55
1.1.4.2.1 Modo Ad Hoc ............................................................................... 57
1.1.4.3 Módulos de Radio Frecuencia ............................................................. 57
1.1.5 Micro controladores. .................................................................................. 59
1.1.5.1 Historia ................................................................................................ 60
1.1.5.2 Partes de un micro controlador ........................................................... 60
1.1.5.3 Aplicaciones ........................................................................................ 61
1.1.5.4 Volúmenes de Ventas. ......................................................................... 63
2. CAPÍTULO II:
HHeerrrraammiieennttaass ddee ddeessaarrrroolllloo ppaarraa ddiissppoossiittiivvooss mmóóvviilleess..
2.1 Introducción al J2ME ....................................................................................... 64
2.2 Configuración ................................................................................................... 64
2.3 Perfiles .............................................................................................................. 65
2.4 MIDLet ............................................................................................................. 66
2.5 Herramienta Netbeans ...................................................................................... 67
2.5.1 Características del Netbeans 6.0 ................................................................ 67
2.5.2 Más fácil instalación y la actualización. .................................................... 69
2.5.3 Swing GUI desarrollo ................................................................................ 70
2.5.4 Perfiles. ...................................................................................................... 71
2.6 Web y Java EE. ................................................................................................ 72
2.7 Mobility ............................................................................................................ 74
2.8 SOA .................................................................................................................. 75
2.9 UML. ................................................................................................................ 77
2.10 Visual Biblioteca API. .................................................................................... 81
2.11 Dispositivos Móviles ...................................................................................... 81
a.- Computadoras de Mano ................................................................................. 81
b.- Teléfonos Celulares ....................................................................................... 81
2.11.1 Computadoras de Mano ........................................................................... 81
2.12 WIFI ............................................................................................................... 83
2.12.1 Seguridad WIFI........................................................................................ 84
VIII
a.- Open Autentication. .................................................................................. 84
b.- Shared Key Authentication. ....................................................................... 84
c.- Validación de estaciones basada en dirección MAC ................................. 85
2.12.2 WEP ......................................................................................................... 85
3. CAPÍTULO III:
Desarrollo del Proyecto Control Industrial por dispositivos móviles..
3.1 Antecedentes .................................................................................................... 86
3.2 Elementos de un sistema de control ................................................................. 86
3.3 Motivación. ....................................................................................................... 88
3.4 Relaciones. ....................................................................................................... 88
3.5 Objetivos de la Tesis. ....................................................................................... 89
3.5.1 Objetivos Específicos. ............................................................................... 89
3.6 Trabajo Propuesto ............................................................................................. 89
3.7 Nuestro Sistema ................................................................................................ 90
3.7.1 Arquitectura del Sistema. ........................................................................... 91
3.7.2 Descripción general del proceso. ............................................................... 92
3.8 Hardware del sistema ....................................................................................... 94
3.8.1 Control por USB. (Adquisición y control de variables discretas.) ............ 94
3.8.1.1 Instalando Driver’s .............................................................................. 95
a.- Firmware del PIC. .................................................................................. 95
b.- Firmware del Software. .......................................................................... 97
3.8.1.2 Circuito PIC-USB. .............................................................................. 98
3.8.2 Comunicación por Radio Frecuencia de las variables. .............................. 99
3.8.2.1 Transmisor para un enlace de RF ...................................................... 100
3.8.2.2 Receptor para un enlace de RF.......................................................... 101
3.8.2.3 Receptor-Emisores en módulo PC-USB ........................................... 101
3.8.2.4 Receptor-Emisores en módulo Sistema a Controlar. ........................ 102
3.8.2.5 Detalles Técnicos HT-12D / HT-12E ............................................... 102
3.8.3 Sistema a controlar................................................................................... 103
3.8.3.1 Tanque Principal. .............................................................................. 104
3.8.3.2 Adquisición de temperatura. ............................................................. 105
3.8.3.3 Control Bombas y confirmación bombas. ......................................... 108
IX
3.8.3.4 Sistema Remoto. ............................................................................... 109
3.8.3.5 Variables de Status. ........................................................................... 110
3.8.3.6 Control Principal. .............................................................................. 112
3.8.3.7 Fuente de Alimentación .................................................................... 113
3.9 Firmware del Sistema .................................................................................... 113
3.9.1 Introducción a Visual Basic ..................................................................... 113
3.9.1.1 Características Generales de Visual Basic ........................................ 114
3.9.1.2 Nociones de visual Basic .................................................................. 115
3.9.1.3 Entornos de desarrollo ...................................................................... 115
3.9.2 Descripción del Sistema........................................................................... 116
3.9.2.1 Descomposición en subsistemas. ...................................................... 116
3.9.2.2 Diseño de objetos. ............................................................................. 117
3.9.3 Herramientas de desarrollo ...................................................................... 118
3.9.3.1 Configuraciones ODBC Para MySQL .............................................. 118
3.9.3.2 Instalación de Componentes LabView.............................................. 119
3.9.3.3 Componentes utilizados en el firmware. ........................................... 122
3.9.3.4 Creación de archivo RPT mediante Crystal Report .......................... 125
3.9.4 Descripción del entorno de desarrollo en Visual Basic ........................... 128
3.9.4.1 Justificación del Firmware y su funcionamiento .............................. 128
3.10 Software y Desarrollo del Móvil. ................................................................. 132
3.10.1 Sistema MCC ......................................................................................... 133
a.- Monitoreo ................................................................................................. 133
b.- Control ..................................................................................................... 133
c.- Chat .......................................................................................................... 133
3.10.2 Arquitectura del Sistema Controlado por Dispositivos Móviles ........... 133
3.10.3 Aplicación Web, Conexión a la Base de Datos ..................................... 134
3.10.4 Creación de WebService ........................................................................ 144
3.10.5 Consumir WebServices.......................................................................... 146
4.BIBLIOGRAFÍA:
4.1 Direcciones Electrónica……………………….………………………....149
4.2 Libros…………….…..…..……………………………………….……...150
X
5. ANEXOS:
ANEXO A ................................................................................................................ 151
A.1 Descripción del capítulo ........................................................................... 151
A.2 Introducción a las interfaces de usuario ................................................... 151
A.3 Descripción de Interfaces Por módulos .................................................... 152
A.3.1 Login Acceso De clave ......................................................................... 152
A.3.2 Sistema de Monitoreo ........................................................................... 153
A.3.3 Consulta por Dispositivo....................................................................... 156
A.3.4 Consulta Monitoreo por usuario ........................................................... 157
A.3.5 Consulta Monitoreo de Encendido y Apagado ..................................... 157
A.3.6 Mantenimiento de Usuario .................................................................... 158
A.3.7 Mantenimiento de Dispositivos .............................................................. 158
A.3.8 Eventos de Suceso................................................................................. 159
A.3.9 Eventos de Alertas ................................................................................ 160
A.3.10 Ventana Cascada ................................................................................... 160
A.3.11 Ventana Mosaico .................................................................................. 161
A.3.12 Ventana Vertical ................................................................................... 161
A.3.13 Ayuda del Sistema ................................................................................ 162
A.3.14 Acerca de Carolina ................................................................................ 162
ANEXO B ................................................................................................................ 163
B.1 Descripción del capítulo ........................................................................... 163
B.2 Introducción a las interfaces de usuario .................................................... 163
B.2.1 Inicio de Sesión de usuario. .................................................................. 164
B.2.2 Monitoreo .............................................................................................. 166
B.2.3 Control................................................................................................... 167
B.2.4 Chat ....................................................................................................... 168
ANEXO C ................................................................................................................ 169
C.1 Descripción del Módulo VBMPUSBAPI.bas ................................................ 169
C.2 Descripción de funcionamiento por formularios ........................................... 175
C.2.1MDI (FRMAIN) ....................................................................................... 178
XI
C.2.2 SISTEMA ................................................................................................ 181
C.2.3 CONSULTAS ......................................................................................... 201
C.2.4 MANTENIMIENTO ............................................................................... 209
C.2.5 EVENTOS............................................................................................... 214
C.2.6 Ayuda ...................................................................................................... 219
ANEXO D ................................................................................................................ 222
D.1 Aplicación Web ............................................................................................. 223
D.2 Aplicación Móvil ........................................................................................... 234
ANEXO E ................................................................................................................ 253
E.1 PROGRAMA DEL PIC 18F4550 .................................................................. 254
E.2 PROGRAMA DEL PIC 16F877 .................................................................... 257
E.2 PROGRAMA DEL PIC 16F870 (Celular) .................................................... 263
ANEXO F ................................................................................................................ 266
F.1 Introducción ................................................................................................... 266
F.2 Análisis ........................................................................................................... 266
F.3 Modelo Entidad-Relación .............................................................................. 267
F.4 Dirección de Datos ......................................................................................... 268
ANEXO G ................................................................................................................ 274
G.1 Diagramas DFD ............................................................................................. 274
G1.2 Control de Dispositivos ........................................................................... 275
G.2 Diagramas IPO .............................................................................................. 276
G2.1 Diagrama IPO Detallado Monitoreo ........................................................ 277
G2.2 Diagrama IPO Detallado Control............................................................. 278
G2.3 Diagrama IPO Detallado Chat ................................................................. 279
G.3 Diagramas de Jerarquía ................................................................................. 280
ANEXO H………………………………………………………………………….279
H.1 Costo materiales eléctricos de maqueta y tubería…………….……….........279
H.2 Costos componentes electrónicos…………………………………………..280
XII
H.3 Costo Total………………………………………………………………….282
5. VOCABULARIO TÉCNICO:
5.1Glosario…………………………………………………………………………283
5.2 Vocabulario…………………………………………………………………….288
XIII
ÍNDICE DE FIGURAS.
Capítulo I.
1.1: Dispositivos conectados por RS-232 hacia una red Ethernet……..…….. 1
1.2 Esquema interno del puerto paralelo5………….…………………..…….. 5
1.3 Conector DB-25…………………………………………………….…….. 5
1.4 Télex.………………………………………………………………..…….. 9
1.5 Conector DB-9……………………………………………………………. 10
1.6 NS16550D.……………………………………………………………….. 11
1.7 Transmisión Síncrona…………………………………………………….. 13
1.8 Recepción Síncrona……………………………………………………….. 13
1.9 Transmisión Asíncrona…………………………………………….…….. 14
1.10 Recepción Asíncrona……………………………………………..…….. 14
1.11 Niveles de Voltaje……………………………………………………….. 15
1.12 Niveles de Tensión………………………………………………..…….. 15
1.13 Conexión DB-9………………………………………………………….. 16
1.14 Ilustración de Conexión de equipos RS-232 hacia Ethernet……..…….. 16
1.15 Ilustración de Conexión de equipos RS-422 a otros equipos…….…….. 17
1.16 Conectividad RED RS-485………………………………………..…….. 17
1.17 Esquema de conexión de enlace entre PC y PLC……………………….. 18
1.18 Ejemplo práctico de conectividad por protocolo ASCII………….…….. 19
1.19 Ejemplo práctico de conectividad por protocolo ASCII………………... 21
1.20 Aplicación práctica de una RED RS-485 hacia Ethernet…..………….. 22
1.21 Modulo de comunicación MODBUS por Radio……………………….. 23
1.22 Ejemplo práctico de conectividad por protocolo ASCII……………….. 23
1.23 Aplicación Integral………………………………………………..…….. 24
1.24 enlace mediante Protocolo BSC…………………………………..…….. 25
1.25 Velocidades de transmisión……………………………………….…….. 26
1.26 Conexión dispositivos por el puerto USB. ………………………..…….. 27
1.27 Logo Conexión USB OTG………………………………………..…….. 36
1.28 Ejemplos Conexión USB OTG………………………………………….. 36
1.29 Conector USB 2.0……………………………………………………….. 38
1.30 Conector USB 3.0……………………………………………………….. 38
1.30 Mini conector USB 3.0………………………………………………….. 38
1.31 Topología del bus……………………………………………………….. 39
1.31 División de la topología del bus………………………………….……… 40
XIV
1.31.1: Cable USB…………………………………………………………….. 52
1.31.2: Cable USB Fijo……………………………………………….……….. 52
1.32: Estructura interna del cable USB………………………………....…….. 53
1.32.1 El espectro electromagnético…………………………………..……… 54
1.32.2 Frecuencia de operación………………………………………………. 55
1.33: Esquema de redes Wireless…………………………………………….. 56
1.34: Velocidad de redes Wireless…………………………………………… 56
1.35: Topología WLan………………………………………………….…….. 57
1.35.1: Modulo Transmisor…………………………………………….…….. 57
1.35.2: TWS-434………………………………………………….………….. 58
1.35.3: Modulo Receptor. ……………………………………………….…… 58
1.35.4: RWS-434……………………………………………….……………. 59
1.36: Grafica del primer integrado…………………………………………… 60
1.37: Parte del microprocesador…………………………………………….. 60
1.38: Grafica de iteración……………………………………………………. 62
1.39: Diagrama bloques Proceso Industrial. ……………………………….. 62
1.40: Ejemplo usos de los microcontroladores. …………………………….. 63
1.41: Distribución de los Microcontroladores. ……………………………… 63
Capítulo II.
2.1: Programando en Netbeans. ……………………………………………… 67
2.2: Ejemplo de código en Netbeans……………………………………….… 68
2.3: Ventana de proyectos en Netbeans………………………………………. 69
2.4: Ejemplo de Aplicación Con Base de Datos……………………………… 70
2.5: Creando un proyecto nuevo……………………………………………… 71
2.6: Interfaz de Netbeans……………………………………………………... 72
2.7: Desarrollo de un proyecto……………………………………………….. 73
2.8: Referencias en Netbeans…………………………………………………. 75
2.9: Abrir un proyecto………………………………………………………... 76
2.10: Trabajando en el proyecto…………………………………………….... 76
2.11: Ventana de opciones……………………………………………............ 78
2.12: Test de parámetros…………………………………………….............. 78
2.13: Trabajando con clases…………………………………………….......... 79
2.14: Variables……………………………………………............................. 79
XV
2.15: Configuración Variables……………………………............................. 80
2.16: Arquitectura de un modulo…………………………….......................... 80
2.17: Ventana General…………………………….......................................... 80
Capítulo III.
86 3.1: Elementos Sistema de control……………………………........................ 87
3.2: Tipo de Señales…………………………….............................................. 87
3.3: Esquema de nuestro Sistema……………….............................................. 91
3.4: Descripción de Nuestro Sistema 92……………….................................... 92
3.5: Descripción del PIC 18F4550………………............................................. 95
3.6: Instalación del PIC………………............................................................. 96
3.7: Periférico conectado………………........................................................... 97
3.8: Diagrama del circuito PIC-USB………………......................................... 98
3.9: Principio de funcionamiento……………….............................................. 99
3.10: Modulo de Transmisión………………................................................... 100
3.11: Modulo de Transmisión………………................................................... 100
3.12: Fuente externa de pulsos.………………................................................ 102
3.13: Sistema de Llenado y Vaciado………………........................................ 103
3.14: Esquema general Control de Bombas…………...................................... 103
3.15: Esquema general Control de Bombas……….......................................... 104
3.16: Esquema general Control de Bombas……….......................................... 105
3.17: Diagrama flujo Temperatura………....................................................... 106
3.18: Etapa encendido-apagado bombas………............................................. 108
3.19: Sistema Remoto………......................................................................... 109
3.20: Variables del Sistema………................................................................ 110
3.21: Control Principal………........................................................................ 111
3.22: Fuente de Alimentación………............................................................. 112
3.23: Modulo del firmware……….................................................................. 115
3.24: Secuencia del Firmware……….............................................................. 116
3.25: Instalación del Driver ODBC………..................................................... 117
3.26: Gráficos de LabVIEW………................................................................ 119
3.27: Agregar componente de LabVIEW………............................................ 120
3.28: Utilización del componente de LabVIEW sobre VB 6.0…..................... 120
3.29: TexBox………..........................................………................................... 121
XVI
3.30: Label………..........................................………....................................... 121
3.31: CommandButton.........................................……….................................. 121
3.32: Toolbar..…..………..........................................………............................. 121
3.33 CWSlide………..........................................………................................... 121
3.34: RichTextBox………..........................................………........................... 122
3.35: Calendar………..........................................……….................................. 122
3.36: CrystalReport………..........................................……….......................... 122
3.37: Frame………..........................................………...................................... 122
3.38: CheckBox………..........................................………............................... 122
3.39: ListBox………..........................................………................................... 123
3.40: Timer………..........................................………...................................... 123
3.41: Utilización de Crystal ......................................………............................ 124
3.42: Utilización de Crystal Report..............................………......................... 125
3.43: Agregando tablas...............................……….......................................... 125
3.44: Escoger datos de un reporte...............................……….......................... 126
3.45: Ambiente de un reporte...............................………................................. 126
3.46: Pantalla de Monitoreo del Proceso...............................………................ 129
3.47: Diagrama del sistema...............................……….................................... 131
3.48: Arquitectura del sistema...............................………................................ 132
3.49: Cargando la base de datos a nuestro sistema.....………........................... 134
3.50: Creando el driver JDBC.....………............................….........…............. 135
3.51: Creando una nueva conexión....………............................….......…......... 135
3.52: Finalizando la Conexión....………............................….........….............. 136
3.54: Creando un nuevo proyecto....………............................….........…......... 137
3.55: Colocando parámetros al proyecto....………...............................…........ 137
3.56: Creando un Web Aplicación....………............................…………....... 138
3.57: Colocando el Netbeans 138....………............................…...................... 138
3.58: Creado el Web Aplicación para la base de datos...….............................. 139
3.59: Creando el pool de conexiones....………............................…................. 139
3.60: Creando el referencia de conexión....………...............................…......... 140
3.61: Agregada la referencia de conexión....………..............................…........ 140
3.62: A tachando la referencia de conexión a tu aplicación..................…........ 141
3.63: Registrando servidor de aplicación................…...................................... 141
3.64: Haciendo la clase en java con las aplicación................…........................ 142
3.65: Haciendo la clase en java con las aplicación................…........................ 142
XVII
3.66: Creando un web service................…....................... ................................ 143
3.67: Agregando una operación................…..................................................... 143
3.68: Nombre y tipo de operación................…................................................. 144
3.69: Creando un nuevo servicio................…................................................... 144
3.70: Creando un consumidor del web service................….............................. 145
3.71: Creando un Cliente................…............................................................... 146
3.72: Parámetros del Cliente................…......................................................... 146
3.73: Finalización la creación de Consumidor de WEB........…....................... 147
ANEXO A
A1.1: Pantalla de acceso................….............................................................
151
A1.2: Pantalla de error de usuario................…..............................................
151
A1.3: Pantalla de ingreso de usuario/clave................…................................. 152
A1.4: Pantalla de acceso al sistema.…...........................................................
152
A1.5: Error si no hay dispositivo (PIC) conectado en el USB.…...................
152
A1.6: Monitoreo Básico del proceso.….......................................................... 153
A1.7: Pantalla de monitoreo.…......................................................................
154
A1.8: Pantalla de problema en las bombas.…................................................
154
A1.9: Continua proceso.…........................…................................................. 155
A1.10: Consulta por usuario.….........................…........................................
156
A1.11: Consulta por dispositivo encendido y apagado.…............................
156
A1.12: Mantenimiento de usuario.…..........…............................................... 157
A1.13: Mantenimiento de dispositivo.….........................…..........................
157
A1.14: Evento de Suceso Normal.….........................…................................
158
A1.15: Evento de Alertas.….........................…............................................. 158
A1.16: Ventana en cascada.….........................…...........................................
159
A1.17: Ventanas en mosaico.….........................…........................................
159
A1.18: Ventana en Vertical.….........................…........................................... 160
A1.19: Archivo de Ayuda.….........................….............................................
160
A1.20: Información del sistema.….........................…....................................
161
ANEXO B
B1.1: Inicio de sesión de usuario.….........................….................................
163
B1.2: Mensaje de advertencia.….........................…......................................
164
B1.3: Pantalla de Bienvenida.….........................…........................................
164
XVIII
B1.4: Monitoreo del sistema.….........................….........................................
165
B1.5: Opciones de software.….........................…..........................................
165
B1.6: Opciones a Tomar.….........................…...............................................
166
B1.7: Opción de Apagado General.….........................…...............................
166
B1.8: Opciones a Chat.….........................….................................................
167
B1.9: Chateo entre usuarios.….........................….........................................
167
ANEXO C
C1.1: Esquemático de los Formularios.….........................……........................
174
XIX
ÍNDICE DE TABLAS:
CAPÍTULO 1
1.1: Tabla general del puerto paralelo….........................….….........................
4
1.2: Tabla de direccionamiento….........................……....................................
6
1.3: Tabla general del puerto serial….........................……..............................
10
1.4: historial de progreso del puerto USB….........................……......................
30
1.6: Periféricos que utilizan el puerto USB….........................……....................
37
1.7: Pines Cable Fijo de Velocidad Baja….........................……........................
53
1.8: Especificaciones del TWS….........................…….....................................
58
1.9: Especificaciones del RWS….........................……..................................... 59
Capítulo 3.
3.1: Descripción de entradas al PIC 18F4550...........………............….............
99
3.2: Descripción de salidas del PIC 18F4550...........…….............. ...................
99
3.3: Características Técnicas PIC...........……...................................................
112
3.4: Tipos de Variables...........……..................................................................
124
1
1.- CAPÍTULO 1.
FUNDAMENTOS Y CONOCIMIENTOS GENERALES DE HARDWARE Y
SOFTWARE
En esta sección se darán detalles de los puertos paralelo, serial y USB.
Veremos configuración de los pines, como se comunican, en el caso del puerto USB
se hablara sobre la detección de dispositivos, drivers de comunicación.
Hablaremos de la comunicación por radio frecuencia, veremos arquitectura, historia,
familias de los micro controladores.
1.1 Introducción.
Hoy en día es común aprovechar los puertos de comunicación de las computadoras,
tal que existen convertidores RS-485, RS-232, RS-222 hacia Ethernet, la vanguardia
de la tecnología apunta hacia la parte inalámbrica tenemos la misma tecnología hacia
redes inalámbricas.
Figura 1.1: Dispositivos conectados por RS-232 hacia una red Ethernet.
Fuente: www.programer-isop.com.en/comunicate-struct/development/imagens%&/ Existen estándares de cableado, como por ejemplo el RS-485 que es un estándar de
múltiples puntos, con una distancia práctica de cableado de 4000 pies máximo, entre
otros que se darán a conocer más adelante.
2
Hay un sinfín de protocolos de comunicación para enlazar estos puertos disponibles
en la mayoría de computadoras con tarjetas externas o algún hardware específico.
La vanguardia de la fibra óptica, cada vez más accesible en cuanto a precio está
siendo cada vez más usada dentro de las redes industriales donde demandan mayores
distancias, la inversión se centra en los convertidores de fibra-Ethernet, fibra-RS485,
fibra-RS232.
Explicaremos el funcionamiento de los puertos existentes en la computadora, tales
como el puerto paralelo, puerto serial, y actualmente el puerto USB, así como
algunos de los protocolos para tales dispositivos, estándares de cableado, ejemplos de
aplicación y comunicación.
1.1.1 Puerto Paralelo.
1.1.1.1 Historia.
En 1981, la IBM (International Business Machines) introdujo la Computadora
Personal (PC). El puerto paralelo (Standar Parallel Port SPP) estaba incluido en el
primer PC y se agregó a éste como una alternativa al bajo rendimiento del puerto
serial, para utilizarlo como controlador de las impresoras de matriz de punto de alto
desempeño. Este puerto tenía la capacidad de transmitir 8 bits de datos a la vez (del
PC a la impresora), mientras que el puerto serial lo hacía de uno en uno. En el
momento que el puerto paralelo fue presentado, las impresoras de punto fueron el
principal dispositivo externo que se conecto a éste. Al hacerse extensamente
utilizado, el puerto paralelo llegó a ser la respuesta para conectar dispositivos más
rápidos.
1.1.1.2 Evolución
Desde la introducción del PC al mercado, el puerto paralelo ha sufrido varias
modificaciones para hacerlo más veloz. Ya que el puerto original era unidireccional,
se creó el puerto bidireccional. El puerto bidireccional fue introducido con el PS/2
compatible. Este permite una comunicación de 8 bits en ambas direcciones. Algo
3
interesante de notar es que el puerto original tenía la posibilidad de ser bidireccional
realizando una conexión entre dos pines de un componente electrónico que venía
incluido en éste. (Dicho de otro modo, el puerto original es bidireccional en diseño
básico, pero no en el diseño operacional). Finalmente se han creado el Enhanced
Parallel Port (EPP) y el Extended Capability Port (ECP). Estos dos últimos son al
puerto estándar como el Pentium al 286, además de ser bidireccionales.
Inicialmente el puerto paralelo se utilizó para la comunicación con impresoras.
Actualmente se utiliza también para manejar otros periféricos como CD ROM, cintas
de copia de respaldo, discos duros, tarjetas de red, protectores de copia, scanner, etc.
El puerto paralelo está formado por 17 líneas de señales y 8 líneas de tierra. Las
líneas de señales están formadas por tres grupos:
4 Líneas de control
5 Líneas de estado
8 Líneas de datos
En el diseño original las líneas de control son usadas para la interface, control e
intercambio de mensajes desde el PC a la impresora.
Las líneas de estado son usadas para intercambio de mensajes, indicadores de estado
desde la impresora al PC (falta papel, impresora ocupada, error en la impresora).
Las líneas de datos suministran los datos de impresión del PC hacia la impresora y
solamente en esa dirección. Las nuevas implementaciones del puerto permiten una
comunicación bidireccional mediante estas líneas.
Cada una de estas líneas (control, estado, datos) puede ser referenciada de modo
independiente mediante un registro.
4
1.1.1.3 Registro del puerto paralelo.
El puerto paralelo tiene tres registros:
Registro de datos
Registro de estado
Registro de control
DB25 Señal Registro Tipo Activo Sentido
1 Control 0 C0- Salida Bajo Invertido
2 Dato 0 D0 Salida Alto directo
3 Dato 1 D1 Salida Alto directo
4 Dato 2 D2 Salida Alto directo
5 Dato 3 D3 Salida Alto directo
6 Dato 4 D4 Salida Alto directo
7 Dato 5 D5 Salida Alto directo
8 Dato 6 D6 Salida Alto directo
9 Dato 7 D7 Salida Alto directo
10 Estado 6 S6+ Entrada Alto directo
11 Estado 7 S7- Entrada Bajo Invertido
12 Estado 5 S5+ Entrada Alto directo
13 Estado 4 S4+ Entrada Alto directo
14 Control 1 C1- Salida Bajo Invertido
15 Estado 3 S3+ Entrada Alto directo
16 Control 2 C2+ Salida Alto directo
17 Control 3 C3- Salida Bajo Invertido
18-25 Tierra Tabla 1.1: Tabla general del puerto paralelo
Fuente: www.programer-isop.com.en/comunicate-struct/development/imagens%&/
5
1.1.1.4 Esquema interno del puerto paralelo.
Figura 1.2 Esquema interno del puerto paralelo.
Fuente:www.javier-moya.com.es/pto_para/image$%&.gif 1.1.1.5 Conector del puerto paralelo.
Figura 1.3 Conector DB-25
Fuente:www.javier-moya.com.es/pto_para/imagen$%·.gif
6
1.1.1.6 Funcionamiento
Explicación del funcionamiento mediante el BIOS y el MS-DOS.
IBM especificó direcciones base para el puerto paralelo estándar (dentro del espacio
de direccionamiento de Entrada/Salida del 80x86). El adaptador de impresora podría
usar la dirección base 3BCh, o más tarde 378h o 278h.
El BIOS (Basic Input Output System) de IBM crea en el momento de arranque o
POST (Power On Seft Test) una tabla en el espacio de la memoria principal (RAM)
para 4 direcciones base de puerto paralelo de impresora, estos se almacenan como 4
bytes empezando con la dirección de memoria 408h. Durante el arranque, el BIOS
comprueba si hay puertos paralelos en las direcciones base 3BCh, 378h, y 278h, en
ese orden, y almacena la dirección base de cualesquiera que hayan sido encontrados
en posiciones consecutivas de la tabla. Las posiciones que no son usadas pueden
estar en 0, o como algunos BIOS lo hacen, le colocan la dirección del primer puerto
encontrado.
Algunos programas pueden ignorar esta tabla, pero esta es usada por lo menos por el
propio BIOS (mediante la INT 17 de E/S de impresora) y por el MS-DOS.
El BIOS detecta estos puertos escribiendo AAh al registro de datos (en la dirección
de E/S Base + 0), y luego si en el registro de datos se lee AAh. Significa que hay un
puerto.
Normalmente la asignación de direcciones es como sigue:
Dirección Nombre Ubicación
3BCh LPT1 Adaptador de impresión
primario
378h LPT2 Adaptador de impresión
secundario
Tabla 1.2: Tabla de direccionamiento Fuente: www.programer-isop.com.en/comunicate-struct/development/imagens%&/
Las referencias a cada registro del puerto se realizan de la siguiente forma:
7
Base (datos)=base+0
Estado=base+1
Control=base+2
Por ejemplo, si encontramos que la dirección base es 378h, entonces las direcciones
del registro de datos, estado y control serán:
Base (datos)=378h
Estado=379h
Control=37Ah
Cada una de ellas permite acceder a los siguientes bits (descritos en la tabla general):
Base (datos)=D0, D1, D2, D3, D4, D5, D6, D7
Estado=S3, S4, S5, S6, S7
Control=C0, C1, C2, C3
1.1.2 Puerto Serie.
El puerto serie está considerado como una de las conexiones externas más básicas de
un ordenador, y ha sido una parte integral de la mayoría de ordenadores durante más
de 20 años. Aunque muchos de los nuevos sistemas están prescindiendo de los
puertos serie a favor de las conexiones USB.
Esencialmente, proveen una conexión estándar y un protocolo para que puedas
conectar diferentes dispositivos. Existen ciertas diferencias con respecto a los puertos
paralelo.
Todos los sistemas operativos de los ordenadores que están es uso hoy en día,
soportan los puertos serie, ya que han estado en funcionamiento durante décadas. Los
puertos paralelos son una invención más reciente y son mucho más rápidos que los
puertos serie. Los puertos USB solo tienen unos pocos años de antigüedad, y con el
tiempo seguramente reemplazarán a los puertos serie y paralelo en los próximos
años.
8
El nombre de “serie” viene por el hecho de que un puerto serie “serializa” los datos.
Esto significa que coge un byte de datos y transmite los 8 bits que contiene el byte
uno a la vez. La ventaja es que los puertos serie solo necesitan un hilo para transmitir
los 8 bits, mientras que los paralelo necesitan 8. La desventaja es que lleva 8 veces
más tiempo que si tuviera 8 hilos.
Antes de cada byte de datos, los puertos serie envían un bit de comienzo, el cual es
un único bit con un valor de 0. Después de cada byte de datos, envía un bit de parada
para señalar que el byte está completo. También envía un bit de paridad.
Los puertos serie, también llamados puertos de comunicación (COM), son bi-
direccionales. La comunicación bi-direccional permite a cada dispositivo recibir
datos a la vez que los transmite.
Los dispositivos serie usan pines diferentes para el recibir y enviar datos - usar los
mismos pines significaría que la comunicación estaría limitada a half-duplex, y que
la información viajaría en una sola dirección a la vez. Usar pines diferentes permite
una comunicación full-duplex, y puede viajar en ambos sentidos.
Los puertos serie delegan en un controlador o chip especial llamado UART
(Universal Asynchronous Receiver/Transmitter), para funcionar correctamente.
El chip UART coge la salida en paralelo del bus del sistema y la transforma en una
forma serie para que se transmita por el puerto serie. Para que funcionen más rápido,
muchos chips UART tiene integrado un buffer de 16 a 64 Kilobytes en su interior.
Este buffer permite al chip hacer un caché de datos mientras está procesando los
datos.
La conexión serie
La conexión externa de un puerto serie puede ser de nueve pines o de 25 pines.
Originalmente, el uso principal de un puerto serie era conectar un modem a un
ordenador. Un aspecto importante de las comunicaciones serie es el concepto del
control de flujo. Esto es la habilidad de un dispositivo de decirle a otro dispositivo
que pare de enviar datos por un rato. Los comandos RTS (Request to Send), CTS
9
Figura 1.4 Telex
Fuente: www.google.com
(Clear To Send), DTR (Data Terminal Ready) y DSR (Data Set Ready) son
utilizados para habilitar el control de flujo.
1.1.2.1 Historia. Los diseñadores del IBM PC ya previeron la posibilidad de comunicación serie, para
lo que posibilitaron la instalación de hasta 7 puertos de comunicaciones serie
asíncronas RS-232.C (aunque es raro instalar más de dos); para atender estos puertos
dispusieron de los correspondientes servicios en la BIOS. En los primeros modelos
la electrónica necesaria no estaba incluida en la placa-base, por lo que los puertos
debían instalarse en adaptadores de tarjeta que se insertaban en cualquiera de los
zócalos disponibles.
RS-232.C significa literalmente "Recomended Standard232 revisión C" (también
conocida como EIA 232). Es un estándar publicado en 1969 por la EIA ("Electronic
Standard Association") que define las características eléctricas que deben presentar
los elementos de conexión para la comunicación serie entre ordenadores y equipos
periféricos.
Su título dice exactamente: "Conexión entre un Equipo Terminal de Datos y un
Equipo de Comunicación de Datos empleando un intercambio de datos binario
serie".
Para comprender bien algunos aspectos de las comunicaciones serie, hay que tener
en cuenta que este tipo de comunicación eléctrica precede en bastantes años a la
aparición de los ordenadores electrónicos.
La comunicación serie tiene sus raíces en el telégrafo (figura 1.4), que
posteriormente derivó en el teleimpresor (Télex), donde se utilizaron diversos
protocolos de comunicación; los más famosos el Morse, el Baudot y el ASCII.
10
Posteriormente las comunicaciones serie informáticas adoptaron algunos de los usos
y costumbres existentes adaptándolos a las nuevas necesidades, empezando por su
propio sistema de códigos (ASCII), pero que conservando algunas reminiscencias de
sus ancestros telegráficos.
1.1.2.2 Registro del puerto serie.
Las señales TXD, DTR y RTS son de salida, mientras que RXD, DSR, CTS y DCD
son de entrada. La masa de referencia para todas las señales es SG (Tierra de Señal).
Finalmente, existen otras señales como RI (Indicador de Llamada), y otras poco
comunes que no se explican en este artículo por rebasar el alcance del mismo.
Numero de Pin Señal Descripción E/S En DB-25 En DB-9 1 1 - Masa chasis - 2 3 TxD Transmit Data S 3 2 RxD Receive Data E 4 7 RTS Request To Send S 5 8 CTS Clear To Send E 6 6 DSR Data Set Ready E 7 5 SG Signal Ground - 8 1 CD/DCD (Data) Carrier Detect E 15 - TxC(*) Transmit Clock S 17 - RxC(*) Receive Clock E 20 4 DTR Data Terminal Ready S 22 9 RI Ring Indicator E 24 - RTxC(*) Transmit/Receive Clock S
Tabla 1.3: Tabla general del puerto serial Fuente: www.programer-isop.com.en/comunicate-struct/development/imagens%&/
1.1.2.3 Conector del puerto serial.
Figura 1.5 Conector DB-9 Fuente: www.javier-moya.com.es/pto-serie/imagen·$%.jpg
11
1.1.2.4 Funcionamiento
El ordenador controla el puerto serie mediante un circuito integrado específico,
llamado UART (Transmisor-Receptor-Asíncrono Universal). Normalmente se
utilizan los siguientes modelos de este chip: 8250 (bastante antiguo, con fallos, solo
llega a 9600 baudios), 16450 (versión corregida del 8250, llega hasta 115.200
baudios) y 16550A (con buffers de E/S). A partir de la gama Pentium, la circuitería
UART de la placa base son todas de alta velocidad, es decir UART 16550.
. Figura 1.6 NS16550D
Fuente: www.nationalsemiconductor.com
Mediante los puertos de E/S se pueden intercambiar datos, mientras que las IRQ
producen una interrupción para indicar a la CPU que ha ocurrido un evento (por
ejemplo, que ha llegado un dato, o que ha cambiado el estado de algunas señales de
entrada). La CPU debe responder a estas interrupciones lo más rápido posible, para
que dé tiempo a recoger el dato antes de que el siguiente lo sobrescriba. Sin embargo,
las UART 16550A incluyen unos buffers de tipo FIFO, dos de 16 bytes (para
recepción y transmisión), donde se pueden guardar varios datos antes de que la CPU
los recoja. Esto también disminuye el número de interrupciones por segundo
generadas por el puerto serie.
El RS-232 puede transmitir los datos en grupos de 5, 6, 7 u 8 bits, a unas velocidades
determinadas (normalmente, 9600 bits por segundo o más). Después de la
transmisión de los datos, le sigue un bit opcional de paridad (indica si el numero de
bits transmitidos es par o impar, para detectar fallos), y después 1 o 2 bits de Stop.
Normalmente, el protocolo utilizado ser 8N1 (que significa, 8 bits de datos, sin
paridad y con 1 bit de Stop).
Una vez que ha comenzado la transmisión de un dato, los bits tienen que llegar uno
detrás de otro a una velocidad constante y en determinados instantes de tiempo. Por
eso se dice que el RS-232 es asíncrono por carácter y síncrono por bit. Los pines que
portan los datos son RXD y TXD. Las demás se encargan de otros trabajos: DTR
12
indica que el ordenador esta encendido, DSR que el aparato conectado a dicho puerto
esta encendido, RTS que el ordenador puede recibir datos (porque no está ocupado),
CTS que el aparato conectado puede recibir datos, y DCD detecta que existe una
comunicación, presencia de datos.
Como ya se ha visto, los parámetros que hay que configurar son: protocolo serie
(8N1), velocidad del puerto serie, y protocolo de control de flujo. Este ultimo puede
ser por hardware (el que ya hemos visto, el handshaking RTS/CTS) o bien por
software (XON/XOFF, el cual no es muy recomendable ya que no se pueden realizar
transferencias binarias). La velocidad del puerto serie no tiene por qué ser la misma
que la de transmisión de los datos, de hecho debe ser superior. Por ejemplo, para
transmisiones de 1200 baudios es recomendable usar 9600, y para 9600 baudios se
pueden usar 38400 (o 19200).
1.1.2.4.1 Formas de transmisiones serie:
Simplex: Un equipo transmite, el otro recibe.
Half-duplex: Transmiten ambos equipos pero no simultáneamente; los equipos se
alternan en la transmisión, uno transmite mientras el otro recibe.
Full-duplex: Ambos equipos transmiten simultáneamente. Para ello se requieren dos
líneas independientes, transmisión y recepción; la línea de transmisión de un equipo
se conecta a la entrada de recepción del otro y viceversa. Los puertos serie del PC
son capaces de utilizar este modo.
Síncronas: Los dispositivos que comunican se sincronizan en el momento inicial de
la transmisión y constantemente se intercambian información a una cadencia
predefinida. Con objeto de mantener la sincronización, cuando no existen datos que
enviar se transmite caracteres sin valor ("idle characters). Esta transmisión es más
rápida que la asíncrona porque no es necesario transmitir señales de inicio o fin de
dato; constantemente se recibe caracteres que pueden ser de datos o sin valor (de
relleno).
13
Figura 1.7 Transmisión Síncrona.
Fuente: www.javier-moya.com.es/pto-serie/tran/imagen·$%.jpg
Figura 1.8 Recepción Síncrona.
Fuente: www.javier-moya.com.es/pto-serie/rec/imagen·$%.jpg Asíncronas: En este modo de transmisión no existe sincronización; no es necesario
enviar caracteres de relleno, pero hay que indicar cuándo empieza un dato y cuando
termina. Esto se hace incluyendo en la transmisión señales de inicio y fin de datos
(bits de "start" y "stop"). En la comunicación asíncrona, la información (cada
carácter) es enviada en el interior de un cuadro ("Frame") de tamaño variable, que
comienza con la mencionada señal de inicio y termina con la de final; es el tipo de
comunicación utilizada en los puertos serie del PC.
14
Figura 1.9 Transmisión Asíncrona.
Fuente: www.javier-moya.com.es/pto-serie/asin/imagen·$%.jpg
Figura 1.10 Recepcion Asíncrona.
Fuente: www.javier-moya.com.es/pto-serie//asin/imagen·$%.jpg
1.1.2.4.2 Servicios BIOS de puerto serie
Los servicios BIOS relacionados con el puerto serie se gestionan mediante el vector
de interrupción 20 (14h); este servicio tiene 4 sub servicios numerados del 0 al 3.
Servicio 0: Inicializar el puerto; permite ajustar los parámetros de
transmisión.
Servicio 1: Enviar un carácter
Servicio 2: Recibir un carácter
15
Servicio 3: Obtener el estado del puerto, tanto de funcionamiento como
estados de error.
Por lo general, la secuencia POST solo detecta los dos primeros puertos serie; como
el DOS utiliza los datos de la BIOS, salvo módulos software especiales, los
programas DOS solo pueden utilizar COM1 y COM2. Sin embargo esta limitación
no existe para Windows 98 en adelante, que pueden utilizar hasta 128 puertos.
1.1.2.5 Características Eléctricas.
Como hemos señalado, las normas y terminología de las comunicaciones serie están
muy influenciadas por sus orígenes telegráficos. Esto incluye algunas de las
definiciones utilizadas por la norma RS-232. Una curiosidad de esta norma es que la
transmisión de los caracteres ASCII se realiza empezando por el bit menos
significativo.
En la figura se muestran los niveles de tensión correspondientes a las salidas. Como
puede verse en la fig. 1.7; la lógica utilizada es poco convencional, utiliza una lógica
bipolar con tensiones negativas para los "1" lógicos.
0-lógicoEspacio
Transición(Estado
indefinido)
1-lógico(Marca)
+ 15 voltios.
+ 5 voltios.
0 Voltios referencia común
- 5 voltios.
- 15 voltios. Figura 1.11 Niveles de Voltaje
Fuente: www.electrices-ubique.com/es/imagen/”·$%&.gif
0-lógicoEspacio
Transición(Estado
indefinido)
1-lógico(Marca)
+ 15 voltios.
+ 3 voltios.
0 Voltios referencia común
- 3 voltios.
- 15 voltios.
Figura 1.12 Niveles de Tensión Fuente: www.electrices-ubique.com/es/imagen/”·$%&.gif
16
Figura 1.13 Conexión DB-9 Fuente: www.google.com
1.1.2.6 Estándares
Estándar RS-232
RS-232C (fig. 2.13) es un estándar de cableado punto a punto
con una distancia práctica de cableado de 15 metros, o 50 pies,
máximo. Esto significa que sólo dos dispositivos pueden
comunicarse en una red de RS-232c, un sólo dispositivo
maestro y un sólo dispositivo esclavo, y la longitud de cable
total no debe exceder 50 pies.
Comparación la RS-232 con otras especificaciones: RS-232 (20 Kbps)
RS-530 (hasta 2Mbps)
V.35 (hasta 6 Mbps)
RS-449 (hasta 10Mbps)
HSSI (hasta 52Mbps) High Speed Serial Interface
Figura 1.14 Ilustración de Conexión de equipos RS-232 hacia Ethernet. Fuente: www.exemys.com
a.- Estándar RS-422
Es un estándar de múltiples puntos con una distancia práctica de cableado de 1000
metros, o 3280 pies, longitud total máxima. Esto significa que puede comunicarse un
maestro solamente, con hasta 10 esclavos, y la distancia total de toda la red entre
todos los dispositivos no puede exceder 1000 metros, o 3280 pies.
17
El estándar RS-422 no especifica una topología de la red, pero en la práctica, una
topología de conexiones múltiples en serie con el maestro en un extremo es la única
manera de hacer la comunicación confiable.
Figura 1.15 Ilustración de Conexión de equipos RS-422 a otros equipos
Fuente: Manual del PLC DL06, 2a. edición en español, 6/07
b.- Estándar RS-485
Es un estándar de cableado de múltiples puntos, con una distancia práctica de
cableado de 4000 pies máximo. Este estándar de cableado prevé la posibilidad de
hasta 32 maestros que se comunican con hasta 32 esclavos todos dentro de la
distancia máxima de 4000 pies.
Figura 1.16 Conectividad RED RS-485 Fuente: Manual del PLC DL06, 2a. edición en español, 6/07.
18
El estándar RS-485 no especifica una topología de red, pero en la práctica, una
topología de conexiones múltiples en serie con el maestro en un extremo es la única
manera de hacer la comunicación confiable.
Figura 1.17 Esquema de conexión de enlace entre PC y PLC. Fuente: Manual del PLC DL06, 2a. edición en español, 6/07
1.1.2.7 Protocolos.
No se va a entrar en detalle en los protocolos de comunicación, más bien se muestra
esta sección para indicar el uso profesional del puerto RS-232 de la PC, que es
ampliamente usada en la industria junto a sistemas SCADA profesionales
especializados en distintas áreas.
Contamos con los protocolos:
1.1.2.7.1 Protocolos Industriales:
Características:
Deben ser sistemas fáciles de reparar y mantener.
Deben poseer un alto nivel de integridad en la transferencia de datos.
Alta velocidad en la actualización de parámetros.
Industrial.• Tienen caracteristicas especiales.• La mayor parte son de propiedad privada.
Comunicación.• Por ejemplo BSC, DDCMP, HDLC
19
Se va a mencionar algunos de los protocolos dejando en mención que es para
beneficio del estudiante, técnicos e ingenieros y no debe interpretarse como
publicidad o violación de derecho de autor, ya que estos protocolos son de propiedad
privada.
a.- Protocolos ASCII.
Los protocolos ASCII son muy populares debido a su simplicidad, lo cual los hace
apropiados para instalaciones sencillas, generalmente una Maestra y una Remota.
Su principal desventaja es su lentitud y su incapacidad para manejar sistemas más
complicados, por ejemplo, sistemas multipunto de más de 32 remotas.
Figura 1.18 Ejemplo práctico de conectividad por protocolo ASCII Fuente: Manual del PLC DL06, 2a. edición en español, 6/07
En la práctica podemos encontrar dos tipos de protocolo ASCII: el protocolo ASCII
para Transmisores Digitales y el protocolo ASCII ANSI X3.28-2.5-A4; este último
es un poco más elaborado. La primera versión del protocolo ANSI X3.28 apareció en
1976.
20
Características
Control por Caracteres
Transmisión HDX asincrónica
Velocidades: entre 300 y 1200 bps
Interfaces: RS-232C en operación punto a punto. Si acaso se llega a utilizar
en operación multipunto, entonces hay que emplear la interfaz RS-485.
Estructura de los Formatos.
Comando desde el Procesador: Leer Datos (Read Data)
Caracteres → 1 1 1 1 1 1
# ADD R D BCC CR
Respuesta desde el Transmisor
Caracteres → 1 1 1 1 9 1 1
* ADD R D Valor del Dato BCC CR
b.- Protocolo HART
El Protocolo HART (Highway Addressable Remote Transducer) permite la
transmisión simultánea de información analógica y digital pues generalmente opera
superpuesto sobre el lazo de corriente de 4-20 mA, y utiliza una señal FSK (fig. 2.19)
para la transmisión digital binaria a 1200 bps, equivalente a un módem Bell 202
(2200 Hz para un Cero y 1200 Hz para un UNO).
21
Figura 1.19 Ejemplo práctico de conectividad por protocolo ASCII
Fuente: Manual del PLC DL06, 2a. edición en español, 6/07 El Protocolo HART se utiliza típicamente en configuración punto a punto, para la
configuración remota, ajuste de parámetros y diagnóstico de dispositivos de campo
inteligentes.
Características: Control por Conteo de Bytes
Transmisión Asincrónica HDX, punto a punto y multipunto
Carácter Básico de 1 bit de arranque, 8 de información, 1 de paridad impar y
1 de paridad; NRZ
Una Maestra puede controlar hasta 15 Remotas
Permite hasta 250 variables en cada dispositivo de campo
Distancia máxima: hasta 3000 m con par trenzado apantallado calibre AWG
24; hasta 1500 m con cable multipar, par trenzado común apantallado calibre
AWG 20.
Modulación FSK, 1200 bps, con Módems Tipo Bell 202
Interfaces asociadas: RS-232D y RS-485
c.- Protocolo Modbus
Modbus es un protocolo de transmisión desarrollado por la Gould Modicon (ahora
AEG Schneider Automation) para sistemas de control y supervisión de procesos
(SCADA) con control centralizado. Utilizando este protocolo, una Estación Maestra
(MTU) puede comunicarse con una o varias Estaciones Remotas (RTU) con la
finalidad de obtener datos de campo para la supervisión y control de un proceso. El
22
protocolo Modbus es muy utilizado en la industria en una gran variedad de sistemas
SCADA.
En Modbus los datos pueden intercambiarse en dos modos de transmisión: en Modo
RTU y en Modo ASCII. El Modo RTU, algunas veces denominado Modbus-B (por
Modbus Binario), es el tipo más común y es el que describiremos a continuación. En
el modo de transmisión ASCII los mensajes generalmente son de duración casi del
doble que en el modo de transmisión RTU.
Linea 1 Linea 2 TAP Linea 3 Linea 4 TIC
8 7 6 2 1 5Modbus Address
RS 485 (MODBUS)
10.175.132.6
Convertidor Multinet
Figura 1.20 Aplicación práctica de una RED RS-485 (MODBUS) hacia Ethernet. Fuente: Los Autores.
Aunque el Protocolo Modbus es anterior al desarrollo del Modelo ISO/OSI, se le
puede identificar tres niveles: un nivel de Capa Física, un nivel de Capa Enlace y un
nivel de Aplicación. En Modbus no se define una determinada interfaz de Capa
Física y el usuario puede elegir entre alguna de las interfaces vistas en el Capítulo III
que sea apropiada para las velocidades de transmisión definidas en el protocolo. A
continuación vamos a describir la Capa Enlace de Modbus. La descripción de la
Capa Aplicación queda fuera de los límites que nos hemos impuesto.
Características: Control por Conteo de Caracteres
Transmisión FDX/HDX asincrónica
Carácter Básico NRZ de ocho dígitos de información (transmitidos como dos
caracteres hexadecimales de cuatro dígitos), un dígito de arranque, un dígito
de paridad y un dígito de paridad; si no hay paridad, se toman dos dígitos de
paridad
Una Maestra puede controlar hasta 247 Remotas
Topología en Estrella
23
Interfaces de Capa Física: RS-232D, RS-422A, RS-485, o lazo de 4-20 mA
Velocidades de Transmisión: 1200 a 19200 bps
Medios de Transmisión: par trenzado, cable coaxial, radio
Figura 1.21 Modulo de comunicación MODBUS por Radio
Fuente: www.prosoft-technology.com
d.- Protocolo Bristol BSAP
El Protocolo BSAP (Bristol Synchronous/Asynchronous Protocol) de la Bristol
Babcock Instruments/Systems es un protocolo industrial utilizado para el control y
supervisión de sistemas SCADA. Es un protocolo muy completo con una topología
tipo árbol con un máximo de seis niveles y 127 nodos por nivel; a su vez, cada nodo
puede controlar hasta 127 dispositivos remotos.
Cada nodo tiene una dirección única basada en su posición en la red y puede ser
maestra de los niveles inferiores o esclava de los niveles superiores. Cumple con el
Modelo ISO/OSI en las cuatro primeras capas, fig. 1.22
Figura 1.22 Ejemplo práctico de conectividad por protocolo ASCII
Fuente: Manual del PLC DL06, 2a. edición en español, 6/07 Características del Protocolo Control por Caracteres (Modo Transparente)
24
Transmisión Asincrónica/Sincrónica HDX y FDX
Operación en Modo de Respuesta Normal y Par a Par
Carácter básico codificado en ASCII sin bit de paridad
Interfaces de Capa Física: RS-232C, RS-422A, RS-423A y RS-485
Velocidades de transmisión: Sincrónico: 187,5 Kbps, 1 Mbps
Asincrónico: 300 bps a 38,4 Kbps
Medios de transmisión: par trenzado, cable coaxial, radio
Conclusión: Para poder visualizar los equipos dentro de una PC debemos considerar
el protocolo de comunicación, el medio por el cual se van a comunicar, la aplicación
en que se va a desarrollar, lo más importante es los drivers de comunicación de los
dispositivos. En este caso mostramos una esquema de la firma automation direct,
recoge las señales de varios PLC y dispositivos, vemos convertidor de RED-485 a
Ethernet, comunicación RS-232 directa al PC, ejemplo lo expuesto anteriormente.
Figura 1.23 Aplicación Integral
Fuente: www.automationdirect.com/dl205
1.1.2.7.2 Protocolos de Comunicación.
a.- Protocolo BSC Se ha desarrollado toda una variedad de protocolos de control por caracteres, pero el
más conocido es el Protocolo BSC (Binary Synchronous Communications)
desarrollado por la IBM; a este protocolo se le denomina también Protocolo BISYN.
25
Este protocolo utiliza ciertos caracteres de control para delimitar los diferentes
campos y para el control de sus funciones propias.
El protocolo BSC es un protocolo sincrónico que opera en HDX y requiere un
reconocimiento para cada trama transmitida antes de enviarse la trama siguiente.
Este protocolo está diseñado para trabajar en punto a punto o en multipunto con una
sola estación de control o estación primaria; esta es la denominada operación
Maestra-Esclava.
Los caracteres de control en el protocolo BSC son los siguientes por orden
alfabético: ACK, DLE, ENQ, EOT, ETB, ETX, NAK, SOH, STX y SYN.
Estos diez caracteres están definidos en los Códigos ASCII, EBCDIC y en el
Transcódigo de 6 Dígitos (Six Bit Transcode).
Figura 1.24 enlace mediante Protocolo BSC Fuente: Folleto Protocolos de Comunicación
b.- Protocolo DDCMP La principal desventaja del protocolo BSC es la complicación que se produce como
resultado de los procedimientos especiales utilizados para asegurar la transparencia.
Este problema se ha resuelto en el Protocolo DDCMP (Digital Data Communication
Message Protocol) desarrollado por la DEC (Digital Equipment Corporation), en el
cual mediante el conteo de los caracteres u octetos contenidos en el campo
INFORMACION se ha eliminado la utilización de DLE y de otros caracteres de
control.
26
El Protocolo DDCMP es un protocolo general y puede utilizarse en sistemas HDX y
FDX, serie o paralelo, asincrónicos y sincrónicos, punto a punto y multipunto.
c.- Protocolo HDLC El protocolo SDLC se había convertido en un “protocolo de facto” por la cantidad de
aplicaciones en donde se utilizaba, y cuando la IBM lo presentó a la ISO fue
aceptado y con muchas modificaciones que mejoraron sus prestaciones, se publicó
en 1976 con el nombre de Protocolo HDLC (High-Level Data Link Control
Protocol), ISO 3309-76(E).
HDLC es el protocolo más importante de la capa de enlace del modelo OSI.
Es un protocolo orientado a bit.
Es la base de otros protocolos como LAPB, LAPD.
Protocolo para comunicar dos niveles del mismo tipo (el nivel de enlace).
Protocolos que utilizan un delimitador o flag para indicar el final de trama.
Utilizan un formato de trama estándar.
1.1.3 Puerto USB.
El USB o Universal Serial Bus es una interfaz para la transmisión serie de datos y
distribución de energía desarrollado por empresas líderes del sector de las
telecomunicaciones y de los ordenadores y que ha sido introducida en el mercado de
los PC´s y periféricos para mejorar las lentas interfaces serie (RS-232) y paralelo.
Tenía en un principio como objetivo el conectar periféricos relativamente lentos
(ratones, impresoras, cámaras digitales, unidades ZIP, etc.) de una forma realmente
sencilla, rápida y basada en comunicaciones serie, aunque por sus características
también podía conectarse hasta discos duros.
Figura 1.25 Velocidades de transmisión
Fuente: Los Autores.
27
Esta interfaz de 4 hilos distribuye 5V para la alimentación y puede transmitir datos a
una velocidad de hasta 480 Mbps en su versión 2.0.
Es un bus serie que hace posible la conexión de hasta 127 periféricos a una única
puerta de un PC, con detección y configuración automáticas, siendo esto posible con
el PC conectado a la red y sin tener que instalar software adicional, y sin tener que
reiniciar el ordenador (plug and play, algo que con los puertos convencionales serie y
paralelo no sucedía. Tampoco hay que preocuparse por conflictos de IRQ’s o instalar
tarjetas de adaptador para cada periférico.
Estos periféricos pueden ser: Ratones, teclados, impresoras, escáneres, grabadoras,
discos duros, módems, cámaras digitales, PLC, Microcontroladores, teléfonos, en fin
una gama de productos y dispositivos existentes en el mercado tecnológico.
Figura 1.26 Conexión dispositivos por el puerto USB.
Fuente: Los autores.
El éxito de la interfaz USB ha sido tal que, actualmente todos los PCs tienen
integrados a lo menos dos puertos USB para la conexión de dispositivos. Los PCs
modernos además de tener los dos traseros pueden tener más puertos en el frontal
para facilitar su conexión. A falta de puertos se pueden acoplar hub’s USB para
ampliar el número de dispositivos siempre que no se sobrepase el limite soportado de
127.
Como desventaja principal nos encontramos con que el ancho de banda debe
repartirse entre todos los dispositivos conectados a él. Lo que quizás no tendría
repercusión si intentáramos conectar varios ratones, pero sí que la tendría si
queremos grabar CD’s en varias grabadoras en paralelo.
28
Uno de los grandes problemas que tienen los PCs (problemas que se han heredado a
través de los tiempos debido a un diseño deficiente en algunos aspectos) es la escasez
de determinados recursos, básicamente líneas de interrupción IRQ’s y canales de
acceso directo a memoria DMA’s. En ambos casos las capacidades del diseño inicial
tuvieron que ser dobladas en 1984, tres años después de su lanzamiento,
aprovechando la aparición de la gama AT.
La instalación de periféricos ha sido un constante quebradero de cabeza para los
ensambladores, que debían asignar los escasos recursos disponibles entre los
dispositivos del sistema. Aunque el estándar PnP ("Plug and Play") vino a aliviar en
parte las dificultades mecánicas de cambiar "jumpers" en las placas, el problema
seguía ahí, ya que desde la aparición del AT el diseño del PC no había sufrido
cambios sustanciales.
Por otra parte, a pesar de que habían persistido desde los inicios del PC, y de su
conveniencia para multitud de aplicaciones, los puertos serie y paralelo presentaban
claras limitaciones en cuanto a capacidad de expansión y rendimiento se refiere.
Por estas razones y como resultado de un intento de dotar al PC de un bus de alta
velocidad que ofreciera las características ideales (PnP, universalidad, facilidad de
conexión y desconexión incluso en caliente (“Hot Swappable”)...), un consorcio
formado por multitud de empresas –las empresas que formaron el grupo inicial
fueron siete:
Compaq, Intel, IBM, Microsoft, Nec, Northern Telecom y Digital Equipment–
desarrolló una nueva interfaz estándar para la conexión de dispositivos externos del
PC, el denominado puerto USB Universal Serial Bus.
Como su nombre indica, es un bus serie bidireccional y de bajo coste, diseñado como
una extensión en la arquitectura estándar del PC y orientado principalmente a la
integración de periféricos y en sus orígenes dirigidos a la integración de dispositivos
telefónicos CTI en los ordenadores (Computer Telephony Integrations).
29
1.1.3.1 Historia del puerto USB
Año Mes Suceso
1994 Noviembre Compaq, Intel y el resto de empresas iniciaron
las especificaciones del Universal Serial Bus
1994 30 Diciembre USB 0.8 (Borrador)
1995 13 Abril USB 0.9 (Borrador)
1996 15 Enero USB 1.0 - Velocidad Oficial 12 Mbps
1996 Febrero Intel anuncia sus primeros chips controladores
de USB
1996 Agosto
Microsoft saca la versión de Windows 95 OSR
2.1 que introduce los controladores
correspondientes para el manejo de los
dispositivos USB
1998 Marzo Sale a la venta el iMac de Apple que utilizaba el
USB 1.0 para la conexión de teclado y ratón
1998 24 Junio
Sale al mercado el Windows 98, el primer
Sistema Operativo con completo soporte para
USB
1998 23 Septiembre USB 1.1 - Revisión completada (USB-IF-
>Compaq, Intel, Microsoft, NEC)
1998 Noviembre
USB-IF supera el record mundial de periféricos
conectados a un simple PC mediante USB (111
periféricos)
1999 Se forma el grupo promotor del USB 2.0
30
1999 Febrero Se propone 240 Mbps como velocidad
1999 12 Octubre Versión 0.79 del USB 2.0. Se aumenta la
velocidad a 480 Mbps
1999 21 diciembre Versión 0.9 del USB 2.0
2000 29 febrero
In-Systems muestra la primera unidad de
almacenamiento USB 2.0, una unidad zip
modificada
2000 17 Marzo Microtech y Netchip muestran su scanner USB
2.0 en el foro de desarrollo de Tokio
2000 27 Abril
USB 2.0 - Velocidad Oficial 480 Mbps (USB-
IF->Compaq, Hewlett-Packard, Intel, Lucent,
Microsoft, NEC, Philips)
2001 18 Diciembre USB 2.0 OTG- (On-The-Go) Ampliación del
USB 2.0.
2002 Mayo
Intel saca a la venta los primeros chipsets que
integran Hi-speed USB 2.0 en el Controlador de
Hub de I/O (ICH4). Estos chipsets fueron el
Intel 845E, 845G y el 845GL.
Tabla1.4: historial de progreso del puerto USB Fuente: www.usb.org
Septiembre del 2007 Intel, integrante y principal impulsor del USB, ha montado junto a empresas como
HP, Microsoft, NEC Corporation, NXP o Texas Instruments, el USB 3.0 Promoter
Group. Durante una conferencia en San Francisco, hace unos días desvelaron algunas
de las características de la nueva versión. Aunque los datos no se confirmarán
oficialmente hasta el año que viene, parece que el USB 3.0 alcanzará una tasa de
transferencia de 4,8 Gigabits por segundo, frente a los 480 Megabits por segundo a
los que llega el USB 2.0. La mejora se debe a que, además de los pares de cobre que
31
ya llevaban las versiones anteriores, este nuevo tipo de conexión llevará también
fibra óptica.
Detallamos conector en la sección siguiente
1.1.3.2 Características generales del USB
La especificación del USB proporciona una serie de características que pueden ser
distribuidas en categorías. Estas características son comunes para todas las versiones
(desde la 1.0 hasta la 2.0)
a.- Fácil uso para los usuarios: Modelo simple para el cableado y los conectores.
Detalles eléctricos aislados del usuario (terminaciones del bus).
Periféricos auto-identificativos
Periféricos acoplados y reconfigurados dinámicamente (Hot Swappable)
b.- Flexibilidad Amplio rango de tamaños de paquetes, permitiendo variedad de opciones de
buffering de dispositivos
Gran variedad de tasas de datos de dispositivos acomodando el tamaño de
buffer para los paquetes y las latencias
Control de flujo para el manejo del buffer construido en el protocolo
c.- Ancho de banda isócrono Se garantiza un ancho de banda y bajas latencias apropiadas para telefonía,
audio...
Cantidad de trabajo isócrono que puede usar el ancho de banda completo del
bus.
Control de flujo para el manejo del buffer construido en el protocolo
Amplia gama de aplicaciones y cargas de trabajo
Adecuando el ancho de banda desde unos pocos Kbps hasta varios Mpbs.
Soporta tanto el tipo de transferencia isócrono como el asíncrono sobre el
mismo conjunto de cables.
32
Conexiones múltiples, soportando operaciones concurrentes de varios
dispositivos.
Soporta hasta 127 dispositivos físicos.
Soporta la transferencia de múltiples datos y flujos de mensajes entre el host
y los dispositivos
d.- Robustez Manejo de errores y mecanismos de recuperación ante fallos implementados
en el protocolo.
Inserción dinámica de dispositivos
Soporte para la identificación de dispositivos defectuosos.
e.- Implementación de bajo coste Sub canal de bajo coste a 1.5 Mbps
Conectores y cables de bajo coste
Adecuado para el desarrollo de periféricos de bajo coste
1.1.3.3 Versiones del USB
a.- Versión 1.0
Esta versión, publicada en Enero 1996, fue iniciada por el USB-IF cuyos integrantes,
ya comentábamos antes (COMPAQ, Digital Equipment Corp., IBM, Intel Corp.,
Microsoft Corp., NEC y Northern Telecom).
Esta es la primera versión oficial que salió a la luz y que reúne todas las
características arriba mencionadas, con un límite máximo de velocidad de 12 Mbps
Inicialmente la especificación USB fue diseñada para conectar eficientemente
teléfonos a PCs. Sin embargo, este nuevo estándar de conectividad tuvo tanto éxito
que el Foro de implementadores decidió empujar al USB como un estándar de PC, a
pesar que el desarrollo de dispositivos USB para telefonía aún no se ha realizado.
En la siguiente tabla podemos observar el alcance de aplicación del USB con
respecto a la velocidad máxima establecida por las características del bus. Esto es
también aplicable a las versiones 1.x del bus.
33
RENDIMIENTO APLICACIONES ATRIBUTOS
VELOCIDAD BAJA Teclado y ratón Bajo coste
Dispositivos Interactivos Periféricos de
entretenimiento
(Des)Conexión en
caliente
10-100 Kb/s Configuración del Monitor Fácil uso
VELOCIDAD MEDIA
Teléfono ISDN/RDSI Bajo coste
Audio PBX
(Des)Conexión en
caliente
Video comprimido POTS Fácil uso
500 Kb/s - 10 Mb/s Audio
Múltiples dispositivos.
Garantizada la latencia
Garantizado el ancho
de banda
Tabla1.5: Velocidad del puerto USB Fuente: www.usb.org
b.- Versión 1.1
El objetivo de esta segunda versión, que salió a la luz en Septiembre de 1998, era
solucionar problemas de ambigüedad en la especificación 1.0 para facilitar el trabajo
a los desarrolladores tanto de software como de hardware sin que hubiera que hacer
cambios en los dispositivos para hacerlos funcionar bajo esta versión.
No se hicieron cambios en los controladores de host para mantener esta
compatibilidad.
El alcance de aplicación de esta versión coincide con la de su predecesora, así como
sus características generales.
34
Dado que el USB se le dio una aplicación distinta a la de las telecomunicaciones,
IBM y Northern Telecom no continuaron como miembros. Para esta especificación
solo quedaron COMPAQ, Intel, Microsoft y NEC ya que Digital Equipment Corp. es
ahora parte de COMPAQ.
c.- Versión 2.0
Esta versión que salió al mercado a mitad del 2000, tras la unión al consorcio de
otras 3 compañías (Hewlett Packard, Philips y Lucent), con lo que volvían a ser siete
las integrantes del USB-IF.
Como principal característica nos encontramos con un aumento de velocidad hasta
480 Mbps (casi 40 veces la velocidad anterior) con una diferencia de coste casi
mínimo. De este aumento de velocidad le viene el nombre de Hi-Speed, que es fácil
de confundir con Full-Speed.
Full-Speed era el término que se le daba a las versiones USB 1.x que alcanzaban 12
Mbps, por lo que se debe tener en cuenta a la hora de hablar sobre ello.
Este incremento de velocidad ha permitido sustituir en muchos casos el interfaz SCSI
por el USB. En total USB 2.0 soporta tres tipos distintos de velocidad:
Hi-Speed 480 Mbps
Full-Speed 12 Mbps
Low-Speed 1.5 Mbps
El alcance de uso para la versión USB 2.0 se ve incrementada notablemente respecto
a sus predecesoras. Así quedaría la tabla anterior modificada.
RENDIMIENTO APLICACIONES ATRIBUTOS
VELOCIDAD
ALTA
Video Video Gran ancho de banda
35
Unidades de
almacenamiento
Discos duros y
grabadoras Latencia garantizada
Video Comprimido Fácil uso
25-500 Mb/s
Básicamente, USB 2.0 incluye todo lo que ofrece USB 1.1 y añade el modo de alta
velocidad. USB 2.0 también usa el mismo tipo de cables y conectores para conectar
los dispositivos de alta velocidad, sin embargo los hub’s USB clásicos ralentizarán
los dispositivos USB 2.0. Otro requisito es que es necesario un controlador de host
para USB 2.0 si queremos tener disponibles la conexión de alta velocidad con un
dispositivo de este tipo.
Los hub’s USB 2.0 tienen ahora mucho más trabajo que hacer que en el USB 1.1 ya
que necesitan manejar todo el tráfico de tres tipo de dispositivos con velocidades
distintas. Conectando un dispositivo USB 1.1 en uno USB 2.0 funcionaría bien, pero
no lo haría si lo hiciéramos al revés, además de ralentizarse a 12 Mbps,
posiblemente, el sistema operativo avisaría de su mal uso.
La forma de distinguir si tu ordenador tiene USB de alta velocidad es mediante los
logotipos registrados por el grupo promotor del USB (el USB-IF), que como se
puede ver más arriba está etiquetado en rojo con Hi-Speed. Dicho logotipo sólo lo
pueden usar las empresas desarrolladas de hardware que hayan pasados los test’s del
USB-IF.
Cabe destacar que el USB 2.0 es simplemente una extensión y nunca llegara a
reemplazar completamente al 1.1 ya que hay productos como teclados genéricos,
ratones, joysticks o altavoces que no requieren la gran velocidad que ofrece la
tecnología USB 2.0. Sólo dispositivos de alta velocidad como webcams o sistemas
de alta capacidad necesitarán el máximo de velocidad, aunque los ordenadores los
fabriquen sólo con puertos USB 2.0.
36
Figura 1.28 Ejemplos Conexión USB OTG
Fuente: Los Autores
d.- Versión USB OTG
USB OTG o "USB-On-The-Go" es un variación de la especificación USB 2.0 que
permite a un sólo puerto actuar como servidor o como dispositivo, más
concretamente permitiría comunicarse a todo tipo de unidades con USB directamente
entre ellas sin la necesidad de ordenador. Incluso después de que el cable está
conectado y las unidades se están comunicando, las dos unidades pueden "cambiar"
de rol bajo el control de un programa.
Figura 1.27 Logo Conexión USB OTG
Fuente: www.usb.org
En resumen, USB On-The-Go define las siguientes características añadidas a la
especificación USB:
Un nuevo estándar para conectores USB y cables (Mini conectores)
El hecho de que dispositivos que antes eran solamente periféricos ahora
puedan ser hosts (dual-role devices) .
La capacidad de ser host y periféricos y cambiar dinámicamente de rol según
convenga (el uso del Host Negotiation Protocolo HNP para el cambio de rol)
Protocolo de petición sesión (Session Request Protocol o SRP).
Requisitos de bajo consumo para promocionar el USB en dispositivos
alimentados con baterías (opción Micropower añadido a las ya existentes low
y high power).
Esta tecnología podría ser muy útil para dispositivos como el PDA, donde el enlace
USB podría conectarse a un PC como un dispositivo o conectarse como servidor a un
teclado o ratón.
37
Host Periférico Aplicación
Teléfono móvil Teléfono móvil
Cámara digital
Reproductor MP3
Scanner
Intercambiar información
de contactos
mandar por mail fotos
Subir fotos a una web
Subir/bajar música
Cámara Digital Cámara digital
Teléfono móvil
Impresora
Dispositivo de
almacenamiento
Intercambiar fotos
Mandar por mail fotos
Subir fotos a una web
Imprimir fotos
Almacenar fotos
Impresora Cámara digital
Scanner
Dispositivo de
almacenamiento
Imprimir fotos
Imprimir imágenes
escaneadas
Reproductor MP3 Reproductor MP3
Dispositivo de
almacenamiento
Intercambiar canciones
Subir/bajar canciones
Osciloscopio Impresora Imprimir imágenes
PDA PDA
Impresora
Teléfono móvil
Reproductor MP3
Escáner
Dispositivo de
almacenamiento
GPS
Cámara digital
Osciloscopio
Intercambiar ficheros
Imprimir ficheros
Subir/bajar ficheros
Subir/bajar música
Escanear fotos
Obtener direcciones
Información de mapas
Subir fotos
Configurar un osciloscopio
Tabla1.6: Periféricos que utilizan el puerto USB Fuente: www.usb.org
38
Dependiendo de la velocidad de transmisión (low-speed o Hi-Speed) existen dos
logotipos que identifica la existencia de un puerto USB On-The-Go en el dispositivo
y que es fácilmente identificable al igual que con el resto de especificaciones.
e.- Versión 3.0
USB 3.0, la próxima versión del estándar USB (fig.1.29), alcanzará una velocidad de
transferencia de 4.8Gbps, diez veces la velocidad de USB 2.0 (480Mbps)
Figura 1.29 Conector USB 2.0
Fuente: www.usb.org
Como podemos ver en la fig. 1.30, en USB 3.0 se añaden cinco contactos nuevos que
son los que utiliza el canal de alta velocidad. Los cuatro contactos clásicos se
mantienen, para mantener la compatibilidad con USB 2.0. Es decir, el conector
contiene nueve contactos en total.
Figura 1.30 Conector USB 3.0
Fuente: www.usb.org
El que es totalmente nuevo es la versión mini-USB (fig. 1.31); por lo que se puede
ver en el dibujo, parece que solo incluye los cinco contactos para el canal de alta
velocidad; si esto es así significa que no será compatible con el conector mini-USB
actual.
Figura 1.30 Mini conector USB 3.0 Fuente: www.usb.org
39
1.1.3.4 Topología del bus
El Universal Serial Bus conecta los dispositivos USB con el host USB. La
interconexión física USB es una topología de estrellas apiladas donde un hub es el
centro de cada estrella. Cada segmento de cable es una conexión punto-a-punto entre
el host y los hub’s o función, o un hub conectado a otro hub o función.
El número máximo de dispositivos que puede conectar USB es de 127, pero debido a
las constantes de tiempo permitidas para los tiempos de propagación del hub y el
cable, el número máximo de capas permitido es de siete (incluida la capa raíz) con un
máximo de longitud de cable entre el hub y el dispositivo de 5 metros. Cabe destacar
que en siete capas, sólo se soportan cinco hub’s que no sean raíz en una ruta de
comunicación entre el host y cualquier dispositivo. Un dispositivo compuesto ocupa
dos capas, por eso, no puede ser activado si está acoplado en la última capa de nivel
siete.
Figura 1.31 Topología del bus
Fuente: http://usuarios.lycos.es/kurganz/datos_tecnicos/topologia.html
La topología del bus USB se puede dividir en tres partes:
La capa física: Como están conectados los elementos físicamente
La capa lógica: Los roles y las responsabilidades de los elementos USB
40
La relación software del cliente-función: Como se ven mutuamente el
software del cliente y los interfaces de las funciones relacionadas
Figura 1.31 División de la topología del bus
Fuente: http://usuarios.lycos.es/kurganz/datos_tecnicos/topologia.html
1.1.3.4.1 La capa física
La arquitectura física del USB se centra en las piezas de plástico y de metal con las
que el usuario debe tratar para construir un entorno USB.
Cada entorno físico USB está compuesto por cinco tipos de componentes:
El host
El controlador del host
Los enlaces
Los dispositivos
Los hub’s
Los dispositivos están conectados físicamente al host a través de una topología en
estrella, como se ilustra en la figura.
41
Los puntos de acople están provistos de una clase de dispositivos USB llamados
hub’s, los cuales tienen puntos de acople adicionales llamados puertos.
Estos hub’s se conectan a otros dispositivos a través de enlaces (cables de cuatro
hilos).
El host proporciona uno o más puntos de acople a través del hub raíz.
Para prevenir los acoples circulares, se impone una estructura ordenada por capas en
la topología de estrella y como resultado se obtiene una configuración al estilo de un
árbol como se ve en la figura.
Todas las comunicaciones físicas son iniciadas por el host.
Esto quiere decir que cada milisegundo, o en cada ventana de tiempo que el bus lo
permita, el host preguntará por nuevos dispositivos en el bus USB. Además el host
inicia todas las transacciones físicas y soporta todas las transferencias de datos sobre
la capa física
a.- El host USB
El host es el sistema de computación completo, incluyendo el software y el hardware,
sobre el cual se sostiene el USB.
El host tiene la habilidad de procesar y gestionar los cambios de configuración que
puedan ocurrir en el bus durante su funcionamiento. El host gestiona el sistema y los
recursos del bus como el uso de la memoria del sistema, la asignación del ancho de
banda del bus y la alimentación del bus. El host también ayuda al usuario con la
configuración automática de los dispositivos conectados y reaccionando cuando son
desconectados.
Un host puede soportar uno o más buses USB. El host gestiona cada bus
independientemente de los demás. Los recursos específicos del bus como el ancho de
banda asignado son únicos a cada bus. Cada bus está conectado al host a través de un
controlador del host.
42
Sólo hay un host en cualquier sistema USB. Desde el interfaz USB hasta el sistema
de host del ordenador es lo que se le llama controlador de host y puede estar
implementado como combinación de hardware, firmware o software. Integrado
dentro del sistema de host hay un hub raíz que provee de un mayor número de
puntos de acople al sistema.
Siempre que es posible, el software del USB usa el interfaz existente del sistema de
host para gestionar las interacciones superiores. Por ejemplo, si un sistema de host
usa la Gestión de Energía Avanzada (APM), el software del USB conecta al APM
para interceptar, suspender las notificaciones.
b.- El controlador del host
El controlador de host está formado por el hardware y el software que permite a los
dispositivos USB ser conectados al host. Este controlador es el agente iniciador del
bus, es decir es el que comienza las transferencias en el bus.
El controlador de bus es el maestro en un bus USB. Otros buses como PCI, permiten
la presencia de múltiples maestros donde cada uno arbitra sus accesos al bus. El la
arquitectura USB sólo hay un controlador de host por cada bus USB y por eso no hay
arbitración para el acceso al bus.
Como las transferencias de datos de los dispositivos pueden ser basadas en datos o en
la disponibilidad espacial del dispositivo, la mayoría de los controladores de host
están implementados como dispositivos maestros de bus PCI.
Esto permite al controlador de host iniciar una transferencia de datos en el bus del
sistema cuando le sea necesario, sin requerir la intervención del host de la CPU para
cada transferencia.
El controlador se comporta como un bus maestro PCI multicanal programable para dar
soporte a las necesidades de transferencia de datos de múltiples dispositivos conectados al
bus USB. La figura de la izquierda muestra una vista conceptual del controlador del
bus USB.
43
La parte software consiste en el driver del controlador de host (HCD). Este software
interactúa con el hardware del controlador de host a través del interfaz
hardware/software.
La parte hardware del controlador de host consiste en un hub raíz que proporciona
los puertos USB y los buffers de datos (colas) donde son almacenadas cuando son
movidas a/desde memoria.
El host USB interactúa con los dispositivos USB a través del controlador. Las
funciones básicas del controlador de host son:
Detectar la inserción o desconexión de dispositivos USB.
Gestionar el flujo de control entre el host y los dispositivos.
Gestionar el flujo de datos entre el host y los dispositivos
Coleccionar estadísticas de actividad y estado
Proveer una cantidad limitada de energía a los dispositivos conectados
Hay dos implementaciones estandarizadas de la parte hardware de los controladores
de host USB. Ambas proporcionan la misma funcionalidad y rendimiento para la
interconexión. Estas implementaciones son:
El Universal Host Controller Inteface (UHCI) definido por Intel
Open Host Controller Interface (OpenHCI o OHCI) definido por Microsoft
UHCI está definido como que la parte software tiene una gran responsabilidad para
mantener el hardware en funcionamiento. Esto permite a esta implementación ser
relativamente simple y realizarse con un bajo número de puertas.
OHCI está definida como que la parte hardware tiene más responsabilidad por el
mantenimiento del flujo de datos, para que la parte software tenga menos trabajo que
hacer. Esta otra implementación tiende a ser más compleja y tiene una cantidad
mayor de puertas que la UHCI
c.- Dispositivos USB
Un dispositivo es una colección de funcionalidad que lleva a cabo algún propósito de
utilidad. Por ejemplo, un dispositivo podría ser un ratón, un teclado, una cámara...
44
Puede haber múltiples dispositivos simultáneamente en el mismo bus. Cada
dispositivo lleva consigo información que puede ser útil para identificar sus
características. La información que describe al dispositivo se encuentra asociada con
el canal de control. Esta información se divide en tres categorías:
Estándar: Esta es la información cuya definición es común a todos los
dispositivos USB e incluye elementos como la identificación del fabricante,
la clase, la gestión de energía....
Clase: La definición de esta información varía dependiendo del aparato. Es
una clasificación de los dispositivos en cuanto a sus prestaciones.
USB Vendor: El fabricante del periférico puede poner aquí cualquier
información deseada.
El software del host es capaz de determinar el tipo de dispositivo conectado haciendo
uso de esta información y de un direccionamiento individual. Todos los dispositivos
USB son accedidos por una dirección USB que es asignada dinámicamente cuando
se conecta, asignándole también un número. Cada aparato soporta además uno o más
canales a través de los cuales el host puede comunicarse con el dispositivo. Una vez
ha sido reconocido e identificado el dispositivo, el software del host puede hacer que
los drivers del dispositivo apropiados obtengan el control del nuevo dispositivo
conectado.
Cuando desconectamos el dispositivo, la dirección puede ser reutilizada para el
próximo dispositivo conectado.
En cuanto a los tipos de dispositivos nos encontramos con dos clases:
Hub’s, que proporcionan los puntos de acople adicionales al USB.
Funciones, que le dan al sistema la funcionalidad (impresoras, unidades de
almacenamiento...).
Funciones
Una función es un dispositivo USB que es capaz de transmitir y recibir datos o
información de control sobre el bus. Típicamente se implementa como un periférico
45
separado con un cable que se conecta en un puerto del hub. Sin embargo hay una
gran flexibilidad a la hora de construir dispositivos. Una función simple pueden dar
una funcionalidad simple (un micrófono, unos altavoces...) o puede estar compuesto
en distintos tipos de funcionalidad, como unos altavoces con un panel LCD. Este tipo
de dispositivos se les llama funciones múltiples o dispositivo compuesto.
Otra forma de construir productos con múltiples funciones es creando un dispositivo
compuesto. Este es el término usado cuando un hub está acoplado junto a múltiples
dispositivos USB dentro de un mismo paquete. El usuario verá una sola unidad en el
extremo del cable, pero internamente tiene un hub y varios dispositivos. Este tipo de
"paquetes" tienen una dirección de bus para cada uno de los componentes, en
contraposición a los dispositivos compuestos que tienen una única dirección.
Un buen ejemplo de un dispositivo compuesto sería un teclado USB que tuviera una
conexión adicional para ratón. A pesar de que el teclado es un periférico, en este caso
se le puede acoplar un ratón y por supuesto se necesitaría de un hub interno en el
teclado para que esto pueda funcionar.
Cada función contiene la información sobre la configuración que describe su
capacidad y requisitos en cuestión de recursos. Antes de que una función pueda ser
usado debe ser configurado por el host.
Algunos ejemplos de funciones pueden ser los siguientes:
Una interfaz humana (HID) como ratón, teclado, tablas digitalizadoras o
controladores de juegos
Dispositivos de imágenes: cámaras, escáneres o impresoras
Dispositivos de almacenamiento: CD-ROM’s, DVD’s disqueteras...
1.1.3.4.2 La capa lógica
El punto de vista lógico presenta capas y abstracciones que son relevantes para los
distintos diseñadores e implementadores. La arquitectura lógica describe como unir
el hardware del dispositivo USB a un driver del dispositivo en el host para que tenga
el comportamiento que el usuario final desea.
46
La vista lógica de esta conexión es la mostrada en el esquema siguiente. En el
podemos ver como el host proporciona conexión al dispositivo, donde esta conexión
es a través de un simple enlace USB. La mayoría de los demás buses como PCI, ISA,
etc. proporcionan múltiples conexiones a los dispositivos y los drivers lo manipulan
mediante algunas combinaciones de estas conexiones (I/O y direcciones de memoria,
interrupciones y canales DMA).
Físicamente el USB tiene sólo un cable simple de bus que es compartido por todos
los dispositivos del bus. Sin embargo, desde el punto de vista lógico cada dispositivo
tiene su propia conexión punto a punto al host.
Aunque la mayoría de las actividades de los hosts o de los dispositivos lógicos usan
esta perspectiva lógica, el host mantiene el conocimiento de la topología física para
dar soporte al proceso de desconexión de los hub’s. Cuando se quita un hub, todos
los dispositivos conectados a él son quitados también de la vista lógica de la
topología.
1.1.3.4.3 La relación "Software del cliente-función"
A pesar de que la topología física y lógica del USB refleja la naturaleza de
compartición del bus, la manipulación del interfaz de una función USB por parte del
software del cliente (CSw) se presenta con una vista distinta.
El software del cliente para las funciones USB debe usar el interfaz de programación
software USB para manipular sus funciones en contraposición de las que son
manipuladas directamente a través de la memoria o los accesos I/O como pasa con
otros buses (PCI,EISA,PCMCIA,...). Durante esta operación, el software del cliente
debería ser independiente a otros dispositivos que puedan conectarse al USB.
1.1.3.5 Tipos de transferencias
La interpretación de los datos que se transmitan a través de las tuberías,
independientemente de que se haga siguiendo o no una estructura USB definida,
corre a cargo del dispositivo y del software cliente. No obstante, USB proporciona
47
cuatro tipos de transferencia de datos sobre las tuberías para optimizar la utilización
del bus en función del tipo de servicio que ofrece la función.
Estos cuatro tipos son:
Transferencias de control
Transferencias isócronas
Transferencias de interrupción
Transferencias de bultos.
a.- Transferencias de control
Es el único tipo de transferencia que utiliza tuberías de mensajes, soporta por lo tanto
comunicaciones de tipo configuración/comando/estado entre el software cliente y su
función. Una transferencia de tipo control se compone de una transacción de setup
del host a la función, cero o mas transacciones de datos en la dirección indicada en la
fase de setup, y por último una transacción de estado de la función al host. La
transacción de estado devolverá éxito cuando el end point haya completado
satisfactoriamente la operación que se había solicitado.
Por lo tanto este tipo de transferencia está pensado para configurar, obtener
información, y en general para manipular el estado de los dispositivos. El tamaño
máximo de datos que se transmiten por el bus viene determinado por el end point. En
dispositivos de velocidad media los posibles tamaños máximos son de 8, 16, 32 o 64
bytes, en velocidad baja el tamaño es de 8 bytes y en velocidad alta 64 bytes. El
porcentaje de (micro) frame utilizado ronda el 30% en velocidad baja, 5% en
velocidad media y el 2% en alta.
El end point puede estar ocupado durante la fase de envío de datos y la fase de
estado, en esos casos el end point indica al host que se encuentra ocupado, invitando
al host a intentarlo mas tarde. Si el end point recibe un mensaje de setup y se
encontraba en mitad de una transferencia de control, aborta la transferencia actual y
pasa a la nueva que acaba de recibir. Normalmente el host no inicia una nueva
transferencia de control con un end point hasta que no ha acabado la actual, si bien
debido a problemas de transmisión el host puede considerar que se han producido
48
errores y pasar a la siguiente. USB proporciona detección y recuperación, vía
retransmisión, de errores en las transferencias de control.
b.- Transferencias isócronas
Hacen uso de tuberías stream. Garantiza un acceso al bus USB con una latencia
limitada, asegura una transmisión constante de los datos a través de la tubería
siempre y cuando se suministren datos, además en caso de que la entrega falle debido
a errores no se intenta reenviar los datos.
USB limita el máximo tamaño de datos para los end points con tipo de transferencia
isócrona a 1023 bytes para los end points de velocidad media y 1024 bytes para
velocidad alta. De hecho las transferencias isócronas solo se pueden usar en
dispositivos de velocidad alta o media. En función de la cantidad de datos que se
estén transmitiendo en un momento dado, en velocidad medio el porcentaje de frame
utilizado puede variar desde un 1% hasta un 69%, mientras que el porcentaje de
microframe utilizado en velocidad alta varía entre un 1% y un 41%.
c.- Transferencias de interrupción
Utiliza tuberías stream. Este tipo de transferencia está diseñado para servicios que
envían o reciben datos de forma infrecuente. Esta trasferencia garantiza el máximo
servicio para la tubería durante el periodo en el que envía. En caso de error al enviar
los datos se reenvían en el próximo periodo de envío de datos.
El tamaño de paquete de datos máximo es de 1024 bytes para alta velocidad, 64
bytes para velocidad media y 8 bytes para baja velocidad. En ningún caso se precisa
que los paquetes sean de tamaño máximo, es decir, no es necesario rellenar los
paquetes que no alcancen el máximo. Cuando en una transferencia de interrupción se
necesite transmitir más datos de los que permite el paquete máximo, todos los
paquetes a excepción del último paquete deben de tener el tamaño máximo. De modo
que la transmisión de un paquete se ha llevado a cabo cuando se ha recibido la
cantidad exacta esperada o bien, se ha recibido un paquete que no alcanza el tamaño
máximo. El porcentaje de (micro) frame utilizado ronda el 13% en velocidad baja y
el 2.5% en velocidad media, mientras que en velocidad alta para cantidades similares
49
utilizadas para obtener los anteriores porcentajes se obtienen resultados del 1%, pero
para cantidades muy superiores se puede llegar a una utilización del 42%.
d.- Transferencias de bultos ("Bulk")
Hace uso de tuberías stream. Está diseñado para dispositivos que necesitan transmitir
grandes cantidades datos en un momento determinado sin importar mucho el ancho
de banda disponible en ese momento. Esta transferencia garantiza el acceso al USB
con el ancho de banda disponible, además en caso de error se garantiza el reenvío de
los datos. Por lo tanto este tipo de transferencia garantiza la entrega de los datos pero
no un determinado ancho de banda o latencia.
El tamaño máximo de paquete de datos para velocidad media es de 8, 16, 32 o 64
bytes, mientras que en velocidad alta es de 512 bytes. Los dispositivos de velocidad
baja no disponen de end points con este tipo de transferencia. No es necesario que los
paquetes se rellenen para alcanzar el tamaño máximo. El porcentaje de frame
utilizado en velocidad media en función del número de bytes enviados varía entre el
1% y el 5%, mientras que el porcentaje de microframe en velocidad alta varía entre
un 1% y un 5%, eso sí, teniendo en cuenta mayor cantidad de datos.
1.1.3.6 Parte Eléctrica del USB.
a.- Identificación de la velocidad del dispositivo
Para poder iniciar cualquier tipo de transacción cuando se conecta el dispositivo al
host, es necesario que este conozca la velocidad a la que trabaja. Con esa finalidad
existe un mecanismo a nivel eléctrico. La diferencia entre los dispositivos de
velocidad media y los de velocidad baja, es que en velocidad media tiene una
resistencia conectada al D+, en velocidad baja la misma resistencia se encuentra en
D- y no en D+
De forma que después del reset el estado de reposo de la línea es diferente si se trata
de baja o media velocidad. En el caso de dispositivos de alta velocidad lo que se hace
50
es que en un principio se conecta como un dispositivos de velocidad media y más
tarde a través de un protocolo se pasa a velocidad alta.
b.- Codificación de datos
El USB utiliza la codificación NRZI para la transmisión de paquetes. En esta
codificación los "0" se representan con un cambio en el nivel, y por el contrario los
"1" se representan con un no cambio en el nivel. De modo que las cadenas de cero
producen transiciones consecutivas en la señal, mientras que cadenas de unos
produce largos periodos sin cambios en la señal. A continuación un ejemplo:
c.- Relleno de bits
Debido a que cadenas de unos pueden producir largos periodos en los que la señal no
cambia dando lugar a problemas de sincronización, se introducen los bits de relleno.
Cada 6 bits consecutivos a "1" se inserta un bit a "0" para forzar un cambio, de esta
forma el receptor puede volverse a sincronizar. El relleno bits empieza con el patrón
de señal Sync. El "1" que finaliza el patrón de señal Sync es el primer uno en la
posible primera secuencia de seis unos.
En las señales a velocidad media o baja, el relleno de bits se utiliza a lo largo de todo
el paquete sin excepción. De modo que un paquete con siete unos consecutivos será
considerado un error y por lo tanto ignorado.
En el caso de la velocidad alta se aplica el relleno de bits a lo largo del paquete, con
la excepción de los bits intencionados de error usados en EOP a velocidad alta.
d.- Sync
Teniendo en cuenta que K y J representan respectivamente nivel bajo y nivel alto, el
patrón de señal Sync emitido, con los datos codificados, es de 3 pares KJ seguidos de
2 K para el caso de velocidad media y baja. Para velocidad alta es una secuencia de
15 pares KJ seguidos de 2 K. El patrón de señal Sync siempre precede al envío de
cualquier paquete, teniendo como objetivo que el emisor y el receptor se sincronicen
y se preparen para emitir y recibir datos respectivamente.
51
Si partimos de que el estado de reposo de la señal es J, podemos interpretar Sync
como una secuencia impar de "0's" y un "1" que se inserta antes de los datos.
e. - EOP ("End Of Packet")
A todo paquete le sigue EOP, cuya finalidad es indicar el final del paquete.
En el caso de velocidad media y baja el EOP consiste en que, después del último bit
de datos en el cual la señal estará o bien en estado J, o bien en estado K, se pasa al
estado SE0 durante el periodo que se corresponde con el ocupado por dos bits,
finalmente se transita al estado J que se mantiene durante 1 bit. Esta última transición
indica el final del paquete.
En el caso de la velocidad alta se utilizan bits de relleno erróneos, que no están en el
lugar correcto, para indicar el EOP. Concretamente, el EOP sin aplicar codificación
consistiría en añadir al final de los datos la secuencia 0111 1111.
1.1.3.7 Parte Mecánica del USB.
Como ya se ha visto la topología física USB consiste en la conexión del puerto de
bajada de un hub o host, con el puerto de subida de algún otro dispositivo o hub. Para
facilitar la conexión de dispositivos de cara el usuario, USB utiliza dos tipos de
conectores totalmente diferentes, los conectores de Serie A y los conectores de serie
B. Los conectores de serie A permiten la conexión directa de dispositivos USB con el
host o con el puerto de bajada de un host, y es obligatorio que estén presentes en
todos los dispositivos y hub’s USB. Los conectores de Serie B no son obligatorios y
sirven para conectar un cable USB con el puerto de subida de un dispositivo,
permitiendo por parte de los fabricantes de dispositivos la utilización de cables
estándar USB.
El cable USB consiste de cuatro conductores, dos conductores de potencia y dos de
señal, D+ y D-. Los cables de media y alta velocidad están compuestos por un par
trenzado de señal, además de GND (Tierra) y Vbus.
Existen tres tipos de cables USB: cable estándar de quita y pon, cable fijo de media y
alta velocidad, y cable fijo de baja velocidad.
52
a.- Cable estándar de quita y pon
Se trata de un cable de velocidad alta y media, con un conector macho de Serie A en
un extremo y un conector macho de Serie B en el otro extremo. Esto permite a los
fabricantes de dispositivos fabricarlos sin cable y al usuario le facilita la sustitución
del cable en caso de que se estropee.
Figura1.31.1: Cable USB
Fuente: Manual USB PLUS
b.- Cable fijo de velocidad alta y media
Con la denominación de fijo nos referimos a los cables que son proporcionados por
el fabricante del dispositivo fijos a este, o bien sin ser fijos, con un conector
especifico del fabricante. Es obligatorio que en un extremo tenga un conector macho
de Serie A. Dado que lo suministra el fabricante, puede ser utilizado por dispositivos
tanto de velocidad alta y media, como de velocidad baja. En el caso de que se utilice
para un dispositivo de velocidad baja, además de poder ser utilizado con dispositivos
de velocidad media y alta, deberá cumplir con todos los requisitos propios de la
velocidad baja.
Figura1.31.2: Cable USB Fijo Fuente: Manual del PLC DL06, 2a. edición en español, 6/07
53
c.- Cable fijo de velocidad baja
Al igual que el cable fijo de alta y media velocidad tiene un conector macho de Serie
A en un extremo, mientras que el otro depende del fabricante. La diferencia es que
este tipo de cables sólo funciona con dispositivos de velocidad baja.
Contacto Señal Cable 1 VBUS Rojo 2 Datos- Blanco 3 Datos+ Verde 4 GND Negro
Tabla1.7: Pines Cable Fijo de Velocidad Baja Fuente: Manual del PLC DL06, 2a. edición en español, 6/07
1.1.3.8 Icono USB.
El icono USB es obligatorio que se encuentre en los conectores de serie A y B, esto
facilita al usuario tanto el reconocimiento de que se trata de un cable USB, como la
orientación a la hora de conectarlo. En los siguientes dibujos se puede observar el
diseño y la colocación del logotipo.
Figura1.32: Ícono del USB Fuente: www.usb.org
1.1.4 Radio Frecuencia.
Las ondas de radio son fáciles de generar, pueden viajar distancias largas y penetrar
edificios sin problemas, de modo que se utilizan mucho en la comunicación, tanto de
interiores como de exteriores. Las ondas de radio también son omnidireccionales,
ósea viajan en todas las direcciones desde la fuente, por lo cual el transmisor y el
receptor no tienen que alinearse físicamente.
54
Las propiedades de las ondas de radio dependen de la frecuencia. A bajas
frecuencias, las ondas de radio cruzan bien los obstáculos, pero la potencia se reduce
drásticamente con la distancia a la fuente. A frecuencias altas, las ondas de radio
tienden a viajar en línea recta y a rebotar en los obstáculos. También son absorbidas
por la lluvia. Todas las ondas de radio están sujetas a interferencia por los motores y
equipos eléctricos.
1.1.4.1 El Espectro Electromagnético
Cuando los electrones se mueven crean ondas electromagnéticas que se pueden
propagar en el espacio libre, aún en el vacío. La cantidad de oscilaciones por
segundo de una onda electromagnética es su frecuencia, f, y se mide en Hz (en
honor a Heinrich Herz). La distancia entre dos máximos o mínimos consecutivos se
llama longitud de onda y se designa con la letra griegaλ.
En el vacío todas las ondas electromagnéticas viajan a la misma velocidad, sin
importar su frecuencia. Esta velocidad, usualmente llamada velocidad de la luz, c, es
aproximadamente 3x108 m/seg.
Fig. 1.32.1 El espectro electromagnético.
Fuente: www.um.es/docencia/barzana/IMGTEORIA/espectro-em.jpg
55
En la grafica anterior se muestra el espectro electromagnético. Las porciones de
radio, microondas, infrarrojo y luz visible del espectro pueden servir para transmitir
información modulando la amplitud, la frecuencia o la fase de las ondas. Las bandas
que se listan en la parte inferior de la figura son los nombres oficiales de la ITU. Los
términos LF, MF y HF se refieren a las frecuencias baja, media y alta,
respectivamente. Las bandas más altas se denominan muy, ultra, súper,
extremadamente y tremendamente alta frecuencia (VHF, UHF, SHF, EHF, THF
respectivamente).
1.1.4.2 Redes Inalámbricas
Las redes inalámbricas son redes que resuelven toda o una parte de su capa física en
base a conexiones no cableadas. En particular, el documento se ocupará de WLAN
(Wireless Local Área Network), para estas redes se establecieron los estándares
802.11 y 802.11b que es una extensión del anterior y luego se comentará algo de
redes infrarrojas.
Proveen todas las características y beneficios de las tradicionales tecnologías LAN
como Ethernet y Token Ring, pero sin las limitaciones de los cables que éstas
poseen.
Fig. 1.32.2 Frecuencia de operación
Fuente: CCNA Módulo Wireless de cisco
Una red inalámbrica puede ampliar la libertad de un usuario respecto de su ubicación
física manteniendo la disponibilidad de la red sin estar atado a un escritorio,
brindando la posibilidad de estar conectado mientras desayuna en el salón comedor,
espera en una sala ... o bien atiende una reunión en la sala de juntas.
56
Figura 1.33: Esquema de redes Wireless Fuente: www.radioptica.com/Radio/wlan.asp
Establecer una WLAN es más rápido, flexible, muchas veces más barato y más
realizable que hacerlo con una red cableada, dado que tender los cables es un
problema en sí mismo.
Hoy día dos tecnologías son las más comunes, la Home RF y la Wi-Fi (IEEE
802.11), de estas la que parece ser la más flexible es la 802.11.
Logotipo de WiFi.
Tenemos en la figura siguiente los inicios de esta tecnología, los diferentes rangos de
velocidad que maneja, hay que recalcar que actualmente nos encontramos en el
protocolo 802.11 n.
Figura 1.34: Velocidad de redes Wireless Fuente: CCNA Módulo 2 de cisco
El acceso de un usuario a una WLAN supera los 11 Mb/s, que es un ancho de banda
más que considerable para muchas aplicaciones o servicios a través de PC o
dispositivos móviles.
57
1.1.4.2.1 Modo Ad Hoc
Solo punto a punto
Fácil de configurar
No hay relay vía los puntos
Conjunto de Servicios Básico Independiente
Figura 1.35: Topología WLan
Fuente: CCNA Módulo 2 de cisco
1.1.4.3 Módulos de Radio Frecuencia
Transmisor y Receptor TWS-# y RWS-#
Figura 1.35.1: Módulo Transmisor Fuente: www.ishtronics.com/tws434a.jpg
El módulo transmisor viene ya ajustado en una frecuencia, que puede ser de 303,875
MHz (TWS-303) ,315 MHz (TWS-315), 418 MHz (TWS-418) y 433,92 MHz
(TWS-433). Está listo para su uso. Sólo se debe colocar una antena, conectarle la
58
alimentación y comenzar a enviarle datos. Para facilitar la transmisión de datos
codificados, existe un codificador que hace juego, que es el Holtek HT12E.
Figura 1.35.2: TWS-434 Fuente: R-8Px.pdf
Pin 1: GND Pin 2: IN Pin 3: VCC Pin 4: ANT Potencia de salida de RF: 8 mW
ESPECIFICACIONES Símbolo Características Condiciones Mín. Tipo. Máx. Unidad Vcc Voltaje de alimentación 1,5 - 12 V Icc Corriente máxima - 5 9 mA Vih Voltaje máximo entrada Idato=100µA
(alto) Vcc-0,5 - Vcc V
Vil Voltaje mínimo entrada Idato=0µA (bajo) - - 0,3 V Pout Potencia RF sobre 50
ohm -3 0 +2 dBm
Tbw Ancho banda modulación
Codificación externa
- 5 - kHz
Tr Flanco subida modulación
- - 100 µS
Tf Flanco bajada modulación
- - 100 µS
Alcance 20 m Tabla 1.8: Especificaciones del TWS
Fuente: R-8Px.pdf
Figura 1.35.3: Módulo Receptor. Fuente: www.ishtronics.com/tws434a.jpg
Los transmisores listados hacen juego con receptores de la misma frecuencia, que
también vienen en un valor predeterminado entre 300 MHz a 434 MHz Puede ser de
303,875 MHz (RWS-303), 315 MHz (RWS-315), 418 MHz (RWS-418) y 433,92
MHz (RWS-433). Posee en diseño pasivo de alta sensibilidad, que no requiere
59
componentes externos. Para decodificar las señales que llegan a este receptor se
pueden utilizar el decodificador asociado Holtek HT12D.
Figura 1.35.4: RWS-434 Fuente: R-8Px.pdf
Pin 1: GND Pin 2: OUT Pin 3: OUT LINEAL Pin 4: VCC Pin 5: VCC Pin 6: GND Pin 7: GND Pin 8: ANT Potencia de salida de RF: 8 mW
ESPECIFICACIONES Símbolo Características Condiciones Mín. Tipo. Máx. Unidad
Vcc Voltaje de alimentación 4,9 5 5,1 V Itot Corriente de operación 4,5 mA
Vdato Salida datos Idata=+200µA (alto)
Vcc-0,5
- Vcc V
Idato=-10µA (bajo)
- - 0,3 V
Fc Frecuencia operación 300 434 MHz Pref Sensibilidad -106 dBm
Ancho de canal ±500 kHz NEB Ancho banda equivalente.
ruido - 5 4 kHz
Velocidad transferencia datos
3 Kb/s
Tiempo de encendido - - 5 ms. Tabla 1.9: Especificaciones del RWS
Fuente: R-8Px.pdf
1.1.5 Micro controladores.
Hace unos años, los sistemas de control se implementaban usando exclusivamente
lógica de componentes, lo que hacía que fuesen dispositivos de gran tamaño y muy
pesados.
Para facilitar una velocidad más alta y mejorar la eficiencia de estos dispositivos de
control, se trató de reducir su tamaño, apareciendo así los microprocesadores.
Siguiendo con el proceso de miniaturización, el siguiente paso consistió en la
fabricación de un controlador que integrase todos sus componentes en un sólo chip.
60
Las principales características que diferencian a un micro controlador de un
microprocesador son:
Son sistemas cerrados, ya que contiene todos los elementos de un
computador en un solo chip, frente a los microprocesadores que son sistemas
abiertos, ya que sacan las líneas de los buses de datos, direcciones y control
al exterior, para la conexión de memorias, interfaces de E/S, etc.
Son de propósito específico, es decir, son programados para realizar una
única tarea, mientras que los microprocesadores son de propósito general.
1.1.5.1 Historia La historia del micro controlador surge desde dos vías de desarrollo paralelas; una
desde Intel y otra desde Texas Instruments. Los primeros micros controladores son el
4004 y 4040 de Intel que dieron lugar al 8048, a su vez predecesor del 8051. Aún así
el primer micro controlador fue el TMS1000 de Texas Instruments. Éste integraba un
reloj, procesador, ROM, RAM, y soportes de E/S en un solo chip.
Figura 1.36: Grafica del primer integrado Fuente: www.neoteo.com
1.1.5.2 Partes de un micro controlador
Figura 1.37: Parte del microprocesador
Fuente: Manual Básico de Microprocesadores
61
CPU o procesador.- Es el cerebro del sistema que procesa todos los datos que
viajan a lo largo del bus.
Memorias.- Está formada por una no volátil (ROM, EEPROM, FLASH)
donde se almacenan los programas y una volátil (RAM) donde se almacenan
los datos.
Reloj principal.- Normalmente todos los micro controladores tienen
incorporados circuitos osciladores para el funcionamiento de éstos.
Puertos E/S (Entrada/Salida).- Soportan las líneas que comunican al micro
controlador con los periféricos externos.
Perro guardián o Watchdog.- Contador que resetea al micro controlador cada
vez que rebosa. Sirve para evitar fallos de funcionamiento, por lo que hay que
inicializarlo periódicamente antes de que rebose.
Protección ante fallo de alimentación o Browout.- Circuito que resetea al
micro controlador cuando la tensión de alimentación baja de un cierto límite.
Temporizadores.- Para controlar periodos de tiempo.
Convertidores A/D y D/A. (Analógico/Digital y Digital/Analógico)
Comparadores analógicos
Moduladores de anchura de impulsos.
Puertos de comunicación.- Tanto serie como paralelo.
Control de interrupciones
1.1.5.3 Aplicaciones El mercado del micro controlador está creciendo cada año y parece no tener barreras.
Los micro controladores a menudo se encuentran en aplicaciones domésticas
(microondas, refrigeradores, televisión, equipos de música, DVD), ordenadores con
sus componentes (impresoras, módems, lectores de discos), coches (ingeniería de
control, diagnostico, control de climatización), control medioambiental
(invernaderos, fabricas, casas), instrumentación, aeronáutica, y miles de usos más.
En muchos podemos encontrar más de un micro controlador.
62
Figura 1.38: Grafica de iteración
Fuente: www.national.com/diagrams Los micro controladores son muy usados el área médica, en los procesos industriales
usarlos hace posible muchas tareas específicas al distribuir un gran número de los
mismos por todo el sistema. La comunicación entre cada micro controlador y uno
central permitiría procesar la información por un ordenador central, o transmitirlo a
otros micro controladores del sistema.
Figura 1.39: Diagrama bloques Proceso Industrial. Fuente: www.national.com/diagrams
63
33%
25%
16%
15%
10%1%
1
2
3
4
5
Son ampliamente utilizarlos para monitorizar y gravar parámetros medioambientales.
El uso en sistemas de navegación por radar, cumplen tareas específicas y complejas.
Figura 1.40: Ejemplo usos de los microcontroladores.
Fuente: www.national.com/diagrams
1.1.5.4 Volúmenes de Ventas.
La distribución de las ventas según su aplicación es la siguiente:
Una tercera parte se absorbe en las aplicaciones relacionadas con los
ordenadores y sus periféricos.
La cuarta parte se utiliza en las aplicaciones de consumo (electrodomésticos,
juegos, TV, vídeo, etc.)
El 16% de las ventas mundiales se destinó al área de las comunicaciones.
Otro 16% fue empleado en aplicaciones industriales.
33 Industria 25 electrodomésticos 16 Sist. De comunicación 15 Industria 10 Automoción 1 Otros
Figura 1.41: Distribución de los Microcontroladores. Fuente: www.google.com
64
2.- CAPÍTULO2
HERRAMIENTAS DE DESARROLLO PARA DISPOSITIVOS MÓVILES
Se estudiara la plataforma de trabajo con el cual se desarrollo la aplicación para los
dispositivos móviles, así como una breve descripción de los famosos teléfonos
inteligentes.
2.1 Introducción al J2ME
J2ME es el acrónimo de Java 2 Micro Edición. J2ME es la versión de Java orientada
a los dispositivos móviles. Debido a que los dispositivos móviles tienen una potencia
de cálculo baja e interfaces de usuario pobres, es necesaria una versión específica de
Java destinada a estos dispositivos, ya que el resto de versiones de Java, J2SE o
J2EE, no encajan dentro de este esquema. J2ME es por tanto, una versión “reducida”
de J2SE.
2.2 Configuración
La configuración es un mínimo grupo de API´s (Application Program Interface),
útiles para desarrollar las aplicaciones destinadas a un amplio rango de dispositivos.
La configuración estándar para los dispositivos inalámbricos es conocida como
CLDC (Connected Limited Device Configuration). El CLDC proporciona un nivel
mínimo de funcionalidades para desarrollar aplicaciones para un determinado
conjunto de dispositivos inalámbricos. Se puede decir que CLDC es el conjunto de
clases esenciales para construir aplicaciones. Hoy por hoy, sólo tenemos una
configuración, pero es de esperar que en el futuro aparezcan distintas
configuraciones orientadas a determinados grupos de dispositivos.
Los requisitos mínimos de hardware que contempla CLDC son:
160KB de memoria disponible para Java
Procesador de 16 bits
Consumo bajo de batería
Conexión a red
Los dispositivos que claramente encajan dentro de este grupo, son los teléfonos
móviles, los PDA (Personal Digital Assintant), los “Pocket PC”.
65
En cuanto a los requisitos de memoria, según CLDC, los 160KB se utilizan de la
siguiente forma:
128KB de memoria no volátil para la máquina virtual Java y
Para las librerías del API de CLDC
32KB de memoria volátil, para sistema de ejecución (Java
Runtime System).
En cuanto a las limitaciones impuestas por CLDC, tenemos por ejemplo las
operaciones en coma flotante. CLDC no proporciona soporte para matemática en
coma flotante. Otra limitación es la eliminación del método Object.finalize.
Este método es invocado cuando un objeto es eliminado de la memoria, para
optimizar los recursos. También se limita el manejo de las excepciones. Es
complicado definir una serie de clases de error estándar, que se ajuste a todos los
dispositivos contemplados dentro de CLDC. La solución es soportar un grupo
limitado de clases de error y permitir que el API específico de cada dispositivo
defina su propio conjunto de
Errores y excepciones.
La seguridad dentro de CLDC es sencilla, sigue el famoso modelo sandbox.
Las líneas básicas del modelo de seguridad sandbox en CLDC son:
Los ficheros de clases, deben ser verificados como aplicaciones válidas.
Sólo las APIs predefinidas dentro de CLDC están disponibles.
No se permite cargadores de clases definidos por el usuario.
Sólo las capacidades nativas proporcionadas por CLDC son accesibles.
2.3 Perfiles
En la arquitectura de J2ME, por encima de la configuración, tenemos el perfil
(profile). El perfil es un grupo más específico de APIs, desde el punto de vista del
dispositivo. Es decir, la configuración se ajusta a una familia de dispositivos, y el
perfil se orienta hacia un grupo determinado de dispositivos dentro de dicha familia.
El perfil, añade funcionalidades adicionales a las proporcionadas por configuración.
66
La especificación MIDP (Mobile Information Device Profile), describe un
dispositivo MIDP como un dispositivo, pequeño, de recursos limitados, móvil y con
una conexión “inalámbrica”.
2.4 MIDLet
Las aplicaciones J2ME desarrolladas bajo la especificación MIDP, se denominan
MIDLets. Las clases de un MIDLet, son almacenadas en bytecodes java, dentro de
un fichero .class. Estas clases, deben ser verificadas antes de su “puesta en marcha”,
para garantizar que no realizan ninguna operación no permitida. Este pre
verificación, se debe hacer debido a las limitaciones de la máquina virtual usada en
estos dispositivos. Esta máquina virtual se denomina KVM. Para mantener esta
máquina virtual lo más sencilla y pequeña posible, se elimina esta verificación, y se
realiza antes de la entrada en producción. El pre verificación se realiza después de la
compilación, y el resultado es una nueva clase, lista para ser puesta en producción.
Los MIDLets, son empaquetados en ficheros “.jar”. Se requiere alguna información
extra, para la puesta en marcha de las aplicaciones. Esta información se almacena en
el fichero de “manifiesto”, que va incluido en el fichero “.jar” y en un fichero
descriptor, con extensión “.jad”. Un fichero “.jar” típico, por tanto, se compondrá de:
Clases del MIDLet
Clases de soporte
Recursos (imágenes, sonidos...)
Manifiesto (fichero “.mf”)
Descriptor (fichero “.jad”)
Un fichero “.jar” puede contener varios MIDLets. Esta colección de MIDLets, se
suele llamar “MIDLet Suite”. Esta unión de varios MIDLets en una distribución,
permite compartir recursos (imágenes, sonidos...), y por tanto optimizar los recursos
del dispositivo.
67
2.5 Herramienta Netbeans
Netbeans es un IDE (Integrated Development Environment), una herramienta de
desarrollo para escribir programas Java pero también, gracias a sus módulos, muchos
otros lenguajes, desde C y C++ hasta XML, HTML y Java Server Pages, pasando por
cualquier tecnología de la calaña de JSP, RMI, CORBA, JINI, etc.
Brevemente, adrémonos camino en NetBeans con un rápido repaso por sus más
interesantes características. Entre otras, un editor de código con sistema de
coloración de la sintaxis y de auto-completado, anotaciones, macros e identificación
automática del código, soporte para Java, C, C++, XML y HTML, así como para
JSP, RMI, CORBA, JINI, JDBC y Servlet. Y por último, para los sistemas de control
de versión Ant y CVS, perfectamente integrados a NetBeans.
Netbeans 6 incorpora características de edición para desarrollo móvil visual,
desarrollo en c++, ruby y soporte para rails, modelado visual de uml, y lo más
importante, un editor visual de interfaces graficas.
2.5.1 Características del Netbeans 6.0
Smarter de código. El editor de NetBeans es más rápido y más inteligente,
proporcionando terminaciones de las palabras clave, los campos, y las
variables. También se enumeran la más lógica de las opciones en la parte
superior, y le permite profundizar en la plena opciones en la parte inferior
Figura 2.1: Programando en Netbeans Fuente: Autores
Destacados. Puede pensar de los aspectos más destacados como una
característica fácil de utilizar y más correcta sustitución de los editores de
búsqueda. El IDE pistas de la posición del carácter y, basándose en ella, se
destacan algunas partes del código. Entre los puntos más destacados están
68
marcados con un color de fondo en el editor también se puso en la banda de
error, que los permisos para tener visión de conjunto de todo el archivo.
Mejora de la navegación y de la inspección. Además de los más destacados,
la fuente editor te permite navegar rápidamente a través de su código con una
mejor organización de la ventana del navegador y los diputados y jerárquico
Inspectores.
Más que de código. Con las plantillas de vivir y Surround Con funcionalidad, puede
introducir rápidamente de uso común de los bloques de código y centrarse en la
lógica empresarial.
Figura 2.2: Ejemplo de código en Netbeans
Fuente: Autores
Apoyo a los Proyectos. Crea rápidamente Ruby proyectos con estructura lógica,
ejecute los archivos de Ruby, Ruby configurar otros intérpretes (como JRuby o
nativos Ruby), localizar e instalar Ruby Gems gráfica a través de un asistente, crear y
ejecutar pruebas de unidad, ejecute RSpec especificación de archivos, entre un salto
de Ruby Archivo y su correspondiente unidad de prueba o archivo específico, y así
sucesivamente.
Edición Avanzada Ruby. Avanzada para la edición de código Ruby, utilizando
información semántica sobre el programa para ofrecer de código, que muestra las
clases y métodos disponibles para la expresión actual, junto con la documentación
asociada RDoc. La sintaxis es poner de relieve con mayor información semántica, de
tal manera que sin utilizar variables locales y los parámetros se muestran en gris. Hay
muchas otras funciones de edición, incluida la Declaración Goto para ir al punto de
declaración de una clase o el método de referencia.
Ruby Debugger. Solo pasó o ejecutar código a través de Ruby, sistema de
interrupción, ver variables locales, la llamada pila de navegar, cambiar los hilos, y
69
evaluar expresiones sólo por encima de ellos el ratón sobre la variable en el Editor.
También existe apoyo a la "rápida depuración" de extensión.
Ruby on Rails Apoyo. Generar proyectos de Rails, o generar código a través del
generador de código Rails asistente gráfico, que ofrece documentación sobre los
plugins en el propio asistente. Participación de terceros en los generadores también
tienen soporte. Además, hay acciones para saltar rápidamente entre un Rails acción y
su correspondiente ", o deformaciones en el navegador la URL para más pertinentes
para el archivo que está editando. Base de datos de las migraciones y Rake objetivos
se apoyan también. Por último, se destacan RHTML archivos (junto con la mejora de
NetBeans 6,0 apoyo a los archivos relacionados, tales como JavaScript y CSS).
Figura 2.3: Ventana de proyectos en Netbeans
Fuente: Autores
2.5.2 Más fácil instalación y la actualización.
Unificado de instalación experiencia. El nuevo instalador NetBeans hace que sea más
fácil obtener la funcionalidad que usted desea. No más descargar e instalar paquetes
separados. Ahora usted elija la que mejor se adapte a descargar e instalar usted las
características y módulos de ejecución que necesita en un solo instalador. Puede
70
añadir la funcionalidad más adelante por volver a ejecutar el instalador.
Mantener actualizado. El Centro de actualizaciones y Gestor de módulos han sido
absorbidos por el administrador de complementos. Fácil de activar y desactivar la
funcionalidad, la búsqueda de actualizaciones y nuevas funcionalidades en un solo
lugar.
2.5.3 Swing GUI desarrollo
Además de numerosas mejoras de la muy aclamada NetBeans GUI Designer (antes
conocido como "Proyecto Matisse"), el desarrollo de aplicaciones Java de escritorio
de apoyo se ha visto mejorada con la siguientes características:
Base de datos de aplicaciones Swing. Tomando ventaja de la tecnología de
encuadernación Beans (JSR 295) y la persistencia de Java API, es ahora más fácil
que nunca para crear aplicaciones de bases de datos de escritorio Swing. Con los
nuevos proyectos de aplicaciones Java Desktop plantilla, usted puede configurar una
forma que muestra una tabla de base de datos y le permite modificar la base de datos.
Vincular una tabla de base de datos a una forma existente arrastrando una tabla desde
la ventana de tiempo de ejecución en un formulario.
E
Figura 2.4: Ejemplo de Aplicación Con Base de Datos Fuente: Autores
71
2.5.4 Perfiles.
Perfil integrado en Netbeans IDE. NetBeans Profiler se ha convertido en una parte
integral de NetBeans IDE de 6,0! No hay ahora ninguna necesidad de descargar e
instalar el NetBeans Profiler separado.
Comparar Memory Snapshots. Usted puede comparar guardado y sin guardar las
instantáneas de memoria para ver qué objetos se han creado o puesto en libertad de
entre el montón, cuando se tomaron las instantáneas. Para más, véase la comparación
de la memoria de instantáneas.
DrillDown Gráfico. Perfiles de los resultados se pueden visualizar en un gráfico que
clasifica tiempo de CPU que se ha gastado. Puede hacer clic en el gráfico de las
secciones para ver los detalles de las categorías de alto nivel para información más
detallada de perfiles. Para más, véase Áreas de Interés - Categorización normas
Heap Walker. Cuando un perfil de su aplicación, podrá ahora utilizar el Heap Walker
para ayudar a evaluar los contenidos de Java heap y búsqueda de fugas de memoria.
Para obtener más información acerca de Heap Walker, consulte la documentación
sobre el Perfil del 6,0 Heap Walker.
Adjuntar dinámico en JDK 1,6.
Figura 2.5: Creando un proyecto nuevo
Fuente: Autores
72
Figura 2.6: Interfaz de Netbeans Fuente: Autores
2.6 Web y Java EE.
Built-in visual para el diseño de aplicaciones web. La plantilla de proyecto de Visual
Web es ahora fusionada con la principal aplicación web plantilla de proyecto. Sólo
tiene que añadir la Visual Web JavaServer Faces marco de su proyecto web y la
palanca de una amplia biblioteca de Ajax permitió a los componentes JavaServer
Faces para construir su aplicación.
Visual flujo de la página de edición. Vinculación de páginas de la aplicación web
nunca ha sido más fácil con el nuevo editor de Visual Page Flow, el apoyo a
JavaServer Faces, JSP, y las páginas HTML.
Mayor soporte de JavaScript. Completo de sintaxis, de código, y la comprobación de
errores de código JavaScript está disponible tanto en el stand-alone y JavaScript en
los archivos de HTML, RHTML, y archivos JSP.
73
Mejora de los servicios web de apoyo. Arrastre y suelte el consumo de servicios web
visuales en páginas web app. La mejora de la interoperabilidad de servicios Web.
Soporte para Ajax habilitado componentes JavaServer Faces. Proyecto Woodstock
biblioteca de componentes encapsula Javascript y complejo del lado del servidor
dentro de los componentes JavaServer Faces. Usando un componente habilitado
Ajax-es como trabajar con cualquier otro componente: Arrastre y suelte el
componente, sistema propiedades, personalizar y del lado del servidor gestores de
eventos.
Fácil migración de Java Studio Creator. Situado en la ruta de migración de Java
Studio Creator 2, NetBeans 6 preserva su inversión en proyectos de Java Studio
Creator vez que le permiten aprovechar las numerosas características de
productividad de la NetBeans IDE en una única herramienta.
Aumento de la edición de CSS. El editor de CSS permite una vista previa de los
cambios en su CSS como que se realicen.
Figura 2.7: Desarrollo de un proyecto Fuente: Autores
74
2.7 Mobility
Nueva Integrado de IU para CLDC / MIDP CDC y el desarrollo. El paquete de
Movilidad ahora apoya el proyecto de propiedades que antes sólo estaban disponibles
para CLDC / MIDP proyectos. Entre ellas figura el apoyo a proyectos de
configuración de dispositivos de fragmentación, la ofuscación y la optimización
integrada de apoyo, y múltiples opciones de despliegue, todo construido en Apache
Ant para la codificación y manejo más fácil.
Nuevo juego constructor. Ahora es más fácil de crear juegos móviles con el paquete
de la movilidad visual de la edición de apoyo a la API MIDP 2,0 Game. La API
soporta sprites de animación y la capacidad de disponer en capas de suelo de
baldosas escenas.
Nueva Mobile Visual Designer. El Visual Designer Mobile (VMD) se ha rediseñado
para mejorar la funcionalidad y facilidad de uso.
Diseño de análisis. Análisis de diseño identifica los componentes no utilizados para
la separación visual de los diseños complejos.
Nuevos componentes personalizados. Nuevos componentes para el móvil Visual
Designer simplificar la creación y el diseño de los navegadores móviles de archivo,
servicio de mensajes cortos (SMS), los compositores, las pantallas de inicio de
sesión, y el Administrador de información personal (PIM) de los navegadores.
Nuevos componentes para el control de flujo.
Generado código es ahora más fácil de modificar.
Re-escrito JSR-172 talón compilador. El nuevo generador tiene soporte para Base64
tipo y es capaz de analizar la documentación de los métodos.
La mejora de los proyectos de gestión de la configuración. Una nueva interfaz de
usuario para el asistente del proyecto hace que sea más fácil de añadir nuevo
proyecto para las nuevas configuraciones de los dispositivos móviles. Ahora es más
fácil crear varias compilaciones para múltiples configuraciones.
75
Figura 2.8: Referencias en Netbeans Fuente: Autores
2.8 SOA
Artefactos para el servicio de composición y montaje. El Composite Application
Service Asamblea Editor le permite editar la configuración de proyectos
empresariales. Apoya la adición y / o modificación de fijaciones y el servicio de
puntos finales, añadir / eliminar conexiones entre las unidades de servicios para
conectar a los puntos finales de las unidades de servicios externos, y la creación de
encuadernación Componente-Componente de encuadernación conexiones.
WSDL editor gráfico. Crear resume documentos WSDL (WSDL sin ataduras)
fácilmente junto con la información de tipo socio enlace.
XSLT editor para editar transformaciones. Visualmente editar transformaciones.
Herramientas de apoyo para los componentes vinculante. Apoyo a Archivo, HTTP, y
JMS vinculante componentes.
Java EE servicio Web de apoyo a los proyectos. Un Java EE proyecto que ejecuta el
servicio de servidor Web o interfaces de cliente se puede agregar a un compuesto
como una aplicación de servicios JBI Dependencia. El Java EE proyecto pueden
76
comunicarse con otras unidades de servicios directamente mediante el interior JBI
normalizados Mensaje Router (RMN).
Figura 2.9: Abrir un proyecto
Fuente: Autores
Figura 2.10: Trabajando en el proyecto
Fuente: Autores
77
2.9 UML.
Plantilla basada en la generación de código ya disponible y personalizable. UML
ofrece ahora la plantilla para la generación de código basado Adelante Ingeniería. El
nuevo enfoque de generación de código utiliza FreeMarker plantillas, que permiten a
los usuarios personalizar la forma en el código se genera por la simple modificación
de las plantillas utilizadas. Los usuarios pueden mejorar la generación de código con
nuevas plantillas de generación de código usando las plantillas de dominio en el
panel de ventana de Opciones de UML.
Aumento de la generación de código de función. La capacidad de fusión de código
fuente generado recientemente en los archivos de código fuente ya está disponible.
Mejora de la gestión de las colecciones. Un usuario de la colección de tipos se
conserva durante Adelante y de ingeniería inversa y puede ser cambiado a través de
conjunto y de diálogo de propiedades para la generación de código.
Herramientas de alineación existentes en la actualidad. El diagrama de ahora, el
Editor ha alineación herramientas disponibles. Seleccione el diagrama de los
elementos que se suman, clic con el botón derecho de la selección, y elija Alinear
desde el menú emergente.
Nueva ventana de diseño. Por defecto, la ventana es ahora Documentación acoplarse
a la ventana Propiedades de la zona. El Centro de Diseño de la ventana es ahora
acopló a la zona Explorer por defecto.
Guardar como ahora en el diagrama de acción nodo. El "Guardar como" la acción se
ha añadido al diagrama de nodos. La acción permite que un diagrama que se
dupliquen.
78
Figura 2.11: Ventana de opciones Fuente: Autores
Figura 2.12: Test de parámetros Fuente: Autores
79
Figura 2.13: Trabajando con clases Fuente: Autores
Figura 2.14: Variables Fuente: Autores
80
Figura 2.15: Configuración Variables Fuente: Autores
Figura 2.16: Arquitectura de un módulo Fuente: Autores
Figura 2.17: Ventana General Fuente: Autores
81
2.10 Visual Biblioteca API.
La Biblioteca Visual API, que es la generación siguiente gráfico Biblioteca, es útil
para la visualización de datos, como el gráfico orientado a modelar, en los módulos
de NetBeans.
Preferencias de la API de NetBeans. El NetBeans Preferencias NetBeans proporciona
una API específica de aplicación de la API de Preferencias del JDK. Por ejemplo,
que te permite almacenar las preferencias del usuario en el directorio de NetBeans.
Lexer. Mejora de la API de NetBeans para la creación de fichas de un texto de
entrada. Las fichas se pueden utilizar para, por ejemplo, proporcionan sintaxis para
colorear.
Logger. NetBeans API ErrorManager obsoleto, en favor de la norma del JDK Logger
mecanismo. Para más detalles, véase el registro en NetBeans.
Interfaces Generified. El JDK 1,5 genéricos se utilizan en toda la API de NetBeans.
2.11 Dispositivos Móviles
Existen variedad de dispositivos Móviles, entre ellas 2 grandes y diferenciados
grupos:
a.- Computadoras de Mano
Palm
b.- Teléfonos Celulares
Nokia
Sony Ericson
2.11.1 Computadoras de Mano
Características:
Ordenador de mano con conectividad inalámbrica total, el ordenador de mano Palm® T|X
es lo que esperabas. Utiliza las tecnologías Wi-Fi y Bluetooth integradas para consultar el
correo electrónico, navegar por Internet y acceder a archivos en redes. Se puede visualizar
82
páginas Web, presentaciones de PowerPoint, documentos de Word y hojas de cálculo de
Excel, en la gran pantalla en color que cambia de posición vertical a horizontal. Además, es
totalmente compatible con Microsoft Outlook. El ordenador de mano Palm T|X resulta
atractivo a primera vista. Su diseño elegante es todo menos corriente.
Especificaciones Técnicas:
Especificaciones del producto.
Sistema operativo
Palm OS® Garnet 5.4
Memoria
128 MB (100 MB accesibles para el usuario)
Procesador
Procesador basado en ARM Intel a 312 MHz
Pantalla
Pantalla táctil TFT 320 x 480 transflectiva.
Compatible con más de 65.000 colores Modos de orientación horizontal y vertical
Inalámbrico.
Tecnología inalámbrica Wi-Fi 802.11b.
Tecnología inalámbrica Bluetooth® 1.1.
Audio
Altavoz
Toma estándar de 3,5 mm para auriculares estéreo
Ranura de expansión
Compatible con tarjetas MultiMediaCard, SD y SDIO
Batería
De litio recargable
83
Cable/Alimentación
Cable de sincronización USB
Adaptador de CA
AC adapter (108-32 VAC/60Hz)
Tamaño
3.08" W x 4.76" H x .61" D
78.2mm W x 120.9mm H x 15.5mm D
Peso
149 g
Requisitos del ordenador de escritorio.
Ordenador Windows
Windows 2000 (SP4), Windows XP
Puerto de hardware USB y unidad de CD-ROM
Son necesarios derechos de administrador para instalarlo.
Para la sincronización con Outlook es necesario MS Outlook 2000, 2002 o 2003
Macintosh
Mac OS 10.2.8 a 10.4
Puerto de hardware USB y unidad de CD-ROM
Son necesarios derechos de administrador para instalarlo
2.12 WIFI
Wi-Fi (siglas del inglés Wireless-Fidelity) es un conjunto de estándares para redes
inalámbricas basados en las especificaciones IEEE 802.11. Fue creado para ser
84
utilizado en redes locales inalámbricas, sin embargo es frecuente que en la actualidad
también se utilice para acceder a Internet.
Wi-Fi es una marca de la Wi-Fi Alliance (anteriormente la WECA: Wireless
Ethernet Compatibility Alliance), la organización comercial que adopta, prueba y
certifica que los equipos cumplen los estándares 802.11.
2.12.1 Seguridad WIFI
Mecanismos para validar clientes en una red inalámbrica:
Open Autentication
Shared Key Authentication.
Validación de estaciones basada en dirección MAC
a.- Open Autentication.
Este tipo de autenticación se basa en la encriptación posterior que se va a hacer de
los datos enviados a través de la red inalámbrica.
Aunque un cliente pueda validarse contra el punto de acceso, si no conoce las claves
de encriptación de los datos no podrá enviar información.
b.- Shared Key Authentication.
Este mecanismo necesita que tanto clientes como puntos de acceso tengan
configurada una clave WEP estática.
Para evitar el envío de la clave WEP a través del medio inalámbrico se utiliza un
mecanismo del tipo petición/respuesta.
El punto de acceso envía al cliente un texto aleatorio para que sea cifrado con la
clave WEP del cliente. Este texto es diferente cada vez que se solicita una validación.
El cliente envía el texto cifrado al punto de acceso. Entonces el punto de acceso
descifra con su clave WEP el texto cifrado y comprueba si el texto de cifrado
coincide con el texto aleatorio original. Si ambos coinciden el punto de acceso da por
bueno el cliente.
85
c.- Validación de estaciones basada en dirección MAC
El punto de acceso dispone de una lista de direcciones MAC de clientes que pueden
utilizar la red inalámbrica limitando de esta manera la posibilidad de que se
produzcan accesos no autorizados a la red.
MAC-Spoofing: Un posible intruso, con un analizador de protocolos, captura
direcciones MAC de clientes y configura su propia tarjeta WLAN para que tenga
una dirección MAC válida.
2.12.2 WEP
Son las siglas de Wired Equivalent Privacy (Privacidad Equivalente a redes
cableadas) y es un mecanismo de cifrado continuo que utiliza clave simétrica. El
hecho de utilizar clave simétrica implica que la clave de encriptación debe ser
conocida por los dos extremos.
No realiza un cifrado extremo a extremo como sería deseable.
Estas claves deben ser estáticas y es necesario llevar a cabo una configuración
manual de las mismas.
86
3.- Capítulo 3. DESARROLLO DEL PROYECTO: CONTROL INDUSTRIAL POR DISPOSITIVOS
MÓVILES.
En este capítulo contemplamos analizar y describir el desarrollo de nuestro sistema,
describiremos los componentes utilizados, así como plataformas de desarrollo y
demás.
3.1 Antecedentes
Cada día es más frecuente el uso de tecnología para aumentar la productividad
dentro de la industria, “automatizar” es la palabra más utilizada en un proceso, la
electrónica industrial se ha convertido en una ciencia que busca alianzas con demás
ingenierías para poder integrar en un solo conjunto los sistemas de control industrial,
para así convertirlos en escalables, sólidos, y fiables.
Los distintos campos como la electro medicina, la aeronáutica, la robótica, la
domótica entre otras están haciendo que ciencias converjan entre si y exigen de los
ingenieros una integración de tecnologías de manera multidisciplinaria, tales como la
ingeniería en sistemas, las telecomunicaciones, la electrónica, la microelectrónica, y
la ingeniería industrial, todas juegan un papel importante para así ocupar un lugar
importante en la tecnología moderna dentro de la industria.
3.2 Elementos de un sistema de control
La mayoría de sistemas de control están compuestos por tres partes:
Sensores. Procesadores. Actuadores.
Figura 3.1: Elementos Sistema de control. Fuente: Electrónica industrial de CEKIT
Tenemos varios tipos de sensores como los detectores de proximidad, sensores de
posición, de fuerza, tenemos los famosos transductores de presión, temperatura y de
ciertos parámetros de fluidos, sensores ultrasónicos, en fin una gran variedad de
sensores que nos permiten monitorear de alguna manera las señales analógicas
existentes en el medio, señales tales como presión, temperatura, presión, corriente,
Procesadores ActuadoresSensores
87
voltaje, y cabe recalcar que permite adquirir datos puntuales es decir señales de
encendido o apagado muy, datos muy útiles en el caso de tomar decisiones acertadas.
Figura 3.2: Tipo de Señales. Fuente: Autores
Los procesadores no son más que el controlador del sistema, es decir el que
gobierna a los actuadores dependiendo de su programación y de las señales
adquiridas.
A continuación mostramos una tabla con el resumen de las diferentes maneras de
controlar y monitorear un proceso industrial.
Los actuadores son una parte muy importante en los sistemas de control, ya que son
los encargados de regular la potencia del proceso y también se encargan de
amplificar las señales de mando, tenemos algunos tipos de actuadores tales como:
•Usados en el control de fuidos gaseosos por medio de señales eléctricas.•Por ejemplo se puede controlar el flujo de aire.Control Electroneumático.
•Bien pueden usarse para controlar procesos sencillos y complejidad media, controlan entradas y salidas de manera del que hayan sido programados.Microcontroladores.
•Se pueden controlar los procesos industriales de manera remota con protocolos de comunicacion tales como ModBus, ethernet, y demas.Redes de Automatización.
•Se obtiene informacion completa de determinado proceso y a la vez se ejecutan labores automaticas, se pueden generar reportes, de manera facil y comoda.Control por Computadora.
•Controladores Lógicos Programables, son dispositivos de procesamiento que poseen entradas y salidas, de diferentes tipos de señal, su funcionamiento depende del programa que previamente se le haya cargadoPLC o Autónomas.
•Tenemos las computadoras industriales, tarjetas diseñadas especialmente para la adquisicion de señales, protocolos de comunicación.Otros Sistemas.
Señales
Analogas
Temperatura
Presión
Puntuales
On
Off
88
3.3 Motivación.
La mayoría de proceso están compuestos por dos partes: el proceso controlado o
ambiente y el controlador, este interactúa con el ambiente basándose en la
información que percibe de los sensores.
La iteración permite al controlador percibir correctamente el estado de las variables,
de otra forma los efectos podrían ser muy severos, es por eso el monitoreo periódico
del sistema y un procesamiento de esta información.
En nuestro proyecto se usa el controlador, la Computadora y varios
microcontroladores, combinados de manera correcta para adquirir señales y controlar
los diferentes actuadores de acuerdo al requerimiento del sistema, hay que recalcar
que este sistema es de lazo cerrado.
El sistema de control en tiempo real debe:
Realizar sus funciones dentro de plazos de respuesta, ejecutándose dentro de
su periodo, tal que se garantice la estabilidad del lazo cerrado.
Planificar todos los procesos de control que conforman una aplicación y
garantizar en todos ellos el cumplimiento de plazos de respuesta.
Proporcionar robustez, es decir poco sensible a las variables presentadas.
Garantizar una operación en forma confiable de los procesos ejecutándose.
Permitir accesibilidad a diferentes aplicaciones para controlar los procesos.
Permitir movilidad dentro y fuera de la industria.
3.4 Relaciones.
Las aplicaciones de procesos industriales, son desarrolladas en dos fases, la primera:
El diseño de las leyes de control
La implementación del sistema de tiempo real.
Actuadores Eléctricos:•Reles.•Contactores.•Motores Electricos, Servomotores, motores de paso.
Actuadores Hidráulicos y Neumáticos:•Válvulas.•Servoválvulas.
89
En el campo industrial grupos de investigación trabajan en la integración de
hardware y software de tal manera que convergen para optimizar varios o todos los
procesos dentro de una industria, tal que permita la optimización del desarrollo,
producción o fabricación de un producto de consumo.
3.5 Objetivos de la Tesis.
Implementar una estación de monitoreo y control de un proceso de llenado y
vaciado de un tanque, y su respectivo censo de temperatura de las bombas utilizadas
de manera local y remota con movilidad hacia el operador.
3.5.1 Objetivos Específicos.
Llevar a cabo el objetivo general de esta tesis, subdividimos el trabajo en diferentes
actividades:
3.6 Trabajo Propuesto En la industria local la mayor es común visualizar y controlar procesos industriales
desde muy pequeños y otros más grandes y peligrosos para ser operados de manera
manual, la tendencia de las industria ecuatorianas es de colocar e implementar un
departamento de sistema en sus instalaciones, para que de soluciones de correo,
acceso a internet, VozIP, en fin todas las tecnologías en el campo de redes e
1•Implementar un sistema de hardware que permita la interacción con la PC, Palm y el teléfono.
2•Implementar la arquitectura en una maqueta de manera académica.
3•Desarrollar e implementar una aplicación para el control y monitoreo de señales del sistema (la parte de
la computadora de escritorio).
4•Desarrollar e implementar una aplicación diferente para cumplir las mismas funciones del operador
central, pero de manera remota aprovechando la tecnología de los dispositivos móviles (Teléfono inteligentes, Pocket PC, Palm).
5•Integrar varias tecnologías en la aérea de ingeniería para automatizar y otorgarle la movilidad y
aprovechar al máximo el sistema.
90
informática, la finalidad de nuestro proyecto es integrar todos estos departamentos, y
darle robustez al área industrial.
Se realizara un hardware de adquisición de datos (variables físicas como
temperatura, presión, variables discretas como encendido o apagado de algún
dispositivo), y control de variables discretas (encendido y apagado), estos datos se
visualizaran en un software de control y visualización realizado en la plataforma de
programación “Visual Basic 6.0”, a la vez se guardaran de manera transparente para
el usuario en una base de datos realizada en “MySQL 5.0”, el software tipo SCADA
podrá visualizarse desde un dispositivo móvil de última generación tipo Smartphone,
Palm, Pocket, este dispositivo tendrá la capacidad tal cual el operador este frente a su
computador, es decir monitoreara, controlara los procesos gracias a la interacción
con la base de datos colocada en el servidor, el proyecto tiene dos valores agregados
muy útiles; el primero es que el operador podrá controlar la planta y estar informado
de la misma por medio de SMS(mensajes cortos de textos), una vez fuera de la
empresa y del área de la Wi-Fi, el segundo valor agregado es que dentro de la zona
Wi-Fi los dispositivos podrán estar siempre en contacto en otras palabras (“chatear”),
supongamos que existe un problema en una área específica por ejemplo “carga de
combustible”, y el operador visualiza en la pantalla del móvil una falla y este está
lejos del lugar, este tiene l posibilidad de ubicar a otros operadores por medio del
chat para que den solución al problema.
En fin, es un proyecto totalmente integral, compromete tecnologías tal como las
comunicaciones, sistemas, electrónica.
3.7 Nuestro Sistema
Como fue detallado en parte del primer capítulo el objetivo central es otorgarle al
operador la capacidad de moverse dentro y fuera de la industria sin llegar a
despegarse de ella, en este capítulo detallamos como logramos esos objetivos,
explicando el funcionamiento de los diferentes módulos. Se detallara el sistema de
manera general y se ahondará en la parte hardware tanto del módulo PC-USB, como
de la parte de control.
91
Figura 3.3: Esquema de nuestro Sistema
Fuente: Autores 3.7.1 Arquitectura del Sistema. Módulo Hardware.
Control por USB. (Adquisición y control de variables discretas.)
Comunicación por Radio Frecuencia de las variables.
Sistema a controlar.
Comunicación por SMS.
Acceso Inalámbrico desde dispositivos móviles y PC.
Dispositivos Móviles.
Módulo Software.
Servidor de aplicaciones.
Servidor WEB.
Base de Datos.
Aplicaciones de monitoreo y control.
92
3.7.2 Descripción general del proceso. Empezamos por el sistema que no es más que un proceso netamente académico y
demostrativo por cuestiones económicas, tiempo, y fácil de interpretar, pero no con
esto damos poca complejidad al proyecto ya que lo que queremos demostrar es la
integración de tecnologías para la implementación del sistema completo.
Este puede migrar a procesos grandes e instalarse sin complicaciones en los mismos.
Figura 3.4: Descripción de Nuestro Sistema Fuente: Autores
Un claro posible aplicación segura de este sistema es sin dunda en el monitoreo de
los tanques elevados ya que las bombas de llenado y vaciado están a una
considerable distancia y lo operadores se encuentran en constante movimiento.
Contamos con un tanque elevado el cual tiene dos bombas, la primera que es de
llenado y la segunda de vaciado, ambas bombas cuentan con sensores de
temperatura, y el tanque tiene tres medidores puntuales que indican el nivel de agua
presente en el mismo.
El estado de las bombas (encendido, apagado, temperatura), niveles de agua presente
en el tanque son llevadas hacia la Servidor central de manera inalámbrica, para lograr
esto usamos los módulos HT-12E (2 para el transmisión).
93
El módulo PC-USB se encarga de tomar esas variables por otro módulo de RF
llamado HT-12D (2 para la recepción).
Estos valores son tomados y llevados al computador por medio del puerto de
comunicación USB, son procesados, interpretados por un programa desarrollado bajo
la plataforma Visual Basic 6.0, este se encarga de monitorear estas variables y las
almacena en una base de datos, dependiendo de algoritmo, procedimiento o proceso
en el que se encuentre, esta base esta desarrolla bajo la plataforma MySQL 5.0, a su
vez el control o monitoreo puede hacerse desde un teléfono inteligente, PocketPC o
palm, este o estos cuentan con un programa desarrollado bajo la plataforma J2ME, el
cual acceda a la base de datos, consulta o modifica de acuerdo a la acción a realizar.
La comunicación también la realiza desde el computador central hacia el sistema a
controlar, dependiendo de la acción a realizar de igual manera modifica los campos
de la tabla para dar oportunidad al operador móvil de ejecutar acciones desde el
móvil.
La distancia máxima de un dispositivo de comunicación a otro es de 80 metros,
características técnicas otorgadas por el fabricante, existen otros módulos que
permiten comunicaciones a distancias mayores.
El rango de operación de los dispositivos móviles está limitado a la red inalámbrica
implementada en la industria.
Como valor agregado contamos con un módulo comunicación dentro de cada
dispositivo móvil que permite a los operadores mantenerse comunicado dentro del
perímetro de la red.
Además tenemos un sistema de alarma cuando se está fuera de la empresa, por medio
de SMS, dando al operador la oportunidad de solucionar los problemas de manera
remota, como por ejemplo apagar una bomba si se disparo una temperatura.
Se detalla a continuación el proceso subdivido en partes antes mencionadas.
94
3.8 Hardware del sistema
3.8.1 Control por USB. (Adquisición y control de variables discretas.)
La parte principal de este módulo lo constituye el integrado PIC 18F4550 del
fabricante Microchip, la función del mismo es de comunicar el software presente en
nuestro servidor hacia el módulo de control de las bombas.
Su principio básico es la de un puente, monitorea los pines de entrada, y envía esos
valores en formato de trama hacia la PC, por medio de la siguiente sentencia
“usb_put_packet(1,envia,8,USB_DTS_TOGGLE)”, dentro del programa presente en
el servidor llevara el código necesario para interactuar con el PIC y poder reconocer
cada una de esas entradas, así mismo podrá ser capaz de recibir la trama de datos
desde el software del servidor por medio de la siguiente sentencia:
“usb_get_packet(1, recibe, 8)”.
Una vez teniendo los datos en el buffer este los enviara hacia el codificador HT-12D,
y a la vez por medio de RF hacia el módulo que controla las bombas de llenado y
vaciado, estos datos son descritos en la tabla 3.2.
Los bits que recibirá el PIC, y que serán otorgados a la PC, serán los mencionados en
la tabla 3.1, los mismos que son capturados por los decodificadores HT-12E.
El puerto “D” del PIC 18F4550, está configurado como puerto de entradas, y el
puerto “B”, como salidas, el código esta desarrollado en “C”, compilado en CCS C
versión 4.057.
Este PIC, gestiona también el inicio de comunicación entre la PC, y el módulo de
control de las bombas, se encarga de habilitar y deshabilitar al HT-12D, para enviar y
recibir los datos.
Se muestra la configuración de los pines del PIC usado.
95
Figura 3.5: Descripción del PIC 18F4550
Fuente: DataSheep microchip
Existen dos varias maneras de instalar el dispositivo por medio de “plug and play”,
que no es más que instalar el dispositivo por medio de HID (Dispositivo de Interfaz
Humana), con velocidades bajas, no necesita driver’s, un claro ejemplo de esto son
los lectores de código de barras, termómetros, mouse, etc.
La manera que interactúan con Windows estos dispositivos es por medio de un VID
(VENDOR IDENTIFICATION), y un PID (PRODUCT IDENTIFICATION), estos
valores son otorgados por Microsoft a los fabricantes de hardware con tecnología
USB.
3.8.1.1 Instalando Driver’s
Para que nuestra tarjeta pueda interactuar con el software es necesario instalar un
driver que permita la comunicación entre el firmware del PIC y el firmware del
Software.
a.- Firmware del PIC.
El VID es un número de 16 bits que significa Vendor Identification o código que
identifica al fabricante del hardware a conectar. En nuestro caso utilizamos el
número 04D8h que identifica a Microchip.
96
El PID es un número de 16 bits que significa Product Identification o código que
identifica al dispositivo en concreto hardware a conectar. En nuestro caso utilizamos
el número 000Ah que identifica a la familia de los PIC18 de este fabricante.
Estos parámetros son colocados en la librería: PicUSB.h, hacemos referencia de esta
en el programa principal del PIC llamado MiUSB.c
Cuando el S.O. conecte con nuestro firmware recibirá el VID&PID y buscará entre
sus drivers instalados para encontrar el que corresponde a esta identificación, si no la
encuentra nos preguntará sobre donde ha de buscar un driver adecuado y deberemos
indicarle su ubicación. Este driver deberá estar configurado para conectar con un
hardware cuyo VID&PID sea el mismo.
A continuación mostramos los pasos para instalar nuestro dispositivo.
Figura 3.6: Instalación del PIC
Fuente: Autores
Podemos definir un nombre para que aparezca en el administrador de dispositivos.
97
Figura 3.7: Periférico conectado. Fuente: Autores
Estos valores deben de ser colocados dentro del archivo picusb.ini para lograr lo
descrito anteriormente.
[Strings] MFGNAME="PROYECTO SALESIANO" INSTDISK="PicUSB Device Driver Disc" DESCRIPTION="CONTROL PIC-PC" SVCDESC="PicUSB Device Driver" ClassName="Control PC-PIC" ClassDesc="PicUSB Sample Device"
b. - Firmware del Software.
Dentro de Visual Basic la manera de comunicación entre la aplicación y el hardware
es por medio de un módulo llamado VBMPUSBAPI.BAS. Esta lleva las rutinas de
llamada a la librería MPUSBAPI.DLL. Mostramos un diagrama de flujo del módulo.
Nuestro dispositivo.
Inicio
Llama DLL
Abre Puerto
Verifico VID y PID
Modulo envia y recibe
Cierra Puerto.
98
Por medio de la siguiente línea de código declaramos el VID y PID con el cual
vamos identificar nuestro dispositivo:
Public Const vid_pid = "vid_04d8&pid_0011" ' Vendor id (Microchip) y Periférico id.
3.8.1.2 Circuito PIC-USB.
Mostramos el circuito de nuestro módulo PIC-USB, notamos los pocos componentes
externos a utilizar.
Figura 3.8: Diagrama del circuito PIC-USB
Fuente: Autores
99
Bit Descripción
D0 Status Sistema General.
D1 Confirmación bomba2
D2 Confirmación bomba1
D3 Tanque Lleno
D4 Tanque Medio
D5 Tanque Vacio
D6 Sensor temperatura bomba2
D7 Sensor temperatura bomba1
Tabla 3.1: Descripción de entradas al PIC 18F4550 Fuente: Autores
Así mismo se reciben los provenientes del sistema a controlar, estos son:
Bit Descripción
B0 On/Off Sistema General
B1 On_Off Bomba 1
B2 On_Off Bomba 2
B3 Control Sistema Total
Tabla 3.2: Descripción de salidas del PIC 18F4550 Fuente: Autores
3.8.2 Comunicación por Radio Frecuencia de las variables.
En esta sección mostraremos los transmisores y receptores de RF, que serán los
encargados de comunicar el módulo PC-USB y el sistema a controlar (Control de
Bombas), como se menciono se utilizan los módulos UHF TWS-418 y RWS-418,
que tienen un alcance máximo de 80 metros.
100
Figura 3.9: Principio de funcionamiento Fuente: Autores
Estos módulos son propiamente de RF, para lograr comunicarnos con mi PIC
utilizaos un par de chips para codificación y decodificación, los HT12E
(Codificador-Emisor) y HT12D (Decodificador-Receptor), respectivamente.
Este juego de integrados codifica y decodifica una palabra de 12 bits, compuesta por
una dirección de 8 bits y una sección de datos de 4 bits. Con esta cantidad de bits se
pueden comandar 256 dispositivos diferentes, enviándoles hasta 16 comandos
distintos a cada uno.
3.8.2.1 Transmisor para un enlace de RF
Figura 3.10: Módulo de Transmisión Fuente: Autores
Mostraos la manera de conexión del módulo transmisor, el rango de voltaje que
permite es de 5 a 12 voltios DC.
101
3.8.2.2 Receptor para un enlace de RF
Figura 3.11: Módulo de Transmisión Fuente: Autores
El receptor, por las características técnicas del chip decodificador HT12D, debe
funcionar exclusivamente con 5V.
3.8.2.3 Receptor-Emisores en módulo PC-USB
Hay que recalcar que mientras se está recibiendo data, el módulo emisor debe estar
desactivado, logramos manteniendo en alto la entrada TE (Transmission Enable =
Habilitación de la transmisión), del integrado codificador HT12E.
Logramos esto con la interacción del PIC y el programa desarrollado en Visual
Basic, de la siguiente manera: Supongamos que se quiere prender el sistema el
operador deberá encender el bit “0” del puerto “B”, “B0” y adicionalmente deberá
habilitar la transmisión. Mostramos un fragmento de código con lo cual se logra, por
cuestiones de seguridad también preguntamos si el dispositivo está conectado, y
podemos también transmitir manualmente con el interruptor conectado en el bit “0”
del puerto “A”, “A0”.
#define LED0 PIN_B7
If (input (PIN_A0) && (usb_enumerated ())) {
Led off (led0);
led_on(Led1);
delay_ms (200);
led_on(Led0);
led_off(Led1);
102
delay_ms (400);
}
3.8.2.4 Receptor-Emisores en módulo Sistema a Controlar.
La teoría es idénticamente igual, acá manejamos dos módulos transmisores ya que
enviamos 4 bits por cada uno de ellos.
Logramos esto ya no por software ni por el PIC mas bien lo hacemos con un reloj
externo para hacerlo totalmente independiente del PIC, logramos sincronizar el envío
de data hacia el módulos conectado en la PC. Así mismo recibimos 4 bits que son de
control Mostramos a continuación el hardware de lo antes descrito:
Figura 3.12: Fuente externa de pulsos.
Fuente: Autores
3.8.2.5 Detalles Técnicos HT-12D / HT-12E
Al tratarse de integrados que se fabrican para que trabajen asociados, uno tiende a
creer que la resistencia que determina la frecuencia del oscilador interno del chip
tendría el mismo valor en ambos circuitos. Sin embargo, para mi sorpresa, no es así.
Como se puede observar en los circuitos, los valores tienen una gran diferencia: 1M
para el transmisor y 47K para el receptor. Posiblemente se pueda afinar aún más la
sensibilidad del receptor ajustando el valor de este último resistor.
103
Cuando se mantiene en bajo la entrada TE (Transmission Enable = Habilitación de la
transmisión), el integrado codificador HT12E transmite constantemente, repitiendo
el código una y otra vez. En estas condiciones, si se modifica el valor de las entradas
de datos se observa que el valor va cambiando en el receptor. Así fue como hicimos
la prueba. El transmisor trabaja con 5 voltios.
En el integrado decodificador HT12D, la señal VT significa Valid Transmission
(Transmisión Válida), es decir, cada vez que esta señal va a un nivel alto es porque el
código presente en la salida de datos es un dato válido para ese dispositivo. Si el
dispositivo no cumple con la dirección que viene en la palabra que ha recibido,
obviamente no se produce esta señal.
3.8.3 Sistema a controlar.
Es la parte del proyecto donde se va a monitorear el estado de las bombas, la
temperatura de las mismas, el nivel del tanque, la interacción con el módulo control
por teléfono (vía SMS). Vemos a continuación la cisterna, el tanque de desecho y el
tanque principal junto a las bombas de llenado y vaciado.
Figura 3.13: Sistema de Llenado y Vaciado. Fuente: Autores
El esquema general del control de bombas se muestra en la siguiente grafica:
104
Figura 3.14: Esquema general “Control de Bombas” Fuente: Autores
Contamos con las siguientes secciones:
Tanque Principal.
Adquisición de Temperatura.
Control bombas y confirmación de bombas
Sistema remoto.
Variables de status.
Control principal.
Fuente de Alimentación
3.8.3.1 Tanque Principal.
Físicamente estarán colocados tres medidores en el tanque principal, el de nivel bajo,
nivel medio y nivel alto. Son de tipo puntual acoplados a un circuito anti rebote cada
uno de ellos y pasan al PIC, para ser procesados por el programa interno del mismo.
Con las siguientes líneas de código sabemos si el tanque se encuentra lleno o vacio.
If Nivel_Bajo=0 or nivel_bajo=1 then AccionNivelBajo
105
if Nivel_bajo=1 and nivel_alto=1 then AccionNivelAlto
En caso de estar en nivel bajo el PIC envía el status al sistema PC-USB, para que
este pueda encender la bomba de llenado, si es el caso de que el tanque se encuentra
lleno, envía este status y espera la confirmación de encendido de la bomba de
descarga.
El circuito anti rebote lo compone una compuerta tipo SCHMITT TRIGGER, de la
serie 4093, un condensador y 2 resistencias, tal cual indica el diagrama siguiente:
Figura 3.15: Esquema general “Control de Bombas”
Fuente: Autores
3.8.3.2 Adquisición de temperatura.
No es más que el acople para monitorear la temperatura de las bombas en línea,
dependiendo de cuál de ellas este encendida.
Lo constituye el sensor LM-35 que es un sensor de temperatura cuyo rango de
medición va desde los -55 ºC a 150 ºC, el mismo que esta calibrado directamente en
grados centígrados, su factor de escala lineal es de +10.01 mV / ºC, y su precisión es
de +/- 0.5 ºC, el rango de operación del mismo va desde los 4 voltios a 30 voltios
DC.
106
Figura 3.16: Esquema general “Control de Bombas”
Fuente: Autores
Como el sensor solo es capaz de entregar a su salida un voltaje de -0.55V a 1.5V
tenemos que acoplar esa señal para poderla llevar al PIC y ser procesada, logramos
esto colocando un amplificador seguidor unitario a la salida del sensor, y un
amplificador no inversor a la salida del primer operacional, esta señal ya acoplada es
enviada a la entrada del PIC, previamente configurada como entradas análogas, y
referencia a 5 voltios, de la siguiente manera:
ADCON1 = %00000101; el puerto A.0, A.1 análogos--A.2 Dig--A.3 +Vref--A.4 Dig
El comportamiento de dentro del PIC a lo que censa la temperatura en cada bomba
está traducido a continuación en un diagrama de flujo.
Si la temperatura sobrepasa el límite colocado en la memoria entonces indicara por
medio de los bits: S1 y S2 que corresponden a temperatura de bomba1 y bomba2
respectivamente.
107
DATO > TEMP1
EPROM 0,[45,45] READ 0, TEMP1READ 1, TEMP2
ADCIN 0, DATOSENSA 1
ALARMA 1
DATO2 > TEMP2
ADCIN 1, DATO 2
ALARMA 2
PROGRAMAPRINCIPAL
SENSA 2
F
F
V
V
Figura 3.17: Diagrama flujo Temperatura Fuente: Autores
A continuación el fragmento de código del diagrama de flujo antes descrito.
;-----------------------------------------------------------------------
eeprom 0,[45,45] ;contenido inicial de la EEPROM
READ 0,temp1 ;lee la EEPROM 0 y lo guarda en temp1
READ 1,temp2 ;lee la EEPROM 1 y lo guarda en temp2
Sensa1:
ADCIN 0, dato ;leer el canal 0 (A0) y guarde en dato
dato = dato /2 ;el dato dividir para 2
if dato > temp1 then Alarma1
Sensa2:
ADCIN 1, dato2 ;leer el canal 0 (A0) y guarde en dato
dato2 = dato2 /2 ;el dato dividir para 2
if dato2 > temp2 then Alarma2
108
3.8.3.3 Control Bombas y confirmación bombas.
Tenemos tres maneras de encender las bombas.
La primera es de manera manual, es decir habrá en campo una botonera capaz de
encender y apagar la misma.
Supongamos que el sistema arranca de manera normal y verifica que el tanque esta
vacio por medio de los sensores, este envía el estatus del mismo, esperando que el
operador encienda la bomba de llenado por medio del software ubicado en el PC o
por medio del POCKET, esta es la segunda forma de prender las bombas. En
operación normal el tanque seguirá llenándose hasta que el nivel del mismo este a su
máxima capacidad, en ese instante la bomba se apagara, y estará lista para ser
encendida y empezar la descarga cuyo proceso es el mismo.
En caso de haber un calentamiento en cualquiera de las bombas en pleno proceso, el
sistema indica al operador que deberá apagar la bomba.
La tercera es por medio de Sistema Remoto, que no es más que la interacción entre
un PIC y un móvil, se hablara más delante de esta etapa.
Se ha considerado l confirmación de encendido de bombas gracias a que los relay
cuentan con dos comunes y cuatro contactos, internamente en el PIC se coloco
código capaz de controlar los picos (anti rebote) de los relay’s
Mostramos fragmento del código, así como su circuito.
if On_Off_B2 = 1 then ActivaB2
Goto AccionNivelAlto
Activa2_B2:
pause 100
high Conf2_B2
for i=1 to 100
pause 4
next
low Tanque_Lleno
109
Figura 3.18: Etapa encendido-apagado bombas.
Fuente: Autores
3.8.3.4 Sistema Remoto.
Su principal componente es el PIC 16F870, se encarga de monitorear el sistema de
manera paralela al PIC principal, para permitir al operador controlar las bombas
desde un teléfono celular de cualquier marca, modelo y de cualquier operadora.
Todo status es monitoreado y avisado de manera de mensajes de texto hacia un
teléfono destino, previamente configurado su número, de la misma manera hacemos
control.
Esto se logra gracias a la comunicación AT, que realiza el teléfono con el PIC de
manera serial, la seguridad del control radica en el programa del PIC, ya que aquí se
coloca el número telefónico único capaz de comunicarse con el sistema.
Mostramos a continuación fragmento del código, junto a su circuito esquemático.
SEROUT2 portb.1,84,[13]
SEROUT2 portb.1,84,["AT+CMGL=0",13]
SERIN2 portb.0,84,[dat0]
SERIN2 portb.0,84, [wait(", ,"),DEC2 dat1]
110
Serin2 portb.0,84, [wait("097482141"),SKIP 5,dec2 dat2]
serout2 portb.1,84, ["AT+CMGD=1",13]
Figura 3.19: Sistema Remoto.
Fuente: Autores
3.8.3.5 Variables de Status.
Son las variables del sistema, mostramos a continuación la declaración de las
mismas.
; Declaro los nombres de los pines
;-----------------------------------------------------------------------
Nivel_Bajo var portA.2 ; IN Nivel Bajo de la Cisterna
Nivel_Alto var portA.4 ; IN Nivel Alto de la Cisterna
Control_Sist_Total var portA.5 ; IN Encendido total del Sistema.
;---PUERTO B--- SALIDAS---
S_1 var portB.0 ; Indica temp alta de la bomba1, se conecta alarma1
S_2 var portB.1 ; Indica temp alta de la bomba2, se conecta alarma2
bomba1 var portB.2 ; Enciende bomba1
bomba2 var portD.1 ; Enciende bomba2
Tanque_LLeno var portB.4 ; Indica estado sensor Nivel_Alto
111
Tanque_Vacio var portB.6 ; Indica estado sensor Nivel_Bajo
On_Off_Sistema_Total var portB.7 ; habilita el sistema total
;---PUERTO C--- ENTRADAS Y SALIDAS---
Confirma_B1 var portC.0 ; IN confirmación ON de bomba_1 desde Sist Electrónico
Confirma_B2 var portC.1 ; IN confirmación ON de bomba_2 desde Sist Electrónico
On_Off_B1 var portC.2 ; IN confirmación encendido bomba_1 desde receptor
On_Off_B2 var portC.3 ; IN confirmación encendido bomba_2 desde receptor
Conf1_B1 var portC.4 ; Out conf ON de B1 hacia Emisor
Conf2_B2 var portC.5 ; Out conf ON de B2 hacia Emisor
Ok var portC.7 ; Out Indica estado del sistema
Así también se muestra el diagrama esquemático de las variables a recibir como a
enviar, en total son 12.
Figura 3.20: Variables del Sistema
Fuente: Autores
112
3.8.3.6 Control Principal.
Lo principal del sistema, podemos considerarlo como la parte medular del mismo,
aquí radica el programa principal desarrollado en BASIC, bajo la plataforma
MicroCode Studio Plus v2.3, y el compilador es PicBasic Pro v2.47.
Lo compone básicamente el PIC16F877A, su descripción se detalla a continuación:
Tabla 3.3: Características Técnicas PIC
Fuente: Autores
En el transcurso del documento del documento se ha descrito el funcionamiento del
sistema por módulos, en esta etapa podemos mencionar que integramos todos ellos
para lograr el funcionamiento del sistema total.
Mostramos a continuación el PIC en detalle con todas las señales que llegan y salen
de él.
Figura 3.21: Control Principal. Fuente: Autores
113
3.8.3.7 Fuente de Alimentación
Tenemos dos etapas, la primera corresponde a la alimentación del sistema en sí, que
es de 5 voltios DC, y la fuente de potencia que es de 12 voltios DC y sirve para
alimentar las bombas, y los relay.
Mostramos el circuito de la misma:
Figura 3.22: Fuente de Alimentación. Fuente: Autores
3.9 Firmware del Sistema
3.9.1 Introducción a Visual Basic Visual Basic es uno de los tantos lenguajes de programación que podemos encontrar
hoy en día. Dicho lenguaje nace del BASIC (Beginner´s All-purpose Symbolic
Instruction Code) que fue creado en su versión original en el Dartmouth College, con
el propósito de servir a aquellas personas que estaban interesadas en iniciarse en
algún lenguaje de programación.
Primero fue GW-BASIC, luego se transformó en QuickBASIC y actualmente se lo
conoce como Visual Basic y la versión más reciente es la 6 que se incluye en el
paquete Visual Studio 6 de Microsoft. Esta versión combina la sencillez del BASIC
114
con un poderoso lenguaje de programación Visual que juntos permiten desarrollar
robustos programas de 32 bits para Windows.
Dentro de este Lenguaje de Programación podemos destacar la amplitud que nos da
al permitir trabajar con puertos de entrada y salida del ordenador siendo así la
herramienta perfecta para destacar en el trabajo con puertos seriales, paralelo y USB
de igual manera el soporte en librerías DLL para acceder a los mencionados puertos
hacen de Visual Basic 6.0 sea la mejor opción para el desarrollo de sistema que
deban de controlar y monitorear dispositivos externos al ordenador.
Su manejo de acoplamiento con las distintas base de datos por medio de la fuente
ODBC hace que visual BASIC permita integrar el sistema remoto con el monitoreo
más cercano al hardware realizando un testeo de cada evento suscitado en el
hardware para que los dispositivos remotos accedan a la base de datos de esta
manera poder lograr un permanente control y monitoreo del hardware.
Así también las librerías propias de visual Basic nos da un sistema de control de
eventos para poder manejar de manera más precisa y exacta los sucesos del hardware
priorizando cada evento sucedido desde el hardware el mismo parámetro que al
acceder al sistema pasa a ser tratado para efectuar la acción referente ha dicho evento
3.9.1.1 Características Generales de Visual Basic
Diseñador de entorno de datos: Es posible generar, de manera automática,
conectividad entre controles y datos mediante la acción de arrastrar y colocar sobre
formularios o informes.
Los Objetos Actives son una nueva tecnología de acceso a datos mediante la acción
de arrastrar y colocar sobre formularios o informes.
Asistente para formularios: Sirve para generar de manera automática formularios que
administran registros de tablas o consultas pertenecientes a una base de datos, hoja
de cálculo u objeto (ADO-ACTIVE DATA OBJECT)
115
Asistente para barras de herramientas es factible incluir barras de herramientas es
factible incluir barra de herramientas personalizada, donde el usuario selecciona los
botones que desea visualizar durante la ejecución.
En las aplicaciones HTML: Se combinan instrucciones de Visual Basic con código
HTML para controlar los eventos que se realizan con frecuencia en una página Web.
La Ventana de Vista de datos proporciona acceso a la estructura de una base de
datos. Desde esta también acceso al Diseñador de Consultas y diseñador de Base de
datos para administrar y registros.
3.9.1.2 Nociones de visual Basic
Es un lenguaje de fácil aprendizaje pensado tanto para programadores principiantes
como expertos, guiado por eventos, y centrado en un motor de formularios que
facilita el rápido desarrollo de aplicaciones gráficas. Su sintaxis, derivada del antiguo
BASIC, ha sido ampliada con el tiempo al agregarse las características típicas de los
lenguajes estructurados modernos. Se ha agregado una implementación limitada de la
programación orientada a objetos (los propios formularios y controles son objetos),
aunque sí admite el polimorfismo mediante el uso de los Interfaces, no admite la
herencia. No requiere de manejo de punteros y posee un manejo muy sencillo de
cadenas de caracteres. Posee varias bibliotecas para manejo de bases de datos,
pudiendo conectar con cualquier base de datos a través de ODBC (Informix, DBase,
Access, MySQL, SQL Server, etc) a través de ADO.
Es utilizado principalmente para aplicaciones de gestión de empresas, debido a la
rapidez con la que puede hacerse un programa que utilice una base de datos sencilla,
además de la abundancia de programadores en este lenguaje.
3.9.1.3 Entornos de desarrollo
Existen dos entornos de desarrollo IDE para Visual Basic:
• Microsoft Visual Basic x.0 para versiones desde la 1.0 hasta la 6.0, (con las
diferencias entre las versiones desde la 1.0 (MS-DOS/Windows 3.1) hasta la
116
SISTEMAMANTENIMIENTO
USUARIOS DISPOSITIVOS
PROCESOS
MONITOREO CONTROL
CONSULTAS
CONSUMODE USUARIOS VARIACIONESENCENDIDO/APAGADO
3.0 (16 bits, Windows 3.1) y las de la 4.0 (16/32 bits, Windows 3.1/95/NT)
hasta la 6.0 (32 bits, Windows 9x/Me/NT/2000/XP/Vista)
• Microsoft Visual Studio .NET, entorno integrado para varios lenguajes entre
ellos Visual Basic .NET (32/64 Bits, Windows XP/Vista), con ediciones:
Express (más limitada en herramientas pero gratuita)
Standard
Professional (Con licencia comercial)
Team Edition (Mucho más completa en herramientas con licencia
comercial más cara)
3.9.2 Descripción del Sistema
El esquema del sistema de acuerdo a la interacción será el usuario ingresara
directamente al monitoreo del proceso por medio de la interface así mismo el sistema
estará conectado con el hardware por medio del puerto USB de esta manera se tendrá
la interacción del sistema con el hardware.
El mismo que llenara las tablas de las base de datos para el monitoreo mediante el
sistema remoto controlado por los Dispositivos móviles.
3.9.2.1 Descomposición en subsistemas.
La aplicación está dividida en los siguientes formularios permitiendo dar una
descripción de manera global de la estructura del sistema.
A Figura 3.23: Módulo del firmware Fuente: Autores
117
SISTEMA
MANTENIMIENTO
PROCESOS
CONSULTAS
A continuación detallaremos cada uno de los módulos expuestos en este diagrama:
El sistema es dividido en tres grandes procesos cada uno de los cuales tendrán
módulos internos de gran importancia para la adecuación y funcionamiento del
sistema.
Dentro del mismo estarán módulos de temperaturas el cual dentro de una interface
totalmente amigable desplegara el funcionamiento del mantenimiento de las
temperaturas.
Dentro del mismo estará el monitoreo y el control del sistema de las variables tanto
de entrada como de salidas y las debidas acciones a tomar para el correcto
funcionamiento del sistema industrial
Dentro de la cual podrán efectuarse la consulta del consumo de líquido para el
proceso industrial.
3.9.2.2 Diseño de objetos.
Figura 3.24: Secuencia del Firmware
Fuente: Autores
2 Procesamiento de variables y ejecución de
acciones
3. Inserción y actualización
de datos en la base
1. Obtención de variables
118
3.9.3 Herramientas de desarrollo
3.9.3.1 Configuraciones ODBC Para MySQL
MySQL es una de las base de datos más rápidas y potentes de la actualidad si a esto
le agregamos lo rápido que se torna desarrollar bajo Visual Basic sin dudas corremos
con grandes ventajas a la hora de crear potentes aplicaciones. No solo para acceder
de forma local a nuestra base de datos sino también puede que necesitemos acceder a
un servidor MySQL localizado en otra parte del mundo y hasta que este corra bajo
Linux.
Primero debemos de proceder a la instalación del ODBC para integrar Mysql5.1 con
VB6.0 dicho componente es mysql-connector-odbc-5.1.0-alpha-win32 para proceder
a la configuración del ODBC seguir los siguientes pasos: Inicio >Panel de
Control>Herramientas Administrativas>Orígenes de datos ODBC
Figura 3.25: Instalación del Driver ODBC Fuente: Autores
Como primer paso debemos crear la referencia a ADO (Ado Data Control 6.0) desde
nuestro Visual Basic, para esto vamos al menú Proyecto > Componentes... y ahí
seleccionamos Microsoft Ado Data Control 6.0.
119
Código Para realizar la conexión con el ODBC.
Public rs As ADODB.Recordset Public con As Connection Public Sub Conectar() Set con = New ADODB.Connection con.ConnectionString = "DRIVER = {MySQL ODBC 5.51 Driver}; Server = localhost; Uid=root; pwd=pasw; database=prueba; connection " con.Open If con.State = 1 Then MsgBox "Conectada" Else MsgBox "Error" End If End Sub Sub registro() Set rs = New ADODB.Recordset With rs .ActiveConnection = con .CursorLocation = adUseClient .CursorType = adOpenDynamic .LockType = adLockOptimistic .Open "Select * from usuario" End With End Sub Private Sub Form_Load() Conectar End Sub
3.9.3.2 Instalación de Componentes LabView
Acerca de LabView LabVIEW es una herramienta gráfica para pruebas, control y diseño mediante la
programación. El lenguaje que usa se llama lenguaje G. Este programa fue creado
por National Instruments (1976) para funcionar sobre máquinas MAC, salió al
mercado por primera vez en 1986. Ahora está disponible para las plataformas
Windows, UNIX, MAC y Linux y va por la versión 8.5.1 con soporte para Windows
Vista.
Los programas desarrollados con LabVIEW se llaman Instrumentos Virtuales, o VIs,
lo que da una idea de su uso en origen: el control de instrumentos. El lema de
LabVIEW es: "La potencia está en el Software". Entre sus objetivos están el reducir
el tiempo de desarrollo de aplicaciones de todo tipo (no sólo en ámbitos de Pruebas,
Control y Diseño) y el permitir la entrada a la informática a programadores no
120
expertos. Esto no significa que la empresa haga únicamente software, sino que busca
combinar este software con todo tipo de hardware, tanto propio -tarjetas de
adquisición de datos, PAC, Visión, y otro Hardware- como de terceras empresas.
Principales usos
Es usado principalmente por ingenieros y científicos para tareas como:
Adquisición de datos
Control de instrumentos
Automatización industrial o PAC (Controlador de Automatización
Programable)
Diseño de control: prototipaje rápido y hardware-en-el-ciclo (HIL)
Diseño Embebido
Domótica
Measurement Studio de National Instruments
National Instruments Measurement Studio es un conjunto de aplicaciones integrado
de clases y controles para aplicaciones de prueba, medida y automatización en Visual
Studio 6.0. Measurement Studio reduce drásticamente el tiempo de desarrollo de la
aplicación, ya que ofrece Windows Forms, Web Forms y controles de interfaz de
usuario de ActiveX diseñados para ingenieros, análisis científicos avanzados,
adquisición de datos (DAQ) y bibliotecas de clases de instrumentos de control
optimizadas para pruebas.
Figura 3.26: Gráficos de LabVIEW
Fuente: www.ni.com/mstudio/
121
Para la colocación del componente de LabVIEW en nuestro proyecto simplemente
basta con instalar la aplicación en nuestro PC y desde ahí se procederá a realizar el
llamado desde Visual Basic de la siguiente manera:
Figura 3.27: Agregar componente de LabVIEW Fuente: Autores
A continuación procedes a escogerlo desde la barra de herramientas y agregarlo al
formulario dentro del mismo se tiene varias opciones para realizar la configuración
sobre el modo de presentación del mismo
Figura 3.28: Utilización del componente de LabVIEW sobre Vb 6.0 Fuente: Autores
122
3.9.3.3 Componentes utilizados en el firmware.
En este capítulo examinaremos cada uno de los objetos utilizados en los sistemas así
como la utilización y los tipos de variables que hemos utilizado para obtener un
conocimiento global de la utilización de los mismos en los formularios realizado para
la presentación del sistema al usuario.
TextBox: Mediante este control podremos realizar tanto la entrada
como la salida de datos en nuestras aplicaciones.
Figura 3.29: TexBox Fuente: Visual Basic
Label: Este control es también uno de los más utilizados, aunque su
utilidad queda restringida a la visualización de datos en el mismo, no
permitiendo la introducción de datos por parte del usuario.
Figura 3.30: Label Fuente: Visual Basic
CommandButton: Este control es el típico botón que aparece en todas
las aplicaciones y que al hacer clic sobre él nos permite realizar alguna
operación concreta, normalmente Aceptar o Cancelar.
Figura 3.31: CommandButton Fuente: Visual Basic
Toolbar: Este control nos permite agregar una barra de control en
nuestro formulario el mismo que podrá tener características y enlace
de diferentes dependiendo de la necesidad que genere la aplicación.
Figura 3.32: Toolbar Fuente: Visual Basic
CWSlide: Control obtenido de la librería de LabVIEW que ya
revisamos en la parte anterior, como instalar este componente el
mismo nos permite representar la grafica del nivel del tanque.
Figura 3.33 CWSlide Fuente: Visual Basic
123
Figura 3.38: CheckBox
Fuente: Visual Basic
RichTextBox: Este control es un componente que nos da una opción de
colocar un archivo RPT como una lista dentro de nuestro formulario,
pudiendo manipular el documento con las características de un archivo
plano Figura 3.34: RichTextBox Fuente: Visual Basic
Calendar: Control que nos brinda las propiedades de un calendario
dentro de nuestro formulario, permitiendo captura la fecha que el
usuario escoja es ideal para la consulta de reportes por rango de
fechas
Figura 3.35: Calendar Fuente: Visual Basic
CrystalReport: Componente que nos brinda el programa Crystal
Report el mismo que nos brinda este componente par ser llamado
desde Vb 6.0, es utilizado para realizar la llamada de los archivos
creados bajo extensión RPT.
Figura 3.36: CrystalReport Fuente: Visual Basic
Frame: Nos permite el agrupamiento de controles para poder realizar
una mejor presentación del formulario al usuario final.
Figura 3.37: Frame Fuente: Visual Basic
CHECK BUTTON Y OPTION BUTTON: El control CheckBox, o casilla de
verificación, permite elegir una opción (activada /
desactivada, True/False) que el usuario puede establecer o
anular haciendo clic. Una X en una casilla de verificación
indica que está seleccionada, activada, o con valor True.
Cada casilla de verificación es independiente de las demás
que puedan existir en el formulario, pudiendo tomar cada una de ellas el valor True o
False, a voluntad del operador. Un control OptionButton muestra una opción que se
puede activar o desactivar, pero con dependencia del estado de otros controles
OptionButton que existan en el formulario.
124
Figura 3.39: ListBox Fuente: Visual Basic
Figura 3.40: Timer Fuente: Visual Basic
LIST BOX Y COMBO BOX: Un control ListBox muestra una lista de elementos en la que el
usuario puede seleccionar uno o más. Si el número de elementos
supera el número que puede mostrarse, se agregará
automáticamente una barra de desplazamiento al control
ListBox.
TIMER TEMPORIZADOR: Este objeto permite establecer temporizaciones.
Presenta una novedad respecto a los controles estudiados
hasta ahora. El control Timer solamente se ve durante el
tiempo de diseño. En tiempo de ejecución, el control
permanece invisible. La temporización producida por el
Timer es independiente de la velocidad de trabajo del
ordenador.
Variable: Dim: Al declarar una variable con esta palabra estamos diciendo que la
variable sea local al ámbito en que se declara. Puede ser dentro de un procedimiento
o dentro de un formulario, de esta forma no sería accesible desde los demás
procedimientos o formularios.
Public: Las variables declaradas serán públicas y podrán estar accesibles desde todos
los formularios de la aplicación. Para conseguirlo tendremos que declararlas en un
módulo de código, no en la sección declaraciones de cualquier formulario de los que
conste la aplicación. Para crear un módulo de código en el menú principal de Visual
Basic marcamos en INSERT/MODULE y aparecerá junto a los demás formularios de
la ventana de proyecto aunque con un icono distinto indicando que se trata de un
módulo de código.
Static: Con esta forma de declarar variables conseguiremos que las variables locales
no se creen y se destruyan al entrar y salir de los procedimientos donde fueron
declaradas sino que se mantenga su valor durante todo el periodo de ejecución de la
aplicación. De esta forma a entrar en algún procedimiento las variables recuerdan el
valor que tenían cuando se salió de él.
125
TIPOS DE VARIABLES
TIPO COMENTARIO BOOLEAN Sólo admite 2 valores TRUE o FALSE BYTE admite valores entre 0 y 255 INTEGER admite valores entre -32768 y 32767 LONG admite valores entre -2.147.483.648 y 2.147.483.647 SINGLE admite valores decimales con precisión simple DOUBLE admite valores decimales de doble precisión CURRENCY válido para valores de tipo moneda STRING cadenas de caracteres DATE fechas, permite operar con ellas
Tabla 3.4: Tipos de Variables Fuente: www.lawebdelprogramador.com
Constantes: Declaración de constantes que pueden ser usadas en cualquier punto en
lugar de su valor, permitiendo cambiarlo cuando sea necesario, sin tener que
cambiarlo en todos los sitios en que se utiliza. La expresión no puede utilizar
llamadas a funciones, pues la constante se calcula en tiempo de compilación, no en
tiempo de ejecución.
3.9.3.4 Creación de archivo RPT mediante Crystal Report
Al abrir el Crystal Report con la primera pantalla que nos mostrara será la siguiente:
Figura 3.41: Utilización de Crystal Report Fuente: Autores
Selecciona la opción de Crear un Nuevo Documento de Crystal Report utilizando el Wizard.
126
La opción que "En tat Expert" permite extraer los datos directamente de la base de
datos. También puedes crear un Documento De Crystal vacío para configura
después, m agregando campos y datos cuando sea necesario. Usted puede escoger el
tipo de informe (normal). Después de este paso, pulse el botón en "OK."
Usted también puede acceder al Wizard escogiendo "Archivo", "Nuevo" del menú
de Crystal
Selección de la Base de datos
Figura 3.42: Utilización de Crystal Report
Fuente: Autores
Usted debe seleccionar la base de datos de la que usted tomara los datos que se
usarán en el Reporte de Crystal. Pulse el botón en " Data base " y seleccione la base
de datos.
Agregando Tablas
Después de la selección de la base de datos es necesario agregar las tablas de las
mismas al reporte.
Figura 3.43: Agregando tablas Fuente: Autores
127
El explorador te permite escoger y visualizar la tabla de tu base de datos que desees
colocar en tu reporte
Escoger los datos de un reporte
Figura 3.44: Escoger datos de un reporte
Fuente: Autores
Su próximo paso es seleccionar campos que usted quiere mostrar en el informe.
Luego pulse el botón "Next". Los campos agregados están en el brillo. Nosotros
podemos agregar tantos campos como sea necesario. Si usted quiere que su informe
este agrupado, usted puede seleccionar la columna por la cual quiere agrupar. Pulse
el botón adelante "Finish"
Ambiente de Reporte
Figura 3.45: Ambiente de un reporte
Fuente: Autores
El Documento De cristal está en el modo “Design”.
Usted podría ver los campos agregados al formulario. Usted puede anular o puede
agregar otros. La fecha de imprimir y el número de páginas son los campos
especiales. Usted tiene la posibilidad de mover los campos para modificar la
presentación del informe de acuerdo a nuestra necesidad.
128
3.9.4 Descripción del entorno de desarrollo en Visual Basic
Dentro de este capítulo conoceremos un poco mas de los componentes utilizados en
el sistema para el desarrollo de nuestra aplicación tanto en sus aplicación como en su
utilización de los mismo, su manera de instalación y la manera de llamarlo desde Vb
así mismo se tendrá un vasto conocimiento en los componentes propios de Vb para
desarrollar la interface grafica del proyecto
Encontrando aplicativos de LabView los mismos que nos permitieron una mejor
traficación mediante el slider para el visor de tanque de llenado.
Dentro de las fases de desarrollo en sistema de visual se podrá denotar cada una de
los componentes utilizados para la creación de formularios los mismos que serán de
la utilización directa para el usuario.
La creación de los archivos RTP son desarrollados desde Crystal Report cuyos
parámetros son entregados desde el Vb 6.0 para realizar consultas especificas y así
lograr un reporte más efectivo de acuerdo al requerimiento del usuario.
3.9.4.1 Justificación del Firmware y su funcionamiento
A continuación, se procederá con el desarrollo de las incursiones de los componentes
necesarios para obtener la forma del programa así como el análisis del sistema y de
sus variables.
El sistema desarrollado es capaz de capturar y procesar las salidas del micro
controlador PIC realizando acciones de acuerdo a las necesidades del sistema y así
lograr el buen funcionamiento del mismo contemplando cada uno de los parámetros
de suceso posibles de ocurrir mientras este activo el proceso industrial. Así mismo el
esquema del código permite que el mismo sea escalable ya que contiene un código
de procesos y acciones en manera modular
El sistema comprende de 8 entradas y 8salidas esquematizadas en los requerimientos
de nuestro sistema a continuación se detallara las mismas
129
Salidas Sistema General: El Bit B0 es el encargado de mantener el pulso para el
funcionamiento de la placa controladora.
Bomba de carga: El Bit B1 activa un destello para precisar el encendido de la bomba
Bomba Descarga: El Bit B2 activa un destello para precisar el encendido de la
bomba 2
Sistema remoto: El Bit B3 es el encargado de enviar la activación al PIC de sistema
remoto
Entradas
Confirmaciones
Sistema General: Luego de que el sistema general arranca me envía un
Bit en alto para confirmarme q el sistema realmente arranco
Bomba de carga: El Bit D1 activa un destello para precisar el encendido de la bomba
Bomba Descarga: El Bit D2 activa un destello para precisar el encendido de la
bomba 2
Niveles de tanque Nivel Alto: Activación de D3 en el momento en que ocurre el llenado del tanque
Nivel Medio: Activación de D4 en el momento en que el tanque se encuentra a
mitad de su volumen total
Nivel Bajo: Activación de D. en el momento en q el tanque comienza a cargar
Sensores de temperatura Sensor1: D7 se activa en caso de recibir una anormalidad en la temperatura de la
bomba1
Sensor2: D6 se activa en caso de recibir una anormalidad en la temperatura de la
bomba2
El módulo de monitoreo arranca con la llamada a un método de reconocimiento de
periférico mediante un proceso desarrollado de comunicación USB directa con el
PIC 18F4550 programado con comandos en lenguaje "C" el mismo que se encarga
130
de realizar la captura de la data de 8 bit que han sido enviados desde mi módulo del
sistema a controlar.
De manera explícita y de manera paralela se proceden a ejecutar procedimientos de
limpieza a la base de datos y demás variables, así mismo el sistema se encarga de ser
informado del tipo de usuario que acceso el mismo.
Figura 3.46: Pantalla de Monitoreo del Proceso.
Fuente: Autores
El sistema consta de envió de data al hardware como el encendido de las Bombas las
mismas que realizan procesos paralelos al momento de ejecutar alguna acción
manejando un aplicativo de conexión tanto a la base de datos como al PIC para
detectar alguna novedad en el sistema. (Anexos- FRMUSB)
Mediante el acceso a la base se guardaran datos del proceso en la tabla registro_mc
tales como tipo de usuario, fecha/Hora de acceso, estado de los dispositivos y modos
en los cuales están operando, la salida de parámetros de la base de datos se efectúa en
el momento que se gravan los datos de manera paralela a la tabla temporal la misma
131
que elimina sus registros en el momento que se concluye un ciclo completo del
proceso (llenado y vaciado).
Módulos como el de censo y activaciones de timers permiten mantener testeada la
base de datos para saber si los equipos remotos han enviado algún requerimiento así
mismo existe un proceso denominado alarma () el mismo que se mantiene en
permanente censo a las variables de temperatura de las bombas dicho dato es
proveído por el hardware.
El sistema no arrancara de manera general hasta que el hardware emita la señal de
que el sistema está preparada para el funcionamiento por el Bit 0 de la trama de 8 bit
enviados desde el puerto USB luego de lo cual estará listo el proceso para comenzar
con el llenado o vaciado del tanque de igual manera comienza el censo del proceso a
ejecutar por medio de la obtención de dicho parámetros mediantes los módulos de
Lectura del sistema que se encarga de capturar la trama de 8bits que nos envía
mediante el PIC 18F4550.
Las variables como las de bomba son una entrada al sistema ya que la confirmación
de las mismas por parte del hardware permite comenzar con el proceso de censo e
inserción al registro de la base de datos de acuerdo a los parámetros que se vaya
obteniendo del proceso de llenado o vaciado tales como cantidad del tanque,
activación de niveles, estados de las temperaturas, guardando el proceso lógico en un
archivo .INI el mismo que contiene datos de los procesos lógicos y de sistemas de
alertas que emita cada acción censada por el puerto USB con respecto al hardware
Dentro el procedimiento de censo de variaciones de temperatura tenemos la
activación del cliente remoto y revisión de parámetros así como el acceso en la tabla
dispositivo.
Dentro de unas de las alertas que pueden ser suscitadas en el módulo el sistema lo
tiene de la manera más eficaz y eficiente de resolución ya sea por el sistema
desarrollado en visual Basic, del módulo remoto o del celular, dentro de suscitarse
algún inconveniente el proceso de continuar permitirá proseguir con la carga del
tanque por medio del módulo reset obteniendo parámetros de la tabla tanque que es
132
SISTEMA
PROCESOS
MONITOREO CONTROL CHAT LOGS
la que almacena la incidencia niveles de tanque y la cantidad en la cual se suscito el
inconveniente.
El botón paro mantiene una programación capaz de cerrar y enviar a apagar el
sistema, provocando el reseteo de variables y la limpieza en la base de datos.
Dentro del proceso de captura de datos del hardware es un proceso que se está
corriendo de manera paralela al de cualquier evento que suscite el procedimiento
desarrollado lleva el nombre de Private Sub Lectura() encargado de mantener
informado sobre el estado de las entradas al sistema.
De igual manera el proceso de envió de datos al hardware se realiza de manera serial
en trama de 8 bits por medio de módulo de Sent_Receive (Form USB) el mismo que
se encarga de generar los pulsos necesarios para las activaciones de las bombas y del
PIC 16F877 encargado de la manipulación del celular para la recepción de mensajes
y control de proceso (Revisar Anexo E).
3.10 Software y Desarrollo del Móvil.
Figura 3.47: Diagrama del sistema Fuente: Autores
133
3.10.1 Sistema MCC
El sistema es dividido en tres grandes procesos cada uno de los cuales tendrán
módulos internos de gran importancia para la adecuación y funcionamiento del
sistema.
a.- Monitoreo
Este proceso se encarga de obtener los datos de la base y presentarlos en un reporte
gráfico en el dispositivo móvil, agilitando el proceso de monitoreo manual y teniendo
datos de los sucesos dentro de un Sistema Industrial (ej.: Sistema de Tanque
Elevado) en tiempo real.
b.- Control
Este proceso se encarga de enviar ordenes de encendido o apagado dentro del
Sistema, mediante la actualización de datos correspondiente.
c.- Chat
Este proceso mantiene comunicados en tiempo real a los usuarios para tener mayor
control dentro del Sistema y así si llegara a fallar el proceso automático siempre
tener la apertura al accionar manual y directo.
3.10.2 Arquitectura del Sistema Controlado por Dispositivos Móviles
Figura 3.48: Arquitectura del sistema Fuente: Autores
Ejecuta
función
Conection
Pool
WebServices
Base de Datos
SERVIDOR WEB
GLASS FISH, JAVA EE
Requerimiento
HTTP Retorna los
Datos
Archivo WSDL
Archivo WSDL
134
Explicación
1. El dispositivo móvil realiza un requerimiento http hacia el Servidor Web
donde está alojado el Servicio Web.
2. Este mediante un Pool de Conexiones se comunica con la base de datos
3. El Webservice ejecuta la función requerida y realiza la petición a la base
4. La base le retorna los datos al Webservice
5. El Webservice formatea los datos recibidos de la base en un archivo wsdl
6. Envía el archivo wsdl hacia el dispositivo móvil que le realizó el
requerimiento
3.10.3 Aplicación Web, Conexión a la Base de Datos
Problema
Muchas veces desarrollamos aplicaciones que se conectan a una o varias bases de
datos (MySQL, Oracle, PostgreSQL, etc.) y el gran problema siempre es la cantidad
de conexiones que deben soportar dichas bases de datos. ¿Qué pasa si hay 4000
conexiones a la vez? ¿Qué pasa si esta cifra aumenta? bueno, ya pueden imaginar
que cosas podrían suceder, partiendo por que el servidor de base de datos se caiga.
Solución
Uso de un DataSource mediante el cual el cliente se conectará a la base de datos.
Este datasource utiliza lo que se conoce como Connection Pool que no es más que
una cantidad de conexiones disponibles para el uso y lo maneja un servidor de
aplicaciones (como glassfish).
Mediante un connection pool las conexiones a la base de datos pueden bajar de 4000
a solo 100 (esas son cifras reales), ya que no siempre se necesitan conexiones
activas. Esto no quiere decir que un cliente se quedará sin el recurso, sino más bien
que el servidor de aplicaciones permitirá un mejor uso de dicho recurso a través de la
gestión que hace al administrar el pool de conexiones.
Pasos:
1. Establecer una conexión con la base de datos.
135
2. Crear una aplicación web.
3. Crear un connection pool.
4. Crear un datasource.
5. Registrar el connection pool y el datasource en el servidor de aplicaciones.
6. Llamar un datasource desde una clase en nuestra aplicación web.
Lo primero es lo primero, necesitamos algunas cosas antes de partir. Necesitamos
instalado:
7. Netbeans 6.0
8. JDK 1.6.0_02
9. Sun Java System Application Server 9
10. MySQL 5.0.45
Una vez todo instalado debemos tener corriendo la base de datos.
Figura 3.49: Cargando la base de datos a nuestro sistema
Fuente: Autores
136
Ahora crearemos una conexión a la base de datos usando netbeans, pinchen la
pestaña "runtime", luego "Databases", clic derecho a "Drivers" y pinchan "New d
Figura 3.50: Creando el driver JDBC
Fuente: Autores
Aquí se pasa el driver JDBC como pueden ver en la imagen, luego clic en Ok. Ahora vamos a crear una conexión utilizando el driver que le acabamos de pasar. Haz clic derecho sobre "Databases" y pincha "New connection".
Figura 3.51: Creando una nueva conexión
Fuente: Autores
137
En la ventana que aparece ingresa los datos que corresponden como pueden ver en la
imagen. Luego pincha Ok.
Figura 3.52: Finalizando la Conexión
Fuente: Autores Ahora ya tenemos una conexión a la base de datos desde netbeans, la cual podremos
usar cuando queramos en nuestras aplicaciones. Ahora levantaremos nuestro servidor
de aplicaciones, para esto pincha sobre "Servers", haz clic derecho sobre "Sun Java
System Application Server 9" y pincha "Start", esto levantará el servicio que
utilizaremos más adelante.
Figura 3.53: Levantando el Servicio
Fuente: Autores
138
Ahora crearemos un "Web Application”...
Figura 3.54: Creando un nuevo proyecto
Fuente: Autores
Figura 3.55: Colocando parámetros al proyecto
Fuente: Autores
139
Una vez creado el proyecto crearemos el connection pool, para esto haz clic derecho
sobre el proyecto, mueve el cursor a "New" y pincha "File/Folder".
Figura 3.56: Creando un Web Application
Fuente: Autores Ahora debes colocar un nombre a tu connection pool y seleccionar la conexión a la base de datos que previamente estableciste en netbeans.
Figura 3.57: Colocando el Netbeans Fuente: Autores
140
Luego pinchas siguiente y verás los datos de la conexión a la base de datos, luego
pinchas "finish".
Figura 3.58: Creado el Web Application para la base de datos
Fuente: Autores
Ahora vamos a crear el datasource, para esto vas donde mismo para crear el
connection pool pero esta vez seleccionas "JDBC Resource".
Figura 3.59: Creando el pool de conexiones
Fuente: Autores
141
Ahora necesitamos crear una referencia al datasource en nuestro proyecto, para esto
haz doble clic en "web.xml" (está en Mi Proyecto -> Web Pages -> WEB-INF), luego
pinchas "References" -> "Add" y agregas el nombre que le pusiste al datasource.
Figura 3.60: Creando el referencia de conexión
Fuente: Autores
Figura 3.61: Agregada la referencia de conexión
Fuente: Autores
142
Ahora haz doble clic sobre "sun-web.xml", expande "Sun Web Aplication" y pincha
el datasource que aparece ahí (es el que tu creaste). Fíjate que donde dice "JNDI
Name" no hay nada, debes copiar y pegar lo que sale justo arribita (el nombre de tu
datasource) y guardas.
Figura 3.62: A tachando la referencia de conexión a tu aplicación
Fuente: Autores.
Ahora debes registrar en el servidor de aplicaciones el connection pool y el
datasource que ha creado previamente, simplemente expande "Server resources" en
tu proyecto y haz clic derecho sobre el connection pool y pincha "Register", lo
mismo después con el datasource.
Figura 3.63: Registrando servidor de aplicación
Fuente: Autores
143
Ya tenemos listo el connection pool y el datasource en nuestra aplicación y en el
servidor de aplicaciones. Ahora solo resta utilizarlos en nuestra aplicación. Para esto
haz una clase java en tu proyecto colocando el nombre que tú quieras.
Figura 3.64: Haciendo la clase en java con las aplicación
Fuente: Autores
Una vez creada haz clic derecho en el editor de netbeans, sobre tu clase y mueve el
cursor a "Enterprise resources" y pincha "Use database".
Figura 3.65: Haciendo la clase en java con las aplicación
Fuente: Autores
144
3.10.4 Creación de WebService
Crear un Web service cliente para consumir dichos servicios.
Sin más preámbulo crearemos un web service, para esto haremos clic derecho sobre
el proyecto -> new -> web service [...]
Figura 3.66: Creando un web service
Fuente: Autores
Luego veremos lo siguiente...
Figura 3.67: Agregando una operación
Fuente: Autores
Pinchamos Add operation para crear un servicio, en Name colocamos el nombre del
servicio que corresponde a un web method, que en éste caso retornará un dato de tipo
145
String y recibirá un parámetro que corresponde al root del usuario y es de tipo String
[...]
Figura 3.68: Nombre y tipo de operación
Fuente: Autores
Luego creamos un tercer servicio y lo nombraremos obtenerUsuario el cual retornará
un objeto de tipo UsuarioBean y recibe como parámetro el root del usuario de tipo
String...
Figura 3.69: Creando un nuevo servicio
Fuente: Autores
146
Ya tenemos declarados los web services, pero aún no están implementados. Si se
fijan en la pantalla donde agregaron las operaciones o servicios hay dos opciones,
una es Design y la otra es Source, si pinchan Source verán el editor de la clase con
los métodos creados anteriormente pero sin implementación, es ahí donde ustedes
pueden llamar a la clase ConexionBDDataSource que habíamos creado
anteriormente y agregar la lógica que corresponda para manejar los datos ingresados
por el usuario y consultar a la base de datos y responderle al usuario. Lo que yo
recomiendo es crear una capa de lógica intermedia que se encargue de hacer las
validaciones correspondientes (que el usuario exista, que tenga deuda, que no pague
cero pesos, etc.) y de esa forma el diseño queda en multicapas y es más fácil después
para cambiar alguna cosa y que su sistema sea adaptable a dicho cambio (flexible,
escalable, etc.).
3.10.5 Consumir WebServices.
Le damos Clic derecho sobre el proyecto -> New -> Java ME Web Services Client
Figura 3.70: Creando un consumidor del web service Fuente: Autores
147
Luego nos aparecerá una pantalla como está
Figura 3.71: Creando un Cliente Fuente: Autores
Después de haber hecho esto le damos clic en finish
Figura 3.72: Parámetros del Cliente Fuente: Autores
148
Por último nos aparecerá una ventana en la que notaremos que tenemos el ws client
agregado y el netbeans habrá agregado un nuevo paquete con todo lo referente al
nuevo Web Service.
Figura 3.73: Finalización la creación de Consumidor de WEB Fuente: Autores
149
4.- Bibliografía.
4.1 Direcciones Electrónicas.
Hardware.
www.rentron.com
www.microchip.com
www.neoteo.com
http://www.melabs.com/products/pbp.htm
http://www.winpic800.com
http://www.ccsinfo.com/content.php?page=ideoverview
http://www.garcia-cuervo.com/picmania.garcia-cuervo.net/PICC.php
Software.
http://www.ni.com/mstudio/
http://www.connectionstrings.com/default.aspx?carrier=mysql
http://dev.mysql.com/downloads/connector/odbc/3.51.html
http://www.mysql.com/products/connector/odbc/
http://www.mysql.com/about/contact/
http://www.trucoswindows.net/foro/topico-5900-manejo-de-puerto-usb.html
http://www.intel.com/intelpress/usb/examples/vboverview.htm
http://www.todoexpertos.com/categorias/tecnologia-e-
Internet/internet/respuestas/1707372/manejo-del-puerto-usb-desde-visual-basic
http://es.wikipedia.org/wiki
Arquitectura del móvil.
www.lexer.netbeans.org
http://www.radioptica.com/Radio/wlan.asp
http://metalklesk.blogspot.com/
http://www.netbeans.org/kb/index.html
http://metalklesk.blogspot.com/2007/09/connection-pool-y-datasource-en.html
http://metalklesk.blogspot.com/2007/12/instalacin-de-glassfish-v2-en-opensuse.html
http://metalklesk.blogspot.com/2007/10/web-service-y-web-service-client-en.html
150
4.2 Libros
SILER, Brian, y otros, Visual Basic 6.0, Edición Especial, Editorial Prentice Hall,
Madrid – España, 1999.
Reyes, Carlos, Aprenda a programar Microcontroladores en Basic, 1era. Edición,
Editorial Gráficas Ayerve, Ecuador, 2004.
Ramos, Guillermo, y otros, Electrónica Industrial y automatización, 1era Edición,
Editorial Cekit, Pereira-Colombia, 2002, Tomo 1.
Castaño, Juan, Curso práctico sobre microcontroladores, 1era Edición, Editorial
Cekit, Pereira-Colombia, 2002, Tomo 1.
151
ANEXO A
Interfaces gráficas de usuario
A.1 Descripción del capítulo
Dentro de este anexo procederemos a la explicación de las opciones y características
del sistema para que el usuario tenga el conocimiento para el control del mismo.
Así mismo se explicara de manera detallada las opciones de error y de sucesos que se
puede tener y la opciones necesarias para poderlo resolver en caso de presentarse
durante la ejecución del control.
Se adjunta graficas del sistema en las mismas que será debidamente explicada para
mejor comprensión por parte del operador.
A.2 Introducción a las interfaces de usuario
El sistema es en su totalidad visual es por aquello que se lo desarrollo en un lenguaje
que permita realizar el proceso de manera interactiva con el operador este es una
razón más para que el sistema encargado en manipular el hardware de manera directa
sea programado en Visual Basic.
Dentro de la cada una de las acciones se tiene su debido mensaje para que de esta
manera el operador decida qué acción realizar así mismo como el control de cada
uno de los eventos que suceda mientras la operación de las maquinarias lo que le
permitirá tener al operador un conocimiento general de lo que está sucediendo en las
maquinarias y en el proceso en sí.
152
Cada una de las acciones realizadas por el usuario son registradas dentro de una base
de datos lo que permite saber cada acción que el operador realice sobre la interface y
sobre el proceso en sí de esta manera podemos permitirnos saber quien, cuando y
desde donde realizo alguna alteración en la manipulación del proceso, así mismo se
cuenta con las debidas seguridades al momento de ingresar al sistema con un lapso
máximo de 3 intentos de acceso luego de aquello el sistema procederá a cerrar de de
manera automática.
A.3 Descripción de Interfaces Por módulos
Se desarrollara la explicación del sistema por cada uno de los módulos desarrollados
en visual Basic esto quiere decir que dentro del formulario principal no se reflejara
algunas instrucciones propias del formulario como las opciones de salir en el MDI
Principal.
A.3.1 Login Acceso De clave
Interface de acceso la misma te permite un máximo de 3 intentos para acceder al
sistema sino procederá a cerrarse el mismo, desplegando los mensajes necesarios en
caso de presentarse este particular.
Figura A1.1: Pantalla de acceso
Fuente: Autores A su vez esta lleva un registro del ingreso de cada usuario al sistema para registrar el
ingreso y salida del usuario.
153
Figura A1.2: Pantalla de error de usuario Fuente: Autores
La misma contiene 2 botones el de acceso y salida y las validaciones necesarias para
que complete los datos antes de poder dar clic a la opción de ingreso como se denoto
en la imagen
Figura A1.3: Pantalla de ingreso de usuario/clave
Fuente: Autores Permitiendo el acceso al sistema
Figura A1.4: Pantalla de acceso al sistema
Fuente: Autores
A.3.2 Sistema de Monitoreo
La interface lo primero que censa será la conexión de hardware al sistema en caso de
no darse dicha situación emitirá un problema de “No hay periférico conectado”
154
Figura A1.5: Error si no hay dispositivo (PIC) conectado en el USB
Fuente: Autores Dentro del sistema de monitoreo la secuencia de funcionamiento será la siguiente
Botón que indicara el encendido general, el segundo botón indicara el “Continuar
Proceso” en caso de haber sucedido una incidencia un Botón de paro que permitía
detener el sistema y activar la opción de celular en proceso remoto y la opción de
terminar el proceso de manera definitiva y salir del formulario.
Figura A1.6: Monitoreo Básico del proceso
Fuente: Autores
155
Nota cabe enfatizar que una vez cerrado el sistema las variables regresaran a NULL
de esta manera será un proceso independiente al anterior es decir no arrancara de
niveles 0 y no del estado anterior, el desarrollo fue procesado de esta manera con la
intención de que los procesos ni el monitoreo trabajen de manera indistinta.
Figura A1.7: Pantalla de monitoreo
Fuente: Autores Dentro del sistema se maneja los Sucesos que ocurren en el sistema el mismo que
nos permite estar alerta del suceso de cada uno de los proceso en los cuales no indica
que acción realizar o que parámetro se necesita para continuar el proceso estos
mensajes son desplegados a partir de los datos que se está obteniendo del hardware
Sucesos de alertas registrados por el sistema antes de poder continuar el proceso de
llenado o vaciado según lo indique su último estado
156
Figura A1.8: Pantalla de problema en las bombas
Fuente: Autores Así mismo el sistema informa de las alertas posibles que pueden suscitarse durante el
proceso y que acción ha decidido tomar el sistema.
Figura A1.9: Continua proceso
Fuente: Autores
A.3.3 Consulta por Dispositivo
Dentro de esta interface se realizara la debida consulta por dispositivo emitiéndose
un reporte de acuerdo a lo deseado por el usuario
157
En esta pantalla debe de estar todos los datos llenados para poder emitir el debido
reporte caso contrario saldrá error. Esta consulta se realiza por medio de rangos de
fechas.
A.3.4 Consulta Monitoreo por usuario
La consulta por usuario puedes realizarla escogiendo todos los usuarios registrados o
en su defecto por user específico el mismo que se desplegaran en el combo de igual
manera su impresión podrá ser por user o por grupo
Figura A1.10: Consulta por usuario
Fuente: Autores
A.3.5 Consulta Monitoreo de Encendido y Apagado
Dentro de la misma podrás realizar la consulta debida con respecto a el dispositivo el
estado que se mantuvo dependiendo del rango de fecha que Ud. deseé escoger o por
una fecha especifica que Ud. decida colocar, se le desplegaran calendarios para un
definición de fecha más acertad y que no surja inconvenientes por parte del usuario
158
Figura A1.11: Consulta por dispositivo encendido y apagado
Fuente: Autores
A.3.6 Mantenimiento de Usuario
Dentro del mantenimiento de usuario puedes realizar la inserción de nuevos usuarios
disponiendo el tipo de usuario que será así mismo podes ingresar su password y sus
datos personales.
Figura A1.12: Mantenimiento de usuario
Fuente: Autores
A.3.7 Mantenimiento de Dispositivos
159
Dentro de los mantenimiento de dispositivo podes ingresar nuevos dispositivos
lamentablemente no podes utilizar este módulo de manera completa ya que para
realizar su monitoreo debe de existir el debido ingreso de hardware lo mismo que
sería otro requerimiento indistinto al propuesto como tema de tesis.
Figura A1.13: Mantenimiento de dispositivo
Fuente: Autores
A.3.8 Eventos de Suceso
Dentro de esta interface tu puedes ver todos los sucesos del sistema acontecidos des
de el día en que proceso de monitoreo fue puesto en marcha la herramienta toolbar
permite tener un mayor control sobre los datos ya insertados, este no permite la
modificación de los mismos pues son datos de registros del sistema no pueden ser
alterados solo visualizados. Podéis imprimirlos abrir otros archivos registrados por ti
y guardados mas no los guardados por el sistema
Figura A1.14: Evento de Suceso Normal
Fuente: Autores
160
A.3.9 Eventos de Alertas
Esta interface maneja la misma temática de procesos puedes abrir archivos, guardar e
imprimir mas no puedes alterar el archivo de origen ya que estos de uso exclusivos
del sistema.
Figura A1.15: Evento de Alertas
Fuente: Autores
A.3.10 Ventana Cascada
Este permite el mantener 2 interfaces en modo de cascada para su apreciación como
a continuación se ilustra en la siguiente grafica
Figura A1.16: Ventana en cascada
Fuente: Autores
161
A.3.11 Ventana Mosaico
Permite la visualización en estilo de mosaico de los eventos que desees mantener
sobre la ventana operativa del MDI Principal.
Figura A1.17: Ventanas en mosaico
Fuente: Autores
A.3.12 Ventana Vertical
Permite observa de manera vertical las interfaces activas sobre el MDI Principal para
tener una mejor apreciación sobre los procesos que están ocurriendo en el sistema
Figura A1.18: Ventana en Vertical
Fuente: Autores
162
A.3.13 Ayuda del Sistema
Demuestra archivo de ayuda sobre el sistema el mismo que será generado por un grafico o por un documento.
Figura A1.19: Archivo de Ayuda
Fuente: Autores
A.3.14 Acerca de Carolina
Interface de información del sistema
Figura A1.20: Información del sistema
Fuente: Autores Demuestra la información acerca del sistema como una reseña sobre la creación del
mismo, también tiene un botón sobre la información del sistema sobre la cual podrá
observar los dispositivos de su PC
163
ANEXO B
Interfaces gráficas de usuario
B.1 Descripción del capítulo
Dentro de este anexo procederemos a la explicación de las opciones y características
del sistema para que el usuario tenga el conocimiento para el control del mismo.
Así mismo se explicara de manera detallada las opciones de error y de sucesos que se
puede tener y la opciones necesarias para poderlo resolver en caso de presentarse
durante la ejecución del control.
Se adjunta graficas del sistema en las mismas que será debidamente explicada para
mejor comprensión por parte del operador.
B.2 Introducción a las interfaces de usuario
164
El sistema es en su totalidad visual es por aquello que se lo desarrollo en un lenguaje
que permita realizar el proceso de manera interactiva con el operador este es una
razón más para que el sistema encargado en manipular el hardware de manera directa
sea programado en Visual Basic.
Dentro de la cada una de las acciones se tiene su debido mensaje para que de esta
manera el operador decida qué acción realizar así mismo como el control de cada
uno de los eventos que suceda mientras la operación de las maquinarias lo que le
permitirá tener al operador un conocimiento general de lo que está sucediendo en las
maquinarias y en el proceso en sí.
Cada una de las acciones realizadas por el usuario son registradas dentro de una base
de datos lo que permite saber cada acción que el operador realice sobre la interface y
sobre el proceso en sí de esta manera podemos permitirnos saber quien, cuando y
desde donde realizo alguna alteración en la manipulación del proceso, así mismo se
cuenta con las debidas seguridades al momento de ingresar al sistema con un lapso
máximo de 3 intentos de acceso luego de aquello el sistema procederá a cerrar de de
manera automática.
B.2.1 Inicio de Sesión de usuario.
La primera pantalla que aparece en el sistema es para el ingresar al sistema, donde el
usuario debe ingresar su nombre y contraseña
165
Figura B1.1: Inicio de sesión de usuario Fuente: Autores
Realiza el requerimiento hacia el Web Service de Autenticación de usuario, por lo
que aparece una pantalla de advertencia de consumo de tiempo aire al realizar una
petición web.
Figura B1.2: Mensaje de advertencia Fuente: Autores
166
Pantalla de Bienvenida en la cual el usuario ve sus datos y las opciones para
comenzar a usar el Sistema entre ellas tenemos a el Monitoreo de Dispositivos,
Control y el Chat Cliente
Figura B1.3: Pantalla de Bienvenida Fuente: Autores
Está pantalla indica los estados de Encendido/Apagado de las Bombas y el nivel del
Tanque.
B.2.2 Monitoreo
Figura B1.4: Monitoreo del sistema Fuente: Autores
167
En el Reporte Gráfico de Monitoreo se puede elegir para las opciones de
Figura B1.5: Opciones de software Fuente: Autores
B.2.3 Control
Al elegir la opción de Control podrá observar y decidir que opción tomar.
168
Figura B1.6: Opciones a Tomar Fuente: Autores
En Apagado General podrá tomar la decisión de mandar a realizar la acción de
apagado general el cual lo que realiza es una actualización de la tabla de
apagado_general.
Figura B1.7: Opción de Apagado General Fuente: Autores
En esta pantalla se podrá elegir que bomba se procederá a apagar, luego de esto
aparecerá un mensaje indicando el éxito de la acción.
B.2.4 Chat
Al elegir Chat se da por entendido que en existe un Server Chat a la espera de una
conexión cliente, en ambas partes aparecerá una pantalla de advertencia de consumo
de tiempo aire al realizar una petición web.
169
Figura B1.8: Opciones a Chat
Fuente: Autores
Luego Se procederá a Ingresar a la pantalla de chat en la cual los usuarios podrán
realizar una conversación vía mensajería instantánea,
Figura B1.9: Chateo entre usuarios
Fuente: Autores
ANEXO C
Codificación del sistema
C.1 Descripción del Módulo VBMPUSBAPI.bas
El módulo comprende de variables globales, así como de un modulo para la conexión
de la base de datos el cual permite la conexión a la base desde cualquier modulo.
170
Así mismo contiene módulos de interacción entre el hardware y el PIC el mismo que
permite enviar parámetros al PIC de control Ubicado en el hardware implementado
'============================================================ ' CONEXION A LA BASE DE DATOS '============================================================ Public con As Connection 'Public base1 As Connection '============================================================ ' VARIABLE USUARIO '============================================================ Public usuario As String '============================================================ ' RUTINAS DE LLAMADA A LA LIBRERIA MPUSBAPI.DLL PARA INTERACTUAR CON EL PIC '============================================================ Option Explicit '-------------------------------------------------------------------------------------- ‘Convenciones de llamada en C ' DWORD _MPUSBGetDLLVersion(void) ' DWORD _MPUSBGetDeviceCount(PCHAR pVID_PID) ' HANDLE _MPUSBOpen(DWORD instance, PCHAR pVID_PID, PCHAR pEP, DWORD dwDir, DWORD dwReserved); ' DWORD _MPUSBRead(HANDLE handle, PVOID pData, DWORD dwLen, PDWORD pLength, DWORD dwMilliseconds); ' DWORD _MPUSBWrite(HANDLE handle, PVOID pData, DWORD dwLen, PDWORD pLength, DWORD dwMilliseconds); ' DWORD _MPUSBReadInt(HANDLE handle, PVOID pData, DWORD dwLen, PDWORD pLength, DWORD dwMilliseconds); '-------------------------------------------------------------------------------------- ‘FUNCIONES EQUIVALENTES PARA REALIZAR LA LLAMADA DESDE VB 6.0 '-------------------------------------------------------------------------------------- Public Declare Function MPUSBGetDLLVersion Lib "mpusbapi.dll" () As Long Public Declare Function MPUSBGetDeviceCount Lib "mpusbapi.dll" (ByVal pVID_PID As String) As Long Public Declare Function MPUSBOpen Lib "mpusbapi.dll" (ByVal instance As Long, ByVal pVID_PID As String, ByVal pEP As String, ByVal dwDir As Long, ByVal dwReserved As Long) As Long Public Declare Function MPUSBClose Lib "mpusbapi.dll" (ByVal handle As Long) As Long
171
Public Declare Function MPUSBRead Lib "mpusbapi.dll" (ByVal handle As Long, ByVal pData As Long, ByVal dwLen As Long, ByRef pLength As Long, ByVal dwMilliseconds As Long) As Long Public Declare Function MPUSBWrite Lib "mpusbapi.dll" (ByVal handle As Long, ByVal pData As Long, ByVal dwLen As Long, ByRef pLength As Long, ByVal dwMilliseconds As Long) As Long Public Declare Function MPUSBReadInt Lib "mpusbapi.dll" (ByVal handle As Long, ByVal pData As Long, ByVal dwLen As Long, ByRef pLength As Long, ByVal dwMilliseconds As Long) As Long '-------------------------------------------------------------------------------------- ‘CONSTANTES PARA LA WIN32 API '-------------------------------------------------------------------------------------- Public Const INVALID_HANDLE_VALUE = -1 Public Const ERROR_INVALID_HANDLE = 6& '-------------------------------------------------------------------------------------- ‘FUNCION DE LA WIN32 API '-------------------------------------------------------------------------------------- Public Declare Function GetLastError Lib "kernel32" () As Long Public Declare Function timeGetTime Lib "winmm.dll" () As Long '-------------------------------------------------------------------------------------- ‘Constantes de conectividad con el PIC '-------------------------------------------------------------------------------------- Public Const vid_pid = "vid_04d8&pid_0011" ' Vendor id (Microchip) y Periférico id Public Const out_pipe = "\MCHP_EP1" Public Const in_pipe = "\MCHP_EP1" Public Const MPUSB_FAIL = 0 Public Const MPUSB_SUCCESS = 1 Public Const MP_WRITE = 0 Public Const MP_READ = 1 '-------------------------------------------------------------------------------------- ' IN_PIPE y OUT_PIPE VARIABLES PUBLICAS '-------------------------------------------------------------------------------------- Public myInPipe As Long Public myOutPipe As Long '-------------------------------------------------------------------------------------- ‘MÓDULO PARA ABRIR EL PERIFERICO '-------------------------------------------------------------------------------------- Sub OpenMPUSBDevice() Dim tempPipe As Long Dim count As Long tempPipe = INVALID_HANDLE_VALUE
172
count = MPUSBGetDeviceCount(vid_pid) If count > 0 Then myInPipe = MPUSBOpen(0, vid_pid, in_pipe, MP_READ, 0) If myOutPipe = INVALID_HANDLE_VALUE Or myInPipe = INVALID_HANDLE_VALUE Then MsgBox Str(myOutPipe) + " " + Str(myInPipe) + " Error al abrir los pipes" myOutPipe = INVALID_HANDLE_VALUE End If Else frmUSB.Command1.Enabled = False MsgBox "No hay periféricos conectados" End If End Sub '-------------------------------------------------------------------------------------- ‘CERRANDO EL PERIFÉRICO '-------------------------------------------------------------------------------------- Sub CloseMPUSBDevice() If myOutPipe <> INVALID_HANDLE_VALUE Then MPUSBClose (myOutPipe) myOutPipe = INVALID_HANDLE_VALUE End If If myInPipe <> INVALID_HANDLE_VALUE Then MPUSBClose (myInPipe) myInPipe = INVALID_HANDLE_VALUE End If End Sub '-------------------------------------------------------------------------------------- ‘CERRANDO EL PERIFERICO DESDE EL FORMULARIO '-------------------------------------------------------------------------------------- Sub cerradito() MPUSBClose (myOutPipe) MPUSBClose (myInPipe) End Sub '-------------------------------------------------------------------------------------- ‘Función Send_Receive DATOS DESDE EL PIC '___________________________________________________________ ' SendData: Matriz de bytes con los datos a mandar ' SendLength: Longitud de datos a mandar ' ReceiveData: Matriz de datos a recibir ' ReceiveLength: Número de bytes a recibir ' SendDelay: Time-out para el envío en milisegundos
173
' ReceiveDelay: Time-out para la recepción en milisegundos '-------------------------------------------------------------------------------------- Function Send_Receive(ByRef SendData() As Byte, SendLength As Long, _ ByRef ReceiveData() As Byte, ByRef ReceiveLength As Long, _ ByVal SendDelay As Long, ByVal ReceiveDelay As Long) As Long Dim SentDataLength As Long Dim ExpectedReceiveLength As Long ExpectedReceiveLength = ReceiveLength If (myOutPipe <> INVALID_HANDLE_VALUE And myInPipe <> INVALID_HANDLE_VALUE) Then If (MPUSBWrite(myOutPipe, VarPtr(SendData(0)), SendLength, SentDataLength, SendDelay) = MPUSB_SUCCESS) Then If (MPUSBRead(myInPipe, VarPtr(ReceiveData(0)), ExpectedReceiveLength, ReceiveLength, ReceiveDelay) = MPUSB_SUCCESS) Then If (ReceiveLength = ExpectedReceiveLength) Then Send_Receive = 1 ' Todo correcto Exit Function Else If (ReceiveLength < ExpectedReceiveLength) Then Send_Receive = 2 ' Envío correcto pero Exit Function ' Recepción fallida End If Else CheckInvalidHandle ' Mensaje de error End If Else CheckInvalidHandle ' Mensaje de error End If End If Send_Receive = 0 ' Operación fallida End Function '-------------------------------------------------------------------------------------- ‘PRESENTA EL TIPO DE ERROR POSIBLE '-------------------------------------------------------------------------------------- Sub CheckInvalidHandle() If (GetLastError() = ERROR_INVALID_HANDLE) Then ‘La causa más habitual es que el circuito esté desconectado CloseMPUSBDevice Else
174
MsgBox "Código de error: " + Str(GetLastError()) End If End Sub '-------------------------------------------------------------------------------------- ‘FUNCION SEND '_________________________________________________________ ' SendData: Matriz de bytes con los datos a mandar ' SendLength: Longitud de datos a mandar ' SendDelay: Time-out para el envío en milisegundos '-------------------------------------------------------------------------------------- Function Send(ByRef SendData() As Byte, SendLength As Long, ByVal SendDelay As Long) As Long Dim SentDataLength As Long If (myOutPipe <> INVALID_HANDLE_VALUE And myInPipe <> INVALID_HANDLE_VALUE) Then If (MPUSBWrite(myOutPipe, VarPtr(SendData(0)), SendLength, SentDataLength, SendDelay) = MPUSB_SUCCESS) Then Send = 1 ' Todo correcto Exit Function Else CheckInvalidHandle ' Mensaje de error End If End If Send = 0 ' Operación fallida End Function '-------------------------------------------------------------------------------------- 'MÓDULO DE CONEXIÓN A LA BASE DE DATOS MYSQL '-------------------------------------------------------------------------------------- Sub conexion() Set con = New ADODB.Connection con.ConnectionString = "DRIVER={MySQL ODBC 5.1 Driver}; SERVER=localhost; DATABASE=tesis; PWD=root; UID=root;OPTION=3" con.Open End Sub '-------------------------------------------------------------------------------------- 'VARIABLE PARA EMITIR REPORTES CAPTURA EL TAMAÑO DE UN ACADENA DE CARACTERES '-------------------------------------------------------------------------------------- Sub SelText(i As Control) i.SelStart = 0 i.SelLength = Len(i.Text) End Sub '--------------------------------------------------------------------------------------
175
'MÓDULO DE RETARDO DE TIEMPO '-------------------------------------------------------------------------------------- Sub time_late() Dim i, x, y As Integer DoEvents For i = 0 To 400 For x = 0 To 800 For y = 0 To 300 Next Next Next End Sub
C.2 Descripción de funcionamiento por formularios
Dentro del esquema de los formularios se presenta a continuación el siguiente diagrama que contiene un bosquejo del sistema completo
176
Figura C1.1: Esquemático de los Formularios Fuente: Autores
FORM2 (LOGIN) El formulario comprende una variable tipo entero la misma q se encarga de llevar el
conteo para q el numero de intentos de acceso al sistema no sea mayor a 3.
FORM 2(LOGIN)
SISTEMA
FrmUSB
SALIR
CONSULTAS
FORM1 (DISPOSITIVOS)FORM6 (USUARIO)
FORM7 (ENCENDIDO Y APAGADO)
MANTENIMIENTO
FORMA3 (USUARIO)
FORM 4(DISPOSITIVO)
EVENTOS
FRMPRESENTA1 (SUCESOS)
FORM5 (ALERTAS)
VENTANA
FUNCION DE VB
FUNCION DE VB
FUNCION DE VB
AYUDA
ARCHIVO DE AYUDA
FRMABOUT
MDI (FRMAIN)
177
Dim contador As Integer Dim tieso As Boolean '------------------------------------------------------------------------------------------------------ ‘MÓDULO QUE REALIZA LA BUSQUEDA DEL USUARIO DENTRO DE LA BASE DE DATOS '------------------------------------------------------------------------------------------------------ Private Sub Command1_Click() contador = contador + 1 tieso = False Dim tabla As ADODB.Recordset sql = "SELECT * FROM usuario " Set tabla = New Recordset tabla.Open sql, con, adOpenDynamic, adLockReadOnly Do Until tabla.EOF If (tabla!usu_nombres = Text1.Text) And (tabla!usu_password = Text2.Text) And (tabla!usu_privilegios = "v") And (tabla!usu_estado = "A") Then ‘Confirma si el usuario existe y si tiene permisos para acceder desde el sistema de visual tieso = True usuario = tabla!usu_id End If tabla.MoveNext Loop If contador <= 3 Then If tieso Then registro_acceso frmMain.Show Unload Me Else Text1.Text = "" Text2.Text = "" Me.Text1.SetFocus MsgBox "Clave y Usuario No Valido", vbInformation End If End If tabla.Close Call pregunta(contador, tieso) End Sub Private Sub Command2_Click() Unload Me End Sub Private Sub Form_Load() contador = 0 Call conexion End Sub '------------------------------------------------------------------------------------------------------
178
‘PROCEDIMIENTO QUE CONSULTA SI YA REALIZO LOS 3 INTENTOS DE ACCESO '------------------------------------------------------------------------------------------------------ Private Sub pregunta(recive As Integer, bule As Boolean) If recive = 3 And bule = False Then MsgBox "Intentos Mayor a 3 el Sistema Procederá a Cerrarse ", vbCritical Unload Me End If End Sub Private Sub Text1_KeyPress(KeyAscii As Integer) If KeyAscii = 13 Then Me.Text2.SetFocus End If End Sub Private Sub Text2_KeyPress(KeyAscii As Integer) If KeyAscii = 13 Then Me.Command1.SetFocus End If End Sub '------------------------------------------------------------------------------------------------------ ‘PROCEDIMIENTO QUE CAPTURA EL ACCESO DEL USUARIO Y LO GRABA EN LA TABLA LOGS '------------------------------------------------------------------------------------------------------ Public Sub registro_acceso() Dim tabla As ADODB.Recordset Set tabla = New Recordset sql = "Select * from logs " tabla.Open sql, con, 3, 3 tabla.AddNew tabla!log_user_id = usuario tabla!log_num_accion = 4 tabla!log_estado = "N" tabla!log_fecha = CStr(Format(Date, "yy/mm/dd")) + " " + CStr(Time) tabla.Update tabla.Close End Sub
C.2.1MDI (FRMAIN)
179
Este formulario contiene básicamente las llamadas a los form child que se hace
referencia de acuerdo a la petición solicitada o aplicación que se desee activar
'------------------------------------------------------------------------------------------------------ ‘Declaración de variables del API PROPIO DE WIN·32 '------------------------------------------------------------------------------------------------------ Private Declare Function SendMessage Lib "user32" Alias "SendMessageA" (ByVal hwnd As Long, ByVal wMsg As Long, ByVal wParam As Long, ByVal lParam As Any) As Long Const EM_UNDO = &HC7 Private Declare Function OSWinHelp% Lib "user32" Alias "WinHelpA" (ByVal hwnd&, ByVal HelpFile$, ByVal wCommand%, dwData As Any) Private Declare Function ShellExecute Lib "shell32.dll" Alias _ "ShellExecuteA" (ByVal hwnd As Long, ByVal lpOperation As String, _ ByVal lpFile As String, ByVal lpParameters As String, _ ByVal lpDirectory As String, ByVal nShowCmd As Long) As Long Private Sub condis_Click() Form1.Show End Sub Private Sub conen_Click() Form7.Show End Sub Private Sub conuser_Click() Form6.Show End Sub Private Sub eveale_Click() Form5.Show End Sub Private Sub evesuc_Click() presenta1.Show End Sub Private Sub mandis_Click() Form4.Show End Sub Private Sub manuser_Click() Form3.Show End Sub '------------------------------------------------------------------------------------------------------ ‘Alineación de los formularios hijos '------------------------------------------------------------------------------------------------------ Private Sub sismoni_Click()
180
Dim f As New frmUSB f.Width = 15000 f.Height = 7665 f.Left = (Screen.Width - f.Width) / 2 f.Top = 500 f.Show End Sub '------------------------------------------------------------------------------------------------------ ‘Cierra el formulario '------------------------------------------------------------------------------------------------------ Private Sub sisSalir_Click() Unload Me End Sub Private Sub mnuHelpAbout_Click() ' MsgBox "Versión " & App.Major & "." & App.Minor & "." & App.Revision frmAbout.Show End Sub Private Sub mnuHelpContents_Click() Dim nRet As Integer 'si no hay archivo de ayuda para este proyecto, mostrar un mensaje al usuario 'puede establecer el archivo de Ayuda para la aplicación en el cuadro 'de diálogo Propiedades del proyecto If Len(App.HelpFile) = 0 Then MsgBox "No se puede mostrar el contenido de la Ayuda. No hay Ayuda asociada a este proyecto.", vbInformation, Me.Caption Else On Error Resume Next nRet = OSWinHelp(Me.hwnd, App.HelpFile, 3, 0) If Err Then MsgBox Err.Description End If End If End Sub Private Sub mnuWindowArrangeIcons_Click() Me.Arrange vbArrangeIcons End Sub Private Sub mnuWindowTileVertical_Click() Me.Arrange vbTileVertical End Sub Private Sub mnuWindowTileHorizontal_Click() Me.Arrange vbTileHorizontal End Sub Private Sub mnuWindowCascade_Click()
181
Me.Arrange vbCascade End Sub '------------------------------------------------------------------------------------------------------ ‘se encarga de centrar los formularios q se habrán sobre el '------------------------------------------------------------------------------------------------------ Private Sub MDIForm_Load() Me.Left = GetSetting(App.Title, "Settings", "MainLeft", 1000) Me.Top = GetSetting(App.Title, "Settings", "MainTop", 1000) Me.Width = GetSetting(App.Title, "Settings", "MainWidth", 6500) Me.Height = GetSetting(App.Title, "Settings", "MainHeight", 6500) End Sub Private Sub MDIForm_Unload(Cancel As Integer) If Me.WindowState <> vbMinimized Then SaveSetting App.Title, "Settings", "MainLeft", Me.Left SaveSetting App.Title, "Settings", "MainTop", Me.Top SaveSetting App.Title, "Settings", "MainWidth", Me.Width SaveSetting App.Title, "Settings", "MainHeight", Me.Height End If End Sub
C.2.2 SISTEMA
FRMUSB Formulario que interactúa con el módulo VBMPUSBAPI.bas para realizar el
control del hardware en el mismo se manejan variables de tipo Boolean, String y
Variant.
Public d7 As Boolean Public Bom1 As Boolean Public bom2 As Boolean Public temp1 As Boolean Public temp2 As Boolean Public flag As Boolean Public flag1 As Boolean Public vacio As Boolean Public info As Variant Public alertas As Variant Public alert As String Dim msjc001 As Boolean '------------------------------------------------------------------------------------------------------ ‘limpia variables booleans '------------------------------------------------------------------------------------------------------ Private Sub clear() temp1 = False
182
temp2 = False Bom1 = False bom2 = False End Sub '------------------------------------------------------------------------------------------------------ ‘Comparación de datos obtenidos con desde el hardware para realizar acciones en el software '------------------------------------------------------------------------------------------------------ Private Sub Arranque(pepito As Integer) Select Case pepito Case "7" temp1 = True Onremote (temp1) Case "6" temp2 = True Onremote (temp2) Case "5" Bomba1.Visible = False Case "3" bomba2.Visible = True Case "2" Bom1 = True Case "1" bom2 = True End Select End Sub '------------------------------------------------------------------------------------------------------ ‘Lectura del puerto USB para ver si alguna alarma se activo desde el hardware '------------------------------------------------------------------------------------------------------ Private Sub Lectura() Dim Send_Buf(0 To 64) As Byte Dim Rec_Buf(0 To 64) As Byte Dim i As Long d7 = True If (myOutPipe <> INVALID_HANDLE_VALUE) And (myInPipe <> INVALID_HANDLE_VALUE) And d7 Then Send_Buf(0) = 3 If (Send_Receive(Send_Buf, 1, Rec_Buf, 8, 1000, 1000) <> 1) Then MsgBox "Fallo en la lectura de entradas" Else If Rec_Buf(0) = 1 Then Timer1.Enabled = True Else d7 = False End If If Rec_Buf(5) = 0 And d7 Then Bomba1.Visible = True End If
183
For i = 0 To 7 If Rec_Buf(i) = 1 And d7 Then chkEntrada(i).Value = vbChecked Arranque (i) Else chkEntrada(i).Value = vbUnchecked End If Next i End If End If End Sub '------------------------------------------------------------------------------------------------------ ‘Activación de la bomba de carga para empezar el procedo de llenado del tanque '------------------------------------------------------------------------------------------------------ Private Sub Bomba1_Click() Timer5.Enabled = False llenado ("L") Timer5.Enabled = True End Sub Private Sub bomba2_Click() Timer5.Enabled = False vaciado ("L") Timer5.Enabled = True End Sub Private Sub Confirbom1() Dim msja001 As Boolean msja001 = True While flag Lectura If chkEntrada(2).Value = vbChecked Then flag = False Bomba1.Enabled = False Else aguante If msja001 Then alertas = "Esperando Confirmacion de Bomba1" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List2.AddItem alertas msja001 = False End If End If Wend End Sub Private Sub Confirbomba2() Dim msja002 As Boolean msja002 = True
184
While flag1 Lectura If chkEntrada(1).Value = vbChecked Then flag1 = False bomba2.Enabled = False Else aguante If msja002 Then alertas = "Esperando Confirmación de Bomba2" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List2.AddItem alertas msja002 = False End If End If Wend End Sub -------------------------------------------------------------------------------------- 'Detener el proceso por completo enviando a apagar la alimentación del sistema '-------------------------------------------------------------------------------------- Private Sub BtParar_Click() Timer4.Enabled = False sql = "update apagado_general set apg_estado = 'A' where apg_id = 1" con.Execute sql Info = "Sistema Apagado POR FAVOR REINICIE" + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info End Sub -------------------------------------------------------------------------------------- ' Procedimiento para Terminar proceso y cierre de formulario '-------------------------------------------------------------------------------------- Private Sub cmdTerminar_Click() ApagaLeds CloseMPUSBDevice cerradito Unload Me End Sub -------------------------------------------------------------------------------------- ‘Módulo de control de Leds '-------------------------------------------------------------------------------------- Private Sub Control_Leds(Comando As Byte, dato As Byte) Dim Send_Buf(0 To 64) As Byte If (myOutPipe <> INVALID_HANDLE_VALUE) And (myInPipe <> INVALID_HANDLE_VALUE) Then Send_Buf(0) = Comando Send_Buf(1) = dato If (Send(Send_Buf, 2, 1000) <> 1) Then MsgBox "Fallo en el LED"
185
End If End If End Sub -------------------------------------------------------------------------------------- ‘Arranque general del proceso '-------------------------------------------------------------------------------------- Private Sub Command1_Click() info = "Sistema Iniciado" + Chr(9) + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info Control_Leds 1, 8 Genesis Timer1.Enabled = True temp1 = True temp2 = True Command1.Visible = False End Sub -------------------------------------------------------------------------------------- ‘Carga principal del formulario '-------------------------------------------------------------------------------------- Private Sub Form_Load() myInPipe = INVALID_HANDLE_VALUE myOutPipe = INVALID_HANDLE_VALUE OpenMPUSBDevice ApagaLeds conexion limpio_bd Timer2.Enabled = True End Sub ‘-------------------------------------------------------------------------------------- 'Apagando todas las salidas '-------------------------------------------------------------------------------------- Private Sub ApagaLeds() Dim i As Byte For i = 1 To 8 Control_Leds 2, i Next i End Sub ‘-------------------------------------------------------------------------------------- ' Reinicio del sistema para continuar con proceso de llamado o de vaciado '------------------------------------------------------------------------------------- Private Sub Reinicio_Click() Dim msj002 As Boolean Dim msj003 As Boolean Dim msj004 As Boolean Dim msj005 As Boolean
186
Dim nivel As Variant Dim tabla As ADODB.Recordset Dim i As Integer limpio_bd Timer4.Enabled = False flag = True flag1 = True Set tabla = New Recordset sql = "Select * from tanque " tabla.Open sql, con, adOpenDynamic, adLockOptimistic tabla.MoveLast msj002 = True msj003 = True msj004 = True msj005 = True If temp1 Or temp2 Then MsgBox "Revise Bombas" Else j = tabla!ta_descripcion nivel = tabla!tan_tiempo direccion = tabla!arriba If direccion <> 0 Then Control_Leds 1, 7 aguante aguante aguante aguante aguante aguante Control_Leds 2, 7 While flag Confirbom1 Wend vacio = True Carga_Decarga (vacio) Nivel1.Value = nivel For i = j To 80 If BtParar.Enabled Then alertas = "Por Favor Confirme Bomba 1" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem alertas Reinicio.Visible = True Call llamalo(Nivel1.Value, i, vacio) alarma Call registro_fallo(Nivel1.Value, vacio) Timer4.Enabled = True Exit For Else If msj002 Then
187
info = "Completando LLenado Bom1" + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info msj002 = False End If aguante alarma Nivel1.Value = Nivel1.Value + 0.125 Call registro(Nivel1.Value, vacio, "L") If Nivel1.Value = 5 Then info = "Nivel Medio Activado" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info End If If Nivel1.Value >= 10 Then Bomba1.Visible = False info = "Nivel Alto Activado" + Chr(9) + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info info = "Llenado Exitoso " + Chr(9) + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info Event_Succes_Log Event_Alert_Log End If Reinicio.Visible = False End If Next i Limpia_Carga_Decarga Else Control_Leds 1, 6 aguante aguante aguante aguante aguante aguante Control_Leds 2, 6 While flag1 Confirbomba2 Wend vacio = False Carga_Decarga (vacio) info = "Completando Vaciado Bom2" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info Nivel1.Value = nivel For i = 1 To j If BtParar.Enabled Then alertas = "Por Favor Confirme Bomba2" + Chr(9) + Chr(9) + Chr(9) +
188
CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List2.AddItem alertas Reinicio.Visible = True Call llamalo(Nivel1.Value, j - i, vacio) alarma Call registro_fallo(Nivel1.Value, vacio) Timer4.Enabled = True Exit For Else If msj004 Then info = "Vaciando Tanque" + Chr(9) + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info msj004 = False End If aguante alarma Nivel1.Value = Nivel1.Value - 0.125 Call registro(Nivel1.Value, vacio, "L") If Nivel1.Value = 5 Then info = "Nivel Medio Desactivado" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info End If If Nivel1.Value = 0.25 And msj003 Then bomba2.Visible = False info = "Nivel bajo Desactivado" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info info = "Vaciado Exitoso" + Chr(9) + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info Event_Succes_Log Event_Alert_Log msj003 = False End If End If Next i Limpia_Carga_Decarga End If limpia_temporal End If tabla.Close End Sub ‘-------------------------------------------------------------------------------------- ‘Módulo para sensar las temperaturas mediante un procedimiento llamado alarma '-------------------------------------------------------------------------------------- Private Sub Timer1_Timer() clear
189
DoEvents alarma End Sub ‘-------------------------------------------------------------------------------------- ' Módulo de las alarmas '-------------------------------------------------------------------------------------- Public Sub alarma() Dim alarm As Boolean Lectura aguante If temp1 Or temp2 Then Control_Leds 1, 5 alarm = True BtParar.Enabled = True Else Control_Leds 2, 5 BtParar.Enabled = False End If End Sub ‘-------------------------------------------------------------------------------------- ' Tiempo utilizado para la lectura de variables externas '-------------------------------------------------------------------------------------- Public Sub aguante() DoEvents Dim i As Integer Dim j As Integer For i = 1 To 1000 For j = 1 To 3500 Next j Next i End Sub ‘-------------------------------------------------------------------------------------- 'Procedimiento para el llenado de una tabla llamada tanque en el cual se almacena el ‘ nivel cada vez que ocurre un problema '-------------------------------------------------------------------------------------- Public Sub llamalo(tiempo As Variant, lazo As Integer, onde As Boolean) For i = 3 To 5 If chkEntrada(i).Value = vbChecked Then valor = valor + i Text1.Text = valor End If Next i Dim tabla As ADODB.Recordset Set tabla = New Recordset sql = "Select * from tanque " tabla.Open sql, con, adOpenDynamic, adLockOptimistic tabla.AddNew
190
If Text1.Text = "5" Then tabla!tan_dis_id = 1 tabla!ta_descripcion = lazo tabla!tan_nivel1 = "1" tabla!tan_nivel2 = "0" tabla!tan_nivel3 = "0" tabla!tan_tiempo = tiempo tabla!arriba = onde End If If Text1.Text = "9" Then tabla!tan_dis_id = 1 tabla!ta_descripcion = lazo tabla!tan_nivel1 = "1" tabla!tan_nivel2 = "1" tabla!tan_nivel3 = "0" tabla!tan_tiempo = tiempo tabla!arriba = onde End If If Text1.Text = "12" Then tabla!tan_dis_id = 1 tabla!ta_descripcion = lazo tabla!tan_nivel1 = "1" tabla!tan_nivel2 = "1" tabla!tan_nivel3 = "1" tabla!tan_tiempo = tiempo tabla!arriba = onde End If tabla.Update tabla.Close End Sub ‘-------------------------------------------------------------------------------------- ' Seteo de variables en la base de datos '-------------------------------------------------------------------------------------- Public Sub Genesis() Dim tabla As ADODB.Recordset Set tabla = New Recordset sql1 = "SELECT * FROM apagado_general" tabla.Open sql1, con, 3, adLockOptimistic If tabla!apg_id = 1 Then sql = "update apagado_general set apg_estado = 'I' where apg_id = 1" End If con.Execute sql tabla.Close End Sub ‘-------------------------------------------------------------------------------------- ‘Activación del proceso remoto '-------------------------------------------------------------------------------------- Public Sub Onremote(remo As Boolean)
191
If remo Then sql = "update apagado_general set apg_estado = 'A' where apg_id = 2" sql1 = "update tipo_mc set tmc_estado = 'A' where tmc_id = 2" Else sql = "update apagado_general set apg_estado = 'I' where apg_id = 2" sql1 = "update tipo_mc set tmc_estado = 'I' where tmc_id = 2" End If con.Execute sql con.Execute sql1 End Sub ‘-------------------------------------------------------------------------------------- 'Módulo para saber la direccion que se llevaba al momento de ocurrir una incidencia '-------------------------------------------------------------------------------------- Public Sub Carga_Decarga(recep As Boolean) If recep Then sql = "update dispositivo set dis_estado = 'A' where dis_id = 2" sql1 = "update dispositivo set dis_estado = 'I' where dis_id = 3" Else sql = "update dispositivo set dis_estado = 'I' where dis_id = 2" sql1 = "update dispositivo set dis_estado = 'A' where dis_id = 3" End If con.Execute sql con.Execute sql1 End Sub Public Sub Limpia_Carga_Decarga() sql = "update dispositivo set dis_estado = 'I' where dis_id = 2" sql1 = "update dispositivo set dis_estado = 'I' where dis_id = 3" con.Execute sql con.Execute sql1 End Sub ‘-------------------------------------------------------------------------------------- ' Gravo los datos que se van produciendo conforme el tanque se llena en la base de datos llamada registro '------------------------------------------------------------------------------------- Public Sub registro(cant As Variant, loco As Boolean, confirmado As String) Dim via As Integer Dim via1 As Integer Dim tabla22 As ADODB.Recordset Set tabla22 = New Recordset confirmado1 = confirmado Text5.Text = Format(Date, "yyyy/mm/dd") Text6.Text = Time Text4.Text = Text5.Text + " " + Text6.Text puro = loco If puro <> 0 Then via = "2" via1 = "1"
192
Else via = "1" via1 = "2" End If ‘-------------------------------------------------------------------------------------- 'Lleno la tabla registro con datos obtenidos del sistema '-------------------------------------------------------------------------------------- sql = "Select * from registro_mc " tabla22.Open sql, con, 3, 3 tabla22.AddNew tabla22!rmc_dis_id = 1 tabla22!rmc_tmc_id = 1 tabla22!rmc_cantidad = cant tabla22!rmc_fecha = Text4.Text tabla22!rmc_estado_on_off = 1 tabla22!rmc_estado_confirmacion = confirmado1 tabla22.AddNew tabla22!rmc_dis_id = 2 tabla22!rmc_tmc_id = 2 tabla22!rmc_cantidad = 1 tabla22!rmc_fecha = Text4.Text tabla22!rmc_estado_on_off = via tabla22!rmc_estado_confirmacion = confirmado1 tabla22.AddNew tabla22!rmc_dis_id = 3 tabla22!rmc_tmc_id = 2 tabla22!rmc_cantidad = 1 tabla22!rmc_fecha = Text4.Text tabla22!rmc_estado_on_off = via1 tabla22!rmc_estado_confirmacion = confirmado1 tabla22.Update tabla22.Close ‘-------------------------------------------------------------------------------------- 'Lleno la tabla temporal de manera paralela a la de registro '-------------------------------------------------------------------------------------- Dim tabla As ADODB.Recordset Set tabla = New Recordset sql1 = "Select * from temporal " tabla.Open sql1, con, 3, 3 tabla.AddNew tabla!tmp_dis_id = 1 tabla!tmp_tmc_id = 1 tabla!tmp_cantidad = cant tabla!tmp_fecha = Text4.Text tabla!tmp_estado_on_off = 1 tabla!tmp_estado_confirmacion = confirmado1 tabla.AddNew tabla!tmp_dis_id = 2
193
tabla!tmp_tmc_id = 2 tabla!tmp_cantidad = 1 tabla!tmp_fecha = Text4.Text tabla!tmp_estado_on_off = via tabla!tmp_estado_confirmacion = confirmado1 tabla.AddNew tabla!tmp_dis_id = 3 tabla!tmp_tmc_id = 2 tabla!tmp_cantidad = 1 tabla!tmp_fecha = Text4.Text tabla!tmp_estado_on_off = via1 tabla!tmp_estado_confirmacion = confirmado1 tabla.Update tabla.Close End Sub ‘-------------------------------------------------------------------------------------- 'Almaceno la incidencia en caso de existir algún problema con alguna bomba '-------------------------------------------------------------------------------------- Public Sub registro_fallo(tanq As Variant, loca As Boolean) Dim via2 As Integer Dim via3 As Integer puro1 = loca If puro1 <> 0 Then via2 = "2" via3 = "1" Else via2 = "1" via3 = "2" End If Dim tabla As ADODB.Recordset Set tabla = New Recordset sql = "Select * from registro_mc " tabla.Open sql, con, adOpenDynamic, adLockOptimistic tabla.AddNew If temp1 Then tabla!rmc_dis_id = 1 tabla!rmc_tmc_id = 1 tabla!rmc_cantidad = tanq tabla!rmc_fecha = Text4.Text tabla!rmc_estado_on_off = 1 tabla!rmc_estado_confirmacion = "ok" tabla.AddNew tabla!rmc_dis_id = 2 tabla!rmc_tmc_id = 2 tabla!rmc_cantidad = 0 tabla!rmc_fecha = Text4.Text tabla!rmc_estado_on_off = via2 tabla!rmc_estado_confirmacion = "fallo"
194
tabla.AddNew tabla!rmc_dis_id = 3 tabla!rmc_tmc_id = 2 tabla!rmc_cantidad = 1 tabla!rmc_fecha = Text4.Text tabla!rmc_estado_on_off = via3 tabla!rmc_estado_confirmacion = "ok" Else tabla!rmc_dis_id = 1 tabla!rmc_tmc_id = 1 tabla!rmc_cantidad = tanq tabla!rmc_fecha = Text4.Text tabla!rmc_estado_on_off = 1 tabla!rmc_estado_confirmacion = "ok" tabla.AddNew tabla!rmc_dis_id = 2 tabla!rmc_tmc_id = 2 tabla!rmc_cantidad = 1 tabla!rmc_fecha = Text4.Text tabla!rmc_estado_on_off = via2 tabla!rmc_estado_confirmacion = "ok" tabla.AddNew tabla!rmc_dis_id = 3 tabla!rmc_tmc_id = 2 tabla!rmc_cantidad = 0 tabla!rmc_fecha = Text4.Text tabla!rmc_estado_on_off = via3 tabla!rmc_estado_confirmacion = "fallo" End If tabla.Update tabla.Close ‘-------------------------------------------------------------------------------------- 'Lleno de manera paralela la incidencia en la tabla temporal '-------------------------------------------------------------------------------------- Dim tabla22 As ADODB.Recordset Set tabla22 = New Recordset sql1 = "Select * from temporal " tabla22.Open sql1, con, adOpenDynamic, adLockOptimistic tabla22.AddNew If temp1 Then tabla22!tmp_dis_id = 1 tabla22!tmp_tmc_id = 1 tabla22!tmp_cantidad = tanq tabla22!tmp_fecha = Text4.Text tabla22!tmp_estado_on_off = 1 tabla22!tmp_estado_confirmacion = "ok" tabla22.AddNew tabla22!tmp_dis_id = 2 tabla22!tmp_tmc_id = 2
195
tabla22!tmp_cantidad = 0 tabla22!tmp_fecha = Text4.Text tabla22!tmp_estado_on_off = via2 tabla22!tmp_estado_confirmacion = "fallo" tabla22.AddNew tabla22!tmp_dis_id = 3 tabla22!tmp_tmc_id = 2 tabla22!tmp_cantidad = 1 tabla22!tmp_fecha = Text4.Text tabla22!tmp_estado_on_off = via3 tabla22!tmp_estado_confirmacion = "ok" Else tabla22!tmp_dis_id = 1 tabla22!tmp_tmc_id = 1 tabla22!tmp_cantidad = tanq tabla22!tmp_fecha = Text4.Text tabla22!tmp_estado_on_off = 1 tabla22!tmp_estado_confirmacion = "ok" tabla22.AddNew tabla22!tmp_dis_id = 2 tabla22!tmp_tmc_id = 2 tabla22!tmp_cantidad = 1 tabla22!tmp_fecha = Text4.Text tabla22!tmp_estado_on_off = via2 tabla22!tmp_estado_confirmacion = "ok" tabla22.AddNew tabla22!tmp_dis_id = 3 tabla22!tmp_tmc_id = 2 tabla22!tmp_cantidad = 0 tabla22!tmp_fecha = Text4.Text tabla22!tmp_estado_on_off = via3 tabla22!tmp_estado_confirmacion = "fallo" End If tabla22.Update tabla22.Close End Sub ‘-------------------------------------------------------------------------------------- 'Se activa para observar si el cliente remoto, no realiza alguna acción en la base de datos '-------------------------------------------------------------------------------------- Public Sub censo_ag() Dim tabla As ADODB.Recordset sql = "SELECT * FROM apagado_general where apg_id = 1" Set tabla = New Recordset tabla.Open sql, con, adOpenDynamic, adLockReadOnly If (tabla!apg_estado = "A") Then ApagaLeds CloseMPUSBDevice cerradito
196
Else If msjc001 Then info = "Iniciado Sistema Remoto" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info msjc001 = False End If End If tabla.Close End Sub ‘-------------------------------------------------------------------------------------- 'Timer para el mantener el monitoreo de las temperaturas en las bombas '-------------------------------------------------------------------------------------- Private Sub Timer2_Timer() Control_Leds 1, 1 Timer3.Enabled = True Timer2.Enabled = False End Sub ‘-------------------------------------------------------------------------------------- 'Timer para el mantener el monitoreo de las temperaturas en las bombas '-------------------------------------------------------------------------------------- Private Sub Timer3_Timer() Control_Leds 2, 1 Timer2.Enabled = True Timer3.Enabled = False End Sub ‘-------------------------------------------------------------------------------------- 'Timer para el mantener el monitoreo de censo '-------------------------------------------------------------------------------------- Private Sub Timer4_Timer() censo_ag End Sub ‘-------------------------------------------------------------------------------------- 'Limpio la base de datos luego de alguna incidencia '-------------------------------------------------------------------------------------- Public Sub limpio_bd() sql = "update apagado_general set apg_estado = 'I' where apg_id = 1" sql1 = "update apagado_general set apg_estado = 'I' where apg_id = 2" sql2 = "update dispositivo set dis_estado = 'I' where dis_id = 2" sql3 = "update dispositivo set dis_estado = 'I' where dis_id = 3" sql4 = "update tipo_mc set tmc_estado = 'I' where tmc_id = 2" sql5 = "update dispositivo set dis_remoto = '0' where dis_id = 2" sql6 = "update dispositivo set dis_remoto = '0' where dis_id = 3" con.Execute sql con.Execute sql1 con.Execute sql2
197
con.Execute sql3 con.Execute sql4 con.Execute sql5 con.Execute sql6 End Sub ‘-------------------------------------------------------------------------------------- 'Limpio la tabla del proceso que realizó remoto '-------------------------------------------------------------------------------------- Public Sub limpio_Remoto_bd() sql15 = "update dispositivo set dis_remoto = '0' where dis_id = 2" sql16 = "update dispositivo set dis_remoto = '0' where dis_id = 3" con.Execute sql15 con.Execute sql16 End Sub ‘-------------------------------------------------------------------------------------- 'Proceso de vaciado del tanque '-------------------------------------------------------------------------------------- Public Sub vaciado(confirma_vaciado As String) Beep Bomba1.Enabled = True Dim msj003 As Boolean msj003 = True Dim i As Integer Dim bandera As Variant flag1 = True Control_Leds 1, 6 aguante aguante aguante aguante aguante aguante Control_Leds 2, 6 While flag1 Confirbomba2 Wend vacio = False Carga_Decarga (vacio) bandera = 10 For i = 1 To 80 If BtParar.Enabled Then alertas = "ALERTA Suceso en las Bombas" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List2.AddItem alertas Reinicio.Visible = True Call llamalo(bandera, 80 - i, vacio) alarma Call registro_fallo(bandera, vacio)
198
msjc001 = True Timer4.Enabled = True Exit For Else If msj003 Then info = "Vaciando Bom2 ==> 'OK'" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info info = "Nivel Alto Desactivado" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info msj003 = False End If aguante alarma Nivel1.Value = bandera - 0.125 bandera = Nivel1.Value Call registro(bandera, vacio, confirma_vaciado) If bandera = 5 Then info = "Nivel Medio Desactivado" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info End If If bandera = 0 Then bomba2.Visible = False info = "Nivel bajo Desactivado" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info info = "Vaciado Exitoso" + Chr(9) + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info Event_Succes_Log Event_Alert_Log End If End If Next i Limpia_Carga_Decarga limpia_temporal limpio_Remoto_bd End Sub ‘-------------------------------------------------------------------------------------- 'Comienzo el proceso de llenado del tanque '-------------------------------------------------------------------------------------- Public Sub llenado(confirma_llenado As String) Beep Dim msj001 As Boolean msj001 = True bomba2.Enabled = True Dim i As Integer
199
Dim bandera As Variant flag = True Control_Leds 1, 7 aguante aguante aguante aguante aguante aguante Control_Leds 2, 7 While flag Confirbom1 Wend vacio = True Carga_Decarga (vacio) For i = 1 To 80 If BtParar.Enabled Then alertas = "ALERTA Suceso en las Bombas" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List2.AddItem alertas Reinicio.Visible = True Call llamalo(bandera, i, vacio) alarma Call registro_fallo(bandera, vacio) msjc001 = True Timer4.Enabled = True Exit For Else If msj001 Then info = "Llenando Bom1 ==> 'OK'" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info msj001 = False info = "Nivel Bajo Activado" + Chr(9) + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info End If aguante alarma Nivel1.Value = bandera + 0.125 bandera = Nivel1.Value Call registro(bandera, vacio, confirma_llenado) If bandera = 5 Then info = "Nivel Medio Activado" + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info End If If bandera >= 10 Then Bomba1.Visible = False
200
info = "Nivel Alto Activado" + Chr(9) + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info info = "Llenado Exitoso " + Chr(9) + Chr(9) + Chr(9) + CStr(Time) + Chr(9) + CStr(Format(Date, "yy/mm/dd")) List1.AddItem info Event_Succes_Log Event_Alert_Log End If End If Next i Limpia_Carga_Decarga limpio_Remoto_bd End Sub ‘-------------------------------------------------------------------------------------- 'Grabo en el registro el tipo de usuario que realizo el proceso un Local o un Remoto '-------------------------------------------------------------------------------------- Public Sub Remoto_Bombas() Dim tabla As ADODB.Recordset sql = "SELECT * FROM dispositivo" Set tabla = New Recordset tabla.Open sql, con, adOpenDynamic, adLockReadOnly Do Until tabla.EOF If (tabla!dis_remoto = 1) And (tabla!dis_id = 2) Then llenado ("R") Else If (tabla!dis_remoto = 1) And (tabla!dis_id = 3) Then vaciado ("R") End If End If tabla.MoveNext Loop tabla.Close End Sub ‘-------------------------------------------------------------------------------------- 'Censa actividad en el proceso remoto '-------------------------------------------------------------------------------------- Private Sub Timer5_Timer() Call Remoto_Bombas End Sub ‘-------------------------------------------------------------------------------------- 'Elimina los datos grabados en temporal luego de cada ciclo completo del proceso '-------------------------------------------------------------------------------------- Public Sub limpia_temporal() sql = "Delete from temporal" con.Execute sql End Sub
201
‘-------------------------------------------------------------------------------------- 'Llenado del archivo para almacenar el evento log '-------------------------------------------------------------------------------------- Public Sub Event_Succes_Log() Dim ruta As String ruta = "c:\EventSucces.ini" Open ruta For Append Lock Write As 1 For i = 0 To List1.ListCount - 1 Me.List1.ListIndex = i Print #1, Me.List1.Text Next Close #1 time_late Me.List1.clear End Sub ‘-------------------------------------------------------------------------------------- 'Llenado del archivo para almacenar el evento alarmas '-------------------------------------------------------------------------------------- Public Sub Event_Alert_Log() Dim ruta As String ruta = "c:\EventAlert.ini" Open ruta For Append Lock Write As 1 For i = 0 To List2.ListCount - 1 Me.List2.ListIndex = i Print #1, Me.List2.Text Next Close #1 time_late Me.List2.clear End Sub
C.2.3 CONSULTAS
FORM1 Consulta realizada por dispositivos en la misma se utiliza formulas parámetros que
son enviados al reporte para que se llene el mismo con datos de importancia para la
emisión del mismo
‘-------------------------------------------------------------------------------------- 'Proceso para empezar a realizar la consulta '-------------------------------------------------------------------------------------- Private Sub Command1_Click() Dim f1 As Date Dim f2 As Date ‘se confirma que los datos estén correctamente ingresados’
202
If Not IsDate(Mas1(0).Text) Then Call MsgBox("Fecha inicial mal ingresada", vbExclamation, "Consultas") Call SelText(Mas1(0)) Mas1(0).SetFocus Exit Sub End If If Not IsDate(Mas1(1).Text) Then Call MsgBox("Fecha final mal ingresada", vbExclamation, "Consultas") Call SelText(Mas1(1)) Mas1(1).SetFocus Exit Sub End If f1 = Mas1(0).Text f2 = Mas1(1).Text ‘Creación de parámetros que se enviaran a Crystal Report para que se muestren’ Me.CrystalReport1.ReportFileName = App.Path & "\ReporteLlenado.rpt" ' Dim formula As String formula = "" For i = 0 To Me.List2.ListCount - 1 If i = 0 Then formula = formula + " if {registro_mc.rmc_estado_on_off}='" & Mid(Me.List2.List(i), 1, 1) & "' then " formula = formula + " '" + Mid(Me.List2.List(i), 2, 100) + "' " Else formula = formula + " else if {registro_mc.rmc_estado_on_off}='" & Mid(Me.List2.List(i), 1, 1) & "' then " formula = formula + " '" + Mid(Me.List2.List(i), 2, 100) + "' " End If Next Debug.Print formula Dim formula1 As String formula1 = "" For i = 0 To Me.List3.ListCount - 1 If i = 0 Then formula1 = formula1 + " if {registro_mc.rmc_tmc_id}=" & Mid(Me.List3.List(i), 1, 1) & " then " formula1 = formula1 + " '" + Mid(Me.List3.List(i), 2, 100) + "' " Else formula1 = formula1 + " else if {registro_mc.rmc_tmc_id}=" & Mid(Me.List3.List(i), 1, 1) & " then " formula1 = formula1 + " '" + Mid(Me.List3.List(i), 2, 100) + "' " End If Next Debug.Print formula1 Me.CrystalReport1.Formulas(0) = "f=" & formula & ""
203
Me.CrystalReport1.Formulas(1) = "g='" & Me.List1.Text & "'" Me.CrystalReport1.Formulas(2) = "h=" & formula1 & "" Me.CrystalReport1.WindowState = crptMaximized ‘Carga de datos obtenidos desde la formula se los esta parametrizando para enviarlos al reporte’ CrystalReport1.ReplaceSelectionFormula ("{registro_mc.rmc_dis_id} = " & Mid(Me.List1.Text, 1, 1) & " and {registro_mc.rmc_Fecha} in DateTime (" & Year(f1) & ", " & Month(f1) & ", " & Day(f1) & ",00, 00, 00) to DateTime (" & Year(f2) & ", " & Month(f2) & ", " & Day(f2) & ",00, 00, 00)") If Me.Check1.Value = 0 And Me.Check2.Value = 1 Then CrystalReport1.ReplaceSelectionFormula ("{registro_mc.rmc_estado_on_off} = '" & Mid(Me.List2.Text, 1, 1) & "' and {registro_mc.rmc_dis_id} = " & Mid(Me.List1.Text, 1, 1) & " and {registro_mc.rmc_Fecha} in DateTime (" & Year(f1) & ", " & Month(f1) & ", " & Day(f1) & ",00, 00, 00) to DateTime (" & Year(f2) & ", " & Month(f2) & ", " & Day(f2) & ",00, 00, 00)") End If Me.CrystalReport1.WindowTitle = "Informe detallado de Nivel de bombas" Me.CrystalReport1.Action = 1 ‘Presentación del reporte’ End Sub ‘-------------------------------------------------------------------------------------- 'Lleno los objetos del formulario con los datos de las tablas a los que pertenecen '-------------------------------------------------------------------------------------- Private Sub Form_Load() conexion Dim tabla As ADODB.Recordset Set tabla = New ADODB.Recordset sql = "select * from dispositivo" tabla.Open sql, con, 3, 3 Me.List1.clear Do Until tabla.EOF Me.List1.AddItem tabla!dis_id & " " & tabla!dis_descripcion tabla.MoveNext Loop tabla.Close sql = "select * from apagado_general" tabla.Open sql, con, 3, 3 Me.List2.clear Do Until tabla.EOF Me.List2.AddItem tabla!apg_id & " " & tabla!apg_descripcion tabla.MoveNext Loop tabla.Close sql = "select * from tipo_mc" tabla.Open sql, con, 3, 3
204
Me.List3.clear Do Until tabla.EOF Me.List3.AddItem tabla!tmc_id & " " & tabla!tmc_descripcion tabla.MoveNext Loop tabla.Close End Sub FORM 6 Consulta realizada consulta por usuario en la misma se utiliza formulas parámetros que son enviados al reporte para que se llene el mismo ‘-------------------------------------------------------------------------------------- ' Contador para poder dar acciones al botón de avance y retroceso '-------------------------------------------------------------------------------------- Public contador As Integer Private Sub Check1_Click() If Check1.Value = 1 Then Combo1.Enabled = False Command1.Visible = True Command2.Visible = True Label7.Visible = True Text5.Visible = True Combo1.Text = "" limpia_text Else Combo1.Enabled = True Command1.Visible = False Command2.Visible = False Label7.Visible = False Text5.Visible = False limpia_text End If End Sub ‘Módulos de limpiar los text para la presentación de los siguientes datos Private Sub limpia_text() Text1.Text = "" Text2.Text = "" Text3.Text = "" Text4.Text = "" Text5.Text = "" End Sub ‘-------------------------------------------------------------------------------------- ‘Búsqueda de siguiente usuario '--------------------------------------------------------------------------------------
205
Private Sub Command1_Click() limpia_text contador = contador - 1 Dim tabla As ADODB.Recordset Set tabla = New ADODB.Recordset sql = "select * from usuario" tabla.Open sql, con, 3, 3 Do Until tabla.EOF If tabla!usu_id = contador Then Text5.Text = tabla!usu_nombres Text1.Text = tabla!usu_apellidos Text2.Text = tabla!usu_direccion Text3.Text = tabla!usu_telefono Text4.Text = tabla!usu_cedula Exit Do End If tabla.MoveNext Loop If contador = 0 Then Command1.Enabled = False Command2.Enabled = True MsgBox "No hay mas registros en la tabla", vbInformation, "Consulta Usuarios" End If tabla.Close End Sub ‘-------------------------------------------------------------------------------------- 'Búsqueda de usuario anterior '-------------------------------------------------------------------------------------- Private Sub Command2_Click() limpia_text contador = contador + 1 Dim tabla As ADODB.Recordset Set tabla = New ADODB.Recordset sql = "select * from usuario" tabla.Open sql, con, 3, 3 Do Until tabla.EOF If tabla!usu_id = contador Then Text5.Text = tabla!usu_nombres Text1.Text = tabla!usu_apellidos Text2.Text = tabla!usu_direccion Text3.Text = tabla!usu_telefono Text4.Text = tabla!usu_cedula Exit Do End If tabla.MoveNext Loop If tabla.EOF Then Command2.Enabled = False Command1.Enabled = True
206
MsgBox "No hay mas registros en la tabla", vbInformation, "Consulta Usuarios" End If tabla.Close End Sub ‘-------------------------------------------------------------------------------------- ‘Formulario para llenar los combos '-------------------------------------------------------------------------------------- Private Sub Form_Load() contador = 0 conexion Dim tabla As ADODB.Recordset Set tabla = New ADODB.Recordset sql = "select * from usuario" tabla.Open sql, con, 3, 3 Me.Combo1.clear Do Until tabla.EOF Combo1.AddItem tabla!usu_nombres tabla.MoveNext Loop tabla.Close End Sub Private Sub Toolbar1_ButtonClick(ByVal Button As MSComctlLib.Button) On Error Resume Next Select Case Button.Key Case "Buscar" Call llena Case "Imprimir" llama_reporte Case "Salir" Unload Me End Select End Sub ‘-------------------------------------------------------------------------------------- 'Llamada de reportes para imprimir '-------------------------------------------------------------------------------------- Private Sub llama_reporte() If Check1.Value = 1 Then Me.CrystalReport1.ReportFileName = App.Path & "\pepito.rpt" Me.CrystalReport1.WindowState = crptMaximized Me.CrystalReport1.WindowTitle = "Informe detallado de Nivel de bombas" Me.CrystalReport1.Action = 1 Else Me.CrystalReport1.ReportFileName = App.Path & "\prueba.rpt" Me.CrystalReport1.WindowState = crptMaximized Me.CrystalReport1.WindowTitle = "Informe detallado de Nivel de bombas"
207
Me.CrystalReport1.Action = 1 End If End Sub ‘-------------------------------------------------------------------------------------- 'Llena datos en el formulario para visualizarlos '-------------------------------------------------------------------------------------- Private Sub llena() Dim tabla As ADODB.Recordset Set tabla = New ADODB.Recordset sql = "select * from usuario" tabla.Open sql, con, 3, 3 Do Until tabla.EOF If Combo1.Text = tabla!usu_nombres Then Text1.Text = tabla!usu_apellidos Text2.Text = tabla!usu_direccion Text3.Text = tabla!usu_telefono Text4.Text = tabla!usu_cedula End If tabla.MoveNext Loop tabla.Close End Sub FORM7 Formulario que realiza la presentación de datos de encendido y apagado de los
dispositivos dentro del sistema durante los procesos.
Public opcion As Boolean ‘-------------------------------------------------------------------------------------- 'chequeo de opciones para saber si es una consulta por rango de fechas o por fecha explicita '-------------------------------------------------------------------------------------- Private Sub Option1_Click() Label5.Visible = True Label6.Visible = True Combo3.Visible = True Combo4.Visible = True Label7.Visible = False Combo5.Visible = False opcion = True End Sub Private Sub Option2_Click()
208
Label5.Visible = False Label6.Visible = False Combo3.Visible = False Combo4.Visible = False Label7.Visible = True Combo5.Visible = True opcion = False End Sub ‘-------------------------------------------------------------------------------------- 'Módulo de elección de acción por medio del toolbar '-------------------------------------------------------------------------------------- Private Sub Toolbar1_ButtonClick(ByVal Button As MSComctlLib.Button) On Error Resume Next Select Case Button.Key Case "Visualiza" Call verifica 'Call visual Case "Imprimir" 'Call imprime Case "Salir" Unload Me End Select End Sub ‘-------------------------------------------------------------------------------------- 'Verifica la opción que eligió el usuario de hacer la búsqueda por rango de fecha o por fecha especifica '-------------------------------------------------------------------------------------- Private Sub verifica() If (Combo1.Text <> "" And Combo2.Text <> "") Then If opcion Then If Combo3.Text = "" Or Combo4.Text = "" Then MsgBox "Por Favor Escoja Rango de Fechas", vbInformation Else visual End If Else If Combo5.Text = "" Then MsgBox "Por Favor Escoja la Fecha", vbInformation Else visual End If End If Else MsgBox "Llene por Favor Todos los datos", vbInformation End If End Sub
209
C.2.4 MANTENIMIENTO
FORM3 Formulario que permite realizar el ingreso de nuevos usuarios a la base de datos ‘-------------------------------------------------------------------------------------- 'Permite grabar los datos obtenidos desde el formulario '-------------------------------------------------------------------------------------- Private Sub Command1_Click() Dim tabla As ADODB.Recordset sql = "SELECT * FROM usuario " Set tabla = New Recordset tabla.Open sql, con, adOpenDynamic, adLockReadOnly Do Until tabla.EOF If (tabla!usu_nombres = MaskEdBox1.Text) Then MsgBox "Usuario ya existe" MaskEdBox1.Text = "" Me.MaskEdBox1.SetFocus End If tabla.MoveNext Loop tabla.Close ‘-------------------------------------------------------------------------------------- 'Confirma si los campos fueron correctamente llenados '-------------------------------------------------------------------------------------- If MaskEdBox1.Text <> "" And MaskEdBox2.Text <> "" And MaskEdBox3.Text <> "" And MaskEdBox4.Text <> "" And MaskEdBox5.Text <> "" And Text1.Text <> "" Then res = MsgBox("Confirma Realizar Inserción de Nuevo Usuario", vbYesNoCancel, "Creación de usuario") If res = 6 Then llena Else If res = 7 Then MsgBox "No se realizó el ingreso" End If End If Else MsgBox "Por Favor Llene Todos los Campos", vbInformation, "Ingreso de Usuarios" End If End Sub ‘-------------------------------------------------------------------------------------- 'Salida del formulario
210
'-------------------------------------------------------------------------------------- Private Sub Command2_Click() Unload Me End Sub Private Sub Form_Load() conexion End Sub Private Sub limpia() MaskEdBox1.Text = "" MaskEdBox2.Text = "" MaskEdBox3.Text = "" MaskEdBox4.Text = "" MaskEdBox5.Text = "" Text1.Text = "" End Sub ‘-------------------------------------------------------------------------------------- 'Procedimiento que llena la tabla de usuario '-------------------------------------------------------------------------------------- Public Sub llena() Dim tabla As ADODB.Recordset sql = "select * from usuario" Set tabla = New Recordset tabla.Open sql, con, 3, 3 tabla.AddNew tabla!usu_nombres = MaskEdBox1.Text tabla!usu_apellidos = MaskEdBox2.Text tabla!usu_direccion = MaskEdBox3.Text tabla!usu_telefono = MaskEdBox4.Text tabla!usu_cedula = MaskEdBox5.Text tabla!usu_password = Text1.Text tabla.Update tabla.Close limpia MsgBox "El registro ha sido guardado satisfactoriamente", vbInformation, "Ingreso de Clientes" End Sub ‘-------------------------------------------------------------------------------------- 'Control para que el despliegue sea realizado por medio de la tecla enter '-------------------------------------------------------------------------------------- Private Sub MaskEdBox1_KeyPress(KeyAscii As Integer) If KeyAscii = 13 Then Me.MaskEdBox2.SetFocus End If End Sub Private Sub MaskEdBox2_KeyPress(KeyAscii As Integer)
211
If KeyAscii = 13 Then Me.MaskEdBox3.SetFocus End If End Sub Private Sub MaskEdBox3_KeyPress(KeyAscii As Integer) If KeyAscii = 13 Then Me.MaskEdBox4.SetFocus End If End Sub Private Sub MaskEdBox4_KeyPress(KeyAscii As Integer) If Not (KeyAscii >= 48 And KeyAscii <= 57 Or KeyAscii = 8 Or KeyAscii = 13) Then KeyAscii = 0 MsgBox "Ingrese solo valores Numéricos" Me.MaskEdBox4.SetFocus End If If KeyAscii = 13 Then If Len(MaskEdBox4.Text) = 7 Then Me.MaskEdBox5.SetFocus Else MsgBox "Este campo solicita 7 Dígitos" Me.MaskEdBox4.SetFocus End If End If End Sub ‘-------------------------------------------------------------------------------------- 'Control para que solo permita ingresar datos numéricos en el campo '-------------------------------------------------------------------------------------- Private Sub MaskEdBox5_KeyPress(KeyAscii As Integer) If Not (KeyAscii >= 48 And KeyAscii <= 57 Or KeyAscii = 8 Or KeyAscii = 13) Then KeyAscii = 0 MsgBox "Ingrese solo valores Numéricos" Me.MaskEdBox5.SetFocus End If If KeyAscii = 13 Then If Len(MaskEdBox5.Text) = 10 Then Me.Text1.SetFocus Else MsgBox "Este campo solicita 10 Dígitos" Me.MaskEdBox5.SetFocus End If End If End Sub Private Sub Text1_KeyPress(KeyAscii As Integer) If KeyAscii = 13 Then Me.Command1.SetFocus
212
End If End Sub FORM4 Mantenimiento de dispositivos en la base de datos más no obstante se agregara al ningún formulario Dim radios As Boolean ‘-------------------------------------------------------------------------------------- 'Control de verificación si ira para monitoreo visual y remoto '-------------------------------------------------------------------------------------- Public Sub radius() If Frame1.Visible = True Then If Option1.Value = True Or Option2.Value = True Then radios = True Else radios = False End If Else radios = True End If End Sub ‘-------------------------------------------------------------------------------------- ‘Envío de focus a los siguientes niveles '-------------------------------------------------------------------------------------- Private Sub Combo1_Click() Me.Combo2.SetFocus End Sub Private Sub Combo1_LostFocus() If Combo1.Text = "Sensor" Then Frame1.Visible = True Else Frame1.Visible = False End If End Sub ‘-------------------------------------------------------------------------------------- ‘Grabo en la base de datos '-------------------------------------------------------------------------------------- Private Sub Command1_Click() radius confirma End Sub
213
‘-------------------------------------------------------------------------------------- 'Cierra el formulario '-------------------------------------------------------------------------------------- Private Sub Command2_Click() Unload Me End Sub ‘-------------------------------------------------------------------------------------- 'Confirmación del ingreso de los datos '-------------------------------------------------------------------------------------- Private Sub confirma() If Combo1.Text <> "" And Combo2.Text <> "" And radios Then res = MsgBox("Confirma Realizar Inserción", vbYesNoCancel, "Creación de Dispositivo") If res = 6 Then inserto Else If res = 7 Then MsgBox "No se realizó el ingreso" End If End If Else MsgBox "Por Favor, Ingrese todos los datos" End If End Sub ‘-------------------------------------------------------------------------------------- 'Ingreso a las tablas de la base de datos '-------------------------------------------------------------------------------------- Public Sub inserto() Dim tabla As ADODB.Recordset sql = "select * from dispositivo" Set tabla = New Recordset tabla.Open sql, con, 3, 3 tabla.AddNew tabla!dis_descripcion = Combo1.Text If Combo2.Text = "Activo" Then tabla!dis_estado = "A" Else tabla!dis_estado = "I" End If If Check1.Value = 1 Then tabla!dis_remoto = 0 Else tabla!dis_remoto = "" End If tabla.Update tabla.Close limpia End Sub
214
Private Sub Form_Load() conexion End Sub ‘-------------------------------------------------------------------------------------- 'Limpio los campos luego del ingreso '-------------------------------------------------------------------------------------- Public Sub limpia() MsgBox "El registro ha sido guardado satisfactoriamente", vbInformation, "Ingreso de Clientes" Combo1.Text = "" Combo2.Text = "" Check1.Value = 0 Check2.Value = 0 Option1.Value = False Option2.Value = False Me.Combo1.SetFocus End Sub
C.2.5 EVENTOS
FRMPRESENTA Se encarga de presentar el evento del proceso que se desarrollaron axial como
contiene un toolbar con las aplicaciones de abrir, guardar, refrescar e imprimir los
datos
‘-------------------------------------------------------------------------------------- 'Declaración de variables utilizables propias del win32 '-------------------------------------------------------------------------------------- Private Declare Function OSWinHelp% Lib "user32" Alias "WinHelpA" (ByVal hwnd&, ByVal HelpFile$, ByVal wCommand%, dwData As Any) Private Declare Function ShellExecute Lib "shell32.dll" Alias _ "ShellExecuteA" (ByVal hwnd As Long, ByVal lpOperation As String, _ ByVal lpFile As String, ByVal lpParameters As String, _ ByVal lpDirectory As String, ByVal nShowCmd As Long) As Long Private Sub Command1_Click() List1.Visible = True rtfText.Visible = False Command1.Visible = False tbToolBar.Visible = True End Sub Private Sub Form_Load() actual
215
End Sub ‘-------------------------------------------------------------------------------------- 'Control toolbar '-------------------------------------------------------------------------------------- Private Sub tbToolBar_ButtonClick(ByVal Button As MSComctlLib.Button) On Error Resume Next Select Case Button.Key Case "Actualiza" Call actual Case "Abrir" Call abre Case "Guardar" Call guarda Case "Imprimir" Call imprime Case "Salir" Unload Me End Select End Sub ‘-------------------------------------------------------------------------------------- 'Control para que solo permita ingresar actuales '-------------------------------------------------------------------------------------- Public Sub actual() List1.clear Open "C:\EventSucces.ini" For Input Lock Read As #1 Do While Not EOF(1) Input #1, linea_texto List1.AddItem linea_texto Loop Close 1 End Sub ‘-------------------------------------------------------------------------------------- 'Abre aplicaciones varias que se puedan desplegar en un archivo rpt '------------------------------------------------------------------------------------- Public Sub abre() List1.Visible = False rtfText.Visible = True Command1.Visible = True tbToolBar.Visible = False Dim sFile As String With dlgCommonDialog .DialogTitle = "Abrir" .CancelError = False 'Pendiente: establecer los indicadores y los atributos del control common dialog .Filter = "Todos los archivos (*.*)|*.*" .ShowOpen If Len(.FileName) = 0 Then
216
Exit Sub End If sFile = .FileName End With rtfText.LoadFile sFile Caption = sFile End Sub ‘-------------------------------------------------------------------------------------- 'Guarda lo que se visualiza en la form rpt '-------------------------------------------------------------------------------------- Public Sub guarda() Dim sFile As String If True Then With dlgCommonDialog .DialogTitle = "Guardar" .CancelError = False .Filter = "Todos los archivos (*.*)|*.*" .ShowSave If Len(.FileName) = 0 Then Exit Sub End If sFile = .FileName End With rtfText.LoadFile ("c:\EventSucces.ini") rtfText.SaveFile sFile Else sFile = Caption rtfText.SaveFile sFile End If End Sub ‘-------------------------------------------------------------------------------------- 'Imprime el documento '-------------------------------------------------------------------------------------- Public Sub imprime() Dim res1 As Long res1 = ShellExecute(Me.hwnd, "Print", "c:\EventSucces.ini", "", "", 1) End Sub FORM5 Se encarga de presentar el evento de alertas proceso que se desarrollaron así como
contiene un toolbar con las aplicaciones de abrir, guardar, refrescar e imprimir los
datos.
‘-------------------------------------------------------------------------------------- 'Declaración de variables utilizables propias del win32 '--------------------------------------------------------------------------------------
217
Private Declare Function OSWinHelp% Lib "user32" Alias "WinHelpA" (ByVal hwnd&, ByVal HelpFile$, ByVal wCommand%, dwData As Any) Private Declare Function ShellExecute Lib "shell32.dll" Alias _ "ShellExecuteA" (ByVal hwnd As Long, ByVal lpOperation As String, _ ByVal lpFile As String, ByVal lpParameters As String, _ ByVal lpDirectory As String, ByVal nShowCmd As Long) As Long Private Sub Command1_Click() List1.Visible = True rtfText.Visible = False Command1.Visible = False tbToolBar.Visible = True End Sub Private Sub Form_Load() actual End Sub ‘-------------------------------------------------------------------------------------- 'Control toolbar para llamar a los diferentes procesos '-------------------------------------------------------------------------------------- Private Sub tbToolBar_ButtonClick(ByVal Button As MSComctlLib.Button) On Error Resume Next Select Case Button.Key Case "Actualiza" Call actual Case "Abrir" Call abre Case "Guardar" Call guarda Case "Imprimir" Call imprime Case "Salir" Unload Me End Select End Sub ‘-------------------------------------------------------------------------------------- 'Control para que solo permita ingresar datos actuales '-------------------------------------------------------------------------------------- Public Sub actual() List1.clear Open "C:\EventAlert.ini" For Input Lock Read As #1 Do While Not EOF(1) Input #1, linea_texto List1.AddItem linea_texto Loop Close 1 End Sub Public Sub abre() List1.Visible = False
218
rtfText.Visible = True Command1.Visible = True tbToolBar.Visible = False Dim sFile As String With dlgCommonDialog .DialogTitle = "Abrir" .CancelError = False 'Pendiente: establecer los indicadores y los atributos del control common dialog .Filter = "Todos los archivos (*.*)|*.*" .ShowOpen If Len(.FileName) = 0 Then Exit Sub End If sFile = .FileName End With rtfText.LoadFile sFile Caption = sFile End Sub ‘-------------------------------------------------------------------------------------- 'Guarda lo que se visualiza en la form rpt '-------------------------------------------------------------------------------------- Public Sub guarda() Dim sFile As String If True Then With dlgCommonDialog .DialogTitle = "Guardar" .CancelError = False .Filter = "Todos los archivos (*.*)|*.*" .ShowSave If Len(.FileName) = 0 Then Exit Sub End If sFile = .FileName End With rtfText.LoadFile ("c:\EventAlert.ini") rtfText.SaveFile sFile Else sFile = Caption rtfText.SaveFile sFile End If End Sub ‘-------------------------------------------------------------------------------------- 'Imprime el documento rpt '-------------------------------------------------------------------------------------- Public Sub imprime() Dim res1 As Long res1 = ShellExecute(Me.hwnd, "Print", "c:\EventAlert.ini", "", "", 1)
219
End Sub
C.2.6 Ayuda
FRMABOUT Presenta información acerca del sistema así como también respecto al desarrollo del programa. Option Explicit ' Opciones de seguridad de clave del Registro... Const READ_CONTROL = &H20000 Const KEY_QUERY_VALUE = &H1 Const KEY_SET_VALUE = &H2 Const KEY_CREATE_SUB_KEY = &H4 Const KEY_ENUMERATE_SUB_KEYS = &H8 Const KEY_NOTIFY = &H10 Const KEY_CREATE_LINK = &H20 Const KEY_ALL_ACCESS = KEY_QUERY_VALUE + KEY_SET_VALUE + _ KEY_CREATE_SUB_KEY + KEY_ENUMERATE_SUB_KEYS + _ KEY_NOTIFY + KEY_CREATE_LINK + READ_CONTROL ' Tipos ROOT de clave del Registro... Const HKEY_LOCAL_MACHINE = &H80000002 Const ERROR_SUCCESS = 0 Const REG_SZ = 1 ' Cadena Unicode terminada en valor nulo Const REG_DWORD = 4 ' Número de 32 bits Const gREGKEYSYSINFOLOC = "SOFTWARE\Microsoft\Shared Tools Location" Const gREGVALSYSINFOLOC = "MSINFO" Const gREGKEYSYSINFO = "SOFTWARE\Microsoft\Shared Tools\MSINFO" Const gREGVALSYSINFO = "PATH" Private Declare Function RegOpenKeyEx Lib "advapi32" Alias "RegOpenKeyExA" (ByVal hKey As Long, ByVal lpSubKey As String, ByVal ulOptions As Long, ByVal samDesired As Long, ByRef phkResult As Long) As Long Private Declare Function RegQueryValueEx Lib "advapi32" Alias "RegQueryValueExA" (ByVal hKey As Long, ByVal lpValueName As String, ByVal lpReserved As Long, ByRef lpType As Long, ByVal lpData As String, ByRef lpcbData As Long) As Long Private Declare Function RegCloseKey Lib "advapi32" (ByVal hKey As Long) As Long Private Sub cmdSysInfo_Click() Call StartSysInfo End Sub
220
Private Sub cmdOK_Click() Unload Me End Sub Private Sub Form_Load() Me.Caption = "Acerca de " & App.Title lblVersion.Caption = "Versión " & App.Major & "." & App.Minor & "." & App.Revision lblTitle.Caption = App.Title End Sub Public Sub StartSysInfo() On Error GoTo SysInfoErr Dim rc As Long Dim SysInfoPath As String ' Intentar obtener ruta de acceso y nombre del programa de Info. Del sistema a partir del Registro... If GetKeyValue(HKEY_LOCAL_MACHINE, gREGKEYSYSINFO, gREGVALSYSINFO, SysInfoPath) Then ' Intentar obtener sólo ruta del programa de Info. Del sistema a partir del Registro... Else If GetKeyValue(HKEY_LOCAL_MACHINE, gREGKEYSYSINFOLOC, gREGVALSYSINFOLOC, SysInfoPath) Then ' Validar la existencia de versión conocida de 32 bits del archivo If (Dir(SysInfoPath & "\MSINFO32.EXE") <> "") Then SysInfoPath = SysInfoPath & "\MSINFO32.EXE" ' Error: no se puede encontrar el archivo... Else GoTo SysInfoErr End If ' Error: no se puede encontrar la entrada del Registro... Else GoTo SysInfoErr End If Call Shell(SysInfoPath, vbNormalFocus) Exit Sub SysInfoErr: MsgBox "La información del sistema no está disponible en este momento", vbOKOnly End Sub Public Function GetKeyValue(KeyRoot As Long, KeyName As String, SubKeyRef As String, ByRef KeyVal As String) As Boolean Dim i As Long ' Contador de bucle Dim rc As Long ' Código de retorno Dim hKey As Long ' Controlador de una clave de Registro abierta Dim hDepth As Long Dim KeyValType As Long ' Tipo de datos de una clave de Registro
221
Dim tmpVal As String ‘Almacenamiento temporal para un valor de clave ‘de Registro Dim KeyValSize As Long ' Tamaño de variable de clave de Registro '------------------------------------------------------------ 'Abrir clave de registro bajo KeyRoot {HKEY_LOCAL_MACHINE...} '------------------------------------------------------------ rc = RegOpenKeyEx(KeyRoot, KeyName, 0, KEY_ALL_ACCESS, hKey) ' Abrir clave de Registro If (rc <> ERROR_SUCCESS) Then GoTo GetKeyError ' Error de controlador... tmpVal = String$(1024, 0) ' Asignar espacio de variable KeyValSize = 1024 ' Marcar tamaño de variable '------------------------------------------------------------ 'Obtener valor de clave de Registro... '------------------------------------------------------------ rc = RegQueryValueEx(hKey, SubKeyRef, 0, _ KeyValType, tmpVal, KeyValSize) ' Obtener o crear valor de clave If (rc <> ERROR_SUCCESS) Then GoTo GetKeyError ' Controlar errores If (Asc(Mid(tmpVal, KeyValSize, 1)) = 0) tmpVal = Left(tmpVal, KeyValSize - 1) ' Encontrado valor nulo, se va a ‘quitar de la cadena Else ' En WinNT las cadenas no terminan en valor nulo... tmpVal = Left(tmpVal, KeyValSize) ' No se ha encontrado valor nulo, sólo se va a extraer la cadena End If '------------------------------------------------------------ ' Determinar tipo de valor de clave para conversión... '------------------------------------------------------------ Select Case KeyValType ' Buscar tipos de datos... Case REG_SZ ' Tipo de datos String de clave de Registro KeyVal = tmpVal ' Copiar valor de cadena Case REG_DWORD ' Tipo de datos Double Word de clave del Registro For i = Len(tmpVal) To 1 Step -1 ' Convertir cada bit KeyVal = KeyVal + Hex(Asc(Mid(tmpVal, i, 1))) ' Generar valor carácter a carácter Next KeyVal = Format$("&h" + KeyVal) ' Convertir Double Word a cadena End Select
222
GetKeyValue = True ' Se ha devuelto correctamente rc = RegCloseKey(hKey) ' Cerrar clave de Registro Exit Function ' Salir GetKeyError: ' Borrar después de que se produzca un error... KeyVal = "" ' Establecer valor a cadena vacía GetKeyValue = False ' Fallo de retorno rc = RegCloseKey(hKey) ' Cerrar clave de Registro End Function
ANEXO D
Codificación del sistema
223
D.1 Aplicación Web
Web Services
o wsApagadoGeneral
o wsControlOnOffDispositivos
o wsObtenerRegistroDispositivo
o wsUsuario
Sources Package
• org.cliente
o ApagadoGeneralBean
o RegistroBean Objetos
o UsuarioBean
• org.servidor
o ConexionBDDataSource
o InterfaceConexionBD
o LogicaNegocio
o wsApagadoGeneral
o wsConotolOnOffDispositivos
o wsObtenerRegistroDispositivo
o wsUsuario
WebServices
wsApagadoGeneral
package org.servidor;
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
import org.cliente.ApagadoGeneralBean;
//Definimos el Webservice
@WebService()
public class wsApagadoGeneral {
//instanciamos el objeto de lógica de negocio
224
private LogicaNegocio ln = new LogicaNegocio();
//Definimos la operación ObtenerApagadoGenreal la cual nos retornará
un //objeto de tipo apagadoGeneralBean
@WebMethod(operationName = "obtenerApagadoGeneral")
public ApagadoGeneralBean obtenerApagadoGeneral(@WebParam(name
= "id")
int id) {
//
ApagadoGeneralBean apg = ln.obtenerApagadoGeneral(id);
return apg;
}
//Definimos la operación apagadoGeneral, mandamos a ejecutar el método
//que actualiza la tabla de apagado general, y nos retorna un boolean que
//nos indica si la acción se ejecuto con éxito o no.
@WebMethod(operationName = "apagadoGeneral")
public boolean apagadoGeneral(@WebParam(name = "id")
int id) {
boolean ok = ln.apagadoGeneral(id);
return ok;
}
}
wsControlOnOffDispositivos
package org.servidor;
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
//Definimos el Webservice
@WebService()
public class wsConotolOnOffDispositivos {
//instanciamos el objeto de lógica de negocio
private LogicaNegocio ln = new LogicaNegocio();
//ejecutamos el ControlOnOffDispositivos el cual actualiza el estado de
encendio
225
//o apagado de los dispositivos, y luego nos retorna un boolean que nos
indica si la acción se ejecuto con éxito o no.
@WebMethod(operationName = "ControlOnOffDispositivos")
public boolean ControlOnOffDispositivos(@WebParam(name = "id")
int id) {
boolean ok = ln.ControlOnOffDispositivos(id);
return ok;
}
}
wsObtenerRegistroDispositivo
package org.servidor;
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
import org.cliente.RegistroBean;
//Definimos el Webservice
@WebService()
public class wsObtenerRegistroDispositivo {
//instanciamos el objeto de lógica de negocio
private LogicaNegocio ln = new LogicaNegocio();
//Definimos una clase de tipo RegistroBean, la cual me retorna el registro
de //todos los dispositivos
@WebMethod(operationName = "obtenerRegistroDispositivo")
public RegistroBean obtenerRegistroDispositivo(@WebParam(name =
"id")
int id) {
//TODO writes your implementation code here:
RegistroBean registro = ln.obtenerRegistroDispositivo(id);
return registro;
}
}
226
wsUsuario
package org.servidor;
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
import org.cliente.UsuarioBean;
//Definimos el Webservice
@WebService()
public class wsUsuario {
//instanciamos el objeto de lógica de negocio
private LogicaNegocio ln = new LogicaNegocio();
//Definimos una clase de tipo UsuarioBean, la cual me retorna el registro
del usuario correspondiente.
@WebMethod(operationName = "obtenerUsuario")
public UsuarioBean obtenerUsuario(@WebParam(name = "cedula")
String cedula,@WebParam(name = "password")
String password) {
UsuarioBean usuario = ln.obtenerUsuario(cedula,password);
return usuario;
}
Sources Packages
org.cliente
Objetos que registran tipos de datos específicos
• ApagadoGeneralBean
• RegistroBean
• UsuarioBean
org.servidor
ConexionBDDataSource
package org.servidor;
import java.sql.Connection;
227
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
import org.cliente.UsuarioBean;
import org.cliente.RegistroBean;
import java.util.ArrayList;
import javax.ejb.FinderException;
import org.cliente.ApagadoGeneralBean;
public class ConexionBDDataSource implements InterfaceConexionBD{
private Connection con;
private DataSource ds;
private PreparedStatement ps;
private ResultSet rs;
public ConexionBDDataSource() {
}
public boolean conectarBD() {
try {
ds = getJdbcMyDatasourceMySQL();
try {
con = ds.getConnection();
} catch (SQLException ex) {
return false;
} catch(NullPointerException ex){
return false;
}
} catch (NamingException ex) {
228
return false;
}
return true;
}
//verifica si el usuario existe o no
public boolean existeUsuario(String cedula) {
try {
ps = con.prepareStatement("select * from usuario where usu_cedula = " +
"'" + cedula + "'");
rs = ps.executeQuery();
if(rs.next()){
return true;
}
} catch (SQLException ex) {
ex.printStackTrace();
}
return false;
}
//obtiene los datos del usuario
public UsuarioBean obtenerUsuario(String cedula,String password) {
UsuarioBean usuario = new UsuarioBean();
String sqlUsuario="select * from usuario where usu_cedula = "+
" '" + cedula + "' and usu_password= "+ " '"+ password +"'";
try {
ps = con.prepareStatement(sqlUsuario);
rs = ps.executeQuery();
if(rs.next()){
usuario.setNombres(rs.getString("usu_nombres"));
usuario.setApellidos(rs.getString("usu_apellidos"));
usuario.setDireccion(rs.getString("usu_direccion"));
usuario.setTelefono(rs.getString("usu_telefono"));
}
229
} catch (SQLException ex) {
ex.printStackTrace();
}
return usuario;
}
//obtiene el último registro del dispositivo requerido
public RegistroBean obtenerRegistroDispositivo(Integer id) {
RegistroBean registro = new RegistroBean();
try {
String sql_registro="";
sql_registro="select dis.dis_descripcion as dispositivo,"+
" tmc.tmc_descripcion as tipo, rmc.rmc_cantidad as cantidad,"+
" rmc.rmc_estado_on_off as estado"+
" FROM registro_mc rmc, dispositivo dis, tipo_mc tmc"+
"where rmc.rmc_dis_id=dis.dis_id and
rmc.rmc_tmc_id=tmc.tmc_id"+
" and rmc.rmc_dis_id= " + id +
" order by rmc.rmc_id desc limit 3";
ps = con.prepareStatement(sql_registro);
rs = ps.executeQuery();
if(rs.next()){
registro.setDispositivo(rs.getString("dispositivo"));
registro.setTipo(rs.getString("tipo"));
registro.setCantidad(rs.getString("cantidad"));
registro.setEstado(rs.getString("estado"));
}
} catch (SQLException ex) {
ex.printStackTrace();
}
return registro;
}
//Obtiene el estado del apagado general del sistema
230
public ApagadoGeneralBean obtenerApagadoGeneral(Integer id) {
ApagadoGeneralBean apg = new ApagadoGeneralBean();
try {
String sql_apg="";
sql_apg="select apg_id as id, apg_descripcion as descripcion,"+
" apg_estado as estado"+
" FROM apagado_general"+
" where apg_id= " + id ;
ps = con.prepareStatement(sql_apg);
rs = ps.executeQuery();
if(rs.next()){
apg.setDescripcion(rs.getString("descripcion"));
apg.setEstado(rs.getString("estado"));
}
} catch (SQLException ex) {
ex.printStackTrace();
}
return apg;
}
//Actualiza el estado de los dispositivos para apagarlos o encenderlos
public boolean ControlOnOffDispositivos(Integer id) {
boolean ok = false;
try {
String sql_apg="";
sql_apg="update dispositivo "+
" set dis_estado='0' "+
" where dis_estado='A' and dis_id= " + id ;
ps = con.prepareStatement(sql_apg);
ps.executeUpdate();
ok=true;
} catch (SQLException ex) {
231
ex.printStackTrace();
}
return ok;
}
public boolean apagadoGeneral(Integer id) {
boolean ok = false;
try {
String sql_apg="";
sql_apg="update apagado_general "+
" set apg_estado='0' "+
" where apg_estado='I' and apg_id= " + id ;
ps = con.prepareStatement(sql_apg);
ps.executeUpdate();
ok=true;
} catch (SQLException ex) {
ex.printStackTrace();
}
return ok;
}
//Código generado por Netbeans realiza el Data Source para la conexion con la
base
private DataSource getJdbcMyDatasourceMySQL() throws NamingException
{
Context c = new InitialContext();
return (DataSource) c.lookup("java:comp/env/jdbc/myDatasourceMySQL");
}
@Override
public void finalize(){
try {
if(!con.isClosed())
232
con.close();
} catch (SQLException ex) {
} catch(NullPointerException ex){
}
}
}
LogicaNegocio
wsApagadoGeneral
wsConotolOnOffDispositivos
wsObtenerRegistroDispositivo
wsUsuario
LogicaNegocio
//Esta clase maneja la lógica del negocio
//Controla la clase de COnexionBDDatasource
package org.servidor;
import org.cliente.UsuarioBean;
import org.cliente.RegistroBean;
import java.util.ArrayList;
import javax.ejb.FinderException;
import org.cliente.ApagadoGeneralBean;
public class LogicaNegocio {
private ConexionBDDataSource con;
private boolean conectado = false;
public LogicaNegocio() {
conectado = conectarse();
}
public boolean conectarse(){
con = new ConexionBDDataSource();
if(!con.conectarBD())
return false;
else
233
return true;
}
public UsuarioBean obtenerUsuario(String cedula,String password){
if(conectado){
if(!con.existeUsuario(cedula)){
return null;
}
else{
UsuarioBean usuario = con.obtenerUsuario(cedula,password);
return usuario;
}
}else
return null;
}
public RegistroBean obtenerRegistroDispositivo(Integer id){
if(conectado){
RegistroBean registro = con.obtenerRegistroDispositivo(id);
return registro;
}else
return null;
}
public ApagadoGeneralBean obtenerApagadoGeneral(Integer id){
if(conectado){
ApagadoGeneralBean apg = con.obtenerApagadoGeneral(id);
return apg;
}else
return null;
}
public boolean ControlOnOffDispositivos(Integer id){
if(conectado){
boolean ok = con.ControlOnOffDispositivos(id);
return ok;
234
}else
return false;
}
public boolean apagadoGeneral(Integer id){
if(conectado){
boolean ok = con.apagadoGeneral(id);
return ok;
}else
return false;
}
}
D.2 Aplicación Móvil
Package hello
httpMidlet
package hello;
import javax.microedition.rms.*;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import javax.microedition.io.*;
import java.io.*;
import java.rmi.Remote.*;
import wsusuarioservice.*;
import wsobtenerregistrodispositivoservice.*;
import wsapagadogeneralservice.*;
//import monitor.midlet.*;
import socket.Client;
//import socket.Server;
235
import java.util.*;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
//import socket.*;
import wsapagadogeneralservice.apagadoGeneralBean;
import wsapagadogeneralservice.wsApagadoGeneralService_Stub;
import
wsconotolonoffdispositivosservice.wsConotolOnOffDispositivosService_Stu
b;
public class HttpMidlet extends MIDlet implements CommandListener{
private Command salir, ingresar, mostrar;
private Command cmdLogin, cmdBack, cmdMonitoreo, cmdControl,
cmdChat, cmdBievenidaControl;
private Command cmdBackBienvenida, cmdBackMonitoreo,
cmdIniciarChat, cmdAceptarControl, cmdBackControl,
cmdAceptarApagado, cmdAceptarEncendido;
private Display display;
private Form pantallaLogin, pantallaBienvenida,pantallaControl,
pantallaApagadoGeneral,
pantallaEncendidoDispositivos,pantallaOKEncendidoDispositivos;
//private reporteGrafico pantallaMonitoreo;
public monitorear pantallaMonitoreo;
private TextField cedula, password;
private List elijeDispositivo;
private ChoiceGroup chOnOff,chEnciendeBomba, chApagadoGeneral;
private StringItem sUsuario, sBombaCarga ,sBombaDescarga, sTanque,
sApagadoGeneral, sEncendidoBombas;
private registroBean registro;
//Bloque Chat
private boolean isPaused;
// private Server server;
private Client client;
236
private boolean llenando=false;
private Timer tm; // Timer
private TestTimerTask tt; // Task
public HttpMidlet() {
display = Display.getDisplay(this);
//Pantalla Login
salir = new Command("Salir", Command.EXIT, 2);
cmdLogin = new Command("Login", Command.OK, 1);
cedula = new TextField("Cedula : ", "",50,TextField.ANY);
password = new TextField("Contraseña", "", 50,
TextField.ANY);
pantallaLogin = new Form("Login");
pantallaLogin.append(cedula);
pantallaLogin.append(password);
pantallaLogin.addCommand(salir);
pantallaLogin.addCommand(cmdLogin);
pantallaLogin.setCommandListener(this);
//Pantalla Bienvenida
cmdBack = new Command("Regresar", Command.BACK, 1);
cmdMonitoreo = new Command("Monitoreo", Command.OK, 1);
cmdBievenidaControl = new Command("Control", Command.OK,
2);
cmdChat = new Command("Chat", Command.OK, 3);
sUsuario = new StringItem("Bienvenido :","");
pantallaBienvenida = new Form("Sistema de Monitoreo y
Control");
pantallaBienvenida.append(sUsuario);
pantallaBienvenida.addCommand(cmdBack);
pantallaBienvenida.addCommand(cmdMonitoreo);
pantallaBienvenida.addCommand(cmdBievenidaControl);
237
pantallaBienvenida.addCommand(cmdChat);
pantallaBienvenida.setCommandListener(this);
//Pantalla Monitoreo
cmdBackBienvenida = new Command("Regresar",
Command.BACK, 1);
cmdChat = new Command("Chat", Command.OK, 1);
cmdControl = new Command("Control", Command.OK, 2);
pantallaMonitoreo = new monitorear();
pantallaMonitoreo.addCommand(cmdBackBienvenida);
pantallaMonitoreo.addCommand(cmdControl);
pantallaMonitoreo.addCommand(cmdChat);
pantallaMonitoreo.setCommandListener(this);
sBombaCarga = new StringItem("Bomba Carga :","");
sBombaDescarga = new StringItem("Bomba Descarga :","");
sTanque = new StringItem("Tanque", "");
//Pantalla Monitoreo
//Pantalla Control
cmdBackMonitoreo = new Command("Regresar",
Command.BACK, 1);
cmdAceptarControl = new Command("Aceptar", Command.OK,
1);
chOnOff = new ChoiceGroup("Apagado/Ecendido de
Dispositivos", Choice.EXCLUSIVE);
chOnOff.append("Apagado General", null);
chOnOff.append("Encendido de Bombas", null);
pantallaControl = new Form("Sistema de Control");
pantallaControl.append(chOnOff);
pantallaControl.addCommand(cmdAceptarControl);
pantallaControl.addCommand(cmdBackMonitoreo);
pantallaControl.setCommandListener(this);
238
cmdBackControl = new Command("Regresar", Command.BACK,
1);
pantallaApagadoGeneral = new Form("Sistema de Control");
chApagadoGeneral = new ChoiceGroup("Apagado General del
Sistema", Choice.EXCLUSIVE);
chApagadoGeneral.append("Si", null);
chApagadoGeneral.append("No", null);
cmdAceptarApagado = new Command("Aceptar", Command.OK,
1);
pantallaApagadoGeneral.append(chApagadoGeneral);
pantallaApagadoGeneral.addCommand(cmdBackControl);
pantallaApagadoGeneral.addCommand(cmdAceptarApagado);
pantallaApagadoGeneral.setCommandListener(this);
pantallaEncendidoDispositivos = new Form("Sistema de Control");
chEnciendeBomba = new ChoiceGroup("Enciende Bomba",
Choice.EXCLUSIVE);
chEnciendeBomba.append("Carga", null);
chEnciendeBomba.append("Descarga", null);
cmdAceptarEncendido = new Command("Aceptar", Command.OK,
1);
pantallaEncendidoDispositivos.append(chEnciendeBomba);
pantallaEncendidoDispositivos.addCommand(cmdBackControl);
pantallaEncendidoDispositivos.addCommand(cmdAceptarEncendido);
pantallaEncendidoDispositivos.setCommandListener(this);
}
public void startApp() {
display.setCurrent(pantallaLogin);
}
public boolean isPaused() {
return isPaused;
239
}
public void pauseApp() {
}
public void destroyApp(boolean unconditional) {
}
public void commandAction(Command c, Displayable s) {
if(c == cmdBack){
display.setCurrent(pantallaLogin);
}
if(c== cmdBackBienvenida){
tm.cancel();
display.setCurrent(pantallaBienvenida);
}
if(c== cmdBackMonitoreo){
llamarTimer();
//wsObtenerRegistroDispotivo();
}
if (c == salir) {
destroyApp(false);
notifyDestroyed();
}
/*if (c == mostrar){
llamarTimer();
}*/
if(c == cmdLogin){
wsLogin();
}
if(c == cmdMonitoreo){
//display.setCurrent(pantallaMonitoreo);
//wsObtenerRegistroDispotivo();
llamarTimer();
//reporteGrafico();
240
}
if(c == cmdChat){
client = new Client(this);
client.start();
}
if (c == cmdIniciarChat) {
tm.cancel();
client = new Client(this);
client.start();
}
if(c == cmdControl){
tm.cancel();
display.setCurrent(pantallaControl);
}
if(c == cmdBievenidaControl){
//tm.cancel();
display.setCurrent(pantallaControl);
//display.setCurrent(elijeDispositivo);
}
if(c == cmdAceptarControl){
//tm.cancel();
if(chOnOff.getSelectedIndex()==0){
display.setCurrent(pantallaApagadoGeneral);
}
if(chOnOff.getSelectedIndex()==1){
display.setCurrent(pantallaEncendidoDispositivos);
}
//display.setCurrent(elijeDispositivo);
}
if(c == cmdBackControl){
display.setCurrent(pantallaControl);
}
241
if(c == cmdAceptarApagado){
wsApagarGeneral();
//display.setCurrent(pantallaControl);
}
if(c == cmdAceptarEncendido){
wsControlDispositivos();
//display.setCurrent(pantallaControl);
}
}
//Clase que maneja el logueo del usuario mediante el consumo del
servicio web y retorna los datos del usuario
public void wsLogin(){
Thread getinfo = new Thread(){/*pasamos como parámetro la instancia
del Thread Principal que no servirá para regresar los datos*/
public void run(){
try{
usuarioBean usuario = new usuarioBean();
wsUsuarioService_Stub wsUsuario = new wsUsuarioService_Stub();
usuario
=wsUsuario.obtenerUsuario(cedula.getString(),password.getString());
sUsuario.setText(usuario.getNombres()+" "+usuario.getApellidos());
if(usuario.getNombres()==null){
Alert alertaUserInvalido = new Alert("Guardar”, “Usuario no
válido...",null,AlertType.CONFIRMATION);
alertaUserInvalido.setTimeout(Alert.FOREVER);
cedula.setString("");
password.setString("");
display.setCurrent(alertaUserInvalido,pantallaLogin);
}else{
display.setCurrent(pantallaBienvenida);
242
}
}catch(IOException e){
e.printStackTrace();
}
}
};
getinfo.start();
}
//Clase que maneja el encendido y apagado de dispositivos dentro del
sistema mediante el consumo de un servicio web el cual actualiza los
estados en la tabla de dispositivos.
public void wsControlDispositivos (){
Thread getinfo = new Thread(){/*pasamos como parámetro la instancia
del Thread Principal que no servirá para regresar los datos*/
public void run(){
try{
boolean ok;
wsConotolOnOffDispositivosService_Stub
wsControlOnOffDispositivos = new
wsConotolOnOffDispositivosService_Stub();
ok
=wsControlOnOffDispositivos.ControlOnOffDispositivos(chEnciendeBomba
.getSelectedIndex()+2);
if(ok==true){
Alert apgControlOnOffDispositivos = new Alert("OK", "Bomba
encendida", null,AlertType.CONFIRMATION);
apgControlOnOffDispositivos.setTimeout(Alert.FOREVER);
display.setCurrent(apgControlOnOffDispositivos,pantallaEncendidoDispositi
vos);
}/*else{
display.setCurrent(pantallaEncendidoDispositivos);
}*/
}catch(IOException e){
243
e.printStackTrace();
}
}
};
getinfo.start();
}
//Clase que maneja el encendido y apagado general del sistema mediante
el consumo de un servicio web el cual actualiza los estados en la tabla de
apagado general.
public void wsApagarGeneral (){
Thread getinfo = new Thread(){/*pasamos como parámetro la instancia
del Thread Principal que no servirá para regresar los datos*/
public void run(){
try{
boolean ok=false;
wsApagadoGeneralService_Stub wsApagarGeneral = new
wsApagadoGeneralService_Stub();
if(chApagadoGeneral.getSelectedIndex()==0){
ok =wsApagarGeneral.apagadoGeneral(1);
}
if(ok==true){
Alert alertApagadoGeneral = new Alert("OK","Apagado General
desde Móbil",null,AlertType.CONFIRMATION);
alertApagadoGeneral.setTimeout(Alert.FOREVER);
display.setCurrent(alertApagadoGeneral,pantallaApagadoGeneral);
}/*else{
display.setCurrent(pantallaEncendidoDispositivos);
}*/
}catch(IOException e){
e.printStackTrace();
}
}
};
244
getinfo.start();
}
//Clase que realiza un reporte gráfico mediante un servicio web que
retorna los registro de los datos actuales de todos y cada uno de los
dispositivos.
public void reporteGrafico(){
Thread getinfo = new Thread(){
public void run(){
try{
registroBean registroTanque = new registroBean();
registroBean registroBombaCarga = new registroBean();
registroBean registroBombaDescarga = new registroBean();
apagadoGeneralBean apg = new apagadoGeneralBean();
wsObtenerRegistroDispositivoService_Stub wsRegistro = new
wsObtenerRegistroDispositivoService_Stub();
wsApagadoGeneralService_Stub wsApg = new
wsApagadoGeneralService_Stub();
apg = wsApg.obtenerApagadoGeneral(2);
registroTanque =wsRegistro.obtenerRegistroDispositivo(1);
registroBombaCarga = wsRegistro.obtenerRegistroDispositivo(2);
registroBombaDescarga = wsRegistro.obtenerRegistroDispositivo(3);
pantallaMonitoreo.setregistroTanque(registroTanque);
pantallaMonitoreo.setregistroBombaCarga(registroBombaCarga);
pantallaMonitoreo.setregistroBombaDescarga(registroBombaDescarga);
pantallaMonitoreo.start();
display.setCurrent(pantallaMonitoreo);
}catch(IOException e){
e.printStackTrace();
245
}
}
};
getinfo.start();
}
public void llamarTimer(){
tm = new Timer();
tt = new TestTimerTask();
tm.schedule(tt,5000, 5000);
}
private class TestTimerTask extends TimerTask
{
public final void run()
{
reporteGrafico();
}
}
}
Monitorear
package hello;
import javax.microedition.lcdui.*;
import javax.microedition.lcdui.game.*;
import javax.microedition.midlet.*;
import java.io.*;
import javax.microedition.media.*;
import java.util.*;
import wsobtenerregistrodispositivoservice.*;
import wsapagadogeneralservice.*;
public class monitorear extends GameCanvas implements Runnable{
private boolean llenando = false;
private long delay;
private Timer tm; // Timer
246
private TestTimerTask tt; // Task
public int tanquex = 0,tanquey = 0;
public int fuenteBomba1X=0, fuenteBomba1Y=0;
public int fuenteBomba2X=0, fuenteBomba2Y=0;
public int fuenteOnOffX=0, fuenteOnOffY=0;
public int fuenteTempX=0, fuenteTempY=0;
public int centroX, centroY, anchoCisterna, altoCisterna;
public int ancho;
public int alto;
private Image image;
//private TiledLayer tiledMapa;
private LayerManager LM;
private Sprite cisterna;
private final Vector gotas = new Vector();
private final Player sonido;
public apagadoGeneralBean apg ;
public registroBean registroTanque;
public registroBean registroBombaCarga;
public registroBean registroBombaDescarga;
//HttpMidlet p;
//Instanciación de Objetos
public void setApagadoGeneral(apagadoGeneralBean apg){
this.apg = apg;
}
public apagadoGeneralBean getApagadoGeneral(){
return apg;
}
public void setregistroTanque(registroBean registroTanque){
this.registroTanque = registroTanque;
}
public registroBean getregistroTanque(){
return registroTanque;
}
public void setregistroBombaCarga(registroBean registroBombaCarga){
247
this.registroBombaCarga = registroBombaCarga;
}
public registroBean getregistroBombaCarga(){
return registroBombaCarga;
}
public void setregistroBombaDescarga(registroBean
registroBombaDescarga){
this.registroBombaDescarga = registroBombaDescarga;
}
public registroBean getregistroBombaDescarga(){
return registroBombaDescarga;
}
//Constructor de la Clase
public monitorear() {
super(true);
ancho = getWidth();
alto = getHeight();
// getDatos();
try {
image= Image.createImage("/cisterna.png");
} catch (IOException e) {
throw new RuntimeException ("Unable to load Image: "+e);
}
cisterna = new Sprite (image,image.getWidth(),image.getHeight());
anchoCisterna=cisterna.getWidth();
altoCisterna=cisterna. GetHeight();
ancho = getWidth();
alto = getHeight();
//varibles de posición de la barra que llena el tanque
//Variables de Fuente
fuenteBomba1X=70;
248
fuenteBomba1Y=(alto/2)+(altoCisterna/2)+20;
fuenteBomba2X=(ancho/2)+(anchoCisterna/2)+20;
fuenteBomba2Y=(alto/2)+(altoCisterna/2)+20;
fuenteOnOffX=10;
fuenteOnOffY=(alto/2)+(altoCisterna/2)+40;
fuenteTempX=10;
fuenteTempY=(alto/2)+(altoCisterna/2)+60;
centroX = (ancho/2)-(anchoCisterna/2);
centroY = (alto/2)-(altoCisterna/2);
cisterna.setPosition(centroX, centroY);
delay = 20;
LM = new LayerManager();
LM.append(cisterna);
//LM.append(tiledMapa);
try {
image= Image.createImage("/gota2.png");
} catch (IOException e) {
throw new RuntimeException ("Unable to load Image: "+e);
}
sonido = createSoundPlayer("/disparo.wav", "audio/x-wav");
}
public void start() {
Thread t = new Thread(this);
t.start();
}
public void stop() {
}
public void run() {
//Instancia la variable gráfica
Graphics g = getGraphics();
//llama a la función que dibuja la animación
llenarCisterna();
while (true) {
//dibuja la pantalla
249
drawScreen(g);
try {
//manda un retardo al hilo que está ejecutándose
Thread.sleep(delay);
} catch (InterruptedException ie) {
}
}
}
//función que dibuja la pantalla
private void drawScreen(Graphics g) {
monitor(g);
//Seteo de Letras Temperatura Bomba de Carga
LM.paint(g,0,0);
flushGraphics();
}
//función que genera un sonido
private Player createSoundPlayer(String filename, String format) {
Player p = null;
try {
InputStream is = getClass().getResourceAsStream(filename);
p = Manager.createPlayer(is, format);
p.prefetch();
} catch (IOException ex){
}
catch (MediaException ex){
}
return p;
}
//función q genera la parte estática del reporte gráfico y muestra los
datos de los dispositivos y del tanque.
private void monitor(Graphics g){
tanquex = (ancho/2)-((anchoCisterna-40)/2);
250
tanquey = ((alto/2)+(altoCisterna/2))-
(Integer.parseInt(registroTanque.getCantidad())*10);
g.setColor(0xffffff);
g.fillRect(0, 0, getWidth(), getHeight());
g.setColor(0x0000ff);
g.setColor(1,1,155);
//g.setColor(1,1,255);
//g.drawRect((ancho/2)-((anchoCisterna-1)/2),(alto/2)-
(altoCisterna/2),anchoCisterna,altoCisterna);
g.setColor(40,155,155);
g.fillRect(tanquex,tanquey,anchoCisterna-
40,Integer.parseInt(registroTanque.getCantidad())*10);
//Seteo Bomba Carga
g.setColor(1,1,155);
Font fBomba1 =
Font.getFont(Font.FACE_SYSTEM,Font.STYLE_BOLD,Font.SIZE_MEDI
UM);
g.setFont(fBomba1);
g.drawString("Bomba 1",fuenteBomba1X, fuenteBomba1Y,
Graphics.HCENTER | Graphics.BOTTOM);
//Seteo Bomba Descarga
g.setColor(1,1,155);
Font fBomba2 =
Font.getFont(Font.FACE_SYSTEM,Font.STYLE_BOLD,Font.SIZE_MEDI
UM);
g.setFont(fBomba2);
g.drawString("Bomba 2",fuenteBomba2X, fuenteBomba2Y,
Graphics.HCENTER | Graphics.BOTTOM);
//Seteo de Letras ON/OF
g.setColor(1,1,155);
Font fOnnOff =
Font.getFont(Font.FACE_SYSTEM,Font.STYLE_BOLD,Font.SIZE_MEDI
UM);
g.setFont(fOnnOff);
251
g.drawString("On/Off",fuenteOnOffX, fuenteOnOffY, Graphics.LEFT |
Graphics.BOTTOM);
//Seteo de Letras Temperatura
g.setColor(1,1,155);
Font fTemp =
Font.getFont(Font.FACE_SYSTEM,Font.STYLE_BOLD,Font.SIZE_MEDI
UM);
g.setFont(fTemp);
g.drawString("Temp",fuenteTempX, fuenteTempY, Graphics.LEFT |
Graphics.BOTTOM);
g.setColor(1,1,155);
Font fB1OnOff =
Font.getFont(Font.FACE_SYSTEM,Font.STYLE_BOLD,Font.SIZE_MEDI
UM);
g.setFont(fB1OnOff);
g.drawString(registroBombaCarga.getEstado(),fuenteBomba1X,
fuenteOnOffY, Graphics.LEFT | Graphics.BOTTOM);
//Seteo de Letras OnOFF Bomba de DesCarga
g.setColor(1,1,155);
Font fB2OnOff =
Font.getFont(Font.FACE_SYSTEM,Font.STYLE_BOLD,Font.SIZE_MEDI
UM);
g.setFont(fB2OnOff);
g.drawString(registroBombaDescarga.getEstado(),fuenteBomba2X,
fuenteOnOffY, Graphics.LEFT | Graphics.BOTTOM);
//Seteo de Letras Temperatura Bomba de Carga
g.setColor(1,1,155);
Font fB1Temp =
Font.getFont(Font.FACE_SYSTEM,Font.STYLE_BOLD,Font.SIZE_MEDI
UM);
g.setFont(fB1Temp);
g.drawString(registroBombaCarga.getCantidad(),fuenteBomba1X,
fuenteTempY, Graphics.LEFT | Graphics.BOTTOM);
//Seteo de Letras Temperatura Bomba de DesCarga
252
g.setColor(1,1,155);
Font fB2Temp =
Font.getFont(Font.FACE_SYSTEM,Font.STYLE_BOLD,Font.SIZE_MEDI
UM);
g.setFont(fB2Temp);
g.drawString(registroBombaDescarga.getCantidad(),fuenteBomba2X,
fuenteTempY, Graphics.LEFT | Graphics.BOTTOM);
}
private String estadoBomba(int numBomba, String tipoMonitoreo){
String estadoBomba="";
return estadoBomba;
}
//Función que genera la animación de llenado del tanque
private void llenarCisterna(){
if(registroBombaCarga.getEstado().compareTo("1")==0){
if (!llenando) {
llenando = true;
Sprite misil = new Sprite(image);
misil.setPosition(cisterna.getX()+2,cisterna.getY()+cisterna.getHeight()-2);
gotas.addElement(misil);
LM.insert(misil, 1);
}
// llenando= false;
}else{
//llenando= false;
}
//llenando = false;
for (int i = 0; i < gotas.size(); ++i) {
for (int j = 0; j < 2; ++j) {
Sprite misil = (Sprite)(gotas.elementAt(i));
if(misil.getX() == cisterna.getX()+2 || misil.getY() ==
cisterna.getY()+cisterna.getHeight()-2 ){
253
misil.move(0, -1);
}
if (misil.getY() < cisterna.getY()+cisterna.getHeight()-82 &&
misil.getX() <= cisterna.getX()+22){
misil.move(1, 0);
}
if(misil.getX() >= cisterna.getX()+22 &&
misil.getY() <= cisterna.getY()+cisterna.getHeight()-10){
misil.move(0,1);
}
if(misil.getY() == cisterna.getY()+cisterna.getHeight()-10
&& misil.getX()== cisterna.getX()+22){
gotas.removeElementAt(i);
LM.remove(misil);
//misil.move(1, 0);
i--;
llenando = false;
break;
}
}
}
}
//función que maneja el tiempo de las tareas predeterminadas
private class TestTimerTask extends TimerTask
{
public final void run()
{
//fmMain.append("run count: " + ++count + "\n");
//llenarCisterna();
}
}
}
ANEXO E
254
E.1 PROGRAMA DEL PIC 18F4550 //*******************************************************************
// Realizado por Universidad Politécnica Salesiana.
// Compilado con el PCW Compiler 4.057
// ******************************************************************
#include <18F4550.h>
#fuses
HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL3,CPUDIV1,V
REGEN
#use delay(clock=48000000)
#define USB_HID_DEVICE FALSE //Deshabilitamos el uso de las directivas
HID
#define USB_EP1_TX_ENABLE USB_ENABLE_BULK // Activa
EP1(EndPoint1) para las transferencias IN Bulk/Interrupt
#define USB_EP1_RX_ENABLE USB_ENABLE_BULK // Activa
EP1(EndPoint1) para las transferencias OUT Bulk/Interrupt
#define USB_EP1_TX_SIZE 8 // Tamaño reservado para el Buffer
Tx EndPoint1
#define USB_EP1_RX_SIZE 8 // Tamaño reservado para el Buffer
Rx EndPoint1
//===========================================================
#include <pic18_usb.h> // Microchip PIC18Fxx5x Hardware para el CCS PIC
USB Driver
#include <PicUSB.h> // Configuración del USB y los descriptores para este
dispositivo
#include <usb.c> // Handles usb ,tokens y descriptores
#define LED0 PIN_B7 // sensor 1
#define LED1 PIN_B6 // sensor 2
#define LED2 PIN_B5 // nivel bajo
#define LED3 PIN_B4 // nivel medio
#define LED4 PIN_B3 // nivel alto
255
#define LED5 PIN_B2 // confirma bomba1
#define LED6 PIN_B1 // confirma bomba 2
#define LED7 PIN_B0 //on / off general
#define entrada_0 envia[0] //
#define entrada_1 envia[1] //
#define entrada_2 envia[2] //
#define entrada_3 envia[3] //
#define entrada_4 envia[4] //
#define entrada_5 envia[5] //
#define entrada_6 envia[6] //
#define entrada_7 envia[7] //
#define LED_ON output_high // Salida en alto
#define LED_OFF output_low // Salida en bajo
#define modo recibe[0] // Byte que indica el modo de operación
#define param1 recibe[1] // Primer parámetro recibido
#define param2 recibe[2] // Segundo parámetro recibido
#define ENCIENDE_LED 1 // Modo de encender leds
#define APAGA_LED 2 // Modo de apagar leds
#define ENTRADAS 3 // Modo de leer las entradas
void main(void){ // Función Principal
int8 recibe[8]; // Declaramos la variable recibe de 8 bytes
int8 envia[8]; // Declaramos la variable envía de 8 bytes
LED_off(LED0);
LED_OFF(LED1);
LED_OFF(LED2);
LED_OFF(LED3);
LED_OFF(LED4);
LED_OFF(LED5);
LED_OFF(LED6);
LED_OFF(LED7);
set_tris_b(0x00); //pto b como salidas
usb_init(); // Inicializamos el USB
256
usb_task(); // Habilita el periférico USB y las interrupciones
usb_wait_for_enumeration(); // Esperamos hasta que el PicUSB sea configurado
por el PC
while (true){
if (input(PIN_A0)&& (usb_enumerated()) ){
led_off(led0);
led_on(Led1);
delay_ms (200);
led_on(Led0);
led_off(Led1);
delay_ms (400);
}
led_off(Led1);
if(usb_enumerated()) // Si el PicUSB está configurado
{
if (usb_kbhit(1)) // Si el EndPoint de salida contiene datos del PC
{
usb_get_packet(1, recibe, 8); // Cogemos el paquete de tamaño 8 bytes del
EP1
// y lo almacenamos en la variable recibe
if (modo==ENCIENDE_LED) // Modo Encender Leds
{
//if (param1==1) {LED_ON(LED0);} // Encendemos led 0
//if (param1==2) {LED_ON(LED1);} //
if (param1==3) {LED_ON(LED2);} //
if (param1==4) {LED_ON(LED3);} //
if (param1==5) {LED_ON(LED4);} //
if (param1==6) {LED_ON(LED5);} //
if (param1==7) {LED_ON(LED6);} //
if (param1==8) {LED_ON(LED7);} //
}
if (modo==APAGA_LED) // Modo Apaga Leds
{
257
//if (param1==1) {LED_OFF(LED0);} //
//if (param1==2) {LED_OFF(LED1);} //
if (param1==3) {LED_OFF(LED2);} //
if (param1==4) {LED_OFF(LED3);} //
if (param1==5) {LED_OFF(LED4);} //
if (param1==6) {LED_OFF(LED5);} //
if (param1==7) {LED_OFF(LED6);} //
if (param1==8) {LED_OFF(LED7);} //
}
if (modo==ENTRADAS) // Modo Entradas
{
entrada_0=input(PIN_D0); //
entrada_1=input(PIN_D1); //
entrada_2=input(PIN_D2); //
entrada_3=input(PIN_D3); //
entrada_4=input(PIN_D4); //
entrada_5=input(PIN_D5); //
entrada_6=input(PIN_D6); //
entrada_7=input(PIN_D7); //
usb_put_packet(1,envia,8,USB_DTS_TOGGLE); // Enviamos el
paquete de tamaño 8 bytes del EP1 al PC
}
}
}
}
}
E.2 PROGRAMA DEL PIC 16F877
258
; Programa General PIC 16F877A
; UNIVERSIDAD POLITECNICA SALESIANA.
; SISTEMA CONTROL INDUSTRIAL MOVIL.
; ----Oscar Santistevan-----Rubén Puma----Roger Córdova----;
Define ADC_BITS 8 ;Fije número de BITS del resultado (5,8,10)
Define ADC_CLOCK 3 ;Fije EL CLOCK (rc = 3)
Define ADC_SAMPLEUS 50 ;Fije el tiempo de muestreo en Us
;ADC_SAMPLEUS es el número de microsegundos que el programa espera
;entre fijar el canal y comenzar la conversión analógica/digital.
TRISA =%11111111 ;el puerto A es de entrada
TRISB =%00000000 ;el puerto B es de salida
TRISC =%01001111 ;C7..4 out, C3..0 in
TRISD =%11111101 ;el puerto D es de entrada
ADCON1 = %00000101;el puerto A.0,A.1 análogos--A.2 Dig--A.3 +Vref--A.4 Dig
;---Declaración de variables---
i var byte : k var byte
x var byte : y var byte
dato var BYTE ;dato para guardar temp1
dato2 var byte ;dato2 para guardar temp2
temp1 var byte ; temp1 inicial para comparar con dato
temp2 var byte ; temp2 inicial para comparar con dato2
; Declaro los nombres de los pines
;A.0 canal temp_1 ---------A.1 canal temp_2
;-----------------------------------------------------------------------
;-----------------------------------------------------------------------
Nivel_Bajo var portA.2 ;IN Nivel Bajo de la Cisterna
Nivel_Alto var portA.4 ;IN Nivel Alto de la Cisterna
Control_Sist_Total var portA.5 ;IN Encendido total del Sistema.
;---PUERTO B--- SALIDAS---
S_1 var portB.0 ;Indica tempertura alta de la bomba1, se conecta alarma1
S_2 var portB.1 ;Indica tempertura alta de la bomba2, se conecta alarma2
bomba1 var portB.2 ;Enciende bomba1
bomba2 var portD.1 ;Enciende bomb2
259
Tanque_LLeno var portB.4 ;Indica estado sensor Nivel_Alto
Tanque_Vacio var portB.6 ;Indica estado sensor Nivel_Bajo
On_Off_Sistema_Total var portB.7 ;habilita el sistema total
;---PUERTO C--- ENTRADAS Y SALIDAS---
Confirma_B1 var portC.0 ;IN confirmación ON de bomba_1 desde Sist Electrónico
Confirma_B2 var portC.1 ;IN confirmación ON de bomba_2 desde Sist Electrónico
On_Off_B1 var portC.2 ;IN confirmación encendido bomba_1 desde receptor
On_Off_B2 var portC.3 ;IN confirmación encendido bomba_2 desde receptor
Conf1_B1 var portC.4 ;Out conf. ON de B1 hacia Emisor
Conf2_B2 var portC.5 ;Out conf. ON de B2 hacia Emisor
Ok var portC.7 ;Out Indica estado del sistema
;-----------------------------------------------------------------------
reinicio var portD.0
temporal var word
temporal = 0
;-----------------------------------------------------------------------
INICIO:
portb=%00000000
low portc.4
low portc.5
low portc.7
;-----------------
low bomba2
;-----------------------------------------------------------------------
eeprom 0,[45,45] ;contenido inicial de la EEPROM
READ 0,temp1 ;lee la EEPROM 0 y lo guarda en temp1
READ 1,temp2 ;lee la EEPROM 1 y lo guarda en temp2
low ok
;-----------------------------------------------------------------------
Sensa1:
ADCIN 0, dato ;leer el canal 0 (A0) y guarde en dato
dato = dato /2 ;el dato dividir para 2
if dato > temp1 then Alarma1
260
Sensa2:
ADCIN 1, dato2 ;leer el canal 0 (A0) y guarde en dato
dato2 = dato2 /2 ;el dato dividir para 2
if dato2 > temp2 then Alarma2
;-----------------------------------------------------------------------
SistemaTotal:
if Control_Sist_Total=1 then inicializa
goto INICIO
;-----------------------------------------------------------------------
inicializa :
for x=1 to 1
LOW Ok
pause 100
HIGH Ok
pause 100
next
PAUSE 100
;-----------------------------------------------------------------------
;-----------------------------------------------------------------------
Control1:
high ON_Off_Sistema_Total
low S_1 ; Apago led_Alarma1
low S_2 ; Apago led_Alarma2
low Bomba1
low bomba2
Estado1:
if (Nivel_Bajo=0 or nivel_bajo=1) and temporal = 0 then AccionNivelBajo
if temporal = 1 then high TANQUE_VACIO
if temporal = 1 and nivel_bajo = 1 then Temp_vaciado
if Nivel_bajo=1 and nivel_alto=1 then AccionNivelAlto
goto Estado1
AccionNivelBajo:
if Nivel_Bajo=1 and nivel_Alto=1 then AccionNivelAlto
261
LOW TANQUE_VACIO
low Tanque_LLeno
low bomba2
low conf2_B2
if On_Off_B1 = 1 then ActivaB1
Goto AccionNivelBajo
ActivaB1:
high bomba1
if Confirma_B1 = 1 then Activa2_B1
goto ActivaB1
Activa2_B1:
pause 100
HIGH TANQUE_VACIO ; INDICO QUE EL TANQUE LLENANDO
high Conf1_B1
Sensar1:
ADCIN 0, dato ;leer el canal 0 (A0) y guarde en dato
dato = dato /2 ;el dato dividir para 2
for y = 1 to 2
if nivel_Alto=1 then AccionNivelAlto
pause 1
next
if dato > temp1 then Alarma1
goto Sensar1
Alarma1:
high S_1
low ok
goto Desactiva
Desactiva:
262
if Reinicio=1 then ApagaTotalS1
goto Desactiva
ApagaTotalS1:
low On_Off_Sistema_Total
low bomba1
low bomba2
LOW OK
goto finaliza
;-----------------------------------------------------------------------
Temp_vaciado:
temporal = 0
high tanque_vacio
low tanque_lleno
low bomba1
low conf1_B1
if On_Off_B2 = 1 then ActivaB2
Goto AccionNivelAlto
;-----------------------------------------------------------------------
AccionNivelAlto:
temporal = 0
high Tanque_LLeno
high tanque_vacio
low bomba1
low conf1_B1
if On_Off_B2 = 1 then ActivaB2
Goto AccionNivelAlto
ActivaB2:
high bomba2
if Confirma_B2 = 1 then Activa2_B2
goto ActivaB2
263
Activa2_B2:
pause 100
high Conf2_B2
Sensar2:
ADCIN 1, dato2 ;leer el canal 0 (A0) y guarde en dato
dato2 = dato2 /2 ;el dato dividir para 2
for y = 1 to 2
IF NIVEL_ALTO=0 THEN LOW TANQUE_LLENO
if Nivel_Bajo=0 then finaliza
pause 1
next
if dato2 > temp2 then Alarma2
goto Sensar2
Alarma2:
temporal = 1
high S_2
low ok
goto Desactiva
;-----------------------------------------------------------------------
Finaliza:
LOW TANQUE_VACIO
low bomba2
low conf2_b2
goto inicio
;-----------------------------------------------------------------------
End
E.2 PROGRAMA DEL PIC 16F870 (Celular)
264
@ device HS_OSC
DEFINE OSC 4
include "modedefs.bas"
text var byte
dat0 VAR BYTE
dat1 var byte
dat2 VAR BYTE
ini:
SEROUT2 portb.1,84,[13]
pause 300
SEROUT2 portb.1,84,["AT+CMGL=0",13]
PAUSE 300
uno:
SERIN2 portb.0,84,[dat0]
IF dat0="O" THEN INI
IF dat0="E" THEN INI
IF dat0!="O" THEN dos
PAUSE 300
dos:
SERIN2 portb.0,84, [wait(", ,"),DEC2 dat1]
IF dat1 = 27 then tres
IF dat1 <= 26 then SEIS
IF dat1 >= 28 then SEIS
PAUSE 300
tres:
Serin2 portb.0,84, [wait("097482141"),SKIP 5,dec2 dat2]
IF dat2 = 11 then CUATRO
if dat2 >=13 then seis
if dat2<= 10 then seis
IF dat2=12 then cinco
if dat2>=13 then seis
265
if dat2<=10 then seis
PAUSE 300
cuatro:
high portb.3
GOTO seis
PAUSE 300
cinco:
low portb.3
goto seis
pause 300
seis:
serout2 portb.1,84, [13]
PAUSE 300
serout2 portb.1,84, ["AT+CMGD=1",13]
pause 1000
goto ini
END
266
ANEXO F
Base de Datos
F.1 Introducción
Una base de datos es una colección de información organizada de forma que un programa de ordenador pueda seleccionar rápidamente los fragmentos de datos que necesite. Una base de datos es un sistema de archivos electrónico. Las bases de datos tradicionales se organizan por campos, registros y archivos. Un campo es una pieza única de información; un registro es un sistema completo de campos; y un archivo es una colección de registros. Por ejemplo, una guía de teléfono es análoga a un archivo. Contiene una lista de registros, cada uno de los cuales consiste en tres campos: nombre, dirección, y número de teléfono. Un Sistema Gestor de base de datos (SGBD) es un conjunto de programas que permiten crear y mantener una Base de datos, asegurando su integridad, confidencialidad y seguridad. Por tanto debe permitir:
Definir una base de datos: especificar tipos, estructuras y restricciones de datos.
Construir la base de datos: guardar los datos en algún medio controlado por el mismo
SGBD.
Manipular la base de datos: realizar consultas, actualizarla, generar informes.
Así se trata de un software de propósito general. Ejemplo de SGBD son Oracle y
SQL Server de Microsoft, Mysql( SGBD el cual se usará para el Proyecto de
Tópico).
Algunas de las características deseables en un Sistema Gestor de base de datos
SGBD son:
Control de la redundancia: La redundancia de datos tiene varios efectos negativos
(duplicar el trabajo al actualizar, desperdicia espacio en disco, puede provocar
inconsistencia de datos) aunque a veces es deseable por cuestiones de rendimiento.
F.2 Análisis
Se realizó un Análisis minucioso y profundo de los procesos que se debería tener en
el Sistema y se llegó al Siguiente Modelo Entidad Relación (MER).
267
F.3 Modelo Entidad-Relación
268
F.4 Dirección de Datos
Acciones
Registra las posibles acciones que se pueden realizar dentro del Sistema de Tanque elevado
apagado_general
Campo Tipo Nulo Predeterminado Clave Ejemplo
acc_id int(11) No - Primaria 1
apg_descripcion varchar(50) Sí - - Apagado general, apagado
bomba carga, apagado
bomba descarga
apg_estado varchar(1) Sí A - A/I
Campo Tipo Nulo Predeterminado Clave Ejemplo
apg_id int(11) No - Primaria 1
apg_descripcion varchar(50) Sí - - General
269
Guarda los estados de encendido y apagado general, tabla que se actualiza constantemente dependiendo de los eventos de la parte
electrónica o requerimientos de dispositivos móviles
Dispositivo
Registra los datos de los dispositivos que se usurarán en el Sistema
Campo Tipo Nulo Predeterminado Clave Ejemplo
dis_id int(11) No - Primaria 1
dis_descripcion varchar(50) No - - Tanque
dis_estado varchar(11) No A - A/I
logs
Registra quien realizó determinada acción, permitiendo llevar un control de todos los sucesos dentro del Sistema.
Campo Tipo Nulo Predeterminado Clave Ejemplo
logs_id int(11) No - Primaria 1
logs_user_id int(11) Sí NULL Foránea 1
apg_estado varchar(1) Sí A - A/I
270
logs_accion_id int(11) Sí NULL Foránea 1
logs_estado varchar(1) Sí NULL - 1 o 2
registro_mc
Registro del historial de todos los sucesos de los dispositivos en lo referente a los tipo de monitoreo y control ej.: estados de
encendido/apagado, niveles o temperatura
Campo Tipo Nulo Predeterminado Clave Ejemplo
rmc_id int(11) No - Primaria 1
rmc_dis_id int(11) Sí NULL Foránea 1
rmc_tmc_id int(11) Sí NULL Foránea 1
rmc_cantidad int(11) Sí NULL - estados de
temperatura,
niveles de
tanque
rmc_estado_on_off varchar(1) Sí NULL - 1 o 2
271
rmc_estado_confirmacion varchar(1) Sí NULL - 1 o 2
temporal
Cumple las mismas funciones de la tabla de registro con la particularidad que esta va a ser accedida por los dispositivos móviles por la
razón que solo va a registrar los datos actuales, es decir cada vez que se cumpla un ciclo de llenado y vaciado esta tabla será vaciada los
registros teniendo así solo temporalmente los registros actuales dentro del Sistema.
Campo Tipo Nulo Predeterminado Clave Ejemplo
tmp_id int(11) No - Primaria 1
tmp_dis_id int(11) Sí NULL Foránea 1
tmp_tmc_id int(11) Sí NULL Foránea 1
tmp_cantidad int(11) Sí NULL - estados de
temperatura,
niveles de
tanque
tmp_estado_on_off varchar(1) Sí NULL - 1 o 2
tmp_estado_confirmacion varchar(1) Sí NULL - 1 o 2
272
Tanque
Registra los niveles del tanque elevado de manera eventual
Campo Tipo Nulo Predeterminado Clave Ejemplo
tan_id int(11) No - Primaria 1
tan_dis_id int(11) Sí NULL Foránea 1
ta_descripcion varchar(50) Sí NULL - Tanque1
tan_nivel1 varchar(1) Sí NULL - 1
tan_nivel2 varchar(1) Sí NULL - 1
tan_nivel3 varchar(1) Sí NULL - 1
tan_tiempo varchar(50) Sí NULL - 2
tipo_mc
registra los tipo de monitoreo y control ej.: estado encendido/apagado, temperatura
Campo Tipo Nulo Predeterminado Clave Ejemplo
tmc_id int(11) No - Primaria 1
273
tmc_descripcion varchar(50) No - - Temperatura/Nivel
tmc_estado varchar(1) No A - A
Usuario.-Registro de los usuarios que usarán el sistema
Campo Tipo Nulo Predeterminado Clave Ejemplo
usu_id int(11) No - Primaria 1
usu_nombres varchar(50) Sí - - Oscar
usu_apellidos varchar(50) Sí - - Santistevan
usu_direccion varchar(50) Sí - - Cdla.
Montebello
usu_telefono varchar(10) Sí - - 096439657
usu_fechaNacimiento date Sí NULL - 12/03/85
usu_cedula varchar(10) Sí - - 0924101835
usu_password varchar(50) Sí - - 123
274
usu_estado var(1) Sí - A/I
ANEXO G
Diagramas
G.1 Diagramas DFD
Monitoreo
Requerimiento de Autenticación
A
Monitoreo
Verificación
de Usuario Pantalla de
Bienvenida
Verificación de Estado:
Bomba Carga Bomba Descarga Nivel de Tanque
R
Reporte
Gráfico
Chat Cliente
Registro
verificado
Petición de
monitor
Entrega de
datos
Monitoreo
275
Técnico
G1.2 Control de Dispositivos
Base de Datos
Petición de
apagado
Base de Datos
Verificación
de Usuario
Socket en estado
escucha
Chat Server
Apagado
manual de
dispositivos
Apagado del sistema
general.
Esperando
conexión
Registro
verificado
Verificación
de Usuario
Pantalla de bienvenida
Control del
dispositivo
Verificación
de estado de
dispositivos
Encendido.
Bomba Carga.
Bomba Descarga.
Apagado General.
Petición de
estado
Petición de
control
Registro
verificado
A
Control
Registro
Selección de
la acción
276
G.2 Diagramas IPO
Entrada
Ingreso de datos user y password para validación
Archivos de usuarios
Proceso
Autentificación Usuario
Monitoreo dispositivos
Control dispositivos
Salida
Reporte gráfico monitoreo
Encender: Bomba carga, bomba descarga.Apagado general.
Archivo de dispositivos
Mensaje de bienvenida a
usuarios
277
G2.1 Diagrama IPO Detallado Monitoreo
Entrada
Monitoriar
Archivos de dispositivos
ProcesoVerificar estado.
Dsipositivos on/off, temperatura.Nivel de tanque
Llamar Web Service (WS)Consultar Dispositos
Manipular XML file
Salida
Reporte gráfico de dispositivos:
Nivel del Tanque.Estado on/off de las bombas.Alertas de temperatura.
278
G2.2 Diagrama IPO Detallado Control
Entrada
Control
Archivos de dispositivos
ProcesoVerificar estado.
Dsipositivos on/off, temperatura.
Nivel de tanque
Llamar Web Service (WS)Actualizar estados de Dispositos
Salida
Encerder bombas carga, descarga.Apagado general
279
G2.3 Diagrama IPO Detallado Chat
Entrada
Monitorear
Controlar
Proceso
Iniciar semilla de chat.(Técnico de Planta)
Inicia cliente de chat.(Jefe de Planta)
Salida
Apagado manual de dispositivos.
280
G.3 Diagramas de Jerarquía
Sistema de Monitoreo y
Control
Monitoreo
Autenticar Usuario Dispositivo
Control
Autenticar Usuario
Encendido de Bombas
Apagado General
281
ANEXO H
COSTOS H.1 Costo materiales eléctricos de maqueta y tubería
Materiales de Eléctricos de Maqueta y tubería.
20,00%
Descripción de Producto. Marca Costo Unit. P. Unit. Cantidad Unidad
Costo Total
Precio Total.
Envases de CD´s IMATION $0,80 $1,00 2 U $1,60 $2,00 Rieles de hierro GENÉRICO $2,00 $2,50 1 U $2,00 $2,50 Neplo pequeños GENÉRICO $0,50 $0,63 2 U $1,00 $1,25 Cinta Teflon GENÉRICO $0,50 $0,63 1 U $0,50 $0,63 Codo PLASTIGAMA $0,65 $0,81 1 U $0,65 $0,81 Sellante de Tubo GENÉRICO $2,50 $3,13 1 U $2,50 $3,13 Fungibles (brocas, lijas, etc.) GENÉRICO $5,50 $6,88 2 U $11,00 $13,75 Canaletas plasticas 2" GENÉRICO $3,00 $3,75 3 U $9,00 $11,25 Cable UTP categoría #5 NOGANET $0,60 $0,75 2 Mts. $1,20 $1,50 Borneras GENÉRICO $1,00 $1,25 3 U $3,00 $3,75 Sensores de Nivel GENÉRICO $1,00 $1,25 3 U $3,00 $3,75 Pulsante Marcha-Paro Bombas GENÉRICO $1,00 $1,25 2 U $2,00 $2,50
Subtotal. 1 $37,45 $46,81
282
H.2 Costos componentes electrónicos
Materiales electrónicos
20,00%
Descripción de Producto. Marca C.U: P. Unit. Cantidad Unidad Costo Total
Precio Total.
PIC 18F4550 MICROCHIP $15,00 $18,75 1 U $15,00 $18,75 PIC 16F877A MICROCHIP $10,00 $12,50 1 U $10,00 $12,50 PIC 16F870 MICROCHIP $8,00 $10,00 1 U $8,00 $10,00 HT-12D HOLTEK $6,00 $7,50 3 U $18,00 $22,50 HT-12E HOLTEK $6,00 $7,50 3 U $18,00 $22,50 TWS-434 N/A $7,00 $8,75 3 U $21,00 $26,25 RWS-434 N/A $7,00 $8,75 3 U $21,00 $26,25 LM-35 NATIONAL SEMICONDUCTOR $4,50 $5,63 2 U $9,00 $11,25 LM-358 NATIONAL SEMICONDUCTOR $1,25 $1,56 2 U $2,50 $3,13 74LS73 TEXAS INSTRUMENTS $0,50 $0,63 1 U $0,50 $0,63 LM-555 NATIONAL SEMICONDUCTOR $0,65 $0,81 1 U $0,65 $0,81 74LS32 FAIRCHILD SEMICONDUCTOR $0,50 $0,63 1 U $0,50 $0,63 74LS86 FAIRCHILD SEMICONDUCTOR $0,50 $0,63 1 U $0,50 $0,63 Relay 5 voltios (2 comues-4 contactos) GENÉRICO $2,00 $2,50 3 U $6,00 $7,50 Conector USB GENÉRICO $1,20 $1,50 1 U $1,20 $1,50 Capacitor 22pf GENÉRICO $0,15 $0,19 2 U $0,30 $0,38 Cristal 4Mhz GENÉRICO $0,70 $0,88 1 U $0,70 $0,88 Resistencias GENÉRICO $0,05 $0,06 25 U $1,25 $1,56 Celular 3220 NOKIA $51,50 $64,38 1 U $51,50 $64,38 Diodos led GENÉRICO $0,10 $0,13 10 U $1,00 $1,25 LM-317 NATIONAL SEMICONDUCTOR $0,65 $0,81 2 U $1,30 $1,63 Potenciómetro 5k GENÉRICO $0,40 $0,50 2 U $0,80 $1,00 Puente diodos N/A $0,80 $1,00 2 U $1,60 $2,00
283
Transistor potencia TIP-42 NATIONAL SEMICONDUCTOR $0,85 $1,06 1 U $0,85 $1,06 Transistor 2N3906 NATIONAL SEMICONDUCTOR $0,26 $0,33 1 U $0,26 $0,33 Motores Eléctricos (Bombas) GENÉRICO $3,00 $3,75 3 U $9,00 $11,25 Cristal 12Mhz GENÉRICO $0,70 $0,88 1 U $0,70 $0,88 Tarjetas Impresas PC-USB N/A $15,00 $18,75 1 U $15,00 $18,75 Tarjetas Impresas Sist. A controlar N/A $30,00 $37,50 1 u $30,00 $37,50 Varios (Utilerías) N/A $30,00 $37,50 1 U $30,00 $37,50
Subtotal. 2 $276,11 $345,14
284
H.3 Costo Total
Mano de obra 20,00% Descripción de Producto. Marca C.U P. Unit. Cantidad Unidad Costo
Total Precio Total.
Desarrollo de Ingeniería AUTORES $ 5,00 6,25 300 Horas $1.500,00 $1.875,00 Desarrollo de Maqueta AUTORES $ 2,00 2,50 20 Horas $40,00 $50,00 Subtotal. 3 $1.540,00 $1.925,00
Costos indirectos 20,00% Descripción de Producto. Marca C.U P. Unit. Cantidad Unidad Costo
Total Precio Total.
Documentación del proyecto N/A 25,00 31,25 3 $75,00 $93,75 Movilización de los autores N/A 3,00 3,75 100 $300,00 $375,00 Alimentación N/A 2,00 2,50 100 $200,00 $250,00 Varios N/A 1,00 1,25 50 $50,00 $62,50 Subtotal. 4 $625,00 $781,25
CONSOLIDADO Materiales de Eléctricos de Maqueta y tubería.
$37,45 $46,81
Materiales electrónicos $276,11 $345,14 Mano de obra $1.540,00 $1.925,00 Costos indirectos $625,00 $781,25 Precios no incluyen IVA TOTAL PROYECTO $2478,56 $2098,20 LICENCIA VISUAL STUDIO PROFESIONAL V 6.0 $200,00
LICENCIA MEASUREMENT STUDIO 8.5 $1.250,00 COSTO DEL PROYECTO PARA SU COMERCIALIZACIÓN $4.548,20
285
5.1 GLOSARIO.
HARDWARE
ASCII: es un código de caracteres basado en el alfabeto latino tal como se usa en
inglés moderno y en otras lenguas occidentales
BIOS: El sistema Básico de entrada/salida, es un software muy básico instalado en la
placa base que permite que ésta cumpla su cometido. Proporciona la comunicación
de bajo nivel, el funcionamiento y configuración del hardware del sistema que, como
mínimo, maneja el teclado y proporciona salida básica (emitiendo pitidos
normalizados por el altavoz de la computadora si se producen fallos) durante el
arranque.
EEPROM: Es un tipo de memoria ROM que puede ser programado, borrado y
reprogramado eléctricamente, a diferencia de la EPROM que ha de borrarse
mediante rayos ultravioletas. Aunque una EEPROM puede ser leída un número
ilimitado de veces, sólo puede ser borrada y reprogramada entre 100.000 y 1.000.000
de veces.
HDX: significa que el método o protocolo de envío de información es bidireccional
pero no simultáneo.
ISO: Organización Internacional para la Estandarización (ISO) investigó modelos de
conexión como la red de Digital Equipment Corporation (DECnet), la Arquitectura
de Sistemas de Red (SNA) y TCP/IP a fin de encontrar un conjunto de reglas
aplicables de forma general a todas las redes. Con base en esta investigación, la ISO
desarrolló un modelo de red que ayuda a los fabricantes a crear redes que sean
compatibles con otras redes. LF
MHz: Es una unidad de medida de frecuencia. Recordando que frecuencia es una
medida para indicar el número de repeticiones de cualquier fenómeno o suceso
periódico en una unidad de tiempo
MS-DOS: Sistema operativo de disco de Microsoft. Es un sistema operativo
comercializado por Microsoft perteneciente a la familia DOS. Fue un sistema
operativo para el IBM PC que alcanzó gran difusión
286
PC: También denominada como ordenador o computador, es una máquina
electrónica que recibe y procesa datos para convertirlos en información útil. Una
computadora es una colección de circuitos integrados y otros componentes
relacionados que puede ejecutar con exactitud, sorprendente rapidez, y de acuerdo a
lo indicado por un usuario o automáticamente por otro programa, una múltiple
variedad de secuencias o rutinas de instrucciones que son ordenadas, organizadas y
sistematizadas en función a una amplia gama de aplicaciones prácticas y
precisamente determinadas
PIC: El nombre completo es PICmicro, aunque generalmente se utiliza como
Peripheral Interface Controller (Controlador de Interfaz Periférico)
RAM: La memoria de acceso aleatorio, o memoria de acceso, se compone de uno o
más chips y se utiliza como memoria de trabajo para programas y datos. Es un tipo
de memoria temporal que pierde sus datos cuando se queda sin energía (por ejemplo,
al apagar la computadora), por lo cual es una memoria volátil
ROM: Es una memoria de semiconductor destinada a ser leída y no destructible, es
decir, que no se puede escribir sobre ella y que conserva intacta la información
almacenada, incluso en el caso de que se interrumpa la corriente (memoria no
volátil). La ROM suele almacenar la configuración del sistema o el programa de
arranque de la computadora.
RS-232 : Es una interfaz que designa una norma para el intercambio serie de datos
binarios entre un DTE (Equipo terminal de datos) y un DCE (Data Communication
Equipment, Equipo de Comunicación de datos), aunque existen otras situaciones en
las que también se utiliza la interfaz RS-232.
SMS: Son las iníciales de Short Messages Standard o lo que es lo mismo: sistema de
mensajes cortos sin hilos. Se trata de una tecnología europea que apareció en 1991 en
nuestro continente, donde también nació la tecnología digital sin hilos que fue
bautizada GSM, Global Standard for Mobiles o patrón global para móviles
USB: Conductor Universal en Serie es un puerto que sirve para conectar periféricos a
una computadora, El estándar incluye la transmisión de energía eléctrica al
dispositivo conectado. Algunos dispositivos requieren una potencia mínima, así que
se pueden conectar varios sin necesitar fuentes de alimentación extra
287
Wi-Fi: Es un sistema de envío de datos sobre redes computacionales que utiliza
ondas de radio en lugar de cables.
WLAN: Es un sistema de comunicación de datos inalámbrico flexible, muy utilizado
como alternativa a las redes LAN cableadas o como extensión de éstas. Utiliza
tecnología de radiofrecuencia que permite mayor movilidad a los usuarios al
minimizar las conexiones cableadas.
FIRMWARE
ADO: Conjunto de objetos COM para el acceso a recursos de datos. Prevé una capa
entre los lenguajes de programación y las base de datos OLE, lo que permite a los
programadores escribir programas que accedan a datos, sin saber cómo está
implementada la base de datos (sólo se debe tener cuidado en la conexión a la
misma). Tampoco es necesario conocer sobre SQL cuando se usa ADO, aunque
también pueden utilizarse comandos SQL, pero esto crearía en el programa una
dependencia del tipo de base de datos usado.
DAQ: La Adquisición de Datos es la toma de muestras del mundo real para generar
datos que pueden ser manipulados por un ordenador. Consiste en tomar un conjunto
de variables físicas, convertirlas en tensiones eléctricas y digitalizarlas de manera
que se puedan procesar en una computadora o PAC. Se requiere una etapa de
acondicionamiento que adecua la señal a niveles compatibles con el elemento que
hace la transformación a señal digital. El elemento que hace dicha transformación es
el módulo o tarjeta de Adquisición de Datos (DAQ).
HTML: Es el lenguaje de marcado predominante para la construcción de páginas
web. Es usado para describir la estructura y el contenido en forma de texto, así como
para complementar el texto con objetos tales como imágenes. HTML se escribe en
forma de "etiquetas", rodeadas por corchetes angulares (<,>). HTML también puede
describir, hasta un cierto punto, la apariencia de un documento, y puede incluir un
script (por ejemplo Javascript), el cual puede afectar el comportamiento de
navegadores web y otros procesadores de HTML
288
IDE: Controla los dispositivos de almacenamiento masivo de datos, como los discos
duros y ATAPI (Advanced Technology Attachment Packet Interface) y además
añade dispositivos como las unidades CD-ROM.
ODBC: Si escribimos una aplicación para acceder a las tablas de una DB de Access,
¿qué ocurrirá si después queremos que la misma aplicación, y sin reescribir nada,
utilice tablas de SQL Server u otra DB cualquiera? La respuesta es sencilla: no
funcionará. Nuestra aplicación, diseñada para un motor concreto, no sabrá dialogar
con el otro. Evidentemente, si todas las DB funcionaran igual, no tendríamos este
problema.... aunque eso no es probable que ocurra nunca.
SOFTWARE
APIs: es el conjunto de funciones y procedimientos (o métodos si se refiere a
programación orientada a objetos) que ofrece cierta biblioteca para ser utilizado por
otro software como una capa de abstracción.
J2ME: La plataforma J2ME es una familia de especificaciones que definen varias
versiones minimizadas de la plataforma Java 2; estas versiones minimizadas pueden
ser usadas para programar en dispositivos electrónicos; desde teléfonos celulares, en
PDAs, hasta en tarjetas inteligentes, etc. Estos dispositivos presentan en común que
no disponen de abundante memoria ni mucha potencia en el procesamiento, ni
tampoco necesitan de todo el soporte que brinda el J2SE, (la plataforma estándar de
Java usada en sistemas de escritorio y servidor)
JSP: Son las iníciales de Java Server Pages, en español significa Páginas de Servidor
Java. En sí es una tecnología orientada a crear páginas web con programación en
Java
KVM: Es una solución para implementar virtualización completa con Linux sobre
hardware x86. Está formada por un módulo del núcleo (con el nombre kvm.ko) y
herramientas en el espacio de usuario, siendo en su totalidad software libre. El
componente KVM para el núcleo está incluido en Linux desde la versión 2.6.20.
KVM permite ejecutar máquinas virtuales utilizando imágenes de disco que
contienen sistemas operativos sin modificar.
289
PDA: Es un computador de mano originalmente diseñado como agenda electrónica
(calendario, lista de contactos, bloc de notas y recordatorios) con un sistema de
reconocimiento de escritura. Hoy día se puede usar como una computadora
doméstica (ver películas, crear documentos, juegos, correo electrónico, navegar por
Internet, reproducir archivos de audio, etc.).
VMD: Es una interfaz gráfica dentro de NetBeans Mobility que le permite diseñar
aplicaciones móviles usando arrastrar y soltar los componentes. El VMD le permite
definir la aplicación de flujo y el diseño de su interfaz gráfica utilizando los
componentes suministrados por el IDE, o componentes que usted mismo diseño, El
VMD contiene muchas estándar de interfaz de usuario (UI) componentes que puede
utilizar para crear aplicaciones como listas, Alertas, formas e imágenes
UML: Es el lenguaje de modelado de sistemas de software más conocido y utilizado
en la actualidad; está respaldado por el OMG (Object Management Group). Es un
lenguaje gráfico para visualizar, especificar, construir y documentar un sistema de
software. UML ofrece un estándar para describir un "plano" del sistema (modelo),
incluyendo aspectos conceptuales tales como procesos de negocios y funciones del
sistema, y aspectos concretos como expresiones de lenguajes de programación,
esquemas de bases de datos y componentes de software reutilizables.
WEP: Es el sistema de cifrado incluido en el estándar IEEE 802.11 como protocolo
para redes Wireless que permite cifrar la información que se transmite. Proporciona
un cifrado a nivel 2. Está basado en el algoritmo de cifrado RC4, y utiliza claves de
64 bits (40 bits más 24 bits del vector de iniciación IV) o de 128 bits (104 bits más
24 bits del IV). Los mensajes de difusión de las redes inalámbricas se transmiten por
ondas de radio, lo que los hace más susceptibles, frente a las redes cableadas, de ser
captados con relativa facilidad. Presentado en 1999, el sistema WEP fue pensado
para proporcionar una confidencialidad comparable a la de una red tradicional
cableada.
XML: Es un metalenguaje extensible de etiquetas desarrollado por el World Wide
Web Consortium (W3C). Es una simplificación y adaptación del SGML y permite
definir la gramática de lenguajes específicos (de la misma manera que HTML es a su
vez un lenguaje definido por SGML). Por lo tanto XML no es realmente un lenguaje
en particular, sino una manera de definir lenguajes para diferentes necesidades.
290
5.2 VOCABULARIO
HARDWARE
ASCII (American Standard Code for Information Interchange,)
AWG (American Wire Gauge)
BIOS (Basic Input Output System
BSAP (Bristol Synchronous/Asynchronous Protocol
BSC (Binary Synchronous Communications)
CTI (Computer Telephony Integrations)
CTS (Clear To Send)
DDCMP (Digital Data Communication Message Protocol
DSR (Data Set Ready)
DTR (Data Terminal Ready)
ECP (Extended Capability Port)
EEPROM (Electrically Erasable Programmable Read Only Memory
EPP (Enhanced Parallel Port)
HART (Highway Addressable Remote Transducer)
HDLC (High-Level Data Link Control Protocol)
HDX (Half Duplex)
HF (Higth Frecuency)
HNP (Host Negotiation Protocol)
HSSI (High Speed Serial Interface)
HT12D (Decodificador asociado Holtek)
IBM (International Business Machines)
ISO/OSI (International Standards Organization/ Open Systems Interconnection)
LF (Low Frecuency)
MF (Medium Frecuencia)
MHz (Mega Hertz)
MS-DOS (System Operator Dir – Microsoft)
MTU (Master Terminal Unit)
PC (Personal Computer)
PIC (Peripheral Interface Controller)
PS/2 (Port Serial Bidireccional)
RAM (Random Access Memory)
291
ROM (Read Only Memory)
RS-232 (Modo de comunicación vía serial)
RTS (Request to Send)
RTU (Unidades remotas de transmisión)
SMS (Small Message)
TE (Transmission Enable)
UART (Transmisor-Receptor-Asíncrono Universal
UHCI (Universal Host Controller Interface)
USB (Universal Series Bus)
VT (Valid Transmission )
Wi-Fi (Wireless Fidelity)
WLAN (Wireless Local Area Network)
FIRMWARE
ADO (Active Data Object)
DAQ (Data Adquision Quality)
HTML (HyperText Markup Language)
IDE (Integrated Device Electronics)
ODBC (Open Database Connectivity)
SOFTWARE
APIs (Application Program Interface)
CLDC (Connected Limited Device Configuration)
J2ME (Java 2 Edición micro)
JSP (Java Server Page)
KVM (Kernel-based Virtual Machine)
MIDP (Mobile Information Device Profile)
PIM (Protocol Independent Multicast)
PDA (Personal Digital Assintant),
VMD (Visual Designer Mobile)
UML (Unified Modeling Language)
WEP (Wired Equivalent Privacy)
WSDL (Web Services Description Language)
XML (Extensible Markup Language)