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
2.1. Antecedentes ............................................................................................................... 3
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
3.1.24. Modelos de Desarrollo de software ..................................................................... 32
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
3.3. Hipótesis de Trabajo ................................................................................................ 38
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. Técnicas de análisis de datos ................................................................................... 41
4.5.1. Entrevista .............................................................................................................. 41
xi
4.5.2. Encuestas .............................................................................................................. 44
4.6. Análisis y selección de herramientas para el desarrollo ....................................... 51
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
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.
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
3
2. PLANTEAMIENTO DEL PROBLEMA
2.1. 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,
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
8
3. MARCO REFERENCIAL
3.1. 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
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:
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:
Ilustración 1. Gráfico. Pulsador Abierto
Ilustración 2. Gráfico. Pulsador Cerrado
Título: Pulsador Abierto.
Fuente: Creado por el Autor.
Ilustración: 1
Título: Pulsador Cerrado.
Fuente: Creado por el Autor.
Ilustración: 2
14
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:
Ilustración 4. Imagen. Distribución de valores según los colores de una resistencia.
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.
Ilustración 3. Gráfico. Símbolos de Resistencias Título: Símbolos de Resistencias.
Fuente: Creado por el Autor.
Ilustración: 3
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
15
Ilustración 5. Imagen. Diodo LED y sus partes
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.
Ilustración 6. Imagen. Lógica Cableada
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
Título: 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.
Ilustración 7. Imagen. Control de puertos de Entrada y Salida
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
Título: Control de puertos de Entrada y Salida.
Fuente: Ejemplo realizado en Arduino por el autor.
Ilustración: 7
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.
Ilustración 8. Imagen. Ejemplo de Microprocesadores
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.
Título: Ejemplo de Microprocesadores.
Fuente: Imagen tomada de http://claudiahernandezinf.blogspot.com/.
Ilustración: 8
18
Ilustración 9. Imagen. Ejemplo de Microcontroladores
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.
Ilustración 10. Gráfico. Ejemplo de la estructura de un PLD
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.
Título: Ejemplo de Microcontroladores.
Fuente: Imagen tomada de http://www.ceiarteuntref.edu.ar/badarte/?q=taxonomy/term/45/9
Ilustración: 9
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
19
Ilustración 11. Gráfico. 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.
Título: Arquitectura de un Sistema basado en CPU.
Fuente: Figura realizada por el autor.
Ilustración: 11
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
Ilustración 12. Imagen. Logo de Arduino
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
Título: Logo de Arduino.
Fuente: Imagen tomada de la página oficial de arduino http://arduino.cc/.
Ilustración: 12
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.
Ilustración 13. Imagen. Primera placa antes de ser Arduino
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.
Título: 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
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:
Ilustración 14. Imagen. Placas y módulos de Arduino
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
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
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
Ilustración 15. Imagen. Arduino DUE
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.
Título: Arduino DUE.
Fuente: Imagen tomada de http://arduino.cc/en/uploads/Main/ArduinoDue_Front.jpg
Ilustración: 15
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
Ilustración 16. Tabla. Comparación funcional entre DUE y Leonardo
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:
Título: Comparación funcional entre DUE y Leonardo.
Fuente: Tabla realizada por el autor en base a la investigación realizada.
Ilustración: 16
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
Ilustración 17. Gráfico. Modelo Lineal o en Cascada
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.
Ilustración 18. Gráfico. Modelo en Espiral
3.1.24.3. Modelo Prototipado o de Prototipos
Título: Modelo Lineal o en Cascada.
Fuente: Ilustración desarrollada por el autor.
Ilustración: 17
Título: Modelo en Espiral.
Fuente: Ilustración tomada de:
http://upload.wikimedia.org/wikipedia/commons/thumb/3/39/ModeloEspiral.svg/359px-ModeloEspiral.svg.png.
Ilustración: 18
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:
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.
Título: Modelo Prototipado o de Prototipos.
Fuente Ilustración desarrollada por el autor
Ilustración: 19
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
39
4. METODOLOGÍA DE LA INVESTIGACIÓN
4.1. 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
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%
Ilustración 20. Tabla. Tabulación pregunta 1. Encuesta a Conductores.
Ilustración 21. Gráfico. Estadística pregunta 1. Encuesta a Conductores.
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.
10
37
20
46
15
0
20
40
60
A B C D E
Per
son
as
Opciones
Pregunta 1
Título: Tabulación pregunta 1. Encuesta a Conductores.
Fuente: Tabla elaborada por el autor, en base a las encuestas realizadas.
Ilustración: 20
Título: Estadística pregunta 1. Encuesta a Conductores.
Fuente: Gráfico elaborado por el autor, en base a las encuestas realizadas.
Ilustración: 21
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%
TOTAL 128 100%
Ilustración 22. Tabla. Tabulación pregunta 2. Encuesta a Conductores.
Ilustración 23. Gráfico. Estadística pregunta 2. Encuesta a Conductores.
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.
4
14
30
55
25
0
10
20
30
40
50
60
A B C D E
Per
son
as
Opciones
Pregunta 2
Título: Tabulación pregunta 2. Encuesta a Conductores.
Fuente: Tabla elaborada por el autor, en base a las encuestas realizadas.
Ilustración: 22
Título: Estadística pregunta 2. Encuesta a Conductores.
Fuente: Gráfico elaborado por el autor, en base a las encuestas realizadas.
Ilustración: 23
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%
TOTAL 128 100%
Ilustración 24. Tabla. Tabulación pregunta 3. Encuesta a Conductores.
Ilustración 25. Gráfico. Estadística pregunta 3. Encuesta a Conductores.
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.
17 20
60
31
0
10
20
30
40
50
60
70
A B C D
Per
son
as
Opciones
Pregunta 3
Título: Tabulación pregunta 3. Encuesta a Conductores.
Fuente: Tabla elaborada por el autor, en base a las encuestas realizadas.
Ilustración: 24
Título: Estadística pregunta 3. Encuesta a Conductores.
Fuente: Gráfico elaborado por el autor, en base a las encuestas realizadas.
Ilustración: 25
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%
Ilustración 26. Tabla. Tabulación pregunta 4. Encuesta a Conductores.
Ilustración 27. Grá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.
10
44 51
23
0
10
20
30
40
50
60
A B C D
Per
son
as
Opciones
Pregunta 4
Título: Tabulación pregunta 4. Encuesta a Conductores.
Fuente: Tabla elaborada por el autor, en base a las encuestas realizadas.
Ilustración: 26
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
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%
TOTAL 128 100%
Ilustración 28. Tabla. Tabulación pregunta 5. Encuesta a Conductores.
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.
24
70
16 18
0
20
40
60
80
A B C D
Per
son
as
Opciones
Pregunta 5
Título: Tabulación pregunta 5. Encuesta a Conductores.
Fuente: Tabla elaborada por el autor, en base a las encuestas realizadas.
Ilustración: 28
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
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%
TOTAL 128 100%
Ilustración 30. Tabla. Tabulación pregunta 6. Encuesta a Conductores.
Ilustración 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.
10
63
22 33
0
20
40
60
80
A B C D
Per
son
as
Opciones
Pregunta 6
Título: Tabulación pregunta 6. Encuesta a Conductores.
Fuente: Tabla elaborada por el autor, en base a las encuestas realizadas.
Ilustración: 30
Título: Estadística pregunta 6. Encuesta a Conductores.
Fuente: Gráfico elaborado por el autor, en base a las encuestas realizadas.
Ilustración: 31
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. Imagen. Pantalla de Proteus con un ejemplo de pulsadores.
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.
Título: Pantalla de Proteus con un ejemplo de pulsadores.
Fuente: Ejemplo realizado por el autor.
Ilustración: 32
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.
Ilustración 33. Imagen. Elaboración del esquema electrónico de la placa para la organización y
distribución de los cables.
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
Título: Elaboración del esquema electrónico de la placa para la organización y distribución de los cables.
Fuente: Esquema realizado por el autor en el programa Inkscape.
Ilustración: 33
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.
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:
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
59
Ilustración 35. Tabla. Estructura de las cadenas de texto para la comunicación entre el ordenador y la
placa Arduino DUE.
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.
Título: Estructura de las cadenas de texto para la comunicación entre el ordenador y la placa Arduino DUE.
Fuente: Tablas realizadas por el autor.
Ilustración: 35
60
Las interfaces iniciales desarrolladas fueron las siguientes:
Ilustración 36. Imagen. Proceso de desarrollo de la primera interfaz del sistema de control para el usuario.
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:
Título: Proceso de desarrollo de la primera interfaz del sistema de control para el usuario.
Fuente: Diseños realizados por el autor.
Ilustración: 36
61
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:
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
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
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
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:
Ilustración 39. Tabla. Diccionario de Datos y Registros de Tablas para las primeras interfaces de usuario.
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:
Título: Diccionario de Datos y Registros de Tablas para las primeras interfaces de usuario.
Fuente: Tablas realizadas por el autor.
Ilustración: 39
63
Ilustración 40. Imagen. Diseño de Interfaz de Usuario.
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:
Título: Diseño de Interfaz de Usuario.
Fuente: Diseño de interfaz realizado por el autor.
Ilustración: 40
Título: Segundo Diccionario de datos.
Fuente: Tablas realizadas por el autor.
Ilustración: 41
64
Ilustración 42. Imagen. Modificación de Interfaz de Usuario con ciclos y pestañas.
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:
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
Título: Diccionario de Datos resultante de la nueva interfaz.
Fuente: Tablas realizadas por el autor.
Ilustración: 43
65
Ilustración 44. Imagen. Interfaz de usuario del Sistema de Control.
Resultado de esto se obtiene el siguiente diccionario de datos:
Ilustración 45. Diccionario de Datos con implantación de los Usuarios.
Título: Interfaz de usuario del Sistema de Control.
Fuente: Diseño de Interfaz realizado por el autor.
Ilustración: 44
Título: Diccionario de Datos con implantación de los Usuarios.
Fuente: Tablas realizadas por el autor.
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:
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
Título: Parte frontal y posterior de la Maqueta.
Fuente: Imagen realizada por el autor.
Ilustración: 46
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.
Ilustración 47. Imagen. Ejemplo de programación para el micro controlador realizado en Basco.
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.
Título: Ejemplo de programación para el micro controlador realizado en Basco.
Fuente: Imagen con código ejemplo realizado por el autor.
Ilustración: 47
68
Ilustración 48. Imagen. Ejemplo de programación en la plataforma de Arduino.
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
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
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
Ilustración 49. Gráfico. Funcionamiento de los ciclos de los semáforos.
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 oeste-
este, 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.
Título: Funcionamiento de los ciclos de los semáforos.
Fuente: Gráfico realizado por el autor
Ilustración: 49
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.
Ilustración 50. Imagen. Clases y Formas del Sistema de Control de Usuario.
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.
Título: 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
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:
Ilustración 51. Imagen. Primera prueba de funcionamiento de pulsadores y diodos led.
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.
Título: Primera prueba de funcionamiento de pulsadores y diodos led.
Fuente: Imagen de práctica realizada por el autor.
Ilustración: 51
74
Ilustración 52. Imagen. Primer semáforo realizado.
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:
Ilustración 53. Imagen. Proceso de elaboración e Implementación de semáforos.
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.
Título: Primer semáforo realizado.
Fuente: Imagen del primer semáforo realizado por el autor.
Ilustración: 52
Título: Proceso de elaboración e Implementación de semáforos.
Fuente: Imágenes del proceso realizado por el autor.
Ilustración: 53
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:
Ilustración 54. Imagen. Proceso de elaboración de la placa para la organización y distribución de los
cables.
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
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.
Fuente: Imagen con proceso realizado por el autor.
Ilustración: 54
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.
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:
Ilustración 56. Imagen. Placa para la Organización y Distribución de los cables junto con la Arduino Due.
Título: Placa luego del planchado.
Fuente: Imagen de una placa realiza por el autor.
Ilustración: 55
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
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
78
5. RESULTADOS
5.1. 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.
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 2da
Edición.
Quito: RISPERGRAF.
Torrente, O.(2013). ARDUINO Curso práctico de formación. Madrid: RC
Libros.
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-caos-
en-cuenca-367319.html
Diario: Hoy
Artículo: Semáforos no tan inteligentes (Quito)
Link: http://www.hoy.com.ec/noticias-ecuador/semaforos-no-tan-inteligentes-
108961.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-la-
Ley-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
Cola Intersección
(Pin de Entrada)
6 Pulsadores por cada Flujo de
tránsito en la intersección
(Total 24 Pines de Entrada)
Entrada
Intersección
(Pin de Entrada)
Salida
Intersección
(Pin de Entrada)
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.
Maqueta con elementos
electrónicos como pulsadores y
diodos leds
3 Luces por semáforo
(Total 12 Pines de
Salida)
Cable USB
tipo B
Cables de red
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, amarillo y
verde).
Canaletas
Tablero triplex
Tubos de antena.
Pintura
Vinilo
Lustre de cocina.
Espadines (pines).
Ácido para placas electrónicas.
Estaño
Pasta para soldar
Herramientas:
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ÁFOROS 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.2-
windows.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-7u21-
windows-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 la configuración
establecida. 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 instalación.
Presionamos clic en Finish.
97
Anexo 7. Manual de Usuario
PROTOTIPO DE SEMÁFOROS 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ÁFOROS 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ÁFORO NORTE-SUR =
Rojo, Amarillo, Verde
byte LSN[3] = 36, 38, 40; // LUCES SEMÁFORO SUR-NORTE =
Rojo, Amarillo, Verde
byte LEO[3] = 49, 47, 45; // LUCES SEMÁFORO ESTE-OESTE =
Rojo, Amarillo, Verde
byte LOE[3] = 3, 4, 5; // LUCES SEMÁFORO OESTE-ESTE =
Rojo, Amarillo, Verde
/* *******************************************************
VARIABLES GENERALES
******************************************************* */
// VARIABLES BANDERAS PARA LOS PULSADORES
// ENTRADAS COLAS SALIDAS ENTRADAS
COLAS 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; // Límite de intentos antes de enviar mensaje a la
central
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 // Esta calle
byte Sentido_2 = 3; // 3 = Oeste
byte Sentido_3 = 0; // 0 = Norte // Calle Transversal
byte Sentido_4 = 1; // 1 = Sur
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 + "-"); Cad = String(Cad + String(CVC[Sentido_2]));
// ya sea el norte y sur o el este y oeste
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; // Bandera para saber
si esta presionado el boton o no. //
void CN1()
if ((digitalRead(PNS[2]) == LOW) && (BNS[2] == 1))
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; // Bandera para saber
si esta presionado el boton o no. //
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; // Bandera para saber
si esta presionado el boton o no. //
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; // Bandera para saber
si esta presionado el boton o no. //
void SE1()
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; // Bandera para saber
si esta presionado el boton o no. //
void EO2()
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; // Bandera para saber
si esta presionado el boton o no. //
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) System.out.println("ExceptionNuevoEstVeh: "+e);
Funcionamiento.java
package Clases;
import java.sql.*;
public class Funcionamiento
ConexionDB con;
public Funcionamiento()
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"); data[i][4] = estFR;
String estT = res.getString("Tipo"); 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 Date dates;
private Integer LimSeg = 5; // 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; public static int BSS = 0; // de vehículos para
almacenar en la DB
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); txtLimiteIntentos.setEditable(estado);
sliderPorcentaje.setEnabled(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); txtCodigo.setText("");
txtNombres.setText(""); txtUsuario.setText("");
txtClave.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); jButtonEncender.setEnabled(false);
btnModificarParam.setEnabled(true); 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) // Usuario Operador
setEnabledUsuarios(false); 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()) EU = "1";
else 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 usu = txtUsuario.getText();
String cla = txtClave.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()) EU = "1";
else EU = "0";
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")) // Pregunto si el usuario es
Supervisor
x = 1;
Principal.setVisible(true);
this.dispose();
else
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);
);
Top Related