Logistieke Robots/les 5

Les 5 - Robots laten samen werken

In de vorige les heb je een controller gemaakt voor 1 robot om bestellingen te kunnen verzamelen. In deze les leer je om een team van twee robots samen te laten werken om mogelijk sneller de bestellingen te laten verzamelen.

Je kan een team van twee robots op veel verschillende manieren met elkaar samen laten werken. In de praktijk heb je vaak te maken met beperkingen zoals het maximale gewicht wat een robot kan tillen. Wij gaan in onze simulatie uit van de volgende restrictie:

Robots kunnen in één keer meerdere artikelen meenemen uit een kast indien deze artikelen dezelfde zijn. Dit geldt niet voor verschillende artikelen.

Bij een enkele robot kunnen we ons dus voorstellen dat hij eerst de hele bestelling doorneemt om te kijken of er dezelfde artikelen in zitten. Wanneer dit het geval is loopt de robot naar de juiste kast en pakt een pakket waar al twee dezelfde artikelen in zitten. Een efficiëntie verbetering kunnen we vervolgens uitdrukken als het aantal minder gelopen meters.

We implementeren in deze les het volgende scenario: 2 robots werken samen om 2 bestellingen op te halen waarbij de bovengenoemde voorwaarde nog steeds geld en waarbij de robots niet naar dezelfde kasten lopen. We richten ons in deze les vooral op de programmering dan op de visualisatie.

Bijhouden van de gelopen afstand

Voordat we efficiëntie verbeteringen kunnen detecteren, moeten we eerst de huidige situatie kunnen meten. Dit doen we aan de hand van de gelopen afstand in meters van de robot. Hoe je dit doet leer je in deze paragraaf.

Verandering robot controller

Logisch is dat we een extra variabele gaan creëren die de gelopen afstand van de robot opslaat. Minder logisch is dat we ook de 3 verschillende coördinaten bijhouden van de robot. De coördinaten van de x,y en z as kun je ophalen met de functie positon. Waarom dit nodig is zien we zo. De variabelen declareer je op de volgende positie:

def get_order():
    # get articles from central controller
    robot["articles"] = start_sens.bodies[0][1:]
    print(robot["articles"])
    # set game properties
    robot["article_number"] = 1 
    robot["target_desk"] = False 
    robot["robot_id"] = start_sens.bodies[1]
    # distance variables
    robot["distance"] = 0.0
    robot["location1"] = robot.position[0]
    robot["location2"] = robot.position[1]
    robot["location3"] = robot.position[2]

Wanneer de order ingepakt is geef je niet alleen de robot id mee aan de centrale controller maar ook de gelopen afstand. Wanneer de robot een nieuwe order krijgt wordt de afstand namelijk weer op 0 gezet. Hoe de centrale controller omgaat met dit bericht zien we in de volgende paragraaf.

GameLogic.sendMessage("Done", robot["robot_id"] , "Ground", "")
GameLogic.sendMessage("Done", str(robot["distance"]) , "Ground", "")

Het updaten van de gelopen afstand gaat op de volgende manier:

main()
robot["distance"] += robot.getVectTo([robot["location1"], robot["location2"], robot["location3"]])[0]
loc1 = robot.position[0]
loc2 = robot.position[1]
loc3 = robot.position[2]
robot["location1"] = loc1
robot["location2"] = loc2
robot["location3"] = loc3

Iedere keer als je de controller aanroept gebruik je de functie getVectTo() om de afstand te berekenen tussen de locatie waar de robot op dat moment is en de laatst opgeslagen locatie. Vervolgend update je de locatie coördinaten naar degene waar de robot nu staat. Zo kan je de totaal gelopen afstand van de robot bijhouden.

Verandering centrale controller

De robot moet zijn eigen gelopen afstand bij houden maar de centrale controller moet dit voor alle robots doen. Hiervoor is dus ook een variabele nodig:

if sens.positive:
    robot = "11"
    central["distance"] = 0
    Send_order(robot)

De waarde van de variabele wordt aangepast als de centrale controller een message krijgt. De gelopen afstand is het tweede bericht gestuurd door de robot en deze is dus te vinden in message.bodies[1]. Wanneer alle orders zijn vervuld, kun je de totale afstand van de robot printen op de volgende manier:

if message.positive:
    central["boxes_done"] +=1
    print("number of boxes done:")
    print(central["boxes_done"])
    central["distance"] += float(message.bodies[1])
    if central["boxes_done"] < central["boxes_tot"]
        robot = message.bodies[0]
        Send_order(robot)
    else:
        print("Total walked distance:")
        print(central["distance"])

Experiment

Nu kunnen we gaan meten hoe efficiënt de robot is in de huidige situatie. Dit doen we door het huidige algoritme een aantal keer te draaien: we gaan een experiment doen. Meerder runs zijn nodig omdat de bestelling steeds verschilt. Op basis van één run kunnen we niet zeggen hoe het algoritme gemiddeld presteert. Het kan namelijk zo zijn dat je alleen naar de dichtstbijzijnde kast hoeft te lopen. Dit is geen goede representatie van een gemiddelde bestelling. Daarom doen we nu 5 runs.

Hieronder staan de uitkomsten van een experiment:

Run	Afstand
Run 1	615
Run 2	709
Run 3	683
Run 4	698
Run 5	719
Gemiddelde	684,8

Doe zelf ook een experiment met minimaal 5 runs en bekijk of het gemiddelde overeenkomt met de resultaten in bovenstaande tabel. Hoe meer runs je hebt, hoe preciezer je schatting van de prestatie van de robot.

Efficiëntie verbetering voor 1 robot

In het vorige algoritme kon het zo zijn dat de robot 2 keer naar dezelfde kast moest lopen. Het gevolg van de voorwaarde die we in het begin van deze les introduceerden is dat dit niet meer hoeft. We gaan nu zien hoe we dit moeten veranderen en wat het gevolg is op de prestatie.

Verandering centrale controller

We moeten nu gaan bedenken wat de beste manier is om deze opzet te implementeren in het systeem. Logischer is dat de robot de order doorgaat en zoekt naar dubbelen. Maar dit is programmeer technisch gezien meer werk. Daarom laten we de centrale controller kijken of er dubbele in de order zitten. We hoeven dan geen aanpassingen te doen in de robot controller en maar een kleine aanpassing in de centrale controller: