Simulación de una estación de servicio.

Proyecto Integrado. Servicios y procesos.

Natàlia Sepúlveda Ballester

----------------------------EXPLICACIÓN PROGRAMA----------------------------

En este proyecto se pretende simular una estación de servicio. El funcionamiento de este programa consiste en que hay dos surtidores de gasolina, con una cantidad limitada de gasolina, y en donde los coches pueden ir entrando y repostando siempre y cuando haya suficiente gasolina en los surtidores, cuando no, el programa se detendrá.

En este caso, se crean seis coches con una cantidad de depósito que se asigna de manera aleatoria, los depósitos tendrán cantidades entre 10 y 60 litros. Se enviarán a los hilos de los surtidores de manera aleatoria. Y la cantidad inicial de los coches es de 0 litros.

Antes de comenzar el programa, debemos importar las clases threading, random, time y por último turtle, que es la que nos permitirá pintar los coches en un lienzo.

Comenzamos el programa creando la clase EstacióndeServicio, que tiene dos variables de tipo surtidor, cuyas cantidades se asignan en este momento y además instancia un objeto de la clase lock, que utilizaremos en al repostar gasolina para bloquear ese proceso y evitar que otro vehículo entre a repostar.

Esta clase tiene además la función de repostar_gasolina, que recibe el surtidor, el coche y la cantidad que repostará el coche. El funcionamiento es el siguiente:

1. Se activa el Lock.
2. Se comprueba si la gasolina actual del coche es superior a la gasolina que puede albergar el depósito del coche en cuestión y además si es mayor a 0.
3. Se calcula la cantidad real a repostar. Se calcula el mínimo entre la cantidad deseada y la cantidad necesaria para llenar el depósito del coche sin exceder su capacidad máxima.
4. Si la cantidad a repostar es mayor a la cantidad que le queda al surtidor, se puede hacer la acción, se le resta al surtidor la cantidad extraída, devuelve True. Si no se cumple esta contición, devuelve un False.

Después se crea la clase Coche, en ella sólo declaramos las variables que tendrá cada coche al ser creado.

Seguidamente tenemos los métodos de dibujar_coche y dibujar_surtidor. Ambas clases reciben y la variable self, que albergará el objeto que se pinta en ese momento y además las variables x e y, que nos ayudará a pintar los objetos del coche y los propios coches en un lugar determinado del lienzo.

Ahora nos encontramos con la función conductor, que simula la acción de un conductor llevando un coche a repostar a una gasolinera. Este método utiliza los argumentos estación y coche. Además, utiliza un bucle "while" mientras que el método al que se llama "repostar_gasolina" siga devolviendo True, como hemos explicado antes. Al llama a este método, se asigna la cantidad que se quiere repostar, que será un número random entre el 1 y el 20. Después hacemos uso de la clase sleep, que espera un segundo antes de acabar, simulando el repostaje de un vehículo en una gasolinera.

En esta parte restante del código, se crea la instancia de la estación y también se crean los coches con sus características propias, como son la cantidad de sus depósito y el color de su carrocería. Después se almacenan en una array de coches.

Se crean los hilos utilizando la biblioteca threading. Cada hilo ejecuta la función conductor, con los argumentos de estación y de vehículo específico, simulando la acción de un conductor al ir a repostar con su coche a una gasolinera.

Tenemos un print que nos muestra el estado de los depósitos de los coches de manera inicial.

Se inician los hilos utilizando la función start() de threading.

Se inicializan las variables x e y, para posicionar los coches en el lienzo cuando vayamos a pintarlos, y se recorre la lista de los coches llamando el método corresponiente para pintar cada uno de los vehículos en una posición concreta en el lienzo.

Se espera a que los hilos acaben utilizando la funcion join() de threading.

Hacemos lo mismo que hemos hecho con los coches, pero para poder pintar los surtidores. El dibujo habrá finalizado en este momento.

Finalmente, se imprime por pantalla los datos que aún no se habían mostrado, que son la cantidad de los depósitos de cada uno de los vehículos después de repostar y al final del programa, y además el estado de los surtidores, para comprobar que efectivamente están vacíos, que es lo que hace el programa se detenga.

Para acabar el código, se esconde la pluma (tortuga) que pinta y se finaliza.

-----------------------------CODIGO------------------------------------

import threading
import random
import time
import turtle

class EstacionDeServicio:
    def __init__(self):
        self.surtidor1 = 80
        self.surtidor2 = 60
        self.lock = threading.Lock()

    def repostar_gasolina(self, coche, cantidad):
        with self.lock:
            if coche.gasolina_actual < coche.capacidad_deposito and cantidad > 0:
                cantidad_a_repostar = min(cantidad, coche.capacidad_deposito - coche.gasolina_actual)
                if cantidad_a_repostar <= self.surtidor1:
                    coche.gasolina_actual += cantidad_a_repostar
                    self.surtidor1 -= cantidad_a_repostar
                    return True
                elif cantidad_a_repostar <= self.surtidor2:
                    coche.gasolina_actual += cantidad_a_repostar
                    self.surtidor2 -= cantidad_a_repostar
                    return True
            return False

