PONTIFICIA UNIVERSIDAD CATÓLICA DEL ECUADOR SEDE SANTO DOMINGO Dirección Académica – Escuela de Ingeniería en Sistemas PORTADA
PROYECTO DE DISERTACIÓN DE GRADO Prototipo de Semáforos Inteligentes
Disertación de grado previa a la obtención del título de Ingeniero de Sistemas y Computación
Línea de Investigación: Estudio, Diseño y Prototipado de Hardware y Software. AUTOR: GERARDO IVÁN SOTOMAYOR IBARRA DIRECTOR: Mg. MILTON TEMISTOCLES ANDRADE SALAZAR
SANTO DOMINGO – ECUADOR Septiembre 2014
PONTIFICIA UNIVERSIDAD CATÓLICA DEL ECUADOR SEDE SANTO DOMINGO
Dirección Académica – Escuela de Ingeniería en Sistemas
HOJA DE APROBACIÓN Prototipo de Semáforos Inteligentes
Línea de Investigación: Estudio, Diseño y Prototipado de Hardware y Software. AUTOR: Gerardo Iván Sotomayor Ibarra.
Milton Temístocles Andrade Salazar, Mg.
F. ______________________
DIRECTOR DE LA DISERTACIÓN DE GRADO
Ángel Ramiro Hurtado Hurtado, Ing.
F. ______________________
CALIFICADOR
Fausto Ernesto Orozco Iguasnia, Ing.
F. ______________________
CALIFICADOR
Rodolfo Sirilo Córdova Gálvez, Mg.
F. ______________________
DIRECTOR DE LA ESCUELA DE SISTEMAS
SANTO DOMINGO – ECUADOR Septiembre 2014
iii
DECLARACIÓN DE AUTENTICIDAD
Yo, Gerardo Iván Sotomayor Ibarra portador de ciudadanía Nº. 171888828-0 declaro que los resultados obtenidos en la investigación que presento como informe final, previo la obtención del Grado de Ingeniero en sistemas son absolutamente originales, auténticos y personales. En tal virtud, declaro que el contenido, las conclusiones y los efectos legales y académicos que se desprendan del trabajo propuesto de investigación y luego de la redacción de este documento son y serán de mi sola y exclusiva responsabilidad legal y académica.
Gerardo Iván Sotomayor Ibarra CI. 1718888280-0
iv
DEDICATORIA
En memoria a mi hermana Andrea Carolina, quien en vida me supo inspirar a ser mejor cada día, para ser digno ejemplo a seguir. A mi madre Guadalupe Isabel, abuela Dominga Gertrudis y tía Sara de Jesús por su incondicional apoyo brindado en mi formación personal y académica. A mi hijo Eduardo Iván, esposa Sara Katherine y hermana Karen Jessenia que son mi mayor inspiración, fuente de energía y vida.
v
AGRADECIMIENTO
Agradezco al apoyo que mi familia me ha sabido brindar durante todo este tiempo, a los docentes que se esmeraron en fomentar las bases para formarme como un excelente profesional y a mis incondicionales amigos por el apoyo y compaĂąĂa en cada uno de los momentos alegres y cruciales vividos durante estos aĂąos.
vi
RESUMEN
Actualmente en la ciudad de Santo Domingo es necesario el uso de tecnología actualizada que permita centralizar el control de los semáforos, permitiendo una configuración mediante el uso de una aplicación que permita este control, además de brindar datos del crecimiento del parque automotor para la toma de decisiones en el redireccionamiento del tránsito vehicular. El desarrollo del prototipo de semáforos inteligentes contiene la solución a estas necesidades, mediante el uso de bases de datos, una aplicación de escritorio y el uso de una placa electrónica. Primero se programó una aplicación para el micro controlador de la placa Arduino Due utilizando la plataforma de desarrollo Arduino, que a su vez se basa de java. Con esta programación en el micro controlador, se controla los pulsadores que detectan la cantidad de vehículos en la intersección y el encendido de las luces de los semáforos. Luego se desarrolló una aplicación en Netbeans, que permita al usuario controlar los semáforos mediante una interfaz amigable y sencilla, junto con el uso de MySQL como gestor de base de datos para el almacenamiento de los datos receptados y de configuración. Por último, se utilizó una maqueta para representar una intersección entre dos calles con dos carriles cada una, en la cual se controle el tránsito vehicular en sentido norte-sur, sur-norte, este-oeste y oeste-este.
vii
ABSTRAC
Nowadays in the Santo Domingo City, it is necessary to use updated technology to centralize control of traffic lights, allowing a configuration through an application that contributes this control, in addition to providing data for fleet growth in order to take necessary decisions to reroute traffic. The development of intelligent traffic lights prototype contains the solution to these needs, using databases, a desktop application and use of an electronic board. First, an application for micro controller Arduino Due using the Arduino development platform was programmed, which in turn is based on java. With this programming in the micro controller, the buttons that detect the number of vehicles in the intersection and on the traffic lights are controlled. After that, an application in Netbeans was develoed, allowing the user to control the traffic lights by a friendly and simple interface, along with the use of MySQL as database manager for storing data and configuration. Finally, a mockup was used to represent an intersection of two streets with two lanes each, in which the vehicular traffic on north-south, south-north, east-west and west-east is controlled.
viii
TABLA DE CONTENIDOS PORTADA................................................................................................................................ i HOJA DE APROBACIÓN .......................................................................................................ii DECLARACIÓN DE AUTENTICIDAD ................................................................................iii DEDICATORIA ...................................................................................................................... iv AGRADECIMIENTO ..............................................................................................................v RESUMEN .............................................................................................................................. vi ABSTRAC .............................................................................................................................. vii TABLA DE CONTENIDOS ................................................................................................. viii TABLA DE GRÁFICOS ........................................................................................................ xii 1.
INTRODUCCIÓN A LA DISERTACIÓN DE GRADO ........................................... 1
2.
PLANTEAMIENTO DEL PROBLEMA..................................................................... 3 Antecedentes ............................................................................................................... 3
2.1. 2.1.1.
Funcionamiento, Tecnología y Repuestos ............................................................ 3
2.1.2.
Asignación de Tiempos y Desfases ........................................................................ 3
2.1.3.
Semáforos Inteligentes ........................................................................................... 4
2.2.
Problema de Investigación ........................................................................................ 5
2.3.
Justificación ................................................................................................................ 5
2.4.
Objetivos ..................................................................................................................... 7
2.4.1.
Objetivo General .................................................................................................... 7
2.4.2.
Objetivos Específicos ............................................................................................. 7
3.
MARCO REFERENCIAL ............................................................................................ 8
3.1.
Revisión de la literatura o fundamentos teóricos .................................................... 8
3.1.1.
Flujo Vehicular....................................................................................................... 8
3.1.2.
Horas Pico ............................................................................................................... 8
3.1.3.
Tránsito Vehicular ................................................................................................. 8
3.1.4.
Congestión Vehicular............................................................................................. 8
3.1.5.
El Semáforo ............................................................................................................ 9
3.1.6.
Corriente Eléctrica............................................................................................... 11
3.1.7.
Circuito Eléctrico ................................................................................................. 11
3.1.8.
Tipos de Circuitos Eléctricos .............................................................................. 11
3.1.8.1.
Circuitos en Serie ............................................................................................. 11
3.1.8.2.
Circuitos en Paralelo........................................................................................ 12
ix
3.1.9.
Sensores................................................................................................................. 12
3.1.10.
Pulsadores ............................................................................................................. 13
3.1.11.
Resistencias Eléctricas ......................................................................................... 13
3.1.12.
LED (Light Emitting Diode, Diodo Emisor de Luz) ......................................... 14
3.1.13.
Sistemas Micro Programables ............................................................................ 15
3.1.13.1.
Lógica Cableada (Hardware) .......................................................................... 15
3.1.13.2.
Lógica Programada (Software)....................................................................... 16
3.1.14.
Clasificación de los Sistemas Micro Programables ........................................... 16
3.1.14.1.
Microprocesadores ........................................................................................... 16
3.1.14.2.
Microcontroladores .......................................................................................... 17
3.1.14.3.
Dispositivos Lógicos Programables (PLD)..................................................... 18
3.1.15.
Arquitectura de un Sistema Basado en CPU (Unidad Central de Proceso) ... 18
3.1.15.1.
Reloj .................................................................................................................. 19
3.1.15.2.
Unidad Central de Proceso o CPU ................................................................. 19
3.1.15.3.
Memoria Central o Interna ............................................................................. 19
3.1.15.4.
Unidad de entrada/salida (interface) .............................................................. 19
3.1.15.5.
Periféricos ......................................................................................................... 20
3.1.16.
Sistemas Embebidos............................................................................................. 20
3.1.17.
Arduino ................................................................................................................. 21
3.1.18.
Arduino DUE ........................................................................................................ 23
3.1.19.
Partes elementales de la placa ............................................................................. 24
3.1.19.1.
Reset .................................................................................................................. 24
3.1.19.2.
Conector de Alimentación ............................................................................... 24
3.1.19.3.
SPI Interfaz Serial de Periféricos ................................................................... 25
3.1.19.4.
Microcontrolador ............................................................................................. 25
3.1.19.5.
Pines .................................................................................................................. 25
3.1.19.5.1.
Análogo ......................................................................................................... 26
3.1.19.5.2.
Digital ............................................................................................................ 26
3.1.19.6.
Puerto de Programación .................................................................................. 26
3.1.19.7.
Puerto Nativo .................................................................................................... 26
3.1.20.
Arquitectura de Microcontroladores ................................................................. 27
3.1.21.
Software ................................................................................................................ 28
3.1.21.1.
Software de Sistemas ....................................................................................... 29
x
3.1.21.2.
Software de Desarrollo .................................................................................... 29
3.1.21.3.
Software de Red ............................................................................................... 29
3.1.21.4.
Software de Aplicación .................................................................................... 29
3.1.21.5.
Otros .................................................................................................................. 30
3.1.22.
Software Libre ...................................................................................................... 30
3.1.23.
Entorno de Desarrollo Integrado........................................................................ 30
3.1.23.1.
JDeveloper Studio ............................................................................................ 31
3.1.23.2.
Visual Studio..................................................................................................... 31
3.1.23.3.
NetBeans IDE ................................................................................................... 31 Modelos de Desarrollo de software..................................................................... 32
3.1.24. 3.1.24.1.
Modelo en Lineal o en Cascada ...................................................................... 32
3.1.24.2.
Modelo Espiral ................................................................................................. 33
3.1.24.3.
Modelo Prototipado o de Prototipos ............................................................... 33
3.1.25.
Base de Datos ........................................................................................................ 34
3.1.26.
Ejemplo de Sistemas de Base de Datos............................................................... 35
3.1.26.1.
Oracle ................................................................................................................ 35
3.1.26.2.
PostgreSQL ....................................................................................................... 35
3.1.26.3.
MySQL .............................................................................................................. 36
3.2. Investigaciones o experiencias empíricas vinculadas con el problema de investigación ......................................................................................................................... 36 Hipótesis de Trabajo ................................................................................................ 38
3.3. 4.
METODOLOGÍA DE LA INVESTIGACIÓN ......................................................... 39
4.1.
Diseño/Tipo de Investigación .................................................................................. 39
4.1.1.
Investigación Transversal Exploratorio............................................................. 39
4.1.2.
Investigación Proyectiva ...................................................................................... 40
4.1.3.
Investigación de Campo....................................................................................... 40
4.2.
Población................................................................................................................... 40
4.3.
Muestra ..................................................................................................................... 40
4.4.
Instrumentos de Recogida de Datos ....................................................................... 40
4.4.1.
Observación .......................................................................................................... 41
4.4.2.
Entrevista .............................................................................................................. 41
4.4.3.
Encuestas .............................................................................................................. 41
4.5. 4.5.1.
Técnicas de análisis de datos ................................................................................... 41 Entrevista .............................................................................................................. 41
xi
Encuestas .............................................................................................................. 44
4.5.2.
Análisis y selección de herramientas para el desarrollo ....................................... 51
4.6. 4.6.1.
Entorno de Desarrollo Integrado........................................................................ 51
4.6.2.
Base de Datos ........................................................................................................ 51
4.6.3.
Herramientas Adicionales ................................................................................... 52
4.7.
Análisis y selección del modelo de desarrollo del software .................................. 52
4.8.
Desarrollo del proyecto............................................................................................ 53
4.8.1.
Requerimientos del Sistema ................................................................................ 53
4.8.2.
Requerimientos del Prototipo ............................................................................. 54
4.8.3.
Diseño del Prototipo ............................................................................................. 56
4.8.3.1.
Diseño del hardware ........................................................................................ 56
4.8.3.2.
Diseño del Software .......................................................................................... 59
4.8.3.3.
Diseño de Maqueta ........................................................................................... 66
4.8.4.
Sistema Prototipo ................................................................................................. 66
4.8.5.
Pruebas.................................................................................................................. 77
4.8.6.
Sistema Entregado ............................................................................................... 77
5.
RESULTADOS ............................................................................................................ 78
5.1.
Discusión y análisis de los resultados ..................................................................... 78
5.2.
Conclusiones ............................................................................................................. 78
5.3.
Limitantes y recomendaciones ................................................................................ 79
Bibliografía ............................................................................................................................ 81 Lincografía ............................................................................................................................. 82 Glosario .................................................................................................................................. 83 Anexos ................................................................................................................................... 89 Anexo 1. Partes del Semáforo Inteligente .................................................................................... 90 Anexo 2. Certificado de la Compañía de Taxis “Las Playas S.A.” ............................................. 91 Anexo 3. Entrevista al Ing. Alex Rojas Técnico de Transporte de la ANT (Agencia Nacional de Transporte) de la Provincia ..................................................................................................... 92 Anexo 4. Formato de encuestas a conductores ............................................................................ 93 Anexo 5. Listado de Materiales y Herramientas .......................................................................... 95 Anexo 6. Manual de Instalación .................................................................................................. 96 Anexo 7. Manual de Usuario ....................................................................................................... 97 Anexo 8. Manual del Programador .............................................................................................. 98
xii
TABLA DE GRÁFICOS Ilustración 1. Gráfico. Pulsador Abierto ................................................................................ 13 Ilustración 2. Gráfico. Pulsador Cerrado ............................................................................... 13 Ilustración 3. Gráfico. Símbolos de Resistencias ................................................................... 14 Ilustración 4. Imagen. Distribución de valores según los colores de una resistencia. ........... 14 Ilustración 5. Imagen. Diodo LED y sus partes ..................................................................... 15 Ilustración 6. Imagen. Lógica Cableada................................................................................. 15 Ilustración 7. Imagen. Control de puertos de Entrada y Salida .............................................. 16 Ilustración 8. Imagen. Ejemplo de Microprocesadores .......................................................... 17 Ilustración 9. Imagen. Ejemplo de Microcontroladores ......................................................... 18 Ilustración 10. Gráfico. Ejemplo de la estructura de un PLD ............................................... 18 Ilustración 11. Gráfico. Arquitectura de un Sistema basado en CPU .................................... 19 Ilustración 12. Imagen. Logo de Arduino .............................................................................. 21 Ilustración 13. Imagen. Primera placa antes de ser Arduino.................................................. 22 Ilustración 14. Imagen. Placas y módulos de Arduino........................................................... 23 Ilustración 15. Imagen. Arduino DUE ................................................................................... 24 Ilustración 16. Tabla. Comparación funcional entre DUE y Leonardo ................................ 28 Ilustración 17. Gráfico. Modelo Lineal o en Cascada ............................................................ 33 Ilustración 18. Gráfico. Modelo en Espiral ............................................................................ 33 Ilustración 19. Gráfico. Modelo Prototipado o de Prototipos ................................................ 34 Ilustración 20. Tabla. Tabulación pregunta 1. Encuesta a Conductores. ............................... 45 Ilustración 21. Gráfico. Estadística pregunta 1. Encuesta a Conductores. ............................. 45 Ilustración 22. Tabla. Tabulación pregunta 2. Encuesta a Conductores. ............................... 46 Ilustración 23. Gráfico. Estadística pregunta 2. Encuesta a Conductores. ............................. 46 Ilustración 24. Tabla. Tabulación pregunta 3. Encuesta a Conductores. ............................... 47 Ilustración 25. Gráfico. Estadística pregunta 3. Encuesta a Conductores. ............................. 47 Ilustración 26. Tabla. Tabulación pregunta 4. Encuesta a Conductores. ............................... 48 Ilustración 27. Gráfico. Estadística pregunta 4. Encuesta a Conductores. ............................. 48 Ilustración 28. Tabla. Tabulación pregunta 5. Encuesta a Conductores. ............................... 49 Ilustración 29. Gráfico. Estadística pregunta 5. Encuesta a Conductores. ............................. 49 Ilustración 30. Tabla. Tabulación pregunta 6. Encuesta a Conductores. ............................... 50 Ilustración 31. Gráfico. Estadística pregunta 6. Encuesta a Conductores. ............................. 50 Ilustración 32. Imagen. Pantalla de Proteus con un ejemplo de pulsadores........................... 56 Ilustración 33. Imagen. Elaboración del esquema electrónico de la placa para la organización y distribución de los cables. ................................................................................................... 57 Ilustración 34. Imagen. Distribución y ubicación de puertos de entrada y salida de la placa Arduino DUE. ........................................................................................................................ 58 Ilustración 35. Tabla. Estructura de las cadenas de texto para la comunicación entre el ordenador y la placa Arduino DUE........................................................................................ 59 Ilustración 36. Imagen. Proceso de desarrollo de la primera interfaz del sistema de control para el usuario. ....................................................................................................................... 60 Ilustración 37. Imagen. Proceso de elaboración de horarios para el funcionamiento de los semáforos. .............................................................................................................................. 61
xiii
Ilustración 38. Imagen. Proceso de Asignación de tiempos para cada horario de la semana. 61 Ilustración 39. Tabla. Diccionario de Datos y Registros de Tablas para las primeras interfaces de usuario. ............................................................................................................. 62 Ilustración 40. Imagen. Diseño de Interfaz de Usuario. ......................................................... 63 Ilustración 41. Tabla. Segundo Diccionario de datos. ........................................................... 63 Ilustración 42. Imagen. Modificación de Interfaz de Usuario con ciclos y pestañas. ............ 64 Ilustración 43. Tabla. Diccionario de Datos resultante de la nueva interfaz. ......................... 64 Ilustración 44. Imagen. Interfaz de usuario del Sistema de Control. ..................................... 65 Ilustración 45. Diccionario de Datos con implantación de los Usuarios. .............................. 65 Ilustración 46. Imagen. Parte frontal y posterior de la Maqueta. ........................................... 66 Ilustración 47. Imagen. Ejemplo de programación para el micro controlador realizado en Basco. ..................................................................................................................................... 67 Ilustración 48. Imagen. Ejemplo de programación en la plataforma de Arduino. ................. 68 Ilustración 49. Gráfico. Funcionamiento de los ciclos de los semáforos. .............................. 70 Ilustración 50. Imagen. Clases y Formas del Sistema de Control de Usuario. ...................... 72 Ilustración 51. Imagen. Primera prueba de funcionamiento de pulsadores y diodos led. ...... 73 Ilustración 52. Imagen. Primer semáforo realizado. .............................................................. 74 Ilustración 53. Imagen. Proceso de elaboración e Implementación de semáforos. ................ 74 Ilustración 54. Imagen. Proceso de elaboración de la placa para la organización y distribución de los cables. ...................................................................................................... 75 Ilustración 55. Imagen. Placa luego del planchado. ............................................................... 76 Ilustración 56. Imagen. Placa para la Organización y Distribución de los cables junto con la Arduino Due........................................................................................................................... 76
1
1.
INTRODUCCIÓN A LA DISERTACIÓN DE GRADO
El proyecto se basa en la creación de un prototipo de semáforos inteligentes, con el objetivo primordial, de estudiar alternativas y soluciones para reducir el problema del tráfico vehicular en una determinada intersección entre dos calles. En Santo Domingo los Tsáchilas la existencia de este tipo de semáforos es nula, es por eso que se propone el desarrollo de este prototipo. En búsqueda de datos sobre el estado actual de la semaforización en Santo Domingo, se realizó una entrevista al Ing. Alex Rojas, Técnico de Transporte de la Agencia Nacional de Tránsito quien proporcionó información que impulsó el desarrollo del proyecto, adjuntando a esto los datos obtenidos por una encuesta aplicada a un grupo de conductores de la ciudad. El prototipo constará de tres partes: una maqueta que representará la intersección entre dos vías que recolectará los datos del pase de los vehículos mediante pulsadores y la visualización de las luces rojo, amarillo y verde de cada uno de los cuatro semáforos;
un
sistema
electrónico
cuyo
componente
principal
será
un
microcontrolador, en el que se grabará una aplicación que permita controlar los semáforos inteligentes en base a los pulsadores, recibiendo y enviando datos entre la maqueta; y la tercera parte que constituye un computador personal (PC). A su vez, el PC contará con una segunda aplicación, la misma que permitirá al usuario del PC acceder a una interfaz amigable para el manejo de los semáforos y el acceso a los datos recolectados, provenientes del sistema electrónico. Ver Anexo 1.
1
2
Para el funcionamiento de la segunda parte usaremos la plataforma electrónica de hardware libre Arduino, destinada justamente para la creación de prototipos usando microcontroladores Atmel AVR el cual se programa en su propio lenguaje de programación y entorno de desarrollo; el primero derivado de wiring y el segundo en processing que es código abierto que a su vez se basa de java. La implementación de este proyecto de semáforos inteligentes, coadyuvará a optimizar el tiempo de duración de cada una de las luces de los semáforos, y por ende ayudará también a una mejor fluidez del tránsito en las avenidas.
3
2. 2.1.
PLANTEAMIENTO DEL PROBLEMA
Antecedentes
2.1.1. Funcionamiento, Tecnología y Repuestos Durante muchos años los semáforos convencionales han venido desempeñando un rol muy importante en el direccionamiento del tránsito vehicular en Ecuador y a nivel mundial. Centrándonos particularmente en la ciudad de Santo Domingo, la semaforización durante la última década se ha caracterizado por su funcionamiento autónomo y descentralizado en el cual cada semáforo, trabaja individualmente con una configuración inicial reajustable únicamente de forma manual por personal específico y especializado el cual se dedica también a su mantenimiento. Su funcionamiento característico ha sido en su mayoría mecánico, con temporizadores para la asignación de los tiempos en los cambios de luces, las cuales a su vez, debido a su tecnología antigua demandan mayor cantidad de electricidad para su funcionamiento en relación a los LED (Diodo Emisor de Luz). Además, cuenta con una escasa disponibilidad de repuestos producida por la discontinuidad de producción de esta tecnología obsoleta, produciendo a causa de ello que las intersecciones se queden sin semáforos para el direccionamiento del tránsito vehicular. 2.1.2. Asignación de Tiempos y Desfases Los tiempos asignados por la configuración inicial que por cierto es de forma manual, son fijos todos los días del año sin variar ni tomar en consideración las horas pico o la carencia de vehículos en la vía a la cual se le asigne el color verde,
3
4
produciendo lentamente la aglomeración de vehículos en la otra vía inmersa en la intersección, hasta llegar a la congestión y caos vehicular temporal en el sector. Debido a su control y manejo, los semáforos convencionales al encenderse manualmente aparentemente trabajan de forma sincronizada pero al caer la tarde, luego de varias horas de uso, los semáforos tienden a mostrar una leve desincronización entre los semáforos inmersos en una intersección produciendo un problema en la asignación de los tiempos de las luces y por ende en el direccionamiento y fluidez del tránsito. Esto se debe a que el encendido de los semáforos por el hecho de ser manuales (es decir a que se destinan a personas para encenderlos) por más que quieran inicializarlos de forma sincronizada se adelantaran o atrasaran unos de otros por cuestión de milisegundos los cuales son insignificantes a la percepción humana durante las primeras horas de funcionamiento, pero que al caer la tarde luego varias horas ese desfase de milisegundos puede llegar a ser un desfase de un segundo o más, lo cual ya empieza a ser percibido por los conductores. Para solucionar este desfase producido inicialmente durante su arranque o encendido, la solución aplicada hasta el momento a este problema es el reinicio de los semáforos, lo cual con el paso de los días vuelve a presentarse periódicamente. 2.1.3. Semáforos Inteligentes En nuestro país ya se han implementado los conocidos semáforos inteligentes en varias ciudades como Cuenca, Guayaquil, Quito, Ibarra, Tulcán, Loja entre otras. En Cuenca al igual que en otras ciudades se implementó con un costo aproximado a los 7 millones de dólares en 98 intersecciones del centro histórico según un artículo publicado en el diario hoy el 11 de septiembre del 2009, pero su funcionamiento no cumplió con las expectativas deseadas siendo una de las causas, la falta de personal
5
especializado para el control de los semáforos desde la cabina principal según María Alvarado presidenta de la comisión de movilidad de aquel entonces. En cuanto a Santo Domingo de los Tsáchilas, actualmente se cuenta con los fondos y se está en negociaciones para la adquisición de los semáforos inteligentes con una empresa internacional que proveerá los equipos con tecnología de punta junto con la capacitación respectiva, según una entrevista con el Ing. Alex Rojas Técnico de la ANT (Agencia Nacional de Tránsito) que se tuvo en junio del 2013.
2.2.
Problema de Investigación
El problema observado en los semáforos se presenta en la distribución de tiempos de luz verde a calles sin vehículos en cola, causados por la asignación fija de tiempo de las luces; además de la descentralización y no estandarización en la comunicación y configuración de la tecnología utilizada en los semáforos actuales junto con la escasez de mano de obra técnica calificada.
2.3.
Justificación
El crecimiento del parque automotor a nivel mundial y la contaminación producida por éste ha obligado a las naciones a la búsqueda de nuevas formas de direccionamiento del tránsito vehicular; es así que una de las formas que se ha aplicado es el uso de los denominados semáforos inteligentes, los cuales han contribuido con la descongestión en las ciudades de mayor importancia y el estudio de su paulatino crecimiento para la búsqueda de nuevas estrategias para su mejor desempeño. A partir del 2009, Ecuador empezó con la adquisición de modernos semáforos para las diferentes ciudades de mayor movimiento vehicular incluyendo a nuestra provincia Santo Domingo de los Tsáchilas, la cual próximamente contará con esta nueva tecnología.
6
Un punto a considerar en la implementación de esta nueva tecnología, es la cantidad de mano de obra capacitada para el control del mismo, siendo un ejemplo de ello la ciudad de Cuenca que tuvo inconvenientes en su implementación y no tan lejana a ella nuestra ciudad de Santo Domingo, es así que el presente proyecto pretende no solo colaborar con una alternativa más para el control de tránsito vehicular sino también, fomentar el desarrollo de nuevas tecnologías aplicadas para este o más campos que requieran de la iniciativa y productividad de manos ecuatorianas, tomando como base el uso de los conocimientos académicos y experiencias vividas, sumando a esto la adquisición de hardware como la plataforma Arduino que es esencial para la parte electrónica y que además de ser reconocida por su iniciativa y calidad, provee de una amplia variedad de dispositivos y repuestos con costos aceptables para proyectos académicos y profesionales; además tiene un gran soporte técnico a nivel mundial, siendo ideal para los proyectos de prototipos e implementación en el campo real. Este proyecto encaja adecuadamente con la nueva tendencia gubernamental de fomentar la producción nacional en base a la investigación académica universitaria y evitando trabajar con licencias de software y hardware. Por consecuencia, los beneficiarios de la realización de este proyecto no solo serán para el autor del mismo, sino también para la comunidad académica, ya que tendrá a la mano una investigación inicial para la búsqueda de nuevas opciones de implementación para la resolución de nuevos proyectos y a largo plazo la ciudadanía con los resultados obtenidos de esta y demás investigaciones futuras.
7
2.4.
Objetivos
2.4.1. Objetivo General Simular la aplicación de los semáforos inteligentes como solución al problema vial, mediante el desarrollo de una maqueta, aplicando la técnica de prototipado. 2.4.2. Objetivos Específicos Analizar y Desarrollar el código para la placa electrónica que controlará los dos semáforos de la intercesión. Diseñar interfaces y desarrollar codificación para la aplicación de control de los semáforos que controlará el usuario final desde un ordenador. Diseñar una representación física de una intersección vial con los componentes electrónicos incluidos para la verificación del funcionamiento del prototipo.
8
3. 3.1.
MARCO REFERENCIAL
Revisión de la literatura o fundamentos teóricos
3.1.1. Flujo Vehicular Denominado así al movimiento de vehículos en una calle o avenida con una dirección determinada. 3.1.2. Horas Pico Corto tiempo durante el cual, circulan mayor cantidad de vehículos que lo acostumbrado aumentando así el flujo vehicular. 3.1.3. Tránsito Vehicular Llamado así al flujo de vehículos que circulan por una vía, avenida, calle o autopista. La carrera dedicada al estudio y regulación del tránsito vehicular es la Ingeniería de Tránsito la misma que se deriva de la Ingeniería Civil. Para colaborar con el control del tránsito se da uso de elementos estáticos como los son las señales viales y elementos dinámicos como los semáforos para ayudar a los conductores y peatones a transitar de forma correcta y segura. La entidad encargada de la regulación de las normas y funcionamiento para un buen desempeño del control del tránsito en nuestro país es la conocida Comisión de Tránsito del Ecuador (CTE). 3.1.4. Congestión Vehicular Es el fenómeno de embotellamiento del tránsito vehicular que se produce a causa de varios motivos. Uno de ellos es la distribución estática y permanente de los tiempos
8
9
de las luces durante todo el día y todos los días, lo cual causa que en las horas pico los vehículos se aglomeren en las calles y disminuya su velocidad hasta llegar a nula; produciendo así mayor contaminación ambiental, auditiva y por supuesto el aumento de los tiempos de viajes, causando frustración y estrés en los conductores y sus pasajeros. 3.1.5. El Semáforo Con una etimología de origen griego la palabra semáforo se traduce en “Lleva las señales” lo cual consistía en dar señales ópticas entre extensas dimensiones de terrenos para comunicarse entre las personas. Es un dispositivo tecnológico (según su época de fabricación puede ser mecánico, eléctrico, electrónico, etc.) y elemento muy importante dentro de la ingeniería de tránsito, cuya función primordial se basa en la regulación del flujo tanto de vehículos como de peatones, permitiendo o impidiendo su paso o circulación en las intersecciones de caminos, calles o avenidas de una localidad determinada. Los semáforos para los vehículos generalmente cuentan con tres luces de colores cuyos significados se detallan a continuación:
Rojo.- Indican que los vehículos deben detenerse antes de la línea de pare impidiendo el flujo vehicular en la dirección en que se encuentre el semáforo. Si la luz roja esta intermitente el conductor deberá detenerse completamente antes de cruzar la vía.
Amarillo.- Implica prevención o advertencia. Alerta a los conductores el próximo cambio a la luz roja y disminuir la velocidad hasta llegar a la línea de pare. Si la luz amarilla es intermitente los conductores podrán cruzar la intersección con las debidas precauciones.
10
Verde.- Indica que los vehículos tienen autorización para avanzar, permitiendo el flujo vehicular en la dirección en que se encuentre el semáforo.
Estas luces con sus colores se las heredó inicialmente del sistema ferroviario y del sistema fluvial. Sus orígenes se remontan a los inicios del siglo XX en el Reino Unido gracias a su inventor el Ing. Británico J.P. Knight quien lo ubicó en el exterior del parlamento británico Westminster, trabajando solamente con las luces rojo y verde. La necesidad de poder controlar de mejor forma el tránsito vehicular, da origen a nuevos modelos de semáforos los cuales puedan trabajar de forma dinámica en relación a los vehículos en circulación. Es así, que mediante el uso de la tecnología se han desarrollado los conocidos semáforos inteligentes, los cuales tienen la característica particular de trabajar con un conjunto de reglas o prioridades que permiten asignar dinámicamente la asignación de tiempos en el encendido y el apagado de las luces en base al flujo de vehículos y a la prioridad que se asigne a una calle o avenida. Actualmente existen modelos y prototipos de estos semáforos que trabajan con elementos en común como los sensores, que son elementos del sistema de semaforización encargos del ingreso de los datos obtenidos en el medio que viene a ser la cantidad de vehículos en una intersección para luego ser procesados y dar así la mejor opción de cambio de luces. Cabe resaltar la existencia de los semáforos tecnológicos, los cuales solo recolectan datos de los vehículos existentes en la intersección para luego ser enviados a una central y sean los operadores (personas) quienes tomen las decisiones en el cambio de las luces; lo que a diferencia del semáforo inteligente es que toma la decisión de
11
forma autónoma en base a las reglas o prioridades que se estipulen en su programación y no cien por ciento en base a la toma de decisión de un humano. 3.1.6. Corriente Eléctrica Es la circulación de cargas o electrones a través de un circuito eléctrico cerrado, que se mueven siempre del polo negativo al polo positivo de la fuente de suministro. Una lámpara comúnmente usada es el resultado de esta teoría ya que se basa en el uso de una batería o pila la que es conectada a los filamentos de la lámpara tanto al positivo y negativo y así pueda proveernos de luz. 3.1.7. Circuito Eléctrico Es el trayecto o ruta que recorre una corriente eléctrica por un conductor. Un ejemplo del funcionamiento del circuito eléctrico es el recorrido que inicia en una de las terminales de una pila, para luego pasar a través de un conducto eléctrico (cable de cobre), llega a una resistencia (foco), que consume parte de la energía eléctrica; continúa después por el conducto, llega a un interruptor y regresa a la otra terminal de la pila. 3.1.8. Tipos de Circuitos Eléctricos 3.1.8.1.
Circuitos en Serie
Consiste en conectar el polo positivo de la primera pila con el polo negativo de la segunda pila, el polo positivo de ésta con el negativo de la tercera y así sucesivamente, los extremos de esta conexión se unen a una resistencia para conectar el circuito.
12
3.1.8.2.
Circuitos en Paralelo
Consiste en conectar varios generadores, los polos positivos entre sí y los polos negativos entre sí. 3.1.9. Sensores Un sensor es un dispositivo que permite obtener un dato de una variable física (temperatura, fuerza, presión, velocidad, posición, etc.) ubicada en el medio que se encuentre, para tomarlo con ingreso a un sistema cualquiera, ya sea este mecánico o electrónico, para así procesarlo y conseguir un resultado deseado. Su campo o área de aplicación es variada, es utilizado en la industria automotriz, aeroespacial, domótica, medicina, robótica y demás áreas según sea su necesidad. Resumiendo lo dicho, la función básica de un sensor es “Detectar”. Los sensores logran obtener un valor de las variables físicas, ya sea por un bloqueo o un reflejo. Un claro ejemplo del bloqueo es una alarma, cuando el intruso bloquea la señal de la luz e interrumpe su paso, produciendo así su activación en el sistema y otro ejemplo para el reflejo es un detector de proximidad de las puertas de un centro comercial. Su clasificación no es tan sencilla debido a la variedad existentes en el mercado, y sobre todo a su composición física y valores o resultados de retorno. La forma más sencilla de clasificarlos puede ser en sensores activos y sensores pasivos. Los sensores activos generan señales de forma autónoma para la detección o medición de magnitudes en el ambiente sin requerir fuente alguna de alimentación; mientras que los pasivos solo miden las señales emitidas por el medio en el que se encuentren por medio del uso de una fuente de alimentación.
13
Según la señal eléctrica que generen se los puede clasificar en análogos, los cuales manejan valores de retorno discretos como voltaje o corriente y los digitales que trabajan con valores de retornos verdadero o falso. Por último, según el tipo de variable física a detectar tenemos medidores de temperatura, movimiento, humedad, caudal, presencia o proximidad, nivel, fuerza, táctiles, etc. 3.1.10. Pulsadores Son dispositivos pasivos dependientes de una alimentación externa de origen eléctrico, electrónico o mecánico que permiten o impiden el paso de corriente eléctrica o de cualquier señal del circuito eléctrico en el que se encuentre inmerso. Existen dos tipos, los cuales reaccionan de acuerdo al momento que sean presionados. Los de contacto abierto que permitirán el paso de la corriente eléctrica o de otras señales y el de contacto cerrado que lo impide. Su representación gráfica es la siguiente:
Título: Pulsador Abierto. Ilustración 1. Gráfico. Pulsador Abierto Fuente: Creado por el Autor. Ilustración: 1
Título: Pulsador Cerrado. Fuente: Creado por el Autor. Ilustración 2. Gráfico. Ilustración: 2 Pulsador Cerrado
3.1.11. Resistencias Eléctricas Llamadas también resistores, son componentes pasivos que no generan tensión ni corriente eléctrica, pero que permite controlarlos, en otras palabras las resistencias eléctricas se encargan de reducir el paso de la corriente eléctrica. Su unidad de medida es el Ohm Ω. Su representación gráfica puede ser cualquiera de las siguientes:
14
Título: SímbolosSímbolos de Resistencias. Ilustración 3. Gráfico. de Resistencias Fuente: Creado por el Autor. Ilustración: 3
Su grado de resistencia y tolerancia, está determinada por cuatro franjas de colores, de las cuales la primera determina el primer digito, la segunda el segundo digito, la tercera la cantidad de ceros que se aumenta al número de ohmios que tendrá la resistencia y la cuarta franja el porcentaje de tolerancia. A continuación se detalla:
Título: Distribución de valores según los colores de una resistencia. Fuente: Imagen tomada de: http://sorrentotorresca.blogspot.com/2012_03_01_archive.html. Ilustración 4. Imagen. Distribución de valores según los colores de una resistencia. Ilustración: 4
3.1.12. LED (Light Emitting Diode, Diodo Emisor de Luz) Es un dispositivo pasivo semiconductor que emite luz al existir dentro de él la circulación de corriente eléctrica. Su uso se ha extendido dejando atrás el uso de la luz incandescente y fluorescente debido a su bajo consumo de energía, mayor tiempo de vida, reducido tamaño, reducción de emisión de calor, entre otras ventajas en relación a sus antecesoras.
15
Título: Diodo LED y sus partes. Fuente: Imagen tomada de http://proaudio.com.es/wp-content/uploads/2010/06/14.png Ilustración 5. Imagen. Diodo LED y sus partes Ilustración: 5
Está formado por el encapsulado y para su conexión se toma en consideración sus dos patas de las cuales la corta es el cátodo (negativo) y la larga el ánodo (positivo). 3.1.13. Sistemas Micro Programables Son un conjunto de dispositivos de propósito general que al ser programados son capaces de resolver problemas determinados, por ejemplo el computador. Al igual que en el computador, en la electrónica digital se diferencian dos lógicas: 3.1.13.1.
Lógica Cableada (Hardware)
Consiste en el diseño del circuito con los componentes (transistores, resistencias, microcontrolador, etc.) a utilizar, para la aplicación a desarrollar; el cual una vez diseñado e implementado, será complicado o imposible de modificar.
Título: Lógica Cableada. Ilustración 6. Imagen. Lógica Cableada Fuente: Ejemplo realizado en Proteus 7 Professional por el autor. Ilustración: 6
16
3.1.13.2.
Lógica Programada (Software)
Consiste en la programación y configuración de los dispositivos de acuerdo a sus capacidades y a las necesidades a resolver. Un claro ejemplo es la programación que se realiza para el control del microcontrolador en sus puertos de entrada/salida.
Título: Control de puertos de Entrada y Salida. Fuente: Ejemplo Control realizadode enpuertos Arduinode por el autor.y Salida Ilustración 7. Imagen. Entrada Ilustración: 7
3.1.14. Clasificación de los Sistemas Micro Programables De acuerdo a los circuitos integrados utilizados, sus capacidades o limitaciones y la forma en que procesan los datos se pueden clasificar en:
Microprocesadores.
Microcontroladores.
Dispositivos Lógicos Programables.
3.1.14.1.
Microprocesadores
Es el circuito integrado de mayor importancia en los sistemas microprogramables, el cual contiene en su interior la Unidad Central de Proceso (CPU), la misma que se
17
encarga de procesar todos los datos que entran al sistema utilizando para esto los dispositivos externos conectados a él, por ejemplo: la memoria primaria, dispositivos de almacenamiento (Disco Duros), etc.
Título: Ejemplo de Microprocesadores. Fuente: Imagen tomada de http://claudiahernandezinf.blogspot.com/. Ilustración 8. Imagen. Ejemplo de Microprocesadores Ilustración: 8
Este componente electrónico se utiliza para el procesamiento de grandes cantidades de datos con una elevada velocidad de respuesta, como es el caso de un computador. 3.1.14.2.
Microcontroladores
Al igual que los microprocesadores, los microcontroladores son circuitos integrados que contienen en su interior una Unidad Central de Proceso (CPU), con dos diferencias fundamentales. La primera que consiste, en que los dispositivos externos como: la memoria Central, los puertos de Entrada/Salida digitales y demás elementos que el microprocesador tiene conectado a él para el funcionamiento del sistema, el microcontrolador los tiene integrados en su interior. La segunda diferencia es a la ves una desventaja, debido a que por tener integrado todos los dispositivos no cuenta con la capacidad de procesar cantidades grandes de datos con alta velocidad, limitando su uso en aplicaciones pequeñas de sistemas de control para electrodomésticos o maquinarias.
18
Título: Ejemplo de Microcontroladores. Fuente: ImagenIlustración tomada de 9. http://www.ceiarteuntref.edu.ar/badarte/?q=taxonomy/term/45/9 Imagen. Ejemplo de Microcontroladores Ilustración: 9
3.1.14.3.
Dispositivos Lógicos Programables (PLD)
Los PLD son circuitos integrados que cuentan con una matriz de puertas lógicas en su interior con el objetivo de resolver problemas de combinaciones. Pueden ser programados por el usuario pero no cuentan con una Unidad Central de Proceso como los dos anteriores, lo que lo limita debido a la falta de los componentes característicos de un sistema basado en CPU.
Título: Ejemplo de la estructura de un PLD. Fuente: Imagen tomada de http://blogmultisim.blogspot.com/2011_01_01_archive.htm Ilustración 10. Gráfico. Ejemplo de la estructura de un PLD Ilustración: 10
3.1.15. Arquitectura de un Sistema Basado en CPU (Unidad Central de Proceso) Tanto los microprocesadores como los microcontroladores se basan en la siguiente arquitectura para su funcionamiento, diferenciándose en que los microprocesadores contienen en su interior solo la CPU (Unidad Central de Proceso), mientras que el microcontrolador contiene todos los elementos integrados dentro de él.
19
Título: Arquitectura de un Sistema basado en CPU. Fuente: Figura realizada por el autor. Ilustración 11. Gráfico. Ilustración: 11 Arquitectura de un Sistema basado en CPU
3.1.15.1.
Reloj
Se encarga de marcar el ritmo del funcionamiento del sistema con la finalidad de mantenerlo sincronizado, es decir nos indica la velocidad con la que trabajarán todos los elementos del sistema. 3.1.15.2.
Unidad Central de Proceso o CPU
Se encarga de receptar, interpretar y ejecutar todas las instrucciones generadas para el manejo y control de todos los elementos conectados en el sistema, por lo que se le considera la parte más importante. Como complemento para su funcionamiento está la memoria primaria (Central) y la secundaria (Unidades de Almacenamiento por ejemplo el disco duro) con las cuales realiza la transferencia de datos con una sincronización controlada por el reloj, el cual determina la velocidad con la que trabaja el sistema. 3.1.15.3.
Memoria Central o Interna
Es el lugar en el cual se alojan las instrucciones o programas pendientes a ejecutarse en la CPU. 3.1.15.4.
Unidad de entrada/salida (interface)
Es un circuito que permite la comunicación con el mundo exterior, sirve como intermediario o mediador para que los elementos o dispositivos del mundo exterior puedan comunicarse con el interior del sistema y viceversa.
20
3.1.15.5.
Periféricos
Son dispositivos que no forman parte del sistema y pertenecen al mundo exterior. Pueden ser de entrada, salida o entrada y salida de datos cada uno con funciones determinadas.
Por
ejemplo:
mouse,
monitor,
etc.
En
el
caso
de
los
microcontroladores los periféricos están incorporados en el sistema. 3.1.16. Sistemas Embebidos Un sistema embebido es un conjunto de elementos electrónicos (Hardware) y sentencias de código (software) que forman un todo único, con la finalidad de realizar una tarea específica, bajo un conjunto de normas y reglas determinadas para obtener un mismo objetivo final. Este tipo de sistemas se diferencian de los ordenadores en que son de propósito específico, centrándose solo en un objetivo en particular y con la posibilidad de formar parte de un sistema más grande o trabajando individualmente. Su campo de aplicación y uso es enorme ya que lo encontramos a diario en los teléfonos celulares, reproductores de MP3, impresoras, automóviles, etc. Se Producen millones de unidades de producción diaria a nivel mundial, siendo así, su campo de aplicación muy extenso y rentable. Entre sus características tenemos su funcionamiento el cual se basa en la ejecución repetitiva de un mismo código específico, el cual se almacena en su memoria el cual es procesado por un microcontrolador en cuestión de milisegundos por línea de código. Su actualización o modificación del código dependerá las funciones a realizar. Otra característica aunque negativa es la limitante de procesamiento que tiene, puesto que este tipo de sistemas incorpora dentro, todo los elementos que un ordenador de uso general los tiene por separados como por ejemplo la memoria
21
primaria,
secundaria
y
periféricos.
La
capacidad
de
procesamiento
de
microcontrolador ha llegado en la actualidad hasta 32 bit que es justamente con la cual se trabajará en este proyecto. Inicialmente trabajaban a 4, 8 y 16 bits, lo que impedía procesar grandes cantidades de instrucciones por segundo convirtiéndose esta capacidad en una limitante muy importante. Otro punto positivo es el bajo consumo de energía ya que no cuenta con elementos muy grandes lo cual constituye algo favorable en cuanto a la movilidad y portabilidad de los equipos como por ejemplo los celulares. Por último tenemos, la reacción a los cambios existentes en el medio ambiente en el que se encuentre y en base a estos cambios el procesamiento en tiempo real de la reacción a tomar por ese cambio producido. Por ejemplo en el campo de la industria, durante el proceso de fabricación de un producto existen sensores que determinan la presencia del objeto y en base a esto el sistema toma la decisión de llenar el agua en una botella o pintar una parte del carro o empacar un producto, para continuar con la línea de producción. 3.1.17. Arduino
Título: LogoIlustración de Arduino.12. Imagen. Logo de Arduino Fuente: Imagen tomada de la página oficial de arduino http://arduino.cc/. Ilustración: 12
Siendo un proyecto, inicialmente surge en el año 2005 en Italia, en base a la necesidad académica de facilitar nuevas herramientas a bajo costo; tomando como inicio una tesis en la que desarrollan un nuevo lenguaje de programación en base a prossesing, es así que trabajando conjuntamente con Hernando Barragán un
22
estudiante Colombiano crean la plataforma wiring. Con el paso del tiempo se plantea el objetivo de desarrollar un proyecto open source de nombre Arduino con su propio software y posterior a ello inician su ámbito comercial con la fabricación inicial de 200 placas y una utilidad de un dólar por cada una, en la actualidad la producción a sobre pasado las 250 mil a nivel del mundo sin contar las clones y compatibles.
Título: Primera placa antes de ser Arduino. Ilustración 13. Imagen. Primera placa antes de ser Arduino Fuente: Imagen tomada de un reporte a los cofundadores de Arduino http://spectrum.ieee.org/geek-life/hands-on/the-making-of-arduino/0 Ilustración: 13
Actualmente arduino constituye una herramienta y plataforma de desarrollo de código abierto. Basado en la ideología de sus creadores tanto el código de programación como los esquemas y componentes físicos se pueden modificar al gusto del usuario final según sea sus necesidades. Cuenta con una comunidad amplia a nivel mundial con la cual se apalanca su constante crecimiento y evolución. Entre las características que convierten a arduino en la mejor opción para desarrolladores tenemos: Bajo Costo.- Sus costos de adquisición son bajos, y si se lo fabrica por cuenta propia disminuyen más. Multiplataforma. Debido a que está basado en java, lo convierte compatible para Windows, Linux y Mac OS X. Entorno de programación simple y directo.
23
Hardware y software ampliable y de código abierto. Convirtiéndose en una de las mejores elecciones para la elaboración de prototipos electrónicos programables, google ha apostado a arduino con la elaboración de android ADK permitiendo a los Smartphone la comunicación con la placa y viceversa. Su primera placa comercializada fue la arduino UNO, en la actualidad se cuenta con varias placas y módulos según la necesidad, por ejemplo:
Título: Placas y módulos de Arduino. Fuente: Parte del listado de placas y módulos disponibles a la venta http://arduino.cc/en/Main/Products Ilustración 14. Imagen. Placas y módulos de Arduino Ilustración: 14
3.1.18. Arduino DUE Es la más potente placa producida por arduino en la cual sobre salta su microcontrolador el cual trabaja con 32 bits y una frecuencia de 84Mhz a diferencia de las demás placas que solo lo realizan a 16 y 8 bits y la compatibilidad con aplicaciones android de google. Entre las principales características tenemos:
Memoria de 512Kb para el almacenamiento del código
54 Pines de entrada / salida
24
Voltaje de operación 3.3v
2 puertos de programación
Microcontrolador AT91SAM3X8E
Conversor análogo digital
3.1.19. Partes elementales de la placa
Título: Arduino DUE. Ilustración 15. Imagen. Arduino DUE Fuente: Imagen tomada de http://arduino.cc/en/uploads/Main/ArduinoDue_Front.jpg Ilustración: 15
3.1.19.1.
Reset
Botón que permite reiniciar el funcionamiento del código grabado en la memoria y sus variables al procedimiento setup que son las primeras líneas de código en ejecutarse y por una sola vez al inicio de su funcionamiento. 3.1.19.2.
Conector de Alimentación
Es uno de los dos medios por los cuales se puede alimentar la placa, la misma que trabaja a 3.3V a diferencia de las demás que lo hacen a 5V. Su alimentación puede ser además mediante el uso de baterías en caso de desear que la placa sea portátil.
25
3.1.19.3.
SPI Interfaz Serial de Periféricos
Es un conector con un conjunto de seis pines que me permite la comunicación entre la placa y cualquier otro módulo como por ejemplo un módulo de infra rojos, de Bluetooth, etc. Para la adecuación de la placa a nuevos proyectos según sea la necesidad. 3.1.19.4.
Microcontrolador
Es el principal componente que se encarga de procesar las instrucciones en cuestión de milésimas de segundos. El micro usado en esta placa es el AT91SAM3X8E de la marca Atmel. La particularidad en relación a los anteriores utilizados en las placas atesoras es que trabajaba con una arquitectura de 32 bits lo cual lo hace más rápido en el proceso de ejecución de instrucciones. 3.1.19.5.
Pines
Es el medio por el cual ingresan o salen variaciones de voltaje como resultado de un proceso o entrada de datos a la placa. Todos los pines se encuentran etiquetados en la placa para mayor referencia. Según se desee un pin puede ser de tipo entrada o de tipo salida y para su declaración se utiliza el comando pinMode de la siguiente forma: pinMode(número_del_pin, tipo_de_pin); El tipo de Pin entrada se denomina “INPUT” y el de salida “OUTPUT”. De acuerdo al tipo de datos a entrar o a salir, puede ser análogo o digital.
26
3.1.19.5.1. Análogo Que trabajara con valores discretos, es decir con valores de entre un rango determinado de opciones. Su configuración está dada por el uso del comando analogWrite o analogRead. analogWrite(pin a escribir, valor); analogRead(número de pin a leer); 3.1.19.5.2. Digital Permitirá trabajar con valores true o false. Su configuración está dada por el uso del comando digitalWrite o digitalRead. digitalWrite(número de pin, estado del pin) digitalRead (númerodepin a leer) El estado de un pin puede ser HIGH para encenderlo o LOW para apagarlo. 3.1.19.6.
Puerto de Programación
Permite guardar las líneas de código programadas en la memoria de la placa para luego ser ejecutadas. 3.1.19.7.
Puerto Nativo
Al igual que el puerto de programación el puerto nativo sirve para el almacenamiento de la codificación en la memoria de placa además que permite realizar un borrado completo de los datos almacenados. Se recomienda hacer uso del puerto de programación para el paso del código a la memoria de la placa por motivo de seguridad ya que se podría borrar lo almacenado en la placa por error.
27
3.1.20. Arquitectura de Microcontroladores Entre los tipos de arquitecturas tenemos la arquitectura de Von Neumann la cual fue la base para la construcción de la ENIAC (computador e Integrador Numérico Electrónico) que fue una de las primeras computadoras creadas por el hombre. Creada por John Von Neumann, ésta arquitectura que es la tradicional de computadoras y microcontroladores la cual trabaja con el uso de un solo bus principal por el cual controla y transmite datos desde la CPU (Unidad Central de Proceso) a la memoria, la misma que contiene los datos y las líneas de código almacenados en su interior. Este tipo de arquitectura es un poco lenta debido a que todas las transacciones están limitadas por el ancho y capacidad del único bus con el que trabaja. La siguiente arquitectura es la de Harvard. Desarrollada por Howard H. en la universidad de Harvard con la colaboración de IBM. Se implementó por primera vez en la MARK I que fue el primer ordenador electromecánico que procesaba cinco operaciones aritméticas. Esta arquitectura mejora a la de Von Neumann implementando un bus adicional para gestionar por separado las instrucciones de programa de los datos. Cada bus puede tener diferente capacidad de transmisión con lo que se consigue mayor velocidad de procesamiento. La Arduino DUE es la primera de las placas de arduino que se basan en la arquitectura ARM (Advanced RISC Machine, Máquina avanzada con conjuntos de instrucciones reducidas), la misma que se deriva de la arquitectura computacional RISC y la arquitectura de microprocesadores Harvard. Lo que la convierte en la más
28
eficiente en procesamiento y almacenamiento que sus predecesores. En la siguiente tabla se encuentra una comparación con su placa antecesora.
Placas
Micro Controlador
Voltaje de Entrada
Voltaje del Sistema
Velocidad del Reloj
Entradas /Salidas Digitales
Entradas Análogas
Espacio en Flash
DUE
AT91SAM3X8E
7 – 12 V
3.3 V
84 MHz
54
12
512 Kb
Leonardo
ATmega32U4
7 – 12 V
5.0 V
16MHz
20
12
32 Kb
Título: Comparación funcional entre DUE y Leonardo. Ilustración Tabla.por Comparación funcional entre DUErealizada. y Leonardo Fuente: Tabla 16. realizada el autor en base a la investigación Ilustración: 16
Como se observa no solo permite almacenar mayor cantidad de líneas de código, sino también permite procesarlas a mayor velocidad gracias a la arquitectura y capacidad del procesador, velocidad de reloj y demás características positivas con el aumento considerable de los puertos disponibles para la conexión de periféricos. Junto a estas características notables se tomó en consideración la escalabilidad que proporciona el uso de esta placa con los módulos que se le pueden implementar en caso de aumentar las exigencias, tales como: el módulo de Bluetooth, Wi-Fi, Ethernet, y demás módulos existentes en el mercado. Por tal razón se considera la mejor placa a utilizar para la realización de este proyecto. 3.1.21. Software Se define como todo lo intangible relacionado con un ordenador, es decir, a la parte de los programas que podemos ver pero no tocar. Existen diferentes tipos de software de acuerdo a su uso y área, a continuación una clasificación:
29
3.1.21.1.
Software de Sistemas
Llamado también sistema operativo es el encargado del gobierno del ordenador, administra y gestiona el hardware como la impresora, uso de memoria, almacenamiento en disco duro, etc. Tenemos varios sistemas operativos disponibles en el mercado según sea la necesidad del usuario, por ejemplo: Windows XP, Windows Vista, Windows 7, Windows 8, Mac OSx, Linux Mandraque, Fedora, Ubuntu, etc. 3.1.21.2.
Software de Desarrollo
Conocido también como IDE (Integrated Development Environment - Entorno de Desarrollo Integrado), son software que crea software. Es decir, son programas que por medio de lenguajes de programación nos permiten desarrollar más aplicaciones según la necesidad. Entre los más reconocidos tenemos: Visual Estudio, Netbeans, C/C++, Borland, Java Developer, Gambas, Anjuta, Pyton, Delphi. 3.1.21.3.
Software de Red
Son programas que permiten realizar tareas en una red de ordenadores y demás dispositivos inter conectados. Un ejemplo de estas aplicaciones son los programas de control de un cyber, además de este software tenemos: putty, Team Viewer, etc 3.1.21.4.
Software de Aplicación
Es el tipo de software más utilizados por los usuarios finales debido a su fácil uso. En este tipo se encuentran todos los editores de texto, hojas de cálculo, programas de diseño, juegos, etc.
30
3.1.21.5.
Otros
En esta sección nos vamos a referir a todos los programas en relación a sus desarrolladores o propietarios, los mismos que de acuerdo a su ideología y tendencia especifican si su producto elaborado necesita un pago o no.
Freeware, se denomina así, a todo programa de libre uso e instalación sin costo alguno para su uso o manejo ilimitado.
Shareware, permite su uso gratuito con restricciones parciales y limitadas.
Vapourware, se caracteriza por ser de mala calidad e incompleto ya que es una versión no finalizada y de procedencia engañosa.
3.1.22. Software Libre A diferencia del Freeware que solo permite instalar y ejecutar un programa, el software libre proporciona al usuario la libertad de poder copiar, distribuir, estudiar su código fuente y cambiarlo a gusto personal. Se puede hacer con el software lo que uno desee, utilizarlo para cualquier propósito, adaptarlo a las necesidades de cada persona o empresa. 3.1.23. Entorno de Desarrollo Integrado Un entorno de desarrollo integrado es un software de desarrollo que contiene una gran variedad de herramientas que basados en un lenguaje de programación nos permiten crear sistemas con funciones específicas. Para el desarrollo de la aplicación de control de los semáforos para el usuario se tomaron en consideración los siguientes Software de desarrollo:
31
3.1.23.1.
JDeveloper Studio
Perteneciente a la corporación Oracle éste entorno de desarrollo integrado permite trabajar con múltiples lenguajes de programación como java, HTML, XML, SQL, javascript entre otros. A partir del 2001 está basado en java lo que le permitió potencializarse en el campo del desarrollo de aplicaciones multiplataforma y a más de ello pasó en el 2005 a ser gratuito. Es utilizado para la construcción de aplicaciones a gran escala, gracias al conjunto de herramientas disponibles en su entorno, lo que a la vez lo torna complejo de manejar a personas que deseen iniciar a programar pequeñas aplicaciones. Su instalación requiere de un exigente hardware para su óptimo funcionamiento. 3.1.23.2.
Visual Studio
Uno de los entornos de desarrollo integrado más frecuentados por la comunidad informática perteneciente a la corporación Microsoft, cuenta con un gran soporte y ayuda para su manejo. Su uso e instalación cuenta con versiones exprés y licenciadas es decir de pago. Soporta lenguajes de programación como Visual C++, Visual C#, Visual J#, ASP .NET y Visual Basic .NET. Permite la creación de proyectos de ventana, web, móviles, entre otras. Está orientado para estudiantes y principiantes. La versión exprés está limitada de ciertos componentes, pero con lo necesario para el inicio de aficionados y estudiantes. 3.1.23.3.
NetBeans IDE
Fundado y patrocinador por Sun MicroSystem, este IDE constituye un proyecto de código libre basado en Java con una comunidad en constante crecimiento a nivel mundial. Esta Herramienta permite la comunicación con cualquier lenguaje de
32
programación, además de ser escalable gracias a la gran cantidad de módulos disponibles. No existe versión exprés ni pagada, el uso e instalación es gratuita y su código disponible para modificaciones, está orientado para todo tipo de usuario, con una gran cantidad de información disponible en la comunidad. 3.1.24. Modelos de Desarrollo de software Encargada de la calidad, funcionamiento y eficiencia durante el proceso de desarrollo de un nuevo sistema informático, la ingeniería del software proporciona varios modelos según el enfoque que se desee aplicar. Entre ellos tenemos: 3.1.24.1.
Modelo en Lineal o en Cascada
Este modelo contiene cinco etapas de desarrollo: el análisis donde se recolectan los requerimientos del cliente y se planifica la forma de resolver la solución informática estudiando su viabilidad. La segunda etapa, es el diseño de las interfaces de la solución informática junto con el esquema de la base de datos, a continuación la codificación, en la cual se construyen instrucciones en base a un lenguaje de programación, posterior la pruebas para verificar su correcto funcionamiento y finalmente el mantenimiento durante todo su tiempo de vida. Cabe indicar que las tareas realizadas cuentan con un itinerario ya establecido con un documento de por medio con lo realizado en la transición de las etapas. Un punto desfavorable de este modelo es el no retorno a la etapa anterior en caso de una modificación o adición de algún requerimiento.
33
Título: Modelo Lineal o en Cascada. Fuente: Ilustración desarrollada el Cascada autor. Ilustración 17. Gráfico. Modelo Linealpor o en Ilustración: 17
3.1.24.2.
Modelo Espiral
Su característica principal es la reducción de riesgo del proyecto mediante el estudio minucioso de la viabilidad en todos sus casos: Legal, Financiera, etc. Está compuesto de cuatro etapas: Determinación de objetivos, Análisis del Riesgo, Desarrollo y Pruebas por último Planificación. El inicio de la espiral en el centro determina el inicio de la realización del proyecto, la fortaleza de este modelo es la gestión de riesgo durante el desarrollo de cada etapa para su corrección inmediata, a diferencia del lineal o en cascada se puede realizar modificación o correcciones durante cualquier punto del desarrollo sin que afecte el progreso. Lo negativo es que genera mucho tiempo de desarrollo, exige un conocimiento en gestión de riesgos, es un modelo costoso y el modelo no puede ser probado en ejecución sin antes terminar todos los módulos en desarrollo.
Título: Modelo en Espiral. Fuente: Ilustración tomada de: Ilustración 18. Gráfico. Modelo en Espiral http://upload.wikimedia.org/wikipedia/commons/thumb/3/39/ModeloEspiral.svg/359px-ModeloEspiral.svg.png. Ilustración: 18
3.1.24.3.
Modelo Prototipado o de Prototipos
34
Este modelo es utilizado cuando los datos de entrada, proceso y salida no están totalmente definidos, y en base a la construcción total o parcial de la aplicación solicitada, lograr detallar y mejorar el producto final deseado conjuntamente con la colaboración permanente del usuario, quien con el programador pulirán poco a poco cada nuevo prototipo diseñado y elaborado del sistema. Entre más iteraciones se realicen, se detallará más los requerimiento y necesidades del usuario. El esquema general del funcionamiento es el siguiente:
Título: Modelo Prototipado o de Prototipos. Fuente Ilustración desarrollada por el autor Ilustración: 19 Ilustración 19. Gráfico. Modelo Prototipado o de Prototipos
Como se muestra en la gráfica luego de receptar el objetivo general del sistema, tanto en los requerimientos, el diseño y el sistema de prototipo cuentan con un listado de revisiones que me permitirán realizar correcciones sobre la marcha al mismo tiempo que el cliente supervisa su desarrollo, y en caso de que se desee modificar, eliminar o agregar, el modelo lo permitirá mediante el retorno a la etapa anterior para su debida implementación. 3.1.25. Base de Datos Similar a un almacén o a una bodega, las bases de datos nos permiten guardar cualquier tipo de dato en su interior permitiéndonos mantenerlos ordenados de forma que la búsqueda de cualquiera de sus datos almacenados se lo pueda realizar de forma rápida.
35
3.1.26. Ejemplo de Sistemas de Base de Datos Actualmente tenemos varios sistemas gestores de bases de datos (SGBD), de entre los cuales tenemos: 3.1.26.1.
Oracle
Considerado el más potente SGBD (Sistema Gestor de Base de Datos) surge en 1977 con el nombre de SDL (Software Development Laboratories), cuenta con un poderoso gestor que permite trabajar con bases de datos en ámbitos empresariales a mayor escala tanto para aplicaciones de escritorio como para aplicaciones web entre los campos más utilizados. A demás de contar con versiones pagadas cuenta con versiones exprés que permiten trabajar con ciertas limitantes pero sin dejar de lado lo robusto y potente. Entre sus características tenemos: Soporte de transacciones para gran cantidad de tareas y procesos, estabilidad en la oferta de un producto eficiente, escalabilidad para el crecimiento oportuno de las aplicaciones y soporte multiplataforma permitiendo la interacción de los datos sin importar el sistema operativo. 3.1.26.2.
PostgreSQL
Es el mayor SGBD libre con características similares a Oracle, es liderada por el Grupo de Desarrollo GlobalPostgreSQL, una comunidad de desarrolladores que trabajan desinteresadamente por mantener a flote este proyecto desde 1982. Entre sus características tenemos: Alta concurrencia para cantidades grandes de conexiones de usuarios a los datos, integridad de datos con restricciones de dominios, integridad referencial entre los más sobresalientes.
36
3.1.26.3.
MySQL
De orígenes open Source, es uno de los SGBD más utilizados en la web como por ejemplo en Facebook, Twitter, Wikipedia entre otros. Posee una alta velocidad de procesamiento de datos como se logra ver en los portales antes mencionados, además de ser de fácil instalación y configuración para el uso de principiantes; a esto se suma la baja exigencia de recurso hardware para su implementación, lo que permite ser instalado en equipos antiguos con escasos recurso sin problema alguno. Usa licencia GPL (Licencia Pública General), lo cual permite al usuario final no solo usarlo sino también estudiar su código, modificarlo y compartirlo a gusto personal.
3.2.
Investigaciones o experiencias empíricas vinculadas con el problema de investigación
Las experiencias obtenidas son muchas, de entre las más relevantes está el viaje a la ciudad de Riobamba para visitar la escuela de electrónica, en la cual encontré documentación sobre los microcontroladores PIC los cuales fueron mi primera selección antes que los AVR. Con este documento conocí como es el proceso que pasa una placa electrónica antes de quedar como comúnmente la vemos en los electrodomésticos aunque desarrollada en forma doméstica. Esto produjo serios problemas para el desarrollo del proyecto por cuanto no se contó con conocimientos básicos para iniciar esta travesía del desarrollo de la placa. Por dos ocasiones diferentes visite la ciudad de Quito primero fue a la Universidad Católica y la Politécnica Nacional, pero no obtuve mayores resultados la segunda ocasión fue para visitar al Ing. Electrónico Macías, ex catedrático de la antigua universidad de Colombia en Santo Domingo, quien se asombró que un alumno de
37
sistemas computacionales investigue el tema, sin embargo la visita fue productiva porque me ilustre más en el tema de microcontroladores, su funcionamiento, características y variedades en el mercado. El tema de tesis me llevo además a una investigación más profunda del funcionamiento de un ordenador y la interactividad entre sus componentes. Así mismo, el tema de la electrónica produjo problemas por lo que su investigación fue constante sobre todo durante el desarrollo de la circuitería, desde como encender un led, como conectar los pulsadores, hasta la programación de la placa con la activación o desactivación de los puertos y sus respectivos voltajes. La placa Arduino Due tiene la particularidad de trabajar con 3 voltios a diferencia de las demás que generalmente trabajan a 5 voltios, característica que exigió mayor cuidado para evitar quemarla. Otro punto a investigar fue la programación en java sobre todo la programación para comunicar la aplicación de usuario con la placa. Este punto tuvo la problemática de la recepción y descomposición de la cadena de caracteres con los parámetros del sistema para encender o apagar las luces, verificación de ciclos, almacenamientos de datos en la base y configuraciones varias. El punto problemático se centró en que la lectura de los caracteres del puerto serial, se realizaba constantemente lo cual impedía saber en qué momento culminaba una cadena y empezaba otra, esto llevo a profundizar el tema de la comunicación entre la placa y el ordenador lo que llevo a investigar más a fondo el uso de nuevas librerías llegando así a conocer la existencia de eventos en la comunicación serial, lo cual fue la solución para descomponer los parámetros de la cadena enviada desde la placa al sistema.
38
La programación de la placa también produjo inconvenientes por cuanto no era posible una programación secuencial como las aplicaciones desarrolladas por mi persona hasta el momento. Se requerían realizar varias tareas instantáneamente y estar a la espera de la activación de cualquiera de los 24 pulsadores al mismo tiempo. Existieron dos alternativas: la programación por hilos y las interrupciones; aprovechando las características de la placa se escogió e investigó el tema de las interrupciones, así mismo fue un tema nuevo que aprender por lo que tomo muchas semanas entender su funcionamiento. Estas son las investigaciones y experiencias más relevantes obtenidas durante el desarrollo del proyecto.
3.3.
Hipótesis de Trabajo
La implantación del proyecto “Prototipo de semáforos inteligentes”, coadyuvará a optimizar el tiempo de duración de cada una de las luces de los semáforos, y por ende ayudará también a una mejor fluidez del tránsito en las avenidas.
39
4. 4.1.
METODOLOGÍA DE LA INVESTIGACIÓN
Diseño/Tipo de Investigación
Se inicia el proyecto con un diseño no experimental por cuanto no se dispone de datos iniciales, ni antecedentes del uso o implementación de semáforos inteligentes en la ciudad de Santo Domingo. Por tal razón se investiga en el municipio su existencia y se estudian los casos académicos realizados en universidades y casos de implementación en otras ciudades dentro y fuera del país. Durante este proceso no se manipula ningún resultado, dedicando el tiempo únicamente a la observación. 4.1.1. Investigación Transversal Exploratorio Desde un enfoque cuantitativo, inicialmente se aplica el diseño transversal exploratorio de la investigación no experimental, por cuanto la información respecto al tema de semáforos inteligentes es escasa en esta provincia y en el país. Para esto se buscó información en el municipio de la ciudad de Santo Domingo, específicamente en la casa tres que concierne a la empresa municipal de tránsito (actualmente ANT Agencia Nacional de Transporte). De acuerdo a los datos obtenidos mediante la aplicación de técnicas de recolección de datos, se logró confirmar que no existen semáforos inteligentes en la ciudad de Santo Domingo, pero que en la primera semana del mes de septiembre del presente año, se firmó un contrato para la adquisición de semáforos peatonales y de tránsito para 96 intersecciones. Se investigó cómo funcionan los semáforos inteligentes en ciudades dentro y fuera del país, que ciudades cuentan con esta tecnología y demás datos que dieron origen a la investigación del proyecto. En las universidades se investigó proyectos relacionados con el tema pero aplicando recursos y funcionamientos diferentes a los propuestos en
39
40
el proyecto. A esto se suma la investigación en sitios y portales web como complemento de las investigaciones realizadas anteriormente. 4.1.2. Investigación Proyectiva Considerando que hay situaciones que no están caminando como debieran, porque no se están aprovechando todas las potencialidades disponibles surge la necesidad de modificarse la realidad presente, para ello se hace uso de la investigación proyectiva, por cuanto se ha diseñado un prototipo que cambiará la situación actual de cómo gestionar el tránsito en la provincia. 4.1.3. Investigación de Campo Este tipo de investigación se llevó a cabo en la población de conductores y todo el ambiente que enmarca el tránsito vehicular, siendo necesario para esto, las técnicas de recolección de datos como; la observación, la entrevista y las encuestas.
4.2.
Población
Se consideran como población para este proyecto a los conductores activos habitantes de la ciudad de Santo Domingo.
4.3.
Muestra
Se determinará una muestra no probabilística por juicio, ya que se investigará a los conductores de taxis, que son un gremio representativo dentro del tránsito vehicular de la provincia; específicamente en la Cooperativa 19 Transplayasa que está conformada por 128 socios taxistas (Ver Anexo 2).
4.4.
Instrumentos de Recogida de Datos
Los instrumentos utilizados son:
41
4.4.1. Observación Vital para el inicio de la investigación, permitió obtener una visión general de los puntos relevantes del funcionamiento y antecedentes de los semáforos, tanto de los convencionales como de los inteligentes. 4.4.2. Entrevista Se entrevistó al Ing. Alex Rojas Técnico de Transporte de la provincia (Formato entrevista, ver Anexo 3), tiempo durante el cual se obtuvo resultados que confirma la inexistencia de semáforos inteligentes, las características de los semáforos actualmente funcionando y las proyecciones que tiene la Agencia Nacional de Transporte en la provincia. 4.4.3. Encuestas Se realizó encuestas (Ver Anexo 4) dirigidas a conductores de vehículos de la ciudad de Santo Domingo por medio de volantes de persona a persona, con el objetivo de conocer el grado de conocimiento y aceptación de los semáforos de tránsito.
4.5.
Técnicas de análisis de datos
Una vez aplicada la entrevista y las encuestas se procede a ordenar, analizar y tabular los datos recolectados por los respectivos instrumentos. 4.5.1. Entrevista Dirigida a: Ing. Alex Rojas Técnico de Transporte de la Provincia de Santo Domingo de los Tsáchilas. Entrevistador: Sr. Gerardo Sotomayor. Objetivo: Conocer la situación actual y futura del funcionamiento de los semáforos de tránsito de la provincia de Santo Domingo de los Tsáchilas.
42
1. De acuerdo a su tecnología. ¿Qué tipo de semáforos operan en la provincia? Síntesis La mayoría de los semáforos que operan en la provincia son mecánicos con un sistema eléctrico, que son los más antiguos y los últimos en adquirir, los semiautomáticos con iluminación led. Análisis Aun se trabaja con tecnología obsoleta en equipos de suma importancia para el direccionamiento del tránsito vehicular, es vital se reemplacen con equipos modernos que permitan mayor control del tránsito. Por otra parte los semáforos semiautomáticos constituyen un avance para llegar al objetivo deseado. 2. ¿Cómo es la estructura y funcionamiento del sistema de semaforización actual? Síntesis Su estructura es descentralizada, debido a que se deben de configurar manualmente los tiempos de las luces para cualquier cambio que se desee realizar. El funcionamiento de los semáforos convencionales se basa en un sistema eléctrico que requiere el cambio de resistencias y capacitores para la variación de tiempos de las luces lo que impide contratar a cualquier persona para su mantenimiento. En cuanto a los semiautomáticos, trabajan con componentes electrónicos como las placas programables que requieren de programación para su configuración de luces; estos semáforos a diferencia de los convencionales que trabajan con focos, éstos trabajan con matrices led para iluminación.
43
Análisis El uso actual de los semáforos convencionales en la mayor parte de las intersecciones semaforizadas produce un elevado costo de mantenimiento, mayor tiempo de configuración, a más de la dificultad de encontrar y contratar personal técnico calificado para su mantenimiento, esto resalta la necesidad de iniciar una estandarización de tecnologías de los semáforos para erradicar el problema del mantenimiento que es la causante de que las intersecciones semaforizadas permanezcan por mucho tiempo deshabilitadas ya sea a causa de la falta de personal técnico capacitado o adquisición de repuesto que no se encuentran fácilmente en el mercado. Además, de la estandarización es vital una comunicación centralizada entre los semáforos para la configuración rápida y coordinada ya que realizarla manualmente produce un desfase en la sincronización al momento de encenderlos uno a uno. 3. ¿Cuáles son las debilidades y amenazas detectadas en el sistema de semaforización utilizado hasta el momento? Síntesis La configuración manual de los semáforos es una gran debilidad que causa desfases al encenderlos, junto con la dificultad de encontrar tanto personal técnico capacitado como los repuestos para las reparaciones ya que no se encuentran fácilmente en el mercado local. El clima húmedo de la provincia es un factor que influye en el funcionamiento de los semáforos causando averías por el óxido que produce la humedad reduciendo el tiempo de funcionamiento de todos los semáforos.
44
Análisis Es notoria la necesidad de una estandarización de tecnología y una comunicación centralizada de los semáforos ya que esto facilitaría el mantenimiento y configuración de los equipos con personal que lograría contratar de entre los habitantes de la provincia y en cuanto a los repuestos serían más factible de encontrarlos aquí o en una ciudad dentro del país en cuestión de horas. 4. ¿Qué proyecciones se tiene planificado en el tema de la implementación de semáforos inteligentes en la ciudad de Santo Domingo? Síntesis En la primera semana del mes de septiembre de este año, se firmó un contrato para la adquisición de semáforos inteligentes para 96 intersecciones de la provincia. Se tiene planificado durante el primer trimestre la llegada de los equipos y el inicio de la implementación. Se tiene planificado la implementación de un prototipo en la intersección de la Av. Jacinto Cortez y Av. Del Cooperativismo para la observación de su desempeño. Análisis Con poco tiempo de haberse inicializado la ANT (Agencia Nacional de Transito) provincial a cargo del municipio, se tiene una planificación acorde a las necesidades existentes, hasta el momento se mantienen las expectativas del funcionamiento en general del sistema a implementarse. 4.5.2. Encuestas Dirigido a: Conductores de la Compañía de taxi Transplayasa S.A. Número 19.
45
Objetivo: Conocer el grado de conocimiento y aceptación de los semáforos de tránsito. Pregunta 1: ¿Está de acuerdo con el funcionamiento de los semáforos convencionales en la ciudad de Santo Domingo? Pregunta 1 Opciones
Personas
Porcentajes
A. Muy de acuerdo
10
7,8%
B. De acuerdo
37
28,9%
C. Indiferente
20
15,6%
D. En desacuerdo
46
35,9%
E. Muy desacuerdo
15
11,7%
TOTAL
128
100%
Título: Tabulación pregunta 1. Encuesta a Conductores. Ilustración 20. Tabla Tabla.elaborada Tabulación Encuesta a Conductores. Fuente: por pregunta el autor, en1.base a las encuestas realizadas. Ilustración: 20
Pregunta 1 Personas
60
46
37
40
20 20
15
10
0 A
B
C Opciones
D
E
Título: Estadística pregunta 1. Encuesta a Conductores. Ilustración 21. Gráfico. Estadística pregunta 1. Encuesta a Conductores. Fuente: Gráfico elaborado por el autor, en base a las encuestas realizadas. Ilustración: 21
Análisis El funcionamiento de los semáforos no es el deseado según la mayoría de los conductores, ya que el 11,7 % de los encuestados está muy desacuerdo que sumados con quienes están en desacuerdo suman el 47,6%. Estos resultados dan a reflejar el grado de descontento y aceptación del sistema actual de semaforización.
46
Pregunta 2: ¿Cómo califica el funcionamiento de los semáforos convencionales?
Pregunta 2 Opciones
Personas
Porcentaje
A. Excelente.
4
3,1%
B. Muy Bueno.
14
10,9%
C. Bueno.
30
23,4%
D. Regular.
55
43,0%
E. Pésimo.
25
19,5%
128
100%
TOTAL
Título: Tabulación pregunta 2. Encuesta a Conductores. Ilustración Fuente: 22. Tabla Tabla. elaborada Tabulación por el autor, pregunta en base 2. Encuesta a las encuestas a Conductores. realizadas. Ilustración: 22
Personas
Pregunta 2 60 50 40 30 20 10 0
55 30
25
14 4 A
B
C Opciones
D
E
Título: Estadística pregunta 2. Encuesta a Conductores. Ilustración 23. Gráfico. Estadística pregunta 2. Encuesta a Conductores. Fuente: Gráfico elaborado por el autor, en base a las encuestas realizadas. Ilustración: 23
Análisis Los resultados de esta pregunta se asocian a los resultados de la pregunta anterior, ya que se califica el funcionamiento de los semáforos como pésimo en un 19,5%, lo que da a pensar en la posibilidad de una mejora en el sistema actual de semaforización. El porcentaje de aceptación entre excelente, muy bueno y bueno suman 36,5% con lo que se considera que puede esperar hasta que planifiquen nuevas mejoras.
47
Pregunta 3: El tiempo de duración de las respectivas luces de los semáforos actuales debe:
Pregunta 3 Opciones
Personas
Porcentaje
A. Aumentar el tiempo.
17
13,3%
B. Disminuir el tiempo.
20
15,6%
C. Auto ajustarse el tiempo, en función de los vehículos en cola.
60
46,9%
D. Mantenerse como están.
31
24,2%
128
100%
TOTAL
Título: Tabulación pregunta 3. Encuesta a Conductores. Fuente: Tabla elaborada por el autor, base aa Conductores. las encuestas realizadas. Ilustración 24. Tabla. Tabulación preguntaen 3. Encuesta Ilustración: 24
Personas
Pregunta 3 70 60 50 40 30 20 10 0
60
31 17
20
A
B
C
D
Opciones Título: Estadística pregunta 3. Encuesta a Conductores. Ilustración 25. Gráfico. Estadística pregunta 3. Encuesta a Conductores. Fuente: Gráfico elaborado por el autor, en base a las encuestas realizadas. Ilustración: 25
Análisis Es notoria la sugerencia emitida en los resultados obtenidos; por lo que el 46,9% de entrevistados considera, que los tiempos de las luces se deben auto ajustar en función de los vehículos en cola, lo que podría satisfacer también al 13,3% de aumentar el tiempo y al 15,6 % de disminuirlo, por lo que la configuración puede cambiar según los vehículos en cola. Estos resultados sustentan la creación de un prototipo para auto ajustar los tiempos de las luces en función a la presencia de vehículos en cola.
48
Pregunta 4: ¿Cómo califica la tecnología de los semáforos que Ud. ha visto en el centro de la ciudad?
Pregunta 4 Opciones
Personas
Porcentaje
A. Excelente.
10
7,8%
B. Buena.
44
34,4%
C. Regular.
51
39,8%
D. Pésima.
23
18,0%
TOTAL
128
100%
Título: Tabulación pregunta 4. Encuesta a Conductores. Fuente: por el autor, en4.base a las encuestas realizadas. Ilustración 26.Tabla Tabla.elaborada Tabulación pregunta Encuesta a Conductores. Ilustración: 26
Pregunta 4 60
51 44
Personas
50 40 30 20
23 10
10 0 A
B
C
D
Opciones Título: Estadística pregunta 4. Encuesta a Conductores. Fuente: Gráfico elaborado por el autor, en base a las encuestas realizadas. Ilustración 27. Ilustración: 27Gráfico. Estadística pregunta 4. Encuesta a Conductores.
Análisis Cerca de la quinta parte no está conforme y considera pésima la tecnología de los semáforos observados en el centro de la ciudad. Mientras que el 39,8% la considera regular, esto se debe gracias a los modelos semiautomáticos implementados en la mayoría de las intersecciones más concurridas en la ciudad.
49
Pregunta 5: ¿Qué grado de eficacia considera que tienen los semáforos convencionales, para dirigir el tránsito vehicular?
Pregunta 5 Opciones
Personas
Porcentaje
A. Muy eficientes
24
18,8%
B. Poco eficientes
70
54,7%
C. Ligeramente eficientes
16
12,5%
D. Nada eficientes
18
14,1%
128
100%
TOTAL
Título: Tabulación pregunta 5. Encuesta a Conductores. Fuente: 28. Tabla elaborada por el autor, en base a las encuestas realizadas. Ilustración Tabla. Tabulación pregunta 5. Encuesta a Conductores. Ilustración: 28
Pregunta 5
Personas
80
70
60 40
24
20
16
18
C
D
0 A
B Opciones
Título: Estadística pregunta 5. Encuesta a Conductores. Fuente: Gráfico elaborado por el autor, en base a las encuestas realizadas. Ilustración: 29 Ilustración 29. Gráfico. Estadística pregunta 5. Encuesta a Conductores.
Análisis Poco eficientes, es lo que califica un 54,7%, lo que indica que es aceptable su desempeño, de lo cual no está de acuerdo un 14,1% que lo considera nada eficientes, esto concluye en que no se tiene la excelencia pero su desempeño es aceptable por la mayoría.
50
Pregunta 6: ¿Está informado sobre los Semáforos Inteligentes?
Pregunta 6 Opciones
Personas
Porcentaje
A. Muy informado
10
7,8%
B. Poco informado
63
49,2%
C. Ligeramente informado
22
17,2%
D. Nada informado
33
25,8%
128
100%
TOTAL
Título: Tabulación pregunta 6. Encuesta a Conductores. Fuente: Tabla elaborada por el autor, en base6.a Encuesta las encuestas realizadas. Ilustración 30. Tabla. Tabulación pregunta a Conductores. Ilustración: 30
Pregunta 6
Personas
80
63
60 33
40 20
22 10
0 A
B
C
D
Opciones Título: Estadística pregunta 6. Encuesta a Conductores. Fuente: Gráfico elaborado por el autor, en base a las encuestas realizadas. Ilustración: Ilustración 31. 31 Gráfico. Estadística pregunta 6. Encuesta a Conductores.
Análisis Cerca de la cuarta parte de los encuestados un 25,8%, no están informados del tema de semáforos inteligentes, lo que indica que el tema es aun nuevo y revolucionario. De los encuestados cerca de la mitad es decir el 49,2%, están empezando ya a conocer algo sobre sus funciones y características, lo que brinda posibilidad de aceptación a esta nueva tecnología.
51
4.6.
Análisis y selección de herramientas para el desarrollo
4.6.1. Entorno de Desarrollo Integrado De entre los revisados en el tercer capítulo, la mejor opción escogida por su cantidad de información disponible, escalabilidad, facilidad de uso, calidad y costo es Netbeans IDE versión 7.3, ya que JDeveloper Studio podrá tener mayor calidad, escalabilidad y herramientas pero así mismo su manejo o uso implica mayor grado de conocimiento a más que la dimensión del presente proyecto a desarrollar no requiere ni exige de herramientas tan avanzadas. Por otra parte Visual Studio proporciona un fácil manejo para el programador, cuenta con mucha ayuda en red pero se prefiere mantener la posibilidad de que en un futuro aumente la escalabilidad del proyecto a un nivel de web para su posible implementación en la realidad, además de mantener la filosofía de software y hardware libre. 4.6.2. Base de Datos Si bien es cierto el más potente y robusto Sistema Gestor de Base de Datos de entre los tres (Oracle, PostgreSQL y Netbeans) es sin dudas Oracle, pero su éxito es a la vez una debilidad para su implementación en este proyecto debido a que requiere de mayor recurso de hardware que las dos opciones restantes, además que no se utilizará ni el 80 % de sus capacidades debido a la naturaleza del proyecto a desarrollar. Por otra parte PostgreSQL tiene la ventaja al igual que MySQL de ser open source junto a su potente desenvolvimiento, pero su desventaja es la cantidad de información en cuanto a su manejo y la escasa frecuencia de uso y dominio por parte del desarrollador del proyecto; lo que lo convierte a MySQL en la mejor opción ya que a diferencia de los anterior mencionados utiliza menor cantidad de recurso físico para
52
su instalación manteniendo la eficiencia en su operatividad y sus demás características mencionadas anteriormente. 4.6.3. Herramientas Adicionales A más del software mencionado hasta el momento, se necesitan herramientas adicionales para un mejor desenvolvimiento del desarrollo de la aplicación de usuario como por ejemplo JasperReports, la cual es una herramienta que mantiene el mismo lineamiento y tendencia tanto del IDE como del SGBD seleccionados. Esta herramienta es un conjunto de librerías basadas en java la cual se adjunta al proyecto, con la tarea de ayudar en la generación de reportes gracias a la ayuda de un front-end gráfico como lo es iReport, el cual ayuda mediante su entorno visual a la recolección de parámetros y demás datos necesarios, para la generación de los reportes deseados. También Inkscape utilizado para la elaboración del diseño del circuito de la placa base de la Arduino DUE.
4.7.
Análisis y selección del modelo de desarrollo del software
De entre los tres modelos de desarrollo de software revisados en el tercer capítulo, el adecuado para este proyecto es el modelo Prototipado o de Prototipos, ya que se necesita desarrollar una y otra vez una muestra de producto parcial o final, para irlo modificando según se crea conveniente, además de ir verificando constantemente su viabilidad en cada iteración obtenida. El Lineal o en cascada se lo omite por cuanto no permite el retorno a una etapa anterior en caso de aparecer un imprevisto y por la falta de gestión de riesgos. Por otro lado el modelo espiral requiere de mayor disponibilidad de recursos, además de ser más complejo que los anteriores.
53
4.8.
Desarrollo del proyecto
Para el desarrollo del prototipo se toma en consideración las herramientas seleccionadas anteriormente y sobre todo el modelo de desarrollo escogido (Ver Ilustración 19), el cual marca el camino durante cada una de las siguientes etapas: 4.8.1. Requerimientos del Sistema Se requiere que el prototipo de semáforos inteligentes cuente con las siguientes exigencias:
Control del tránsito vehicular en una intersección de dos calles con dos carriles cada una en sentido vehicular: norte-sur, sur-norte, este-oeste y oeste-este.
Cambio automático de luz verde en caso de no existir vehículos en una de las calles.
Cambio automático a luz amarilla parpadeante en caso de no existir vehículos en espera en la intersección.
Cambio de luz verde en caso de que el flujo vehicular no avance por un determinado tiempo.
Visualización de mensaje de aviso en caso de un atascamiento vehicular prolongado.
Control de encendido y apagado de los semáforos.
Manejo de tres tipos de funcionamiento: o Inteligente.- Realice cambio de luces en base a parámetros configurados por los usuarios y según la ausencia de vehículos en la intersección. o Automático.- Realice cambio de luces en base a parámetros configurados por los usuarios sin tener en consideración la ausencia de vehículos.
54
o Intermitente.- Encendido y apagado continuo de las luces amarillas por lapsos de 2 segundos.
Visualización de la cantidad de vehículos que ingresan y salen por cada flujo vehicular durante el día.
Configuración de los tiempos de cambios de luces para cada semáforo en segundos.
Visualización del estado y cambio de luces de los semáforos en pantalla.
Generación de reportes con la cantidad de vehículos que circulen por la intersección en una fecha dada.
Configuración de parámetros para la comunicación con la placa electrónica.
Gestión de Usuarios con tres tipos: Administrador, Supervisor y Operador con restricciones de acceso al sistema dependiendo del tipo de usuario.
4.8.2. Requerimientos del Prototipo Inicialmente se consideraron necesarios los siguientes requerimientos, para el desarrollo del prototipo:
Uso de pulsadores para contar la presencia de vehículos.
Uso de luces LED para los semáforos.
Desarrollo de una placa electrónica para consolidar los componentes electrónicos.
Creación de una maqueta para representar una intersección con los semáforos junto con la placa electrónica.
Un ordenador de cuarta generación.
Uso de un entorno de desarrollo visual para la creación de la aplicación de control para el usuario.
55
Búsqueda y selección de una herramienta de simulación para constatar el funcionamiento de la parte electrónica antes de adquirir componentes.
PostgreSQL para el almacenamiento de los datos.
Estos fueron los requerimientos iniciales que se proyectó para el desarrollo del prototipo, pero durante el transcurso de las innumerables revisiones que se realizaron durante el diseño y el sistema de prototipo, se dieron cambios que obligaron a reconsiderar la adición y modificación de los siguientes requerimientos del prototipo para lograr los requerimientos del sistema:
Según lo detallado en la etapa de Sistema prototipo se ve la necesidad de aumentar el requerimiento de una placa Arduino Due, la cual trabaja con un micro controlador como componente principal. Inicialmente se pensó controlar los leds y pulsadores mediante el uso del puerto paralelo pero esto no fue suficiente al momento de la programación.
Por otro lado la opción de elaborar una placa electrónica, temporalmente se eliminó por cuanto se optó por el uso de la placa arduino, pero antes de dar por culminada la etapa del desarrollo, se notó que la distribución y presentación de los cables que interconectaban los leds y los pulsadores con la placa arduino DUE era desorganizada. Así que se optó nuevamente por la construcción de una placa de circuitos que permita la distribución y organización de los cables con la arduino, con la diferencia de que esta nueva placa solo utilizaría borneras para sujetar la punta de los cables y pines para unir las dos placas como se detalla en la etapa de Diseño del Prototipo.
Se decide el cambió a MySQL para el almacenamiento de datos según lo requerido en la etapa de desarrollo.
56
En cuanto se continuaba con el desarrollo la lista de materiales y herramientas aumentaba progresivamente entre los cuales se detallan en el anexo 5.
4.8.3. Diseño del Prototipo Se diseñó varias interfaces para el sistema de control del usuario y esquemas para el desarrollo de la parte electrónica. Éstos se fueron modificando en base a las revisiones realizadas en cada una de las etapas del modelo Prototipado. 4.8.3.1.
Diseño del hardware
Se inició por el lado del hardware, para ello se realizó en el programa proteus un esquema electrónico de los leds para los semáforos y su futura distribución en la placa electrónica como se visualiza a continuación:
Ilustración 32.Pantalla Imagen.de Pantalla decon Proteus con un ejemplo de pulsadores. Título: Proteus un ejemplo de pulsadores.
Fuente: Ejemplo realizado por el autor. Ilustración: 32
Esto permitiría en la etapa siguiente realizar con el código respectivo, una simulación del funcionamiento. Pero como los requerimientos del prototipo cambiaron en base a la adquisición de la placa arduino, este diseño resultó innecesario temporalmente.
57
Una vez que se programó adecuadamente la placa Arduino Due en la etapa de Sistema Prototipo, se presentó la necesidad de realizar revisiones en la parte del diseño electrónico, implementando así, una nueva placa de circuito para la organización y distribución de los cables que interconecte la Arduino Due con los cables de los pulsadores y leds de los semáforos. A continuación se visualizan las versiones realizadas hasta llegar al resultado final.
Título:Ilustración Elaboración del esquema electrónico de la placa para la organización y distribución de los 33. Imagen. Elaboración del esquema electrónico de la placa para la organización y cables. Fuente: Esquema realizado por el autordistribución en el programa Inkscape. de los cables. Ilustración: 33
La elaboración del diseño final fue muy complicada por cuanto los pines de la placa a desarrollar debían cuadrar exactamente con los orificios de los puertos de la placa Arduino Due. Establecido el diseño anterior de procedió con el diseño electrónico para la distribución de los puertos de la placa Arduino, hacia los pulsadores y luces de los semáforos. Se obtuvo varios diseños, en el segundo solo se redistribuyó los números
58
de puertos, ya que la elaboración de la placa para conectar con la Arduino Due tuvo una reestructuración por inconvenientes durante su elaboración. En la siguiente imagen se visualiza la ubicación de los pulsadores y luces de los semáforos en relación a los puertos de la placa arduino due.
Título: Distribución y ubicación de puertos de entrada y salida de la placa Arduino DUE. Fuente: Diseño realizado por el autor. Ilustración: 34
Ilustración 34. Imagen. Distribución y ubicación de puertos de entrada y salida de la placa Arduino DUE.
El envío de datos entre la placa arduino y el ordenador durante la programación, produjo conflictos para el control de los semáforos, lo que obligó a realizar revisiones en el diseño para elaborar un cuadro que ayude a ordenar el envío y recepción de una cadena que contenga los datos para la configuración tanto de la placa como el almacenamiento de la cantidad de vehículos en la base de datos. Es así que se resuelve la siguiente solución:
59
Título: Estructura de las cadenas de texto para la comunicación entre el ordenador y la placa Arduino DUE. Ilustración 35. Tabla. Estructura de las cadenas de texto para la comunicación entre el ordenador y la Fuente: Tablas realizadas por el autor. placa Arduino DUE. Ilustración: 35
En la primera tabla se detalla la estructura de la cadena para enviar los parámetros de configuración desde el ordenador, hacia la placa arduino due. Mientras que en la segunda se detalla las cadenas que se envía en sentido contrario, es decir, desde la placa arduino due, hacia el ordenador. Estas tablas permiten establecer la forma en que se envía y reciben los valores para las diferentes variables que controlan el funcionamiento tanto del micro controlador como de la aplicación de escritorio. 4.8.3.2.
Diseño del Software
Durante la realización de las interfaces para el usuario, se obtuvo varias versiones resultantes de las revisiones realizadas.
60
Las interfaces iniciales desarrolladas fueron las siguientes:
Título:36. Proceso deProceso desarrollo de la primera sistema control el usuario. Ilustración Imagen. de desarrollo de lainterfaz primeradel interfaz delde sistema de para control para el usuario. Fuente: Diseños realizados por el autor. Ilustración: 36
Estas interfaces fueron diseñadas para visualizar en el formulario principal como se movilizaban los vehículos que ingresan y salen de la intersección. El cuadro de la línea de tiempo de los semáforos que se visualiza en la ilustración anterior, era para modificar la distribución de tiempos en los semáforos. Este diseño se modificó por cuanto no es posible determinar por cual salida se dirige un vehículo que entra por el norte, sur, etc. Las imágenes restantes de la ilustración anterior muestran cómo se fue realizando una de las primeras interfaces para el sistema de control para el usuario y el sentido de los flujos de tránsito en la intersección. Para la configuración de los semáforos, se planificó crear horarios de transición para cada día de la semana. A continuación se muestra el proceso de creación de los horarios mostrando paso a paso su proceso:
61
Título: Proceso de elaboración de horarios para el funcionamiento de los semáforos. Fuente: Diseños de Interfaz realizados por el autor. Ilustración: 37
Ilustración 37. Imagen. Proceso de elaboración de horarios para el funcionamiento de los semáforos.
Para la asignación de los segundos para el encendido de cada luz de los semáforos se dispuso lo siguiente:
Título: Proceso de Asignación de tiempos para cada horario de la semana. Fuente: Diseños de Interfaz realizados por el autor. Ilustración: 38
Ilustración 38. Imagen. Proceso de Asignación de tiempos para cada horario de la semana.
Este nuevo conjunto de interfaces para la asignación de tiempos para cada horario de la semana, tuvo un inconveniente, que se encontró en la revisión del sistema de
62
prototipo en el cual los semáforos inteligentes exigían adaptabilidad de los cambios de luces según la presencia de vehículos, como lo especificaba uno de los requerimientos del sistema y no en base a un horario establecido, esto obligó a modificar nuevamente las interfaces. El diccionario de datos resultante hasta esta interface fue el siguiente:
Título:39. Diccionario de Datosdey Datos Registros de Tablas para laspara primeras interfaces de usuario. Ilustración Tabla. Diccionario y Registros de Tablas las primeras interfaces de usuario. Fuente: Tablas realizadas por el autor. Ilustración: 39
La siguiente revisión se encaminó de mejor manera la interfaz final ya que contenía la mayor parte de los requerimientos, permitiendo crear una interfaz más amigable para el usuario, mejorando la distribución de tiempos y organizando los datos de una forma adecuada tanto los de configuración como los receptados por la placa. Junto a la nueva interfaz, el diccionario de datos correspondiente:
63
Título: Diseño de Interfaz de Usuario. Fuente: Diseño de interfaz realizado por el autor. Ilustración: 40
Ilustración 40. Imagen. Diseño de Interfaz de Usuario.
Título: Segundo Diccionario de datos. Fuente: Tablas realizadas por el autor. Ilustración: 41
Ilustración 41. Tabla. Segundo Diccionario de datos.
Al avanzar, nuevamente se obtuvo un problema con la asignación de los tiempos en la etapa del sistema Prototipo, por lo que se reconsidero en el diseño la asignación de tiempos en base a los ciclos con que cuentan los semáforos en vez de asignar individualmente a las luces, obteniendo un total de 6 ciclos. A esto se sumó la implementación de viñetas para así incluir en una ventana todo lo requerido. Se visualiza la siguiente interfaz junto con su respectivo diccionario de datos:
64
Título: Modificación de Interfaz de Usuario con ciclos y pestañas. Fuente: Diseño de Interfaz realizado por el autor. Ilustración: 42
Ilustración 42. Imagen. Modificación de Interfaz de Usuario con ciclos y pestañas.
Título: Diccionario de Datos resultante de la nueva interfaz. Fuente: Tablas realizadas por el autor. Ilustración: 43
Ilustración 43. Tabla. Diccionario de Datos resultante de la nueva interfaz.
Se pasó por alto la administración de los usuarios pero sin mayor problema de adjunto una nueva pestaña en la interfaz y se redistribuyo otros elementos como se visualiza a continuación:
65
Título: Interfaz de usuario del Sistema de Control. Ilustración Imagen. Interfazrealizado de usuario delelSistema Fuente: 44. Diseño de Interfaz por autor. de Control.
Ilustración: 44
Resultado de esto se obtiene el siguiente diccionario de datos:
Título: Diccionario de Datos con implantación de los Usuarios. Fuente: Tablas realizadas por el autor. Ilustración 45. Diccionario de Datos con implantación de los Usuarios. Ilustración: 45
66
4.8.3.3.
Diseño de Maqueta
Este diseño inicialmente se consideró realizarlo encima de una caja de 50x50 cm y 15cm de altura dentro de la cual estaría la parte electrónica, pero debido a las revisiones realizadas y al tamaño de los pulsadores y luces, se consideró sacar la tapa superior y reemplazarla por una tabla de mayor tamaño sobre la cual encajaría mejor la implementación de la intersección con todos sus elementos. A continuación imágenes:
Título: Parte frontal y posterior de la Maqueta. Fuente: Imagen realizada por el autor. Ilustración: 46
Ilustración 46. Imagen. Parte frontal y posterior de la Maqueta.
4.8.4. Sistema Prototipo Esta etapa del modelo Prototipado al igual que otros modelos de desarrollo, resulta ser la más complicada y la que mayores revisiones tiene, causando además, mayores modificaciones que en las etapas anteriores. Al iniciar la parte de la programación, se decidió empezar con Visual Studio y el manejo del puerto paralelo para el control de los pulsadores y las luces led. Durante la programación se consideró pertinente el uso de un micro controlador para un mejor desempeño del sistema. Entre los micro controladores PIC y los AVR se
67
escoge el segundo por tener mayor capacidad de procesamiento a pesar de la escasa información y en cuanto al puerto se comunicación mediante el serial. Para la programación del micro controlador AVR se utilizó el programa BASCO, junto con Proteus que es un software de simulación para componentes electrónicos. A continuación se visualiza una porción de código de un ejemplo realizado para encender y apagar leds utilizando un micro controlador atmega16.
Título: Ejemplo de programación para el micro controlador realizado en Basco. Fuente: Imagen con código ejemplo realizado el autor. Ilustración 47. Imagen. Ejemplo de programación parapor el micro controlador realizado en Basco. Ilustración: 47
Esta selección de hardware y software resultó problemática por cuanto el proceso de grabación era manual y tedioso; para esto se debía conseguir un hardware específico para grabar el código desarrollado dentro del mismo. En solución al problema, se decide reemplazar el micro controlador junto con la placa electrónica establecida inicialmente, por la adquisición de una placa arduino, la cual reduciría tiempo y esfuerzo ya este hardware cuenta con una plataforma y lenguaje de programación que facilitaría el desarrollo. Se optó por la placa Arduino Uno que es la placa más sencilla. A continuación la interfaz de la plataforma de programación de arduino con un código ejemplo para encender y apagar luces en lapsos de 500 milis segundos.
68
Título: Ejemplo de programación en la plataforma de Arduino. Fuente: Imagen con ejemplo de código realizado por el autor. Ilustración 48. Imagen. Ejemplo de programación en la plataforma de Arduino. Ilustración: 48
En posteriores revisiones durante esta etapa, se presentó el inconveniente que la capacidad del micro controlador de la placa Arduino Uno a pesar de contar con 4 puertos con interrupciones, no eran suficientes ya que el diseño requiere de una interrupción por pulsador lo que suman 24 puertos con interrupciones. La solución a esta limitación la brindó la placa arduino DUE la cual cuenta con más disponibilidad de puertos e interrupciones junto con la característica principal de contar con un micro controlador más potente y velóz. Considerando que arduino es hardware libre, se decide mantener el lineamiento de software libre para la programación del sistema de control del usuario decidiendo como mejor opción a Netbeans. Y en cuanto al sistema de base de datos debido a la baja exigencia y proceso de datos a almacenar se consideró adecuado cambiar a MySQL. Las razones por las cuales se realizaron estos cambios se detallan en el análisis y selección de herramientas para el desarrollo. Una interrupción es un proceso que se puede activar al momento de recibir un impulso sobre un puerto de entrada, interrumpiendo la ejecución de cualquier procedimiento sin importar la cantidad de ocasiones que se produzca. Esto se utiliza
69
para aumentar la cantidad de vehículos mientras se realiza el cambio de luces sin alterar su funcionamiento y actualizando las variables constantemente. Como se detalló anteriormente, la parte de programación de divide en dos partes que son: el código del microcontrolador de la placa arduino DUE y el código de la interfaz de usuario desarrollada en Netbeans. El archivo de codificación del micro controlador está compuesto por las siguientes partes:
Asignación de puertos a luces y sensores.- En esta porción de código se declaran los vectores que contendrán los puertos de la placa arduino a los cuales se conectarán las respectivas luces y pulsadores.
Variables Generales.- En esta sección se declaran los vectores que sirven como banderas para determinar el estado de los pulsadores, además de las variables contadoras de vehículos.
Variables Receptoras de Parámetros del Sistema.- Se declaran las diferentes variables con las que se controla el funcionamiento de los semáforos como también la comunicación entre la placa y el ordenador. Aquí, se asignan los valores por defecto de las variables iniciales como tiempo para cada ciclo, tiempo máximo de espera, etc.
Void Setup ().- Este procedimiento es el primero en ejecutarse al encenderse la placa. En él se detalla la velocidad de la comunicación serial con el ordenador, se especifica que puertos serán de entrada y cuáles de salida, apaga todas las luces e inicia los procesos de interrupciones para los pulsadores.
Void loop ().- Se encarga de ejecutar consecutivamente los ciclos de luces de los semáforos. Estos ciclos son:
70
Título: Funcionamiento de los ciclos de los semáforos. Ilustración 49. Gráfico. Funcionamiento de los ciclos de los semáforos. Fuente: Gráfico realizado por el autor Ilustración: 49
Para cada ciclo se asigna un tiempo de espera en la interfaz de usuario y se almacena en el vector Ciclo de tipo byte. El ciclo 1 permite circular a los flujos vehiculares en sentido este-oeste y oesteeste, mientras que los restantes se mantienen en rojo. Así mismo, el ciclo 4 permite la circulación de los flujos vehiculares en sentido norte-sur y sur-norte manteniendo detenidos a los flujos vehiculares restantes.
Void ApagarTodo ().- Procede a apagar las luces de los semáforos durante el cambio de los ciclos además, de mantenerse en espera de encenderlos una vez que se envíe a apagar permanentemente las luces.
Void Ciclo_0 ().- Este ciclo permite mantener intermitentes las luces amarillas de los semáforos. Este tiempo de encendido y apagado es fijo y no configurable en la interfaz de usuario. Se ejecuta cuando no existen vehículos en espera.
Void Ciclo_1_4 (byte Par_Ciclo).- Permite ejecutar el cambio de luces de los ciclos 1 y 4, dependiendo del parámetro ingresado en la variable Par_ciclo. Al mismo tiempo que contabiliza la cantidad de vehículos que pasan por la intersección.
71
Void Ciclo_2_5 (byte Par_Ciclo).- Permite ejecutar el cambio de luces de los ciclos 2 y 5, dependiendo del parámetro ingresado en la variable Par_ciclo. Al mismo tiempo que contabiliza la cantidad de vehículos que pasan por la intersección.
Void Ciclo_3_6 (byte Par_Ciclo).- Permite ejecutar el cambio de luces de los ciclos 3 y 6, dependiendo del parámetro ingresado en la variable Par_ciclo. Al mismo tiempo que contabiliza la cantidad de vehículos que pasan por la intersección.
Void Ciclo_9 ().- Se encarga de apagar todas las luces de los semáforos y mantenerse en espera en caso de volver a encenderlos.
Void Send_Data_Sensor (byte Tipo, byte Sentido).- Envía una cadena de caracteres al ordenador con el estado de las variables de los vehículos de entrada, cola y salida para visualizar en la interfaz de usuario.
Void send_light (byte L). -Envía una cadena de caracteres al ordenador, para realizar el cambio de luces en la interfaz de usuario. El parámetro indica el ciclo que se desea enviar, junto con la letra L que es el indicador para reconocer el comando en el sistema de la PC.
Leer_Datos ().- Se encarga de leer el puerto serial de la placa, para receptar los datos enviados por el sistema de control del ordenador y asignarlos a cada una de las variables del sistema.
void Declaraciones_Interrupciones ().- En este procedimiento se realizan las interrupciones del sistema, especificando el puerto y tipo de interrupción para los pulsadores.
72
En cuanto al proyecto desarrollado para el sistema de control del usuario en netbeans, está formado por varias clases que son las que permiten conectarse tanto a la base de datos como a la placa, se detallan a continuación.
Título:Ilustración Clases y Formas del Sistema de Control de Usuario. 50. Imagen. Clases y Formas del Sistema de Control de Usuario. Fuente: Imagen del explorador de proyectos del sistema realizado por el autor en Netbeans. Ilustración: 50
ClaseSerial.java.- Permite la comunicación serial con la placa Arduino DUE.
ConexionDB.java.- Establece la conexión a la base de datos DBSemaforos con usuarios root y la contraseña semaforos2013 en el host local utilizando el conector de MySQL.
EstadisticasVehiculos.java.- Mediante la clase de conexión a la base de datos esta clase me permite trabajar sobre la tabla de los vehículos para el ingreso de registros producidos por los pulsadores desde la maqueta.
Funcionamiento.java.- Almacena y consulta los parámetros de configuración del sistema y de la placa.
Report.java.- Permite la generación de los reportes de las tablas de usuarios y de vehículos.
Splash.java.- Visualiza una balla de tiempo para la imagen de inicio del sistema.
73
Usuario.java.- Permite la inserción, modificación, eliminación de los registros de la tabla de usuarios.
FrmPincipal.java.- Es el formulario en donde se encuentran los controles que permiten la manipulación y configuración de los semáforos.
JFrameLogin.java.- Formulario de inicio del sistema, solicita el usuario y contraseña para iniciar el sistema.
La codificación del Sistema de Control para el Usuario final realizado en el programa Netbeans y la codificación para el micro controlador desarrollada en la plataforma de arduino, se detalla en el manual del programador ubicado en el anexo 8; mientras que el procedimiento de instalación de detalla en el manual de instalación adjunto en el anexo 6. En relación al desarrollo de la parte electrónica se inició realizando conexiones de resistencias con pulsadores y diodos led en un protoboard junto con la placa Arduino como se visualiza a continuación:
Título: Primera prueba de funcionamiento de pulsadores y diodos led. Fuente: Imagen Primera de práctica realizada por el autor. de pulsadores y diodos led. Ilustración 51. Imagen. prueba de funcionamiento Ilustración: 51
Luego de experimentar y verificar su funcionamiento se procedió a crear el primer semáforo, pero debido a la inestabilidad de los leds se buscó la forma de estabilizarlos.
74
Título: Primer 52. semáforo Ilustración Imagen.realizado. Primer semáforo realizado. Fuente: Imagen del primer semáforo realizado por el autor. Ilustración: 52
La mejor forma fue utilizar una placa perforada, la cual cortada en pequeños pedazos daría la estructura para luego proceder a maquetar los pulsadores y semáforos. A continuación se visualiza una imagen de los materiales utilizados, el resultado obtenido y la implementación de los pulsadores y luces led en la maqueta:
Título: Proceso de elaboración e Implementación de semáforos.de semáforos. Ilustración 53. Imagen. Proceso de elaboración e Implementación Fuente: Imágenes del proceso realizado por el autor. Ilustración: 53
La primera imagen muestra los materiales utilizados inicialmente para la elaboración de los semáforos. La segunda y tercera imagen muestra como quedaron los pulsadores junto con un semáforo, luego de cortar la placa perforada a un tamaño adecuado y de soldar los componentes. Por último se visualiza como quedan luego de implementarlos en la maqueta. Como es de notar, la organización y distribución de los cables en el protoboard no resultó ser la adecuada, se decidió construir una nueva placa para corregir esta debilidad.
75
Luego de diseñar el esquema electrónico en la etapa de Diseño regresamos a construirla en una placa virgen. A continuación imágenes de la elaboración de la placa:
1
2
3
4
5
6
Título: Proceso de elaboración de la placa para la organización y distribución de los cables.
Ilustración 54. Imagen. Proceso de elaboración de la placa para la organización y distribución de los Fuente: Imagen con proceso realizado por cables. el autor.
Ilustración: 54
Para iniciar este proceso conseguimos la placa virgen junto con un lustre de cocina (1), seguidamente lijamos esta placa con el lustre hasta que quede completamente limpia de impurezas (2). Luego se coloca el esquema realizado en el programa Inkscape sobre la superficie lijada adhiriéndola con cinta adhesiva (3). Pasamos la plancha sobre el papel por al menos 15 minutos (4). Luego se procedió con la perforación para incrustar las borneras y espadines (llamados también pines) con un taladro y broca de 1 milímetro (5); al terminar se remarcan las pistas que no estén bien definidas con un marcador indelebre (6). Lo último en realizar es sumergir la placa en un envase con ácido para resolución de placas electrónicas mesclando con agua durante 20 minutos y para terminar el proceso se la lava la placa con detergente o cualquier jabón. En la siguiente imagen, se visualizan las líneas para la circulación de la energía eléctrica pero no se encuentran bien definidas, esto se debió a la poca cantidad de
76
calor durante el planchado, el tiempo de revelación con el ácido y el tipo de papel usado en la impresión del diseño del circuito.
Título: Placa luego del planchado. Fuente: Imagen de una placa realiza por el autor. Ilustración: 55
Ilustración 55. Imagen. Placa luego del planchado.
Debido a la carencia de conocimiento y experiencia se procedió a enviar el diseño elaborado, para realizar la impresión del circuito en una placa de mayor calidad y durabilidad, ya que el tipo de placa utilizada es vulnerable a la humedad lo cual dañaría con facilidad la integridad de la misma por el clima en esta ciudad. Se adicionó un recubrimiento de barniz para que no se oxiden con facilidad las líneas junto con la soldadura de las borneras y espadines dando como resultado la siguiente placa:
Título: Placa para la Organización y Distribución de los cables junto con la Arduino Due. Fuente: Imagen de la placa diseñada por el autor. Ilustración: 56
Ilustración 56. Imagen. Placa para la Organización y Distribución de los cables junto con la Arduino Due.
77
Con esto culmina la elaboración de la placa electrónica para la organización y distribución delos cables para los pulsadores y leds. 4.8.5. Pruebas El periodo de pruebas se realizó con normalidad verificando el funcionamiento y cumplimiento de los requerimientos establecidos inicialmente. Para el manejo y uso adecuado de la aplicación de escritorio se adjunta el manual de usuario en el anexo 7. 4.8.6. Sistema Entregado Una vez realizadas las pruebas respectivas se procede a realizar la entrega del sistema íntegro, con todas sus partes debidamente desarrolladas.
78
5. 5.1.
RESULTADOS
Discusión y análisis de los resultados
Los datos obtenidos por la investigación nos dan a conocer que la tecnología de los semáforos actuales brinda un servicio básico para el direccionamiento del tránsito y que aún es tolerable para los conductores, pero aun así existe la exigencia del cambio de la tecnología utilizada y su funcionamiento. Por otra parte, el asunto del mantenimiento que brinda la Agencia Nacional de Tránsito provincial y que ha brindado la policía nacional años atrás, revela la necesidad de una estandarización de tecnologías y de una comunicación centralizada que permita facilitar y sincronizar la configuración manual que hasta el momento se ha venido realizando durante años.
5.2.
Conclusiones
El campo de aplicación de los micro controladores es muy amplia, por lo que se lo puede utilizar para la ejecución de proyectos destinados para facilitar el diario vivir.
La plataforma que brinda Arduino, es accesible para el uso de personas con nivel de conocimiento básico de programación, lo que lo convierte en una opción adecuada para la introducción al mundo de los microcontroladores sin mayores conocimientos en electrónica.
Netbeans es el software de desarrollo adecuado para todo principiante que desee iniciar a programar en java, además de contar con una extensa comunidad investigativa como apoyo.
Diseño y estructura de las avenidas, no acorde al parque automotor actual.
78
79
El sistema actual de semaforización en nuestra ciudad está llegando a un estado de obsolescencia, por lo que es necesario su cambio por un sistema actualizado.
Se observan pocas competencias en las personas que manejan el tránsito en la provincia al respecto del manejo de la tecnología de semáforos inteligentes.
Escaso conocimiento de parte de los conductores, sobre la cultura del buen conducir.
Los estudios de esta investigación brindan a la comunidad estudiantil información para el uso de la tecnología de microcontroladores, la cual ofrece una amplia gama de productos aplicables a la automatización de procesos en las industrias y comercio en general.
5.3.
Limitantes y recomendaciones
La limitante del proyecto, es que se lo aplica a una intersección y el tipo de comunicación entre el microcontrolador y el ordenador es de tipo serial.
Para la gestión y control de este proyecto, será necesario capacitar al personal sobre el manejo de este tipo de tecnología.
En caso de realizar la implantación de este prototipo, se puede utilizar la red de CNT (Corporación Nacional de Telecomunicaciones) para la interconexión de las placas en las intersecciones, aumentando el módulo Ethernet.
El desenvolvimiento adecuado del proyecto presentado, depende fuertemente de la capacidad de vía con que cuenten las calles de la intersección.
El prototipo presentado descarta el direccionamiento de tránsito con giro a la izquierda.
La asignación y cambio de luces de los semáforos es en función a la presencia de vehículos en las calles y no a la cantidad que exista en espera.
80
La programación realizada se aplica para el control de semáforos en una sola intersección.
Se recomienda tomar en consideración la realización de talleres para la aplicación de los temas revisados en las materias de Matemáticas Discretas y Electrología y Circuitos Lógicos, ya que esto ayudará a realizar proyectos de este tipo.
81
Bibliografía
Cegarra, J. (2011). Metodología de la investigación científica y tecnológica. Madrid: Ediciones Díaz de Santos.
García, M & Martínez, P.(2012). Guía Práctica para la realización de Trabajos de Fin de Grado y Trabajos de Fin de Máster. Murcia: EDITUM.
Hernandez, R & Fernandez, C & Bautista, M. (2010). Metodología de la Investigación 5ta Edición. México D.F.: McGrawHill / Interamericana.
Jaramillo, S& Cardona, S & Villa, D.(2008). Programación Avanzada en Java. Colombia: ELIZCOM S.A.S.
Reyes, C.(2006). Microcontroladores PIC Programación en Basic 2daEdición. Quito: RISPERGRAF.
Torrente, O.(2013). Libros.
ARDUINO Curso práctico de formación. Madrid: RC
82
Lincografía Diario: Hoy Artículo: Semáforos Inteligentes generan caos en Cuenca Link: http://www.hoy.com.ec/noticias-ecuador/semaforos-inteligentes-generan-caosen-cuenca-367319.html
Diario: Hoy Artículo: Semáforos no tan inteligentes (Quito) Link: http://www.hoy.com.ec/noticias-ecuador/semaforos-no-tan-inteligentes108961.html
Diario: El Tiempo Artículo: Semáforos Inteligentes (Cuenca) Link: http://www.eltiempo.com.ec/noticias-opinion/2363-sema-foros-inteligentes/
Sitio Web: Encyclopedia Cubana ECURED Artículo: El Semáforo Link: http://www.ecured.cu/index.php/Sem%C3%A1foro
Documento: Registro Oficial de la Ley Orgánica de Transporte, Tránsito y Seguridad Vial Link: http://www.cte.gob.ec/wp-content/uploads/2013/03/Nuevo-Reglamento-a-laLey-de-Transporte-Terrestre-Transito-y-Seguridad-Vial.pdf
83
Glosario A ANÁLOGO. Sistema de trabajo con valores discretos, es decir con valores de entre un rango determinado de opciones. ANT. Agencia nacional de Trisito. ARDUINO. Herramienta y plataforma de desarrollo de código abierto basado en el uso de microcontroladores. ARDUINO DUE. Placa Electrónica primera en su categoría basada en un micro controlador de 32 bits y compatible con aplicaciones android de google. AVR. Es un CPU con una arquitectura Harvard que pertenece a la Familia de microcontroladores RISC fabricados por la empresa Atmel. B BAUDIO. Unidad de medición utilizada en las telecomunicaciones para la transmisión de datos en señales análogas y digitales. C CPU(Unidad Central de Proceso).Parte importante del microcontrolador que se encarga de receptar, interpretar y ejecutar todas las instrucciones generadas para el manejo y control de todos los elementos conectados en el sistema, por lo que se le considera la parte más importante. CTE. Comisión de Tránsito del Ecuador.
84
CONGESTIÓN VEHICULAR. Fenómeno de embotellamiento del tránsito vehicular que se produce a causa de varios motivos D DIGITAL. Sistema de trabajo con valores binarios, ceros o unos. F FLUJO VEHICULAR. Movimiento de vehículos en una calle o avenida con una dirección determinada. G GNU. Proyecto iniciado por Richard Stallman con el objetivo de crear un sistema operativo completamente libre GPL. La Licencia Pública General de GNU o más conocida por su nombre en inglés GNU General. GPS (Sistema de Posicionamiento Global). Sistema global de navegación por satélite que permite determinar la posición de un objeto en cualquier parte del planeta. H HORAS PICO. Corto tiempo durante el cual, circulan mayor cantidad de vehículos que lo acostumbrado aumentando así el flujo de vehicular. I INTERFACE. Intermediario entre la programación y el usuario. Permite al usuario acceder a un sistema de forma amigable y sencilla.
85
INTERSECCIÓN. Cruce entre dos vía de tránsito vehicular. L LED (Diodo Emisor de Luz). Elemento eléctrico que transforma la energía eléctrica en energía lumínica con un bajo consumo de energía. M MICROCONTROLADOR. Circuito integrado de menor capacidad que los microprocesadores, que trabaja con los dispositivos como memoria, disco duro, etc. incluidos en él. MICROPROCESADOR. Circuito integrado de mayor importancia en un sistema micro programable. Trabaja con dispositivos externos como memoria, disco duro, etc. MULTIPLATAFORMA. Capacidad de trabajar bajo cualquier sistema operativo por ejemplo Windows, Linux, Solaris, etc. O OPEN SOURCE. Código abierto es la expresión con la que se conoce al software distribuido y desarrollado libremente. P PERIFÉRICOS. Son dispositivos que no forman parte del sistema y pertenecen al mundo exterior.
86
PIC. Peripheral Interface Controller (controlador de interfaz periférico). Familia de microcontroladores fabricados por la empresa Microchip. Se considera la competencia de los microcontroladores AVR. PIN. Es el medio por el cual ingresan o salen variaciones de voltaje como resultado de un proceso o entrada de datos a una placa electrónica. PLD (Dispositivos Lógicos Programables). Circuitos integrados que cuentan con una matriz de puertas lógicas en su interior con el objetivo de resolver problemas de combinaciones PROCESSING. Lenguaje de programación y entorno de desarrollo integrado de código abierto basado en Java. PUBLIC LICENCE (Licencia Pública). Licencia más ampliamente usada en el mundo del software y garantiza a los usuarios finales la libertad de usar, estudiar, compartir (copiar) y modificar el software. PUTTY. Software de red que permite monitorear remotamente servidores para ver el transido de datos en una red. S SEMÁFORO. Dispositivo utilizado para el direccionamiento del tránsito vehicular. SEMÁFOROS
CONVENCIONALES.
Semáforos
de
funcionamiento
y
componentes eléctricos de configuración manual, considerados de tecnología obsoleta por la discontinuidad de su fabricación.
87
SEMÁFOROS INTELIGENTES. Semáforos de funcionamiento y componentes electrónicos programables, configurables remotamente y auto ajustables al tránsito vehicular. SEMÁFOROS
SEMIAUTOMÁTICOS.
Semáforos
de
funcionamiento
y
componentes electrónicos. Contiene una placa programable que permite realizar modificaciones en su configuración de forma manual. SENSOR. Dispositivo que permite obtener un dato de una variable física como la temperatura, fuerza, presión, velocidad, posición, etc. para tomarlo como ingreso en el sistema en el que se encuentre inmerso. SGBD (Sistema Gestor de Base de Datos). Software que permite la creación y manipulación de bases de datos mediante el uso de un lenguaje de consulta estructurado. SISTEMA EMBEBIDO. Conjunto de elementos electrónicos (Hardware) y sentencias de código (software) que forman un todo único, con la finalidad de realizar una tarea específica, bajo un conjunto de normas y reglas determinadas para obtener un mismo objetivo final. SISTEMAS MICRO PROGRAMABLES. Son un conjunto de dispositivos de propósito general que al ser programados son capaces de resolver problemas determinados. SPI (Interfaz Serial de Periféricos). Conector con un conjunto de seis pines que me permite la comunicación entre una placa electrónica y cualquier módulo como por ejemplo un módulo de infra rojos.
88
SQL (Lenguaje de Consulta Estructurado). Lenguaje por medio del cual es posible la comunicación con la base de datos para la creación, modificación, eliminación o actualización de tablas, registros y demás objetos. T TEAM VIEWER. Software de red que permite controlar remotamente un ordenador desde cualquier ordenador que se encuentra en una misma red. TRÁNSITO VEHICULAR. Flujos de vehículos que circulan por una vía, avenida, calle o autopista. W WIRING. Lenguaje de programación basado en Procesing que a su vez se basa en java. WI-FI. Mecanismo de conexión de dispositivos electrónicos de forma inalámbrica.
89
Anexos
90
Anexo 1. Partes del Semáforo Inteligente
Maqueta con elementos electrónicos como pulsadores y diodos leds Salida Intersección (Pin de Entrada)
6 Pulsadores por cada Flujo de tránsito en la intersección (Total 24 Pines de Entrada)
3 Luces por semáforo (Total 12 Pines de Salida)
Cola Intersección (Pin de Entrada) Entrada Intersección (Pin de Entrada) Cables de red
Cable USB tipo B
Aplicación de Control Desarrollada en Netbeans
Sistema Electrónico compuesto por la placa Arduino Due y una placa electrónica desarrollada para la distribución y organización de cables.
91
Anexo 2. Certificado de la Compañía de Taxis “Las Playas S.A.”
92
Anexo 3. Entrevista al Ing. Alex Rojas TĂŠcnico de Transporte de la ANT (Agencia Nacional de Transporte) de la Provincia
93
Anexo 4. Formato de encuestas a conductores PONTIFICIA UNIVERSIDAD CATÓLICA DEL ECUADORSEDE SANTO DOMINGO
Instrumento: Encuesta. Tema: Prototipo de Semáforos Inteligentes. Objetivo: Conocer el grado de conocimiento y aceptación de los semáforos de tránsito. Dirigido a: Conductores de la Compañía de taxi Transplayasa S.A. Número 19. Instrucciones: Seleccionar una sola opción por pregunta encerrándola en un círculo o subrayándola. Se agradece de ante mano, su gentil colaboración y tiempo. Preguntas: 1. ¿Está de acuerdo con el funcionamiento de los semáforos convencionales en la ciudad de Santo Domingo? A. Muy de acuerdo B. De acuerdo C. Indiferente D. En desacuerdo E. Muy desacuerdo 2. ¿Cómo califica el funcionamiento de los semáforos convencionales? A. Excelente. B. Muy Bueno. C. Bueno. D. Regular. E. Pésimo. 3. El tiempo de duración de las respectivas luces de los semáforos actuales debe: A. Aumentar el tiempo. B. Disminuir el tiempo. C. Auto ajustarse el tiempo, en función de los vehículos en cola. D. Mantenerse como están.
94
4. ¿Cómo califica la tecnología de los semáforos que Ud. ha visto en el centro de la ciudad? A. Excelente B. Buena C. Regular D. Pésima 5. ¿Qué grado de eficiencia considera que tienen los semáforos convencionales, para dirigir el tránsito vehicular? A. Muy eficaces B. Poco Eficaces C. Ligeramente eficaces D. Nada Eficaces 6. ¿Está informado sobre los Semáforos Inteligentes? A. Muy informado. B. Poco informado. C. Ligeramente informado. D. Nada informado.
95
Anexo 5. Listado de Materiales y Herramientas
Materiales:
Arduino Due.
Borneras.
Resistencias.
Pulsadores
Placa de circuito perforado.
Placa de circuito virgen.
Marcador indelebre.
Cable de red.
Diodos
led (rojo,
verde).
Canaletas Tablero triplex Tubos de antena. Pintura Vinilo
amarillo
Lustre de cocina.
Espadines (pines).
Ácido para placas electrónicas.
Estaño
Pasta para soldar
Herramientas:
y
Taladro con broca de 1 milímetro.
Estilete
Desarmadores
Protoboard
Cable USB tipo B.
Tijeras
Pegamento
Alicate.
Cautin.
Plancha.
96
Anexo 6. Manual de Instalaciﾃｳn
PROTOTIPO DE SEMﾃ：OROS INTELIGENTES
Manual de Instalaciﾃｳn
2
Tabla de Contenidos 1. Introducci贸n.
3
2. Requerimientos previos.
3
3. Instalaci贸n de Arduino.
3
4. Instalaci贸n del Kit de Desarrollo de Java (JDK).
6
5. Instalaci贸n de MySQL.
7
3
1. Introducción Este manual nos guiará a instalar los requisitos de software necesarios para la ejecución del sistema, de subdivide en cinco partes:
Requerimientos previos.
Instalación de Arduino. Instalará los controladores de la placa Arduino DUE.
Manual Instalación del Kit de Desarrollo de Java (JDK). Permite instalara la máquina virtual de Java.
Manual de Instalación de MySQL. Es el sistema gestor de base de datos donde se almacenará nuestra base de datos
2. Requerimientos previos Antes de inicializar las instalaciones se debe de contar con los siguientes requerimientos previos: Sistema Operativo: Windows 7 Ultimate de 64 bits. Procesador: Core i3. Memoria RAM: 2.0 Gb. Resolución de pantalla: 1280x1024.
3. Instalación de Arduino A. Lo primero en realizar, es tomar el archivo arduino-1.5.2windows.rar que contiene el entorno de desarrollo para Arduino y el controlador para luego descomprimirlo en el escritorio. B. Conectamos la placa Arduino DUE al ordenador con el cable USB.
4
C. Luego de encenderse, procedemos a instalar el controlador de la placa Arduino DUE. Para esto nos dirigimos al Administrador de dispositivos, que se encuentra en Hardware y Sonido del Panel de control.
D. En la ventana de Administrador de Dispositivos, presionamos clic derecho en Arduino DUE Prog. Port que es nuestra
placa
Arduino
DUE
sin
controlador, y seleccionamos la opci贸n Actualizar software de controlador.
E. Aparece una nueva ventana con dos opciones; seleccionamos la segunda Buscar software de controlador en el equipo.
5
F. En esta nueva ventana, presionamos clic en el botรณn de Examinar para seleccionar la carpeta que contiene el controlador de la placa Arduino DUE;
buscamos la carpeta drives que se encuentra en la carpeta que se descomprimiรณ al inicio del manual, presionamos aceptar y luego Siguiente.
G. Confirmamos que deseamos instalar los controladores presionando clic en el botรณn Instalar y nos aparecerรก una ventana de confirmaciรณn.
H. Para finalizar, comprobamos que la placa nos aparece como reconocida en los dispositivos tipo puerto COM, especificando el puerto COM con el que vamos a trabajar en mi caso es el
6
COM3. Cada ordenador tendrá su número, no será el mismo en todos los ordenadores por lo tanto habrá que recordar el número de puerto para la programación y configuración posteriores.
4. Instalación del Kit de Desarrollo de Java (JDK) Como requisito básico para la instalación de Netbeans es la instalación del Kit de Desarrollo de Java llamado también JDK, en nuestro caso utilizaremos jdk-7u21windows-x64 que es la versión 7.2 para sistemas operativos de 64 bits. Esto nos permitirá desarrollar aplicaciones que trabajen en la máquina virtual de java.
A. Instalamos el JDK, para lo cual presionamos doble clic en el icono
B. Nos aparecerá un mensaje del sistema operativo preguntando ¿Desea permitir que este programa realice cambios en su equipo?, presionamos clic en la opción Sí para continuar.
C. Nos da un mensaje de bienvenida. Presionamos Next.
D. Nos pregunta el tipo de instalación. Presionamos Next.
7
E. Nos confirma el lugar de instalación, en caso de desear cambiar la ruta lo podemos hacer con el botón Change. Dejamos como esta y Presionamos Next.
F. Inicia la instalación en la ruta especificada.
G. La instalación se ha completado. Presionamos clic en Close.
5. Instalación de MySQL Necesario para el almacenamiento de los datos recolectados por los pulsadores, las configuraciones y los usuarios, procedemos a la instalación de MySQL. A. Instalamos MySQL, para lo cual presionamos doble clic en el icono
8
B. La ventana de bienvenida de la instalaci贸n. Presionamos clic en Next.
C. Realizamos
una
instalaci贸n
t铆pica.
Presionamos clic en Next.
D. Presionamos clic en Next
E. Nos confirma el lugar de instalaci贸n en el disco duro. Presionamos clic en Install
9
F. Culminamos
con
la
instalaci贸n,
Presionamos
clic
en
Finish
y
empezamos con la configuraci贸n de MySQL.
G. Presionamos clic en Next.
H. Seleccionamos
una
configuracion
estandar. Presionamos clic en Next.
I. Seleccionamos Instalacion como servicio de windows. Presionamos clic en Next.
10
J. Modificamos
la configuracion
de
seguridad asignando la contrase帽a: semaforos2013 para el usuario root. Presionamos clic en Next.
K. Ejecutamos establecida.
la
configuraci贸n
Presionamos clic en
Excecute.
L. Culminamosla instalaci贸n de MySQL. Presionamos clic en Finish.
Como complemento se instala las herramientas de MySQL para ralizar los backup y restore de la base de datos, se puede utilizar cualquier otro si asi fuese deseado.
M. Iniciamos lainstalaci贸n. Presionamos clic en Next.
11
N. Aceptamos la licencia de instalaci贸n. Presionamos clic en Next.
O. Confirmamos la ubicaci贸n de la instalaci贸n.
Presionamos
clic en
Next.
P. Seleccionamos
una
instalaci贸n
completa. Presionamos clic en Next.
12
Q. Confirmamos los datos. Presionamos clic en Install.
R. El sistema operativo pregunta si deseo realilzar los cambios, seleccionamos que si deseamos. Aparecera la ventana que confirma su inicio de instalaci贸n.
S. Se
ha
completado
la
Presionamos clic en Finish.
instalaci贸n.
97
Anexo 7. Manual de Usuario
PROTOTIPO DE SEMﾃ：OROS INTELIGENTES
Manual de Usuario
2
Tabla de Contenidos 1. Ingreso al Sistema
3
2. Ventana Principal
4
3. Partes de la Ventana Principal
4
A. Sistema
5
B. Funcionamiento
5
C. Datos Recibidos
5
D. Fecha y Hora
6
E. Configuraci贸n
6
F. Intersecci贸n
6
G. Estad铆sticas
7
H. Par谩metros
7
I. Usuarios
7
3
1. Ingreso al Sistema Para ingresar al sistema presionamos doble clic en el icono
Seguido aparecerá la ventana de login o ingreso al sistema, en la cual especificaremos nuestro nombre de usuario y contraseña asignada por el administrador del sistema.
En caso de no ingresar correctamente el usuario o la contraseña aparecerá el mensaje de error respectivo:
Una vez ingresado usuario y contraseña correctos se accederá a la ventana principal del sistema.
4
2. Ventana Principal
Esta interfaz permite al usuario controlar los semáforos a su gusto y conveniencia. 3. Partes de la ventana Principal Las partes que conforman esta interfaz son: A. Sistema B. Funcionamiento C. Datos Recibidos D. Fecha y hora E. Configuración F. Intersección G. Estadísticas H. Parámetros I. Usuarios
5
A. Sistema Contiene los botones de encendido y apagado del sistema.
B. Funcionamiento Permite seleccionar el funcionamiento de los semáforos.
La opción Inteligente permite restar los tiempos en
verde a las calles en las que no existan vehículos en espera permitiendo a la segunda calle o avenida pasar con su tiempo asignado en la configuración. Este tiempo puede aumentar en proporción al porcentaje de aumento que se establezca en los parámetros de configuración de la pestaña Parámetros y los tiempos asignados en la sección de Configuración que se detallan más adelante.
La opción Manual establece a los semáforos trabajar con tiempos de luces fijos es decir trabajar como cualquier semáforo convencional sin importar la presencia o ausencia de vehículos.
Por último la opción intermitente establece a los semáforos en parpadeo constante de las luces amarillas.
C. Datos Recibidos Visualiza los contadores de los vehículos que ingresan y salen de la intersección donde se encuentran ubicados los semáforos inteligentes. Estos datos son recolectados por medio de los pulsadores ubicados en la maqueta.
6
D. Fecha y hora
Visualiza la hora y fecha del sistema
E. Configuración Permite la configuración de los tiempos de asignación para las luces de los semáforos, los cuales están conformados por 6 ciclos, para los cuales se asigna valores numéricos de tres cifras con la unidad de tiempo en segundos. En Caso de no ingresar lo requerido el sistema emitirá el mensaje de error respectivo.
F. Intersección Es donde se visualiza lo que ocurre en la placa Arduino DUE. Aquí se visualizan los
valores
de
los
contadores
recolectados por los pulsadores y el estado de las luces de los semáforos, además, de las cadenas que se envían a la placa con los parámetros configurados y las cadenas que se receptan en el sistema proveniente de la placa.
7
G. Estadísticas Permite obtener reportes de los datos recolectados según un intervalo de tiempo especificado en la interfaz. Se debe especificar la fecha con hora de inicio y fin para luego presionar el botón del reporte deseado. Existe el reporte general que visualiza la sumatoria de los vehículos que ingresan y salen por el norte, sur, este y oeste con su gráfica representativa correspondiente. Además del reporte detallado por día que presenta la sumatoria de vehículos que ingresan y salen de la intersección pero separando la sumatoria por cada día del periodo seleccionado. H. Parámetros En esta pestaña, se configuran los parámetros de configuración para la comunicación con la placa, además permite modificar el tipo de funcionamiento (Inteligente,
Normal
o
Intermitente)
y
la
configuración de los tiempos para los seis ciclos de los semáforos. Una vez que se modifique a gusto los valores de los cuadros de texto y demás controles, se presiona clic en enviar o cancelar según sea el caso. I. Usuarios En esta pestaña se crean los usuarios que tendrán acceso al sistema. Existen tres tipos de usuarios:
8
Administrador.- tiene acceso a todo el sistema. Supervisor.- Tiene Acceso a todo el sistema excepto la pestaña de usuarios. Operador.- Tiene acceso a todo el sistema excepto a las pestañas Usuarios y Parámetros. El usuario Administrador puede agregar un nuevo usuario, modificar sus datos, eliminarlos o imprimir el listado de todos los usuarios del sistema.
98
Anexo 8. Manual del Programador
PROTOTIPO DE SEMﾃ：OROS INTELIGENTES
Manual del Programador
2
Tabla de Contenidos 1. Introducción
4
2. Estructura del Proyecto
4
A. Código del microcontrolador de la placa arduino DUE
4
Asignación de puertos a luces y sensores
4
Variables Generales.
5
Variables Receptoras de Parámetros del Sistema
6
Void Setup
7
Void Loop
8
ApagarTodo
8
void Ciclo_0()
8
void Ciclo_1_4(byte Par_Ciclo)
10
void Ciclo_2_5(byte Par_Ciclo)
14
void Ciclo_3_6(byte Par_Ciclo)
14
void Ciclo_9()
15
void Send_Data_Sensor(byte Tipo, byte Sentido)
16
void Leer_Datos()
17
void Declaraciones_Interrupciones()
20
B. Código de la interfaz de usuario desarrollada en Netbeans.
30
ClaseSerial.java
30
ConexionDB.java
36
EstadisticasVehiculos.java
37
Funcionamiento.java
38
Report.java
42
3
Splash.java
43
Usuario.java
44
FrmPincipal.java
48
JFrameLogin.java
80
4
1. Introducción Este manual nos permite dar a conocer sobre la estructura y funcionamiento de los formularios, módulos y demás código existente en el proyecto. Se sugiere tener cuidado con la manipulación del código y respaldar una copia antes de cualquier modificación importante. 2. Estructura del Proyecto El proyecto se componen de: A. Código del microcontrolador de la placa arduino DUE. B. Código de la interfaz de usuario desarrollada en Netbeans. Una vez instalados los requerimientos de software empezamos con la parte del código de programación. A. Código del microcontrolador de la placa arduino DUE /******************************************************** ASIGNACÓN DE PUERTOS A LUCES Y SENSORES ******************************************************* */ // //
PUERTOS DE ENTRADA (24)
<< PULSADORES >>
ENTRADAS COLAS SALIDAS
byte PNS[6] = {18, 19, 26, 24, 16, 17}; // Pulsadores Carretera Norte-Sur = {Entradas Norte, Colas Norte, Salidas Norte}; byte PSN[6] = {50, 52, 53, 51, 44, 42}; // Pulsadores Carretera Sur-Norte = {Entradas Sur, Colas Sur, Salidas Sur};
5
byte PEO[6] = {35, 33, 31, 29, 41, 43}; // Pulsadores Carretera Este-Oeste = {Entradas Este, Colas Este, Salidas Este}; byte POE[6] = {28, 30, 32, 34, 22, 6}; // Pulsadores Carretera Oeste-Este = {Entradas Oeste, Colas Oeste, Salidas Oeste}; // //
PUERTOS DE SALIDA (12)
<< LUCES >>
R A V
byte LNS[3] = {27, 25, 23};
// LUCES SEMﾃ：ORO NORTE-SUR =
{Rojo, Amarillo, Verde} byte LSN[3] = {36, 38, 40};
// LUCES SEMﾃ：ORO SUR-NORTE =
{Rojo, Amarillo, Verde} byte LEO[3] = {49, 47, 45};
// LUCES SEMﾃ：ORO ESTE-OESTE =
{Rojo, Amarillo, Verde} byte LOE[3] = { 3, 4, 5};
// LUCES SEMﾃ：ORO OESTE-ESTE =
{Rojo, Amarillo, Verde} /* ******************************************************* VARIABLES GENERALES ******************************************************* */ // // COLAS
VARIABLES BANDERAS PARA LOS PULSADORES ENTRADAS COLAS SALIDAS
ENTRADAS
SALIDAS
volatile byte BNS[6] = { 0, 0, 0, 0, 0, 0}; // Carretera N-S = {EN1, EN2, VC1, VC2, SS1, SS2}; volatile byte BSN[6] = { 0, 0, 0, 0, 0, 0}; // Carretera S-N = {ES1, ES2, VC1, VC2, SN1, SN2};
6
volatile byte BEO[6] = { 0, 0, 0, 0, 0, 0}; // Carretera E-O = {EE1, EE2, VC1, VC2, SO1, SO2}; volatile byte BOE[6] = { 0, 0, 0, 0, 0, 0}; // Carretera O-E = {EO1, EO2, VC1, VC2, SE1, SE2}; // //
VARIABLES CONTADORES DE VEHÍCULOS N S E O
int CVE[4] = { 0, 0, 0, 0};
// Contador Vehículos en Entradas = {Norte,
Sur, Este, Oeste}; int CVS[4] = { 0, 0, 0, 0};
// Contador Vehículos en Salidas = {Norte, Sur,
Este, Oeste}; int CVC[4] = { 0, 0, 0, 0};
// Contador Vehículos en Colas
= {Norte, Sur,
Este, Oeste}; byte Borrar[5] = {0,0,0,0,0};
// Vector para llevar el conteo de vehiculos
que no circulan /* ***************************************************************** VARIABLES RECEPTORAS DE PARÁMETROS DEL SISTEMA ***************************************************************** */ byte Sistema = 1;
// Determina el estado de los Semáforos (00 =
Encendido o 01 = Apagado). byte Funcionamiento = 0;
// 00 = Inteligente, 01 = Manual, 02 =
Intermitente byte Tiempo_Espera_Maximo = 5;
// Pasado este tiempo si no cruzan
cambia el color byte Intentos = 3; central
// Límite de intentos antes de enviar mensaje a la
7
byte Porcentaje = 50;
// Para aumentar el tiempo en caso de haber
vehículos en la transversal. int Ciclo[7] = {2, 8, 2, 1, 8, 2, 1};
// Tiempo en Segundos de los ciclos. Ciclo 0
es intermitente; String cadena = "";
// Cadena con todos los parámetro recibidos desde
el PC // ***************************************************************** void setup() { Serial.begin(9600);
// Activación del puerto Serial a 9600 Baudios
for (byte T = 0; T < 6; T++){ // Configuración Puertos de Entrada pinMode(PNS[T], INPUT); pinMode(PSN[T], INPUT); pinMode(PEO[T], INPUT); pinMode(POE[T], INPUT); } for (byte T = 0; T < 3; T++){ // Configuración Puertos de Salida pinMode(LNS[T], OUTPUT); pinMode(LSN[T], OUTPUT); pinMode(LEO[T], OUTPUT); pinMode(LOE[T], OUTPUT); } ApagarTodo(); Declaraciones_Interrupciones(); } void loop() {
8
Ciclo_3_6(6); Ciclo_1_4(1); Ciclo_2_5(2); Ciclo_3_6(3); Ciclo_1_4(4); Ciclo_2_5(5); } void ApagarTodo() { for (byte T=0; T<3; T++){ digitalWrite(LNS[T],LOW); digitalWrite(LSN[T],LOW); digitalWrite(LEO[T],LOW); digitalWrite(LOE[T],LOW); } while (Sistema == 0)
// Si parรกmetro = 0 Se apagan los semรกforos
{ delay(1000); Leer_Datos(); send_light(9); } } void Ciclo_0() {
// LUCES INTERMITENTES
9
while((CVC[0] <= 0) && (CVC[1] <= 0) && (CVC[2] <= 0) && (CVC[3] <= 0) && (Funcionamiento==0)) { ApagarTodo(); send_light(0);
// Envia al PC el ciclo para los cambios de luces en la interfaz
delay(1000); digitalWrite(LNS[1],HIGH); digitalWrite(LSN[1],HIGH); digitalWrite(LEO[1],HIGH); digitalWrite(LOE[1],HIGH); send_light(0);
// Envia al PC el ciclo para los cambio de luces en la interfaz
delay(Ciclo[0] * 1000); Leer_Datos(); } while (Funcionamiento == 2) // Funcionamiento Intermitente { ApagarTodo(); send_light(0);
// Envia al PC el ciclo para los cambio de luces en la interfaz -
0 = Amarillo delay(1000); digitalWrite(LNS[1],HIGH); digitalWrite(LSN[1],HIGH); digitalWrite(LEO[1],HIGH); digitalWrite(LOE[1],HIGH); send_light(0);
// Envia al PC el ciclo para los cambio de luces en la interfaz
10
delay(Ciclo[0] * 1000); Leer_Datos(); } }
void Ciclo_1_4(byte Par_Ciclo) { int Tiempo_Disponible = Ciclo[Par_Ciclo]; int Salir = 0; byte Anterior = 0; // Variables para contar segundos sin pasar vehiculos en verde byte Actual = 0; byte Tiempo_Esperado = 0;// Contador segundos de espera a que pasen los vehĂculos byte Color_1 = 0;
// Color Rojo -> Norte - Sur
byte Color_2 = 2;
// Color Verde -> Este - Oeste
byte Sentido_1 = 2;
// 2 = Este
byte Sentido_2 = 3;
// 3 = Oeste
byte Sentido_3 = 0;
// 0 = Norte
byte Sentido_4 = 1;
// 1 = Sur
// Esta calle
// Calle Transversal
if (Par_Ciclo == 4) { Color_1 = 2;
// Color Rojo -> Este - Oeste
Color_2 = 0;
// Color Verde -> Norte - Sur
Sentido_1 = 0;
// 1 = Norte
11
Sentido_2 = 1;
// 2 = Sur
Sentido_3 = 2;
// 2 = Este
Sentido_4 = 3;
// 3 = Oeste
} if (Ciclo[Par_Ciclo]>0){ ApagarTodo();// Apaga todas las luces y verifica si el estado Intermitente esta activo send_light(Par_Ciclo);// Envia al PC el ciclo para los cambio de luces en la interfaz digitalWrite(LSN[Color_1], HIGH);
digitalWrite(LNS[Color_1], HIGH);
digitalWrite(LEO[Color_2], HIGH);
digitalWrite(LOE[Color_2], HIGH);
} Actual = CVC[Sentido_1] + CVC[Sentido_2];// Total Vehiculos en Cola=Este+Oeste if (Funcionamiento == 0 && Ciclo[Par_Ciclo]>0) { while ((Salir == 0) && (Tiempo_Disponible > 0)) { while ((Tiempo_Disponible > 0) && (Salir == 0)) { if ((CVC[Sentido_1] <= 0) && (CVC[Sentido_2] <= 0)) { Salir = 1; } else { delay(1000); Tiempo_Disponible--;
12
Anterior = Actual;
// Empezamos a verificar si existen
vehículos detenidos durante el verde Actual = CVC[Sentido_1] + CVC[Sentido_2];
// Total Vehiculos en Cola
= Este + Oeste if (Anterior <= Actual) {
Tiempo_Esperado++;
}
// Contamos los segundos de espera
hasta el maximo esperado else {
Tiempo_Esperado = 0; }
// Borra y va de nuevo. Ya paso un
nuevo vehículo if ((Tiempo_Esperado >= Tiempo_Espera_Maximo))// Si ya lleego a su limite de espera y no pasan vehículos que cambie de color { Borrar[Par_Ciclo]++;
Tiempo_Esperado = 0;
if (!((CVC[Sentido_3] == 0) && (CVC[Sentido_4] == 0))) Salir = 1; } if (Borrar[Par_Ciclo] >= Intentos) { Serial.print("Limite de espera para Ciclo "); Serial.println(Par_Ciclo); String Cad = "M"; Cad = String(Cad + "-");
Cad = String(Cad + String(Par_Ciclo));
// a
ver si es el ciclo 1 o el 4 Cad = String(Cad + "-");
Cad = String(Cad + String(CVC[Sentido_1]));
// envio valores de los dos hemisferios Cad = String(Cad + "-"); // ya sea el norte y sur o el este y oeste
Cad = String(Cad + String(CVC[Sentido_2]));
13
Serial.println(Cad); Borrar[Par_Ciclo] = 0; CVC[Sentido_1] = 0;
CVC[Sentido_2] = 0;
Send_Data_Sensor(9,9); // actualiza los contadores de la cola de vehiculos } } } // Cierro segundo While if ((CVC[Sentido_3] <= 0) && (CVC[Sentido_4] <= 0) && (Salir == 0)) // ÂżNo existen vehĂculos en cola Norte ni SUR? { Tiempo_Disponible = Ciclo[Par_Ciclo] + (Ciclo[Par_Ciclo] * Porcentaje / 100); // Aumento el 50% del tiempo inicial }
// Fin If averigua si hay vehiculo o no en la
transversal para continuar por mas tiempo }
// Fin While verificador de tiempo luces
encendidas } if (Funcionamiento == 1 && Ciclo[Par_Ciclo]>0) { Leer_Datos();
delay(Ciclo[Par_Ciclo] * 1000);
} // Fin Procedimiento Ciclo_1_4()
void Ciclo_2_5(byte Par_Ciclo) { byte Color_1 = 0;
byte Color_2 = 1;
}
14
if (Par_Ciclo == 5) { Color_1 = 1; Color_2 = 0; } if (Ciclo[Par_Ciclo]>0){ ApagarTodo(); send_light(Par_Ciclo);// Envia al PC el ciclo para los cambio de luces en la interfaz digitalWrite(LSN[Color_1], HIGH);
digitalWrite(LNS[Color_1], HIGH);
digitalWrite(LEO[Color_2], HIGH);
digitalWrite(LOE[Color_2], HIGH);
Leer_Datos();
delay(Ciclo[Par_Ciclo] * 1000);
} }
void Ciclo_3_6(byte Par_Ciclo) { if (Ciclo[Par_Ciclo]>0){ ApagarTodo(); send_light(Par_Ciclo); // Envia al PC el ciclo para los cambio de luces en la interfaz digitalWrite(LSN[0], HIGH);
digitalWrite(LNS[0], HIGH);
digitalWrite(LEO[0], HIGH);
digitalWrite(LOE[0], HIGH);
delay(Ciclo[Par_Ciclo] * 1000); }
15
if (Ciclo[1]==0 && Ciclo[2]==0 && Ciclo[3]==0 && Ciclo[4]==0 && Ciclo[5]==0 && Ciclo[6]==0){ Sistema = 0;
Ciclo_9();
} Leer_Datos(); if((CVC[0] <= 0) && (CVC[1] <= 0) && (CVC[2] <= 0) && (CVC[3] <= 0) && (Funcionamiento == 0)) Ciclo_0(); if (Funcionamiento == 2) Ciclo_0(); // Funcionamiento Intermitente ir al Ciclo_0 para que se quede ahí hasta que se cambie el funcionamiento. if (Sistema == 0) Ciclo_9(); }
void Ciclo_9() { while (Sistema == 0) { ApagarTodo(); send_light(9);
// Envia al PC el ciclo para los cambio de luces en la interfaz
delay(1500); Leer_Datos(); } } /* Envía la cadena de caracteres al Ordenador con el estado de las variables de los vehículos de entrada, cola y salida en la interfaz de usuario.
16
*/ void Send_Data_Sensor(byte Tipo, byte Sentido) { String Cadena = "S"; for (int t = 0; t <= 3; t++){ Cadena = String(Cadena + "-");
Cadena = String(Cadena + String(CVE[t])); }
for (int t = 0; t <= 3; t++){ Cadena = String(Cadena + "-");
Cadena = String(Cadena + String(CVC[t])); }
for (int t = 0; t <= 3; t++){ Cadena = String(Cadena + "-");
Cadena = String(Cadena + String(CVS[t])); }
Cadena = String(Cadena + "-");
Cadena = String(Cadena + String(Tipo));
Cadena = String(Cadena + "-");
Cadena = String(Cadena + String(Sentido));
Serial.println(Cadena); } /* EnvĂa la cadena de caracteres al Ordenador para ralizar el cambio de luces en la interfaz de usuario. El parĂĄmetro indica el ciclo que se desea enviar junto con la letra L que es el indicador para reconocer el comando en el sistema de la PC. */ void send_light(byte L) { String Cadena = "L-"; Cadena = String(Cadena + String(L)); Serial.println(Cadena); }
17
void Leer_Datos() { char aux[3]; byte pos = 0; cadena = ""; char var; if (Serial.available()) { delay(80); while(Serial.available()>0) { var = (char)Serial.read(); if (var=='0' || var=='1' || var=='2' || var=='3' || var=='4' || var=='5' || var=='6' || var=='7' || var=='8' || var=='9' || var=='B') { cadena+= var; }else{ Serial.print(var); Serial.println("->Llego caracter BASURA..! se lo descarta"); } } if (cadena.length()>=25){ Serial.print("Se recibe:"); Serial.println(cadena); memset(aux, 0, sizeof(aux)); aux[0] = cadena[0];
18
aux[1] = cadena[1]; Sistema = atoi(aux); Serial.print("Sistema: "); Serial.println(Sistema); memset(aux, 0, sizeof(aux)); aux[0] = cadena[2]; aux[1] = cadena[3]; Funcionamiento = atoi(aux); Serial.print("Funcionamiento: "); Serial.println(Funcionamiento);
for (int t = 4; t <= 22; t+=3) { memset(aux, 0, sizeof(aux)); aux[0] = cadena[t]; aux[1] = cadena[t+1]; aux[2] = cadena[t+2]; Ciclo[pos]= atoi(aux); Serial.print("Ciclo: "); Serial.println(Ciclo[pos]); pos++; }
memset(aux, 0, sizeof(aux)); aux[0] = cadena[25]; aux[1] = cadena[26]; Tiempo_Espera_Maximo = atoi(aux); Serial.print("Tiempo_Espera_Maximo: ");
19
Serial.println(Tiempo_Espera_Maximo); memset(aux, 0, sizeof(aux)); aux[0] = cadena[27]; aux[1] = cadena[28]; Intentos = atoi(aux); Serial.print("Intentos: "); Serial.println(Intentos); memset(aux, 0, sizeof(aux)); aux[0] = cadena[29]; aux[1] = cadena[30]; Porcentaje = atoi(aux); Serial.print("Porcentaje: "); Serial.println(Porcentaje); Serial.println("Parametros receptados.. Ahora envio los contadores..->"); Send_Data_Sensor(5,5); } if ((cadena.length()==1) && (cadena[0]=='B')) { Serial.println("Encerando los contadores"); for (byte T = 0; T < 4; T++){ CVE[T] = 0; CVS[T] = 0; CVC[T] = 0; } Send_Data_Sensor(9,9); } } } /****************************************************************** INTERRUPCIONES ***************************************************************** */
20
void Declaraciones_Interrupciones() { attachInterrupt(PNS[0], EN1, CHANGE); attachInterrupt(PNS[1], EN2, CHANGE); attachInterrupt(PNS[2], CN1, CHANGE); attachInterrupt(PNS[3], CN2, CHANGE); attachInterrupt(PNS[4], SN1, CHANGE); attachInterrupt(PNS[5], SN2, CHANGE);
attachInterrupt(PSN[0], ESU1, CHANGE); attachInterrupt(PSN[1], ESU2, CHANGE); attachInterrupt(PSN[2], CSU1, CHANGE); attachInterrupt(PSN[3], CSU2, CHANGE); attachInterrupt(PSN[4], SSU1, CHANGE); attachInterrupt(PSN[5], SSU2, CHANGE);
attachInterrupt(PEO[0], EE1, CHANGE); attachInterrupt(PEO[1], EE2, CHANGE); attachInterrupt(PEO[2], CE1, CHANGE); attachInterrupt(PEO[3], CE2, CHANGE); attachInterrupt(PEO[4], SE1, CHANGE); attachInterrupt(PEO[5], SE2, CHANGE);
attachInterrupt(POE[0], EO1, CHANGE); attachInterrupt(POE[1], EO2, CHANGE);
21
attachInterrupt(POE[2], CO1, CHANGE); attachInterrupt(POE[3], CO2, CHANGE); attachInterrupt(POE[4], SO1, CHANGE); attachInterrupt(POE[5], SO2, CHANGE); } /*
NORTE - SUR */
void EN1() { if ((digitalRead(PNS[0]) == LOW)&& (BNS[0] == 1)) { BNS[0] = 0; CVE[0]++; CVC[0]++; Send_Data_Sensor(0,0); } // Contador_Vehículos_Entrada[Norte]++; Contador_Vehículos_Cola[Norte]; if (digitalRead(PNS[0]) == HIGH) BNS[0] = 1;
// Bandera para saber
si esta presionado el boton o no. // } void EN2() { if ((digitalRead(PNS[1]) == LOW) && (BNS[1] == 1)) { BNS[1] = 0; CVE[0]++; CVC[0]++; Send_Data_Sensor(0,0); } // Contador_Vehículos_Entrada[Norte]++; Contador_Vehículos_Cola[Norte]; if (digitalRead(PNS[1]) == HIGH) BNS[1] = 1; si esta presionado el boton o no. // } void CN1() { if ((digitalRead(PNS[2]) == LOW) && (BNS[2] == 1))
// Bandera para saber
22
{ BNS[2] = 0; if (CVC[0] > 0) { CVC[0]--; } Send_Data_Sensor(1,0);
//
Contador_Vehículos_Cola[Norte]--; } if (digitalRead(PNS[2]) == HIGH) BNS[2] = 1;
// Bandera para saber si
esta presionado el boton o no. // } void CN2() { if ((digitalRead(PNS[3]) == LOW) && (BNS[3] == 1)) { BNS[3] = 0; if (CVC[0] > 0) { CVC[0]--; } Send_Data_Sensor(1,0);
//
Contador_Vehículos_Cola[Norte]--; } if (digitalRead(PNS[3]) == HIGH) BNS[3] = 1;
// Bandera para saber
si esta presionado el boton o no. // } void SN1() //Agregar contador de vehículos Salida Norte 1 { if ((digitalRead(PNS[4]) == LOW) && (BNS[4] == 1)) { BNS[4] = 0;
CVS[0]++;
Send_Data_Sensor(2,0); } //
Contador_Vehículos_Salida[Norte]++; if (digitalRead(PNS[4]) == HIGH) BNS[4] = 1; si esta presionado el boton o no. // }
// Bandera para saber
23
void SN2() //Agregar contador de vehículos Salida Norte 2 { if ((digitalRead(PNS[5]) == LOW) && (BNS[5] == 1)) { BNS[5] = 0;
CVS[0]++;
Send_Data_Sensor(2,0); } //
Contador_Vehículos_Salida[Norte]++; if (digitalRead(PNS[5]) == HIGH) BNS[5] = 1;
// Bandera para saber
si esta presionado el boton o no. // } /*
SUR - NORTE */
void ESU1() { if ((digitalRead(PSN[0]) == LOW) && (BSN[0] == 1)) { BSN[0] = 0; CVE[1]++; CVC[1]++; Send_Data_Sensor(0,1); } // Contador_Vehículos_Entrada[Sur]++; Contador_Vehículos_Cola[Sur]; if (digitalRead(PSN[0]) == HIGH) BSN[0] = 1;
// Bandera para saber
si esta presionado el boton o no. // } void ESU2() { if ((digitalRead(PSN[1]) == LOW) && (BSN[1] == 1)) { BSN[1] = 0; CVE[1]++; CVC[1]++; Send_Data_Sensor(0,1); } // Contador_Vehículos_Entrada[Sur]++; Contador_Vehículos_Cola[Sur]; if (digitalRead(PSN[1]) == HIGH) BSN[1] = 1; si esta presionado el boton o no. // }
// Bandera para saber
24
void CSU1() { if ((digitalRead(PSN[2]) == LOW) && (BSN[2] == 1)) { BSN[2] = 0; if (CVC[1] > 0) { CVC[1]--; } Send_Data_Sensor(1,1);
//
Contador_Vehículos_Cola[Sur]--; } if (digitalRead(PSN[2]) == HIGH) BSN[2] = 1;
// Bandera para saber
si esta presionado el boton o no. // } void CSU2() { if ((digitalRead(PSN[3]) == LOW) && (BSN[3] == 1)) { BSN[3] = 0; if (CVC[1] > 0) { CVC[1]--; } Send_Data_Sensor(1,1);
//
Contador_Vehículos_Cola[Sur]--; } if (digitalRead(PSN[3]) == HIGH) BSN[3] = 1;
// Bandera para saber
si esta presionado el boton o no. // } void SSU1() //Agregar contador de vehículos Salida Sur 1 { if ((digitalRead(PSN[4]) == LOW) && (BSN[4] == 1)) { BSN[4] = 0;
CVS[1]++;
Send_Data_Sensor(2,1); } //
Contador_Vehículos_Salida[Sur]++;
25
if (digitalRead(PSN[4]) == HIGH) BSN[4] = 1;
// Bandera para saber
si esta presionado el boton o no. // } void SSU2() //Agregar contador de vehículos Salida Sur 2 { if ((digitalRead(PSN[5]) == LOW) && (BSN[5] == 1)) { BSN[5] = 0;
CVS[1]++;
Send_Data_Sensor(2,1); } //
Contador_Vehículos_Salida[Sur]++; if (digitalRead(PSN[5]) == HIGH) BSN[5] = 1;
// Bandera para saber
si esta presionado el boton o no. // } // *
ESTE - OESTE
* //
void EE1() { if ((digitalRead(PEO[0]) == LOW) && (BEO[0] == 1)) { BEO[0] = 0; CVE[2]++; CVC[2]++; Send_Data_Sensor(0,2); } // Contador_Vehículos_Entrada[Este]++; Contador_Vehículos_Cola[Este]; if (digitalRead(PEO[0]) == HIGH) BEO[0] = 1;
// Bandera para saber
si esta presionado el boton o no. // } void EE2() { if ((digitalRead(PEO[1]) == LOW) && (BEO[1] == 1)) { BEO[1] = 0; CVE[2]++; CVC[2]++; Send_Data_Sensor(0,2); } // Contador_Vehículos_Entrada[Este]++; Contador_Vehículos_Cola[Este];
26
if (digitalRead(PEO[1]) == HIGH) BEO[1] = 1;
// Bandera para saber
si esta presionado el boton o no. // } void CE1() { if ((digitalRead(PEO[2]) == LOW) && (BEO[2] == 1)) { BEO[2] = 0; if (CVC[2] > 0) { CVC[2]--; } Send_Data_Sensor(1,2);
//
Contador_Vehículos_Cola[Este]--; } if (digitalRead(PEO[2]) == HIGH) BEO[2] = 1;
// Bandera para saber
si esta presionado el boton o no. // }
void CE2() { if ((digitalRead(PEO[3]) == LOW) && (BEO[3] == 1)) { BEO[3] = 0; if (CVC[2] > 0) { CVC[2]--; } Send_Data_Sensor(1,2);
//
Contador_Vehículos_Cola[Este]--; } if (digitalRead(PEO[3]) == HIGH) BEO[3] = 1; si esta presionado el boton o no. // } void SE1()
// Bandera para saber
27
{ if ((digitalRead(PEO[4]) == LOW) && (BEO[4] == 1)) { BEO[4] = 0;
CVS[2]++;
Send_Data_Sensor(2,2); } //
Contador_Vehículos_Salida[Este]++; if (digitalRead(PEO[4]) == HIGH) BEO[4] = 1;
// Bandera para saber
si esta presionado el boton o no. // } void SE2() { if ((digitalRead(PEO[5]) == LOW) && (BEO[5] == 1)) { BEO[5] = 0;
CVS[2]++;
Send_Data_Sensor(2,2); } //
Contador_Vehículos_Salida[Este]++; if (digitalRead(PEO[5]) == HIGH) BEO[5] = 1;
// Bandera para saber
si esta presionado el boton o no. // } // *
OESTE - ESTE
* //
void EO1() { if ((digitalRead(POE[0]) == LOW) && (BOE[0] == 1)) { BOE[0] = 0; CVE[3]++; CVC[3]++; Send_Data_Sensor(0,3); } // Contador_Vehículos_Entrada[Oeste]++; Contador_Vehículos_Cola[Oeste]; if (digitalRead(POE[0]) == HIGH) BOE[0] = 1; si esta presionado el boton o no. // } void EO2()
// Bandera para saber
28
{ if ((digitalRead(POE[1]) == LOW) && (BOE[1] == 1)) { BOE[1] = 0; CVE[3]++; CVC[3]++; Send_Data_Sensor(0,3); } // Contador_Vehículos_Entrada[Oeste]++; Contador_Vehículos_Cola[Oeste]; if (digitalRead(POE[1]) == HIGH) BOE[1] = 1;
// Bandera para saber
si esta presionado el boton o no. // }
void CO1() { if ((digitalRead(POE[2]) == LOW) && (BOE[2] == 1)) { BOE[2] = 0; if (CVC[3] > 0) { CVC[3]--; } Send_Data_Sensor(1,3);
//
Contador_Vehículos_Cola[Oeste]--; } if (digitalRead(POE[2]) == HIGH) BOE[2] = 1;
// Bandera para saber
si esta presionado el boton o no. // } void CO2() { if ((digitalRead(POE[3]) == LOW) && (BOE[3] == 1)) { BOE[3] = 0; if (CVC[3] > 0) { CVC[3]--; } Send_Data_Sensor(1,3); Contador_Vehículos_Cola[Oeste]--; }
//
29
if (digitalRead(POE[3]) == HIGH) BOE[3] = 1;
// Bandera para saber
si esta presionado el boton o no. // } void SO1() { if ((digitalRead(POE[4]) == LOW) && (BOE[4] == 1)) { BOE[4] = 0;
CVS[3]++;
Send_Data_Sensor(2,3); } //
Contador_Vehículos_Salida[Oeste]++; if (digitalRead(POE[4]) == HIGH) BOE[4] = 1;
// Bandera para saber
si esta presionado el boton o no. // } void SO2() { if ((digitalRead(POE[5]) == LOW) && (BOE[5] == 1)) { BOE[5] = 0;
CVS[3]++;
Send_Data_Sensor(2,3); } //
Contador_Vehículos_Salida[Oeste]++; if (digitalRead(POE[5]) == HIGH) BOE[5] = 1; si esta presionado el boton o no. // }
// Bandera para saber
30
B. Cรณdigo de la interfaz de usuario desarrollada en Netbeans. A continuaciรณn se detalla el cรณdigo de programaciรณn de cada mรณdulo y formulario: ClaseSerial.java package Clases; import Formas.FrmPrincipal; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStream; import gnu.io.CommPortIdentifier; import gnu.io.PortInUseException; import gnu.io.SerialPort; import gnu.io.SerialPortEvent; import gnu.io.SerialPortEventListener; import gnu.io.UnsupportedCommOperationException; import java.awt.Color; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.util.Enumeration; import java.util.TooManyListenersException; import javax.swing.AbstractAction; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.Timer;
31
public class ClaseSerial implements SerialPortEventListener { private static final int TIME_OUT = 5; private static final int DATA_RATE = 9600; private static final String PORT_NAMES[] = { "/dev/ttyUSB0", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9", "COM10" }; private byte save = 0; private byte Bandera = 1; private BufferedReader input; public static char[] cadenaRecibida; public static SerialPort serialPort; public static OutputStream output; public static CommPortIdentifier portId; public String[] aux;
public void initialize() { portId = null; Enumeration portEnum = CommPortIdentifier.getPortIdentifiers(); while (portEnum.hasMoreElements()) { CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement(); for (String portName : PORT_NAMES) { if (currPortId.getName().equals(portName)) { portId = currPortId; FrmPrincipal.PuertoSeleccionado = portName;
32
break; } } } if (portId == null)
{
System.out.println("No se encuentra Puerto COM."); FrmPrincipal.jTextPaneLog.setText("No se encuentra Puerto COM."); this.close(); return; } else{ if (Bandera == 1){ System.out.println("Se conecto la placa"); FrmPrincipal.jTextPaneLog.setText("Se conecto la placa"); Timer polo = new Timer(2000, new AbstractAction() { @Override public void actionPerformed(ActionEvent ae) { if (Bandera == 1){ FrmPrincipal.construirCadena(); save = 1;
Bandera = 0;
} } }); polo.setRepeats(false); polo.start();
33
} } try { serialPort = (SerialPort) portId.open(this.getClass().getName(), TIME_OUT); serialPort.setSerialPortParams(DATA_RATE, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); input = new BufferedReader(new InputStreamReader(serialPort.getInputStream())); serialPort.addEventListener(this); serialPort.notifyOnDataAvailable(true); } catch (PortInUseException | UnsupportedCommOperationException | IOException | TooManyListenersException e) { } } public synchronized void close() { if (serialPort != null) { serialPort.removeEventListener(); serialPort.close();
Bandera = 1;
} } public synchronized void serialEvent(SerialPortEvent oEvent) { if (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) { try { String inputLine=input.readLine(); cadenaRecibida = inputLine.toCharArray(); output = serialPort.getOutputStream();
34
System.out.println(cadenaRecibida); aux = new String(cadenaRecibida).split("-"); FrmPrincipal.jTextPaneLog.setText(new String(cadenaRecibida)); if(aux[0].equals("L")){ FrmPrincipal.cambiarLuces(Integer.parseInt(aux[1]), new String(cadenaRecibida));
}
if(aux[0].equals("S")){ FrmPrincipal.cargarDatos(new String(cadenaRecibida)); } if(aux[0].equals("M")){ MSN v = new MSN(Integer.parseInt(aux[1]), Integer.parseInt(aux[2]), Integer.parseInt(aux[3])); } if(aux[13].equals("5") && save == 1 ){ // Se ejecuta solo al iniciar la ejecuci贸n de a interfaz de usuario FrmPrincipal.BEN = Integer.valueOf(FrmPrincipal.jLabelEntradaN.getText()); FrmPrincipal.BES = Integer.valueOf(FrmPrincipal.jLabelEntradaS.getText()); FrmPrincipal.BEE = Integer.valueOf(FrmPrincipal.jLabelEntradaE.getText()); FrmPrincipal.BEO = Integer.valueOf(FrmPrincipal.jLabelEntradaO.getText()); FrmPrincipal.BSN = Integer.valueOf(FrmPrincipal.jLabelSalidaN.getText()); FrmPrincipal.BSS = Integer.valueOf(FrmPrincipal.jLabelSalidaS.getText());
35
FrmPrincipal.BSE = Integer.valueOf(FrmPrincipal.jLabelSalidaE.getText()); FrmPrincipal.BSO = Integer.valueOf(FrmPrincipal.jLabelSalidaO.getText()); } } catch (IOException | NumberFormatException e) { } } } } class MSN extends JFrame{ public MSN(int C, int H1, int H2){ JLabel Etiqueta = new JLabel(""); setUndecorated(true); // Permite deshabilitar la barra de titulo y activar el conmando siguiente setOpacity(0.8f);
// Permite activar el modo de Opacidad con la f aclaramos
que es float El rango es de 0 a 1 this.setTitle("Informativo"); this.setResizable(false);
this.setVisible(true);
this.setBounds(420, 460, 420, 100);
// Es la suma de setLocation(x, y) +
setSize(w, h) this.add(Etiqueta);
Etiqueta.setOpaque(true);
Etiqueta.setBounds(5, 15, 50, 50);
Etiqueta.setBackground(Color.yellow);
String Cadena = "<html><div align='center'><B><H2>EXISTEN VEHĂ?CULOS QUE NO AVANZAN</hr><I>";
36
if (C==1){ // Este y Oeste if (H1>0) Cadena = Cadena + "<BR>Este
: " + H1;
if (H2>0) Cadena = Cadena + "<BR>Oeste : " + H2; }else{ // Norte y Sur if (H1>0) Cadena = Cadena + "<BR>Norte : " + H1; if (H2>0) Cadena = Cadena + "<BR>Sur
: " + H2;
} Cadena = Cadena + "</I><BR> Se procede a borrar los contadores respectivos.</H2></B><div align='center'></html>"; Etiqueta.setText(Cadena); Timer pepe = new Timer (8000, new ActionListener (){
@Override
public void actionPerformed(ActionEvent e){ dispose(); } }); pepe.setRepeats(false); pepe.start(); } }
ConexionDB.java package Clases; import java.sql.*; import javax.swing.JOptionPane; public class ConexionDB { static String bd = "dbsemaforos"; static String login = "root";
37
static String password = "semaforos2013"; static String url = "jdbc:mysql://localhost/"+bd; Connection conn = null; public ConexionDB() { try{ Class.forName("com.mysql.jdbc.Driver"); conn = DriverManager.getConnection(url,login,password); if (conn!=null)
System.out.println("Conecci贸n a base de datos listo..");
}catch(ClassNotFoundException | SQLException e){ JOptionPane.showConfirmDialog(null,"Error:" + e.getMessage()); } } public Connection getConnection(){ return conn;
}
public void desconectar(){ conn = null;
System.out.println("La conexion a la base de datos "+bd+" a
terminado"); } }
EstadisticasVehiculos.java package Clases; import java.sql.*;
public class EstadisticasVehiculos { ConexionDB con;
38
public EstadisticasVehiculos(){ con = new ConexionDB(); }
public void NuevoEstVeh(String TT, String SS, int VV){ try { PreparedStatement PE = con.getConnection().prepareStatement("INSERT INTO tbl_isvehiculos (T, S, V) VALUES(?, ?, ?)"); PE.setString(1, String.valueOf(TT)); PE.setString(2, String.valueOf(SS)); PE.setInt(3, VV); PE.execute(); PE.close(); }catch(SQLException e){ } } }
Funcionamiento.java package Clases; import java.sql.*;
public class Funcionamiento { ConexionDB con; public Funcionamiento(){
System.out.println("ExceptionNuevoEstVeh: "+e);
39
con = new ConexionDB(); } public void updateParCic(String OFS, String TFS, String C1, String C2, String C3, String C4, String C5, String C6, String TEM, String LI, String PAT, //String MI, String PUERTO, String BITS, String BAUDIOS){ try { PreparedStatement PF = con.getConnection().prepareStatement("UPDATE tbl_funcionamiento "+ "SET OFS=?, TFS=?, C1=?, C2=?, C3=?, C4=?, C5=?, C6=?, TEM=?, LI=?, PAT=?, PUERTO=?, BITS=?, BAUDIOS=? where Codigo = 1"); PF.setString(1, String.valueOf(OFS)); PF.setString(2, String.valueOf(TFS)); PF.setString(3, String.valueOf(C1)); PF.setString(4, String.valueOf(C2)); PF.setString(5, String.valueOf(C3)); PF.setString(6, String.valueOf(C4)); PF.setString(7, String.valueOf(C5)); PF.setString(8, String.valueOf(C6)); PF.setString(9, String.valueOf(TEM)); PF.setString(10, String.valueOf(LI)); PF.setString(11, String.valueOf(PAT)); PF.setString(12, PUERTO); PF.setString(13, String.valueOf(BITS)); PF.setString(14, String.valueOf(BAUDIOS));
40
PF.execute(); PF.close(); }catch(SQLException e){
System.out.println("ExceptionupdateParCic: "+e);
} } public String[] DatosControles(){ String datosRegistro[] = new String[15]; try{ PreparedStatement ConFun = con.getConnection().prepareStatement("SELECT * FROM tbl_funcionamiento"); ResultSet RegFun = ConFun.executeQuery(); RegFun.next(); datosRegistro[0] = RegFun.getString("OFS"); datosRegistro[1] = RegFun.getString("TFS"); datosRegistro[2] = RegFun.getString("C1"); datosRegistro[3] = RegFun.getString("C2"); datosRegistro[4] = RegFun.getString("C3"); datosRegistro[5] = RegFun.getString("C4"); datosRegistro[6] = RegFun.getString("C5"); datosRegistro[7] = RegFun.getString("C6"); datosRegistro[8] = RegFun.getString("TEM"); datosRegistro[9] = RegFun.getString("LI"); datosRegistro[10] = RegFun.getString("PAT"); datosRegistro[12] = RegFun.getString("PUERTO"); datosRegistro[13] = RegFun.getString("BITS");
41
datosRegistro[14] = RegFun.getString("BAUDIOS"); RegFun.close(); }catch(SQLException e){
System.out.println("ExceptionDatosControles"+e);
} return datosRegistro; } }
Report.java package Clases; import java.awt.Frame; import java.sql.*; import java.util.HashMap; import java.util.Map; import javax.swing.JOptionPane; import net.sf.jasperreports.engine.JRException; import net.sf.jasperreports.engine.JasperFillManager; import net.sf.jasperreports.engine.JasperPrint; import net.sf.jasperreports.engine.JasperReport; import net.sf.jasperreports.engine.util.JRLoader; import net.sf.jasperreports.view.JasperViewer;
public class Report { private ConexionDB Conn; private String Master;
42
private JasperReport masterReport; private JasperPrint JasperPrint; private JasperViewer Jviewer; public Map Parametros; @SuppressWarnings("static-access") public Report(){ this.Parametros = new HashMap(); this.Master = System.getProperty("user.dir"); //Obtener el directorio donde esta ubicado el sistema Conn = new ConexionDB(); } // Metodo para cargar el reporte public void verReportes(String rpt) throws ClassNotFoundException, SQLException { Master = Master + "/src/Reportes/Rpt"+rpt+".jasper"; if (Master == null) { JOptionPane.showMessageDialog(null, "No se encontro el reporte maestro,\n asegurese que esta copiado en la ruta correcta", "Error", JOptionPane.ERROR_MESSAGE); } try { masterReport = (JasperReport) JRLoader.loadObject(Master); JasperPrint = JasperFillManager.fillReport(masterReport,Parametros,Conn.getConnection());
43
Jviewer = new JasperViewer(JasperPrint,false);
//Crear una variable de
opciones del reporte Jviewer.setTitle("REPORTE "+rpt.toUpperCase()); //Cambiar el tĂtulo del reporte solicitado Jviewer.setExtendedState(Frame.MAXIMIZED_BOTH); Jviewer.setVisible(true);
//Visualizar el reporte
} catch (JRException ex) { JOptionPane.showMessageDialog(null, "Error al cargar el reporte maestro: \n" + ex.getMessage(), "Error", JOptionPane.ERROR_MESSAGE); } finally { try { if (Conn != null) { Conn.desconectar();
}
} catch (Exception e)
{ e.printStackTrace();
} } }
Splash.java package Clases; import java.awt.*; import java.awt.SplashScreen; public final class Splash {
}
44
final SplashScreen splash ; public Splash() { splash = SplashScreen.getSplashScreen(); } public void animar() { if (splash != null) { Graphics2D g = splash.createGraphics(); for(int i=0; i<800; i+=5) { g.fillRect(100, 525,i , 30);
// x,y,ancho,alto
g.setColor( new Color(0,102,204)); //Color del Fondo splash.update(); try { Thread.sleep(1);} catch(InterruptedException e) { } } splash.close(); } } }
Usuario.java package Clases; import java.sql.*; public class Usuario { ConexionDB con; public Usuario (){
con = new ConexionDB();
}
45
public void NuevoUsuario(String N, String U, String C, String T, String E) { try { PreparedStatement POLO = con.getConnection().prepareStatement("INSERT INTO tbl_usuarios" + "(Nombres, Usuario, Clave, Tipo, Estado) VALUES(?,?,?,?,?)"); POLO.setString(1, N); POLO.setString(2, U); POLO.setString(3, C); POLO.setString(4, T); POLO.setString(5, E); POLO.execute(); POLO.close(); }catch(SQLException e){
System.out.println(e);
}
} public void updateUsuario(String C, String N, String U, String P, String T, String E){ try { PreparedStatement POLO = con.getConnection().prepareStatement("UPDATE tbl_usuarios "+ "SET Nombres=?, Usuario=?, Clave=?, Tipo=?, Estado=? where Codigo = ?"); POLO.setString(1, N); POLO.setString(2, U); POLO.setString(3, P); POLO.setString(4, T); POLO.setString(5, E); POLO.setString(6, String.valueOf(C)); POLO.execute();
46
POLO.close(); }catch(SQLException e){
System.out.println("ExceptionupdateUsuario: "+e);
} } public void eliminarUsuario(String C){ try { PreparedStatement POLO = con.getConnection().prepareStatement("DELETE FROM tbl_usuarios WHERE Codigo = ?"); POLO.setString(1, C); POLO.execute(); POLO.close(); }catch(SQLException e){
System.out.println(e);
}
} public String[] buscarUsuario(String U, String P){ String datosRegistro[] = new String[4]; try{ int registros = 0; PreparedStatement POLO = con.getConnection().prepareStatement("SELECT * FROM tbl_usuarios " + "WHERE Usuario = '" + U + "' AND Clave = '" + P + "'"); ResultSet res = POLO.executeQuery(); while(res.next()) registros++; if (registros >= 1){ res.previous(); datosRegistro[0] = Integer.toString(registros); datosRegistro[1] = res.getString("Tipo"); datosRegistro[2] = res.getString("Estado");
47
datosRegistro[3] = res.getString("Nombres"); } res.close(); }catch(SQLException e){
System.out.println(e);
}
return datosRegistro; } public Object [][] getDatos(){ int registros = 0; try{ PreparedStatement POLO = con.getConnection().prepareStatement("SELECT count(1) as total FROM tbl_usuarios "); ResultSet res = POLO.executeQuery(); res.next(); registros = res.getInt("total"); res.close(); }catch(SQLException e){
System.out.println(e);
}
Object[][] data = new String[registros][7]; try{ PreparedStatement POLO = con.getConnection().prepareStatement("SELECT " + " Codigo, Nombres, Usuario, Clave, FechaRegistro, Tipo, Estado " + " FROM tbl_usuarios" + " ORDER BY Codigo "); ResultSet res = POLO.executeQuery(); int i = 0; while(res.next()){ String estC = res.getString("Codigo");
data[i][0] = estC;
48
String estN = res.getString("Nombres");
data[i][1] = estN;
String estU = res.getString("Usuario");
data[i][2] = estU;
String estCL = res.getString("Clave");
data[i][3] = estCL;
String estFR = res.getString("FechaRegistro"); String estT = res.getString("Tipo");
data[i][4] = estFR;
data[i][5] = estT;
String estE = res.getString("Estado");
data[i][6] = estE;
i++; } res.close(); }catch(SQLException e){
System.out.println(e);
return data; } }
FrmPincipal.java package Formas; import Clases.ClaseSerial; import Clases.EstadisticasVehiculos; import Clases.Funcionamiento; import Clases.Usuario; import java.awt.event.ActionEvent; import static java.awt.image.ImageObserver.ERROR; import java.io.IOException; import java.sql.SQLException; import java.text.SimpleDateFormat; import java.util.Calendar;
}
49
import java.util.Date; import java.util.logging.Level; import java.util.logging.Logger; import javax.swing.AbstractAction; import javax.swing.ImageIcon; import javax.swing.JComboBox; import javax.swing.JOptionPane; import javax.swing.Timer; import javax.swing.table.DefaultTableModel;
public class FrmPrincipal extends javax.swing.JFrame { private static boolean flag = true;
// Sirve de bandera para el cambio de luces
en las intermitentes private static int carga = 0; private static String[] datos; private static String[] days = new String[]{"Domingo","Lunes","Martes","MiĂŠrcoles","Jueves","Viernes","Sabado"}; private Calendar cal; private Integer LimSeg = 5;
private Date dates; // Limite segundos antes de enviar a guardar
la cantidad de los sensores en la BD public static int BEN = 0;
public static int BSN = 0; // Banderas para
conseguir la diferencia public static int BES = 0; almacenar en la DB
public static int BSS = 0; // de vehĂculos para
50
public static int BEE = 0;
public static int BSE = 0; // y no guardar
reduntantemente. public static int BEO = 0;
public static int BSO = 0;
public static ClaseSerial USB = new ClaseSerial(); public static Integer OnOffTblFuncionamiento = 0; // Estado del Sistema 0 = Apagado - 1 = Encendido public static Integer TipoTblFuncionamiento = 0; // Tipo de funcionamiento
0=
Inteligente - 1 = Normal - 2 = Intermitente public static String PuertoSeleccionado; public static String usrdir = System.getProperty("user.dir")+"/src/Imagenes"; public static String cadenaTarjeta = ""; int fila = 0; int save = 1; EstadisticasVehiculos ObjEV = new EstadisticasVehiculos(); Funcionamiento ObjFuncionamiento = new Funcionamiento(); Object[][] MatrizUsr; // Almacena temporalmente los registros de los Usuarios para pasarlos al grid. Usuario ObjUsuario = new Usuario(); public FrmPrincipal() { initComponents(); } private void setEnabledCiclosParametros(boolean estado){ // Activo o desactivo los controles de parรกmetros, configuracion y Sistema. txtC1.setEditable(estado);
txtC2.setEditable(estado);
txtC3.setEditable(estado);
txtC4.setEditable(estado);
51
txtC5.setEditable(estado);
txtC6.setEditable(estado);
radInteligente.setEnabled(estado);
radManual.setEnabled(estado);
radIntermitente.setEnabled(estado);
btnEnviarParam.setEnabled(estado);
txtTiempoEspera.setEditable(estado); sliderPorcentaje.setEnabled(estado);
txtLimiteIntentos.setEditable(estado); cboPorts.setEnabled(estado);
txtTimeOuts.setEditable(estado);
txtBaudRate.setEditable(estado);
} private void setEnabledUsuarios(boolean estado){ // Activo o desactivo los controles de la pesta単a de usuarios. btnNuevoUsuario.setEnabled(estado); btnActualizarUsuario.setEnabled(estado); btnEliminarUsuario.setEnabled(estado); btnImprimirUsuario.setEnabled(estado); txtCodigo.setEnabled(estado);
txtNombres.setEnabled(estado);
txtUsuario.setEnabled(estado);
txtClave.setEnabled(estado);
cboTipoUser.setEnabled(estado);
chkEstadoUser.setEnabled(estado);
dccFechaRegistro.setEditable(estado); tableUsuarios.setVisible(false); } private void getDatosControles(){ // Actualiza el registro de funcionamiento en los controles String Datos[] = new String[15]; Datos = ObjFuncionamiento.DatosControles(); OnOffTblFuncionamiento = Integer.parseInt(Datos[0]); TipoTblFuncionamiento = Integer.parseInt(Datos[1]); if (TipoTblFuncionamiento == 0 )
radInteligente.setSelected(true);
52
if (TipoTblFuncionamiento == 1 )
radManual.setSelected(true);
if (TipoTblFuncionamiento == 2 )
radIntermitente.setSelected(true);
txtC1.setText(Datos[2]);
txtC2.setText(Datos[3]);
txtC3.setText(Datos[4]);
txtC4.setText(Datos[5]);
txtC5.setText(Datos[6]);
txtC6.setText(Datos[7]);
txtTiempoEspera.setText(Datos[8]);
txtLimiteIntentos.setText(Datos[9]);
sliderPorcentaje.setValue(Integer.parseInt(Datos[10])); txtTimeOuts.setText(Datos[13]);
txtBaudRate.setText(Datos[14]);
} private void updateUsers(){
// Relleno el grid con los datos de la tabla Usuarios
String[] Campos = {"Codigo","Nombres", "Usuario", "Clave", "FechaRegistro", "Tipo", "Estado"}; MatrizUsr = ObjUsuario.getDatos();
DefaultTableModel datos = new
DefaultTableModel(MatrizUsr,Campos); tableUsuarios.setModel(datos); } private void newUsers(){ // Agrego un nuevo usuario Calendar Cal= Calendar.getInstance(); String fec= Cal.get(Cal.DATE)+"/"+(Cal.get(Cal.MONTH)+1)+"/"+Cal.get(Cal.YEAR)+" "+Cal.get(Cal.HOUR_OF_DAY)+":"+Cal.get(Cal.MINUTE)+":"+Cal.get(Cal.SEC OND); dccFechaRegistro.setText(fec); txtNombres.setText(""); txtClave.setText("");
txtCodigo.setText(""); txtUsuario.setText(""); chkEstadoUser.setSelected(false);
53
btnActualizarUsuario.setVisible(false); btnEliminarUsuario.setEnabled(false); btnImprimirUsuario.setEnabled(false); btnNuevoUsuario.setVisible(false); btnGuardarUsuario.setEnabled(true); btnCancelarGuardarUsuario.setEnabled(true); txtNombres.requestFocus(); } private void printUsers(int F){ tableUsuarios.setRowSelectionInterval(F, F); txtCodigo.setText(String.valueOf(tableUsuarios.getValueAt(F, 0))); txtNombres.setText(String.valueOf(tableUsuarios.getValueAt(F, 1))); txtUsuario.setText(String.valueOf(tableUsuarios.getValueAt(F, 2))); txtClave.setText(String.valueOf(tableUsuarios.getValueAt(F, 3))); dccFechaRegistro.setText(String.valueOf(tableUsuarios.getValueAt(F, 4))); String TU = String.valueOf(tableUsuarios.getValueAt(F, 5)); if (TU.equals("O")) cboTipoUser.setSelectedIndex(0); if (TU.equals("S")) cboTipoUser.setSelectedIndex(1); if (TU.equals("A")) cboTipoUser.setSelectedIndex(2); String EU = String.valueOf(tableUsuarios.getValueAt(F, 6)); if (EU.equals("0")) chkEstadoUser.setSelected(false); if (EU.equals("1")) chkEstadoUser.setSelected(true); }
public static void cambiarLuces(Integer ciclo, String cadena){ // Realiza los cambios de luces de los semรกforos. switch(ciclo){
54
case 0: if(flag == true){ jLabelSemaforoNS.setIcon(new ImageIcon(usrdir+"/Amarillo.png")); jLabelSemaforoSN.setIcon(new ImageIcon(usrdir+"/Amarillo.png")); jLabelSemaforoEO.setIcon(new ImageIcon(usrdir+"/Amarillo.png")); jLabelSemaforoOE.setIcon(new ImageIcon(usrdir+"/Amarillo.png")); flag = false; }else{ jLabelSemaforoNS.setIcon(new ImageIcon(usrdir+"/Apagados.png")); jLabelSemaforoSN.setIcon(new ImageIcon(usrdir+"/Apagados.png")); jLabelSemaforoEO.setIcon(new ImageIcon(usrdir+"/Apagados.png")); jLabelSemaforoOE.setIcon(new ImageIcon(usrdir+"/Apagados.png")); flag = true; } jButtonApagar.setEnabled(true); jButtonEncender.setEnabled(false); vaciarCalles(); break; case 1: jLabelSemaforoNS.setIcon(new ImageIcon(usrdir+"/Rojo.png")); jLabelSemaforoSN.setIcon(new ImageIcon(usrdir+"/Rojo.png")); jLabelSemaforoEO.setIcon(new ImageIcon(usrdir+"/Verde.png")); jLabelSemaforoOE.setIcon(new ImageIcon(usrdir+"/Verde.png")); jLabelEN.setIcon(new ImageIcon(usrdir+"/CarroNR.png")); jLabelES.setIcon(new ImageIcon(usrdir+"/CarroSR.png"));
55
jLabelEE.setIcon(new ImageIcon(usrdir+"/CarroEV.png")); jLabelEO.setIcon(new ImageIcon(usrdir+"/CarroOV.png")); jButtonApagar.setEnabled(true); jButtonEncender.setEnabled(false); break; case 2: jLabelSemaforoNS.setIcon(new ImageIcon(usrdir+"/Rojo.png")); jLabelSemaforoSN.setIcon(new ImageIcon(usrdir+"/Rojo.png")); jLabelSemaforoEO.setIcon(new ImageIcon(usrdir+"/Amarillo.png")); jLabelSemaforoOE.setIcon(new ImageIcon(usrdir+"/Amarillo.png")); jButtonApagar.setEnabled(true); jButtonEncender.setEnabled(false); break; case 3: jLabelSemaforoNS.setIcon(new ImageIcon(usrdir+"/Rojo.png")); jLabelSemaforoSN.setIcon(new ImageIcon(usrdir+"/Rojo.png")); jLabelSemaforoEO.setIcon(new ImageIcon(usrdir+"/Rojo.png")); jLabelSemaforoOE.setIcon(new ImageIcon(usrdir+"/Rojo.png")); jLabelEN.setIcon(new ImageIcon(usrdir+"/CarroNR.png")); jLabelES.setIcon(new ImageIcon(usrdir+"/CarroSR.png")); jLabelEE.setIcon(new ImageIcon(usrdir+"/CarroER.png")); jLabelEO.setIcon(new ImageIcon(usrdir+"/CarroOR.png")); jButtonApagar.setEnabled(true); jButtonEncender.setEnabled(false); break;
56
case 4: jLabelSemaforoNS.setIcon(new ImageIcon(usrdir+"/Verde.png")); jLabelSemaforoSN.setIcon(new ImageIcon(usrdir+"/Verde.png")); jLabelSemaforoEO.setIcon(new ImageIcon(usrdir+"/Rojo.png")); jLabelSemaforoOE.setIcon(new ImageIcon(usrdir+"/Rojo.png")); jLabelEN.setIcon(new ImageIcon(usrdir+"/CarroNV.png")); jLabelES.setIcon(new ImageIcon(usrdir+"/CarroSV.png")); jLabelEE.setIcon(new ImageIcon(usrdir+"/CarroER.png")); jLabelEO.setIcon(new ImageIcon(usrdir+"/CarroOR.png")); jButtonApagar.setEnabled(true); jButtonEncender.setEnabled(false); break; case 5: jLabelSemaforoNS.setIcon(new ImageIcon(usrdir+"/Amarillo.png")); jLabelSemaforoSN.setIcon(new ImageIcon(usrdir+"/Amarillo.png")); jLabelSemaforoEO.setIcon(new ImageIcon(usrdir+"/Rojo.png")); jLabelSemaforoOE.setIcon(new ImageIcon(usrdir+"/Rojo.png")); jButtonApagar.setEnabled(true); jButtonEncender.setEnabled(false); break; case 6: jLabelSemaforoNS.setIcon(new ImageIcon(usrdir+"/Rojo.png")); jLabelSemaforoSN.setIcon(new ImageIcon(usrdir+"/Rojo.png")); jLabelSemaforoEO.setIcon(new ImageIcon(usrdir+"/Rojo.png")); jLabelSemaforoOE.setIcon(new ImageIcon(usrdir+"/Rojo.png"));
57
jLabelEN.setIcon(new ImageIcon(usrdir+"/CarroNR.png")); jLabelES.setIcon(new ImageIcon(usrdir+"/CarroSR.png")); jLabelEE.setIcon(new ImageIcon(usrdir+"/CarroER.png")); jLabelEO.setIcon(new ImageIcon(usrdir+"/CarroOR.png")); jButtonApagar.setEnabled(true); jButtonEncender.setEnabled(false); break; case 9:
// Se Apagan los Sem谩foros
jLabelSemaforoNS.setIcon(new ImageIcon(usrdir+"/Apagados.png")); jLabelSemaforoSN.setIcon(new ImageIcon(usrdir+"/Apagados.png")); jLabelSemaforoEO.setIcon(new ImageIcon(usrdir+"/Apagados.png")); jLabelSemaforoOE.setIcon(new ImageIcon(usrdir+"/Apagados.png")); jButtonEncender.setEnabled(true); jButtonApagar.setEnabled(false); break; } } public static void vaciarCalles(){ // Desaparece los carros de la intersecci贸n. jLabelEN.setIcon(new ImageIcon(""));
jLabelES.setIcon(new ImageIcon(""));
jLabelEE.setIcon(new ImageIcon(""));
jLabelEO.setIcon(new ImageIcon(""));
} public static void cargarDatos(String cadena){ // visualiza en las etiquetas los datos recolectados por los sensores datos = cadena.split("-");
carga = 1;
jLabelEntradaN.setText(datos[1]);
jLabelEntradaN1.setText(datos[1]);
58
jLabelEntradaS.setText(datos[2]);
jLabelEntradaS1.setText(datos[2]);
jLabelEntradaE.setText(datos[3]);
jLabelEntradaE1.setText(datos[3]);
jLabelEntradaO.setText(datos[4]);
jLabelEntradaO1.setText(datos[4]);
jLabelColaNS.setText(datos[5]);
jLabelColaSN.setText(datos[6]);
jLabelColaEO.setText(datos[7]);
jLabelColaOE.setText(datos[8]);
jLabelSalidaN.setText(datos[9]);
jLabelSalidaN2.setText(datos[9]);
jLabelSalidaS.setText(datos[10]);
jLabelSalidaS2.setText(datos[10]);
jLabelSalidaE.setText(datos[11]);
jLabelSalidaE2.setText(datos[11]);
jLabelSalidaO.setText(datos[12]);
jLabelSalidaO2.setText(datos[12]);
}
private void setParametrosCiclos(){ // enviar a guardar los cambios de los parรกmetros String OFS = String.valueOf(OnOffTblFuncionamiento); // Encendido o Apagado String TFS = String.valueOf(TipoTblFuncionamiento); // Tipo de Funcionamiento String C1 = txtC1.getText();
String C2 = txtC2.getText();
String C3 = txtC3.getText();
String C4 = txtC4.getText();
String C5 = txtC5.getText();
String C6 = txtC6.getText();
String TEM = txtTiempoEspera.getText(); String LI = txtLimiteIntentos.getText(); String PAT = txtPorcentaje.getText().replace("%", ""); String PUERTO = cboPorts.getSelectedItem().toString(); String BITS = txtTimeOuts.getText();
59
String BAUDIOS = txtBaudRate.getText(); ObjFuncionamiento.updateParCic(OFS, TFS, C1, C2, C3, C4, C5, C6, TEM, LI, PAT, PUERTO, BITS, BAUDIOS); } public static void construirCadena(){ // Contruye la cadena para enviar los parรกmetros a la placa cadenaTarjeta = ""; //1er Parรกmetro - Determinar si esta encendido o apagado if (OnOffTblFuncionamiento == 0){ cadenaTarjeta = cadenaTarjeta+"00"; } if (OnOffTblFuncionamiento == 1){ cadenaTarjeta = cadenaTarjeta+"01"; } //2do Parรกmetro - Determinar el tipo de funcionamiento 00 = Inteligente, 01 = Manual, 02 = Intermitente if (TipoTblFuncionamiento == 0){ cadenaTarjeta = cadenaTarjeta+"00";
}
if (TipoTblFuncionamiento == 1){ cadenaTarjeta = cadenaTarjeta+"01";
}
if (TipoTblFuncionamiento == 2){ cadenaTarjeta = cadenaTarjeta+"02";
}
//3er Parรกmetro - Determina el tiempo en segundos del Ciclo Intermitente cadenaTarjeta = cadenaTarjeta + "002"; //Ciclo Cero // 4to Parรกmetro - Determina el tiempo en segundos del Ciclo 1 if(Integer.parseInt(txtC1.getText())<10){ cadenaTarjeta = cadenaTarjeta + "00" + Integer.parseInt(txtC1.getText()); }else{ if(Integer.parseInt(txtC1.getText())<100){ cadenaTarjeta = cadenaTarjeta + "0" + Integer.parseInt(txtC1.getText());
60
}else{ cadenaTarjeta = cadenaTarjeta + Integer.parseInt(txtC1.getText()); } } //5to Parรกmetro - Determina el tiempo en segundos del Ciclo 2 if(Integer.parseInt(txtC2.getText())<10){ cadenaTarjeta = cadenaTarjeta + "00" + Integer.parseInt(txtC2.getText()); }else{ if(Integer.parseInt(txtC2.getText())<100){ cadenaTarjeta = cadenaTarjeta + "0" + Integer.parseInt(txtC2.getText()); }else{ cadenaTarjeta = cadenaTarjeta + Integer.parseInt(txtC2.getText()); } } //6to Parรกmetro - Determina el tiempo en segundos del Ciclo 3 if(Integer.parseInt(txtC3.getText())<10){ cadenaTarjeta = cadenaTarjeta + "00" + Integer.parseInt(txtC3.getText()); }else{ if(Integer.parseInt(txtC3.getText())<100){ cadenaTarjeta = cadenaTarjeta + "0" + Integer.parseInt(txtC3.getText()); }else{ cadenaTarjeta = cadenaTarjeta + Integer.parseInt(txtC3.getText()); } } //7mo Parรกmetro - Determina el tiempo en segundos del Ciclo 4 if(Integer.parseInt(txtC4.getText())<10){ cadenaTarjeta = cadenaTarjeta + "00" + Integer.parseInt(txtC4.getText()); }else{ if(Integer.parseInt(txtC4.getText())<100){ cadenaTarjeta = cadenaTarjeta + "0" + Integer.parseInt(txtC4.getText()); }else{ cadenaTarjeta = cadenaTarjeta + Integer.parseInt(txtC4.getText()); } } //8vo Parรกmetro - Determina el tiempo en segundos del Ciclo 5
61
if(Integer.parseInt(txtC5.getText())<10){ cadenaTarjeta = cadenaTarjeta + "00" + Integer.parseInt(txtC5.getText()); }else{ if(Integer.parseInt(txtC5.getText())<100){ cadenaTarjeta = cadenaTarjeta + "0" + Integer.parseInt(txtC5.getText()); }else{ cadenaTarjeta = cadenaTarjeta + Integer.parseInt(txtC5.getText()); } } //9no Parámetro - Determina el tiempo en segundos del Ciclo 6 if(Integer.parseInt(txtC6.getText())<10){ cadenaTarjeta = cadenaTarjeta + "00" + Integer.parseInt(txtC6.getText()); }else{ if(Integer.parseInt(txtC6.getText())<100){ cadenaTarjeta = cadenaTarjeta + "0" + Integer.parseInt(txtC6.getText()); }else{ cadenaTarjeta = cadenaTarjeta + Integer.parseInt(txtC6.getText()); } } //10mo Parámetro - Determina el tiempo en segundos del Tiempo Máximo de Espera if(Integer.parseInt(txtTiempoEspera.getText())<10){ cadenaTarjeta = cadenaTarjeta + "0" + Integer.parseInt(txtTiempoEspera.getText()); }else{ cadenaTarjeta = cadenaTarjeta + Integer.parseInt(txtTiempoEspera.getText());
}
//11vo Parámetro - Determina el Límite de Intentos if(Integer.parseInt(txtLimiteIntentos.getText())<10){ cadenaTarjeta = cadenaTarjeta + "0" + Integer.parseInt(txtLimiteIntentos.getText()); }else{ cadenaTarjeta = cadenaTarjeta + Integer.parseInt(txtLimiteIntentos.getText());
}
//12vo Parámetro - Determina el Porcentaje de Aumento
62
if(Integer.parseInt(txtPorcentaje.getText().replace("%", ""))<10) cadenaTarjeta = cadenaTarjeta + "0"; cadenaTarjeta = cadenaTarjeta + txtPorcentaje.getText().replace("%", ""); sendData(cadenaTarjeta); } public static void sendData(String todo) { // Envia los datos a la placa y a la base de datos try { ClaseSerial.output.write(todo.getBytes()); //Se hace el envio de bits a la placa jTextPaneLog.setText("Datos Enviados: "+todo); System.out.println("<-"+todo); } catch (IOException e) { System.exit(ERROR); } } private void jButtonEncenderActionPerformed(java.awt.event.ActionEvent evt) { jButtonApagar.setEnabled(true); btnModificarParam.setEnabled(true);
jButtonEncender.setEnabled(false); OnOffTblFuncionamiento = 1;
construirCadena(); } private void jButtonApagarActionPerformed(java.awt.event.ActionEvent evt) { jButtonEncender.setEnabled(true);
jButtonApagar.setEnabled(false);
btnModificarParam.setVisible(true);
btnModificarParam.setEnabled(false);
btnEnviarParam.setEnabled(false);
getDatosControles();
63
jLabelSemaforoNS.setIcon(new ImageIcon(usrdir+"/Apagados.png")); jLabelSemaforoSN.setIcon(new ImageIcon(usrdir+"/Apagados.png")); jLabelSemaforoEO.setIcon(new ImageIcon(usrdir+"/Apagados.png")); jLabelSemaforoOE.setIcon(new ImageIcon(usrdir+"/Apagados.png")); OnOffTblFuncionamiento = 0; setEnabledCiclosParametros(false); // Desactiva los controles del Panel derecho de configuraciones y de la pestaña Parámetros construirCadena();
vaciarCalles();
} private void formWindowActivated(java.awt.event.WindowEvent evt) { } private void btnModificarParamActionPerformed(java.awt.event.ActionEvent evt) { btnModificarParam.setVisible(false);
txtTiempoEspera.requestFocus();
setEnabledCiclosParametros(true); } private void btnEnviarParamActionPerformed(java.awt.event.ActionEvent evt) { if(txtC1.getText().equals("") || txtC2.getText().equals("") || txtC3.getText().equals("") || txtC4.getText().equals("") || txtC5.getText().equals("") || txtC6.getText().equals("") || txtTiempoEspera.getText().equals("") || txtLimiteIntentos.getText().equals("") || txtTimeOuts.getText().equals("") || txtBaudRate.getText().equals("")){ JOptionPane.showMessageDialog(null, "Debe ingresar valores numéricos para todos los parámetros y tiempos de los ciclos.","Advertencia",2);
64
}else{ btnModificarParam.setEnabled(true); btnModificarParam.setVisible(true); setEnabledCiclosParametros(false); // Desactiva los controles del Panel derecho de configuraciones y de la pestaña Parámetros setParametrosCiclos();
// Guarda los datos a la Base de Datos
construirCadena(); JOptionPane.showMessageDialog(null, "Datos enviados a la placa. !","Información",1); } } private void sliderPorcentajeMouseWheelMoved(java.awt.event.MouseWheelEvent evt) { txtPorcentaje.setText(String.valueOf(sliderPorcentaje.getValue())); } private void formWindowOpened(java.awt.event.WindowEvent evt) { updateUsers(); if (JFrameLogin.x == 0) printUsers(0);
// Usuario Administrador
if (JFrameLogin.x == 1) setEnabledUsuarios(false); // Usuario Supervisor if (JFrameLogin.x == 2){ setEnabledUsuarios(false);
// Usuario Operador btnModificarParam.setEnabled(false);
} getDatosControles();
// Actualizo los datos de la base en
controles Timer RelojSistema = new Timer(1000, new AbstractAction()
65
{ @Override public void actionPerformed(ActionEvent ae) { dates = new Date(); SimpleDateFormat Hora = new SimpleDateFormat( "hh:mm:ss a" ); txtHourMeridian.setText(Hora.format(dates)); cal = Calendar.getInstance(); SimpleDateFormat Fecha = new SimpleDateFormat( "dd/MM/yyyy" ); txtDate.setText(days[cal.get(Calendar.DAY_OF_WEEK)-1] + " " + Fecha.format( dates )); cboPorts.removeAllItems(); if ("No se encuentra Puerto COM.".equals(FrmPrincipal.jTextPaneLog.getText())){ jLabelSemaforoNS.setIcon(new ImageIcon(usrdir+"/Desconectado.png")); jLabelSemaforoSN.setIcon(new ImageIcon(usrdir+"/Desconectado.png")); jLabelSemaforoEO.setIcon(new ImageIcon(usrdir+"/Desconectado.png")); jLabelSemaforoOE.setIcon(new ImageIcon(usrdir+"/Desconectado.png")); cboPorts.addItem("null"); } else{
66
cboPorts.addItem(PuertoSeleccionado); if (txtHourMeridian.getText().equalsIgnoreCase("12:00:00 AM")){ //Inicio de un nuevo día..! sendData("B"); // Envio comando para reiniciar valores en los contadores de los vehículos. BEN = 0;
BES = 0;
BEE = 0;
BEO = 0;
BSN = 0;
BSS = 0;
BSE = 0;
BSO = 0;
} } } }); RelojSistema.setRepeats(true); RelojSistema.start(); Timer RelojPlaca = new Timer(500, new AbstractAction() { @Override public void actionPerformed(ActionEvent ae) { USB.initialize(); } }); RelojPlaca.setRepeats(true); RelojPlaca.start(); Timer RelojBD = new Timer(LimSeg * 1000, new AbstractAction() { @Override public void actionPerformed(ActionEvent ae){ int CEN = Integer.valueOf(jLabelEntradaN.getText()) - BEN; // CEN = Contador Entrada Norte, BEN = Bandera
67
int CES = Integer.valueOf(jLabelEntradaS.getText()) - BES; int CEE = Integer.valueOf(jLabelEntradaE.getText()) - BEE; int CEO = Integer.valueOf(jLabelEntradaO.getText()) - BEO; int CSN = Integer.valueOf(jLabelSalidaN.getText()) - BSN; // CEN = Contador Salida Norte, BSN = Bandera int CSS = Integer.valueOf(jLabelSalidaS.getText()) - BSS; int CSE = Integer.valueOf(jLabelSalidaE.getText()) - BSE; int CSO = Integer.valueOf(jLabelSalidaO.getText()) - BSO; BEN = Integer.valueOf(jLabelEntradaN.getText());
BSN =
Integer.valueOf(jLabelSalidaN.getText()); BES = Integer.valueOf(jLabelEntradaS.getText());
BSS =
Integer.valueOf(jLabelSalidaS.getText()); BEE = Integer.valueOf(jLabelEntradaE.getText());
BSE =
Integer.valueOf(jLabelSalidaE.getText()); BEO = Integer.valueOf(jLabelEntradaO.getText());
BSO =
Integer.valueOf(jLabelSalidaO.getText()); if (carga == 1)
// Para no guardar la primera vez que se inicia el
programa { // Almacena en la DB luego de ejecutar el procedimiento cargarDatos(String) if (CEN>0) {ObjEV.NuevoEstVeh("Entrada", "Norte", CEN); System.out.println("Se guarda en la BD -> EN: "+CEN); } if (CES>0) {ObjEV.NuevoEstVeh("Entrada", "Sur", CES); System.out.println("Se guarda en la BD -> ES: "+CES); }
68
if (CEE>0) {ObjEV.NuevoEstVeh("Entrada", "Este", CEE); System.out.println("Se guarda en la BD -> EE: "+CEE); } if (CEO>0) {ObjEV.NuevoEstVeh("Entrada", "Oeste", CEO); System.out.println("Se guarda en la BD -> EO: "+CEO); } if (CSN>0) {ObjEV.NuevoEstVeh("Salida", "Norte", CSN); System.out.println("Se guarda en la BD -> SN: "+CSN); } if (CSS>0) {ObjEV.NuevoEstVeh("Salida", "Sur", CSS); System.out.println("Se guarda en la BD -> SS: "+CSS); } if (CSE>0) {ObjEV.NuevoEstVeh("Salida", "Este", CSE); System.out.println("Se guarda en la BD -> SE: "+CSE); } if (CSO>0) {ObjEV.NuevoEstVeh("Salida", "Oeste", CSO); System.out.println("Se guarda en la BD -> SO: "+CSO); } } } }); RelojBD.setRepeats(true); RelojBD.start(); } private void chkEstadoUserActionPerformed(java.awt.event.ActionEvent evt) { } private void tableUsuariosMouseClicked(java.awt.event.MouseEvent evt) { fila = tableUsuarios.rowAtPoint(evt.getPoint()); if (fila > -1 & save > -1){ printUsers(fila); } }
69
private void btnActualizarUsuarioActionPerformed(java.awt.event.ActionEvent evt) { if (fila > -1){ String codigo = String.valueOf(tableUsuarios.getValueAt(fila, 0)); String nombres = txtNombres.getText(); String usuario = txtUsuario.getText(); String clave = txtClave.getText(); String TU = ""; if (cboTipoUser.getSelectedIndex() == 0) TU = "O"; if (cboTipoUser.getSelectedIndex() == 1) TU = "S"; if (cboTipoUser.getSelectedIndex() == 2) TU = "A"; String EU = ""; if (chkEstadoUser.isSelected()){ }else{
EU = "1";
EU = "0";
}
ObjUsuario.updateUsuario(codigo, nombres, usuario, clave, TU, EU); updateUsers();
printUsers(fila);
} } private void btnNuevoUsuarioActionPerformed(java.awt.event.ActionEvent evt) { newUsers();
save = -1;
} private void btnGuardarUsuarioActionPerformed(java.awt.event.ActionEvent evt) { String nom = txtNombres.getText(); String cla = txtClave.getText();
String usu = txtUsuario.getText(); String TU = "";
70
if (cboTipoUser.getSelectedIndex() == 0) TU = "O"; if (cboTipoUser.getSelectedIndex() == 1) TU = "S"; if (cboTipoUser.getSelectedIndex() == 2) TU = "A"; String EU = ""; if (chkEstadoUser.isSelected()){ }else{
EU = "0";
EU = "1"; }
ObjUsuario.NuevoUsuario(nom, usu, cla, TU, EU); updateUsers();
save = 1;
btnNuevoUsuario.setVisible(true);
btnActualizarUsuario.setVisible(true);
btnEliminarUsuario.setEnabled(true);
btnImprimirUsuario.setEnabled(true);
fila = tableUsuarios.getRowCount()-1; printUsers(tableUsuarios.getRowCount()-1); } private void btnEliminarUsuarioActionPerformed(java.awt.event.ActionEvent evt) { if (fila > -1){ String codigo = String.valueOf(tableUsuarios.getValueAt(fila, 0)); ObjUsuario.eliminarUsuario(codigo); updateUsers(); fila=fila-1;
printUsers(fila);
} } private void txtC1KeyReleased(java.awt.event.KeyEvent evt) { if (!txtC1.getText().matches("[0-9--]*")){ JOptionPane.showMessageDialog(null, "Solo se permiten NĂşmeros","Advertencia",2);// 0=advertencia (Rojo) 1=Informacion (Azul) 2=Advertencia (amarillo) 3=Interrogacion (Gris)
71
txtC1.setText("");
txtC1.requestFocus();
} if (txtC1.getText().length()>3){ JOptionPane.showMessageDialog(null, "No mas de tres caracterees","Advertencia",2); txtC1.setText(txtC1.getText().substring(0,3)); } } private void txtC2KeyReleased(java.awt.event.KeyEvent evt) { if (!txtC2.getText().matches("[0-9--]*")){ JOptionPane.showMessageDialog(null, "Solo se permiten NĂşmeros","Advertencia",2);// 0=advertencia (Rojo) 1=Informacion (Azul) 2=Advertencia (amarillo) 3=Interrogacion (Gris) txtC2.setText("");
txtC2.requestFocus();
} if (txtC2.getText().length()>3){ JOptionPane.showMessageDialog(null, "No mas de tres caracterees","Advertencia",2); txtC2.setText(txtC2.getText().substring(0,3)); } } private void txtC3KeyReleased(java.awt.event.KeyEvent evt) { if (!txtC3.getText().matches("[0-9--]*")){
72
JOptionPane.showMessageDialog(null, "Solo se permiten Números","Advertencia",2);// 0=advertencia (Rojo) 1=Informacion (Azul) 2=Advertencia (amarillo) 3=Interrogacion (Gris) txtC3.setText("");
txtC3.requestFocus();
} if (txtC3.getText().length()>3){ JOptionPane.showMessageDialog(null, "No mas de tres caracterees","Advertencia",2); txtC3.setText(txtC3.getText().substring(0,3)); } } private void txtC4KeyReleased(java.awt.event.KeyEvent evt) { if (!txtC4.getText().matches("[0-9--]*")){ JOptionPane.showMessageDialog(null, "Solo se permiten Números","Advertencia",2);// 0=advertencia (Rojo) 1=Informacion (Azul) 2=Advertencia (amarillo) 3=Interrogacion (Gris) txtC4.setText("");
txtC4.requestFocus();
} if (txtC4.getText().length()>3){ JOptionPane.showMessageDialog(null, "No mas de tres caracterees","Advertencia",2); txtC4.setText(txtC4.getText().substring(0,3)); } } private void txtC5KeyReleased(java.awt.event.KeyEvent evt) {
73
if (!txtC5.getText().matches("[0-9--]*")){ JOptionPane.showMessageDialog(null, "Solo se permiten Números","Advertencia",2);// 0=advertencia (Rojo) 1=Informacion (Azul) 2=Advertencia (amarillo) 3=Interrogacion (Gris) txtC5.setText("");
txtC5.requestFocus();
} if (txtC5.getText().length()>3){ JOptionPane.showMessageDialog(null, "No mas de tres caracterees","Advertencia",2); txtC5.setText(txtC5.getText().substring(0,3)); } } private void txtC6KeyReleased(java.awt.event.KeyEvent evt) { if (!txtC6.getText().matches("[0-9--]*")){ JOptionPane.showMessageDialog(null, "Solo se permiten Números","Advertencia",2);// 0=advertencia (Rojo) 1=Informacion (Azul) 2=Advertencia (amarillo) 3=Interrogacion (Gris) txtC6.setText("");
txtC6.requestFocus();
} if (txtC6.getText().length()>3){ JOptionPane.showMessageDialog(null, "No mas de tres caracterees","Advertencia",2); txtC6.setText(txtC6.getText().substring(0,3)); } }
74
private void radInteligenteMouseClicked(java.awt.event.MouseEvent evt) { TipoTblFuncionamiento = 0; } private void radManualMouseClicked(java.awt.event.MouseEvent evt) { TipoTblFuncionamiento = 1; } private void radIntermitenteMouseClicked(java.awt.event.MouseEvent evt) { TipoTblFuncionamiento = 2; } private void btnRptEstadisticaActionPerformed(java.awt.event.ActionEvent evt) { String[] list = {"Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"}; JComboBox jcb = new JComboBox(list);
jcb.setEditable(false);
JOptionPane.showMessageDialog( null, jcb, "Seleccione DĂa de la Semana", JOptionPane.QUESTION_MESSAGE); Clases.Report reportes = new Clases.Report(); String fechaini = estFechaIni.getText(); String[] descomponeini = fechaini.split("/"); fechaini = "20" + descomponeini[2] + "-" + descomponeini[1] + "-" + descomponeini[0]; String horaini = " 0" + spnHoraInicioPTE.getValue() + ":0" + spnMinutoInicioPTE.getValue() + ":0" + spnSegundoInicioPTE.getValue(); String fechafin = estFechaFin.getText(); String[] descomponefin = fechafin.split("/");
75
fechafin = "20" + descomponefin[2] + "-" + descomponefin[1] + "-" + descomponefin[0]; String horafin = " 0" + spnHoraFinPTE.getValue() + ":0" + spnMinutoFinPTE.getValue() + ":0" + spnSegundoFinPTE.getValue(); String fechainisql2 = fechaini + horaini; String fechafinsql2 = fechafin + horafin; java.sql.Timestamp fechainisql = java.sql.Timestamp.valueOf(fechainisql2); java.sql.Timestamp fechafinsql = java.sql.Timestamp.valueOf(fechafinsql2); try { reportes.Parametros.put("FI",fechainisql); reportes.Parametros.put("FF",fechafinsql); reportes.Parametros.put("DIA",jcb.getSelectedIndex()); reportes.verReportes("Diario"); } catch (SQLException | ClassNotFoundException ex) { Logger.getLogger(FrmPrincipal.class.getName()).log(Level.SEVERE, null, ex); } } private void txtTiempoEsperaKeyReleased(java.awt.event.KeyEvent evt) { if (!txtTiempoEspera.getText().matches("[0-9--]*")){ JOptionPane.showMessageDialog(null, "Solo se permiten NĂşmeros","Advertencia",2);// 0=advertencia (Rojo) 1=Informacion (Azul) 2=Advertencia (amarillo) 3=Interrogacion (Gris) txtTiempoEspera.setText("");
txtTiempoEspera.requestFocus();
76
} if (txtTiempoEspera.getText().length()>2){ JOptionPane.showMessageDialog(null, "No mas de dos caracterees","Advertencia",2); txtTiempoEspera.setText(txtTiempoEspera.getText().substring(0,2)); } } private void txtLimiteIntentosKeyReleased(java.awt.event.KeyEvent evt) { if (!txtLimiteIntentos.getText().matches("[0-9--]*")){ JOptionPane.showMessageDialog(null, "Solo se permiten Números","Advertencia",2);// 0=advertencia (Rojo) 1=Informacion (Azul) 2=Advertencia (amarillo) 3=Interrogacion (Gris) txtLimiteIntentos.setText("");
txtLimiteIntentos.requestFocus();
} if (txtLimiteIntentos.getText().length()>2){ JOptionPane.showMessageDialog(null, "No mas de dos caracterees","Advertencia",2); txtLimiteIntentos.setText(txtLimiteIntentos.getText().substring(0,2)); } } private void txtTimeOutsKeyReleased(java.awt.event.KeyEvent evt) { if (!txtTimeOuts.getText().matches("[0-9--]*")){ JOptionPane.showMessageDialog(null, "Solo se permiten Números","Advertencia",2);// 0=advertencia (Rojo) 1=Informacion (Azul) 2=Advertencia (amarillo) 3=Interrogacion (Gris)
77
txtTimeOuts.setText("");
txtTimeOuts.requestFocus();
} if (txtTimeOuts.getText().length()>4){ JOptionPane.showMessageDialog(null, "No mas de cuatro caracterees","Advertencia",2); txtTimeOuts.setText(txtTimeOuts.getText().substring(0,4)); } } private void txtBaudRateKeyReleased(java.awt.event.KeyEvent evt) { if (!txtBaudRate.getText().matches("[0-9--]*")){ JOptionPane.showMessageDialog(null, "Solo se permiten NĂşmeros ","Advertencia",2);// 0=advertencia (Rojo) 1=Informacion (Azul)
2=Advertencia
(amarillo) 3=Interrogacion (Gris) txtBaudRate.setText("");
txtBaudRate.requestFocus();
} if (txtBaudRate.getText().length()>4){ JOptionPane.showMessageDialog(null, "No mas de cuatro caracterees","Advertencia",2); txtBaudRate.setText(txtBaudRate.getText().substring(0,4)); } } private void btnCancelarModificarParamActionPerformed(java.awt.event.ActionEvent evt) { getDatosControles();
setEnabledCiclosParametros(false);
btnModificarParam.setVisible(true);
78
} private void rptReporteGeneralActionPerformed(java.awt.event.ActionEvent evt) { Clases.Report reportes1 = new Clases.Report(); Clases.Report reportes2 = new Clases.Report(); Clases.Report reportes3 = new Clases.Report(); String fechaini = estFechaIni.getText(); String[] descomponeini = fechaini.split("/"); fechaini = "20" + descomponeini[2] + "-" + descomponeini[1] + "-" + descomponeini[0]; String horaini = " 0" + spnHoraInicioPTE.getValue() + ":0" + spnMinutoInicioPTE.getValue() + ":0" + spnSegundoInicioPTE.getValue();
String fechafin =
estFechaFin.getText(); String[] descomponefin = fechafin.split("/"); fechafin = "20" + descomponefin[2] + "-" + descomponefin[1] + "-" + descomponefin[0]; String horafin = " 0" + spnHoraFinPTE.getValue() + ":0" + spnMinutoFinPTE.getValue() + ":0" + spnSegundoFinPTE.getValue(); String fechainisql2 = fechaini + horaini;
String fechafinsql2 = fechafin +
horafin; java.sql.Timestamp fechainisql = java.sql.Timestamp.valueOf(fechainisql2); java.sql.Timestamp fechafinsql = java.sql.Timestamp.valueOf(fechafinsql2); try {
79
reportes1.Parametros.put("FI",fechainisql); reportes1.Parametros.put("FF",fechafinsql); reportes2.Parametros.put("FI",fechainisql); reportes2.Parametros.put("FF",fechafinsql); reportes3.Parametros.put("FI",fechainisql); reportes3.Parametros.put("FF",fechafinsql); reportes1.verReportes("General Horas Dia"); reportes2.verReportes("General Dias Semana"); reportes3.verReportes("General Dias Calendario"); } catch (SQLException | ClassNotFoundException ex) { Logger.getLogger(FrmPrincipal.class.getName()).log(Level.SEVERE, null, ex); } } private void btnImprimirUsuarioActionPerformed(java.awt.event.ActionEvent evt) { Clases.Report reportes = new Clases.Report(); try { reportes.verReportes("Usuarios"); } catch (SQLException | ClassNotFoundException ex) { Logger.getLogger(FrmPrincipal.class.getName()).log(Level.SEVERE, null, ex); } } private void jTabbedPaneOpcionesMouseClicked(java.awt.event.MouseEvent evt) {
80
} private void btnCancelarGuardarUsuarioActionPerformed(java.awt.event.ActionEvent evt) { save = 1;
btnNuevoUsuario.setVisible(true);
btnActualizarUsuario.setVisible(true); btnEliminarUsuario.setEnabled(true); btnImprimirUsuario.setEnabled(true);
printUsers(fila);
}
JFrameLogin.java package Formas; import Clases.Splash; import Clases.Usuario; import javax.swing.ImageIcon; import javax.swing.JOptionPane;
public class JFrameLogin extends javax.swing.JFrame { Usuario ObjUsuario= new Usuario(); public static int x = 0; public static String usuari = ""; public JFrameLogin() { initComponents(); this.setLocationRelativeTo(null); } private void jButtonSalirActionPerformed(java.awt.event.ActionEvent evt) { System.exit(0);
81
} private void formWindowActivated(java.awt.event.WindowEvent evt) { txtUsuario.requestFocus(); } private void jButtonIngresarActionPerformed(java.awt.event.ActionEvent evt) { String datosRegistro[] = new String[3]; datosRegistro = ObjUsuario.buscarUsuario(txtUsuario.getText(),txtContrasena.getText()); if (datosRegistro[0] != null){ if (datosRegistro[0].equals("1")){ if(datosRegistro[2].equals("1")){ FrmPrincipal Principal = new FrmPrincipal(); usuari = datosRegistro[3]; if (datosRegistro[1].equals("A")){ x = 0; Principal.setVisible(true); this.dispose(); } else{ if (datosRegistro[1].equals("S")){ Supervisor x = 1; Principal.setVisible(true); this.dispose(); }else{
// Pregunto si el usuario es
82
if (datosRegistro[1].equals("O")){ // Pregunto si el usuario es Operador x = 2; Principal.setVisible(true); this.dispose(); } } } }else{ JOptionPane.showMessageDialog(null, "Usuario NO ACTIVO. Consulte con el Adminitrador","Error",JOptionPane.ERROR_MESSAGE); } }else{ JOptionPane.showMessageDialog(null, "Usuario y Contrase単a Duplicados. Consulte con el Adminitrador","Error",JOptionPane.ERROR_MESSAGE); } }else{ JOptionPane.showMessageDialog(null, "Usuario o Contrase単a no existe","Error",JOptionPane.ERROR_MESSAGE); } txtUsuario.setText(""); txtContrasena.setText(""); txtUsuario.requestFocus(); } public static void main(String args[]) {
83
new Splash().animar(); try { for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) { if ("Nimbus".equals(info.getName())) { javax.swing.UIManager.setLookAndFeel(info.getClassName()); break; } } } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | javax.swing.UnsupportedLookAndFeelException ex) {
java.util.logging.Logger.getLogger(JFrameLogin.class.getName()).log(java.util.loggi ng.Level.SEVERE, null, ex); } //</editor-fold> java.awt.EventQueue.invokeLater(new Runnable() { public void run() { new JFrameLogin().setVisible(true); } }); }