1° Entrega - Semáforos

Introducción

En esta practica se creó la simulación de un semáforo adaptativo, con esto se quiere decir que el semáforo funcionará según sea le situación de cada carril y así se puede regular el flujo de vehículos y evitar el congestionamiento en las calles.

Como lenguaje de programación se uso Python.
Otro dato importante que cabe mencionar es que hicimos uso de la librería Pygame, con la cual se hizo la interfaz gráfica.

Pre-diseño de cruce

En esta practica se creó un sistema que simula algunas calles y avenidas (carriles) muy concurridas en nuestra ciudad, el objetivo fue crear unos semáforos que tuvieran su parte adaptativa, pero, ¿Cómo lograr esto? 

La parte adaptativa se basó primordialmente en lo siguiente: Las calles con más congestionamiento tienen mayor prioridad para poder avanzar y se les proporciona una mayor cantidad de tiempo en Verde, pero por lógica, en algún momento se les permite a los vehículos de las otras calles avanzar.

¿Qué nos puede salir mal?

Algunas de lo complicaciones que pueden presentarse son la mala programación de los semáforos, que por error o alguna mala lógica algunos de los carriles que no pudieran estar en Verde al mismo tiempo, lo estén y causen un colapso.

Diseño de la solución

Condiciones de los Semáforos

El sentido A y el sentido B podrán avanzar siempre y cuando los demás sentidos estén deshabilitados.

El sentido A y el sentido D podrán avanzar siempre y cuando los demás sentidos estén deshabilitados.

El sentido B y el sentido E podrán avanzar siempre y cuando los demás sentidos estén deshabilitados.
Se puede ver que el sentido C puede avanzar siempre y cuando los demás sentidos estén deshabilitados, sucede lo mismo en el sentido F.

Código

#! /usr/bin/python

#Librerias
import pygame
import sys
from threading import Thread
import time
import random

#Variables globales
carrilA = 0
carrilB = 0
carrilC = 0
carrilD = 0
carrilE = 0
carrilF = 0
mayor = 0
SCREEN_WIDTH = 700
SCREEN_HEIGHT = 700

#Clase semaforo que contiene la funcion run (hilo)
class semaforo(Thread):
    def __init__ (self):
        Thread.__init__(self)
        
    def run (self):
        #Modificamos las variables globales
        global carrilA
        
        #Random para asignar los autos entrantes
        entrantes = random.randint(0, 10)
        for i in range(entrantes):
            # Random que asigna el carril para cada auto
            nuevo = random.randint(1, 6)
            if nuevo == 1:
                carrilA += 1           
            elif nuevo == 2:
                carrilB += 1          
            elif nuevo == 3:
                carrilC += 1          
            elif nuevo == 4:
                carrilD += 1          
            elif nuevo == 5:
                carrilE += 1
            else:
                carrilF += 1

        # Esto se repite para cada uno de los carriles
        if carrilA > 0:
            y = 405
            x = 180
            for i in range (carrilA):
                screen.blit(carroA, (x, y))
                x -= 50
        
        #Imprimir los valores en la terminal
        lista = [carrilA, carrilB, carrilC, carrilD, carrilE, carrilF]
        mayor = max(lista)
        print "(/*-*)/ <<====CARRILES====>> \(^-^\)"
        print "A      B      C      D      E      F"
        print carrilA,'    ',carrilB,'    ',carrilC,'    ',carrilD,'    ',carrilE,'    ',carrilF

#Funcion principal (main)
if __name__ == '__main__':
    
    pygame.init()
    #Se cargan la pantalla y las imagenes
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("Semaforos :D")
    fondo = pygame.image.load("callefinal2.png")
    carroA = pygame.image.load("carA2.png").convert_alpha()
    SADrojo = pygame.image.load("SADrojo.png").convert_alpha()

    #Bucle infinito
    while True:
        screen.blit(fondo, (0, 0))
        for event in pygame.event.get():
            if event.type ==pygame.QUIT:
                sys.exit()

        screen.blit(SADrojo, (225, 350))
        
        #Se declara la clase semaforo como hilo y se inicia
        hilo = semaforo()
        hilo.start()
        time.sleep(3)
        print        
        pygame.display.flip()

        #Se compara la cantidad de autos en cada carril para eliminarlos 
        #y se agregan las imagenes de los semaforos, igualmente este if 
        #se repite para los demas carriles
        if ((carrilA >= carrilC) and (carrilA >= carrilD) and (carrilA >= carrilE) and (carrilA >= carrilF)) or ((carrilB >= carrilC) and (carrilB >= carrilD) and (carrilB >= carrilE) and (carrilB >= carrilF)):
            print "Semaforos A y B encendidos"
            if (carrilA >= carrilB):
                for i in range (carrilA):
                    if carrilA > 0:
                        carrilA -= 1
                    if carrilB > 0:
                        carrilB -= 1
                   # Aqui se agregan las imagenes de los semaforos
            
            else:         
                for i in range (carrilB):
                    if carrilA > 0:
                        carrilA -= 1
                    if carrilB > 0:
                        carrilB -= 1
            print
            time.sleep(1)
                    

Video

Conclusiones

Una de las experiencias que tuvimos al momento de realizar el código para nuestro semáforo, fue que nos daba el valor mayor de vehículos en cierto carril, pero al momento de desalojar esa cantidad de vehículos, la desalojaba de un carril distinto, nuestro error fue al momento de declarar los “if” ya que poníamos todas las condiciones seguidas "if (carrilA >= carrilC and carrilB and carrilD and carrilE and carrilF)", al momento de ejecutar el programa, se generaban otros valores con esa instrucción, nuestra solución fue hacer comparaciones individuales.

Alguna mejora que podríamos hacer en nuestro proyecto , sería que los carros tuvieran movimiento, ya que en nuestra interfaz gráfica, solo se van agregando o eliminando vehículos, pero no presentan movimiento, aprendimos a analizar el algoritmo que se presentaba, y el auto-ajuste de parámetros que es el tiempo que dura el semáforo, dependiendo de la cantidad de autos que estuvieran en espera, el monitoreo de variables que vendría siendo la cantidad de carros que pasan, y a simular un sistema inteligente.

Referencias

Threads en Python
Más sobre hilos en Python... 
Ejemplo de hilo simple en Python 
Crear ventanas y cargar imagenes