class Coche:
    def __init__(self, nombre, capacidad_deposito, color):
        self.nombre = nombre
        self.capacidad_deposito = capacidad_deposito
        self.gasolina_actual = 0
        self.color = color

    def dibujar_coche(self, x, y):
        turtle.penup()
        turtle.goto(x, y)
        turtle.pendown()
        turtle.color(self.color)
        turtle.begin_fill()
        for _ in range(2):
            turtle.forward(60)
            turtle.right(90)
            turtle.forward(20)
            turtle.right(90)
        turtle.end_fill()

        for i in range(2):
            turtle.penup()
            turtle.goto(x + i * 55, y - 30) 
            turtle.pendown()
            turtle.color("black")
            turtle.begin_fill()
            turtle.circle(10)
            turtle.end_fill()

        turtle.penup()
        turtle.goto(x + 10, y + 20)
        turtle.pendown()
        turtle.color(self.color)
        turtle.begin_fill()
        for _ in range(2):
            turtle.forward(40)
            turtle.right(90)
            turtle.forward(20)
            turtle.right(90)
        turtle.end_fill()

        turtle.penup()
        turtle.goto(x + 30, y + 5)
        turtle.pendown()
        turtle.color("black")
        turtle.write(f"{self.gasolina_actual}L", align="center", font=("Arial", 8, "normal"))

        turtle.penup()
        turtle.goto(x + 30, y + 40)
        turtle.pendown()
        turtle.color("black")
        turtle.write(self.nombre, align="center", font=("Arial", 8, "normal"))

    def dibujar_surtidor_gasolina(self, x, y):

        turtle.penup()
        turtle.goto(x, y)
        turtle.pendown()
        turtle.color("red")
        turtle.begin_fill()
        for _ in range(2):
            turtle.forward(20)
            turtle.right(90)
            turtle.forward(40)
            turtle.right(90)
        turtle.end_fill()

 
        turtle.penup()
        turtle.goto(x + 10, y - 15)
        turtle.pendown()
        turtle.color("black")
        turtle.write(f"{self.gasolina_actual}L", align="center", font=("Arial", 8, "normal"))


        turtle.penup()
        turtle.goto(x + 10, y + 20)
        turtle.pendown()
        turtle.color("black")
        turtle.write("Surtidor", align="center", font=("Arial", 8, "normal"))

def conductor(estacion, coche):
    while estacion.repostar_gasolina(coche, random.randint(1, 20)):
        time.sleep(1)
    print(f"{coche.nombre} ha terminado de repostar. Gasolina actual: {coche.gasolina_actual}")


estacion = EstacionDeServicio()

capacidades_deposito = random.sample(range(10, 61), 6)
colores = ["green", "blue", "orange", "pink", "yellow", "grey"]
coches = [Coche(f"Coche {i + 1}", capacidad, colores[i]) for i, capacidad in enumerate(capacidades_deposito)]
hilos_conductores = [threading.Thread(target=conductor, args=(estacion, coche)) for coche in coches]

print("Estado inicial de los coches:")
for coche in coches:
    print(f"{coche.nombre}: Gasolina actual = {coche.gasolina_actual}/{coche.capacidad_deposito}")

for hilo_conductor in hilos_conductores:
    hilo_conductor.start()


fila1_y = 100
fila2_y = -100
for i, coche in enumerate(coches):
    if i < 3:
        coche.dibujar_coche(-150 + i * 150, fila1_y)
    else:
        coche.dibujar_coche(-150 + (i - 3) * 150, fila2_y)


for hilo_conductor in hilos_conductores:
    hilo_conductor.join()

coche_surtidor1 = Coche("Surtidor 1", 0, "")
coche_surtidor2 = Coche("Surtidor 2", 0, "")
coche_surtidor1.surtidor1 = estacion.surtidor1
coche_surtidor2.surtidor2 = estacion.surtidor2
coche_surtidor1.dibujar_surtidor_gasolina(-75, -30)
coche_surtidor2.dibujar_surtidor_gasolina(75, -30)


print(f"\nEstado final de los surtidores:")
print(f"Surtidor 1: {estacion.surtidor1} litros")
print(f"Surtidor 2: {estacion.surtidor2} litros")

print("\nEstado final de los coches:")
for coche in coches:
    print(f"{coche.nombre}: Gasolina actual = {coche.gasolina_actual}/{coche.capacidad_deposito}")

turtle.hideturtle()

turtle.done()

-------------------------------CAPTURAS DE EJECUCIÓN-----------------------------------

En esta captura vemos la ejecución del programa cuando todavía está activo.

En esta captura vemos el estado final del programa cuando ya ha finalizado.