prototipo de semáforos inteligentes

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 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.


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.


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%



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



Ilustración: 22



Ilustración: 23

47

Pregunta 3:

El tiempo de duración de las respectivas luces de los semáforos actuales debe:

Pregunta 3


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%



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



Ilustración: 24



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


A. Excelente. 10 7,8%

B. Buena. 44 34,4%

C. Regular. 51 39,8%

D. Pésima. 23 18,0%

TOTAL 128 100%



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



Ilustración: 26



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


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%



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



Ilustración: 28



Ilustración: 29

50

Pregunta 6:

¿Está informado sobre los Semáforos Inteligentes?

Pregunta 6


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%



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



Ilustración: 30



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.


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.


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.


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.


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




intersección.




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

http://www.hoy.com.ec/noticias-ecuador/semaforos-inteligentes-generan-caos-en-cuenca-367319.html

http://www.hoy.com.ec/noticias-ecuador/semaforos-inteligentes-generan-caos-en-cuenca-367319.html

http://www.hoy.com.ec/noticias-ecuador/semaforos-no-tan-inteligentes-108961.html

http://www.hoy.com.ec/noticias-ecuador/semaforos-no-tan-inteligentes-108961.html

http://www.eltiempo.com.ec/noticias-opinion/2363-sema-foros-inteligentes/

http://www.ecured.cu/index.php/Sem%C3%A1foro

http://www.cte.gob.ec/wp-content/uploads/2013/03/Nuevo-Reglamento-a-la-Ley-de-Transporte-Terrestre-Transito-y-Seguridad-Vial.pdf

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.


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.


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


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


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_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 =


byte LEO[3] = 49, 47, 45; // LUCES SEMÁFORO ESTE-OESTE =


byte LOE[3] = 3, 4, 5; // LUCES SEMÁFORO OESTE-ESTE =


