You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
221 lines
9.6 KiB
221 lines
9.6 KiB
<h2>Simulación de una estación de servicio.</h2>
|
|
<h4>Proyecto Integrado. Servicios y procesos. </h4>
|
|
<h4>Natàlia Sepúlveda Ballester</h4>
|
|
|
|
*----------------------------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------------------------------------*
|
|
|
|
<pre>
|
|
|
|
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()
|
|
|
|
</pre>
|
|
|
|
*-------------------------------CAPTURAS DE EJECUCIÓN-----------------------------------*
|
|
|
|
![](image/captura1_enproceso.png)
|
|
|
|
![](image/captura2_procesofinalizado.png)
|
|
|
|
|
|
|
|
|
|
|
|
|