---
# System prepended metadata

title: Práctica 1 - Autoajuste semáforos

---

# Práctica 1 - Autoajuste semáforos

## Introducción
En esta práctica #1 del Laboratorio de Programación de Sistemas Adaptativos, se trata el tema de autoajuste de parámetros en el cual se realizará una simulación de un cruce de automóviles a través de semáforos de una calle muy congestionada, tiene como objetivo observar cómo se aplican los sistemas adaptativos en ciertos aspectos de la vida diaria, el semáforo dependiendo de la hora en la que más autos circulen, es como se tendrá el tiempo de los semáforos.  

En el transcurso de la actividad observaremos el flujo de vehículos en un cruce de avenidas para desarrollar un sistema adaptativo que simulará el funcionamiento de un semáforo para garantizar un flujo óptimo y mejorar el tránsito en la zona.


## Desarrollo

### Diseño de cruce

![Diseño de cruce](https://hackmd.io/_uploads/S1QXFAha3.png)
![Grafo](https://hackmd.io/_uploads/SJvVKC2ph.png)
![Matriz de Conflictos](https://hackmd.io/_uploads/S1XBFC26h.png)



### Diseño de la solución

Para la solución en nuestro simulador se aprovecha cambiar la variable del tiempo del color verde para que más autos puedan pasar si es que hay demasiados carros en esa calle. Todos tendrán la misma oportunidad de pasar a su destino cuando les toque su turno, en este tipo de simulación estaría muy bien implementarla en la vida diaria ya que en ocasiones hay mucho congestionamiento vial.
En este caso la programación del código se hizo en Python que simula el tráfico en una intersección y regula automáticamente la duración de las luces verdes en los semáforos. El objetivo del código es mejorar el fuljo de tráfico en la intersección y reducir los tiempos de espera de los conductores.
Las restricciones que se tienen son que hay semáforos que no pueden estar en verde al mismo tiempo.

### Solución

Se le asignó aleatoriamente un horario en el cual el semáforo tendrá una duración mayor o menor en verde, amarillo y rojo, dependiendo si es un horario más concurrido por las personas o automóviles y así evitar el tráfico y/o el congestionamiento vehicular, también para que no haya colisiones según las restricciones que son las siguientes:
La matriz de conflictos nos muestra que cuando los carriles B y C están en verde, A y D serán rojos, cuando termine el tiempo del semáforo, A y D se volverán verdes, mientras que C y D se volverán rojos, y así continua cíclicamente, cabe recalcar que los carros que pasan por las calles son aleatorios, en caso de que se acumulen carros en algún carril se les dará acceso para que no congestionen y provoquen tráfico.
Por su parte el diagrama de cruce nos muestra que el carril A circula de oeste a este, mientras que D circula de este a oeste, mientras que los carriles B y C circulan de forma perpendicular, siendo B de sur a norte, mientras que C de norte a sur.


### Codificación

#### Explicación del código Frontend
  
Para la elaboración de nuestro programa con interfaz gráfica de usuario, se seleccionó el módulo turtle de python.  
Se crearon los objetos `GraphicUserInterface` que se encarga de establecer las características de nuestra ventana y arrancar los subprocesos que queremos que se ejecuten simultaneamente; `Car` es una clase que hereda todos los metodos de la clase `Turtle` y que modifica su apariencia para lucir como un auto de manera aleatoria. Para conocer más sobre el modulo turtle de python, se tiene la [documentacion de turtle](https://docs.python.org/3/library/turtle.html), donde se listan los métodos y objetos que se encuentran en la clase. `Semaphore` es una clase definida que también hereda de la clase turtle todos sus métodos y atributos, por lo que podríamos tratarlo como una instancia de Turtle con funcionalidad extra definida de manera personalizada.

##### GraphicUserInterface

```python=60
# Clase que renderiza nuestra interfaz grafica
class GraphicUserInterface():
    def __init__(self):
        # Crea un objeto Screen 
        self.sc = sc = Screen()
        sc.setup(800,700)
        sc.bgpic('sprites/bg.png')
        sc.title("Simulador Semaforos")

        # Desactivamos el renderizado automatico, ya que este tiene un delay
        sc.tracer(0)

        # Registramos las imagenes de nuestros coches como formas 
        for i in range(1, 7):
            for j in range(4): 
                sc.register_shape(f'sprites/coche_{i}{j}.gif')

        # Registramos las imagenes del semaforo
        sc.register_shape('sprites/semaforo_rojo.gif')
        sc.register_shape('sprites/semaforo_verde.gif')
        sc.register_shape('sprites/semaforo_amarillo.gif')

        # Creamos los semaforos
        self.sem0_sprite = Semaforo(0)
        self.sem1_sprite = Semaforo(1)
        self.sem2_sprite = Semaforo(2)
        self.sem3_sprite = Semaforo(3)

        # Proceso encargado de generar los autos
        self.t1 = threading.Thread(target=generate_cars, daemon=True)
        # Proceso encargado de cambiar las luces de los semaforos
        self.t2 = threading.Thread(target=changing_lights, args=[self], daemon=True)
        # Proceso encargado de mover los autos
        self.t3 = threading.Thread(target=move_cars, args=[self], daemon=True)

        # Arrancamos los sub-procesos simultaneos
        self.t1.start()
        self.t2.start()
        self.t3.start()

        # Configuramos para salir del programa con un click en la pantalla
        sc.exitonclick()
```

```python
# Clase que renderiza nuestra interfaz gráfica
class GraphicUserInterface():
    def __init__(self):
```
Aquí se define una clase llamada `GraphicUserInterface`, que se utiliza para crear y controlar la interfaz gráfica de la simulación.

```python
        # Crea un objeto Screen 
        self.sc = sc = Screen()
        sc.setup(800,700)
        sc.bgpic('sprites/bg.png')
        sc.title("Simulador Semaforos")

        # Desactivamos el renderizado automático, ya que este tiene un delay
        sc.tracer(0)
```
Se crea un objeto `Screen` que proporciona un lienzo gráfico para dibujar elementos. Se configura el tamaño de la pantalla a 800x700 píxeles y se establece un fondo utilizando la imagen 'sprites/bg.png'. También se establece el título de la ventana de la simulación. Después, se desactiva el renderizado automático usando `sc.tracer(0)` para evitar un retraso en la actualización de la pantalla.

```python
        # Registramos las imágenes de nuestros coches como formas 
        for i in range(1, 7):
            for j in range(4): 
                sc.register_shape(f'sprites/coche_{i}{j}.gif')

        # Registramos las imágenes del semáforo
        sc.register_shape('sprites/semaforo_rojo.gif')
        sc.register_shape('sprites/semaforo_verde.gif')
        sc.register_shape('sprites/semaforo_amarillo.gif')
```
En este bloque de código, se registran las imágenes de los coches y los semáforos como formas en la pantalla. Las imágenes de los coches están numeradas del 1 al 6 y de 0 a 3 para permitir diferentes variaciones de imágenes de coches y estados del semáforo.

```python
        # Creamos los semáforos
        self.sem0_sprite = Semaforo(0)
        self.sem1_sprite = Semaforo(1)
        self.sem2_sprite = Semaforo(2)
        self.sem3_sprite = Semaforo(3)
```
Se crean instancias de la clase `Semaforo` . Cada instancia representa un semáforo diferente identificado por un número de 0 a 3.

```python
        # Proceso encargado de generar los autos
        self.t1 = threading.Thread(target=generate_cars, daemon=True)
        # Proceso encargado de cambiar las luces de los semáforos
        self.t2 = threading.Thread(target=changing_lights, args=[self], daemon=True)
        # Proceso encargado de mover los autos
        self.t3 = threading.Thread(target=move_cars, args=[self], daemon=True)
```
Se crean tres subprocesos (hilos) utilizando la biblioteca `threading`. Estos subprocesos se encargarán de tareas específicas: generar coches, cambiar las luces del semáforo y mover los coches respectivamente. Cada subproceso se crea utilizando la función `Thread` y se les asignan objetivos (funciones) a ejecutar. El argumento `daemon=True` indica que estos subprocesos son "daemons", lo que significa que se detendrán cuando el programa principal termine.

```python
        # Arrancamos los sub-procesos simultáneos
        self.t1.start()
        self.t2.start()
        self.t3.start()
```
Aquí se inician los tres subprocesos simultáneamente utilizando el método `start()`.

```python
        # Configuramos para salir del programa con un clic en la pantalla
        sc.exitonclick()
```
Finalmente, se configura la función `exitonclick()` de la pantalla para que el programa se cierre cuando el usuario haga clic en cualquier parte de la ventana.

En resumen, este código crea una interfaz gráfica que simula semáforos y coches en Python utilizando la biblioteca Turtle. Los coches se generan, las luces del semáforo cambian y los coches se mueven de manera concurrente a través de subprocesos.

##### Definición de la clase Semaforo

```python=103
# Semaforos (Semaforos del modulo threading )
class Semaforo(Turtle):
    def __init__(self, lane) -> None:
        super().__init__(visible=False)
        self.lane = lane
        self.state = 'rojo'
        data = LANES[lane]
        x = data['sem_x']
        y = data['sem_y']
        self.pu()
        self.shape('sprites/semaforo_rojo.gif')
        self.goto(x, y)
        self.showturtle()
```

Este fragmento de código representa una clase llamada `Semaforo` que hereda de la clase `Turtle` de la biblioteca Turtle en Python. La clase `Semaforo` se utiliza para crear objetos que representan semáforos en la simulación gráfica.

```python
# Semaforos (Semaforos del modulo threading )
class Semaforo(Turtle):
    def __init__(self, lane) -> None:
```

Se define la clase `Semaforo`, que hereda de la clase `Turtle`. Esta clase será utilizada para crear objetos que representan semáforos en la simulación. El método `__init__` es el constructor de la clase y se llama automáticamente cuando se crea una nueva instancia de `Semaforo`. El parámetro `lane` se refiere al carril en el que se coloca el semáforo.

```python
        super().__init__(visible=False)
```

Se llama al constructor de la clase base `Turtle` utilizando la función `super()`, y se establece `visible=False` para que el objeto del semáforo no sea visible al principio.

```python
        self.lane = lane
```

Se asigna el valor del parámetro `lane` a un atributo de instancia llamado `lane`. Esto almacenará la información del carril en el que se encuentra el semáforo.

```python
        self.state = 'rojo'
```

Se inicializa un atributo de instancia llamado `state` con el valor `'rojo'`. Este atributo representará el estado actual del semáforo y se inicia en rojo.

```python
        data = LANES[lane]
```

Se accede al diccionario `LANES` utilizando el valor del parámetro `lane` como clave. Esto parece indicar que hay un diccionario `LANES` definido en otro lugar del código que contiene información sobre las posiciones de los carriles y otros datos relevantes.

```python
        x = data['sem_x']
        y = data['sem_y']
```

Se obtienen las coordenadas `x` e `y` del diccionario `data`, que parecen representar la posición en la que se ubicará el semáforo en la pantalla.

```python
        self.pu()
```

Se utiliza el método `pu()` para "pen up", que es una función de la biblioteca Turtle que levanta el lápiz virtual, evitando que se dibuje mientras el objeto se mueve.

```python
        self.shape('sprites/semaforo_rojo.gif')
```
Se establece la forma (imagen) del semáforo utilizando el método `shape()`. En este caso, se utiliza la imagen 'sprites/semaforo_rojo.gif' para representar el semáforo en su estado inicial de rojo.

```python
        self.goto(x, y)
```
Se mueve el objeto del semáforo a la posición especificada por las coordenadas `x` e `y`.

```python
        self.showturtle()
```
Se utiliza el método `showturtle()` para hacer que el objeto del semáforo sea visible en la pantalla.
##### Definición de la clase Car

```python=118
class Car(Turtle):
    def __init__(self, lane) -> None:
        # Choose a random lane and a random car sprite
        self.currentLine = ''
        self.lane = lane
        self.not_affected_by_sem = False
        car_model_number = random.randint(1, 6)
        data = LANES[self.lane]
        x = data['position_x']
        y = data['position_y']
        angle = data['rotate']
        image_dir = f'sprites/coche_{car_model_number}{self.lane}.gif'
        super().__init__(visible=False)
        self.pu()
        self.shape(image_dir)
        self.goto(x, y)
        self.left(angle)
        self.showturtle()
```

#### Explicación del código Backend

##### Generar autos
El siguiente, es uno  de los threads que se ejecuta simultáneamente junto con changing_lights y move_cars. 
Esta función toma la lista  `all_cars` (variable global), que contiene un arreglo de arreglos, como se muestra a continuación.

```python
# Contiene todos los autos, separados por carril
# carril 0, 1, 2, 3
all_cars = [[], [], [], []]
```

- `options` es una variable que almacena una Lista, la forma en la que esta ha sido creada es usando List comprehension. Los valores que almacena son los indices de los carriles que todavia no se han llenado (el limite de coches por carril es  3) o que tienen un semaforo activo. De esta manera, no generaremos coches en carriles que ya estén llenos, ocasionando un error en nuestor programa.
- Después, si la lista de options NO está vacia, es decir que tenemos opciones, elige un valor aleatorio de esta lista con el método random.choice.
- Posteriormente, se elige si se creará un objeto nuevo o si reciclaremos un objeto ya existente, esto con la finalidad de optimizar el performance de nuestra aplicación, ya que si tenemos muchos objetos creados, podríamos ralentizar la ejecución de la aplicación.
- Una vez creado el objeto, se agrega al final de la lista all_cars en el carril correspondiente
- Esperamos un tiempo aleatorio entre 1, 2 o 3 segundos para volver a generar otro coche con el mismo código, ya que nos encontramos dentro de un bucle while.

```python=241
def generate_cars():
    global all_cars
    while True:
        options = [i for (i, l) in enumerate(all_cars) 
                   if len(l) < 3 or semaphores[i] == 1]
        if options:
            lane = random.choice(options)
            # Si hay objetos reciclables
            if object_pooling:
                # reciclar objeto
                car = recycle_car_obj(object_pooling.pop(), lane)
            else:
                car = Car(lane)
			all_cars[car.lane].append(car)
        # Esperar un tiempo aleatorio de 1, 2 o 3 segundos
        time.sleep(random.randint(1,3))
```

##### Retornar si el auto debe moverse o no

```python=138
def is_not_on_limit(car, lane:list):
    if car.not_affected_by_sem:
        return True
    lane_number = car.lane
    cars_ahead =  len([car for car in all_cars[lane_number] if not car.not_affected_by_sem])

    if lane_number == 0:
        return car.xcor() < LANES[lane_number]['limit'][0] - (95 * cars_ahead)
    elif lane_number == 1:
        return car.xcor() > LANES[lane_number]['limit'][0] + (95 *cars_ahead)
    elif lane_number == 2:
        return car.ycor() > LANES[lane_number]['limit'][1] + (95 *cars_ahead)
    else:
        return car.ycor() < LANES[3]['limit'][1] - (95 * len(lane))

```

##### Mover los autos en pantalla

```python=154
def move_cars(gui):
    while True:
        for lane in all_cars:
            for car in lane:
                condition1 = car.xcor() > 490 or car.xcor() < -490
                condition2 = (car.ycor() > 500 or car.ycor() < -500)
                lane_num = car.lane
                if condition1 or condition2:
                    all_cars[lane_num].remove(car)
                    car.hideturtle()
                    object_pooling.append(car)
                    continue
                is_semaphore_green = semaphores[car.lane] == 1
                cond3 = is_not_on_limit(car, all_cars[lane_num])
                if is_semaphore_green or cond3 or car.not_affected_by_sem:
                    car.forward(20)
                    if not cond3 and semaphores[car.lane] == 1 and not car.not_affected_by_sem:
                        car.not_affected_by_sem = True
        try:
            gui.sc.update()
        except:
            pass
        time.sleep(0.05)
```

##### Cambiar las luces del semaforo (autoajuste)

```python=179
def changing_lights(gui):
    sem0_sprite = gui.sem0_sprite
    sem1_sprite = gui.sem1_sprite
    sem2_sprite = gui.sem2_sprite
    sem3_sprite = gui.sem3_sprite

    global semaphores
    semaphores = random.choice([[0, 0, 1, 1], [1,1,0,0]])

    if semaphores[0] ==1:
        sem0_sprite.shape('sprites/semaforo_verde.gif')
        sem1_sprite.shape('sprites/semaforo_verde.gif')
    else:
        sem2_sprite.shape('sprites/semaforo_verde.gif')
        sem3_sprite.shape('sprites/semaforo_verde.gif')

    while True:
        # Elegir el carril con mayor numero de autos
        longer_lane = max(all_cars, key=len)
        longer_lane_num = all_cars.index(longer_lane)

        # Si el carril no está encendido, cambiar el semaforo
        if semaphores[longer_lane_num] != 1:
            semaphores = [0,0,0,0]
            # Encender el semaforo  
            if longer_lane_num in (0, 1):
                sem2_sprite.shape('sprites/semaforo_amarillo.gif')
                sem3_sprite.shape('sprites/semaforo_amarillo.gif')
                time.sleep(2)
                semaphores = [1, 1, 0, 0]
                sem0_sprite.shape('sprites/semaforo_verde.gif')
                sem1_sprite.shape('sprites/semaforo_verde.gif')
                sem2_sprite.shape('sprites/semaforo_rojo.gif')
                sem3_sprite.shape('sprites/semaforo_rojo.gif')
            else:
                sem0_sprite.shape('sprites/semaforo_amarillo.gif')
                sem1_sprite.shape('sprites/semaforo_amarillo.gif')
                time.sleep(2)
                semaphores = [0, 0, 1, 1]
                sem0_sprite.shape('sprites/semaforo_rojo.gif')
                sem1_sprite.shape('sprites/semaforo_rojo.gif')
                sem2_sprite.shape('sprites/semaforo_verde.gif')
                sem3_sprite.shape('sprites/semaforo_verde.gif')
        time.sleep(3)
```

##### Reciclar los objetos

```python=225
def recycle_car_obj(car:Car, lane):
    car.lane = lane
    car.not_affected_by_sem = False
    car_model_number = random.randint(1, 6)
    data = LANES[lane]
    x = data['position_x']
    y = data['position_y']
    angle = data['rotate']
    image_dir = f'sprites/coche_{car_model_number}{lane}.gif'
    car.shape(image_dir)
    car.goto(x, y)
    car.setheading(angle)
    car.showturtle()
    return car
```


### Video en YouTube

[Enlace al video https://youtu.be/ICfEk_QS7zY](https://youtu.be/ICfEk_QS7zY)

## Conclusiones

**Samuel Luna**
En esta práctica en lo personal pude aprender muchas cosas, pero principalmente puede darme cuenta de que tengo que mejorar algunos puntos de mí como programador en diferentes lenguajes, hubo momentos en los que no entendí bien que era lo que iba a hacer porque para mí era nuevo, así que tuve que investigar en internet como tenía que hacerlo y que comandos utilizar en Python o módulos. De ahí en fuera se me hizo un practica interesante, un poco tediosa pero interesante. También aprendí que dentro de nuestra vida diaria existe el autoajuste de parámetros, esto dependiendo en qué situación nos encontremos y tengamos que modificar nuestro comportamiento o actuar.

**Fátima Sofia**
En mi conclusión el autoajuste de parámetros puede servir para que un dispositivo se adapte a cambios en su entorno, en lo personal desconocíamos por completo de los parámetros, pero con las herramientas proporcionadas en la clase fue suficiente para su entendimiento y realización de esta actividad. En esta actividad como se vio en la práctica de auto ajuste de parámetros es la modificación automática de un parámetro de acuerdo con su entorno, Se utilizo el caso de un semáforo donde su programación de los estados de ajustes de manera autónoma a la variación de tráfico que se tienen en un momento especifico adaptándose a las necesidades.

**Gloria Carolina Sánchez Barbosa**
Los parámetros es una tarea que en lo personal pienso que se utiliza para todo en la vida cotidiana en este caso como lo fue en esta actividad que fue en una simulación de semáforos, pero hay que entender más sobre ellos para poder crear nuevas simulaciones u objetos en la vida diaria. En lo personal desconocía por completo de los parámetros, pero con las herramientas proporcionadas por la maestra fue suficiente para el entendimiento y realización de esta actividad, también me sirvió la información de lo de los grfaos.


**Yazmin Melgoza Zamarripa**
Considero que esto nos dio una introducción a  todo lo que respecta a los autoajustes, mientras que los hilos son procesos que se ejecutan y se pueden interrumpir o detener, Se entendió completamente la función de los hilos, además de cómo funcionan las clases y los métodos, el paso de parámetros y sobre todo la codificación ya que no se había programado algo tan “complejo” hasta este punto para los conocimientos que se tenían anteriormente, aún falta mucho por aprender. Pienso que este es apenas el comienzo de los conceptos básicos de programación ya que es un tema muy amplio, y es el principio de esta materia.


**Nathalia Ramos Garza**
Esta práctica nos sirvió como introducción gracias a las señales de apagado y encendido que las habíamos visto anteriormente en otras materias, programar en un lenguaje orientado a objetos, y la introducción a los parámetros que en este caso fue algo nuevo para mi porque no había programado algo así, me gustó la actividad solo que fue algo difícil al principio porque no sabía cómo hacer la actividad hasta que vimos materiales de referencia que nos ayudaron.



## Referencias

- turtle — Turtle graphics. (2023). Python Documentation. https://docs.python.org/3/library/turtle.html
- threading — Thread-based parallelism. (2023). Python Documentation. https://docs.python.org/3/library/threading.html
- random — Generate pseudo-random numbers. (2023). Python Documentation. https://docs.python.org/3/library/random.html
- Semáforos en Python. (2015, 4 octubre). Computational Development Key.
https://cdklhph.wordpress.com/2015/10/04/semaforos-en-python/
- Vergara, L. A. M. (2023). ¿Cómo hacer optimización de parámetros en Python? Escuela de Datos Vivos
https://blog.escueladedatosvivos.ai/como-hacer-optimizacion-parametros-python/