/* *******************************************************

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);


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()


byte Color_1 = 0; byte Color_2 = 1;

14

if (Par_Ciclo == 5)

Color_1 = 1;

Color_2 = 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);



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();


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);


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)


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++;


aux[0] = cadena[25];


Tiempo_Espera_Maximo = atoi(aux);

Serial.print("Tiempo_Espera_Maximo: ");

19

Serial.println(Tiempo_Espera_Maximo);




Intentos = atoi(aux);

Serial.print("Intentos: "); Serial.println(Intentos);




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];



void CN1()


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()


BNS[3] = 0;


Contador_Vehículos_Cola[Norte]--;



void SN1() //Agregar contador de vehículos Salida Norte 1


BNS[4] = 0; CVS[0]++; Send_Data_Sensor(2,0); //

Contador_Vehículos_Salida[Norte]++;



23

void SN2() //Agregar contador de vehículos Salida Norte 2


BNS[5] = 0; CVS[0]++; Send_Data_Sensor(2,0); //

Contador_Vehículos_Salida[Norte]++;



/* 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


void ESU2()


BSN[1] = 0; CVE[1]++; CVC[1]++; Send_Data_Sensor(0,1); //

Contador_Vehículos_Entrada[Sur]++; Contador_Vehículos_Cola[Sur];



24

void CSU1()


BSN[2] = 0;


Contador_Vehículos_Cola[Sur]--;



void CSU2()


BSN[3] = 0;


Contador_Vehículos_Cola[Sur]--;



void SSU1() //Agregar contador de vehículos Salida Sur 1


BSN[4] = 0; CVS[1]++; Send_Data_Sensor(2,1); //

Contador_Vehículos_Salida[Sur]++;

25



void SSU2() //Agregar contador de vehículos Salida Sur 2


BSN[5] = 0; CVS[1]++; Send_Data_Sensor(2,1); //

Contador_Vehículos_Salida[Sur]++;



// * 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


void EE2()


BEO[1] = 0; CVE[2]++; CVC[2]++; Send_Data_Sensor(0,2); //

Contador_Vehículos_Entrada[Este]++; Contador_Vehículos_Cola[Este];

26



void CE1()


BEO[2] = 0;


Contador_Vehículos_Cola[Este]--;



void CE2()


BEO[3] = 0;


Contador_Vehículos_Cola[Este]--;



void SE1()

27


BEO[4] = 0; CVS[2]++; Send_Data_Sensor(2,2); //

Contador_Vehículos_Salida[Este]++;



void SE2()


BEO[5] = 0; CVS[2]++; Send_Data_Sensor(2,2); //

Contador_Vehículos_Salida[Este]++;



// * 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


void EO2()

28


BOE[1] = 0; CVE[3]++; CVC[3]++; Send_Data_Sensor(0,3); //

Contador_Vehículos_Entrada[Oeste]++; Contador_Vehículos_Cola[Oeste];



void CO1()


BOE[2] = 0;


Contador_Vehículos_Cola[Oeste]--;



void CO2()


BOE[3] = 0;


Contador_Vehículos_Cola[Oeste]--;

29



void SO1()


BOE[4] = 0; CVS[3]++; Send_Data_Sensor(2,3); //

Contador_Vehículos_Salida[Oeste]++;



void SO2()


BOE[5] = 0; CVS[3]++; Send_Data_Sensor(2,3); //

Contador_Vehículos_Salida[Oeste]++;



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(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[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 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


con.getConnection().prepareStatement("DELETE FROM tbl_usuarios WHERE

Codigo = ?");

POLO.setString(1, C);

POLO.execute();

POLO.close();


public String[] buscarUsuario(String U, String P)


try

int registros = 0;


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();


return datosRegistro;

public Object [][] getDatos()

int registros = 0;

try


con.getConnection().prepareStatement("SELECT count(1) as total FROM

tbl_usuarios ");


res.next();

registros = res.getInt("total");

res.close();


Object[][] data = new String[registros][7];

try


con.getConnection().prepareStatement("SELECT " +

" Codigo, Nombres, Usuario, Clave, FechaRegistro, Tipo, Estado " +

" FROM tbl_usuarios" +

" ORDER BY Codigo ");


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();


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.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);


51


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]);



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"));



break;

case 2:



jLabelSemaforoEO.setIcon(new ImageIcon(usrdir+"/Amarillo.png"));

jLabelSemaforoOE.setIcon(new ImageIcon(usrdir+"/Amarillo.png"));



break;

case 3:



jLabelSemaforoEO.setIcon(new ImageIcon(usrdir+"/Rojo.png"));

jLabelSemaforoOE.setIcon(new ImageIcon(usrdir+"/Rojo.png"));



jLabelEE.setIcon(new ImageIcon(usrdir+"/CarroER.png"));

jLabelEO.setIcon(new ImageIcon(usrdir+"/CarroOR.png"));



break;

56

case 4:

jLabelSemaforoNS.setIcon(new ImageIcon(usrdir+"/Verde.png"));

jLabelSemaforoSN.setIcon(new ImageIcon(usrdir+"/Verde.png"));



jLabelEN.setIcon(new ImageIcon(usrdir+"/CarroNV.png"));

jLabelES.setIcon(new ImageIcon(usrdir+"/CarroSV.png"));





break;

case 5:

jLabelSemaforoNS.setIcon(new ImageIcon(usrdir+"/Amarillo.png"));

jLabelSemaforoSN.setIcon(new ImageIcon(usrdir+"/Amarillo.png"));





break;

case 6:





57







break;

case 9: // Se Apagan los Semáforos





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 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";



//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






//6to Parámetro - Determina el tiempo en segundos del Ciclo 3






//7mo Parámetro - Determina el tiempo en segundos del Ciclo 4






//8vo Parámetro - Determina el tiempo en segundos del Ciclo 5

61






//9no Parámetro - Determina el tiempo en segundos del Ciclo 6






//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





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


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


jLabelSemaforoEO.setIcon(new


jLabelSemaforoOE.setIcon(new


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


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));













72




















73




















74

private void radInteligenteMouseClicked(java.awt.event.MouseEvent evt)

TipoTblFuncionamiento = 0;

private void radManualMouseClicked(java.awt.event.MouseEvent evt)


private void radIntermitenteMouseClicked(java.awt.event.MouseEvent evt)


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--]*"))




txtTiempoEspera.setText(""); txtTiempoEspera.requestFocus();

76

if (txtTiempoEspera.getText().length()>2)

JOptionPane.showMessageDialog(null, "No mas de dos


txtTiempoEspera.setText(txtTiempoEspera.getText().substring(0,2));

private void txtLimiteIntentosKeyReleased(java.awt.event.KeyEvent evt)

if (!txtLimiteIntentos.getText().matches("[0-9--]*"))




txtLimiteIntentos.setText(""); txtLimiteIntentos.requestFocus();

if (txtLimiteIntentos.getText().length()>2)

JOptionPane.showMessageDialog(null, "No mas de dos


txtLimiteIntentos.setText(txtLimiteIntentos.getText().substring(0,2));

private void txtTimeOutsKeyReleased(java.awt.event.KeyEvent evt)

if (!txtTimeOuts.getText().matches("[0-9--]*"))




77

txtTimeOuts.setText(""); txtTimeOuts.requestFocus();

if (txtTimeOuts.getText().length()>4)

JOptionPane.showMessageDialog(null, "No mas de cuatro


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


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();



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);





reportes1.verReportes("General Horas Dia");

reportes2.verReportes("General Dias Semana");

reportes3.verReportes("General Dias Calendario");



ex);

private void btnImprimirUsuarioActionPerformed(java.awt.event.ActionEvent

evt)

Clases.Report reportes = new Clases.Report();

try

reportes.verReportes("Usuarios");



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;


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)


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;


this.dispose();

else

82

if (datosRegistro[1].equals("O")) // Pregunto si el usuario es

Operador

x = 2;


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);

);

prototipo de semáforos inteligentes

Documents