Practica # 1 - Control de Semáforos

ENTREGA FINAL

Objetivo.

Por medio de esta práctica el alumno desarrollará lo mas profundo posible las diferentes soluciones y posibles problemas que se puede encontrar para el problema propuesto. Implementará un sistema que simule un crucero congestionado y éste regule automáticamente la duración del verde de los semáforos de los cruces.

Diseño del Sistema.

Para la siguiente práctica se recomienda que el alumno considere de apoyo los siguientes Temas:

• Sistema de Colas
• Hilos de Ejecución (Threads)
• Programación Modular

En los siguientes diagramas se presenta el escenario con el que se va a trabajar a lo largo de esta práctica. A continuación el Diseño del cruce:

A continuación se presenta la Matriz y el Grafo de Conflictos:

Vector de Características

Diseño de la Solución.

Con lo anterior se puede deducir lo siguiente:

Si se imagina el cómo sería el comportamiento de los automóviles, dependiendo de las luces, es fácil ver que tanto los carros del carril A tanto del B nunca entraría en conflicto, y no harían colisión. Lo mismo ocurre con las filas C y D. Por tanto, no hay ningún problema si la luz está en verde tanto para el carril A como el carril B simultáneamente.

De esta manera, es como se da la sincronización de los semaforos, pues dos de ellos irán siempre encendidos u apagados al mismo tiempo, y los que cambiarán serán los otros dos, que a su vez, estarán sincronizados uno con el otro.

Para la determinación del tiempo de activación de la Luz verde para los cuatro carriles se consideran como carriles principales los carriles A y B; y como carriles secundarios a los carriles C y D. Para la solución de nuestro problema se asignaron valores de tiempo para la activación de la luz verde en los carriles, dependiendo del congestionamiento de autos que se presente.

* Los tiempos reales en la Simulación van a disminuir considerablemente.

Para determinar la solución del congestionamiento en los carriles, se consideró que si se encuentran 10 o mas carros en los carriles principales(A,B) se tomaría como Congestionados CongA = true y CongB = true y si se encontraban 5 automóviles o más en los carriles secundarios(C,D) se tomaría como Congestionados CongC = true y CongD = true.

Una vez teniendo como valores booleanos el Congestionamiento en los carriles se realizó la siguiente tabla de verdad:

Posteriormente se realizó un Mapa de Karnaught para encontrar la ecuación booleana que nos ayude a controlar los semáforos, es decir, que determine qué semáforo es el que tendrá el paso.

Se analizó el Mapa siguiendo la lógica del OR y se obtuvo la siguiente ecuación:

SemAB = (A + B + D')·(A + C' + D')·(A + B + C')·(B + C' + D');

El estado del SemCD se pasaría como el contrario de SemAB, es decir:

SemCD = !SemAB;

A continuación se presentan las partes interesantes del código para comprender mejor la solución del problema. Para ver los códigos completos:

https://gist.github.com/3662916

Código de la clase Sistema.java:

ListaCarros LisCarr = new ListaCarros();

    while(true) {
     if (CarrilA > 10) { CA = true; }
            if (CarrilB > 10) { CB = true; }
     if (CarrilC > 5 ) { CC = true; }
     if (CarrilD > 5 ) { CD = true; }

 SemAB = (CA | CB | !CD ) & (CA | !CC | !CD ) & (CA | CB | !CC) & (CB | !CC | !CD);
 SemCD = !SemAB;

 LisCarr.setEstado(SemAB,SemCD);

            if (SemAB == true) {
  EstadoAB = "Verde";
  EstadoCD = "Rojo";

            } else {
  EstadoAB = "Rojo";
  EstadoCD = "Verde"; 
     } 

 for(int r=0;r<20;r++){System.out.println("\n");}
  System.out.println("\t\t----------------------------------");
  System.out.println("\t\t~Sistema de Control de Semaforos~"); 
  System.out.println("\t\t----------------------------------");
  System.out.println("\n\n\t\t~Congestionamiento~");
  System.out.println("\n\tHay "+CarrilA+" carros en A");
  System.out.println("\n\tHay "+CarrilB+" carros en B");
  System.out.println("\n\tHay "+CarrilC+" carros en C");
  System.out.println("\n\tHay "+CarrilD+" carros en D");

  System.out.println("\n\n\t\t~Estado Semaforos~");
  System.out.println("\n\tA y B -> "+EstadoAB );
  System.out.println("\n\tC y D -> "+EstadoCD );

    Thread.sleep(5000);
    } //Fin del while

Código de la clase ListaCarros.java:

  a = ( ( Rand.nextInt(10000) % 16) + 1);
  CarrilA = CarrilA + a;
  if (CarrilA < 0) { CarrilA = 0; }
  b = ( ( Rand.nextInt(10000) % 16) + 1);
  CarrilB = CarrilB + b;
  if (CarrilB < 0) { CarrilB = 0; }
  c = ( ( Rand.nextInt(10000) % 8) + 1);
  CarrilC = CarrilC + c;
  if (CarrilC < 0) { CarrilC = 0; }
  d = ( ( Rand.nextInt(10000) % 8) + 1);
  CarrilD = CarrilD + d;
  if (CarrilD < 0) { CarrilD = 0; }

 if (aux = true) {

     if (SemAB = true) {

  CarrilA=CarrilA-3;
  CarrilB=CarrilB-2;

     if (CarrilA < 0) { CarrilA = 0; }
     if (CarrilB < 0) { CarrilB = 0; }

  CarrilC=CarrilC+5;
  CarrilD=CarrilD+5;

     } else {

  CarrilC=CarrilC-2;
  CarrilD=CarrilD-2;

     if (CarrilC < 0) { CarrilC = 0; }
     if (CarrilD < 0) { CarrilD = 0; }

  CarrilA=CarrilA+3;
  CarrilB=CarrilB+3; 
     }
 }

Sistema CtrlSem = new Sistema();
CtrlSem.start();
CtrlSem.setCarros(CarrilA,CarrilB,CarrilC,CarrilD);

Video de la Simulación:

Referencias:

http://epere4.blogspot.mx/2008/04/cmo-funciona-synchronized-en-java.html

http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java/Operadores_booleanos