Lab - Gebruikersbijdragen [nl]

Logistieke Robots

2014-12-17T17:23:40Z

Jacqueline: /* Over het project */

{{Zijbalk Logistieke Robots}}

== Over het project==
[[Bestand:stofzuig_robot.png|thumb|240px|right|zie: https://www.youtube.com/watch?v=hKzMWGVi-YM]]

We zien robots steeds meer in ons dagelijkse leven verschijnen, van simpele stofzuigers (zie rechts voor link) tot zelf rijdende auto’s. Deze robots moeten over een passende intelligentie beschikken om hun taak goed uit te kunnen voeren. Robots worden in vele sectoren in het bedrijfsleven gebruikt waaronder de logistieke sector. Een goed voorbeeld hiervan is de Kiva robot. Deze robot helpt werknemers bestellingen in te pakken in een pakhuis (zie rechts voor link).
[[Bestand:Kiva_Robot.jpg|thumb|240px|right|zie: https://www.youtube.com/watch?v=6KRjuuEVEZs]]

In dit project leer je hoe je soortgelijke “brein software” kan ontwikkelen om een groep robots aan te sturen om bestellingen in te pakken in een magazijn.

=== Blender ===

Het softwareprogramma wat ons hierbij zal ondersteunen is Blender. Blender is gratis, opensource en erg snel te installeren op meerdere platforms (Windows, Mac OS X,Linux).

=== Leerdoelen ===

Na het succesvol afronden van dit project kun je:
# overweg met het simulatiepakket Blender in combinatie met Python,
# robot software ontwikkelen voor individuele robots,
# robot software ontwikkelen voor een samenwerkende robots,
# zelf verbeterende robot software ontwikkelen voor een groep samenwerkende robots,
# het experimenteel testen en beoordelen van robot gedrag,
# het koppelen van bovenstaande aan een werkveld, met name Logistiek.

Het project is opgebouwd uit 8 lessen. Iedere les duurt 2-3 uur. Iedere les heeft een verschillend aantal plusopdrachten waar je tussen de lessen door mee aan de slag kunt.
De opdrachtomschrijving is getest op een Mac en Windows. Indien je een ander platform gebruikt, kun je wellicht op problemen stuiten. Het wordt dus aangeraden een Mac of Windows computer te gebruiken maar andere platformen zouden ook mogelijk kunnen zijn

Je kan nu beginnen met Les 1!

== Ontwikkeling ==
Het maken van dit lesmateriaal is mogelijk gemaakt dankzij subsidie van de gemeente Amsterdam. Het project is uitgevoerd aan de Vrije Universiteit Amsterdam, afdeling Computational Intelligence, in samenwerking met ICT in de Wolken Amsterdam.

Voor vragen over de totstandkoming van dit project kunt u terecht bij:

* Jacqueline Heinerman (j.v.heinerman@vu.nl)
* Eelco Dijkstra (eelco@infvo.com)

== Referenties ==
* [[/Bestanden]]

Logistieke Robots

2014-12-17T17:23:30Z

Jacqueline: /* Over het project */

{{Zijbalk Logistieke Robots}}

== Over het project==
[[Bestand:stofzuig_robot.png|thumb|240px|right|zie: https://www.youtube.com/watch?v=hKzMWGVi-YM]]

We zien robots steeds meer in ons dagelijkse leven verschijnen, van simpele stofzuigers (zie rechts voor link) tot zelf rijdende auto’s. Deze robots moeten over een passende intelligentie beschikken om hun taak goed uit te kunnen voeren. Robots worden in vele sectoren in het bedrijfsleven gebruikt waaronder de logistieke sector. Een goed voorbeeld hiervan is de Kiva robot. Deze robot helpt werknemers bestellingen in te pakken in een pakhuis (zie rechts voor link).
[[Bestand:Kiva_Robot.jpg|thumb|240px|right|zie: https://www.youtube.com/watch?v=6KRjuuEVEZs]]

In dit project leer je hoe je soortgelijke “brein software” kan ontwikkelen om een groep robots aan te sturen om bestellingen in te pakken in een magazijn.

TEST

=== Blender ===

Het softwareprogramma wat ons hierbij zal ondersteunen is Blender. Blender is gratis, opensource en erg snel te installeren op meerdere platforms (Windows, Mac OS X,Linux).

=== Leerdoelen ===

Na het succesvol afronden van dit project kun je:
# overweg met het simulatiepakket Blender in combinatie met Python,
# robot software ontwikkelen voor individuele robots,
# robot software ontwikkelen voor een samenwerkende robots,
# zelf verbeterende robot software ontwikkelen voor een groep samenwerkende robots,
# het experimenteel testen en beoordelen van robot gedrag,
# het koppelen van bovenstaande aan een werkveld, met name Logistiek.

Het project is opgebouwd uit 8 lessen. Iedere les duurt 2-3 uur. Iedere les heeft een verschillend aantal plusopdrachten waar je tussen de lessen door mee aan de slag kunt.
De opdrachtomschrijving is getest op een Mac en Windows. Indien je een ander platform gebruikt, kun je wellicht op problemen stuiten. Het wordt dus aangeraden een Mac of Windows computer te gebruiken maar andere platformen zouden ook mogelijk kunnen zijn

Je kan nu beginnen met Les 1!

== Ontwikkeling ==
Het maken van dit lesmateriaal is mogelijk gemaakt dankzij subsidie van de gemeente Amsterdam. Het project is uitgevoerd aan de Vrije Universiteit Amsterdam, afdeling Computational Intelligence, in samenwerking met ICT in de Wolken Amsterdam.

Voor vragen over de totstandkoming van dit project kunt u terecht bij:

* Jacqueline Heinerman (j.v.heinerman@vu.nl)
* Eelco Dijkstra (eelco@infvo.com)

== Referenties ==
* [[/Bestanden]]

Logistieke Robots/les 6

2014-12-17T17:18:52Z

Jacqueline: /* Les 6 - Robots van elkaar laten leren */

{{Zijbalk Logistieke Robots}}

==Les 6 - Robots van elkaar laten leren ==
Voordat we naar les 6 gaan, bespreken we een aantal verbeteringen in de huidige code zodat we er vervolgens makkelijker mee kunnen werken. Deze verandering moet je ook doorvoeren als je door wilt werken met je huidige bestand. Je mag ook les 6 starten met de file [https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/warehouse_team_collission.blend warehouse_team_collission.blend]

==Verbetering code na les 5 ==
We gaan een functie set_articles() maken zodat er een array aangemaakt
wordt met de artikelen.

<syntaxhighlight lang="Python" line>
def get_order():
# get articles from central controller
set_articles()
print(robot["articles"])
# set game properties
robot["article_number"] = 1
robot["target_desk"] = False
# distance variables
robot["distance"] = 0.0
robot["location1"] = robot.position[0]
robot["location2"] = robot.position[1]
robot["location3"] = robot.position[2]
</syntaxhighlight>

Vervang ook de declaratie van robot[“robot_id”] door onderstaande. De central controller hoeft zo niet meer te vertellen om welke robot het gaat.

<syntaxhighlight lang="Python" line>
# get the current controller
cont = bge.logic.getCurrentController()
robot = cont.owner
robot["robot_id"] = robot.name[6:]
</syntaxhighlight>

De functie set_articles() ziet er als volgt uit:

<syntaxhighlight lang="Python" line>
def set_articles():
message = start_sens.bodies[0][1:]
order_length = len(re.findall(r'[^\s ]+', message))
robot["articles"] = [""]*order_length
for i in range(order_length):
robot["articles"][i] = re.findall(r'[^\s ]+', message)[i]
</syntaxhighlight>

De main() functie ziet er nu overzichtelijker uit:

<syntaxhighlight lang="Python" line>
def main():
if robot["target_desk"] == False:
shelf_sens.propName = "Shelf"
if robot["article_number"] <= len(robot["articles"]):
track_act.target = robot["articles"][robot["article_number"]-1]
else:
shelf_sens.propName = "Desk"
track_act.target = "Desk_" + str(robot["robot_id"])
if shelf_sens.positive:
if robot["target_desk"] == True:
robot["article_number"] += 1
if robot["article_number"] == len(robot["articles"]) +1:
cont.deactivate(track_act)
print("done robot "+ str(robot["robot_id"]))
GameLogic.sendMessage("Done", robot["robot_id"] , "Ground", "")
GameLogic.sendMessage("Done", str(robot["distance"]) , "Ground", "")
robot["target_desk"]= not robot["target_desk"]
</syntaxhighlight>

We veranderen ook de physics van de robot zodat de robot niet om kan vallen. Ga op de robot staan en ga in het rechter window naar:

[[Bestand:balk_physics.png]]

Verander dan de form factor in 0.0:

[[Bestand:form_factor.png]]

Doe dit voor beide robots.

==Hervat les 6 - Robots van elkaar laten leren ==
Nu we weten hoe we een team aan kunnen sturen en we weten dat er efficiëntie winst te bepalen viel, willen we dit natuurlijk op grote schaal toepassen. Wanneer we meer teams in gaan zetten lopen we wel tegen het probleem aan dat ze elkaar voor de voeten kunnen lopen. Dit probleem gaan we ontdekken en een manier vinden om dit op te lossen.
We kunnen zo’n “botsingen probleem” op 2 manieren op lossen. We kunnen de robot vertellen wat hij moet doen of we kunnen de robot een manier aangeven waardoor de robot zelf kan leren wat een optimaal ontwijkingsmechanisme is. De robots worden nu zelf lerend. Dit laatste is natuurlijk veel leuker en daarom gaan we dat doen.
Het eindresultaat kun je zien op https://www.youtube.com/watch?v=LwOjSqbDy0g

==Observeren van botsingen==
Open het bestand “warehouse_team_collission.blend” en voeg hier nog twee Morsy robots aan toe op dezelfde manier als in les 5 met de namen Robot_9 en Robot_8.
De centrale controller moet ook veranderd worden omdat we nu twee teams hebben. Doe daarvoor de volgende aanpassingen:

<syntaxhighlight lang="Python" line>
if sens.positive:
robot_team = ["10","11"]
central["active_robots"] = [0,0,0,0,0,0,0,0,0,0,0]
central["distance"] =0
central["time"] = 0.0
Send_order(robot_team)
</syntaxhighlight>

<syntaxhighlight lang="Python" line>
if message.positive:
central["active_robots"][int(message.bodies[0])-1]=0
central["distance"] += float(message.bodies[1])
if central["boxes_done"] < central["boxes_tot"]-1 and central["active_robots"][10-1]+central["active_robots"][11-1]==0:
central["boxes_done"] +=1
print("number of boxes done:")
print(central["boxes_done"])
Send_order(["10","11"])
if central["boxes_done"] < central["boxes_tot"]-1 and central["active_robots"][9-1]+central["active_robots"][8-1]==0:
central["boxes_done"] +=1
print("number of boxes done:")
print(central["boxes_done"])
Send_order(["8","9"])
if sum(central["active_robots"]) == 0:
print("Total walked distance:")
print(central["distance"])
print(central["time"])
</syntaxhighlight>

Wanneer je nu de robots de orders laat verzamelen zie je dat de paden van de robots elkaar kunnen kruizen. Wanneer ze elkaar tegemoet lopen reageren ze niet op elkaar en botsen ze dus tegen elkaar op. Omdat ze allebei naar voren bewegen, komen ze allebei niet voorruit. We kunnen, zoals eerder genoemd, nu twee aanpakken kiezen om hier mee om te gaan:
# We kunnen gedragsregels opstellen voor de robots. De robots weten dat wanneer ze een artikel opgehaald hebben, ze weer terug naar tafel moeten en op deze manier kunnen we ze ook vertellen wat ze moeten doen als ze een andere robot zien. Bijvoorbeeld: doe altijd een stap naar links als je dicht bij een andere robot bent.
# We kunnen de robots ook een methode geven om van elkaar te leren hoe ze om moeten gaan met elkaar. Dit kun je doen als je zelf ook niet precies weet hoe de robots zich moeten gedragen. Deze methode die we hiervoor kunnen gebruiken heet een evolutionair algoritme. Voor een voorbeeld kun je kijken op : https://www.youtube.com/watch?v=AnuLXVp-Zf0. In dit filmpje zie je een e-puck robot aan het leren om obstakels te ontwijken. Dit is ook wat wij willen bereiken.
We kiezen voor algoritme 2 om te laten zien hoe je een robot van slimme kennis voorziet.

== Kunnen reageren op andere robots ==
We gaan er in deze paragraaf voor zorgen dat de robots elkaar kunnen herkennen en op elkaar kunnen reageren. Hiervoor moeten we veranderingen doorvoeren in de opzet van het pakhuis en veranderingen doorvoeren in de controller van de robot.

===Veranderen pakhuis omgeving===
Omdat we de controller van de robot gaan veranderen, mag je robot 9, 10 en 11 weer verwijderen. En de volgende stappen uitvoeren:

'''Stap 1:'''
Voeg aan de robot een string game property toe met de naam “Robot”. Dit is om elkaar te kunnen herkennen met een Radar

'''Stap 2:'''
Zet de Physics Type op Character en vink de box Actor aan:

[[Bestand: balk_actor.png]]

[[Bestand: set_as_actor.png]]

'''Stap 3:'''
Omdat we de robots nu niet meer helemaal kunnen controleren, ze kunnen immers afwijken van de directe route tussen de tafel en de kast, moeten we het pakhuis iets veranderen. Verander de physics van de kasten op de volgende manier:

[[Bestand: change_physics.png]]

Creëer extra wanden door de bestaande wanden te kopiëren, te verplaatsen en om hun as te draaien zodat we er doorheen kunnen blijven kijken. Verwijder Desk 1 t/m Desk 5 en verdeel Desk 6 t/m Desk 11 over de ruimte. De arena ziet er nu als volgt uit, waarbij er bij jou maar 1 robot staat bij Desk 8:

[[Bestand: nieuwe_arena.png]]

===Veranderen robot controller ===
De robots moeten elkaar nu herkennen, hier op reageren en vervolgens weer doorgaan met het ophalen van artikelen. We moeten veel gaan veranderen aan de controller. We nemen dit stap voor stap door:

'''Stap 1:'''
We hebben een extra Radar nodig om een ontwijkactie te starten en we moeten kunnen meten of de robot een goede actie gedaan heeft. Dit doen we met een collission sensor. De always sensor is nodig om de taak weer op te pakken na de ontwijkactie:
[[Bestand: add_radar.png]]

'''Stap 2:'''
De ontwijkactie houdt in dat de robot, na het detecteren van een andere robot, een aantal seconden rondjes draait, weg loopt van de robot en daarna zijn taak weer oppakt. Dit definiëren we in een extra state:
[[Bestand: add_state.png]]

'''Stap 3:'''
Voeg extra game properties toe:
[[Bestand: add_game_property.png]]

'''Stap 4:'''
Het script moet ook onder handen genomen worden. Er moet een extra package geïmporteerd worden omdat we de robot een willekeurige waarde geven voor het draaien om zijn eigen as en het weglopen van de radar locatie:

<syntaxhighlight lang="Python" line>
# import necessary packages
import bge
import GameLogic
import re
import random
</syntaxhighlight>

De extra sensors moeten gedefinieerd worden:

<syntaxhighlight lang="Python" line>
# get sensors and actuators
start_sens = cont.sensors["Start"]
shelf_sens = cont.sensors["Shelf"]
track_act = cont.actuators["TrackTo"]
robot_radar = cont.sensors["RobotRadar"]
robot_collission = cont.sensors["RobotCollission"]
</syntaxhighlight>

Wanneer de robot voor de eerste keer begint met de order, worden de parameters gedefinieerd die te maken hebben met het ontwijken van de andere robot:

<syntaxhighlight lang="Python" line>
if start_sens.positive:
cont.activate(track_act)
print("Start new order:")
get_order()
# set avoidance parameters and evaluation variables
print("begin")
if robot["active"] == False:
robot["sec_rot"] = random.uniform(0,2)
robot["sec_walk"] = random.uniform(0,2)
robot["active"] =True
</syntaxhighlight>

Wanneer een robot iemand op de radar heeft, moet de robot de ontwijkactie uit gaan voeren in de andere state. Ook moet bijgehouden worden of de robot alsnog tegen een ander aan stoot. Wanneer de robot een slechte ontwijkactie heeft en vaak tegen iemand op botst, willen we dat deze robot een nieuwe ontwijkreactie krijgt. Dit noemen we een “reset”. Dit is nodig als de robot ergens vast zit:

<syntaxhighlight lang="Python" line>
if robot_radar.positive == True:
cont.deactivate(track_act)
robot["radar"] +=1
robot["time"] = 0.0
robot.state = 2

if robot_collission.positive:
robot["collission"] +=1

if robot["collission"] >=20:
#reset parameters because its stuck
robot["sec_rot"] = random.uniform(0,2)
robot["sec_walk"] = random.uniform(0,2)
</syntaxhighlight>

In de extra state hebben we gezien dat er nog een “avoiding.py” gemaakt moet worden. Deze ziet er als volgt uit:

<syntaxhighlight lang="Python" line>
# import necessary packages
import bge
import GameLogic
import re

# get the current controller
cont = bge.logic.getCurrentController()
robot = cont.owner
robot["robot_id"] = robot.name[6:]

# get sensors and actuators
rot_act = cont.actuators["Rotate"]
walk_act = cont.actuators["Walk"]
robot_collission2 = cont.sensors["RobotCollission2"]
robot_radar2 = cont.sensors["RobotRadar2"]

robot["time"] += 1/60

if robot["time"] < robot["sec_rot"]:
cont.activate(rot_act)

if robot["time"] > robot["sec_rot"] and robot["time"] < (robot["sec_rot"] + robot["sec_walk"]):
cont.deactivate(rot_act)
cont.activate(walk_act)

if robot["time"] > (robot["sec_rot"] + robot["sec_walk"]):
robot.state =1

if robot_collission2.positive:
robot["collission"] +=1

if robot_radar2.positive:
robot["radar"] +=1
robot["time"] = 0.0
</syntaxhighlight>

Wanneer je de robots nu laat starten met het ophalen van bestellingen, zie je dat ze op elkaar reageren en hun ontwijkactie uitvoeren. De acties die ze uitvoeren zijn hetzelfde maar hoelang ze deze actie uit voeren kan verschillen. Sommige robots zullen beter kunnen ontwijken en sneller door kunnen gaan met hun bestelling dan andere robots. De robots die een goede ontwijkstrategie hebben kunnen hun strategie doorgeven aan de andere robots.

==Optimaliseren van reactie==
Wanneer de robots met hun eigen ontwijkingsstrategie orders gaan verzamelen, zul je verschillen zien in de aanpak. De ene robot draait lang een rondje terwijl de andere robot bijna gelijk weer verder gaat met de bestelling. Je wilt dat de robots van elkaar leren en de beste strategieën nadoen zodat ze totaal zo min mogelijk botsen. Botsen kan er namelijk voor zorgen dat de robot kapot gaat of dat een artikel op de grond valt.
Omdat we 6 robots hebben beginnen we met 6 verschillende strategieën (ieder tweetal met het aantal seconden rondjes draaien en rechtdoor lopen is een strategie). Na een bepaalde tijd moeten we weten hoe goed de strategie van iedere robot is zodat de goede robots dit door kunnen geven aan de andere robots.
Het uitwisselen van deze informatie en het veranderen van de strategie gebeurd in de centrale controller op de volgende manier:

'''Stap 1:'''
Importeer extra package numpy:

<syntaxhighlight lang="Python" line>
# import necessary packages
import bge
import GameLogic
import random
import numpy
</syntaxhighlight>

'''Stap 2:'''
Voeg een extra team toe met robot 6 en 7. Je weet van de vorige les al hoe dit moet.

'''Stap 3:'''
Voeg een extra tijd meting toe om de strategieën te kunnen updaten:
<syntaxhighlight lang="Python" line>
central["time"]+= 1/60
central["time_minute"]+= 1/60
</syntaxhighlight>

'''Stap 4:'''
Per minuut gaan we de strategieën van de robots herzien en veranderen op de volgende manier:
<syntaxhighlight lang="Python" line>
if central["time_minute"] >=60:
central["time_minute"] = 0
robots = ["Robot_6", "Robot_7", "Robot_8", "Robot_9", "Robot_10", "Robot_11"]
result = [[0,0,0,""] for i in range(len(robots))]
alg_result = 0
for i in range(len(robots)):
robot = scene.objects[robots[i]]
result[i][0] = robot["collission"]
result[i][1] = robot["sec_rot"]
result[i][2] = robot["sec_walk"]
result[i][3] = robot
alg_result += robot["collission"]
robot["collission"] = 0
robot["radar"]=0
central["algorithm"].append(alg_result)
# print number of collissions per minute
print(central["algorithm"])
result = sorted(result, key=lambda a_entry: a_entry[0])
print(result)
print("Total walked distance:")
print(central["distance"])
print(central["time"])
# update values
for i in range(len(robots)):
robot = scene.objects[robots[i]]
take_from = random.choice([0,1])
robot["sec_rot"] = max(0,result[take_from][1] + random.gauss(0, 0.1))
robot["sec_walk"] = max(0,result[take_from][2] + random.gauss(0, 0.1))
</syntaxhighlight>

Wat we in deze functie doen is het evalueren van de prestatie van de robots. Met prestatie bedoelen we het aantal keer opbotsen tegen de andere robots. Hoe minder dit gebeurd, hoe beter. Voor iedere robot wordt dit aantal opgeslagen samen met de twee waarden die hiervoor zorgden. Deze prestatie wordt opgeteld bij het algehele resultaat van de groep en de waarden worden weer op 0 gezet voor de volgende minuut.
Vervolgens worden de strategieën van de robots aangepast. We nemen de strategieën van de 2 beste robots, de robots met het minste aantal botsingen, om door te geven aan de anderen. Op deze waarden passen we nog een kleine variatie toe om te kijken of we in de volgende minuut nog een betere strategie tegen gaan komen. Zo kunnen de robots blijven leren.

==Experimenten==
Wanneer je de robots nu aan het werk zet zie je per minuut een update van de prestatie van het algoritme uitgeprint in de Terminal. Het is moeilijk te analyseren of deze methode echt werkt als je alleen naar deze geprinte waarden. Je kan de robots aan het werk zetten en een aantal boxen laten vullen en deze cijfers in de gaten houden maar je kan er pas echt wat over zeggen als je een goed experiment uitvoert. Dit gaan we doen in Les 7.

==Plusopdracht==
Denk alvast na over hoe je kan testen of dit algoritme werkt.

Logistieke Robots/les 6

2014-12-17T17:18:39Z

Jacqueline: /* Les 6 - Robots van elkaar laten leren */

{{Zijbalk Logistieke Robots}}

==Les 6 - Robots van elkaar laten leren ==
Voordat we naar les 6 gaan, bespreken we een aantal verbeteringen in de huidige code zodat we er vervolgens makkelijker mee kunnen werken. Deze verandering moet je ook doorvoeren als je door wilt werken met je huidige bestand. Je mag ook les 6 starten met de file https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/warehouse_team_collission.blend warehouse_team_collission.blend]

==Verbetering code na les 5 ==
We gaan een functie set_articles() maken zodat er een array aangemaakt
wordt met de artikelen.

<syntaxhighlight lang="Python" line>
def get_order():
# get articles from central controller
set_articles()
print(robot["articles"])
# set game properties
robot["article_number"] = 1
robot["target_desk"] = False
# distance variables
robot["distance"] = 0.0
robot["location1"] = robot.position[0]
robot["location2"] = robot.position[1]
robot["location3"] = robot.position[2]
</syntaxhighlight>

Vervang ook de declaratie van robot[“robot_id”] door onderstaande. De central controller hoeft zo niet meer te vertellen om welke robot het gaat.

<syntaxhighlight lang="Python" line>
# get the current controller
cont = bge.logic.getCurrentController()
robot = cont.owner
robot["robot_id"] = robot.name[6:]
</syntaxhighlight>

De functie set_articles() ziet er als volgt uit:

<syntaxhighlight lang="Python" line>
def set_articles():
message = start_sens.bodies[0][1:]
order_length = len(re.findall(r'[^\s ]+', message))
robot["articles"] = [""]*order_length
for i in range(order_length):
robot["articles"][i] = re.findall(r'[^\s ]+', message)[i]
</syntaxhighlight>

De main() functie ziet er nu overzichtelijker uit:

<syntaxhighlight lang="Python" line>
def main():
if robot["target_desk"] == False:
shelf_sens.propName = "Shelf"
if robot["article_number"] <= len(robot["articles"]):
track_act.target = robot["articles"][robot["article_number"]-1]
else:
shelf_sens.propName = "Desk"
track_act.target = "Desk_" + str(robot["robot_id"])
if shelf_sens.positive:
if robot["target_desk"] == True:
robot["article_number"] += 1
if robot["article_number"] == len(robot["articles"]) +1:
cont.deactivate(track_act)
print("done robot "+ str(robot["robot_id"]))
GameLogic.sendMessage("Done", robot["robot_id"] , "Ground", "")
GameLogic.sendMessage("Done", str(robot["distance"]) , "Ground", "")
robot["target_desk"]= not robot["target_desk"]
</syntaxhighlight>

We veranderen ook de physics van de robot zodat de robot niet om kan vallen. Ga op de robot staan en ga in het rechter window naar:

[[Bestand:balk_physics.png]]

Verander dan de form factor in 0.0:

[[Bestand:form_factor.png]]

Doe dit voor beide robots.

==Hervat les 6 - Robots van elkaar laten leren ==
Nu we weten hoe we een team aan kunnen sturen en we weten dat er efficiëntie winst te bepalen viel, willen we dit natuurlijk op grote schaal toepassen. Wanneer we meer teams in gaan zetten lopen we wel tegen het probleem aan dat ze elkaar voor de voeten kunnen lopen. Dit probleem gaan we ontdekken en een manier vinden om dit op te lossen.
We kunnen zo’n “botsingen probleem” op 2 manieren op lossen. We kunnen de robot vertellen wat hij moet doen of we kunnen de robot een manier aangeven waardoor de robot zelf kan leren wat een optimaal ontwijkingsmechanisme is. De robots worden nu zelf lerend. Dit laatste is natuurlijk veel leuker en daarom gaan we dat doen.
Het eindresultaat kun je zien op https://www.youtube.com/watch?v=LwOjSqbDy0g

==Observeren van botsingen==
Open het bestand “warehouse_team_collission.blend” en voeg hier nog twee Morsy robots aan toe op dezelfde manier als in les 5 met de namen Robot_9 en Robot_8.
De centrale controller moet ook veranderd worden omdat we nu twee teams hebben. Doe daarvoor de volgende aanpassingen:

<syntaxhighlight lang="Python" line>
if sens.positive:
robot_team = ["10","11"]
central["active_robots"] = [0,0,0,0,0,0,0,0,0,0,0]
central["distance"] =0
central["time"] = 0.0
Send_order(robot_team)
</syntaxhighlight>

<syntaxhighlight lang="Python" line>
if message.positive:
central["active_robots"][int(message.bodies[0])-1]=0
central["distance"] += float(message.bodies[1])
if central["boxes_done"] < central["boxes_tot"]-1 and central["active_robots"][10-1]+central["active_robots"][11-1]==0:
central["boxes_done"] +=1
print("number of boxes done:")
print(central["boxes_done"])
Send_order(["10","11"])
if central["boxes_done"] < central["boxes_tot"]-1 and central["active_robots"][9-1]+central["active_robots"][8-1]==0:
central["boxes_done"] +=1
print("number of boxes done:")
print(central["boxes_done"])
Send_order(["8","9"])
if sum(central["active_robots"]) == 0:
print("Total walked distance:")
print(central["distance"])
print(central["time"])
</syntaxhighlight>

Wanneer je nu de robots de orders laat verzamelen zie je dat de paden van de robots elkaar kunnen kruizen. Wanneer ze elkaar tegemoet lopen reageren ze niet op elkaar en botsen ze dus tegen elkaar op. Omdat ze allebei naar voren bewegen, komen ze allebei niet voorruit. We kunnen, zoals eerder genoemd, nu twee aanpakken kiezen om hier mee om te gaan:
# We kunnen gedragsregels opstellen voor de robots. De robots weten dat wanneer ze een artikel opgehaald hebben, ze weer terug naar tafel moeten en op deze manier kunnen we ze ook vertellen wat ze moeten doen als ze een andere robot zien. Bijvoorbeeld: doe altijd een stap naar links als je dicht bij een andere robot bent.
# We kunnen de robots ook een methode geven om van elkaar te leren hoe ze om moeten gaan met elkaar. Dit kun je doen als je zelf ook niet precies weet hoe de robots zich moeten gedragen. Deze methode die we hiervoor kunnen gebruiken heet een evolutionair algoritme. Voor een voorbeeld kun je kijken op : https://www.youtube.com/watch?v=AnuLXVp-Zf0. In dit filmpje zie je een e-puck robot aan het leren om obstakels te ontwijken. Dit is ook wat wij willen bereiken.
We kiezen voor algoritme 2 om te laten zien hoe je een robot van slimme kennis voorziet.

== Kunnen reageren op andere robots ==
We gaan er in deze paragraaf voor zorgen dat de robots elkaar kunnen herkennen en op elkaar kunnen reageren. Hiervoor moeten we veranderingen doorvoeren in de opzet van het pakhuis en veranderingen doorvoeren in de controller van de robot.

===Veranderen pakhuis omgeving===
Omdat we de controller van de robot gaan veranderen, mag je robot 9, 10 en 11 weer verwijderen. En de volgende stappen uitvoeren:

'''Stap 1:'''
Voeg aan de robot een string game property toe met de naam “Robot”. Dit is om elkaar te kunnen herkennen met een Radar

'''Stap 2:'''
Zet de Physics Type op Character en vink de box Actor aan:

[[Bestand: balk_actor.png]]

[[Bestand: set_as_actor.png]]

'''Stap 3:'''
Omdat we de robots nu niet meer helemaal kunnen controleren, ze kunnen immers afwijken van de directe route tussen de tafel en de kast, moeten we het pakhuis iets veranderen. Verander de physics van de kasten op de volgende manier:

[[Bestand: change_physics.png]]

Creëer extra wanden door de bestaande wanden te kopiëren, te verplaatsen en om hun as te draaien zodat we er doorheen kunnen blijven kijken. Verwijder Desk 1 t/m Desk 5 en verdeel Desk 6 t/m Desk 11 over de ruimte. De arena ziet er nu als volgt uit, waarbij er bij jou maar 1 robot staat bij Desk 8:

[[Bestand: nieuwe_arena.png]]

===Veranderen robot controller ===
De robots moeten elkaar nu herkennen, hier op reageren en vervolgens weer doorgaan met het ophalen van artikelen. We moeten veel gaan veranderen aan de controller. We nemen dit stap voor stap door:

'''Stap 1:'''
We hebben een extra Radar nodig om een ontwijkactie te starten en we moeten kunnen meten of de robot een goede actie gedaan heeft. Dit doen we met een collission sensor. De always sensor is nodig om de taak weer op te pakken na de ontwijkactie:
[[Bestand: add_radar.png]]

'''Stap 2:'''
De ontwijkactie houdt in dat de robot, na het detecteren van een andere robot, een aantal seconden rondjes draait, weg loopt van de robot en daarna zijn taak weer oppakt. Dit definiëren we in een extra state:
[[Bestand: add_state.png]]

'''Stap 3:'''
Voeg extra game properties toe:
[[Bestand: add_game_property.png]]

'''Stap 4:'''
Het script moet ook onder handen genomen worden. Er moet een extra package geïmporteerd worden omdat we de robot een willekeurige waarde geven voor het draaien om zijn eigen as en het weglopen van de radar locatie:

<syntaxhighlight lang="Python" line>
# import necessary packages
import bge
import GameLogic
import re
import random
</syntaxhighlight>

De extra sensors moeten gedefinieerd worden:

<syntaxhighlight lang="Python" line>
# get sensors and actuators
start_sens = cont.sensors["Start"]
shelf_sens = cont.sensors["Shelf"]
track_act = cont.actuators["TrackTo"]
robot_radar = cont.sensors["RobotRadar"]
robot_collission = cont.sensors["RobotCollission"]
</syntaxhighlight>

Wanneer de robot voor de eerste keer begint met de order, worden de parameters gedefinieerd die te maken hebben met het ontwijken van de andere robot:

<syntaxhighlight lang="Python" line>
if start_sens.positive:
cont.activate(track_act)
print("Start new order:")
get_order()
# set avoidance parameters and evaluation variables
print("begin")
if robot["active"] == False:
robot["sec_rot"] = random.uniform(0,2)
robot["sec_walk"] = random.uniform(0,2)
robot["active"] =True
</syntaxhighlight>

Wanneer een robot iemand op de radar heeft, moet de robot de ontwijkactie uit gaan voeren in de andere state. Ook moet bijgehouden worden of de robot alsnog tegen een ander aan stoot. Wanneer de robot een slechte ontwijkactie heeft en vaak tegen iemand op botst, willen we dat deze robot een nieuwe ontwijkreactie krijgt. Dit noemen we een “reset”. Dit is nodig als de robot ergens vast zit:

<syntaxhighlight lang="Python" line>
if robot_radar.positive == True:
cont.deactivate(track_act)
robot["radar"] +=1
robot["time"] = 0.0
robot.state = 2

if robot_collission.positive:
robot["collission"] +=1

if robot["collission"] >=20:
#reset parameters because its stuck
robot["sec_rot"] = random.uniform(0,2)
robot["sec_walk"] = random.uniform(0,2)
</syntaxhighlight>

In de extra state hebben we gezien dat er nog een “avoiding.py” gemaakt moet worden. Deze ziet er als volgt uit:

<syntaxhighlight lang="Python" line>
# import necessary packages
import bge
import GameLogic
import re

# get the current controller
cont = bge.logic.getCurrentController()
robot = cont.owner
robot["robot_id"] = robot.name[6:]

# get sensors and actuators
rot_act = cont.actuators["Rotate"]
walk_act = cont.actuators["Walk"]
robot_collission2 = cont.sensors["RobotCollission2"]
robot_radar2 = cont.sensors["RobotRadar2"]

robot["time"] += 1/60

if robot["time"] < robot["sec_rot"]:
cont.activate(rot_act)

if robot["time"] > robot["sec_rot"] and robot["time"] < (robot["sec_rot"] + robot["sec_walk"]):
cont.deactivate(rot_act)
cont.activate(walk_act)

if robot["time"] > (robot["sec_rot"] + robot["sec_walk"]):
robot.state =1

if robot_collission2.positive:
robot["collission"] +=1

if robot_radar2.positive:
robot["radar"] +=1
robot["time"] = 0.0
</syntaxhighlight>

Wanneer je de robots nu laat starten met het ophalen van bestellingen, zie je dat ze op elkaar reageren en hun ontwijkactie uitvoeren. De acties die ze uitvoeren zijn hetzelfde maar hoelang ze deze actie uit voeren kan verschillen. Sommige robots zullen beter kunnen ontwijken en sneller door kunnen gaan met hun bestelling dan andere robots. De robots die een goede ontwijkstrategie hebben kunnen hun strategie doorgeven aan de andere robots.

==Optimaliseren van reactie==
Wanneer de robots met hun eigen ontwijkingsstrategie orders gaan verzamelen, zul je verschillen zien in de aanpak. De ene robot draait lang een rondje terwijl de andere robot bijna gelijk weer verder gaat met de bestelling. Je wilt dat de robots van elkaar leren en de beste strategieën nadoen zodat ze totaal zo min mogelijk botsen. Botsen kan er namelijk voor zorgen dat de robot kapot gaat of dat een artikel op de grond valt.
Omdat we 6 robots hebben beginnen we met 6 verschillende strategieën (ieder tweetal met het aantal seconden rondjes draaien en rechtdoor lopen is een strategie). Na een bepaalde tijd moeten we weten hoe goed de strategie van iedere robot is zodat de goede robots dit door kunnen geven aan de andere robots.
Het uitwisselen van deze informatie en het veranderen van de strategie gebeurd in de centrale controller op de volgende manier:

'''Stap 1:'''
Importeer extra package numpy:

<syntaxhighlight lang="Python" line>
# import necessary packages
import bge
import GameLogic
import random
import numpy
</syntaxhighlight>

'''Stap 2:'''
Voeg een extra team toe met robot 6 en 7. Je weet van de vorige les al hoe dit moet.

'''Stap 3:'''
Voeg een extra tijd meting toe om de strategieën te kunnen updaten:
<syntaxhighlight lang="Python" line>
central["time"]+= 1/60
central["time_minute"]+= 1/60
</syntaxhighlight>

'''Stap 4:'''
Per minuut gaan we de strategieën van de robots herzien en veranderen op de volgende manier:
<syntaxhighlight lang="Python" line>
if central["time_minute"] >=60:
central["time_minute"] = 0
robots = ["Robot_6", "Robot_7", "Robot_8", "Robot_9", "Robot_10", "Robot_11"]
result = [[0,0,0,""] for i in range(len(robots))]
alg_result = 0
for i in range(len(robots)):
robot = scene.objects[robots[i]]
result[i][0] = robot["collission"]
result[i][1] = robot["sec_rot"]
result[i][2] = robot["sec_walk"]
result[i][3] = robot
alg_result += robot["collission"]
robot["collission"] = 0
robot["radar"]=0
central["algorithm"].append(alg_result)
# print number of collissions per minute
print(central["algorithm"])
result = sorted(result, key=lambda a_entry: a_entry[0])
print(result)
print("Total walked distance:")
print(central["distance"])
print(central["time"])
# update values
for i in range(len(robots)):
robot = scene.objects[robots[i]]
take_from = random.choice([0,1])
robot["sec_rot"] = max(0,result[take_from][1] + random.gauss(0, 0.1))
robot["sec_walk"] = max(0,result[take_from][2] + random.gauss(0, 0.1))
</syntaxhighlight>

Wat we in deze functie doen is het evalueren van de prestatie van de robots. Met prestatie bedoelen we het aantal keer opbotsen tegen de andere robots. Hoe minder dit gebeurd, hoe beter. Voor iedere robot wordt dit aantal opgeslagen samen met de twee waarden die hiervoor zorgden. Deze prestatie wordt opgeteld bij het algehele resultaat van de groep en de waarden worden weer op 0 gezet voor de volgende minuut.
Vervolgens worden de strategieën van de robots aangepast. We nemen de strategieën van de 2 beste robots, de robots met het minste aantal botsingen, om door te geven aan de anderen. Op deze waarden passen we nog een kleine variatie toe om te kijken of we in de volgende minuut nog een betere strategie tegen gaan komen. Zo kunnen de robots blijven leren.

==Experimenten==
Wanneer je de robots nu aan het werk zet zie je per minuut een update van de prestatie van het algoritme uitgeprint in de Terminal. Het is moeilijk te analyseren of deze methode echt werkt als je alleen naar deze geprinte waarden. Je kan de robots aan het werk zetten en een aantal boxen laten vullen en deze cijfers in de gaten houden maar je kan er pas echt wat over zeggen als je een goed experiment uitvoert. Dit gaan we doen in Les 7.

==Plusopdracht==
Denk alvast na over hoe je kan testen of dit algoritme werkt.

Logistieke Robots/les 5

2014-12-17T17:17:47Z

Jacqueline: /* Bijhouden van de gelopen afstand */

{{Zijbalk Logistieke Robots}}

==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. Je kan verder gaan met je eigen bestand maar je kan ook starten met [https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/warehouse_team.blend warehouse_team.blend]

=== 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:

<syntaxhighlight lang="Python">
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]
</syntaxhighlight>

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.

<syntaxhighlight lang="Python">
GameLogic.sendMessage("Done", robot["robot_id"] , "Ground", "")
GameLogic.sendMessage("Done", str(robot["distance"]) , "Ground", "")
</syntaxhighlight>

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

<syntaxhighlight lang="Python">
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
</syntaxhighlight>

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:

<syntaxhighlight lang="Python">
if sens.positive:
robot = "11"
central["distance"] = 0
Send_order(robot)
</syntaxhighlight>

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:

<syntaxhighlight lang="Python">
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"])
</syntaxhighlight>

=== 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:
{| class="wikitable"
! 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:

<syntaxhighlight lang="Python">
def Send_order(robot_team):
pre_order = [random.choice(box_articles) for t in range(central["box_size"])]
pre_order = list(set(pre_order))
order = ""
for j in range(len(pre_order)):
order += " " + pre_order[j]
GameLogic.sendMessage("Start", order , "Robot_"+robot, "Ground")
GameLogic.sendMessage("Start", robot , "Robot_"+robot, "Ground")
</syntaxhighlight>

Zoals je kunt zien moet je nu gebruik maken van een array voor het aanmaken van de bestelling. Dan kun je namelijk de functie list() en set() gebruiken voor het eruit halen van dubbele artikelen. Aan de robot kunnen we alleen een string meegeven en daarom moeten we de array nog omzetten in een string. De grootte van de order kan nu 1, 2 of nog steeds 3 zijn.

===Experiment ===
De resultaten zijn nu als volgt:
{| class="wikitable"
! Run !! Afstand
|-
|Run 1 || 495
|-
|Run 2 || 592
|-
|Run 3 || 599
|-
|Run 4 || 437
|-
|Run 5|| 648
|-
|Gemiddelde || 554,2
|}

Te zien is dat de gemiddelde afstand van een run naar beneden is gegaan met 130,6 meter.
Als je deze afstand omzet naar de tijd die de robot daardoor sneller is kun je nadenken of je moet investeren in robots die meer artikelen uit een kast kunnen halen. Wanneer de investering namelijk kleiner is dan de opbrengt zal dit voor extra winst zorgen.

==Efficiëntie verbetering door samenwerking==
Dat we een verbetering zouden zien is natuurlijk begrijpelijk omdat de robots ineens meer kunnen tillen. Interessanter is dat we met deze simulatie hebben kunnen zien wat de efficiëntie winst precies zal zijn en of het zin heeft om in deze complexere machines te investeren.

We gaan nu kijken naar de efficiëntie verbetering is door met een team van 2 robots te werken. Naast de vermindering in totaal gelopen meters gaan we nu ook kijken naar de tijd die het kost om de orders in te pakken.

===Creëren team===
De robots gaan nu in tweetallen werken om de artikelen op te halen. Er zijn veel mogelijkheden hoe de robots samen kunnen werken. Verdelen van soorten artikelen, eerstvolgende artikel op de lijst ophalen, eerst de verste artikelen etc. Omdat de robots naast elkaar staan maakt het qua gelopen afstand niet veel uit welke robot welk artikel haalt. Het gaat hier dus vooral om de winst in tijd.
We gaan twee verschillende algoritmen implementeren. Eerst geven we de robots verantwoordelijkheid over de helft van de artikelen en vervolgens kijken we naar een goede verdeling op basis van de binnengekregen order.

Om een team aan het werk te kunnen zetten, moeten we wel een team hebben. Selecteer Robot_11 en kopieer de robot (ctrl+c, ctrl+v voor Windows en cmd+c, cmd+v voor Mac) druk op de toets G en de toets X en sleep robot naar achter. Je hebt nu twee robots:

[[Bestand:2_robots.png]]

Verander de naam van de tweede robot in Robot_10 op de volgende manier:

[[Bestand:rename_robot.png]]

Verwijder de extra python controllers door deze te selecteren en op ‘x’ te drukken. Zorg ervoor dat je alleen de twee onderstaande controllers overhoudt:

[[Bestand:delete_controllers.png]]

Voeg de robot controller toe aan Robot_10:

[[Bestand:change_controller.png]]

===Veranderingen centrale controller===
We nemen de code weer stap voor stap onder handen. Bij het definiëren van de box_articles is het nu handiger als de “Shelf_” er niet voor staat. Waarom zien we zo.
<syntaxhighlight lang="Python">
# define game properties
central["boxes_tot"] = 5
central["box_size"] = 3
box_articles = [1,2,3,4,5,6,7,8]
</syntaxhighlight>

In plaats dat we nu een robot meegeven aan Send_order() geven we een team mee. We moeten nu ook bijhouden of de robots op hun teammaatje aan het wachten zijn voordat een nieuwe order kan gaan starten. Hiervoor maken we een array aan met de waarden 0/1 voor 11 robots. Naast de afstand houden we ook de tijd bij.

<syntaxhighlight lang="Python">
if sens.positive:
robot_team = ["10","11"]
central["active_robots"] = [0,0,0,0,0,0,0,0,0,0,0]
central["distance"] =0
central["time"] = 0.0
Send_order(robot_team)
</syntaxhighlight>

De order wordt nu twee keer zo lang omdat de robots samen werken. We knippen de order op bij artikel 4. Robot 10 gaat dus artikelen 1, 2, 3 en 4 ophalen en Robot 11 de rest:

<syntaxhighlight lang="Python">
def Send_order(robot_team):
pre_order = [random.choice(box_articles) for t in range(len(robot_team)*central["box_size"])]
pre_order = list(set(pre_order))
pre_order.sort()
order = ""
order2= ""

for j in range(len(pre_order)):
if j <= len(pre_order)/2 -1 :
order += " Shelf_" + str(pre_order[j])
else:
order2 += " Shelf_" + str(pre_order[j])
GameLogic.sendMessage("Start", order , "Robot_"+robot_team[0] , "Ground")
GameLogic.sendMessage("Start", robot_team[0] , "Robot_"+robot_team[0] , "Ground")
central["active_robots"][int(robot_team[0])-1]=1
GameLogic.sendMessage("Start", order2 , "Robot_"+robot_team[1] , "Ground")
GameLogic.sendMessage("Start", robot_team[1] , "Robot_"+robot_team[1] , "Ground")
central["active_robots"][int(robot_team[1])-1]=1
</syntaxhighlight>

Wanneer de robot klaar is met zijn deel van de bestelling moet hij wachten op zijn teamgenoot voordat er een nieuwe order kan starten. Dit kan op de volgende manier geprogrammeerd worden:

<syntaxhighlight lang="Python">
if message.positive:
central["active_robots"][int(message.bodies[0])-1]=0
central["distance"] += float(message.bodies[1])
if central["boxes_done"] < central["boxes_tot"]-1 and central["active_robots"][10-1]+central["active_robots"][11-1]==0:
central["boxes_done"] +=1
print("number of boxes done:")
print(central["boxes_done"])
Send_order(["10","11"])
if sum(central["active_robots"]) == 0:
print("Total walked distance:")
print(central["distance"])
print(central["time"])

central["time"]+= 1/60
</syntaxhighlight>

De tijd wordt bijgehouden met central[“time”]. Hiervoor moet je een Always sensor toevoegen met een pulse. Deze geeft 60 keer per seconde een pulse aan de central controller. Door bij iedere pulse 1/60 toe te voegen aan de variabele, kunnen we de tijd bijhouden.

[[Bestand:add_pulse.png]]

In de robot.py kun je print(“done robot 11”) vervangen door onderstaande regel:

<syntaxhighlight lang="Python">
print("done robot "+ str(robot["robot_id"]))
</syntaxhighlight>

===Experiment===
Hieronder staan de resultaten van een experiment.

''Experiment 1''

{| class="wikitable"
! Run !! Afstand !! Tijd
|-
|Run 1 || 929 || 124
|-
|Run 2 || 879 || 134
|-
|Run 3 || 1092 || 154
|-
|Run 4 || 863 || 121
|-
|Run 5|| 805 || 109
|-
|Gemiddelde || 913,6 || 128,4
|}

Als we de gemiddelde afstand willen vergelijken met de afstanden uit de vorige experimenten moeten we dit getal eerst delen door 2 omdat er nu 2 keer zoveel bestellingen gedaan worden. We zien dan weer een verbetering in het totaal gelopen meters. Omdat dit niet erg verassend is gaan we nu kijken naar het tweede algoritme. Hier bekijken we een slimmere aanpak voor het verdelen van de artikelen in de order zodat de robots minder lang op elkaar wachten. We kunnen zo een winst in tijd behalen.

''Experiment 2''

Nu kan het voorkomen dat het aantal op te halen artikelen erg verschillend is doordat de artikelen alleen in kast 1 t/m 4 of 5 t/m 8 staan. Dit willen we gaan verbeteren. Dit kun je op de volgende manier doen: kijk naar het aantal artikelen in de array pre_order en deel dit door 2. Bij een oneven aantal artikelen krijgt Robot 11 het extra artikel. De code ziet er dan als volgt uit:

<syntaxhighlight lang="Python">
def Send_order(robot_team):
pre_order = [random.choice(box_articles) for t in range(len(robot_team)*central["box_size"])]
pre_order = list(set(pre_order))
pre_order.sort()
order = ""
order2= ""

for j in range(len(pre_order)):
if j <= len(pre_order)/2 -1 :
order += " Shelf_" + str(pre_order[j])
else:
order2 += " Shelf_" + str(pre_order[j])
</syntaxhighlight>

De resultaten van het experiment zijn nu:

{| class="wikitable"
! Run !! Afstand !! Tijd
|-
|Run 1 || 950 || 114
|-
|Run 2 || 940 || 111
|-
|Run 3 || 940 || 112
|-
|Run 4 || 993 || 117
|-
|Run 5|| 996 || 116
|-
|Gemiddelde || 963,8 || 114
|}

We zien dat, ondanks de verhoging van het aantal gelopen meters, de totale tijd afgenomen is. Dit is dus een echte verbetering van het algoritme omdat dezelfde opstelling gebruikt wordt maar er slimmer gebruik wordt gemaakt van de robots.

===Plusopdracht===
Bedenk andere manieren om de taken tussen de robots te verdelen om de gelopen afstand of tijd naar beneden te krijgen. Doe hier experimenten mee

Logistieke Robots/Blender installeren

2014-12-17T16:48:58Z

Jacqueline: /* Downloaden en installeren Blender */

== Downloaden en installeren Blender ==

Blender is erg snel te downloaden en installeren aan de hand van het volgende stappenplan:

# Ga naar http://www.blender.org/download/ om de 2.71 versie van Blender te downloaden
# Ga naar de tab overeenkomstig met jouw platform (Windows, Mac of iets anders) [[Bestand:Download-tabel.png|550px|Download-tabel]]
# Klik op ’64 bit’ of ’32 bit’ afhankelijk van jouw processor. Als je niet weet welke processor je hebt kun je onderstaande stappen volgen:
## Windows Druk op de “Start” knop en vervolgens met de rechtermuisknop op “Computer” en erna op “Eigenschappen”. Bij “Systeem” staat het systeemtype weergegeven.
## Mac Druk op “Over deze Mac”, vervolgens op “Meer informatie” en “systeem rapport” en kijk bij de hardware tap naar de Processor Naam. Vergelijk deze naam met onderstaande tabel:
# Wacht tot het downloaden klaar is
# Open het .exe bestand en volg de instructies. Het installeren duurt een aantal minuten
# Open Blender als dit niet automatisch na de installatie gebeurt
# Blender is succesvol geïnstalleerd wanneer je scherm er als volgt uit ziet: [[Bestand:Blender-openingscherm.png|600px|Blender openingscherm]]

Voor hulp zie: https://www.youtube.com/watch?v=7oIdiRAjueM

Logistieke Robots/les 1

2014-12-17T16:48:33Z

Jacqueline: /* Inhoud les 1 */

{{Zijbalk Logistieke Robots}}

== Inhoud les 1 ==

In deze les leer je hoe je voor een robot eenvoudige “brein software” kunt ontwikkelen in Blender. Deze “Brein software” zullen we vanaf nu een controller noemen. Je gaat eerst een controller ontwikkelen die je kunt aansturen via het toetsenbord: https://www.youtube.com/watch?v=Nzy56Jjr_2o.
In latere lessen zul je deze controller verder automatiseren, door middel van een Python-programma, zodat de robot zelfstandig (autonoom) aan de slag kan.

Voordat je hiermee kunnen starten moet je ervoor zorgen dat Blender op je systeem geïnstalleerd is. [[../Blender installeren|Installeren Blender]]

== Werken met Blender ==

Het openen van Blender kan wat overweldigend zijn. Er zijn erg veel knoppen en getallen te zien en dit is nog niet alles. Voor dit project gebruiken we lang niet alle mogelijkheden die Blender heeft. We bespreken daarom ook niet alle knoppen die je nu ziet. Veel van de uitleg in deze paragraaf is overgenomen van http://wiki.blender.org/index.php/Doc:NL/2.6/Manual.

Mocht je geïnteresseerd zijn in alle mogelijkheden van Blender kun je op deze site kijken. Ook zijn er mensen die graag hun creaties in Blender willen delen via het internet. We zullen hier verderop ook gebruik van maken.

=== Blender interface ===

De pop-up is het opstartscherm. Hier kun je recent geopende bestanden zien als je die hebt. Wanneer je een nieuw bestand wilt beginnen klik je ergens buiten het opstartscherm. Nu is de standaard lay-out zichtbaar met een kubus voorzien van assen. De standaard lay-out kan opgedeeld worden in verschillende vensters. Deze vensters, inclusief de meest gebruikte basiselementen, zijn aangegeven in figuur 1.

[[Bestand:Blender-vensters.png|600px|Blender vensters]]

Figuur 1

De vijf vensters in het startscherm zijn:
* Info Window: bovenaan het scherm, bestaande uit alleen een header
* 3D Window: hier kun je de uiteindelijke robots in actie zien
* Timeline Window: deze zullen we in dit project niet gebruiken
* Outliner Window: dit scherm geeft alle gemaakte objecten (inclusief de robots) weer in de omgeving
* Properties Window: hier kun je kenmerken van objecten wijzigen (bijvoorbeeld kleur en naam)
Er zijn meerdere Windows die je kan weergeven in je scherm. Het type venster kun je wijzigen door het Window Type te veranderen, te vinden in de linkerhoek van de headers van de windows.
Voor hulp zie: https://www.youtube.com/watch?v=TLJThln4eOE

De meest gebruikte basiselementen zijn:
* Current Screen Layout: Blender heeft passende startschermen voor verschillende gebruiksdoeleinden. Wij gebruiken Default of Scripting.
* Current Scene: je kunt verschillende 3D windows ontwikkelen. Dit zijn scenes. Wij zullen maar een Scene ontwikkelen
* Current Rendering Engine:
* Toggle Fullscreen: schakel de fullscreen mode aan/uit
* 3D Transform Manipulator: visueel hulpmiddel bij het transformeren van objecten (grab/verplaatsen, roteren en schalen). Dit kan ook met behulp van het toetsenbord (G, R, S)
* 3D cursor: heeft meerdere functies. Nieuwe objecten worden hier bijvoorbeeld geplaats en het geeft aan waar het rotatiepunt zit
* Cube Mesh / Light / Camera: bij het openen van een nieuw bestand in Blender is er standaard Cube Mesh, een Light en een Camera aanwezig
* Selected object: dit veld toont de naam van het huidige geselecteerde object
* 3D Window Header: alle vensters in Blender hebben een header, maar deze zit aan de onderkant. Hij bestaat onder andere uit:
** Viewport shading: hiermee kan het shading type aangegeven worden. Deze functie zal niet aangepast worden tijdens dit project
** Layers: wanneer je vele objecten hebt gecreëerd kan het makkelijk zijn om deze te ordenen in functionele groepen (robots in de ene layer, de omgeving in de andere). Hier zullen we geen gebruik van maken
* Buttons (Properties) Window Header: dit venster toont panels en deze panels zijn gegroepeerd. Om een andere groep te zien kunnen de knoppen in de header aangeklikt worden [[Bestand:venster-knoppen.png|400px|Venster-knoppen]]
* Outliner Window: dit venster laat alle objecten in een scene zien.
* Timeline Window: Dit venster laat een tijdlijn zien die gebruikt kan worden voor karakter animaties. Dit zullen we niet gaan toepassen in dit project
* Window types: zoals eerder gezegd zijn er vele mogelijke vensters. Ieder venster werkt onafhankelijk van de anderen en het is mogelijk om het zelfde type venster meerdere keren open te hebben. We zullen niet alle types gebruiken. Degene die we wel gaan gebruiken, naast de basis schermen, zijn:
** Logic Editor: hiermee kan een controller gemaakt worden
** Text editor: hier schrijven we Python code
** Console: hier kun je de output zien van de Python code.

=== Besturen van het 3D scherm ===

Alle handelingen in Blender kun je doen door te werken met de muis. Voor iedere handeling is er ook een shortcut beschikbaar via het keyboard. Blender maakt gebruik van alle functies op een muis. Om deze reden is het aan te raden dat je een uitgebreide muis gebruikt (met een scrol functie die ingedrukt kan worden) voor de Windows computer. Voor de Mac is de touchpad toereikend. Gedurende dit project zullen we onderstaande codes gebruikten om te refereren naar handelingen met de muis.
* LMB - Linker muisknop
* MMB - Druk op het scroll wiel alsof het een knop is
* RMB - Rechter muisknop
* Wheel - Scrol wiel

De muis gebruik je voornamelijk om de 3D view te besturen
* MMB: hiermee kun je de scene vanuit alle hoeken bekijken
* Wheel: in/uitzoomen
* LMB: vastpakken van een object
* RMB: selecteren van een object

De opdrachten hebben altijd betrekking op het subvenster waar de cursor staat. Je kunt bijvoorbeeld zowel in het 3D View als in het logic control venster in- en uitzoomen.

== Aansturen van Morsy de Robot ==
[[Bestand:Morsy.png|thumb|200px|right|Morsy]]

Nu gaan we echt aan de slag met Blender. We gaan een robot aansturen via het toetsenbord. Voordat we een robot kunnen aansturen moeten we er natuurlijk een hebben.
We gebruiken, om snel aan de slag te kunnen met de controller, een robot die al is ontwikkeld genaamd Morsy. Morsy komt uit de MORSE code, de Modular OpenRobots Simulation Engine. (https://www.openrobots.org/wiki/morse/)
Een plaatje van Morsy zie je hiernaast.

Merk op dat deze logistieke robot geen armen heeft. Het oppakken van objecten om te verplaatsen zal dus meer symbolisch zijn. Het is mogelijk om armen met een animatie toe te voegen om een object op te pakken. Omdat dit niet het doel is van het project zullen we dit niet behandelen.

=== Stap 1 ===
Open [https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/morsy.blend morsy.blend] (je moet deze eerst naar je eigen computer downloaden).
Je ziet dat we te maken hebben met dezelfde basis omgeving maar dat de Cube Mesh vervangen is door de Morsy robot.

=== Stap 2 ===
Verander zonodig het window type van de timeline window (links onder) naar de logic editor (zie hiernaast).

[[Bestand:Selecteer-logic-editor.png|thumb|200px|right|Selecteer Logic Editor]]

=== Stap 3 ===
Maak de ruimte voor de logic editor iets groter en zoom indien nodig in (met de muis/touch pad) zodat de letters leesbaar zijn. Je kunt nu zien dat de logic editor bestaat uit sensoren, controllers en actuatoren. Sensoren zijn gebeurtenissen die Morsy kan waarnemen vanuit de omgeving. De controller bepaalt hoe je op deze gebeurtenis ingaat om zo eventueel een actuator aan te sturen.

=== Stap 4: controller, sturen naar rechts ===
We kunnen nu de controller gaan maken. We willen de robot aansturen met de pijltjes op het toetsenbord. Iedere toets is dan een sensor. Wanneer deze sensor actief is (en dus ingedrukt wordt) moet de robot een bepaalde kant op gaan lopen. We beginnen met naar rechts lopen
Wanneer we de toets → indrukken willen we dat Morsy naar rechts gaat lopen (voor Morsy zelf is dit naar links). In de linker beneden hoek van het 3D scherm zien we de assen waarover de robot kan bewegen. We zien dat we Morsy moeten laten lopen over de –X as om deze naar rechts te laten gaan. Dit gaat als volgt:
* Voor het aanmaken van deze actie moeten we een sensor hebben die detecteert of we de toets → indrukken. Klik op “Add Sensor” en dan op Keyboard.
* Geef de Keyboard de naam “Right” en ga erna in het vakje “Key” staan waardoor je ziet “Press a key” en druk op →
* Ga naar “Add Controller” en voeg een “And” controller toe. Maak een link tussen de sensor en controller door de twee punten met elkaar te verbinden. Het moet er nu als volgt uit zien: [[Bestand:Les1-keyboard-controller.png|700px|Keyboard sensor en controller]] Wanneer we op de → toets drukken geeft dit een positief signaal aan de controller. De controller moet positieve signalen ontvangen van alle sensoren die verbonden zijn met deze controller om zelf een positief signaal door te kunnen geven. Dit is er nu maar 1. Wanneer alleen de toets → ingedrukt wordt geeft de controller dus een positief signaal.
* Nu gaan we de controller verbinden aan een actie: lopen. Ga naar “Add Actuator” en voeg een “Motion” actuator toe. Geef deze ook de naam “Right” en een X loc waarde van -0.3. Druk ook op de L achter deze regel. Dit geeft aan dat we willen bewegen ten opzichte van de assen en niet ten opzichte van de locatie van Morsy zelf. Maak een link tussen de controller en actuator. [[Bestand:Les1-motion-actuator.png|700px|Add motion actuator]]

==== Toevoegen van de vloer ====
Graag willen we nu weten of de robot naar rechts kan lopen. Als we nu in de “play” modus zouden gaan, zou de robot naar beneden vallen omdat we nog geen vloer hebben toegevoegd. Je zet Blender in de “play” modus door met de muis in het 3D view te staan en dan op ‘P’ te drukken. Je komt weer uit deze modus door op ‘Esc’ te drukken.
Voeg een vloer toe door in de header van de 3D view te klikken op “Add”, dan op “Mesh” en dan op “Plane”.

[[Bestand:Les1-add-plane.png|350px|Add plane]]

Verschuif het vierkant onder Morsy door op de assen te klikken en de grond te verschuiven. Druk op “S” en gebruik de “Wheel” om de grond groter te maken.
Verander de kleur van de vloer door in het property venster te gaan naar:

[[Bestand:Les1-plane-newmaterial.png|350px|Add new material]]

en klik op “+ New”. Bij diffuse kun je een kleur uitkiezen.
Als het goed is ziet het 3D window er nu als volgt uit:

[[Bestand:Les1-morsy-floor.png|700px|Morsy op het speelveld]]

Druk nu op “P” en kijk of Morsy naar rechts beweegt bij het indrukken van de pijl naar rechts. Wanneer je dit getest hebt, druk weer op “Esc”. Wanneer Morsy niet naar rechts loopt, moet je stap 4 nogmaals doorlopen om te zien of je alles juist ingevoerd hebt.
* als Morsy naar links loopt, moet je het teken van de X-verplaatsing veranderen (bijv. van 0.2 naar -0.2);
* als Morse te snel of te langzaam loopt, moet je de verplaatsing kleiner of groter maken (bijv. van 0.4 naar 0.2);
* als er helemaal niets gebeurt, moet je controleren of je (i) de juiste toets ingevoerd hebt, in de Keyboard sensor; (ii) of je de verbinding tussen sensor en controller en controller en actuator gemaakt hebt;

=== Stap 5: sturen naar links, achter en voor ===
Zorg ervoor dat Morsy ook naar links, achter en naar voren kan lopen door middel van het toetsenbord.

=== Stap 6: bestand opslaan voor vervolg ===
Sla het bestand op om volgende les mee verder te gaan.

== Plusopdracht ==
Zorg ervoor dat de robot via het toetsenbord:
* Een rondje kan draaien om zijn eigen as met de toets ‘R’.
* Kan springen bij wanneer de Spacebar en toets J ingedrukt zijn.
Voor hulp zie: https://www.youtube.com/watch?v=Lpb8yCNgDQ8

== Referenties ==

* [[../Blender installeren]]
* MORSE code, de Modular OpenRobots Simulation Engine. (https://www.openrobots.org/wiki/morse/)

Logistieke Robots/les 1

2014-12-17T16:48:00Z

Jacqueline: /* Plusopdracht */

{{Zijbalk Logistieke Robots}}

== Inhoud les 1 ==

In deze les leer je hoe je voor een robot eenvoudige “brein software” kunt ontwikkelen in Blender. Deze “Brein software” zullen we vanaf nu een controller noemen. Je gaat eerst een controller ontwikkelen die je kunt aansturen via het toetsenbord.
In latere lessen zul je deze controller verder automatiseren, door middel van een Python-programma, zodat de robot zelfstandig (autonoom) aan de slag kan.

Voordat je hiermee kunnen starten moet je ervoor zorgen dat Blender op je systeem geïnstalleerd is. [[../Blender installeren|Installeren Blender]]

== Werken met Blender ==

Het openen van Blender kan wat overweldigend zijn. Er zijn erg veel knoppen en getallen te zien en dit is nog niet alles. Voor dit project gebruiken we lang niet alle mogelijkheden die Blender heeft. We bespreken daarom ook niet alle knoppen die je nu ziet. Veel van de uitleg in deze paragraaf is overgenomen van http://wiki.blender.org/index.php/Doc:NL/2.6/Manual.

Mocht je geïnteresseerd zijn in alle mogelijkheden van Blender kun je op deze site kijken. Ook zijn er mensen die graag hun creaties in Blender willen delen via het internet. We zullen hier verderop ook gebruik van maken.

=== Blender interface ===

De pop-up is het opstartscherm. Hier kun je recent geopende bestanden zien als je die hebt. Wanneer je een nieuw bestand wilt beginnen klik je ergens buiten het opstartscherm. Nu is de standaard lay-out zichtbaar met een kubus voorzien van assen. De standaard lay-out kan opgedeeld worden in verschillende vensters. Deze vensters, inclusief de meest gebruikte basiselementen, zijn aangegeven in figuur 1.

[[Bestand:Blender-vensters.png|600px|Blender vensters]]

Figuur 1

De vijf vensters in het startscherm zijn:
* Info Window: bovenaan het scherm, bestaande uit alleen een header
* 3D Window: hier kun je de uiteindelijke robots in actie zien
* Timeline Window: deze zullen we in dit project niet gebruiken
* Outliner Window: dit scherm geeft alle gemaakte objecten (inclusief de robots) weer in de omgeving
* Properties Window: hier kun je kenmerken van objecten wijzigen (bijvoorbeeld kleur en naam)
Er zijn meerdere Windows die je kan weergeven in je scherm. Het type venster kun je wijzigen door het Window Type te veranderen, te vinden in de linkerhoek van de headers van de windows.
Voor hulp zie: https://www.youtube.com/watch?v=TLJThln4eOE

De meest gebruikte basiselementen zijn:
* Current Screen Layout: Blender heeft passende startschermen voor verschillende gebruiksdoeleinden. Wij gebruiken Default of Scripting.
* Current Scene: je kunt verschillende 3D windows ontwikkelen. Dit zijn scenes. Wij zullen maar een Scene ontwikkelen
* Current Rendering Engine:
* Toggle Fullscreen: schakel de fullscreen mode aan/uit
* 3D Transform Manipulator: visueel hulpmiddel bij het transformeren van objecten (grab/verplaatsen, roteren en schalen). Dit kan ook met behulp van het toetsenbord (G, R, S)
* 3D cursor: heeft meerdere functies. Nieuwe objecten worden hier bijvoorbeeld geplaats en het geeft aan waar het rotatiepunt zit
* Cube Mesh / Light / Camera: bij het openen van een nieuw bestand in Blender is er standaard Cube Mesh, een Light en een Camera aanwezig
* Selected object: dit veld toont de naam van het huidige geselecteerde object
* 3D Window Header: alle vensters in Blender hebben een header, maar deze zit aan de onderkant. Hij bestaat onder andere uit:
** Viewport shading: hiermee kan het shading type aangegeven worden. Deze functie zal niet aangepast worden tijdens dit project
** Layers: wanneer je vele objecten hebt gecreëerd kan het makkelijk zijn om deze te ordenen in functionele groepen (robots in de ene layer, de omgeving in de andere). Hier zullen we geen gebruik van maken
* Buttons (Properties) Window Header: dit venster toont panels en deze panels zijn gegroepeerd. Om een andere groep te zien kunnen de knoppen in de header aangeklikt worden [[Bestand:venster-knoppen.png|400px|Venster-knoppen]]
* Outliner Window: dit venster laat alle objecten in een scene zien.
* Timeline Window: Dit venster laat een tijdlijn zien die gebruikt kan worden voor karakter animaties. Dit zullen we niet gaan toepassen in dit project
* Window types: zoals eerder gezegd zijn er vele mogelijke vensters. Ieder venster werkt onafhankelijk van de anderen en het is mogelijk om het zelfde type venster meerdere keren open te hebben. We zullen niet alle types gebruiken. Degene die we wel gaan gebruiken, naast de basis schermen, zijn:
** Logic Editor: hiermee kan een controller gemaakt worden
** Text editor: hier schrijven we Python code
** Console: hier kun je de output zien van de Python code.

=== Besturen van het 3D scherm ===

Alle handelingen in Blender kun je doen door te werken met de muis. Voor iedere handeling is er ook een shortcut beschikbaar via het keyboard. Blender maakt gebruik van alle functies op een muis. Om deze reden is het aan te raden dat je een uitgebreide muis gebruikt (met een scrol functie die ingedrukt kan worden) voor de Windows computer. Voor de Mac is de touchpad toereikend. Gedurende dit project zullen we onderstaande codes gebruikten om te refereren naar handelingen met de muis.
* LMB - Linker muisknop
* MMB - Druk op het scroll wiel alsof het een knop is
* RMB - Rechter muisknop
* Wheel - Scrol wiel

De muis gebruik je voornamelijk om de 3D view te besturen
* MMB: hiermee kun je de scene vanuit alle hoeken bekijken
* Wheel: in/uitzoomen
* LMB: vastpakken van een object
* RMB: selecteren van een object

De opdrachten hebben altijd betrekking op het subvenster waar de cursor staat. Je kunt bijvoorbeeld zowel in het 3D View als in het logic control venster in- en uitzoomen.

== Aansturen van Morsy de Robot ==
[[Bestand:Morsy.png|thumb|200px|right|Morsy]]

Nu gaan we echt aan de slag met Blender. We gaan een robot aansturen via het toetsenbord. Voordat we een robot kunnen aansturen moeten we er natuurlijk een hebben.
We gebruiken, om snel aan de slag te kunnen met de controller, een robot die al is ontwikkeld genaamd Morsy. Morsy komt uit de MORSE code, de Modular OpenRobots Simulation Engine. (https://www.openrobots.org/wiki/morse/)
Een plaatje van Morsy zie je hiernaast.

Merk op dat deze logistieke robot geen armen heeft. Het oppakken van objecten om te verplaatsen zal dus meer symbolisch zijn. Het is mogelijk om armen met een animatie toe te voegen om een object op te pakken. Omdat dit niet het doel is van het project zullen we dit niet behandelen.

=== Stap 1 ===
Open [https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/morsy.blend morsy.blend] (je moet deze eerst naar je eigen computer downloaden).
Je ziet dat we te maken hebben met dezelfde basis omgeving maar dat de Cube Mesh vervangen is door de Morsy robot.

=== Stap 2 ===
Verander zonodig het window type van de timeline window (links onder) naar de logic editor (zie hiernaast).

[[Bestand:Selecteer-logic-editor.png|thumb|200px|right|Selecteer Logic Editor]]

=== Stap 3 ===
Maak de ruimte voor de logic editor iets groter en zoom indien nodig in (met de muis/touch pad) zodat de letters leesbaar zijn. Je kunt nu zien dat de logic editor bestaat uit sensoren, controllers en actuatoren. Sensoren zijn gebeurtenissen die Morsy kan waarnemen vanuit de omgeving. De controller bepaalt hoe je op deze gebeurtenis ingaat om zo eventueel een actuator aan te sturen.

=== Stap 4: controller, sturen naar rechts ===
We kunnen nu de controller gaan maken. We willen de robot aansturen met de pijltjes op het toetsenbord. Iedere toets is dan een sensor. Wanneer deze sensor actief is (en dus ingedrukt wordt) moet de robot een bepaalde kant op gaan lopen. We beginnen met naar rechts lopen
Wanneer we de toets → indrukken willen we dat Morsy naar rechts gaat lopen (voor Morsy zelf is dit naar links). In de linker beneden hoek van het 3D scherm zien we de assen waarover de robot kan bewegen. We zien dat we Morsy moeten laten lopen over de –X as om deze naar rechts te laten gaan. Dit gaat als volgt:
* Voor het aanmaken van deze actie moeten we een sensor hebben die detecteert of we de toets → indrukken. Klik op “Add Sensor” en dan op Keyboard.
* Geef de Keyboard de naam “Right” en ga erna in het vakje “Key” staan waardoor je ziet “Press a key” en druk op →
* Ga naar “Add Controller” en voeg een “And” controller toe. Maak een link tussen de sensor en controller door de twee punten met elkaar te verbinden. Het moet er nu als volgt uit zien: [[Bestand:Les1-keyboard-controller.png|700px|Keyboard sensor en controller]] Wanneer we op de → toets drukken geeft dit een positief signaal aan de controller. De controller moet positieve signalen ontvangen van alle sensoren die verbonden zijn met deze controller om zelf een positief signaal door te kunnen geven. Dit is er nu maar 1. Wanneer alleen de toets → ingedrukt wordt geeft de controller dus een positief signaal.
* Nu gaan we de controller verbinden aan een actie: lopen. Ga naar “Add Actuator” en voeg een “Motion” actuator toe. Geef deze ook de naam “Right” en een X loc waarde van -0.3. Druk ook op de L achter deze regel. Dit geeft aan dat we willen bewegen ten opzichte van de assen en niet ten opzichte van de locatie van Morsy zelf. Maak een link tussen de controller en actuator. [[Bestand:Les1-motion-actuator.png|700px|Add motion actuator]]

==== Toevoegen van de vloer ====
Graag willen we nu weten of de robot naar rechts kan lopen. Als we nu in de “play” modus zouden gaan, zou de robot naar beneden vallen omdat we nog geen vloer hebben toegevoegd. Je zet Blender in de “play” modus door met de muis in het 3D view te staan en dan op ‘P’ te drukken. Je komt weer uit deze modus door op ‘Esc’ te drukken.
Voeg een vloer toe door in de header van de 3D view te klikken op “Add”, dan op “Mesh” en dan op “Plane”.

[[Bestand:Les1-add-plane.png|350px|Add plane]]

Verschuif het vierkant onder Morsy door op de assen te klikken en de grond te verschuiven. Druk op “S” en gebruik de “Wheel” om de grond groter te maken.
Verander de kleur van de vloer door in het property venster te gaan naar:

[[Bestand:Les1-plane-newmaterial.png|350px|Add new material]]

en klik op “+ New”. Bij diffuse kun je een kleur uitkiezen.
Als het goed is ziet het 3D window er nu als volgt uit:

[[Bestand:Les1-morsy-floor.png|700px|Morsy op het speelveld]]

Druk nu op “P” en kijk of Morsy naar rechts beweegt bij het indrukken van de pijl naar rechts. Wanneer je dit getest hebt, druk weer op “Esc”. Wanneer Morsy niet naar rechts loopt, moet je stap 4 nogmaals doorlopen om te zien of je alles juist ingevoerd hebt.
* als Morsy naar links loopt, moet je het teken van de X-verplaatsing veranderen (bijv. van 0.2 naar -0.2);
* als Morse te snel of te langzaam loopt, moet je de verplaatsing kleiner of groter maken (bijv. van 0.4 naar 0.2);
* als er helemaal niets gebeurt, moet je controleren of je (i) de juiste toets ingevoerd hebt, in de Keyboard sensor; (ii) of je de verbinding tussen sensor en controller en controller en actuator gemaakt hebt;

=== Stap 5: sturen naar links, achter en voor ===
Zorg ervoor dat Morsy ook naar links, achter en naar voren kan lopen door middel van het toetsenbord.

=== Stap 6: bestand opslaan voor vervolg ===
Sla het bestand op om volgende les mee verder te gaan.

== Plusopdracht ==
Zorg ervoor dat de robot via het toetsenbord:
* Een rondje kan draaien om zijn eigen as met de toets ‘R’.
* Kan springen bij wanneer de Spacebar en toets J ingedrukt zijn.
Voor hulp zie: https://www.youtube.com/watch?v=Lpb8yCNgDQ8

== Referenties ==

* [[../Blender installeren]]
* MORSE code, de Modular OpenRobots Simulation Engine. (https://www.openrobots.org/wiki/morse/)

Logistieke Robots/les 1

2014-12-17T16:47:45Z

Jacqueline: /* Plusopdracht */

{{Zijbalk Logistieke Robots}}

== Inhoud les 1 ==

In deze les leer je hoe je voor een robot eenvoudige “brein software” kunt ontwikkelen in Blender. Deze “Brein software” zullen we vanaf nu een controller noemen. Je gaat eerst een controller ontwikkelen die je kunt aansturen via het toetsenbord.
In latere lessen zul je deze controller verder automatiseren, door middel van een Python-programma, zodat de robot zelfstandig (autonoom) aan de slag kan.

Voordat je hiermee kunnen starten moet je ervoor zorgen dat Blender op je systeem geïnstalleerd is. [[../Blender installeren|Installeren Blender]]

== Werken met Blender ==

Het openen van Blender kan wat overweldigend zijn. Er zijn erg veel knoppen en getallen te zien en dit is nog niet alles. Voor dit project gebruiken we lang niet alle mogelijkheden die Blender heeft. We bespreken daarom ook niet alle knoppen die je nu ziet. Veel van de uitleg in deze paragraaf is overgenomen van http://wiki.blender.org/index.php/Doc:NL/2.6/Manual.

Mocht je geïnteresseerd zijn in alle mogelijkheden van Blender kun je op deze site kijken. Ook zijn er mensen die graag hun creaties in Blender willen delen via het internet. We zullen hier verderop ook gebruik van maken.

=== Blender interface ===

De pop-up is het opstartscherm. Hier kun je recent geopende bestanden zien als je die hebt. Wanneer je een nieuw bestand wilt beginnen klik je ergens buiten het opstartscherm. Nu is de standaard lay-out zichtbaar met een kubus voorzien van assen. De standaard lay-out kan opgedeeld worden in verschillende vensters. Deze vensters, inclusief de meest gebruikte basiselementen, zijn aangegeven in figuur 1.

[[Bestand:Blender-vensters.png|600px|Blender vensters]]

Figuur 1

De vijf vensters in het startscherm zijn:
* Info Window: bovenaan het scherm, bestaande uit alleen een header
* 3D Window: hier kun je de uiteindelijke robots in actie zien
* Timeline Window: deze zullen we in dit project niet gebruiken
* Outliner Window: dit scherm geeft alle gemaakte objecten (inclusief de robots) weer in de omgeving
* Properties Window: hier kun je kenmerken van objecten wijzigen (bijvoorbeeld kleur en naam)
Er zijn meerdere Windows die je kan weergeven in je scherm. Het type venster kun je wijzigen door het Window Type te veranderen, te vinden in de linkerhoek van de headers van de windows.
Voor hulp zie: https://www.youtube.com/watch?v=TLJThln4eOE

De meest gebruikte basiselementen zijn:
* Current Screen Layout: Blender heeft passende startschermen voor verschillende gebruiksdoeleinden. Wij gebruiken Default of Scripting.
* Current Scene: je kunt verschillende 3D windows ontwikkelen. Dit zijn scenes. Wij zullen maar een Scene ontwikkelen
* Current Rendering Engine:
* Toggle Fullscreen: schakel de fullscreen mode aan/uit
* 3D Transform Manipulator: visueel hulpmiddel bij het transformeren van objecten (grab/verplaatsen, roteren en schalen). Dit kan ook met behulp van het toetsenbord (G, R, S)
* 3D cursor: heeft meerdere functies. Nieuwe objecten worden hier bijvoorbeeld geplaats en het geeft aan waar het rotatiepunt zit
* Cube Mesh / Light / Camera: bij het openen van een nieuw bestand in Blender is er standaard Cube Mesh, een Light en een Camera aanwezig
* Selected object: dit veld toont de naam van het huidige geselecteerde object
* 3D Window Header: alle vensters in Blender hebben een header, maar deze zit aan de onderkant. Hij bestaat onder andere uit:
** Viewport shading: hiermee kan het shading type aangegeven worden. Deze functie zal niet aangepast worden tijdens dit project
** Layers: wanneer je vele objecten hebt gecreëerd kan het makkelijk zijn om deze te ordenen in functionele groepen (robots in de ene layer, de omgeving in de andere). Hier zullen we geen gebruik van maken
* Buttons (Properties) Window Header: dit venster toont panels en deze panels zijn gegroepeerd. Om een andere groep te zien kunnen de knoppen in de header aangeklikt worden [[Bestand:venster-knoppen.png|400px|Venster-knoppen]]
* Outliner Window: dit venster laat alle objecten in een scene zien.
* Timeline Window: Dit venster laat een tijdlijn zien die gebruikt kan worden voor karakter animaties. Dit zullen we niet gaan toepassen in dit project
* Window types: zoals eerder gezegd zijn er vele mogelijke vensters. Ieder venster werkt onafhankelijk van de anderen en het is mogelijk om het zelfde type venster meerdere keren open te hebben. We zullen niet alle types gebruiken. Degene die we wel gaan gebruiken, naast de basis schermen, zijn:
** Logic Editor: hiermee kan een controller gemaakt worden
** Text editor: hier schrijven we Python code
** Console: hier kun je de output zien van de Python code.

=== Besturen van het 3D scherm ===

Alle handelingen in Blender kun je doen door te werken met de muis. Voor iedere handeling is er ook een shortcut beschikbaar via het keyboard. Blender maakt gebruik van alle functies op een muis. Om deze reden is het aan te raden dat je een uitgebreide muis gebruikt (met een scrol functie die ingedrukt kan worden) voor de Windows computer. Voor de Mac is de touchpad toereikend. Gedurende dit project zullen we onderstaande codes gebruikten om te refereren naar handelingen met de muis.
* LMB - Linker muisknop
* MMB - Druk op het scroll wiel alsof het een knop is
* RMB - Rechter muisknop
* Wheel - Scrol wiel

De muis gebruik je voornamelijk om de 3D view te besturen
* MMB: hiermee kun je de scene vanuit alle hoeken bekijken
* Wheel: in/uitzoomen
* LMB: vastpakken van een object
* RMB: selecteren van een object

De opdrachten hebben altijd betrekking op het subvenster waar de cursor staat. Je kunt bijvoorbeeld zowel in het 3D View als in het logic control venster in- en uitzoomen.

== Aansturen van Morsy de Robot ==
[[Bestand:Morsy.png|thumb|200px|right|Morsy]]

Nu gaan we echt aan de slag met Blender. We gaan een robot aansturen via het toetsenbord. Voordat we een robot kunnen aansturen moeten we er natuurlijk een hebben.
We gebruiken, om snel aan de slag te kunnen met de controller, een robot die al is ontwikkeld genaamd Morsy. Morsy komt uit de MORSE code, de Modular OpenRobots Simulation Engine. (https://www.openrobots.org/wiki/morse/)
Een plaatje van Morsy zie je hiernaast.

Merk op dat deze logistieke robot geen armen heeft. Het oppakken van objecten om te verplaatsen zal dus meer symbolisch zijn. Het is mogelijk om armen met een animatie toe te voegen om een object op te pakken. Omdat dit niet het doel is van het project zullen we dit niet behandelen.

=== Stap 1 ===
Open [https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/morsy.blend morsy.blend] (je moet deze eerst naar je eigen computer downloaden).
Je ziet dat we te maken hebben met dezelfde basis omgeving maar dat de Cube Mesh vervangen is door de Morsy robot.

=== Stap 2 ===
Verander zonodig het window type van de timeline window (links onder) naar de logic editor (zie hiernaast).

[[Bestand:Selecteer-logic-editor.png|thumb|200px|right|Selecteer Logic Editor]]

=== Stap 3 ===
Maak de ruimte voor de logic editor iets groter en zoom indien nodig in (met de muis/touch pad) zodat de letters leesbaar zijn. Je kunt nu zien dat de logic editor bestaat uit sensoren, controllers en actuatoren. Sensoren zijn gebeurtenissen die Morsy kan waarnemen vanuit de omgeving. De controller bepaalt hoe je op deze gebeurtenis ingaat om zo eventueel een actuator aan te sturen.

=== Stap 4: controller, sturen naar rechts ===
We kunnen nu de controller gaan maken. We willen de robot aansturen met de pijltjes op het toetsenbord. Iedere toets is dan een sensor. Wanneer deze sensor actief is (en dus ingedrukt wordt) moet de robot een bepaalde kant op gaan lopen. We beginnen met naar rechts lopen
Wanneer we de toets → indrukken willen we dat Morsy naar rechts gaat lopen (voor Morsy zelf is dit naar links). In de linker beneden hoek van het 3D scherm zien we de assen waarover de robot kan bewegen. We zien dat we Morsy moeten laten lopen over de –X as om deze naar rechts te laten gaan. Dit gaat als volgt:
* Voor het aanmaken van deze actie moeten we een sensor hebben die detecteert of we de toets → indrukken. Klik op “Add Sensor” en dan op Keyboard.
* Geef de Keyboard de naam “Right” en ga erna in het vakje “Key” staan waardoor je ziet “Press a key” en druk op →
* Ga naar “Add Controller” en voeg een “And” controller toe. Maak een link tussen de sensor en controller door de twee punten met elkaar te verbinden. Het moet er nu als volgt uit zien: [[Bestand:Les1-keyboard-controller.png|700px|Keyboard sensor en controller]] Wanneer we op de → toets drukken geeft dit een positief signaal aan de controller. De controller moet positieve signalen ontvangen van alle sensoren die verbonden zijn met deze controller om zelf een positief signaal door te kunnen geven. Dit is er nu maar 1. Wanneer alleen de toets → ingedrukt wordt geeft de controller dus een positief signaal.
* Nu gaan we de controller verbinden aan een actie: lopen. Ga naar “Add Actuator” en voeg een “Motion” actuator toe. Geef deze ook de naam “Right” en een X loc waarde van -0.3. Druk ook op de L achter deze regel. Dit geeft aan dat we willen bewegen ten opzichte van de assen en niet ten opzichte van de locatie van Morsy zelf. Maak een link tussen de controller en actuator. [[Bestand:Les1-motion-actuator.png|700px|Add motion actuator]]

==== Toevoegen van de vloer ====
Graag willen we nu weten of de robot naar rechts kan lopen. Als we nu in de “play” modus zouden gaan, zou de robot naar beneden vallen omdat we nog geen vloer hebben toegevoegd. Je zet Blender in de “play” modus door met de muis in het 3D view te staan en dan op ‘P’ te drukken. Je komt weer uit deze modus door op ‘Esc’ te drukken.
Voeg een vloer toe door in de header van de 3D view te klikken op “Add”, dan op “Mesh” en dan op “Plane”.

[[Bestand:Les1-add-plane.png|350px|Add plane]]

Verschuif het vierkant onder Morsy door op de assen te klikken en de grond te verschuiven. Druk op “S” en gebruik de “Wheel” om de grond groter te maken.
Verander de kleur van de vloer door in het property venster te gaan naar:

[[Bestand:Les1-plane-newmaterial.png|350px|Add new material]]

en klik op “+ New”. Bij diffuse kun je een kleur uitkiezen.
Als het goed is ziet het 3D window er nu als volgt uit:

[[Bestand:Les1-morsy-floor.png|700px|Morsy op het speelveld]]

Druk nu op “P” en kijk of Morsy naar rechts beweegt bij het indrukken van de pijl naar rechts. Wanneer je dit getest hebt, druk weer op “Esc”. Wanneer Morsy niet naar rechts loopt, moet je stap 4 nogmaals doorlopen om te zien of je alles juist ingevoerd hebt.
* als Morsy naar links loopt, moet je het teken van de X-verplaatsing veranderen (bijv. van 0.2 naar -0.2);
* als Morse te snel of te langzaam loopt, moet je de verplaatsing kleiner of groter maken (bijv. van 0.4 naar 0.2);
* als er helemaal niets gebeurt, moet je controleren of je (i) de juiste toets ingevoerd hebt, in de Keyboard sensor; (ii) of je de verbinding tussen sensor en controller en controller en actuator gemaakt hebt;

=== Stap 5: sturen naar links, achter en voor ===
Zorg ervoor dat Morsy ook naar links, achter en naar voren kan lopen door middel van het toetsenbord.

=== Stap 6: bestand opslaan voor vervolg ===
Sla het bestand op om volgende les mee verder te gaan.

== Plusopdracht ==
Zorg ervoor dat de robot via het toetsenbord:
* Een rondje kan draaien om zijn eigen as met de toets ‘R’. Voor hulp zie: https://www.youtube.com/watch?v=Lpb8yCNgDQ8
* Kan springen bij wanneer de Spacebar en toets J ingedrukt zijn
* …

== Referenties ==

* [[../Blender installeren]]
* MORSE code, de Modular OpenRobots Simulation Engine. (https://www.openrobots.org/wiki/morse/)

Logistieke Robots/les 2

2014-12-17T16:46:53Z

Jacqueline: /* Les 2 - Objecten zoeken en verplaatsen */

{{Zijbalk Logistieke Robots}}

== Les 2 - Objecten zoeken en verplaatsen ==

In dit project willen we robots toepassen in de logistieke sector. Wanneer robots actief zijn in de logistieke sector betekent dit vaak dat robots bepaalde objecten moeten zoeken, oppakken en naar een doel moeten brengen. Hoe we een robot moeten aansturen die dit kan gaan we zien in deze les. Het eindresultaat van deze les ziet er als volgt uit: https://www.youtube.com/watch?v=z22EOFDgOj4.

Voor deze les maken we gebruik van het bestand [https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/living_room.blend living_room.blend]. Wanneer je het bestand opent zie je een huiskamer en een aantal boeken die rondslingeren in de kamer. We willen dat de robot de boeken kan herkennen, er naar toe kan lopen, op kan pakken en in de boekenkast kan zetten. In paragraaf 1 zullen we de robot aansturen via het toetsenbord en in paragraaf 2 laten we de robot deze taak autonoom (=zelfstandig) uitvoeren.

== Object naar het doel verplaatsten met het toetsenbord ==
Aan de hand van 5 stappen kunnen we de controller gaan maken. Zorg ervoor dat je eerst zelf nadenkt over de stappen die je uit moet voeren voordat je naar de print kijkt hoe de controller eruit moet zien.

=== Stap 1: Naar het boek lopen ===
Wanneer je op Morsy klikt, zie je in de logic editor dat er vier Keyboard sensors aangemaakt zijn. Hier kunnen we Morsy mee naar een boek laten lopen. Als je goed kijkt zie je ook dat er een Game Property aangemaakt is met de naam Morsy. Zo kunnen andere objecten Morsy herkennen. Waarom dit nodig is zien we later.

=== Stap 2: Boek vastpakken ===
Omdat Morsy geen armen heeft kan hij het boek niet vasthouden zoals wij dat zouden doen met onze handen. Morsy kan wel naar het boek lopen en wanneer hij contact heeft met het boek kun je je voorstellen dat het boek vast zit aan Morsy door middel van een magneet. Dit kunnen we als volgt doen:
Ga naar de controller van book_blue_ground en voeg een Collision sensor toe. Geef bij Property aan dat het om Morsy gaat.
Voeg een Parent actuator toe waarbij je bij Parent Object Morsy selecteert. Verbind de twee met elkaar. Er komt dan automatisch een And controller tussen.
Wanneer je nu in de spelmodus gaat (druk op P) en naar het blauwe boek loopt, zie je dat het blauwe boek vast blijft zitten aan Morsy. De controller ziet er als volgt uit:

[[Bestand:Les2-book-controller.png|700px]]

=== Stap 3: Naar het doel lopen ===
Het doel, de kast waar de drie dezelfde boeken wel in de kast staan, kan bereikt worden door middel van het toetsenbord.
Wanneer Morsy met het boek bij de kast is wil je dat het boek in de kast komt te staan. Het visualiseren van deze actie is niet een van de leerdoelen van dit project. Uiteraard mag je Morsy voorzien van een grijparm en visualiseren hoe Morsy het boek in de kast zet maar dit zal veel tijd in beslag nemen. Daarom gebruiken we een eenvoudiger methode.

=== Stap 4: Boek in de kast plaatsen ===
Wanneer Morsy de kast bereikt met een boek, wil je dat dit boek verdwijnt en dat het boek in de kast zichtbaar wordt. Voordat Morsy kan herkennen of er aanraking plaatsvindt met de kast, moet de kast een Game Property hebben.

==== Voeg kast-game property "Goal" toe ====
Selecteer de kast en voeg een ‘String’ Game Property toe aan de kast met de naam ‘Goal’:
[[Bestand:Les2-stap4-goal.png|700px|Add property: Goal]]

==== Voeg Morsy-sensoren en actuatoren toe ====

Selecteer nu weer Morsy en voeg een Collision sensor toe en twee Message actuatoren naar het blauwe boek op de grond en in de kast met als Subject ‘Done’:
[[Bestand:Les2-stap4-done.png|700px|Add message actuators: Done]]

==== Boek op de grond wordt opgepakt (onzichtbaar) ====
Zorg ervoor dat het blauwe boek op de grond het bericht kan ontvangen en hierna onzichtbaar wordt:
[[Bestand:Les2-stap4-book.png|700px|Boek wordt onzichtbaar]]

==== Boek in de kast wordt zichtbaar ====
Zorg er ook voor dat het boek in de kast vanaf het begin onzichtbaar is
totdat deze het bericht ‘Done’ krijgt van Morsy. Neem zelf even de tijd om te bedenken hoe dit moet.
[[Bestand:Les2-stap4-shelf.png|700px|Boek wordt in kast zichtbaar]]

=== Uiteindelijk resultaat ===
Het kan er uiteindelijk als volgt uit zien:

[[Bestand:Les2-stap5-afronden.png|500px|Morsy verplaatst het boek]]
Voor hulp zie: https://www.youtube.com/watch?v=nEgubbYwRy0

Wanneer je zelf andere sensoren en actuatoren gebruikt die hetzelfde resultaat als gevolg hebben, mag dit ook.

== Object herkennen met een radar ==

In deze paragraaf leren we hoe Morsy zelf naar de boeken kan lopen zonder aansturing via het toetsenbord.
Hiervoor moet Morsy tussen verschillende States (toestanden) kunnen schakelen. Morsy moet eerst de kamer afzoeken naar de boeken. Wanneer Morsy een boek gevonden heeft moet hij hier naartoe lopen en erna mogelijk weer verder zoeken om vervolgens de boeken bij de kast af te leveren.

We gebruiken de volgende toestanden (states):
* 1: zoeken naar boek 1 (met een radar-sensor), bewegen naar het boek, en oppakken van het boek
* 2: oppakken van boek 1 en in de kast plaatsen
* 3: zoeken naar boek 2
* 4: oppakken van boek 4
* 5: loop naar de kast en plaats de boeken daarin

=== Stap 1: Opzetten ===
In de vorige paragraaf konden wij de boeken zien liggen en Morsy erheen sturen via het toetsenbord. Nu willen we dat Morsy zelf de boeken kan vinden. Geef de boeken die op de grond liggen de Game Property ‘book_1’ en ‘book_2’ en verwijder alle sensorsen en actuators van Morsy.

=== Stap 2: Boeken detecteren ===
We gaan Morsy voorzien van verschillende Radars die de boeken kunnen detecteren. We voegen eerst een radar toe voor <code>book_1</code>
* Om de boeken te kunnen zien met de Radars moet Morsy rondjes draaien. Voeg een Always sensor toe die een Motion actuator activeert waarbij je 2 graden om de Z as beweegt.
** controleer of deze werkt;
* Voeg een Radar sensor toe met Property <code>book_1</code>, over de –X as (<code>-X axis</code>), een hoek (<code>Angle</code>) van 50 graden en een afstand (<code>Distance</code>) van 8 meter.
** Om de radar te kunnen zien in de 3D view, kun je in de info window van Blender drukken op <code>Game > Show Physics Visualization</code>. Wanneer je nu naar de spel modus gaat kun je de radar zien. Je kunt de Physics Visualization hierna weer uitzetten.

=== Stap 3: Boeken ophalen in verschillende states ===
* Voeg aan Morsy een Integer Game Property toe genaamd ‘number’. Dit is het aantal boeken dat Morsy opgepakt heeft. We laten Morsy de boeken in een speciale volgorde ophalen. Dit is nodig wanneer je met de logic bricks werkt. In de volgende les zien we dat het met Python sneller kan. Wanneer de radar het boek ziet met property <code>book_1</code> en deze moet ophalen (property number is dan nog 0) gaat Morsy naar state 2. De controller ziet er nu als volgt uit: [[Bestand:Les2-state1.png|700px|Controller state 1]]

Nu moeten we een invulling gaan geven aan de controller in state 2.
* Druk op het plusje links naast de Controller bar. En ga naar state 2. Initial geeft aan in welke state je begint. In deze state wil je dat Morsy naar een bepaald boek loopt. In dit geval het boek met property book_1. Dit kan met een Steering actuator. Je kan variëren met de snelheid en afstand om het ophalen zo natuurlijk mogelijk te laten verlopen.
* Wanneer Morsy het boek bereikt heeft moeten er een aantal dingen gebeuren.
** Morsy moet laten weten aan het boek dat het zich vast moet klampen aan de robot.
** Vervolgens gaat de number property 1 omhoog zodat Morsy op zoek kan naar het volgende boek wanneer hij teruggezet wordt naar state 1. De controller ziet er nu als volgt uit: [[Bestand:Les2-state2.png|700px|Controller state 2]]
* Wanneer we een bericht sturen naar het boek, moeten we de controller van het boek wel aanpassen. De Collision sensor van het boek veranderen we in een Message sensor op de volgende manier: [[Bestand:Voorbeeld.png]]

Herhaal deze procedure voor boek 2 en 3 (gebruik states 3 en 4 hiervoor). Wanneer Morsy alle boeken gevonden heeft, zal de number property op 3 staan en moet Morsy terug naar de kast. Het lopen naar de kast kan gezien worden als state 5. Voeg in state 1 een property sensor toe. Als deze gelijk is aan 3, zet Morsy dan in state 5.

In state 5 moet je altijd sturen naar de kast. Als je hier bent stuur je een Done message naar alle boeken. Zet Morsy vervolgens in state 6: een lege state. State 5 ziet er als volgt uit:
[[Bestand:Voorbeeld.png]]

voor hulp zie: https://www.youtube.com/watch?v=s3YjWyM_QWs

== Plusopdracht ==
Het is je vast al opgevallen dat het best lastig is om van een toetsenbord controller naar een autonome controller te gaan. In de plusopdracht verbeter je twee aspecten:
# Wanneer de radar afstand van Morsy kleiner is, moet Morsy naast alleen draaien ook gaan wandelen om de boeken te kunnen detecteren.
# Met een toetsenbord kun je makkelijker om een obstakel heen navigeren. Nu zal Morsy tegen alles opbotsen wat tussen hem en het doel instaat. Zorg ervoor dat Morsy om obstakels heen kan lopen.
Als je even niet meer wilt programmeren kun je ook gaan werken met de camera's
# Probeer de kamer vanuit Morsy te bekijken. Voor hulp zie: https://www.youtube.com/watch?v=Rmeq85kt8zE

Logistieke Robots/les 2

2014-12-17T16:46:13Z

Jacqueline: /* Stap 3: Boeken ophalen in verschillende states */

{{Zijbalk Logistieke Robots}}

== Les 2 - Objecten zoeken en verplaatsen ==

In dit project willen we robots toepassen in de logistieke sector. Wanneer robots actief zijn in de logistieke sector betekent dit vaak dat robots bepaalde objecten moeten zoeken, oppakken en naar een doel moeten brengen. Hoe we een robot moeten aansturen die dit kan gaan we zien in deze les.

Voor deze les maken we gebruik van het bestand [https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/living_room.blend living_room.blend]. Wanneer je het bestand opent zie je een huiskamer en een aantal boeken die rondslingeren in de kamer. We willen dat de robot de boeken kan herkennen, er naar toe kan lopen, op kan pakken en in de boekenkast kan zetten. In paragraaf 1 zullen we de robot aansturen via het toetsenbord en in paragraaf 2 laten we de robot deze taak autonoom (=zelfstandig) uitvoeren.

== Object naar het doel verplaatsten met het toetsenbord ==
Aan de hand van 5 stappen kunnen we de controller gaan maken. Zorg ervoor dat je eerst zelf nadenkt over de stappen die je uit moet voeren voordat je naar de print kijkt hoe de controller eruit moet zien.

=== Stap 1: Naar het boek lopen ===
Wanneer je op Morsy klikt, zie je in de logic editor dat er vier Keyboard sensors aangemaakt zijn. Hier kunnen we Morsy mee naar een boek laten lopen. Als je goed kijkt zie je ook dat er een Game Property aangemaakt is met de naam Morsy. Zo kunnen andere objecten Morsy herkennen. Waarom dit nodig is zien we later.

=== Stap 2: Boek vastpakken ===
Omdat Morsy geen armen heeft kan hij het boek niet vasthouden zoals wij dat zouden doen met onze handen. Morsy kan wel naar het boek lopen en wanneer hij contact heeft met het boek kun je je voorstellen dat het boek vast zit aan Morsy door middel van een magneet. Dit kunnen we als volgt doen:
Ga naar de controller van book_blue_ground en voeg een Collision sensor toe. Geef bij Property aan dat het om Morsy gaat.
Voeg een Parent actuator toe waarbij je bij Parent Object Morsy selecteert. Verbind de twee met elkaar. Er komt dan automatisch een And controller tussen.
Wanneer je nu in de spelmodus gaat (druk op P) en naar het blauwe boek loopt, zie je dat het blauwe boek vast blijft zitten aan Morsy. De controller ziet er als volgt uit:

[[Bestand:Les2-book-controller.png|700px]]

=== Stap 3: Naar het doel lopen ===
Het doel, de kast waar de drie dezelfde boeken wel in de kast staan, kan bereikt worden door middel van het toetsenbord.
Wanneer Morsy met het boek bij de kast is wil je dat het boek in de kast komt te staan. Het visualiseren van deze actie is niet een van de leerdoelen van dit project. Uiteraard mag je Morsy voorzien van een grijparm en visualiseren hoe Morsy het boek in de kast zet maar dit zal veel tijd in beslag nemen. Daarom gebruiken we een eenvoudiger methode.

=== Stap 4: Boek in de kast plaatsen ===
Wanneer Morsy de kast bereikt met een boek, wil je dat dit boek verdwijnt en dat het boek in de kast zichtbaar wordt. Voordat Morsy kan herkennen of er aanraking plaatsvindt met de kast, moet de kast een Game Property hebben.

==== Voeg kast-game property "Goal" toe ====
Selecteer de kast en voeg een ‘String’ Game Property toe aan de kast met de naam ‘Goal’:
[[Bestand:Les2-stap4-goal.png|700px|Add property: Goal]]

==== Voeg Morsy-sensoren en actuatoren toe ====

Selecteer nu weer Morsy en voeg een Collision sensor toe en twee Message actuatoren naar het blauwe boek op de grond en in de kast met als Subject ‘Done’:
[[Bestand:Les2-stap4-done.png|700px|Add message actuators: Done]]

==== Boek op de grond wordt opgepakt (onzichtbaar) ====
Zorg ervoor dat het blauwe boek op de grond het bericht kan ontvangen en hierna onzichtbaar wordt:
[[Bestand:Les2-stap4-book.png|700px|Boek wordt onzichtbaar]]

==== Boek in de kast wordt zichtbaar ====
Zorg er ook voor dat het boek in de kast vanaf het begin onzichtbaar is
totdat deze het bericht ‘Done’ krijgt van Morsy. Neem zelf even de tijd om te bedenken hoe dit moet.
[[Bestand:Les2-stap4-shelf.png|700px|Boek wordt in kast zichtbaar]]

=== Uiteindelijk resultaat ===
Het kan er uiteindelijk als volgt uit zien:

[[Bestand:Les2-stap5-afronden.png|500px|Morsy verplaatst het boek]]
Voor hulp zie: https://www.youtube.com/watch?v=nEgubbYwRy0

Wanneer je zelf andere sensoren en actuatoren gebruikt die hetzelfde resultaat als gevolg hebben, mag dit ook.

== Object herkennen met een radar ==

In deze paragraaf leren we hoe Morsy zelf naar de boeken kan lopen zonder aansturing via het toetsenbord.
Hiervoor moet Morsy tussen verschillende States (toestanden) kunnen schakelen. Morsy moet eerst de kamer afzoeken naar de boeken. Wanneer Morsy een boek gevonden heeft moet hij hier naartoe lopen en erna mogelijk weer verder zoeken om vervolgens de boeken bij de kast af te leveren.

We gebruiken de volgende toestanden (states):
* 1: zoeken naar boek 1 (met een radar-sensor), bewegen naar het boek, en oppakken van het boek
* 2: oppakken van boek 1 en in de kast plaatsen
* 3: zoeken naar boek 2
* 4: oppakken van boek 4
* 5: loop naar de kast en plaats de boeken daarin

=== Stap 1: Opzetten ===
In de vorige paragraaf konden wij de boeken zien liggen en Morsy erheen sturen via het toetsenbord. Nu willen we dat Morsy zelf de boeken kan vinden. Geef de boeken die op de grond liggen de Game Property ‘book_1’ en ‘book_2’ en verwijder alle sensorsen en actuators van Morsy.

=== Stap 2: Boeken detecteren ===
We gaan Morsy voorzien van verschillende Radars die de boeken kunnen detecteren. We voegen eerst een radar toe voor <code>book_1</code>
* Om de boeken te kunnen zien met de Radars moet Morsy rondjes draaien. Voeg een Always sensor toe die een Motion actuator activeert waarbij je 2 graden om de Z as beweegt.
** controleer of deze werkt;
* Voeg een Radar sensor toe met Property <code>book_1</code>, over de –X as (<code>-X axis</code>), een hoek (<code>Angle</code>) van 50 graden en een afstand (<code>Distance</code>) van 8 meter.
** Om de radar te kunnen zien in de 3D view, kun je in de info window van Blender drukken op <code>Game > Show Physics Visualization</code>. Wanneer je nu naar de spel modus gaat kun je de radar zien. Je kunt de Physics Visualization hierna weer uitzetten.

=== Stap 3: Boeken ophalen in verschillende states ===
* Voeg aan Morsy een Integer Game Property toe genaamd ‘number’. Dit is het aantal boeken dat Morsy opgepakt heeft. We laten Morsy de boeken in een speciale volgorde ophalen. Dit is nodig wanneer je met de logic bricks werkt. In de volgende les zien we dat het met Python sneller kan. Wanneer de radar het boek ziet met property <code>book_1</code> en deze moet ophalen (property number is dan nog 0) gaat Morsy naar state 2. De controller ziet er nu als volgt uit: [[Bestand:Les2-state1.png|700px|Controller state 1]]

Nu moeten we een invulling gaan geven aan de controller in state 2.
* Druk op het plusje links naast de Controller bar. En ga naar state 2. Initial geeft aan in welke state je begint. In deze state wil je dat Morsy naar een bepaald boek loopt. In dit geval het boek met property book_1. Dit kan met een Steering actuator. Je kan variëren met de snelheid en afstand om het ophalen zo natuurlijk mogelijk te laten verlopen.
* Wanneer Morsy het boek bereikt heeft moeten er een aantal dingen gebeuren.
** Morsy moet laten weten aan het boek dat het zich vast moet klampen aan de robot.
** Vervolgens gaat de number property 1 omhoog zodat Morsy op zoek kan naar het volgende boek wanneer hij teruggezet wordt naar state 1. De controller ziet er nu als volgt uit: [[Bestand:Les2-state2.png|700px|Controller state 2]]
* Wanneer we een bericht sturen naar het boek, moeten we de controller van het boek wel aanpassen. De Collision sensor van het boek veranderen we in een Message sensor op de volgende manier: [[Bestand:Voorbeeld.png]]

Herhaal deze procedure voor boek 2 en 3 (gebruik states 3 en 4 hiervoor). Wanneer Morsy alle boeken gevonden heeft, zal de number property op 3 staan en moet Morsy terug naar de kast. Het lopen naar de kast kan gezien worden als state 5. Voeg in state 1 een property sensor toe. Als deze gelijk is aan 3, zet Morsy dan in state 5.

In state 5 moet je altijd sturen naar de kast. Als je hier bent stuur je een Done message naar alle boeken. Zet Morsy vervolgens in state 6: een lege state. State 5 ziet er als volgt uit:
[[Bestand:Voorbeeld.png]]

voor hulp zie: https://www.youtube.com/watch?v=s3YjWyM_QWs

== Plusopdracht ==
Het is je vast al opgevallen dat het best lastig is om van een toetsenbord controller naar een autonome controller te gaan. In de plusopdracht verbeter je twee aspecten:
# Wanneer de radar afstand van Morsy kleiner is, moet Morsy naast alleen draaien ook gaan wandelen om de boeken te kunnen detecteren.
# Met een toetsenbord kun je makkelijker om een obstakel heen navigeren. Nu zal Morsy tegen alles opbotsen wat tussen hem en het doel instaat. Zorg ervoor dat Morsy om obstakels heen kan lopen.
Als je even niet meer wilt programmeren kun je ook gaan werken met de camera's
# Probeer de kamer vanuit Morsy te bekijken. Voor hulp zie: https://www.youtube.com/watch?v=Rmeq85kt8zE

Logistieke Robots/les 3

2014-12-17T16:12:07Z

Jacqueline: /* Morsy besturen met Python */

{{Zijbalk Logistieke Robots}}

== Morsy besturen met Python ==
In de vorige les hebben we gezien dat de controller van Morsy veel complexer wordt als we hem autonoom aan willen sturen. Wanneer we Morsy nog meer taken willen geven, en wanneer we Morsy in een groep willen laten werken, zijn de logic bricks niet meer toereikend. Daarom gaan we Blender combineren met de programmeertaal Python. Het eindresultaat van deze les is: https://www.youtube.com/watch?v=-TvRNqFqew8.

Controleer eerst of de juiste versie van Python op je systeem geïnstalleerd is, op de juiste plaats. (Zie: [[../Python installeren|Python installeren]] voor verdere aanwijzingen.) In sommige gevallen is Python geïnstalleerd als onderdeel van Blender.

== Blender combineren met programmeertaal Python ==
In deze les gebruiken we [https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/warehouse.blend warehouse.blend]. Deze omgeving zullen we gedurende de rest van het project gebruiken. Het openen van het bestand gaat nu anders omdat we de Python output willen zien. Dit is verschillend voor de Windows en voor de OS X versie van Blender.

=== OS X: Blender opstarten met Terminal ===

Ga naar de Blender applicatie en open de Package Contents van Blender.

[[Bestand:osx-show-package.png|350px|Show Package contents]]

Open vervolgens het blender executable bestand via het openen van de volgende folders: <code>Contents > MacOS > blender </code>

[[Bestand:osx-blender-terminal.png|700px|Blender starten met terminal]]

Als Blender opstart, kun je via <code>File>Open</code> het bestand “warehouse.blend” openen.

=== Windows: ===

Open Blender op de gebruikelijke manier. Ga naar de Info Window en klik op <code>Window >Toggle System Console</code>. Er is nu een extra scherm in beeld.

Wanneer je de file “warehouse.blend” geopend hebt, zie je in het window linksonder een Tekst Editor. Hier kun je een Python controller ontwikkelen.

=== Controleren of Python werkt in Blender ===

Om te testen of de link tussen Blender en Python werkt, voeren we de volgende stappen uit:
# Voeg aan Robot_11 (de voorste) een Always sensor toe.
# Maak een nieuw Python script aan:
## klik op de "+" onderin het Text Editor venster (naast de naam van het bestand).
## verander de naam van het bestand in "Text.py"
## typ in de Text Editor: <code>print(“Hello”)</code>
# Voeg aan Robot_11 een Python controller: [[Bestand:Les3-robot11-python-controller.png|350px|Voeg Python controller toe]]
# Selecteer als script voor deze Python-controller: "Text.py"
# Link de controller met de sensor: [[Bestand:Les3-robot11-sensor-controller.png|700px|Link sensor en controller]]
# Ga na de spel modus (of, voor OS X, naar de Terminal) en kijk naar de console. Dit moet er nu in de console te zien zijn:
<pre>
Blender Game Engine Started
Hello
Blender Game Engine Finished
</pre>

Voor hulp zie: https://www.youtube.com/watch?v=9dRd-pU2dKQ

== Ontwikkelen van een controller in Python ==

Nu je weet hoe je Python aan Blender moet koppelen, kunnen we een Python controller maken. We gaan Morsy, nu genaamd Robot_11, naar een kast laten lopen om een artikel op te halen en in de box te zetten op tafel. Voordat we hieraan kunnen beginnen moeten we begrijpen hoe je sensoren kunt opvangen en actuatoren kunt aansturen via een Python controller.

=== Morsy laten lopen door een Python controller ===

Wat je in deze paragraaf gaat leren lijkt op wat je geleerd hebt in les 2, het autonoom laten ophalen van objecten en naar een bepaald doel brengen, maar nu doen we dat via een Python controller.

==== Stap 1: Onderdelen van een script ====
Blender heeft al een opzet voor hoe je een robot moet aansturen. Ga in de Tekst editor window naar <code>Templates > Python> GameLogic Simple</code>. Je ziet nu de volgende code verschijnen:
<syntaxhighlight lang="Python" line>
import bge

def main():

cont = bge.logic.getCurrentController()
own = cont.owner

sens = cont.sensors['mySensor']
actu = cont.actuators['myActuator']

if sens.positive:
cont.activate(actu)
else:
cont.deactivate(actu)

main()
</syntaxhighlight>

Dit heet een script. Dit script bestaat uit verschillende onderdelen.
* (r. 1) <code>import bge</code> importeert de Blender Game Engine module voor Python. In deze module is onder andere de functie <code>logic.getCurrentController()</code> gedefinieerd.
* (r. 4-15) De definitie van de functie <code>main()</code>;
* (r. 17) Een aanroep van de functie <code>main()</code>: de opdrachten in de definitie daarvan worden uitgevoerd.

Het is belangrijk om te begrijpen hoe een script werkt. Wanneer deze controller geactiveerd wordt (bijvoorbeeld door een sensor), wordt het script uitgevoerd, en gebeurt er het volgende:
# <code>import bge</code> - Het script importeert de module ‘bge’ en beschikt zo over alle gedefinieerde functies in de bge module.
# <code>def main():</code> - definieert de functie main met de daarop volgende opdrachten.
# <code>main() </code> - aanroep van de functie main. De opdrachten in de definitie (“body”) van de functie main worden uitgevoerd.

=== Stap 2: Sensoren en actuatoren toevoegen ===
Als we op ENTER (ofwel Return) drukken willen we dat Morsy naar de voorste kast gaat lopen. Ga door de volgende stappen heen om de juiste sensors en actuators toe te voegen:
# Verander de Always sensor in een Keyboard sensor met als Key de ENTER knop. Geef deze sensor de naam ‘Start’
# Voeg een Steering actuator toe. Laat deze de naam ‘Steering’ houden en over de –X as bewegen.
# Voeg een Collission sensor genaamd ‘AtTarget’ toe link deze aan de Python controller.
Dit zijn alle actuators en sensors die we nodig hebben om de genoemde taak uit te voeren.

=== Stap 3: Triggers ontvangen en versturen door de Python controller ===
In de vorige lessen hadden we een sensor, bijvoorbeeld een Keyboard sensor, aan een And controller gekoppeld. Wanneer je de juiste toets aanraakt op je toetsenbord gaat er een positieve ‘trigger’ naar de And controller die de bijbehorende actuator activeert.

Nu moeten we de Start trigger op zien te vangen in de Python controller. Doe dit als volgt:

* Het script moet de ''controller'' kunnen aanroepen waar de sensoren en actuatoren aan gekoppeld zijn. Dit kan door de functie <code>bge.logic.getCurrentController()</code>
* Vervolgens moet de controller kunnen herkennen welke van de inkomende sensoren een trigger geeft om een juiste actuator aan te roepen. Je kunt deze sensoren vinden via <code>cont.sensors[“Start”]</code> en <code>cont.sensors[“AtTarget”]</code>
Om de code overzichtelijk te houden kun je verwijzingen maken naar de sensoren en actuatoren. Je mag deze namen zelf verzinnen of de volgende gebruiken:

<syntaxhighlight lang="Python">
import bge
cont = bge.logic.getCurrentController()
start = cont.sensors[“Start”]
collision = cont.sensors[“AtTarget”]

def main():
# define function main…

main()
</syntaxhighlight>

* Bij het indrukken van de ENTER key, willen we dat Morsy zijn taak uit gaat voeren. Zowel het indrukken als het loslaten van de ENTER key geeft een trigger aan de controller. Het indrukken is een positive pulse en loslaten een negative pulse. Via een boolean (met waarde TRUE of FALSE) wordt aangegeven of er een pulse gegeven wordt. We willen dat de main() alleen aangeroepen wordt als start.positive TRUE is. Omdat start.positive een boolean is kun je dit als volgt opschrijven:

<syntaxhighlight lang="Python">
if start.positive
main()
</syntaxhighlight>
(Let op: een Tab in Python staat gelijk aan 4 spaties en is nodig om aan te geven wat er moet gebeuren als de conditie van de if <code>TRUE</code> is)
* Zorg ervoor dat in de definitie van de functie <code>main() </code> de Steering actuator geactiveerd wordt en naar Shelf_8 toe gaat (de voorste kast). De code ziet er nu als volgt uit:

<syntaxhighlight lang="Python">
import bge

cont = bge.logic.getCurrentController()
start = cont.sensors[“Start”]
collision = cont.sensors[“AtTarget”]
steering - cont.actuators[“Steering”]

def main():
steering.target = “Shelf_8”
cont.activate(steering)

if start.positive:
main()
</syntaxhighlight>

=== Stap 4: Script afmaken ===
Wanneer je nu in de play modus gaat en op ENTER drukt zie je dat Morsy naar Shelf_8 gaat lopen.

In deze stap ga je zelf uitzoeken hoe Morsy heen en weer loopt naar de kast. Het is geen vereiste meer dat de ENTER key voor de start zorgt. Morsy mag gelijk van start gaan in de play modus. Denk zelf na hoe je dit moet doen.

Tips: je moet een Game Property aanmaken voor Desk_11, Shelf_8 en een voor Robot_11 om aan te geven waar hij heen moet lopen. Deze kun je aanroepen en veranderen via de variabele <code>cont.owner[“naam van game propery”]</code> . Ook moet je in de Collision sensor de Tap button aanklikken om maar 1 trigger te geven bij aanraking van de tafel of kast.

De Start sensor kun je veranderen in een Always sensors zodat Morsy gelijk begint met lopen.

Het is niet erg als je er zelf nog niet helemaal uit bent gekomen. Juist als het niet werkt zoals je wilt leer je hier meer van doordat je de verkeerde code moet herstellen. Wanneer je er niet uit komt kun je naar onderstaande uitwerking kijken:

<syntaxhighlight lang="Python">
import bge

def main():
print("main called")
cont = bge.logic.getCurrentController()
own = cont.owner

collision1 = cont.sensors['AtTarget']
steering = cont.actuators['Steering']

if collision1.positive:
print("Collision target=" + steering.target.name)
if steering.target.name == "Shelf_8":
steering.target = "Desk_11"
collision1.propName = "Desk"
else:
steering.target = "Shelf_8"
collision1.propName = "Shelf"
else:
print("no Collision")

cont.activate(steering)

main()
</syntaxhighlight>

Voor hulp zie: https://www.youtube.com/watch?v=y36ZGsFDA2E

plus: visualiseer pakket https://www.youtube.com/watch?v=wJYlWa5D0hc

Logistieke Robots/les 3

2014-12-17T16:11:12Z

Jacqueline: /* Stap 4: Script afmaken */

{{Zijbalk Logistieke Robots}}

== Morsy besturen met Python ==
In de vorige les hebben we gezien dat de controller van Morsy veel complexer wordt als we hem autonoom aan willen sturen. Wanneer we Morsy nog meer taken willen geven, en wanneer we Morsy in een groep willen laten werken, zijn de logic bricks niet meer toereikend. Daarom gaan we Blender combineren met de programmeertaal Python.

Controleer eerst of de juiste versie van Python op je systeem geïnstalleerd is, op de juiste plaats. (Zie: [[../Python installeren|Python installeren]] voor verdere aanwijzingen.) In sommige gevallen is Python geïnstalleerd als onderdeel van Blender.

== Blender combineren met programmeertaal Python ==
In deze les gebruiken we [https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/warehouse.blend warehouse.blend]. Deze omgeving zullen we gedurende de rest van het project gebruiken. Het openen van het bestand gaat nu anders omdat we de Python output willen zien. Dit is verschillend voor de Windows en voor de OS X versie van Blender.

=== OS X: Blender opstarten met Terminal ===

Ga naar de Blender applicatie en open de Package Contents van Blender.

[[Bestand:osx-show-package.png|350px|Show Package contents]]

Open vervolgens het blender executable bestand via het openen van de volgende folders: <code>Contents > MacOS > blender </code>

[[Bestand:osx-blender-terminal.png|700px|Blender starten met terminal]]

Als Blender opstart, kun je via <code>File>Open</code> het bestand “warehouse.blend” openen.

=== Windows: ===

Open Blender op de gebruikelijke manier. Ga naar de Info Window en klik op <code>Window >Toggle System Console</code>. Er is nu een extra scherm in beeld.

Wanneer je de file “warehouse.blend” geopend hebt, zie je in het window linksonder een Tekst Editor. Hier kun je een Python controller ontwikkelen.

=== Controleren of Python werkt in Blender ===

Om te testen of de link tussen Blender en Python werkt, voeren we de volgende stappen uit:
# Voeg aan Robot_11 (de voorste) een Always sensor toe.
# Maak een nieuw Python script aan:
## klik op de "+" onderin het Text Editor venster (naast de naam van het bestand).
## verander de naam van het bestand in "Text.py"
## typ in de Text Editor: <code>print(“Hello”)</code>
# Voeg aan Robot_11 een Python controller: [[Bestand:Les3-robot11-python-controller.png|350px|Voeg Python controller toe]]
# Selecteer als script voor deze Python-controller: "Text.py"
# Link de controller met de sensor: [[Bestand:Les3-robot11-sensor-controller.png|700px|Link sensor en controller]]
# Ga na de spel modus (of, voor OS X, naar de Terminal) en kijk naar de console. Dit moet er nu in de console te zien zijn:
<pre>
Blender Game Engine Started
Hello
Blender Game Engine Finished
</pre>

Voor hulp zie: https://www.youtube.com/watch?v=9dRd-pU2dKQ

== Ontwikkelen van een controller in Python ==

Nu je weet hoe je Python aan Blender moet koppelen, kunnen we een Python controller maken. We gaan Morsy, nu genaamd Robot_11, naar een kast laten lopen om een artikel op te halen en in de box te zetten op tafel. Voordat we hieraan kunnen beginnen moeten we begrijpen hoe je sensoren kunt opvangen en actuatoren kunt aansturen via een Python controller.

=== Morsy laten lopen door een Python controller ===

Wat je in deze paragraaf gaat leren lijkt op wat je geleerd hebt in les 2, het autonoom laten ophalen van objecten en naar een bepaald doel brengen, maar nu doen we dat via een Python controller.

==== Stap 1: Onderdelen van een script ====
Blender heeft al een opzet voor hoe je een robot moet aansturen. Ga in de Tekst editor window naar <code>Templates > Python> GameLogic Simple</code>. Je ziet nu de volgende code verschijnen:
<syntaxhighlight lang="Python" line>
import bge

def main():

cont = bge.logic.getCurrentController()
own = cont.owner

sens = cont.sensors['mySensor']
actu = cont.actuators['myActuator']

if sens.positive:
cont.activate(actu)
else:
cont.deactivate(actu)

main()
</syntaxhighlight>

Dit heet een script. Dit script bestaat uit verschillende onderdelen.
* (r. 1) <code>import bge</code> importeert de Blender Game Engine module voor Python. In deze module is onder andere de functie <code>logic.getCurrentController()</code> gedefinieerd.
* (r. 4-15) De definitie van de functie <code>main()</code>;
* (r. 17) Een aanroep van de functie <code>main()</code>: de opdrachten in de definitie daarvan worden uitgevoerd.

Het is belangrijk om te begrijpen hoe een script werkt. Wanneer deze controller geactiveerd wordt (bijvoorbeeld door een sensor), wordt het script uitgevoerd, en gebeurt er het volgende:
# <code>import bge</code> - Het script importeert de module ‘bge’ en beschikt zo over alle gedefinieerde functies in de bge module.
# <code>def main():</code> - definieert de functie main met de daarop volgende opdrachten.
# <code>main() </code> - aanroep van de functie main. De opdrachten in de definitie (“body”) van de functie main worden uitgevoerd.

=== Stap 2: Sensoren en actuatoren toevoegen ===
Als we op ENTER (ofwel Return) drukken willen we dat Morsy naar de voorste kast gaat lopen. Ga door de volgende stappen heen om de juiste sensors en actuators toe te voegen:
# Verander de Always sensor in een Keyboard sensor met als Key de ENTER knop. Geef deze sensor de naam ‘Start’
# Voeg een Steering actuator toe. Laat deze de naam ‘Steering’ houden en over de –X as bewegen.
# Voeg een Collission sensor genaamd ‘AtTarget’ toe link deze aan de Python controller.
Dit zijn alle actuators en sensors die we nodig hebben om de genoemde taak uit te voeren.

=== Stap 3: Triggers ontvangen en versturen door de Python controller ===
In de vorige lessen hadden we een sensor, bijvoorbeeld een Keyboard sensor, aan een And controller gekoppeld. Wanneer je de juiste toets aanraakt op je toetsenbord gaat er een positieve ‘trigger’ naar de And controller die de bijbehorende actuator activeert.

Nu moeten we de Start trigger op zien te vangen in de Python controller. Doe dit als volgt:

* Het script moet de ''controller'' kunnen aanroepen waar de sensoren en actuatoren aan gekoppeld zijn. Dit kan door de functie <code>bge.logic.getCurrentController()</code>
* Vervolgens moet de controller kunnen herkennen welke van de inkomende sensoren een trigger geeft om een juiste actuator aan te roepen. Je kunt deze sensoren vinden via <code>cont.sensors[“Start”]</code> en <code>cont.sensors[“AtTarget”]</code>
Om de code overzichtelijk te houden kun je verwijzingen maken naar de sensoren en actuatoren. Je mag deze namen zelf verzinnen of de volgende gebruiken:

<syntaxhighlight lang="Python">
import bge
cont = bge.logic.getCurrentController()
start = cont.sensors[“Start”]
collision = cont.sensors[“AtTarget”]

def main():
# define function main…

main()
</syntaxhighlight>

* Bij het indrukken van de ENTER key, willen we dat Morsy zijn taak uit gaat voeren. Zowel het indrukken als het loslaten van de ENTER key geeft een trigger aan de controller. Het indrukken is een positive pulse en loslaten een negative pulse. Via een boolean (met waarde TRUE of FALSE) wordt aangegeven of er een pulse gegeven wordt. We willen dat de main() alleen aangeroepen wordt als start.positive TRUE is. Omdat start.positive een boolean is kun je dit als volgt opschrijven:

<syntaxhighlight lang="Python">
if start.positive
main()
</syntaxhighlight>
(Let op: een Tab in Python staat gelijk aan 4 spaties en is nodig om aan te geven wat er moet gebeuren als de conditie van de if <code>TRUE</code> is)
* Zorg ervoor dat in de definitie van de functie <code>main() </code> de Steering actuator geactiveerd wordt en naar Shelf_8 toe gaat (de voorste kast). De code ziet er nu als volgt uit:

<syntaxhighlight lang="Python">
import bge

cont = bge.logic.getCurrentController()
start = cont.sensors[“Start”]
collision = cont.sensors[“AtTarget”]
steering - cont.actuators[“Steering”]

def main():
steering.target = “Shelf_8”
cont.activate(steering)

if start.positive:
main()
</syntaxhighlight>

=== Stap 4: Script afmaken ===
Wanneer je nu in de play modus gaat en op ENTER drukt zie je dat Morsy naar Shelf_8 gaat lopen.

In deze stap ga je zelf uitzoeken hoe Morsy heen en weer loopt naar de kast. Het is geen vereiste meer dat de ENTER key voor de start zorgt. Morsy mag gelijk van start gaan in de play modus. Denk zelf na hoe je dit moet doen.

Tips: je moet een Game Property aanmaken voor Desk_11, Shelf_8 en een voor Robot_11 om aan te geven waar hij heen moet lopen. Deze kun je aanroepen en veranderen via de variabele <code>cont.owner[“naam van game propery”]</code> . Ook moet je in de Collision sensor de Tap button aanklikken om maar 1 trigger te geven bij aanraking van de tafel of kast.

De Start sensor kun je veranderen in een Always sensors zodat Morsy gelijk begint met lopen.

Het is niet erg als je er zelf nog niet helemaal uit bent gekomen. Juist als het niet werkt zoals je wilt leer je hier meer van doordat je de verkeerde code moet herstellen. Wanneer je er niet uit komt kun je naar onderstaande uitwerking kijken:

<syntaxhighlight lang="Python">
import bge

def main():
print("main called")
cont = bge.logic.getCurrentController()
own = cont.owner

collision1 = cont.sensors['AtTarget']
steering = cont.actuators['Steering']

if collision1.positive:
print("Collision target=" + steering.target.name)
if steering.target.name == "Shelf_8":
steering.target = "Desk_11"
collision1.propName = "Desk"
else:
steering.target = "Shelf_8"
collision1.propName = "Shelf"
else:
print("no Collision")

cont.activate(steering)

main()
</syntaxhighlight>

Voor hulp zie: https://www.youtube.com/watch?v=y36ZGsFDA2E

plus: visualiseer pakket https://www.youtube.com/watch?v=wJYlWa5D0hc

Logistieke Robots/les 3

2014-12-17T16:10:09Z

Jacqueline: /* Controleren of Python werkt in Blender */

{{Zijbalk Logistieke Robots}}

== Morsy besturen met Python ==
In de vorige les hebben we gezien dat de controller van Morsy veel complexer wordt als we hem autonoom aan willen sturen. Wanneer we Morsy nog meer taken willen geven, en wanneer we Morsy in een groep willen laten werken, zijn de logic bricks niet meer toereikend. Daarom gaan we Blender combineren met de programmeertaal Python.

Controleer eerst of de juiste versie van Python op je systeem geïnstalleerd is, op de juiste plaats. (Zie: [[../Python installeren|Python installeren]] voor verdere aanwijzingen.) In sommige gevallen is Python geïnstalleerd als onderdeel van Blender.

== Blender combineren met programmeertaal Python ==
In deze les gebruiken we [https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/warehouse.blend warehouse.blend]. Deze omgeving zullen we gedurende de rest van het project gebruiken. Het openen van het bestand gaat nu anders omdat we de Python output willen zien. Dit is verschillend voor de Windows en voor de OS X versie van Blender.

=== OS X: Blender opstarten met Terminal ===

Ga naar de Blender applicatie en open de Package Contents van Blender.

[[Bestand:osx-show-package.png|350px|Show Package contents]]

Open vervolgens het blender executable bestand via het openen van de volgende folders: <code>Contents > MacOS > blender </code>

[[Bestand:osx-blender-terminal.png|700px|Blender starten met terminal]]

Als Blender opstart, kun je via <code>File>Open</code> het bestand “warehouse.blend” openen.

=== Windows: ===

Open Blender op de gebruikelijke manier. Ga naar de Info Window en klik op <code>Window >Toggle System Console</code>. Er is nu een extra scherm in beeld.

Wanneer je de file “warehouse.blend” geopend hebt, zie je in het window linksonder een Tekst Editor. Hier kun je een Python controller ontwikkelen.

=== Controleren of Python werkt in Blender ===

Om te testen of de link tussen Blender en Python werkt, voeren we de volgende stappen uit:
# Voeg aan Robot_11 (de voorste) een Always sensor toe.
# Maak een nieuw Python script aan:
## klik op de "+" onderin het Text Editor venster (naast de naam van het bestand).
## verander de naam van het bestand in "Text.py"
## typ in de Text Editor: <code>print(“Hello”)</code>
# Voeg aan Robot_11 een Python controller: [[Bestand:Les3-robot11-python-controller.png|350px|Voeg Python controller toe]]
# Selecteer als script voor deze Python-controller: "Text.py"
# Link de controller met de sensor: [[Bestand:Les3-robot11-sensor-controller.png|700px|Link sensor en controller]]
# Ga na de spel modus (of, voor OS X, naar de Terminal) en kijk naar de console. Dit moet er nu in de console te zien zijn:
<pre>
Blender Game Engine Started
Hello
Blender Game Engine Finished
</pre>

Voor hulp zie: https://www.youtube.com/watch?v=9dRd-pU2dKQ

== Ontwikkelen van een controller in Python ==

Nu je weet hoe je Python aan Blender moet koppelen, kunnen we een Python controller maken. We gaan Morsy, nu genaamd Robot_11, naar een kast laten lopen om een artikel op te halen en in de box te zetten op tafel. Voordat we hieraan kunnen beginnen moeten we begrijpen hoe je sensoren kunt opvangen en actuatoren kunt aansturen via een Python controller.

=== Morsy laten lopen door een Python controller ===

Wat je in deze paragraaf gaat leren lijkt op wat je geleerd hebt in les 2, het autonoom laten ophalen van objecten en naar een bepaald doel brengen, maar nu doen we dat via een Python controller.

==== Stap 1: Onderdelen van een script ====
Blender heeft al een opzet voor hoe je een robot moet aansturen. Ga in de Tekst editor window naar <code>Templates > Python> GameLogic Simple</code>. Je ziet nu de volgende code verschijnen:
<syntaxhighlight lang="Python" line>
import bge

def main():

cont = bge.logic.getCurrentController()
own = cont.owner

sens = cont.sensors['mySensor']
actu = cont.actuators['myActuator']

if sens.positive:
cont.activate(actu)
else:
cont.deactivate(actu)

main()
</syntaxhighlight>

Dit heet een script. Dit script bestaat uit verschillende onderdelen.
* (r. 1) <code>import bge</code> importeert de Blender Game Engine module voor Python. In deze module is onder andere de functie <code>logic.getCurrentController()</code> gedefinieerd.
* (r. 4-15) De definitie van de functie <code>main()</code>;
* (r. 17) Een aanroep van de functie <code>main()</code>: de opdrachten in de definitie daarvan worden uitgevoerd.

Het is belangrijk om te begrijpen hoe een script werkt. Wanneer deze controller geactiveerd wordt (bijvoorbeeld door een sensor), wordt het script uitgevoerd, en gebeurt er het volgende:
# <code>import bge</code> - Het script importeert de module ‘bge’ en beschikt zo over alle gedefinieerde functies in de bge module.
# <code>def main():</code> - definieert de functie main met de daarop volgende opdrachten.
# <code>main() </code> - aanroep van de functie main. De opdrachten in de definitie (“body”) van de functie main worden uitgevoerd.

=== Stap 2: Sensoren en actuatoren toevoegen ===
Als we op ENTER (ofwel Return) drukken willen we dat Morsy naar de voorste kast gaat lopen. Ga door de volgende stappen heen om de juiste sensors en actuators toe te voegen:
# Verander de Always sensor in een Keyboard sensor met als Key de ENTER knop. Geef deze sensor de naam ‘Start’
# Voeg een Steering actuator toe. Laat deze de naam ‘Steering’ houden en over de –X as bewegen.
# Voeg een Collission sensor genaamd ‘AtTarget’ toe link deze aan de Python controller.
Dit zijn alle actuators en sensors die we nodig hebben om de genoemde taak uit te voeren.

=== Stap 3: Triggers ontvangen en versturen door de Python controller ===
In de vorige lessen hadden we een sensor, bijvoorbeeld een Keyboard sensor, aan een And controller gekoppeld. Wanneer je de juiste toets aanraakt op je toetsenbord gaat er een positieve ‘trigger’ naar de And controller die de bijbehorende actuator activeert.

Nu moeten we de Start trigger op zien te vangen in de Python controller. Doe dit als volgt:

* Het script moet de ''controller'' kunnen aanroepen waar de sensoren en actuatoren aan gekoppeld zijn. Dit kan door de functie <code>bge.logic.getCurrentController()</code>
* Vervolgens moet de controller kunnen herkennen welke van de inkomende sensoren een trigger geeft om een juiste actuator aan te roepen. Je kunt deze sensoren vinden via <code>cont.sensors[“Start”]</code> en <code>cont.sensors[“AtTarget”]</code>
Om de code overzichtelijk te houden kun je verwijzingen maken naar de sensoren en actuatoren. Je mag deze namen zelf verzinnen of de volgende gebruiken:

<syntaxhighlight lang="Python">
import bge
cont = bge.logic.getCurrentController()
start = cont.sensors[“Start”]
collision = cont.sensors[“AtTarget”]

def main():
# define function main…

main()
</syntaxhighlight>

* Bij het indrukken van de ENTER key, willen we dat Morsy zijn taak uit gaat voeren. Zowel het indrukken als het loslaten van de ENTER key geeft een trigger aan de controller. Het indrukken is een positive pulse en loslaten een negative pulse. Via een boolean (met waarde TRUE of FALSE) wordt aangegeven of er een pulse gegeven wordt. We willen dat de main() alleen aangeroepen wordt als start.positive TRUE is. Omdat start.positive een boolean is kun je dit als volgt opschrijven:

<syntaxhighlight lang="Python">
if start.positive
main()
</syntaxhighlight>
(Let op: een Tab in Python staat gelijk aan 4 spaties en is nodig om aan te geven wat er moet gebeuren als de conditie van de if <code>TRUE</code> is)
* Zorg ervoor dat in de definitie van de functie <code>main() </code> de Steering actuator geactiveerd wordt en naar Shelf_8 toe gaat (de voorste kast). De code ziet er nu als volgt uit:

<syntaxhighlight lang="Python">
import bge

cont = bge.logic.getCurrentController()
start = cont.sensors[“Start”]
collision = cont.sensors[“AtTarget”]
steering - cont.actuators[“Steering”]

def main():
steering.target = “Shelf_8”
cont.activate(steering)

if start.positive:
main()
</syntaxhighlight>

=== Stap 4: Script afmaken ===
Wanneer je nu in de play modus gaat en op ENTER drukt zie je dat Morsy naar Shelf_8 gaat lopen.

In deze stap ga je zelf uitzoeken hoe Morsy heen en weer loopt naar de kast. Het is geen vereiste meer dat de ENTER key voor de start zorgt. Morsy mag gelijk van start gaan in de play modus. Denk zelf na hoe je dit moet doen.

Tips: je moet een Game Property aanmaken voor Desk_11, Shelf_8 en een voor Robot_11 om aan te geven waar hij heen moet lopen. Deze kun je aanroepen en veranderen via de variabele <code>cont.owner[“naam van game propery”]</code> . Ook moet je in de Collision sensor de Tap button aanklikken om maar 1 trigger te geven bij aanraking van de tafel of kast.

De Start sensor kun je veranderen in een Always sensors zodat Morsy gelijk begint met lopen.

Het is niet erg als je er zelf nog niet helemaal uit bent gekomen. Juist als het niet werkt zoals je wilt leer je hier meer van doordat je de verkeerde code moet herstellen. Wanneer je er niet uit komt kun je naar onderstaande uitwerking kijken:

<syntaxhighlight lang="Python">
import bge

def main():
print("main called")
cont = bge.logic.getCurrentController()
own = cont.owner

collision1 = cont.sensors['AtTarget']
steering = cont.actuators['Steering']

if collision1.positive:
print("Collision target=" + steering.target.name)
if steering.target.name == "Shelf_8":
steering.target = "Desk_11"
collision1.propName = "Desk"
else:
steering.target = "Shelf_8"
collision1.propName = "Shelf"
else:
print("no Collision")

cont.activate(steering)

main()
</syntaxhighlight>

Voor hulp zie: https://www.youtube.com/watch?v=y36ZGsFDA2E

Logistieke Robots/les 6

2014-12-17T16:09:27Z

Jacqueline: /* Hervat les 6 - Robots van elkaar laten leren */

{{Zijbalk Logistieke Robots}}

==Les 6 - Robots van elkaar laten leren ==
Voordat we naar les 6 gaan, bespreken we een aantal verbeteringen in de huidige code zodat we er vervolgens makkelijker mee kunnen werken. Deze verandering moet je ook doorvoeren als je door wilt werken met je huidige bestand. Je mag ook les 6 starten met de file "warehouse_team_collission.blend".

==Verbetering code na les 5 ==
We gaan een functie set_articles() maken zodat er een array aangemaakt
wordt met de artikelen.

<syntaxhighlight lang="Python" line>
def get_order():
# get articles from central controller
set_articles()
print(robot["articles"])
# set game properties
robot["article_number"] = 1
robot["target_desk"] = False
# distance variables
robot["distance"] = 0.0
robot["location1"] = robot.position[0]
robot["location2"] = robot.position[1]
robot["location3"] = robot.position[2]
</syntaxhighlight>

Vervang ook de declaratie van robot[“robot_id”] door onderstaande. De central controller hoeft zo niet meer te vertellen om welke robot het gaat.

<syntaxhighlight lang="Python" line>
# get the current controller
cont = bge.logic.getCurrentController()
robot = cont.owner
robot["robot_id"] = robot.name[6:]
</syntaxhighlight>

De functie set_articles() ziet er als volgt uit:

<syntaxhighlight lang="Python" line>
def set_articles():
message = start_sens.bodies[0][1:]
order_length = len(re.findall(r'[^\s ]+', message))
robot["articles"] = [""]*order_length
for i in range(order_length):
robot["articles"][i] = re.findall(r'[^\s ]+', message)[i]
</syntaxhighlight>

De main() functie ziet er nu overzichtelijker uit:

<syntaxhighlight lang="Python" line>
def main():
if robot["target_desk"] == False:
shelf_sens.propName = "Shelf"
if robot["article_number"] <= len(robot["articles"]):
track_act.target = robot["articles"][robot["article_number"]-1]
else:
shelf_sens.propName = "Desk"
track_act.target = "Desk_" + str(robot["robot_id"])
if shelf_sens.positive:
if robot["target_desk"] == True:
robot["article_number"] += 1
if robot["article_number"] == len(robot["articles"]) +1:
cont.deactivate(track_act)
print("done robot "+ str(robot["robot_id"]))
GameLogic.sendMessage("Done", robot["robot_id"] , "Ground", "")
GameLogic.sendMessage("Done", str(robot["distance"]) , "Ground", "")
robot["target_desk"]= not robot["target_desk"]
</syntaxhighlight>

We veranderen ook de physics van de robot zodat de robot niet om kan vallen. Ga op de robot staan en ga in het rechter window naar:

[[Bestand:balk_physics.png]]

Verander dan de form factor in 0.0:

[[Bestand:form_factor.png]]

Doe dit voor beide robots.

==Hervat les 6 - Robots van elkaar laten leren ==
Nu we weten hoe we een team aan kunnen sturen en we weten dat er efficiëntie winst te bepalen viel, willen we dit natuurlijk op grote schaal toepassen. Wanneer we meer teams in gaan zetten lopen we wel tegen het probleem aan dat ze elkaar voor de voeten kunnen lopen. Dit probleem gaan we ontdekken en een manier vinden om dit op te lossen.
We kunnen zo’n “botsingen probleem” op 2 manieren op lossen. We kunnen de robot vertellen wat hij moet doen of we kunnen de robot een manier aangeven waardoor de robot zelf kan leren wat een optimaal ontwijkingsmechanisme is. De robots worden nu zelf lerend. Dit laatste is natuurlijk veel leuker en daarom gaan we dat doen.
Het eindresultaat kun je zien op https://www.youtube.com/watch?v=LwOjSqbDy0g

==Observeren van botsingen==
Open het bestand “warehouse_team_collission.blend” en voeg hier nog twee Morsy robots aan toe op dezelfde manier als in les 5 met de namen Robot_9 en Robot_8.
De centrale controller moet ook veranderd worden omdat we nu twee teams hebben. Doe daarvoor de volgende aanpassingen:

<syntaxhighlight lang="Python" line>
if sens.positive:
robot_team = ["10","11"]
central["active_robots"] = [0,0,0,0,0,0,0,0,0,0,0]
central["distance"] =0
central["time"] = 0.0
Send_order(robot_team)
</syntaxhighlight>

<syntaxhighlight lang="Python" line>
if message.positive:
central["active_robots"][int(message.bodies[0])-1]=0
central["distance"] += float(message.bodies[1])
if central["boxes_done"] < central["boxes_tot"]-1 and central["active_robots"][10-1]+central["active_robots"][11-1]==0:
central["boxes_done"] +=1
print("number of boxes done:")
print(central["boxes_done"])
Send_order(["10","11"])
if central["boxes_done"] < central["boxes_tot"]-1 and central["active_robots"][9-1]+central["active_robots"][8-1]==0:
central["boxes_done"] +=1
print("number of boxes done:")
print(central["boxes_done"])
Send_order(["8","9"])
if sum(central["active_robots"]) == 0:
print("Total walked distance:")
print(central["distance"])
print(central["time"])
</syntaxhighlight>

Wanneer je nu de robots de orders laat verzamelen zie je dat de paden van de robots elkaar kunnen kruizen. Wanneer ze elkaar tegemoet lopen reageren ze niet op elkaar en botsen ze dus tegen elkaar op. Omdat ze allebei naar voren bewegen, komen ze allebei niet voorruit. We kunnen, zoals eerder genoemd, nu twee aanpakken kiezen om hier mee om te gaan:
# We kunnen gedragsregels opstellen voor de robots. De robots weten dat wanneer ze een artikel opgehaald hebben, ze weer terug naar tafel moeten en op deze manier kunnen we ze ook vertellen wat ze moeten doen als ze een andere robot zien. Bijvoorbeeld: doe altijd een stap naar links als je dicht bij een andere robot bent.
# We kunnen de robots ook een methode geven om van elkaar te leren hoe ze om moeten gaan met elkaar. Dit kun je doen als je zelf ook niet precies weet hoe de robots zich moeten gedragen. Deze methode die we hiervoor kunnen gebruiken heet een evolutionair algoritme. Voor een voorbeeld kun je kijken op : https://www.youtube.com/watch?v=AnuLXVp-Zf0. In dit filmpje zie je een e-puck robot aan het leren om obstakels te ontwijken. Dit is ook wat wij willen bereiken.
We kiezen voor algoritme 2 om te laten zien hoe je een robot van slimme kennis voorziet.

== Kunnen reageren op andere robots ==
We gaan er in deze paragraaf voor zorgen dat de robots elkaar kunnen herkennen en op elkaar kunnen reageren. Hiervoor moeten we veranderingen doorvoeren in de opzet van het pakhuis en veranderingen doorvoeren in de controller van de robot.

===Veranderen pakhuis omgeving===
Omdat we de controller van de robot gaan veranderen, mag je robot 9, 10 en 11 weer verwijderen. En de volgende stappen uitvoeren:

'''Stap 1:'''
Voeg aan de robot een string game property toe met de naam “Robot”. Dit is om elkaar te kunnen herkennen met een Radar

'''Stap 2:'''
Zet de Physics Type op Character en vink de box Actor aan:

[[Bestand: balk_actor.png]]

[[Bestand: set_as_actor.png]]

'''Stap 3:'''
Omdat we de robots nu niet meer helemaal kunnen controleren, ze kunnen immers afwijken van de directe route tussen de tafel en de kast, moeten we het pakhuis iets veranderen. Verander de physics van de kasten op de volgende manier:

[[Bestand: change_physics.png]]

Creëer extra wanden door de bestaande wanden te kopiëren, te verplaatsen en om hun as te draaien zodat we er doorheen kunnen blijven kijken. Verwijder Desk 1 t/m Desk 5 en verdeel Desk 6 t/m Desk 11 over de ruimte. De arena ziet er nu als volgt uit, waarbij er bij jou maar 1 robot staat bij Desk 8:

[[Bestand: nieuwe_arena.png]]

===Veranderen robot controller ===
De robots moeten elkaar nu herkennen, hier op reageren en vervolgens weer doorgaan met het ophalen van artikelen. We moeten veel gaan veranderen aan de controller. We nemen dit stap voor stap door:

'''Stap 1:'''
We hebben een extra Radar nodig om een ontwijkactie te starten en we moeten kunnen meten of de robot een goede actie gedaan heeft. Dit doen we met een collission sensor. De always sensor is nodig om de taak weer op te pakken na de ontwijkactie:
[[Bestand: add_radar.png]]

'''Stap 2:'''
De ontwijkactie houdt in dat de robot, na het detecteren van een andere robot, een aantal seconden rondjes draait, weg loopt van de robot en daarna zijn taak weer oppakt. Dit definiëren we in een extra state:
[[Bestand: add_state.png]]

'''Stap 3:'''
Voeg extra game properties toe:
[[Bestand: add_game_property.png]]

'''Stap 4:'''
Het script moet ook onder handen genomen worden. Er moet een extra package geïmporteerd worden omdat we de robot een willekeurige waarde geven voor het draaien om zijn eigen as en het weglopen van de radar locatie:

<syntaxhighlight lang="Python" line>
# import necessary packages
import bge
import GameLogic
import re
import random
</syntaxhighlight>

De extra sensors moeten gedefinieerd worden:

<syntaxhighlight lang="Python" line>
# get sensors and actuators
start_sens = cont.sensors["Start"]
shelf_sens = cont.sensors["Shelf"]
track_act = cont.actuators["TrackTo"]
robot_radar = cont.sensors["RobotRadar"]
robot_collission = cont.sensors["RobotCollission"]
</syntaxhighlight>

Wanneer de robot voor de eerste keer begint met de order, worden de parameters gedefinieerd die te maken hebben met het ontwijken van de andere robot:

<syntaxhighlight lang="Python" line>
if start_sens.positive:
cont.activate(track_act)
print("Start new order:")
get_order()
# set avoidance parameters and evaluation variables
print("begin")
if robot["active"] == False:
robot["sec_rot"] = random.uniform(0,2)
robot["sec_walk"] = random.uniform(0,2)
robot["active"] =True
</syntaxhighlight>

Wanneer een robot iemand op de radar heeft, moet de robot de ontwijkactie uit gaan voeren in de andere state. Ook moet bijgehouden worden of de robot alsnog tegen een ander aan stoot. Wanneer de robot een slechte ontwijkactie heeft en vaak tegen iemand op botst, willen we dat deze robot een nieuwe ontwijkreactie krijgt. Dit noemen we een “reset”. Dit is nodig als de robot ergens vast zit:

<syntaxhighlight lang="Python" line>
if robot_radar.positive == True:
cont.deactivate(track_act)
robot["radar"] +=1
robot["time"] = 0.0
robot.state = 2

if robot_collission.positive:
robot["collission"] +=1

if robot["collission"] >=20:
#reset parameters because its stuck
robot["sec_rot"] = random.uniform(0,2)
robot["sec_walk"] = random.uniform(0,2)
</syntaxhighlight>

In de extra state hebben we gezien dat er nog een “avoiding.py” gemaakt moet worden. Deze ziet er als volgt uit:

<syntaxhighlight lang="Python" line>
# import necessary packages
import bge
import GameLogic
import re

# get the current controller
cont = bge.logic.getCurrentController()
robot = cont.owner
robot["robot_id"] = robot.name[6:]

# get sensors and actuators
rot_act = cont.actuators["Rotate"]
walk_act = cont.actuators["Walk"]
robot_collission2 = cont.sensors["RobotCollission2"]
robot_radar2 = cont.sensors["RobotRadar2"]

robot["time"] += 1/60

if robot["time"] < robot["sec_rot"]:
cont.activate(rot_act)

if robot["time"] > robot["sec_rot"] and robot["time"] < (robot["sec_rot"] + robot["sec_walk"]):
cont.deactivate(rot_act)
cont.activate(walk_act)

if robot["time"] > (robot["sec_rot"] + robot["sec_walk"]):
robot.state =1

if robot_collission2.positive:
robot["collission"] +=1

if robot_radar2.positive:
robot["radar"] +=1
robot["time"] = 0.0
</syntaxhighlight>

Wanneer je de robots nu laat starten met het ophalen van bestellingen, zie je dat ze op elkaar reageren en hun ontwijkactie uitvoeren. De acties die ze uitvoeren zijn hetzelfde maar hoelang ze deze actie uit voeren kan verschillen. Sommige robots zullen beter kunnen ontwijken en sneller door kunnen gaan met hun bestelling dan andere robots. De robots die een goede ontwijkstrategie hebben kunnen hun strategie doorgeven aan de andere robots.

==Optimaliseren van reactie==
Wanneer de robots met hun eigen ontwijkingsstrategie orders gaan verzamelen, zul je verschillen zien in de aanpak. De ene robot draait lang een rondje terwijl de andere robot bijna gelijk weer verder gaat met de bestelling. Je wilt dat de robots van elkaar leren en de beste strategieën nadoen zodat ze totaal zo min mogelijk botsen. Botsen kan er namelijk voor zorgen dat de robot kapot gaat of dat een artikel op de grond valt.
Omdat we 6 robots hebben beginnen we met 6 verschillende strategieën (ieder tweetal met het aantal seconden rondjes draaien en rechtdoor lopen is een strategie). Na een bepaalde tijd moeten we weten hoe goed de strategie van iedere robot is zodat de goede robots dit door kunnen geven aan de andere robots.
Het uitwisselen van deze informatie en het veranderen van de strategie gebeurd in de centrale controller op de volgende manier:

'''Stap 1:'''
Importeer extra package numpy:

<syntaxhighlight lang="Python" line>
# import necessary packages
import bge
import GameLogic
import random
import numpy
</syntaxhighlight>

'''Stap 2:'''
Voeg een extra team toe met robot 6 en 7. Je weet van de vorige les al hoe dit moet.

'''Stap 3:'''
Voeg een extra tijd meting toe om de strategieën te kunnen updaten:
<syntaxhighlight lang="Python" line>
central["time"]+= 1/60
central["time_minute"]+= 1/60
</syntaxhighlight>

'''Stap 4:'''
Per minuut gaan we de strategieën van de robots herzien en veranderen op de volgende manier:
<syntaxhighlight lang="Python" line>
if central["time_minute"] >=60:
central["time_minute"] = 0
robots = ["Robot_6", "Robot_7", "Robot_8", "Robot_9", "Robot_10", "Robot_11"]
result = [[0,0,0,""] for i in range(len(robots))]
alg_result = 0
for i in range(len(robots)):
robot = scene.objects[robots[i]]
result[i][0] = robot["collission"]
result[i][1] = robot["sec_rot"]
result[i][2] = robot["sec_walk"]
result[i][3] = robot
alg_result += robot["collission"]
robot["collission"] = 0
robot["radar"]=0
central["algorithm"].append(alg_result)
# print number of collissions per minute
print(central["algorithm"])
result = sorted(result, key=lambda a_entry: a_entry[0])
print(result)
print("Total walked distance:")
print(central["distance"])
print(central["time"])
# update values
for i in range(len(robots)):
robot = scene.objects[robots[i]]
take_from = random.choice([0,1])
robot["sec_rot"] = max(0,result[take_from][1] + random.gauss(0, 0.1))
robot["sec_walk"] = max(0,result[take_from][2] + random.gauss(0, 0.1))
</syntaxhighlight>

Wat we in deze functie doen is het evalueren van de prestatie van de robots. Met prestatie bedoelen we het aantal keer opbotsen tegen de andere robots. Hoe minder dit gebeurd, hoe beter. Voor iedere robot wordt dit aantal opgeslagen samen met de twee waarden die hiervoor zorgden. Deze prestatie wordt opgeteld bij het algehele resultaat van de groep en de waarden worden weer op 0 gezet voor de volgende minuut.
Vervolgens worden de strategieën van de robots aangepast. We nemen de strategieën van de 2 beste robots, de robots met het minste aantal botsingen, om door te geven aan de anderen. Op deze waarden passen we nog een kleine variatie toe om te kijken of we in de volgende minuut nog een betere strategie tegen gaan komen. Zo kunnen de robots blijven leren.

==Experimenten==
Wanneer je de robots nu aan het werk zet zie je per minuut een update van de prestatie van het algoritme uitgeprint in de Terminal. Het is moeilijk te analyseren of deze methode echt werkt als je alleen naar deze geprinte waarden. Je kan de robots aan het werk zetten en een aantal boxen laten vullen en deze cijfers in de gaten houden maar je kan er pas echt wat over zeggen als je een goed experiment uitvoert. Dit gaan we doen in Les 7.

==Plusopdracht==
Denk alvast na over hoe je kan testen of dit algoritme werkt.

Logistieke Robots/les 3

2014-12-17T16:08:00Z

Jacqueline: /* Stap 4: Script afmaken */

{{Zijbalk Logistieke Robots}}

== Morsy besturen met Python ==
In de vorige les hebben we gezien dat de controller van Morsy veel complexer wordt als we hem autonoom aan willen sturen. Wanneer we Morsy nog meer taken willen geven, en wanneer we Morsy in een groep willen laten werken, zijn de logic bricks niet meer toereikend. Daarom gaan we Blender combineren met de programmeertaal Python.

Controleer eerst of de juiste versie van Python op je systeem geïnstalleerd is, op de juiste plaats. (Zie: [[../Python installeren|Python installeren]] voor verdere aanwijzingen.) In sommige gevallen is Python geïnstalleerd als onderdeel van Blender.

== Blender combineren met programmeertaal Python ==
In deze les gebruiken we [https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/warehouse.blend warehouse.blend]. Deze omgeving zullen we gedurende de rest van het project gebruiken. Het openen van het bestand gaat nu anders omdat we de Python output willen zien. Dit is verschillend voor de Windows en voor de OS X versie van Blender.

=== OS X: Blender opstarten met Terminal ===

Ga naar de Blender applicatie en open de Package Contents van Blender.

[[Bestand:osx-show-package.png|350px|Show Package contents]]

Open vervolgens het blender executable bestand via het openen van de volgende folders: <code>Contents > MacOS > blender </code>

[[Bestand:osx-blender-terminal.png|700px|Blender starten met terminal]]

Als Blender opstart, kun je via <code>File>Open</code> het bestand “warehouse.blend” openen.

=== Windows: ===

Open Blender op de gebruikelijke manier. Ga naar de Info Window en klik op <code>Window >Toggle System Console</code>. Er is nu een extra scherm in beeld.

Wanneer je de file “warehouse.blend” geopend hebt, zie je in het window linksonder een Tekst Editor. Hier kun je een Python controller ontwikkelen.

=== Controleren of Python werkt in Blender ===

Om te testen of de link tussen Blender en Python werkt, voeren we de volgende stappen uit:
# Voeg aan Robot_11 (de voorste) een Always sensor toe.
# Maak een nieuw Python script aan:
## klik op de "+" onderin het Text Editor venster (naast de naam van het bestand).
## verander de naam van het bestand in "Text.py"
## typ in de Text Editor: <code>print(“Hello”)</code>
# Voeg aan Robot_11 een Python controller: [[Bestand:Les3-robot11-python-controller.png|350px|Voeg Python controller toe]]
# Selecteer als script voor deze Python-controller: "Text.py"
# Link de controller met de sensor: [[Bestand:Les3-robot11-sensor-controller.png|700px|Link sensor en controller]]
# Ga na de spel modus (of, voor OS X, naar de Terminal) en kijk naar de console. Dit moet er nu in de console te zien zijn:
<pre>
Blender Game Engine Started
Hello
Blender Game Engine Finished
</pre>

== Ontwikkelen van een controller in Python ==

Nu je weet hoe je Python aan Blender moet koppelen, kunnen we een Python controller maken. We gaan Morsy, nu genaamd Robot_11, naar een kast laten lopen om een artikel op te halen en in de box te zetten op tafel. Voordat we hieraan kunnen beginnen moeten we begrijpen hoe je sensoren kunt opvangen en actuatoren kunt aansturen via een Python controller.

=== Morsy laten lopen door een Python controller ===

Wat je in deze paragraaf gaat leren lijkt op wat je geleerd hebt in les 2, het autonoom laten ophalen van objecten en naar een bepaald doel brengen, maar nu doen we dat via een Python controller.

==== Stap 1: Onderdelen van een script ====
Blender heeft al een opzet voor hoe je een robot moet aansturen. Ga in de Tekst editor window naar <code>Templates > Python> GameLogic Simple</code>. Je ziet nu de volgende code verschijnen:
<syntaxhighlight lang="Python" line>
import bge

def main():

cont = bge.logic.getCurrentController()
own = cont.owner

sens = cont.sensors['mySensor']
actu = cont.actuators['myActuator']

if sens.positive:
cont.activate(actu)
else:
cont.deactivate(actu)

main()
</syntaxhighlight>

Dit heet een script. Dit script bestaat uit verschillende onderdelen.
* (r. 1) <code>import bge</code> importeert de Blender Game Engine module voor Python. In deze module is onder andere de functie <code>logic.getCurrentController()</code> gedefinieerd.
* (r. 4-15) De definitie van de functie <code>main()</code>;
* (r. 17) Een aanroep van de functie <code>main()</code>: de opdrachten in de definitie daarvan worden uitgevoerd.

Het is belangrijk om te begrijpen hoe een script werkt. Wanneer deze controller geactiveerd wordt (bijvoorbeeld door een sensor), wordt het script uitgevoerd, en gebeurt er het volgende:
# <code>import bge</code> - Het script importeert de module ‘bge’ en beschikt zo over alle gedefinieerde functies in de bge module.
# <code>def main():</code> - definieert de functie main met de daarop volgende opdrachten.
# <code>main() </code> - aanroep van de functie main. De opdrachten in de definitie (“body”) van de functie main worden uitgevoerd.

=== Stap 2: Sensoren en actuatoren toevoegen ===
Als we op ENTER (ofwel Return) drukken willen we dat Morsy naar de voorste kast gaat lopen. Ga door de volgende stappen heen om de juiste sensors en actuators toe te voegen:
# Verander de Always sensor in een Keyboard sensor met als Key de ENTER knop. Geef deze sensor de naam ‘Start’
# Voeg een Steering actuator toe. Laat deze de naam ‘Steering’ houden en over de –X as bewegen.
# Voeg een Collission sensor genaamd ‘AtTarget’ toe link deze aan de Python controller.
Dit zijn alle actuators en sensors die we nodig hebben om de genoemde taak uit te voeren.

=== Stap 3: Triggers ontvangen en versturen door de Python controller ===
In de vorige lessen hadden we een sensor, bijvoorbeeld een Keyboard sensor, aan een And controller gekoppeld. Wanneer je de juiste toets aanraakt op je toetsenbord gaat er een positieve ‘trigger’ naar de And controller die de bijbehorende actuator activeert.

Nu moeten we de Start trigger op zien te vangen in de Python controller. Doe dit als volgt:

* Het script moet de ''controller'' kunnen aanroepen waar de sensoren en actuatoren aan gekoppeld zijn. Dit kan door de functie <code>bge.logic.getCurrentController()</code>
* Vervolgens moet de controller kunnen herkennen welke van de inkomende sensoren een trigger geeft om een juiste actuator aan te roepen. Je kunt deze sensoren vinden via <code>cont.sensors[“Start”]</code> en <code>cont.sensors[“AtTarget”]</code>
Om de code overzichtelijk te houden kun je verwijzingen maken naar de sensoren en actuatoren. Je mag deze namen zelf verzinnen of de volgende gebruiken:

<syntaxhighlight lang="Python">
import bge
cont = bge.logic.getCurrentController()
start = cont.sensors[“Start”]
collision = cont.sensors[“AtTarget”]

def main():
# define function main…

main()
</syntaxhighlight>

* Bij het indrukken van de ENTER key, willen we dat Morsy zijn taak uit gaat voeren. Zowel het indrukken als het loslaten van de ENTER key geeft een trigger aan de controller. Het indrukken is een positive pulse en loslaten een negative pulse. Via een boolean (met waarde TRUE of FALSE) wordt aangegeven of er een pulse gegeven wordt. We willen dat de main() alleen aangeroepen wordt als start.positive TRUE is. Omdat start.positive een boolean is kun je dit als volgt opschrijven:

<syntaxhighlight lang="Python">
if start.positive
main()
</syntaxhighlight>
(Let op: een Tab in Python staat gelijk aan 4 spaties en is nodig om aan te geven wat er moet gebeuren als de conditie van de if <code>TRUE</code> is)
* Zorg ervoor dat in de definitie van de functie <code>main() </code> de Steering actuator geactiveerd wordt en naar Shelf_8 toe gaat (de voorste kast). De code ziet er nu als volgt uit:

<syntaxhighlight lang="Python">
import bge

cont = bge.logic.getCurrentController()
start = cont.sensors[“Start”]
collision = cont.sensors[“AtTarget”]
steering - cont.actuators[“Steering”]

def main():
steering.target = “Shelf_8”
cont.activate(steering)

if start.positive:
main()
</syntaxhighlight>

=== Stap 4: Script afmaken ===
Wanneer je nu in de play modus gaat en op ENTER drukt zie je dat Morsy naar Shelf_8 gaat lopen.

In deze stap ga je zelf uitzoeken hoe Morsy heen en weer loopt naar de kast. Het is geen vereiste meer dat de ENTER key voor de start zorgt. Morsy mag gelijk van start gaan in de play modus. Denk zelf na hoe je dit moet doen.

Tips: je moet een Game Property aanmaken voor Desk_11, Shelf_8 en een voor Robot_11 om aan te geven waar hij heen moet lopen. Deze kun je aanroepen en veranderen via de variabele <code>cont.owner[“naam van game propery”]</code> . Ook moet je in de Collision sensor de Tap button aanklikken om maar 1 trigger te geven bij aanraking van de tafel of kast.

De Start sensor kun je veranderen in een Always sensors zodat Morsy gelijk begint met lopen.

Het is niet erg als je er zelf nog niet helemaal uit bent gekomen. Juist als het niet werkt zoals je wilt leer je hier meer van doordat je de verkeerde code moet herstellen. Wanneer je er niet uit komt kun je naar onderstaande uitwerking kijken:

<syntaxhighlight lang="Python">
import bge

def main():
print("main called")
cont = bge.logic.getCurrentController()
own = cont.owner

collision1 = cont.sensors['AtTarget']
steering = cont.actuators['Steering']

if collision1.positive:
print("Collision target=" + steering.target.name)
if steering.target.name == "Shelf_8":
steering.target = "Desk_11"
collision1.propName = "Desk"
else:
steering.target = "Shelf_8"
collision1.propName = "Shelf"
else:
print("no Collision")

cont.activate(steering)

main()
</syntaxhighlight>

Voor hulp zie: https://www.youtube.com/watch?v=y36ZGsFDA2E

Logistieke Robots/les 2

2014-12-17T16:07:03Z

Jacqueline: /* Uiteindelijk resultaat */

{{Zijbalk Logistieke Robots}}

== Les 2 - Objecten zoeken en verplaatsen ==

In dit project willen we robots toepassen in de logistieke sector. Wanneer robots actief zijn in de logistieke sector betekent dit vaak dat robots bepaalde objecten moeten zoeken, oppakken en naar een doel moeten brengen. Hoe we een robot moeten aansturen die dit kan gaan we zien in deze les.

Voor deze les maken we gebruik van het bestand [https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/living_room.blend living_room.blend]. Wanneer je het bestand opent zie je een huiskamer en een aantal boeken die rondslingeren in de kamer. We willen dat de robot de boeken kan herkennen, er naar toe kan lopen, op kan pakken en in de boekenkast kan zetten. In paragraaf 1 zullen we de robot aansturen via het toetsenbord en in paragraaf 2 laten we de robot deze taak autonoom (=zelfstandig) uitvoeren.

== Object naar het doel verplaatsten met het toetsenbord ==
Aan de hand van 5 stappen kunnen we de controller gaan maken. Zorg ervoor dat je eerst zelf nadenkt over de stappen die je uit moet voeren voordat je naar de print kijkt hoe de controller eruit moet zien.

=== Stap 1: Naar het boek lopen ===
Wanneer je op Morsy klikt, zie je in de logic editor dat er vier Keyboard sensors aangemaakt zijn. Hier kunnen we Morsy mee naar een boek laten lopen. Als je goed kijkt zie je ook dat er een Game Property aangemaakt is met de naam Morsy. Zo kunnen andere objecten Morsy herkennen. Waarom dit nodig is zien we later.

=== Stap 2: Boek vastpakken ===
Omdat Morsy geen armen heeft kan hij het boek niet vasthouden zoals wij dat zouden doen met onze handen. Morsy kan wel naar het boek lopen en wanneer hij contact heeft met het boek kun je je voorstellen dat het boek vast zit aan Morsy door middel van een magneet. Dit kunnen we als volgt doen:
Ga naar de controller van book_blue_ground en voeg een Collision sensor toe. Geef bij Property aan dat het om Morsy gaat.
Voeg een Parent actuator toe waarbij je bij Parent Object Morsy selecteert. Verbind de twee met elkaar. Er komt dan automatisch een And controller tussen.
Wanneer je nu in de spelmodus gaat (druk op P) en naar het blauwe boek loopt, zie je dat het blauwe boek vast blijft zitten aan Morsy. De controller ziet er als volgt uit:

[[Bestand:Les2-book-controller.png|700px]]

=== Stap 3: Naar het doel lopen ===
Het doel, de kast waar de drie dezelfde boeken wel in de kast staan, kan bereikt worden door middel van het toetsenbord.
Wanneer Morsy met het boek bij de kast is wil je dat het boek in de kast komt te staan. Het visualiseren van deze actie is niet een van de leerdoelen van dit project. Uiteraard mag je Morsy voorzien van een grijparm en visualiseren hoe Morsy het boek in de kast zet maar dit zal veel tijd in beslag nemen. Daarom gebruiken we een eenvoudiger methode.

=== Stap 4: Boek in de kast plaatsen ===
Wanneer Morsy de kast bereikt met een boek, wil je dat dit boek verdwijnt en dat het boek in de kast zichtbaar wordt. Voordat Morsy kan herkennen of er aanraking plaatsvindt met de kast, moet de kast een Game Property hebben.

==== Voeg kast-game property "Goal" toe ====
Selecteer de kast en voeg een ‘String’ Game Property toe aan de kast met de naam ‘Goal’:
[[Bestand:Les2-stap4-goal.png|700px|Add property: Goal]]

==== Voeg Morsy-sensoren en actuatoren toe ====

Selecteer nu weer Morsy en voeg een Collision sensor toe en twee Message actuatoren naar het blauwe boek op de grond en in de kast met als Subject ‘Done’:
[[Bestand:Les2-stap4-done.png|700px|Add message actuators: Done]]

==== Boek op de grond wordt opgepakt (onzichtbaar) ====
Zorg ervoor dat het blauwe boek op de grond het bericht kan ontvangen en hierna onzichtbaar wordt:
[[Bestand:Les2-stap4-book.png|700px|Boek wordt onzichtbaar]]

==== Boek in de kast wordt zichtbaar ====
Zorg er ook voor dat het boek in de kast vanaf het begin onzichtbaar is
totdat deze het bericht ‘Done’ krijgt van Morsy. Neem zelf even de tijd om te bedenken hoe dit moet.
[[Bestand:Les2-stap4-shelf.png|700px|Boek wordt in kast zichtbaar]]

=== Uiteindelijk resultaat ===
Het kan er uiteindelijk als volgt uit zien:

[[Bestand:Les2-stap5-afronden.png|500px|Morsy verplaatst het boek]]
Voor hulp zie: https://www.youtube.com/watch?v=nEgubbYwRy0

Wanneer je zelf andere sensoren en actuatoren gebruikt die hetzelfde resultaat als gevolg hebben, mag dit ook.

== Object herkennen met een radar ==

In deze paragraaf leren we hoe Morsy zelf naar de boeken kan lopen zonder aansturing via het toetsenbord.
Hiervoor moet Morsy tussen verschillende States (toestanden) kunnen schakelen. Morsy moet eerst de kamer afzoeken naar de boeken. Wanneer Morsy een boek gevonden heeft moet hij hier naartoe lopen en erna mogelijk weer verder zoeken om vervolgens de boeken bij de kast af te leveren.

We gebruiken de volgende toestanden (states):
* 1: zoeken naar boek 1 (met een radar-sensor), bewegen naar het boek, en oppakken van het boek
* 2: oppakken van boek 1 en in de kast plaatsen
* 3: zoeken naar boek 2
* 4: oppakken van boek 4
* 5: loop naar de kast en plaats de boeken daarin

=== Stap 1: Opzetten ===
In de vorige paragraaf konden wij de boeken zien liggen en Morsy erheen sturen via het toetsenbord. Nu willen we dat Morsy zelf de boeken kan vinden. Geef de boeken die op de grond liggen de Game Property ‘book_1’ en ‘book_2’ en verwijder alle sensorsen en actuators van Morsy.

=== Stap 2: Boeken detecteren ===
We gaan Morsy voorzien van verschillende Radars die de boeken kunnen detecteren. We voegen eerst een radar toe voor <code>book_1</code>
* Om de boeken te kunnen zien met de Radars moet Morsy rondjes draaien. Voeg een Always sensor toe die een Motion actuator activeert waarbij je 2 graden om de Z as beweegt.
** controleer of deze werkt;
* Voeg een Radar sensor toe met Property <code>book_1</code>, over de –X as (<code>-X axis</code>), een hoek (<code>Angle</code>) van 50 graden en een afstand (<code>Distance</code>) van 8 meter.
** Om de radar te kunnen zien in de 3D view, kun je in de info window van Blender drukken op <code>Game > Show Physics Visualization</code>. Wanneer je nu naar de spel modus gaat kun je de radar zien. Je kunt de Physics Visualization hierna weer uitzetten.

=== Stap 3: Boeken ophalen in verschillende states ===
* Voeg aan Morsy een Integer Game Property toe genaamd ‘number’. Dit is het aantal boeken dat Morsy opgepakt heeft. We laten Morsy de boeken in een speciale volgorde ophalen. Dit is nodig wanneer je met de logic bricks werkt. In de volgende les zien we dat het met Python sneller kan. Wanneer de radar het boek ziet met property <code>book_1</code> en deze moet ophalen (property number is dan nog 0) gaat Morsy naar state 2. De controller ziet er nu als volgt uit: [[Bestand:Les2-state1.png|700px|Controller state 1]]

Nu moeten we een invulling gaan geven aan de controller in state 2.
* Druk op het plusje links naast de Controller bar. En ga naar state 2. Initial geeft aan in welke state je begint. In deze state wil je dat Morsy naar een bepaald boek loopt. In dit geval het boek met property book_1. Dit kan met een Steering actuator. Je kan variëren met de snelheid en afstand om het ophalen zo natuurlijk mogelijk te laten verlopen.
* Wanneer Morsy het boek bereikt heeft moeten er een aantal dingen gebeuren.
** Morsy moet laten weten aan het boek dat het zich vast moet klampen aan de robot.
** Vervolgens gaat de number property 1 omhoog zodat Morsy op zoek kan naar het volgende boek wanneer hij teruggezet wordt naar state 1. De controller ziet er nu als volgt uit: [[Bestand:Les2-state2.png|700px|Controller state 2]]
* Wanneer we een bericht sturen naar het boek, moeten we de controller van het boek wel aanpassen. De Collision sensor van het boek veranderen we in een Message sensor op de volgende manier: [[Bestand:Voorbeeld.png]]

Herhaal deze procedure voor boek 2 en 3 (gebruik states 3 en 4 hiervoor). Wanneer Morsy alle boeken gevonden heeft, zal de number property op 3 staan en moet Morsy terug naar de kast. Het lopen naar de kast kan gezien worden als state 5. Voeg in state 1 een property sensor toe. Als deze gelijk is aan 3, zet Morsy dan in state 5.

In state 5 moet je altijd sturen naar de kast. Als je hier bent stuur je een Done message naar alle boeken. Zet Morsy vervolgens in state 6: een lege state. State 5 ziet er als volgt uit:
[[Bestand:Voorbeeld.png]]

== Plusopdracht ==
Het is je vast al opgevallen dat het best lastig is om van een toetsenbord controller naar een autonome controller te gaan. In de plusopdracht verbeter je twee aspecten:
# Wanneer de radar afstand van Morsy kleiner is, moet Morsy naast alleen draaien ook gaan wandelen om de boeken te kunnen detecteren.
# Met een toetsenbord kun je makkelijker om een obstakel heen navigeren. Nu zal Morsy tegen alles opbotsen wat tussen hem en het doel instaat. Zorg ervoor dat Morsy om obstakels heen kan lopen.
Als je even niet meer wilt programmeren kun je ook gaan werken met de camera's
# Probeer de kamer vanuit Morsy te bekijken. Voor hulp zie: https://www.youtube.com/watch?v=Rmeq85kt8zE

Logistieke Robots/les 4

2014-12-17T16:06:25Z

Jacqueline: /* Stap 3: Programmeren script “central_controller.py” */

{{Zijbalk Logistieke Robots}}

== Les 4 ==

In de vorige les heb je de basis geleerd om een controller te ontwikkelen met behulp van Python. We hebben ook de omgeving geïntroduceerd waar we de rest van het project mee blijven werken: een magazijn. De robots krijgen bestellingen binnen die uit verschillende artikelen bestaan. Ze moeten deze artikelen gaan verzamelen om de bestelling compleet te maken. Dit kan natuurlijk op meerdere manieren: een robot kan de artikelen 1 voor 1 ophalen, allemaal in 1 keer of misschien kan deze robot maar een maximaal aantal artikelen tillen, of een maximaal gewicht. Als de bestelling compleet is, krijgt een robot een nieuwe bestelling.

In deze les leren we hoe we een controller kunnen maken voor 1 robot die de artikelen 1 voor 1 ophaalt. Open de file “[https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/warehouse_one_order.blend warehouse_one_order.blend]”.
Wat je in deze les ontwikkelt, gebruik je in de volgende lessen als basis om op door werken.

== Sturen van de bestelling door centrale systeem ==
Een robot moet een bestelling doorkrijgen van een computer die het overzicht heeft over alle bestellingen. Deze controller moeten we aan een centraal object in Blender toegevoegen. We kiezen hiervoor de vloer (Ground object).

Net als in de vorige les ontwikkelen we de controller via de logic bricks en via Python scripting.

=== Stap 1: Python script aanmaken voor Ground object ===
* Selecteer het Ground object;
* Maak een nieuw Python script aan door op het ‘+ New’ teken te drukken in de header van de tekst editor. Geef het script de naam “central_controller.py”;
* Voeg een Python controller aan met dit script.

=== Stap 2: Logic bricks voor Ground object ===
* Voeg een keyboard “Start” sensor toe met de ENTER key. Druk op Tap. Dit betekent dat de sensor eenmalig een positieve puls geeft aan de controller in plaats van zolang de sensor waar is.

[[Bestand:Les4-keyboard-tap.png|350px|Keyboard controller met tap-instelling]]

* Verbind deze sensor met de Python-controller van de vorige stap.

=== Stap 3: Programmeren script “central_controller.py” ===
In deze stap programmeren we de centrale controller die de bestellingen verstuurt aan de robot. Hier zullen we voor het eerst ingewikkeldere Python kennis gebruiken. Het script bouwen we op de volgende manier op:

* Importeren van de nodige packages, ophalen van de controller en het object en declareren van de sensor. Dit hebben we ook gezien in de vorige les.

<syntaxhighlight lang="Python">
import bge
import GameLogic
import random

cont = bge.logic.getCurrentController() # controller of this script
central = cont.owner # game object owning this controller

# get sensors
sens = cont.sensors["Start"]

</syntaxhighlight>

* Definiëren van variabelen. We hebben al gezien dat je variabelen kunt definiëren door “Game Properties” aan te maken voor een game-object zoals een robot. De vloer is ook een dergelijk game-object waar we een controller en variabelen aan kunnen koppelen. Deze variabelen kun je aanmaken en een waarde geven via het script met behulp van de volgende code:
<pre>
game_object[“naam_variabele”] = waarde
</pre>

Belangrijke variabelen in het pakhuis zijn hoeveel boxen er gevuld moeten worden, hoe groot de bestellingen zijn en welke artikelen in deze box kunnen zitten. Dit coderen we dus als volgt:

<syntaxhighlight lang="Python">
# define game properties
central["boxes_tot"] = 5
central["box_size"] = 3

box_articles = ["Shelf_1", "Shelf_2", "Shelf_3", "Shelf_4", "Shelf_5", "Shelf_6", "Shelf_7", "Shelf_8"]

</syntaxhighlight>

“boxes_tot” en “box_size” zijn game properties verbonden aan het Ground object.

“box_articles” is een lokale variabele in het script - en geen game-property. Dit is een array van strings: deze declareren we op de manier van Python.
Shelf_1 tot en met Shelf_8 corresponderen met de kasten die te zien zijn in het pakhuis en iedere kast heeft één soort artikel. Shelf_1 heeft dus een kast vol met artikelen nummer 1.

* We willen dat het systeem pas begint wanneer we op ENTER drukken. Wanneer deze sensor, “sens”, een positieve puls krijgt, wil je Robot_11 een bestelling (order) meegeven. Dit kan op de volgende manier:

<syntaxhighlight lang="Python">
if sens.positive:
robot = "11"
Send_order(robot)
</syntaxhighlight>
waarin <code>Send_order</code> als volgt gedefinieerd is:
<syntaxhighlight lang="Python">
def Send_order(robot):
order = ""
for j in range(central["box_size"]):
order += " " + random.choice(box_articles)
GameLogic.sendMessage("Start", order , "Robot_"+robot , "Ground")
GameLogic.sendMessage("Start", robot , "Robot_"+robot , "Ground")
</syntaxhighlight>

Zoals je kunt zien krijgt de functie Send_order een getal mee van de robot waar de bestelling naar toe moet. Dit doen we omdat we straks meer robots aan gaan sturen met deze functie.
Vervolgens maken we een order aan. Dit moet in de vorm van een String variabelen omdat we deze anders niet mee kunnen sturen naar de robot. We plakken steeds een willekeurig artikel (tussen 1 en 8) aan de order. Wanneer we de lengte van de order bereikt hebben, in ons geval 3, sturen we de order naar de robot en ook de variabele “robot”. Dit laatste doen we zodat we de robot.py controller kunnen hergebruiken voor alle robots. We hoeven dan niet een aparte python controller te maken voor iedere robot. De sendMessage functie is een functie die Blender al voor ons heeft gemaakt. Aan deze functie moet je de titel geven van de message (let op: de robot moet dus een message “Start” sensor hebben), wat er in de message staat, naar wie de message toe moet en wie deze message stuurt.

hulp: https://www.youtube.com/watch?v=jbsFA7qwFak

Logistieke Robots/les 1

2014-12-17T16:01:56Z

Jacqueline: /* Blender interface */

{{Zijbalk Logistieke Robots}}

== Inhoud les 1 ==

In deze les leer je hoe je voor een robot eenvoudige “brein software” kunt ontwikkelen in Blender. Deze “Brein software” zullen we vanaf nu een controller noemen. Je gaat eerst een controller ontwikkelen die je kunt aansturen via het toetsenbord.
In latere lessen zul je deze controller verder automatiseren, door middel van een Python-programma, zodat de robot zelfstandig (autonoom) aan de slag kan.

Voordat je hiermee kunnen starten moet je ervoor zorgen dat Blender op je systeem geïnstalleerd is. [[../Blender installeren|Installeren Blender]]

== Werken met Blender ==

Het openen van Blender kan wat overweldigend zijn. Er zijn erg veel knoppen en getallen te zien en dit is nog niet alles. Voor dit project gebruiken we lang niet alle mogelijkheden die Blender heeft. We bespreken daarom ook niet alle knoppen die je nu ziet. Veel van de uitleg in deze paragraaf is overgenomen van http://wiki.blender.org/index.php/Doc:NL/2.6/Manual.

Mocht je geïnteresseerd zijn in alle mogelijkheden van Blender kun je op deze site kijken. Ook zijn er mensen die graag hun creaties in Blender willen delen via het internet. We zullen hier verderop ook gebruik van maken.

=== Blender interface ===

De pop-up is het opstartscherm. Hier kun je recent geopende bestanden zien als je die hebt. Wanneer je een nieuw bestand wilt beginnen klik je ergens buiten het opstartscherm. Nu is de standaard lay-out zichtbaar met een kubus voorzien van assen. De standaard lay-out kan opgedeeld worden in verschillende vensters. Deze vensters, inclusief de meest gebruikte basiselementen, zijn aangegeven in figuur 1.

[[Bestand:Blender-vensters.png|600px|Blender vensters]]

Figuur 1

De vijf vensters in het startscherm zijn:
* Info Window: bovenaan het scherm, bestaande uit alleen een header
* 3D Window: hier kun je de uiteindelijke robots in actie zien
* Timeline Window: deze zullen we in dit project niet gebruiken
* Outliner Window: dit scherm geeft alle gemaakte objecten (inclusief de robots) weer in de omgeving
* Properties Window: hier kun je kenmerken van objecten wijzigen (bijvoorbeeld kleur en naam)
Er zijn meerdere Windows die je kan weergeven in je scherm. Het type venster kun je wijzigen door het Window Type te veranderen, te vinden in de linkerhoek van de headers van de windows.
Voor hulp zie: https://www.youtube.com/watch?v=TLJThln4eOE

De meest gebruikte basiselementen zijn:
* Current Screen Layout: Blender heeft passende startschermen voor verschillende gebruiksdoeleinden. Wij gebruiken Default of Scripting.
* Current Scene: je kunt verschillende 3D windows ontwikkelen. Dit zijn scenes. Wij zullen maar een Scene ontwikkelen
* Current Rendering Engine:
* Toggle Fullscreen: schakel de fullscreen mode aan/uit
* 3D Transform Manipulator: visueel hulpmiddel bij het transformeren van objecten (grab/verplaatsen, roteren en schalen). Dit kan ook met behulp van het toetsenbord (G, R, S)
* 3D cursor: heeft meerdere functies. Nieuwe objecten worden hier bijvoorbeeld geplaats en het geeft aan waar het rotatiepunt zit
* Cube Mesh / Light / Camera: bij het openen van een nieuw bestand in Blender is er standaard Cube Mesh, een Light en een Camera aanwezig
* Selected object: dit veld toont de naam van het huidige geselecteerde object
* 3D Window Header: alle vensters in Blender hebben een header, maar deze zit aan de onderkant. Hij bestaat onder andere uit:
** Viewport shading: hiermee kan het shading type aangegeven worden. Deze functie zal niet aangepast worden tijdens dit project
** Layers: wanneer je vele objecten hebt gecreëerd kan het makkelijk zijn om deze te ordenen in functionele groepen (robots in de ene layer, de omgeving in de andere). Hier zullen we geen gebruik van maken
* Buttons (Properties) Window Header: dit venster toont panels en deze panels zijn gegroepeerd. Om een andere groep te zien kunnen de knoppen in de header aangeklikt worden [[Bestand:venster-knoppen.png|400px|Venster-knoppen]]
* Outliner Window: dit venster laat alle objecten in een scene zien.
* Timeline Window: Dit venster laat een tijdlijn zien die gebruikt kan worden voor karakter animaties. Dit zullen we niet gaan toepassen in dit project
* Window types: zoals eerder gezegd zijn er vele mogelijke vensters. Ieder venster werkt onafhankelijk van de anderen en het is mogelijk om het zelfde type venster meerdere keren open te hebben. We zullen niet alle types gebruiken. Degene die we wel gaan gebruiken, naast de basis schermen, zijn:
** Logic Editor: hiermee kan een controller gemaakt worden
** Text editor: hier schrijven we Python code
** Console: hier kun je de output zien van de Python code.

=== Besturen van het 3D scherm ===

Alle handelingen in Blender kun je doen door te werken met de muis. Voor iedere handeling is er ook een shortcut beschikbaar via het keyboard. Blender maakt gebruik van alle functies op een muis. Om deze reden is het aan te raden dat je een uitgebreide muis gebruikt (met een scrol functie die ingedrukt kan worden) voor de Windows computer. Voor de Mac is de touchpad toereikend. Gedurende dit project zullen we onderstaande codes gebruikten om te refereren naar handelingen met de muis.
* LMB - Linker muisknop
* MMB - Druk op het scroll wiel alsof het een knop is
* RMB - Rechter muisknop
* Wheel - Scrol wiel

De muis gebruik je voornamelijk om de 3D view te besturen
* MMB: hiermee kun je de scene vanuit alle hoeken bekijken
* Wheel: in/uitzoomen
* LMB: vastpakken van een object
* RMB: selecteren van een object

De opdrachten hebben altijd betrekking op het subvenster waar de cursor staat. Je kunt bijvoorbeeld zowel in het 3D View als in het logic control venster in- en uitzoomen.

== Aansturen van Morsy de Robot ==
[[Bestand:Morsy.png|thumb|200px|right|Morsy]]

Nu gaan we echt aan de slag met Blender. We gaan een robot aansturen via het toetsenbord. Voordat we een robot kunnen aansturen moeten we er natuurlijk een hebben.
We gebruiken, om snel aan de slag te kunnen met de controller, een robot die al is ontwikkeld genaamd Morsy. Morsy komt uit de MORSE code, de Modular OpenRobots Simulation Engine. (https://www.openrobots.org/wiki/morse/)
Een plaatje van Morsy zie je hiernaast.

Merk op dat deze logistieke robot geen armen heeft. Het oppakken van objecten om te verplaatsen zal dus meer symbolisch zijn. Het is mogelijk om armen met een animatie toe te voegen om een object op te pakken. Omdat dit niet het doel is van het project zullen we dit niet behandelen.

=== Stap 1 ===
Open [https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/morsy.blend morsy.blend] (je moet deze eerst naar je eigen computer downloaden).
Je ziet dat we te maken hebben met dezelfde basis omgeving maar dat de Cube Mesh vervangen is door de Morsy robot.

=== Stap 2 ===
Verander zonodig het window type van de timeline window (links onder) naar de logic editor (zie hiernaast).

[[Bestand:Selecteer-logic-editor.png|thumb|200px|right|Selecteer Logic Editor]]

=== Stap 3 ===
Maak de ruimte voor de logic editor iets groter en zoom indien nodig in (met de muis/touch pad) zodat de letters leesbaar zijn. Je kunt nu zien dat de logic editor bestaat uit sensoren, controllers en actuatoren. Sensoren zijn gebeurtenissen die Morsy kan waarnemen vanuit de omgeving. De controller bepaalt hoe je op deze gebeurtenis ingaat om zo eventueel een actuator aan te sturen.

=== Stap 4: controller, sturen naar rechts ===
We kunnen nu de controller gaan maken. We willen de robot aansturen met de pijltjes op het toetsenbord. Iedere toets is dan een sensor. Wanneer deze sensor actief is (en dus ingedrukt wordt) moet de robot een bepaalde kant op gaan lopen. We beginnen met naar rechts lopen
Wanneer we de toets → indrukken willen we dat Morsy naar rechts gaat lopen (voor Morsy zelf is dit naar links). In de linker beneden hoek van het 3D scherm zien we de assen waarover de robot kan bewegen. We zien dat we Morsy moeten laten lopen over de –X as om deze naar rechts te laten gaan. Dit gaat als volgt:
* Voor het aanmaken van deze actie moeten we een sensor hebben die detecteert of we de toets → indrukken. Klik op “Add Sensor” en dan op Keyboard.
* Geef de Keyboard de naam “Right” en ga erna in het vakje “Key” staan waardoor je ziet “Press a key” en druk op →
* Ga naar “Add Controller” en voeg een “And” controller toe. Maak een link tussen de sensor en controller door de twee punten met elkaar te verbinden. Het moet er nu als volgt uit zien: [[Bestand:Les1-keyboard-controller.png|700px|Keyboard sensor en controller]] Wanneer we op de → toets drukken geeft dit een positief signaal aan de controller. De controller moet positieve signalen ontvangen van alle sensoren die verbonden zijn met deze controller om zelf een positief signaal door te kunnen geven. Dit is er nu maar 1. Wanneer alleen de toets → ingedrukt wordt geeft de controller dus een positief signaal.
* Nu gaan we de controller verbinden aan een actie: lopen. Ga naar “Add Actuator” en voeg een “Motion” actuator toe. Geef deze ook de naam “Right” en een X loc waarde van -0.3. Druk ook op de L achter deze regel. Dit geeft aan dat we willen bewegen ten opzichte van de assen en niet ten opzichte van de locatie van Morsy zelf. Maak een link tussen de controller en actuator. [[Bestand:Les1-motion-actuator.png|700px|Add motion actuator]]

==== Toevoegen van de vloer ====
Graag willen we nu weten of de robot naar rechts kan lopen. Als we nu in de “play” modus zouden gaan, zou de robot naar beneden vallen omdat we nog geen vloer hebben toegevoegd. Je zet Blender in de “play” modus door met de muis in het 3D view te staan en dan op ‘P’ te drukken. Je komt weer uit deze modus door op ‘Esc’ te drukken.
Voeg een vloer toe door in de header van de 3D view te klikken op “Add”, dan op “Mesh” en dan op “Plane”.

[[Bestand:Les1-add-plane.png|350px|Add plane]]

Verschuif het vierkant onder Morsy door op de assen te klikken en de grond te verschuiven. Druk op “S” en gebruik de “Wheel” om de grond groter te maken.
Verander de kleur van de vloer door in het property venster te gaan naar:

[[Bestand:Les1-plane-newmaterial.png|350px|Add new material]]

en klik op “+ New”. Bij diffuse kun je een kleur uitkiezen.
Als het goed is ziet het 3D window er nu als volgt uit:

[[Bestand:Les1-morsy-floor.png|700px|Morsy op het speelveld]]

Druk nu op “P” en kijk of Morsy naar rechts beweegt bij het indrukken van de pijl naar rechts. Wanneer je dit getest hebt, druk weer op “Esc”. Wanneer Morsy niet naar rechts loopt, moet je stap 4 nogmaals doorlopen om te zien of je alles juist ingevoerd hebt.
* als Morsy naar links loopt, moet je het teken van de X-verplaatsing veranderen (bijv. van 0.2 naar -0.2);
* als Morse te snel of te langzaam loopt, moet je de verplaatsing kleiner of groter maken (bijv. van 0.4 naar 0.2);
* als er helemaal niets gebeurt, moet je controleren of je (i) de juiste toets ingevoerd hebt, in de Keyboard sensor; (ii) of je de verbinding tussen sensor en controller en controller en actuator gemaakt hebt;

=== Stap 5: sturen naar links, achter en voor ===
Zorg ervoor dat Morsy ook naar links, achter en naar voren kan lopen door middel van het toetsenbord.

=== Stap 6: bestand opslaan voor vervolg ===
Sla het bestand op om volgende les mee verder te gaan.

== Plusopdracht ==
Zorg ervoor dat de robot via het toetsenbord:
* Een rondje kan draaien om zijn eigen as met de toets ‘R’
* Kan springen bij wanneer de Spacebar en toets J ingedrukt zijn
* …

== Referenties ==

* [[../Blender installeren]]
* MORSE code, de Modular OpenRobots Simulation Engine. (https://www.openrobots.org/wiki/morse/)

Logistieke Robots/les 2

2014-12-17T15:59:51Z

Jacqueline: /* Plusopdracht */

{{Zijbalk Logistieke Robots}}

== Les 2 - Objecten zoeken en verplaatsen ==

In dit project willen we robots toepassen in de logistieke sector. Wanneer robots actief zijn in de logistieke sector betekent dit vaak dat robots bepaalde objecten moeten zoeken, oppakken en naar een doel moeten brengen. Hoe we een robot moeten aansturen die dit kan gaan we zien in deze les.

Voor deze les maken we gebruik van het bestand [https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/living_room.blend living_room.blend]. Wanneer je het bestand opent zie je een huiskamer en een aantal boeken die rondslingeren in de kamer. We willen dat de robot de boeken kan herkennen, er naar toe kan lopen, op kan pakken en in de boekenkast kan zetten. In paragraaf 1 zullen we de robot aansturen via het toetsenbord en in paragraaf 2 laten we de robot deze taak autonoom (=zelfstandig) uitvoeren.

== Object naar het doel verplaatsten met het toetsenbord ==
Aan de hand van 5 stappen kunnen we de controller gaan maken. Zorg ervoor dat je eerst zelf nadenkt over de stappen die je uit moet voeren voordat je naar de print kijkt hoe de controller eruit moet zien.

=== Stap 1: Naar het boek lopen ===
Wanneer je op Morsy klikt, zie je in de logic editor dat er vier Keyboard sensors aangemaakt zijn. Hier kunnen we Morsy mee naar een boek laten lopen. Als je goed kijkt zie je ook dat er een Game Property aangemaakt is met de naam Morsy. Zo kunnen andere objecten Morsy herkennen. Waarom dit nodig is zien we later.

=== Stap 2: Boek vastpakken ===
Omdat Morsy geen armen heeft kan hij het boek niet vasthouden zoals wij dat zouden doen met onze handen. Morsy kan wel naar het boek lopen en wanneer hij contact heeft met het boek kun je je voorstellen dat het boek vast zit aan Morsy door middel van een magneet. Dit kunnen we als volgt doen:
Ga naar de controller van book_blue_ground en voeg een Collision sensor toe. Geef bij Property aan dat het om Morsy gaat.
Voeg een Parent actuator toe waarbij je bij Parent Object Morsy selecteert. Verbind de twee met elkaar. Er komt dan automatisch een And controller tussen.
Wanneer je nu in de spelmodus gaat (druk op P) en naar het blauwe boek loopt, zie je dat het blauwe boek vast blijft zitten aan Morsy. De controller ziet er als volgt uit:

[[Bestand:Les2-book-controller.png|700px]]

=== Stap 3: Naar het doel lopen ===
Het doel, de kast waar de drie dezelfde boeken wel in de kast staan, kan bereikt worden door middel van het toetsenbord.
Wanneer Morsy met het boek bij de kast is wil je dat het boek in de kast komt te staan. Het visualiseren van deze actie is niet een van de leerdoelen van dit project. Uiteraard mag je Morsy voorzien van een grijparm en visualiseren hoe Morsy het boek in de kast zet maar dit zal veel tijd in beslag nemen. Daarom gebruiken we een eenvoudiger methode.

=== Stap 4: Boek in de kast plaatsen ===
Wanneer Morsy de kast bereikt met een boek, wil je dat dit boek verdwijnt en dat het boek in de kast zichtbaar wordt. Voordat Morsy kan herkennen of er aanraking plaatsvindt met de kast, moet de kast een Game Property hebben.

==== Voeg kast-game property "Goal" toe ====
Selecteer de kast en voeg een ‘String’ Game Property toe aan de kast met de naam ‘Goal’:
[[Bestand:Les2-stap4-goal.png|700px|Add property: Goal]]

==== Voeg Morsy-sensoren en actuatoren toe ====

Selecteer nu weer Morsy en voeg een Collision sensor toe en twee Message actuatoren naar het blauwe boek op de grond en in de kast met als Subject ‘Done’:
[[Bestand:Les2-stap4-done.png|700px|Add message actuators: Done]]

==== Boek op de grond wordt opgepakt (onzichtbaar) ====
Zorg ervoor dat het blauwe boek op de grond het bericht kan ontvangen en hierna onzichtbaar wordt:
[[Bestand:Les2-stap4-book.png|700px|Boek wordt onzichtbaar]]

==== Boek in de kast wordt zichtbaar ====
Zorg er ook voor dat het boek in de kast vanaf het begin onzichtbaar is
totdat deze het bericht ‘Done’ krijgt van Morsy. Neem zelf even de tijd om te bedenken hoe dit moet.
[[Bestand:Les2-stap4-shelf.png|700px|Boek wordt in kast zichtbaar]]

=== Uiteindelijk resultaat ===
Het kan er uiteindelijk als volgt uit zien:

[[Bestand:Les2-stap5-afronden.png|500px|Morsy verplaatst het boek]]

Wanneer je zelf andere sensoren en actuatoren gebruikt die hetzelfde resultaat als gevolg hebben, mag dit ook.

== Object herkennen met een radar ==

In deze paragraaf leren we hoe Morsy zelf naar de boeken kan lopen zonder aansturing via het toetsenbord.
Hiervoor moet Morsy tussen verschillende States (toestanden) kunnen schakelen. Morsy moet eerst de kamer afzoeken naar de boeken. Wanneer Morsy een boek gevonden heeft moet hij hier naartoe lopen en erna mogelijk weer verder zoeken om vervolgens de boeken bij de kast af te leveren.

We gebruiken de volgende toestanden (states):
* 1: zoeken naar boek 1 (met een radar-sensor), bewegen naar het boek, en oppakken van het boek
* 2: oppakken van boek 1 en in de kast plaatsen
* 3: zoeken naar boek 2
* 4: oppakken van boek 4
* 5: loop naar de kast en plaats de boeken daarin

=== Stap 1: Opzetten ===
In de vorige paragraaf konden wij de boeken zien liggen en Morsy erheen sturen via het toetsenbord. Nu willen we dat Morsy zelf de boeken kan vinden. Geef de boeken die op de grond liggen de Game Property ‘book_1’ en ‘book_2’ en verwijder alle sensorsen en actuators van Morsy.

=== Stap 2: Boeken detecteren ===
We gaan Morsy voorzien van verschillende Radars die de boeken kunnen detecteren. We voegen eerst een radar toe voor <code>book_1</code>
* Om de boeken te kunnen zien met de Radars moet Morsy rondjes draaien. Voeg een Always sensor toe die een Motion actuator activeert waarbij je 2 graden om de Z as beweegt.
** controleer of deze werkt;
* Voeg een Radar sensor toe met Property <code>book_1</code>, over de –X as (<code>-X axis</code>), een hoek (<code>Angle</code>) van 50 graden en een afstand (<code>Distance</code>) van 8 meter.
** Om de radar te kunnen zien in de 3D view, kun je in de info window van Blender drukken op <code>Game > Show Physics Visualization</code>. Wanneer je nu naar de spel modus gaat kun je de radar zien. Je kunt de Physics Visualization hierna weer uitzetten.

=== Stap 3: Boeken ophalen in verschillende states ===
* Voeg aan Morsy een Integer Game Property toe genaamd ‘number’. Dit is het aantal boeken dat Morsy opgepakt heeft. We laten Morsy de boeken in een speciale volgorde ophalen. Dit is nodig wanneer je met de logic bricks werkt. In de volgende les zien we dat het met Python sneller kan. Wanneer de radar het boek ziet met property <code>book_1</code> en deze moet ophalen (property number is dan nog 0) gaat Morsy naar state 2. De controller ziet er nu als volgt uit: [[Bestand:Les2-state1.png|700px|Controller state 1]]

Nu moeten we een invulling gaan geven aan de controller in state 2.
* Druk op het plusje links naast de Controller bar. En ga naar state 2. Initial geeft aan in welke state je begint. In deze state wil je dat Morsy naar een bepaald boek loopt. In dit geval het boek met property book_1. Dit kan met een Steering actuator. Je kan variëren met de snelheid en afstand om het ophalen zo natuurlijk mogelijk te laten verlopen.
* Wanneer Morsy het boek bereikt heeft moeten er een aantal dingen gebeuren.
** Morsy moet laten weten aan het boek dat het zich vast moet klampen aan de robot.
** Vervolgens gaat de number property 1 omhoog zodat Morsy op zoek kan naar het volgende boek wanneer hij teruggezet wordt naar state 1. De controller ziet er nu als volgt uit: [[Bestand:Les2-state2.png|700px|Controller state 2]]
* Wanneer we een bericht sturen naar het boek, moeten we de controller van het boek wel aanpassen. De Collision sensor van het boek veranderen we in een Message sensor op de volgende manier: [[Bestand:Voorbeeld.png]]

Herhaal deze procedure voor boek 2 en 3 (gebruik states 3 en 4 hiervoor). Wanneer Morsy alle boeken gevonden heeft, zal de number property op 3 staan en moet Morsy terug naar de kast. Het lopen naar de kast kan gezien worden als state 5. Voeg in state 1 een property sensor toe. Als deze gelijk is aan 3, zet Morsy dan in state 5.

In state 5 moet je altijd sturen naar de kast. Als je hier bent stuur je een Done message naar alle boeken. Zet Morsy vervolgens in state 6: een lege state. State 5 ziet er als volgt uit:
[[Bestand:Voorbeeld.png]]

== Plusopdracht ==
Het is je vast al opgevallen dat het best lastig is om van een toetsenbord controller naar een autonome controller te gaan. In de plusopdracht verbeter je twee aspecten:
# Wanneer de radar afstand van Morsy kleiner is, moet Morsy naast alleen draaien ook gaan wandelen om de boeken te kunnen detecteren.
# Met een toetsenbord kun je makkelijker om een obstakel heen navigeren. Nu zal Morsy tegen alles opbotsen wat tussen hem en het doel instaat. Zorg ervoor dat Morsy om obstakels heen kan lopen.
Als je even niet meer wilt programmeren kun je ook gaan werken met de camera's
# Probeer de kamer vanuit Morsy te bekijken. Voor hulp zie: https://www.youtube.com/watch?v=Rmeq85kt8zE

Logistieke Robots

2014-12-17T15:42:54Z

Jacqueline: /* Over het project */

{{Zijbalk Logistieke Robots}}

== Over het project==
[[Bestand:stofzuig_robot.png|thumb|200px|right|zie: https://www.youtube.com/watch?v=hKzMWGVi-YM]]

We zien robots steeds meer in ons dagelijkse leven verschijnen, van simpele stofzuigers (zie rechts voor link) tot zelf rijdende auto’s. Deze robots moeten over een passende intelligentie beschikken om hun taak goed uit te kunnen voeren. Robots worden in vele sectoren in het bedrijfsleven gebruikt waaronder de logistieke sector. Een goed voorbeeld hiervan is de Kiva robot. Deze robot helpt werknemers bestellingen in te pakken in een pakhuis (zie rechts voor link).
[[Bestand:Kiva_Robot.jpg|thumb|200px|right|zie: https://www.youtube.com/watch?v=6KRjuuEVEZs]]

In dit project leer je hoe je soortgelijke “brein software” kan ontwikkelen om een groep robots aan te sturen om bestellingen in te pakken in een magazijn.

=== Blender ===

Het softwareprogramma wat ons hierbij zal ondersteunen is Blender. Blender is gratis, opensource en erg snel te installeren op meerdere platforms (Windows, Mac OS X,Linux).

=== Leerdoelen ===

Na het succesvol afronden van dit project kun je:
# overweg met het simulatiepakket Blender in combinatie met Python,
# robot software ontwikkelen voor individuele robots,
# robot software ontwikkelen voor een samenwerkende robots,
# zelf verbeterende robot software ontwikkelen voor een groep samenwerkende robots,
# het experimenteel testen en beoordelen van robot gedrag,
# het koppelen van bovenstaande aan een werkveld, met name Logistiek.

Het project is opgebouwd uit 8 lessen. Iedere les duurt 2-3 uur. Iedere les heeft een verschillend aantal plusopdrachten waar je tussen de lessen door mee aan de slag kunt.
De opdrachtomschrijving is getest op een Mac en Windows. Indien je een ander platform gebruikt, kun je wellicht op problemen stuiten. Het wordt dus aangeraden een Mac of Windows computer te gebruiken maar andere platformen zouden ook mogelijk kunnen zijn

Je kan nu beginnen met Les 1!

== Ontwikkeling ==
Het maken van dit lesmateriaal is mogelijk gemaakt dankzij subsidie van de gemeente Amsterdam. Het project is uitgevoerd aan de Vrije Universiteit Amsterdam, afdeling Computational Intelligence, in samenwerking met ICT in de Wolken Amsterdam.

Voor vragen over de totstandkoming van dit project kunt u terecht bij:

* Jacqueline Heinerman (j.v.heinerman@vu.nl)
* Eelco Dijkstra (eelco@infvo.com)

== Referenties ==
* [[/Bestanden]]

Logistieke Robots

2014-12-17T15:42:21Z

Jacqueline: /* Over het project */

{{Zijbalk Logistieke Robots}}

== Over het project==
[[Bestand:stofzuig_robot.png|thumb|200px|right|zie: https://www.youtube.com/watch?v=hKzMWGVi-YM]]

We zien robots steeds meer in ons dagelijkse leven verschijnen, van simpele stofzuigers tot zelf rijdende auto’s. Deze robots moeten over een passende intelligentie beschikken om hun taak goed uit te kunnen voeren. Robots worden in vele sectoren in het bedrijfsleven gebruikt waaronder de logistieke sector. Een goed voorbeeld hiervan is de Kiva robot. Deze robot helpt werknemers bestellingen in te pakken in een pakhuis.
[[Bestand:Kiva_Robot.jpg|thumb|200px|right|zie: https://www.youtube.com/watch?v=6KRjuuEVEZs]]

In dit project leer je hoe je soortgelijke “brein software” kan ontwikkelen om een groep robots aan te sturen om bestellingen in te pakken in een magazijn.

=== Blender ===

Het softwareprogramma wat ons hierbij zal ondersteunen is Blender. Blender is gratis, opensource en erg snel te installeren op meerdere platforms (Windows, Mac OS X,Linux).

=== Leerdoelen ===

Na het succesvol afronden van dit project kun je:
# overweg met het simulatiepakket Blender in combinatie met Python,
# robot software ontwikkelen voor individuele robots,
# robot software ontwikkelen voor een samenwerkende robots,
# zelf verbeterende robot software ontwikkelen voor een groep samenwerkende robots,
# het experimenteel testen en beoordelen van robot gedrag,
# het koppelen van bovenstaande aan een werkveld, met name Logistiek.

Het project is opgebouwd uit 8 lessen. Iedere les duurt 2-3 uur. Iedere les heeft een verschillend aantal plusopdrachten waar je tussen de lessen door mee aan de slag kunt.
De opdrachtomschrijving is getest op een Mac en Windows. Indien je een ander platform gebruikt, kun je wellicht op problemen stuiten. Het wordt dus aangeraden een Mac of Windows computer te gebruiken maar andere platformen zouden ook mogelijk kunnen zijn

Je kan nu beginnen met Les 1!

== Ontwikkeling ==
Het maken van dit lesmateriaal is mogelijk gemaakt dankzij subsidie van de gemeente Amsterdam. Het project is uitgevoerd aan de Vrije Universiteit Amsterdam, afdeling Computational Intelligence, in samenwerking met ICT in de Wolken Amsterdam.

Voor vragen over de totstandkoming van dit project kunt u terecht bij:

* Jacqueline Heinerman (j.v.heinerman@vu.nl)
* Eelco Dijkstra (eelco@infvo.com)

== Referenties ==
* [[/Bestanden]]

Logistieke Robots

2014-12-17T15:40:20Z

Jacqueline: /* Over het project */

{{Zijbalk Logistieke Robots}}

== Over het project==
[[Bestand:stofzuig_robot.png|thumb|200px|right|zie: https://www.youtube.com/watch?v=hKzMWGVi-YM]]

We zien robots steeds meer in ons dagelijkse leven verschijnen, van simpele stofzuigers tot zelf rijdende auto’s. Deze robots moeten over een passende intelligentie beschikken om hun taak goed uit te kunnen voeren. Robots worden in vele sectoren in het bedrijfsleven gebruikt waaronder de logistieke sector. Een goed voorbeeld hiervan is de Kiva robot. Deze robot helpt werknemers bestellingen in te pakken in een pakhuis.
[[Bestand:Kiva_robot.jpg|thumb|200px|right|zie: https://www.youtube.com/watch?v=6KRjuuEVEZs]]

In dit project leer je hoe je soortgelijke “brein software” kan ontwikkelen om een groep robots aan te sturen om bestellingen in te pakken in een magazijn.

=== Blender ===

Het softwareprogramma wat ons hierbij zal ondersteunen is Blender. Blender is gratis, opensource en erg snel te installeren op meerdere platforms (Windows, Mac OS X,Linux).

=== Leerdoelen ===

Na het succesvol afronden van dit project kun je:
# overweg met het simulatiepakket Blender in combinatie met Python,
# robot software ontwikkelen voor individuele robots,
# robot software ontwikkelen voor een samenwerkende robots,
# zelf verbeterende robot software ontwikkelen voor een groep samenwerkende robots,
# het experimenteel testen en beoordelen van robot gedrag,
# het koppelen van bovenstaande aan een werkveld, met name Logistiek.

Het project is opgebouwd uit 8 lessen. Iedere les duurt 2-3 uur. Iedere les heeft een verschillend aantal plusopdrachten waar je tussen de lessen door mee aan de slag kunt.
De opdrachtomschrijving is getest op een Mac en Windows. Indien je een ander platform gebruikt, kun je wellicht op problemen stuiten. Het wordt dus aangeraden een Mac of Windows computer te gebruiken maar andere platformen zouden ook mogelijk kunnen zijn

Je kan nu beginnen met Les 1!

== Ontwikkeling ==
Het maken van dit lesmateriaal is mogelijk gemaakt dankzij subsidie van de gemeente Amsterdam. Het project is uitgevoerd aan de Vrije Universiteit Amsterdam, afdeling Computational Intelligence, in samenwerking met ICT in de Wolken Amsterdam.

Voor vragen over de totstandkoming van dit project kunt u terecht bij:

* Jacqueline Heinerman (j.v.heinerman@vu.nl)
* Eelco Dijkstra (eelco@infvo.com)

== Referenties ==
* [[/Bestanden]]

Logistieke Robots

2014-12-17T15:39:18Z

Jacqueline: /* Over het project */

{{Zijbalk Logistieke Robots}}

== Over het project==
[[Bestand:stofzuig_robot.png|thumb|200px|right|zie: https://www.youtube.com/watch?v=hKzMWGVi-YM]]

We zien robots steeds meer in ons dagelijkse leven verschijnen, van simpele stofzuigers tot zelf rijdende auto’s. Deze robots moeten over een passende intelligentie beschikken om hun taak goed uit te kunnen voeren. Robots worden in vele sectoren in het bedrijfsleven gebruikt waaronder de logistieke sector. Een goed voorbeeld hiervan is de Kiva robot. Deze robot helpt werknemers bestellingen in te pakken in een pakhuis.
[[Bestand:kiva_robot.jpg|thumb|200px|right|zie: https://www.youtube.com/watch?v=6KRjuuEVEZs]]

In dit project leer je hoe je soortgelijke “brein software” kan ontwikkelen om een groep robots aan te sturen om bestellingen in te pakken in een magazijn.

=== Blender ===

Het softwareprogramma wat ons hierbij zal ondersteunen is Blender. Blender is gratis, opensource en erg snel te installeren op meerdere platforms (Windows, Mac OS X,Linux).

=== Leerdoelen ===

Na het succesvol afronden van dit project kun je:
# overweg met het simulatiepakket Blender in combinatie met Python,
# robot software ontwikkelen voor individuele robots,
# robot software ontwikkelen voor een samenwerkende robots,
# zelf verbeterende robot software ontwikkelen voor een groep samenwerkende robots,
# het experimenteel testen en beoordelen van robot gedrag,
# het koppelen van bovenstaande aan een werkveld, met name Logistiek.

Het project is opgebouwd uit 8 lessen. Iedere les duurt 2-3 uur. Iedere les heeft een verschillend aantal plusopdrachten waar je tussen de lessen door mee aan de slag kunt.
De opdrachtomschrijving is getest op een Mac en Windows. Indien je een ander platform gebruikt, kun je wellicht op problemen stuiten. Het wordt dus aangeraden een Mac of Windows computer te gebruiken maar andere platformen zouden ook mogelijk kunnen zijn

Je kan nu beginnen met Les 1!

== Ontwikkeling ==
Het maken van dit lesmateriaal is mogelijk gemaakt dankzij subsidie van de gemeente Amsterdam. Het project is uitgevoerd aan de Vrije Universiteit Amsterdam, afdeling Computational Intelligence, in samenwerking met ICT in de Wolken Amsterdam.

Voor vragen over de totstandkoming van dit project kunt u terecht bij:

* Jacqueline Heinerman (j.v.heinerman@vu.nl)
* Eelco Dijkstra (eelco@infvo.com)

== Referenties ==
* [[/Bestanden]]

Logistieke Robots

2014-12-17T15:19:11Z

Jacqueline: /* Over het project */

{{Zijbalk Logistieke Robots}}

== Over het project==

We zien robots steeds meer in ons dagelijkse leven verschijnen, van simpele stofzuigers [[Bestand:stofzuig_robot.png]] (https://www.youtube.com/watch?v=hKzMWGVi-YM) tot zelf rijdende auto’s. Deze robots moeten over een passende intelligentie beschikken om hun taak goed uit te kunnen voeren. Robots worden in vele sectoren in het bedrijfsleven gebruikt waaronder de logistieke sector. Een goed voorbeeld hiervan is de Kiva robot. Deze robot helpt werknemers bestellingen in te pakken in een pakhuis: [[Bestand:kiva_robot.jpg]] https://www.youtube.com/watch?v=6KRjuuEVEZs.
In dit project leer je hoe je soortgelijke “brein software” kan ontwikkelen om een groep robots aan te sturen om bestellingen in te pakken in een magazijn.

=== Blender ===

Het softwareprogramma wat ons hierbij zal ondersteunen is Blender. Blender is gratis, opensource en erg snel te installeren op meerdere platforms (Windows, Mac OS X,Linux).

=== Leerdoelen ===

Na het succesvol afronden van dit project kun je:
# overweg met het simulatiepakket Blender in combinatie met Python,
# robot software ontwikkelen voor individuele robots,
# robot software ontwikkelen voor een samenwerkende robots,
# zelf verbeterende robot software ontwikkelen voor een groep samenwerkende robots,
# het experimenteel testen en beoordelen van robot gedrag,
# het koppelen van bovenstaande aan een werkveld, met name Logistiek.

Het project is opgebouwd uit 8 lessen. Iedere les duurt 2-3 uur. Iedere les heeft een verschillend aantal plusopdrachten waar je tussen de lessen door mee aan de slag kunt.
De opdrachtomschrijving is getest op een Mac en Windows. Indien je een ander platform gebruikt, kun je wellicht op problemen stuiten. Het wordt dus aangeraden een Mac of Windows computer te gebruiken maar andere platformen zouden ook mogelijk kunnen zijn

Je kan nu beginnen met Les 1!

== Ontwikkeling ==
Het maken van dit lesmateriaal is mogelijk gemaakt dankzij subsidie van de gemeente Amsterdam. Het project is uitgevoerd aan de Vrije Universiteit Amsterdam, afdeling Computational Intelligence, in samenwerking met ICT in de Wolken Amsterdam.

Voor vragen over de totstandkoming van dit project kunt u terecht bij:

* Jacqueline Heinerman (j.v.heinerman@vu.nl)
* Eelco Dijkstra (eelco@infvo.com)

== Referenties ==
* [[/Bestanden]]

Logistieke Robots

2014-12-17T15:17:01Z

Jacqueline: /* Over het project */

{{Zijbalk Logistieke Robots}}

== Over het project==

We zien robots steeds meer in ons dagelijkse leven verschijnen, van simpele stofzuigers [[Bestand:stofzuig_robot.jpg]] (https://www.youtube.com/watch?v=hKzMWGVi-YM) tot zelf rijdende auto’s. Deze robots moeten over een passende intelligentie beschikken om hun taak goed uit te kunnen voeren. Robots worden in vele sectoren in het bedrijfsleven gebruikt waaronder de logistieke sector. Een goed voorbeeld hiervan is de Kiva robot. Deze robot helpt werknemers bestellingen in te pakken in een pakhuis: [[Bestand:kiva_robot.jpg]] https://www.youtube.com/watch?v=6KRjuuEVEZs.
In dit project leer je hoe je soortgelijke “brein software” kan ontwikkelen om een groep robots aan te sturen om bestellingen in te pakken in een magazijn.

=== Blender ===

Het softwareprogramma wat ons hierbij zal ondersteunen is Blender. Blender is gratis, opensource en erg snel te installeren op meerdere platforms (Windows, Mac OS X,Linux).

=== Leerdoelen ===

Na het succesvol afronden van dit project kun je:
# overweg met het simulatiepakket Blender in combinatie met Python,
# robot software ontwikkelen voor individuele robots,
# robot software ontwikkelen voor een samenwerkende robots,
# zelf verbeterende robot software ontwikkelen voor een groep samenwerkende robots,
# het experimenteel testen en beoordelen van robot gedrag,
# het koppelen van bovenstaande aan een werkveld, met name Logistiek.

Het project is opgebouwd uit 8 lessen. Iedere les duurt 2-3 uur. Iedere les heeft een verschillend aantal plusopdrachten waar je tussen de lessen door mee aan de slag kunt.
De opdrachtomschrijving is getest op een Mac en Windows. Indien je een ander platform gebruikt, kun je wellicht op problemen stuiten. Het wordt dus aangeraden een Mac of Windows computer te gebruiken maar andere platformen zouden ook mogelijk kunnen zijn

Je kan nu beginnen met Les 1!

== Ontwikkeling ==
Het maken van dit lesmateriaal is mogelijk gemaakt dankzij subsidie van de gemeente Amsterdam. Het project is uitgevoerd aan de Vrije Universiteit Amsterdam, afdeling Computational Intelligence, in samenwerking met ICT in de Wolken Amsterdam.

Voor vragen over de totstandkoming van dit project kunt u terecht bij:

* Jacqueline Heinerman (j.v.heinerman@vu.nl)
* Eelco Dijkstra (eelco@infvo.com)

== Referenties ==
* [[/Bestanden]]

Bestand:Kiva Robot.jpg

2014-12-17T15:14:59Z

Jacqueline:

Bestand:Stofzuig robot.png

2014-12-17T15:13:40Z

Jacqueline:

Logistieke Robots

2014-12-17T14:43:06Z

Jacqueline: /* Over het project */

{{Zijbalk Logistieke Robots}}

== Over het project==

We zien robots steeds meer in ons dagelijkse leven verschijnen, van simpele stofzuigers (https://www.youtube.com/watch?v=hKzMWGVi-YM) tot zelf rijdende auto’s. Deze robots moeten over een passende intelligentie beschikken om hun taak goed uit te kunnen voeren. Robots worden in vele sectoren in het bedrijfsleven gebruikt waaronder de logistieke sector. Een goed voorbeeld hiervan is de Kiva robot. Deze robot helpt werknemers bestellingen in te pakken in een pakhuis: https://www.youtube.com/watch?v=6KRjuuEVEZs.
In dit project leer je hoe je soortgelijke “brein software” kan ontwikkelen om een groep robots aan te sturen om bestellingen in te pakken in een magazijn.

Het softwareprogramma wat ons hierbij zal ondersteunen is Blender. Blender is gratis, opensource en erg snel te installeren op meerdere platforms (Windows, Mac OS X,Linux).

Na het succesvol afronden van dit project kun je:
# overweg met het simulatiepakket Blender in combinatie met Python,
# robot software ontwikkelen voor individuele robots,
# robot software ontwikkelen voor een samenwerkende robots,
# zelf verbeterende robot software ontwikkelen voor een groep samenwerkende robots,
# het experimenteel testen en beoordelen van robot gedrag,
# het koppelen van bovenstaande aan een werkveld, met name Logistiek.

Het project is opgebouwd uit 8 lessen. Iedere les duurt 2-3 uur. Iedere les heeft een verschillend aantal plusopdrachten waar je tussen de lessen door mee aan de slag kunt.
De opdrachtomschrijving is getest op een Mac en Windows. Indien je een ander platform gebruikt, kun je wellicht op problemen stuiten. Het wordt dus aangeraden een Mac of Windows computer te gebruiken maar andere platformen zouden ook mogelijk kunnen zijn

Je kan nu beginnen met Les 1!

== Ontwikkeling ==
Het maken van dit lesmateriaal is mogelijk gemaakt dankzij subsidie van de gemeente Amsterdam. Het project is uitgevoerd aan de Vrije Universiteit Amsterdam, afdeling Computational Intelligence, in samenwerking met ICT in de Wolken Amsterdam.

Voor vragen over de totstandkoming van dit project kunt u terecht bij:

* Jacqueline Heinerman (j.v.heinerman@vu.nl)
* Eelco Dijkstra (eelco@infvo.com)

== Referenties ==
* [[/Bestanden]]

Logistieke Robots

2014-12-17T14:34:47Z

Jacqueline: /* Over het project */

{{Zijbalk Logistieke Robots}}

== Over het project==
Robots worden steeds slimmer en in de toekomst zullen steeds meer taken vervuld gaan worden door robots. Een voorbeeld van een robot die al te koop is in de winkel is de stofzuig robot. Zie https://www.youtube.com/watch?v=hKzMWGVi-YM.
Robots worden niet alleen in het huishouden gebruikt. Ze worden in vele sectoren in het bedrijfsleven gebruikt waaronder de logistieke sector. Een goed voorbeeld hiervan is de Kiva robot. Deze robot helpt werknemers bestellingen in te pakken in een pakhuis: https://www.youtube.com/watch?v=6KRjuuEVEZs.
De robots nemen dus taken over van de werknemers maar er ontstaan ook nieuwe werkzaamheden omdat de robots wel aangestuurd moeten worden om deze taken te kunnen vervullen. In dit project zullen we leren hoe we robots aan sturen om ze taken te laten vervullen in de logistieke sector.
Je kan nu beginnen met Les 1!

== Ontwikkeling ==
Het maken van dit lesmateriaal is mogelijk gemaakt dankzij subsidie van de gemeente Amsterdam. Het project is uitgevoerd aan de Vrije Universiteit Amsterdam, afdeling Computational Intelligence, in samenwerking met ICT in de Wolken Amsterdam.

Voor vragen over de totstandkoming van dit project kunt u terecht bij:

* Jacqueline Heinerman (j.v.heinerman@vu.nl)
* Eelco Dijkstra (eelco@infvo.com)

== Referenties ==
* [[/Bestanden]]

Logistieke Robots

2014-12-17T14:33:31Z

Jacqueline: /* Over het project */

{{Zijbalk Logistieke Robots}}

== Over het project==
Robots worden steeds slimmer en in de toekomst zullen steeds meer taken vervuld gaan worden door robots. Een voorbeeld van een robot die al te koop is in de winkel is de stofzuig robot. Zie https://www.youtube.com/watch?v=hKzMWGVi-YM.
Robots worden niet alleen in het huishouden gebruikt. Ze worden in vele sectoren in het bedrijfsleven gebruikt waaronder de logistieke sector. Een goed voorbeeld hiervan is de Kiva robot. Deze robot helpt werknemers bestellingen in te pakken in een pakhuis: https://www.youtube.com/watch?v=6KRjuuEVEZs.
De robots nemen dus taken over van de werknemers maar er ontstaan ook nieuwe werkzaamheden omdat de robots wel aangestuurd moeten worden om deze taken te kunnen vervullen. In dit project zullen we leren hoe we robots aan sturen om ze taken te laten vervullen in de logistieke sector.

== Ontwikkeling ==
Het maken van dit lesmateriaal is mogelijk gemaakt dankzij subsidie van de gemeente Amsterdam. Het project is uitgevoerd aan de Vrije Universiteit Amsterdam, afdeling Computational Intelligence, in samenwerking met ICT in de Wolken Amsterdam.

Voor vragen over de totstandkoming van dit project kunt u terecht bij:

* Jacqueline Heinerman (j.v.heinerman@vu.nl)
* Eelco Dijkstra (eelco@infvo.com)

== Referenties ==
* [[/Bestanden]]

Logistieke Robots

2014-12-17T14:30:46Z

Jacqueline: /* Over het project */

{{Zijbalk Logistieke Robots}}

== Over het project==
Robots worden steeds slimmer en in de toekomst zullen meer steeds taken vervuld gaan worden door robots. Een voorbeeld van een robot die al te koop is in de winkel is de stofzuig robot. Zie https://www.youtube.com/watch?v=hKzMWGVi-YM.
Robots worden niet alleen in het huishouden gebruikt. Ze worden in vele sectoren in het bedrijfsleven gebruikt waaronder de logistieke sector. Een goed voorbeeld hiervan is de Kiva robot. Deze robot helpt mensen om bestellingen in te pakken in een pakhuis: https://www.youtube.com/watch?v=6KRjuuEVEZs.
De robots nemen dus taken over van de mensen maar tegelijk moeten de mensen de robot wel leren besturen om taken te kunnen vervullen. In dit project zullen we leren hoe we robots aan sturen om ze taken te laten vervullen in de logistieke sector.

== Ontwikkeling ==
Het maken van dit lesmateriaal is mogelijk gemaakt dankzij subsidie van de gemeente Amsterdam. Het project is uitgevoerd aan de Vrije Universiteit Amsterdam, afdeling Computational Intelligence, in samenwerking met ICT in de Wolken Amsterdam.

Voor vragen over de totstandkoming van dit project kunt u terecht bij:

* Jacqueline Heinerman (j.v.heinerman@vu.nl)
* Eelco Dijkstra (eelco@infvo.com)

== Referenties ==
* [[/Bestanden]]

Logistieke Robots

2014-12-17T14:30:07Z

Jacqueline: /* Over het project */

{{Zijbalk Logistieke Robots}}

== Over het project==
Robots worden steeds slimmer en in de toekomst zullen meer steeds taken vervuld gaan worden door robots. Een voorbeeld van een robot die al te koop is in de winkel is de stofzuig robot. Zie https://www.youtube.com/watch?v=hKzMWGVi-YM.
Robots worden niet alleen in het huishouden gebruikt. Ze worden in vele sectoren in het bedrijfsleven gebruikt en ook in de logistieke sector. Een goed voorbeeld hiervan is de Kiva robot. Deze robot helpt mensen om bestellingen in te pakken in een pakhuis: https://www.youtube.com/watch?v=6KRjuuEVEZs.
De robots nemen dus taken over van de mensen maar tegelijk moeten de mensen de robot wel leren besturen om taken te kunnen vervullen. In dit project zullen we leren hoe we robots aan sturen om ze taken te laten vervullen in de logistieke sector.

== Ontwikkeling ==
Het maken van dit lesmateriaal is mogelijk gemaakt dankzij subsidie van de gemeente Amsterdam. Het project is uitgevoerd aan de Vrije Universiteit Amsterdam, afdeling Computational Intelligence, in samenwerking met ICT in de Wolken Amsterdam.

Voor vragen over de totstandkoming van dit project kunt u terecht bij:

* Jacqueline Heinerman (j.v.heinerman@vu.nl)
* Eelco Dijkstra (eelco@infvo.com)

== Referenties ==
* [[/Bestanden]]

Logistieke Robots

2014-12-17T14:22:26Z

Jacqueline: /* Ontwikkeling */

{{Zijbalk Logistieke Robots}}

== Over het project==
Robots worden steeds slimmer en in de toekomst zullen meer steeds taken vervuld gaan worden door robots. Een voorbeeld zijn de
Werkzaamheden die nu mensen nog doen zullen dan gedaan worden door robots. Dit zorgt voor een verschuiving van werkzaamheden van het uitvoeren van de taak naar het aansturen van de robot voor deze taak. In dit project leer je hoe je een robot aan moet sturen om taken in de logistieke sector te vervullen.

== Ontwikkeling ==
Het maken van dit lesmateriaal is mogelijk gemaakt dankzij subsidie van de gemeente Amsterdam. Het project is uitgevoerd aan de Vrije Universiteit Amsterdam, afdeling Computational Intelligence, in samenwerking met ICT in de Wolken Amsterdam.

Voor vragen over de totstandkoming van dit project kunt u terecht bij:

* Jacqueline Heinerman (j.v.heinerman@vu.nl)
* Eelco Dijkstra (eelco@infvo.com)

== Referenties ==
* [[/Bestanden]]

Logistieke Robots/Bestanden

2014-12-17T14:21:04Z

Jacqueline: /* Bestanden */

== Bestanden ==

De Blender-bestanden zijn te vinden via:
* https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots
** https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/morsy.blend
** https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/living_room.blend
** https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/warehouse.blend
** https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/warehouse_one_order.blend
** https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/warehouse_team.blend
** https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots/warehouse_team_collission.blend
* uitwerkingen: https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots-final
** https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots-final/morsy_final.blend
** https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots-final/living_room_final.blend
** https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots-final/warehouse_final.blend
** https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots-final/warehouse_one_order_final.blend
** https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots-final/warehouse_team_final.blend
** https://googledrive.com/host/0B4Wf_Tca5KDuNnFUWTc4R09jblU/logistieke-robots-final/warehouse_team_collission_final.blend

Logistieke Robots

2014-12-17T14:08:04Z

Jacqueline: /* Ontwikkeling */

Logistieke Robots

2014-12-17T13:58:57Z

Jacqueline: /* Over het project */

Logistieke Robots

2014-12-17T13:54:22Z

Jacqueline:

{{Zijbalk Logistieke Robots}}

== Over het project==
Robots worden steeds slimmer en in de toekomst zullen meer steeds taken vervuld gaan worden door robots.

Werkzaamheden die nu mensen nog doen zullen dan gedaan worden door robots. Dit zorgt voor een verschuiving van werkzaamheden van het uitvoeren van de taak naar het aansturen van de robot voor deze taak. In dit project leer je hoe je een robot aan moet sturen om taken in de logistieke sector te vervullen

== Ontwikkeling ==
Het maken van dit lesmateriaal is mogelijk gemaakt dankzij subsidie van de gemeente Amsterdam. Het project is uitgevoerd aan de Vrije Universiteit Amsterdam, afdeling Computational Intelligence, in samenwerking met ICT in de Wolken Amsterdam.

Voor vragen over de totstandkoming van dit project kunt u terecht bij:

* Jacqueline Heinerman (j.v.heinerman@vu.nl)
* Eelco Dijkstra (eelco@infvo.com)

== Referenties ==
* [[/Bestanden]]

Logistieke Robots/les 5

2014-12-17T13:45:37Z

Jacqueline: /* Les 5 - Robots laten samen werken */

{{Zijbalk Logistieke Robots}}

==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:

<syntaxhighlight lang="Python">
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]
</syntaxhighlight>

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.

<syntaxhighlight lang="Python">
GameLogic.sendMessage("Done", robot["robot_id"] , "Ground", "")
GameLogic.sendMessage("Done", str(robot["distance"]) , "Ground", "")
</syntaxhighlight>

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

<syntaxhighlight lang="Python">
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
</syntaxhighlight>

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:

<syntaxhighlight lang="Python">
if sens.positive:
robot = "11"
central["distance"] = 0
Send_order(robot)
</syntaxhighlight>

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:

<syntaxhighlight lang="Python">
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"])
</syntaxhighlight>

=== 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:
{| class="wikitable"
! 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:

<syntaxhighlight lang="Python">
def Send_order(robot_team):
pre_order = [random.choice(box_articles) for t in range(central["box_size"])]
pre_order = list(set(pre_order))
order = ""
for j in range(len(pre_order)):
order += " " + pre_order[j]
GameLogic.sendMessage("Start", order , "Robot_"+robot, "Ground")
GameLogic.sendMessage("Start", robot , "Robot_"+robot, "Ground")
</syntaxhighlight>

Zoals je kunt zien moet je nu gebruik maken van een array voor het aanmaken van de bestelling. Dan kun je namelijk de functie list() en set() gebruiken voor het eruit halen van dubbele artikelen. Aan de robot kunnen we alleen een string meegeven en daarom moeten we de array nog omzetten in een string. De grootte van de order kan nu 1, 2 of nog steeds 3 zijn.

===Experiment ===
De resultaten zijn nu als volgt:
{| class="wikitable"
! Run !! Afstand
|-
|Run 1 || 495
|-
|Run 2 || 592
|-
|Run 3 || 599
|-
|Run 4 || 437
|-
|Run 5|| 648
|-
|Gemiddelde || 554,2
|}

Te zien is dat de gemiddelde afstand van een run naar beneden is gegaan met 130,6 meter.
Als je deze afstand omzet naar de tijd die de robot daardoor sneller is kun je nadenken of je moet investeren in robots die meer artikelen uit een kast kunnen halen. Wanneer de investering namelijk kleiner is dan de opbrengt zal dit voor extra winst zorgen.

==Efficiëntie verbetering door samenwerking==
Dat we een verbetering zouden zien is natuurlijk begrijpelijk omdat de robots ineens meer kunnen tillen. Interessanter is dat we met deze simulatie hebben kunnen zien wat de efficiëntie winst precies zal zijn en of het zin heeft om in deze complexere machines te investeren.

We gaan nu kijken naar de efficiëntie verbetering is door met een team van 2 robots te werken. Naast de vermindering in totaal gelopen meters gaan we nu ook kijken naar de tijd die het kost om de orders in te pakken.

===Creëren team===
De robots gaan nu in tweetallen werken om de artikelen op te halen. Er zijn veel mogelijkheden hoe de robots samen kunnen werken. Verdelen van soorten artikelen, eerstvolgende artikel op de lijst ophalen, eerst de verste artikelen etc. Omdat de robots naast elkaar staan maakt het qua gelopen afstand niet veel uit welke robot welk artikel haalt. Het gaat hier dus vooral om de winst in tijd.
We gaan twee verschillende algoritmen implementeren. Eerst geven we de robots verantwoordelijkheid over de helft van de artikelen en vervolgens kijken we naar een goede verdeling op basis van de binnengekregen order.

Om een team aan het werk te kunnen zetten, moeten we wel een team hebben. Selecteer Robot_11 en kopieer de robot (ctrl+c, ctrl+v voor Windows en cmd+c, cmd+v voor Mac) druk op de toets G en de toets X en sleep robot naar achter. Je hebt nu twee robots:

[[Bestand:2_robots.png]]

Verander de naam van de tweede robot in Robot_10 op de volgende manier:

[[Bestand:rename_robot.png]]

Verwijder de extra python controllers door deze te selecteren en op ‘x’ te drukken. Zorg ervoor dat je alleen de twee onderstaande controllers overhoudt:

[[Bestand:delete_controllers.png]]

Voeg de robot controller toe aan Robot_10:

[[Bestand:change_controller.png]]

===Veranderingen centrale controller===
We nemen de code weer stap voor stap onder handen. Bij het definiëren van de box_articles is het nu handiger als de “Shelf_” er niet voor staat. Waarom zien we zo.
<syntaxhighlight lang="Python">
# define game properties
central["boxes_tot"] = 5
central["box_size"] = 3
box_articles = [1,2,3,4,5,6,7,8]
</syntaxhighlight>

In plaats dat we nu een robot meegeven aan Send_order() geven we een team mee. We moeten nu ook bijhouden of de robots op hun teammaatje aan het wachten zijn voordat een nieuwe order kan gaan starten. Hiervoor maken we een array aan met de waarden 0/1 voor 11 robots. Naast de afstand houden we ook de tijd bij.

<syntaxhighlight lang="Python">
if sens.positive:
robot_team = ["10","11"]
central["active_robots"] = [0,0,0,0,0,0,0,0,0,0,0]
central["distance"] =0
central["time"] = 0.0
Send_order(robot_team)
</syntaxhighlight>

De order wordt nu twee keer zo lang omdat de robots samen werken. We knippen de order op bij artikel 4. Robot 10 gaat dus artikelen 1, 2, 3 en 4 ophalen en Robot 11 de rest:

<syntaxhighlight lang="Python">
def Send_order(robot_team):
pre_order = [random.choice(box_articles) for t in range(len(robot_team)*central["box_size"])]
pre_order = list(set(pre_order))
pre_order.sort()
order = ""
order2= ""

for j in range(len(pre_order)):
if j <= len(pre_order)/2 -1 :
order += " Shelf_" + str(pre_order[j])
else:
order2 += " Shelf_" + str(pre_order[j])
GameLogic.sendMessage("Start", order , "Robot_"+robot_team[0] , "Ground")
GameLogic.sendMessage("Start", robot_team[0] , "Robot_"+robot_team[0] , "Ground")
central["active_robots"][int(robot_team[0])-1]=1
GameLogic.sendMessage("Start", order2 , "Robot_"+robot_team[1] , "Ground")
GameLogic.sendMessage("Start", robot_team[1] , "Robot_"+robot_team[1] , "Ground")
central["active_robots"][int(robot_team[1])-1]=1
</syntaxhighlight>

Wanneer de robot klaar is met zijn deel van de bestelling moet hij wachten op zijn teamgenoot voordat er een nieuwe order kan starten. Dit kan op de volgende manier geprogrammeerd worden:

<syntaxhighlight lang="Python">
if message.positive:
central["active_robots"][int(message.bodies[0])-1]=0
central["distance"] += float(message.bodies[1])
if central["boxes_done"] < central["boxes_tot"]-1 and central["active_robots"][10-1]+central["active_robots"][11-1]==0:
central["boxes_done"] +=1
print("number of boxes done:")
print(central["boxes_done"])
Send_order(["10","11"])
if sum(central["active_robots"]) == 0:
print("Total walked distance:")
print(central["distance"])
print(central["time"])

central["time"]+= 1/60
</syntaxhighlight>

De tijd wordt bijgehouden met central[“time”]. Hiervoor moet je een Always sensor toevoegen met een pulse. Deze geeft 60 keer per seconde een pulse aan de central controller. Door bij iedere pulse 1/60 toe te voegen aan de variabele, kunnen we de tijd bijhouden.

[[Bestand:add_pulse.png]]

In de robot.py kun je print(“done robot 11”) vervangen door onderstaande regel:

<syntaxhighlight lang="Python">
print("done robot "+ str(robot["robot_id"]))
</syntaxhighlight>

===Experiment===
Hieronder staan de resultaten van een experiment.

''Experiment 1''

{| class="wikitable"
! Run !! Afstand !! Tijd
|-
|Run 1 || 929 || 124
|-
|Run 2 || 879 || 134
|-
|Run 3 || 1092 || 154
|-
|Run 4 || 863 || 121
|-
|Run 5|| 805 || 109
|-
|Gemiddelde || 913,6 || 128,4
|}

Als we de gemiddelde afstand willen vergelijken met de afstanden uit de vorige experimenten moeten we dit getal eerst delen door 2 omdat er nu 2 keer zoveel bestellingen gedaan worden. We zien dan weer een verbetering in het totaal gelopen meters. Omdat dit niet erg verassend is gaan we nu kijken naar het tweede algoritme. Hier bekijken we een slimmere aanpak voor het verdelen van de artikelen in de order zodat de robots minder lang op elkaar wachten. We kunnen zo een winst in tijd behalen.

''Experiment 2''

Nu kan het voorkomen dat het aantal op te halen artikelen erg verschillend is doordat de artikelen alleen in kast 1 t/m 4 of 5 t/m 8 staan. Dit willen we gaan verbeteren. Dit kun je op de volgende manier doen: kijk naar het aantal artikelen in de array pre_order en deel dit door 2. Bij een oneven aantal artikelen krijgt Robot 11 het extra artikel. De code ziet er dan als volgt uit:

<syntaxhighlight lang="Python">
def Send_order(robot_team):
pre_order = [random.choice(box_articles) for t in range(len(robot_team)*central["box_size"])]
pre_order = list(set(pre_order))
pre_order.sort()
order = ""
order2= ""

for j in range(len(pre_order)):
if j <= len(pre_order)/2 -1 :
order += " Shelf_" + str(pre_order[j])
else:
order2 += " Shelf_" + str(pre_order[j])
</syntaxhighlight>

De resultaten van het experiment zijn nu:

{| class="wikitable"
! Run !! Afstand !! Tijd
|-
|Run 1 || 950 || 114
|-
|Run 2 || 940 || 111
|-
|Run 3 || 940 || 112
|-
|Run 4 || 993 || 117
|-
|Run 5|| 996 || 116
|-
|Gemiddelde || 963,8 || 114
|}

We zien dat, ondanks de verhoging van het aantal gelopen meters, de totale tijd afgenomen is. Dit is dus een echte verbetering van het algoritme omdat dezelfde opstelling gebruikt wordt maar er slimmer gebruik wordt gemaakt van de robots.

===Plusopdracht===
Bedenk andere manieren om de taken tussen de robots te verdelen om de gelopen afstand of tijd naar beneden te krijgen. Doe hier experimenten mee

Logistieke Robots/les 5

2014-12-17T13:42:46Z

Jacqueline: /* Les 5 - Robots laten samen werken */

{{Zijbalk Logistieke Robots}}

==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.

[[embedvideo]]
http://youtu.be/nEgubbYwRy0
[[/embedvideo]]

== 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:

<syntaxhighlight lang="Python">
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]
</syntaxhighlight>

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.

<syntaxhighlight lang="Python">
GameLogic.sendMessage("Done", robot["robot_id"] , "Ground", "")
GameLogic.sendMessage("Done", str(robot["distance"]) , "Ground", "")
</syntaxhighlight>

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

<syntaxhighlight lang="Python">
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
</syntaxhighlight>

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:

<syntaxhighlight lang="Python">
if sens.positive:
robot = "11"
central["distance"] = 0
Send_order(robot)
</syntaxhighlight>

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:

<syntaxhighlight lang="Python">
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"])
</syntaxhighlight>

=== 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:
{| class="wikitable"
! 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:

<syntaxhighlight lang="Python">
def Send_order(robot_team):
pre_order = [random.choice(box_articles) for t in range(central["box_size"])]
pre_order = list(set(pre_order))
order = ""
for j in range(len(pre_order)):
order += " " + pre_order[j]
GameLogic.sendMessage("Start", order , "Robot_"+robot, "Ground")
GameLogic.sendMessage("Start", robot , "Robot_"+robot, "Ground")
</syntaxhighlight>

Zoals je kunt zien moet je nu gebruik maken van een array voor het aanmaken van de bestelling. Dan kun je namelijk de functie list() en set() gebruiken voor het eruit halen van dubbele artikelen. Aan de robot kunnen we alleen een string meegeven en daarom moeten we de array nog omzetten in een string. De grootte van de order kan nu 1, 2 of nog steeds 3 zijn.

===Experiment ===
De resultaten zijn nu als volgt:
{| class="wikitable"
! Run !! Afstand
|-
|Run 1 || 495
|-
|Run 2 || 592
|-
|Run 3 || 599
|-
|Run 4 || 437
|-
|Run 5|| 648
|-
|Gemiddelde || 554,2
|}

Te zien is dat de gemiddelde afstand van een run naar beneden is gegaan met 130,6 meter.
Als je deze afstand omzet naar de tijd die de robot daardoor sneller is kun je nadenken of je moet investeren in robots die meer artikelen uit een kast kunnen halen. Wanneer de investering namelijk kleiner is dan de opbrengt zal dit voor extra winst zorgen.

==Efficiëntie verbetering door samenwerking==
Dat we een verbetering zouden zien is natuurlijk begrijpelijk omdat de robots ineens meer kunnen tillen. Interessanter is dat we met deze simulatie hebben kunnen zien wat de efficiëntie winst precies zal zijn en of het zin heeft om in deze complexere machines te investeren.

We gaan nu kijken naar de efficiëntie verbetering is door met een team van 2 robots te werken. Naast de vermindering in totaal gelopen meters gaan we nu ook kijken naar de tijd die het kost om de orders in te pakken.

===Creëren team===
De robots gaan nu in tweetallen werken om de artikelen op te halen. Er zijn veel mogelijkheden hoe de robots samen kunnen werken. Verdelen van soorten artikelen, eerstvolgende artikel op de lijst ophalen, eerst de verste artikelen etc. Omdat de robots naast elkaar staan maakt het qua gelopen afstand niet veel uit welke robot welk artikel haalt. Het gaat hier dus vooral om de winst in tijd.
We gaan twee verschillende algoritmen implementeren. Eerst geven we de robots verantwoordelijkheid over de helft van de artikelen en vervolgens kijken we naar een goede verdeling op basis van de binnengekregen order.

Om een team aan het werk te kunnen zetten, moeten we wel een team hebben. Selecteer Robot_11 en kopieer de robot (ctrl+c, ctrl+v voor Windows en cmd+c, cmd+v voor Mac) druk op de toets G en de toets X en sleep robot naar achter. Je hebt nu twee robots:

[[Bestand:2_robots.png]]

Verander de naam van de tweede robot in Robot_10 op de volgende manier:

[[Bestand:rename_robot.png]]

Verwijder de extra python controllers door deze te selecteren en op ‘x’ te drukken. Zorg ervoor dat je alleen de twee onderstaande controllers overhoudt:

[[Bestand:delete_controllers.png]]

Voeg de robot controller toe aan Robot_10:

[[Bestand:change_controller.png]]

===Veranderingen centrale controller===
We nemen de code weer stap voor stap onder handen. Bij het definiëren van de box_articles is het nu handiger als de “Shelf_” er niet voor staat. Waarom zien we zo.
<syntaxhighlight lang="Python">
# define game properties
central["boxes_tot"] = 5
central["box_size"] = 3
box_articles = [1,2,3,4,5,6,7,8]
</syntaxhighlight>

In plaats dat we nu een robot meegeven aan Send_order() geven we een team mee. We moeten nu ook bijhouden of de robots op hun teammaatje aan het wachten zijn voordat een nieuwe order kan gaan starten. Hiervoor maken we een array aan met de waarden 0/1 voor 11 robots. Naast de afstand houden we ook de tijd bij.

<syntaxhighlight lang="Python">
if sens.positive:
robot_team = ["10","11"]
central["active_robots"] = [0,0,0,0,0,0,0,0,0,0,0]
central["distance"] =0
central["time"] = 0.0
Send_order(robot_team)
</syntaxhighlight>

De order wordt nu twee keer zo lang omdat de robots samen werken. We knippen de order op bij artikel 4. Robot 10 gaat dus artikelen 1, 2, 3 en 4 ophalen en Robot 11 de rest:

<syntaxhighlight lang="Python">
def Send_order(robot_team):
pre_order = [random.choice(box_articles) for t in range(len(robot_team)*central["box_size"])]
pre_order = list(set(pre_order))
pre_order.sort()
order = ""
order2= ""

for j in range(len(pre_order)):
if j <= len(pre_order)/2 -1 :
order += " Shelf_" + str(pre_order[j])
else:
order2 += " Shelf_" + str(pre_order[j])
GameLogic.sendMessage("Start", order , "Robot_"+robot_team[0] , "Ground")
GameLogic.sendMessage("Start", robot_team[0] , "Robot_"+robot_team[0] , "Ground")
central["active_robots"][int(robot_team[0])-1]=1
GameLogic.sendMessage("Start", order2 , "Robot_"+robot_team[1] , "Ground")
GameLogic.sendMessage("Start", robot_team[1] , "Robot_"+robot_team[1] , "Ground")
central["active_robots"][int(robot_team[1])-1]=1
</syntaxhighlight>

Wanneer de robot klaar is met zijn deel van de bestelling moet hij wachten op zijn teamgenoot voordat er een nieuwe order kan starten. Dit kan op de volgende manier geprogrammeerd worden:

<syntaxhighlight lang="Python">
if message.positive:
central["active_robots"][int(message.bodies[0])-1]=0
central["distance"] += float(message.bodies[1])
if central["boxes_done"] < central["boxes_tot"]-1 and central["active_robots"][10-1]+central["active_robots"][11-1]==0:
central["boxes_done"] +=1
print("number of boxes done:")
print(central["boxes_done"])
Send_order(["10","11"])
if sum(central["active_robots"]) == 0:
print("Total walked distance:")
print(central["distance"])
print(central["time"])

central["time"]+= 1/60
</syntaxhighlight>

De tijd wordt bijgehouden met central[“time”]. Hiervoor moet je een Always sensor toevoegen met een pulse. Deze geeft 60 keer per seconde een pulse aan de central controller. Door bij iedere pulse 1/60 toe te voegen aan de variabele, kunnen we de tijd bijhouden.

[[Bestand:add_pulse.png]]

In de robot.py kun je print(“done robot 11”) vervangen door onderstaande regel:

<syntaxhighlight lang="Python">
print("done robot "+ str(robot["robot_id"]))
</syntaxhighlight>

===Experiment===
Hieronder staan de resultaten van een experiment.

''Experiment 1''

{| class="wikitable"
! Run !! Afstand !! Tijd
|-
|Run 1 || 929 || 124
|-
|Run 2 || 879 || 134
|-
|Run 3 || 1092 || 154
|-
|Run 4 || 863 || 121
|-
|Run 5|| 805 || 109
|-
|Gemiddelde || 913,6 || 128,4
|}

Als we de gemiddelde afstand willen vergelijken met de afstanden uit de vorige experimenten moeten we dit getal eerst delen door 2 omdat er nu 2 keer zoveel bestellingen gedaan worden. We zien dan weer een verbetering in het totaal gelopen meters. Omdat dit niet erg verassend is gaan we nu kijken naar het tweede algoritme. Hier bekijken we een slimmere aanpak voor het verdelen van de artikelen in de order zodat de robots minder lang op elkaar wachten. We kunnen zo een winst in tijd behalen.

''Experiment 2''

Nu kan het voorkomen dat het aantal op te halen artikelen erg verschillend is doordat de artikelen alleen in kast 1 t/m 4 of 5 t/m 8 staan. Dit willen we gaan verbeteren. Dit kun je op de volgende manier doen: kijk naar het aantal artikelen in de array pre_order en deel dit door 2. Bij een oneven aantal artikelen krijgt Robot 11 het extra artikel. De code ziet er dan als volgt uit:

<syntaxhighlight lang="Python">
def Send_order(robot_team):
pre_order = [random.choice(box_articles) for t in range(len(robot_team)*central["box_size"])]
pre_order = list(set(pre_order))
pre_order.sort()
order = ""
order2= ""

for j in range(len(pre_order)):
if j <= len(pre_order)/2 -1 :
order += " Shelf_" + str(pre_order[j])
else:
order2 += " Shelf_" + str(pre_order[j])
</syntaxhighlight>

De resultaten van het experiment zijn nu:

{| class="wikitable"
! Run !! Afstand !! Tijd
|-
|Run 1 || 950 || 114
|-
|Run 2 || 940 || 111
|-
|Run 3 || 940 || 112
|-
|Run 4 || 993 || 117
|-
|Run 5|| 996 || 116
|-
|Gemiddelde || 963,8 || 114
|}

We zien dat, ondanks de verhoging van het aantal gelopen meters, de totale tijd afgenomen is. Dit is dus een echte verbetering van het algoritme omdat dezelfde opstelling gebruikt wordt maar er slimmer gebruik wordt gemaakt van de robots.

===Plusopdracht===
Bedenk andere manieren om de taken tussen de robots te verdelen om de gelopen afstand of tijd naar beneden te krijgen. Doe hier experimenten mee

Logistieke Robots/les 5

2014-12-17T13:41:51Z

Jacqueline: /* Les 5 - Robots laten samen werken */

{{Zijbalk Logistieke Robots}}

==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.

[[embedvideo]]
<iframe width="420" height="315" src="//www.youtube.com/embed/nEgubbYwRy0" frameborder="0" allowfullscreen></iframe>
[[/embedvideo]]

== 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:

<syntaxhighlight lang="Python">
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]
</syntaxhighlight>

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.

<syntaxhighlight lang="Python">
GameLogic.sendMessage("Done", robot["robot_id"] , "Ground", "")
GameLogic.sendMessage("Done", str(robot["distance"]) , "Ground", "")
</syntaxhighlight>

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

<syntaxhighlight lang="Python">
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
</syntaxhighlight>

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:

<syntaxhighlight lang="Python">
if sens.positive:
robot = "11"
central["distance"] = 0
Send_order(robot)
</syntaxhighlight>

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:

<syntaxhighlight lang="Python">
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"])
</syntaxhighlight>

=== 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:
{| class="wikitable"
! 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:

<syntaxhighlight lang="Python">
def Send_order(robot_team):
pre_order = [random.choice(box_articles) for t in range(central["box_size"])]
pre_order = list(set(pre_order))
order = ""
for j in range(len(pre_order)):
order += " " + pre_order[j]
GameLogic.sendMessage("Start", order , "Robot_"+robot, "Ground")
GameLogic.sendMessage("Start", robot , "Robot_"+robot, "Ground")
</syntaxhighlight>

Zoals je kunt zien moet je nu gebruik maken van een array voor het aanmaken van de bestelling. Dan kun je namelijk de functie list() en set() gebruiken voor het eruit halen van dubbele artikelen. Aan de robot kunnen we alleen een string meegeven en daarom moeten we de array nog omzetten in een string. De grootte van de order kan nu 1, 2 of nog steeds 3 zijn.

===Experiment ===
De resultaten zijn nu als volgt:
{| class="wikitable"
! Run !! Afstand
|-
|Run 1 || 495
|-
|Run 2 || 592
|-
|Run 3 || 599
|-
|Run 4 || 437
|-
|Run 5|| 648
|-
|Gemiddelde || 554,2
|}

Te zien is dat de gemiddelde afstand van een run naar beneden is gegaan met 130,6 meter.
Als je deze afstand omzet naar de tijd die de robot daardoor sneller is kun je nadenken of je moet investeren in robots die meer artikelen uit een kast kunnen halen. Wanneer de investering namelijk kleiner is dan de opbrengt zal dit voor extra winst zorgen.

==Efficiëntie verbetering door samenwerking==
Dat we een verbetering zouden zien is natuurlijk begrijpelijk omdat de robots ineens meer kunnen tillen. Interessanter is dat we met deze simulatie hebben kunnen zien wat de efficiëntie winst precies zal zijn en of het zin heeft om in deze complexere machines te investeren.

We gaan nu kijken naar de efficiëntie verbetering is door met een team van 2 robots te werken. Naast de vermindering in totaal gelopen meters gaan we nu ook kijken naar de tijd die het kost om de orders in te pakken.

===Creëren team===
De robots gaan nu in tweetallen werken om de artikelen op te halen. Er zijn veel mogelijkheden hoe de robots samen kunnen werken. Verdelen van soorten artikelen, eerstvolgende artikel op de lijst ophalen, eerst de verste artikelen etc. Omdat de robots naast elkaar staan maakt het qua gelopen afstand niet veel uit welke robot welk artikel haalt. Het gaat hier dus vooral om de winst in tijd.
We gaan twee verschillende algoritmen implementeren. Eerst geven we de robots verantwoordelijkheid over de helft van de artikelen en vervolgens kijken we naar een goede verdeling op basis van de binnengekregen order.

Om een team aan het werk te kunnen zetten, moeten we wel een team hebben. Selecteer Robot_11 en kopieer de robot (ctrl+c, ctrl+v voor Windows en cmd+c, cmd+v voor Mac) druk op de toets G en de toets X en sleep robot naar achter. Je hebt nu twee robots:

[[Bestand:2_robots.png]]

Verander de naam van de tweede robot in Robot_10 op de volgende manier:

[[Bestand:rename_robot.png]]

Verwijder de extra python controllers door deze te selecteren en op ‘x’ te drukken. Zorg ervoor dat je alleen de twee onderstaande controllers overhoudt:

[[Bestand:delete_controllers.png]]

Voeg de robot controller toe aan Robot_10:

[[Bestand:change_controller.png]]

===Veranderingen centrale controller===
We nemen de code weer stap voor stap onder handen. Bij het definiëren van de box_articles is het nu handiger als de “Shelf_” er niet voor staat. Waarom zien we zo.
<syntaxhighlight lang="Python">
# define game properties
central["boxes_tot"] = 5
central["box_size"] = 3
box_articles = [1,2,3,4,5,6,7,8]
</syntaxhighlight>

In plaats dat we nu een robot meegeven aan Send_order() geven we een team mee. We moeten nu ook bijhouden of de robots op hun teammaatje aan het wachten zijn voordat een nieuwe order kan gaan starten. Hiervoor maken we een array aan met de waarden 0/1 voor 11 robots. Naast de afstand houden we ook de tijd bij.

<syntaxhighlight lang="Python">
if sens.positive:
robot_team = ["10","11"]
central["active_robots"] = [0,0,0,0,0,0,0,0,0,0,0]
central["distance"] =0
central["time"] = 0.0
Send_order(robot_team)
</syntaxhighlight>

De order wordt nu twee keer zo lang omdat de robots samen werken. We knippen de order op bij artikel 4. Robot 10 gaat dus artikelen 1, 2, 3 en 4 ophalen en Robot 11 de rest:

<syntaxhighlight lang="Python">
def Send_order(robot_team):
pre_order = [random.choice(box_articles) for t in range(len(robot_team)*central["box_size"])]
pre_order = list(set(pre_order))
pre_order.sort()
order = ""
order2= ""

for j in range(len(pre_order)):
if j <= len(pre_order)/2 -1 :
order += " Shelf_" + str(pre_order[j])
else:
order2 += " Shelf_" + str(pre_order[j])
GameLogic.sendMessage("Start", order , "Robot_"+robot_team[0] , "Ground")
GameLogic.sendMessage("Start", robot_team[0] , "Robot_"+robot_team[0] , "Ground")
central["active_robots"][int(robot_team[0])-1]=1
GameLogic.sendMessage("Start", order2 , "Robot_"+robot_team[1] , "Ground")
GameLogic.sendMessage("Start", robot_team[1] , "Robot_"+robot_team[1] , "Ground")
central["active_robots"][int(robot_team[1])-1]=1
</syntaxhighlight>

Wanneer de robot klaar is met zijn deel van de bestelling moet hij wachten op zijn teamgenoot voordat er een nieuwe order kan starten. Dit kan op de volgende manier geprogrammeerd worden:

<syntaxhighlight lang="Python">
if message.positive:
central["active_robots"][int(message.bodies[0])-1]=0
central["distance"] += float(message.bodies[1])
if central["boxes_done"] < central["boxes_tot"]-1 and central["active_robots"][10-1]+central["active_robots"][11-1]==0:
central["boxes_done"] +=1
print("number of boxes done:")
print(central["boxes_done"])
Send_order(["10","11"])
if sum(central["active_robots"]) == 0:
print("Total walked distance:")
print(central["distance"])
print(central["time"])

central["time"]+= 1/60
</syntaxhighlight>

De tijd wordt bijgehouden met central[“time”]. Hiervoor moet je een Always sensor toevoegen met een pulse. Deze geeft 60 keer per seconde een pulse aan de central controller. Door bij iedere pulse 1/60 toe te voegen aan de variabele, kunnen we de tijd bijhouden.

[[Bestand:add_pulse.png]]

In de robot.py kun je print(“done robot 11”) vervangen door onderstaande regel:

<syntaxhighlight lang="Python">
print("done robot "+ str(robot["robot_id"]))
</syntaxhighlight>

===Experiment===
Hieronder staan de resultaten van een experiment.

''Experiment 1''

{| class="wikitable"
! Run !! Afstand !! Tijd
|-
|Run 1 || 929 || 124
|-
|Run 2 || 879 || 134
|-
|Run 3 || 1092 || 154
|-
|Run 4 || 863 || 121
|-
|Run 5|| 805 || 109
|-
|Gemiddelde || 913,6 || 128,4
|}

Als we de gemiddelde afstand willen vergelijken met de afstanden uit de vorige experimenten moeten we dit getal eerst delen door 2 omdat er nu 2 keer zoveel bestellingen gedaan worden. We zien dan weer een verbetering in het totaal gelopen meters. Omdat dit niet erg verassend is gaan we nu kijken naar het tweede algoritme. Hier bekijken we een slimmere aanpak voor het verdelen van de artikelen in de order zodat de robots minder lang op elkaar wachten. We kunnen zo een winst in tijd behalen.

''Experiment 2''

Nu kan het voorkomen dat het aantal op te halen artikelen erg verschillend is doordat de artikelen alleen in kast 1 t/m 4 of 5 t/m 8 staan. Dit willen we gaan verbeteren. Dit kun je op de volgende manier doen: kijk naar het aantal artikelen in de array pre_order en deel dit door 2. Bij een oneven aantal artikelen krijgt Robot 11 het extra artikel. De code ziet er dan als volgt uit:

<syntaxhighlight lang="Python">
def Send_order(robot_team):
pre_order = [random.choice(box_articles) for t in range(len(robot_team)*central["box_size"])]
pre_order = list(set(pre_order))
pre_order.sort()
order = ""
order2= ""

for j in range(len(pre_order)):
if j <= len(pre_order)/2 -1 :
order += " Shelf_" + str(pre_order[j])
else:
order2 += " Shelf_" + str(pre_order[j])
</syntaxhighlight>

De resultaten van het experiment zijn nu:

{| class="wikitable"
! Run !! Afstand !! Tijd
|-
|Run 1 || 950 || 114
|-
|Run 2 || 940 || 111
|-
|Run 3 || 940 || 112
|-
|Run 4 || 993 || 117
|-
|Run 5|| 996 || 116
|-
|Gemiddelde || 963,8 || 114
|}

We zien dat, ondanks de verhoging van het aantal gelopen meters, de totale tijd afgenomen is. Dit is dus een echte verbetering van het algoritme omdat dezelfde opstelling gebruikt wordt maar er slimmer gebruik wordt gemaakt van de robots.

===Plusopdracht===
Bedenk andere manieren om de taken tussen de robots te verdelen om de gelopen afstand of tijd naar beneden te krijgen. Doe hier experimenten mee

Bestand:Grafiek 2.png

2014-12-09T15:56:30Z

Jacqueline:

Bestand:Grafiek 1.png

2014-12-09T15:55:54Z

Jacqueline:

Bestand:Grafiek maken excel.png

2014-12-09T15:55:36Z

Jacqueline:

Bestand:Excel waarden.png

2014-12-09T15:55:14Z

Jacqueline:

Logistieke Robots/les 7

2014-12-09T15:54:35Z

Jacqueline: Nieuwe pagina aangemaakt met '{{Zijbalk Logistieke Robots}} ==Les 7 - Algoritmen met elkaar vergelijken == De eerste vraag die we natuurlijk willen onderzoeken is: werkt dit echt? Zorgt dit al...'

{{Zijbalk Logistieke Robots}}

==Les 7 - Algoritmen met elkaar vergelijken ==

De eerste vraag die we natuurlijk willen onderzoeken is: werkt dit echt? Zorgt dit algoritme echt voor een verbetering ten opzichte van niet met elkaar communiceren? Voordat we hier echt uitspraken over kunnen doen, moeten we eerst veel experimenteren.
Let daarbij ook op het feit dat het simuleren met robots ontzettend lastig is. Er kan, zoals je misschien wel gezien hebt, van alles verkeerd gaan. Robot kunnen vast blijven zitten tussen de kasten, elkaar steeds in de radar hebben en daardoor niet verder kunnen etc. De simulaties die in deze les gedaan zijn kunnen dan ook erg verschillen van jouw resultaten. Dit is helemaal niet erg. Er is ook geen beste oplossing en het is ontzettend lastig om de juiste waarden te vinden die ervoor zorgen dat de robots snel van elkaar leren. Maar dit maakt het ook weer erg leuk!

We gaan op de volgende manier ons algoritme testen:
We gaan eerst experimenten doen met waarden van de robots niet veranderen. Wanneer we hier een aantal runs van gedaan hebben, hebben we een idee van de prestatie van het algoritme zonder leren. Vervolgens laten we de waarden wel veranderen met ons evolutionair algoritme. We kunnen nu de uitkomsten van beide manieren met elkaar vergelijken.

We moeten dan alles onder “# update values” in commentaar zetten door voor iedere regels een # te zetten. Laat de robots totaal 50 boxen vullen en zet de robots aan het werk. In het terminal venster zie je de orders geprint worden en je ziet ook een array die steeds groter wordt naarmate de robots langer bezig zijn. Dit is het central[“algorithm”] array en geeft per minuut het aantal botsingen weer.
Doe 5 keer een run. Het kan gebeuren dat de robots vast lopen. Stop deze run dan en probeer het opnieuw. Wanneer dit vaak gebeurd, open Blender dan opnieuw. Hieronder staat de ruwe data van 5 complete runs:

Run 1:
Prestatie:
[28.0, 4.0, 2.0, 18.0, 0.0, 4.0, 4.0, 6.0, 0.0, 6.0, 32.0]
[[0.0, 1.1033122539520264, 1.4639674425125122, Robot_6], [0.0, 1.2986571788787842, 0.5416139364242554, Robot_10], [0.0, 0.651454746723175, 1.3667792081832886, Robot_11], [3.0, 1.9125906229019165, 1.1833915710449219, Robot_9], [8.0, 0.0756225660443306, 1.3220340013504028, Robot_7], [21.0, 1.4247708320617676, 1.0523004531860352, Robot_8]]
Total walked distance:
13691
659.673114329765

Run 2:
[2.0, 29.0, 9.0, 13.0, 55.0, 9.0, 18.0, 0.0, 8.0, 22.0, 12.0]
[[0.0, 0.11781859397888184, 0.6557546257972717, Robot_9], [0.0, 1.0547598600387573, 0.571683406829834, Robot_11], [1.0, 1.167196273803711, 1.976454496383667, Robot_6], [1.0, 1.3991421461105347, 1.4800572395324707, Robot_8], [5.0, 1.9634203910827637, 1.1145190000534058, Robot_7], [5.0, 1.4843071699142456, 0.8718631267547607, Robot_10]]
Total walked distance:
13488
660.432861328125

Run 3:
[105.0, 8.0, 27.0, 8.0, 24.0, 34.0, 41.0, 4.0, 0.0, 0.0, 26.0]
[[0.0, 0.6206476092338562, 1.2706804275512695, Robot_6], [0.0, 1.888157606124878, 0.8151676058769226, Robot_7], [0.0, 1.1586012840270996, 1.4619909524917603, Robot_8], [3.0, 1.3452816009521484, 1.9687161445617676, Robot_11], [8.0, 0.7305728793144226, 0.9222739934921265, Robot_10], [15.0, 0.5778017044067383, 1.1174777746200562, Robot_9]]
Total walked distance:
14184
660.0662841796875

Run 4:
[14.0, 18.0, 29.0, 4.0, 12.0, 31.0, 6.0, 8.0, 33.0, 0.0, 6.0] [[0.0, 0.5198497176170349, 1.950926661491394, Robot_6], [0.0, 0.5083528757095337, 1.4684268236160278, Robot_9], [0.0, 0.339052677154541, 1.2538245916366577, Robot_11], [1.0, 1.4567952156066895, 1.5516620874404907, Robot_7], [11.0, 1.5452338457107544, 0.8980489373207092, Robot_10], [21.0, 0.24807365238666534, 0.017792876809835434, Robot_8]]
Total walked distance:
13029
559.6408081054688

Run 5:
[6.0, 16.0, 4.0, 4.0, 54.0, 14.0, 24.0, 15.0, 10.0, 43.0]
[[0.0, 1.8651994466781616, 0.8983461260795593, Robot_6], [0.0, 0.7337772846221924, 1.389615535736084, Robot_8], [0.0, 0.24811603128910065, 1.3182649612426758, Robot_9], [0.0, 1.664925456047058, 0.2161814123392105, Robot_11], [2.0, 0.9058579206466675, 1.5737985372543335, Robot_7], [41.0, 1.09906005859375, 1.6222947835922241, Robot_10]]
Total walked distance:
13590
600.0642700195312

We willen deze waarden presenteren in een grafiek. Open Excel en typ de waarden over:

[[Bestand: excel_waarden.png]]

Het kan zijn dat niet alle cellen gevuld zijn omdat het inpakken de ene keer sneller ging dan de andere keer. Selecteer de waarden in kolom 2-7 en voeg een grafiek toe:

[[Bestand: grafiek_maken_excel.png]]

De volgende grafiek ontstaat nu:

[[Bestand: grafiek_1.png]]

Pas op dit moment kunnen we iets zeggen over de prestatie van het algoritme.
We zien erg veel variatie in het aantal botsingen per minuut en tussen de runs. Verschil tussen de runs kan komen door de verschillende (willekeurige) startwaarden. Wel kunnen we vaststellen dat geen een run een klein aantal botsingen heeft voor iedere minuut.

We gaan nu experimenten doen waarbij de robots van elkaar leren. We hopen hierbij te zien dat het aantal botsingen een dalende lijn is bij iedere run.
We zeggen hier met nadruk “hopen” omdat je niet zeker weet of dit het geval is. Doe weer een aantal runs.

Run 1:
[69.0, 0.0, 4.0, 2.0, 47.0, 0.0, 50.0, 2.0, 0.0, 6.0, 2.0]
[[0.0, 2.146437644958496, 1.5113431215286255, Robot_6], [0.0, 1.5602511167526245, 1.0936894416809082, Robot_7], [0.0, 1.9991168975830078, 1.5253989696502686, Robot_8], [0.0, 1.5248929262161255, 0.983869194984436, Robot_9], [0.0, 1.957208514213562, 1.5127331018447876, Robot_10], [0.0, 1.8197909593582153, 1.096867561340332, Robot_11]]
Total walked distance:
13318
720.0682983398438

Run 2:
[37.0, 17.0, 8.0, 4.0, 0.0, 0.0, 0.0, 13.0, 31.0, 4.0]
[[0.0, 2.028287887573242, 0.7059972286224365, Robot_6], [0.0, 2.0065548419952393, 1.0062334537506104, Robot_8], [0.0, 2.313992977142334, 0.997683584690094, Robot_9], [0.0, 2.0005781650543213, 0.9316716194152832, Robot_10], [2.0, 2.1137619018554688, 0.9539632797241211, Robot_7], [2.0, 2.295074224472046, 1.1398147344589233, Robot_11]]
Total walked distance:
12566
600.0642700195312

Run 3:
[13.0, 12.0, 6.0, 30.0, 2.0, 2.0, 30.0, 17.0]
[[0.0, 0.4430656433105469, 0.5342904329299927, Robot_10], [0.0, 0.5598312020301819, 0.3072521984577179, Robot_11], [1.0, 0.3825035095214844, 0.6534862518310547, Robot_9], [4.0, 0.4900607466697693, 0.3672640025615692, Robot_7], [5.0, 0.6171832084655762, 0.5994473695755005, Robot_8], [7.0, 0.32172659039497375, 0.5386554598808289, Robot_6]]
Total walked distance:
12057
480.06024169921875

Run 4:
[13.0, 0.0, 7.0, 0.0, 0.0, 0.0, 6.0, 6.0, 2.0, 0.0]
[[0.0, 1.5696516036987305, 0.019686052575707436, Robot_6], [0.0, 1.553520679473877, 0.2368871420621872, Robot_7], [0.0, 1.6649249792099, 0.3868585228919983, Robot_8], [0.0, 1.4215301275253296, 0.05945594608783722, Robot_9], [0.0, 1.315022349357605, 0.0, Robot_10], [0.0, 1.4969103336334229, 0.0028564489912241697, Robot_11]]
Total walked distance:
12796
600.0642700195312

Run 5:
[6.0, 0.0, 4.0, 20.0, 0.0, 0.0, 0.0, 64.0, 13.0]
[[0.0, 1.2154109477996826, 1.8105230331420898, Robot_6], [0.0, 1.3451547622680664, 1.8669763803482056, Robot_7], [0.0, 1.3241212368011475, 1.782742977142334, Robot_9], [0.0, 1.600753664970398, 1.936579942703247, Robot_11], [2.0, 1.7318297624588013, 2.0279102325439453, Robot_8], [3.0, 1.4447206258773804, 1.689884901046753, Robot_10]]
Total walked distance:
15149
720.0682983398438

Wanneer we van deze resultaten een grafiek maken krijgen we het volgende:

[[Bestand: grafiek_2.png]]

We zien duidelijk dat het aantal botsingen in de eerste paar minuten afnemen. Dit kan zijn omdat de slechte strategieën snel vervangen worden door de betere. Hierna zien we jammer genoeg weer een stijging.
Iedere run zal anders zijn en jouw grafiek zal vast verschillen van degene die hierboven staat. In de grafiek hierboven kun je een interessant gegeven halen. We zien namelijk dat Run 4 in iedere minuut een klein aantal botsingen heeft. Het is dan interessant om te kijken naar de waarden van de strategieën in Run 4 en deze al beginwaarden te nemen voor een nieuw experiment. Zo kunnen we de robots voorzien van eerder zelf geleerde kennis!

Belangrijk om te leren van deze les is dat werken met robots in de echte wereld veel moeilijkheden met zich meebrengt. Voor ons is het zo vanzelfsprekend om niet tegen andere mensen aan te botsen maar voor robots is dit helemaal niet het geval. Hoe ga je hiermee om?

==Plusopdracht==
Je kan op dit moment ontzettend veel gaan onderzoeken. Je kan zelf waarden meegeven aan de robots waarvan jij denkt dat het de juiste zijn. Je kan robots verschillende waarden geven zodat ze niet op precies hetzelfde moment weer verder gaan met de bestelling en elkaar weer tegen komen, je kan de variatie die opgeteld wordt bij de nieuwe strategie veranderen. Kortom: je kan van alles proberen om het aantal botsingen naar beneden te krijgen. Je kan zelfs de hele strategie wijzigen, misschien wil je wel dat wanneer de robots elkaar tegen komren op de radar, de een gaat versnellen om de andere robot net voor te zijn? Of wil je dat ze met elkaar communiceren om een plan te maken wie welke kant op stapt?

Logistieke Robots/les 6

2014-12-09T15:47:36Z

Jacqueline:

{{Zijbalk Logistieke Robots}}

==Les 6 - Robots van elkaar laten leren ==
Voordat we naar les 6 gaan, bespreken we een aantal verbeteringen in de huidige code zodat we er vervolgens makkelijker mee kunnen werken. Deze verandering moet je ook doorvoeren als je door wilt werken met je huidige bestand. Je mag ook les 6 starten met de file "warehouse_team_collission.blend".

==Verbetering code na les 5 ==
We gaan een functie set_articles() maken zodat er een array aangemaakt
wordt met de artikelen.

<syntaxhighlight lang="Python" line>
def get_order():
# get articles from central controller
set_articles()
print(robot["articles"])
# set game properties
robot["article_number"] = 1
robot["target_desk"] = False
# distance variables
robot["distance"] = 0.0
robot["location1"] = robot.position[0]
robot["location2"] = robot.position[1]
robot["location3"] = robot.position[2]
</syntaxhighlight>

Vervang ook de declaratie van robot[“robot_id”] door onderstaande. De central controller hoeft zo niet meer te vertellen om welke robot het gaat.

<syntaxhighlight lang="Python" line>
# get the current controller
cont = bge.logic.getCurrentController()
robot = cont.owner
robot["robot_id"] = robot.name[6:]
</syntaxhighlight>

De functie set_articles() ziet er als volgt uit:

<syntaxhighlight lang="Python" line>
def set_articles():
message = start_sens.bodies[0][1:]
order_length = len(re.findall(r'[^\s ]+', message))
robot["articles"] = [""]*order_length
for i in range(order_length):
robot["articles"][i] = re.findall(r'[^\s ]+', message)[i]
</syntaxhighlight>

De main() functie ziet er nu overzichtelijker uit:

<syntaxhighlight lang="Python" line>
def main():
if robot["target_desk"] == False:
shelf_sens.propName = "Shelf"
if robot["article_number"] <= len(robot["articles"]):
track_act.target = robot["articles"][robot["article_number"]-1]
else:
shelf_sens.propName = "Desk"
track_act.target = "Desk_" + str(robot["robot_id"])
if shelf_sens.positive:
if robot["target_desk"] == True:
robot["article_number"] += 1
if robot["article_number"] == len(robot["articles"]) +1:
cont.deactivate(track_act)
print("done robot "+ str(robot["robot_id"]))
GameLogic.sendMessage("Done", robot["robot_id"] , "Ground", "")
GameLogic.sendMessage("Done", str(robot["distance"]) , "Ground", "")
robot["target_desk"]= not robot["target_desk"]
</syntaxhighlight>

We veranderen ook de physics van de robot zodat de robot niet om kan vallen. Ga op de robot staan en ga in het rechter window naar:

[[Bestand:balk_physics.png]]

Verander dan de form factor in 0.0:

[[Bestand:form_factor.png]]

Doe dit voor beide robots.

==Hervat les 6 - Robots van elkaar laten leren ==
Nu we weten hoe we een team aan kunnen sturen en we weten dat er efficiëntie winst te bepalen viel, willen we dit natuurlijk op grote schaal toepassen. Wanneer we meer teams in gaan zetten lopen we wel tegen het probleem aan dat ze elkaar voor de voeten kunnen lopen. Dit probleem gaan we ontdekken en een manier vinden om dit op te lossen.
We kunnen zo’n “botsingen probleem” op 2 manieren op lossen. We kunnen de robot vertellen wat hij moet doen of we kunnen de robot een manier aangeven waardoor de robot zelf kan leren wat een optimaal ontwijkingsmechanisme is. De robots worden nu zelf lerend. Dit laatste is natuurlijk veel leuker en daarom gaan we dat doen.

==Observeren van botsingen==
Open het bestand “warehouse_team_collission.blend” en voeg hier nog twee Morsy robots aan toe op dezelfde manier als in les 5 met de namen Robot_9 en Robot_8.
De centrale controller moet ook veranderd worden omdat we nu twee teams hebben. Doe daarvoor de volgende aanpassingen:

<syntaxhighlight lang="Python" line>
if sens.positive:
robot_team = ["10","11"]
central["active_robots"] = [0,0,0,0,0,0,0,0,0,0,0]
central["distance"] =0
central["time"] = 0.0
Send_order(robot_team)
</syntaxhighlight>

<syntaxhighlight lang="Python" line>
if message.positive:
central["active_robots"][int(message.bodies[0])-1]=0
central["distance"] += float(message.bodies[1])
if central["boxes_done"] < central["boxes_tot"]-1 and central["active_robots"][10-1]+central["active_robots"][11-1]==0:
central["boxes_done"] +=1
print("number of boxes done:")
print(central["boxes_done"])
Send_order(["10","11"])
if central["boxes_done"] < central["boxes_tot"]-1 and central["active_robots"][9-1]+central["active_robots"][8-1]==0:
central["boxes_done"] +=1
print("number of boxes done:")
print(central["boxes_done"])
Send_order(["8","9"])
if sum(central["active_robots"]) == 0:
print("Total walked distance:")
print(central["distance"])
print(central["time"])
</syntaxhighlight>

Wanneer je nu de robots de orders laat verzamelen zie je dat de paden van de robots elkaar kunnen kruizen. Wanneer ze elkaar tegemoet lopen reageren ze niet op elkaar en botsen ze dus tegen elkaar op. Omdat ze allebei naar voren bewegen, komen ze allebei niet voorruit. We kunnen, zoals eerder genoemd, nu twee aanpakken kiezen om hier mee om te gaan:
# We kunnen gedragsregels opstellen voor de robots. De robots weten dat wanneer ze een artikel opgehaald hebben, ze weer terug naar tafel moeten en op deze manier kunnen we ze ook vertellen wat ze moeten doen als ze een andere robot zien. Bijvoorbeeld: doe altijd een stap naar links als je dicht bij een andere robot bent.
# We kunnen de robots ook een methode geven om van elkaar te leren hoe ze om moeten gaan met elkaar. Dit kun je doen als je zelf ook niet precies weet hoe de robots zich moeten gedragen. Deze methode die we hiervoor kunnen gebruiken heet een evolutionair algoritme. Voor een voorbeeld kun je kijken op : https://www.youtube.com/watch?v=AnuLXVp-Zf0. In dit filmpje zie je een e-puck robot aan het leren om obstakels te ontwijken. Dit is ook wat wij willen bereiken.
We kiezen voor algoritme 2 om te laten zien hoe je een robot van slimme kennis voorziet.

== Kunnen reageren op andere robots ==
We gaan er in deze paragraaf voor zorgen dat de robots elkaar kunnen herkennen en op elkaar kunnen reageren. Hiervoor moeten we veranderingen doorvoeren in de opzet van het pakhuis en veranderingen doorvoeren in de controller van de robot.

===Veranderen pakhuis omgeving===
Omdat we de controller van de robot gaan veranderen, mag je robot 9, 10 en 11 weer verwijderen. En de volgende stappen uitvoeren:

'''Stap 1:'''
Voeg aan de robot een string game property toe met de naam “Robot”. Dit is om elkaar te kunnen herkennen met een Radar

'''Stap 2:'''
Zet de Physics Type op Character en vink de box Actor aan:

[[Bestand: balk_actor.png]]

[[Bestand: set_as_actor.png]]

'''Stap 3:'''
Omdat we de robots nu niet meer helemaal kunnen controleren, ze kunnen immers afwijken van de directe route tussen de tafel en de kast, moeten we het pakhuis iets veranderen. Verander de physics van de kasten op de volgende manier:

[[Bestand: change_physics.png]]

Creëer extra wanden door de bestaande wanden te kopiëren, te verplaatsen en om hun as te draaien zodat we er doorheen kunnen blijven kijken. Verwijder Desk 1 t/m Desk 5 en verdeel Desk 6 t/m Desk 11 over de ruimte. De arena ziet er nu als volgt uit, waarbij er bij jou maar 1 robot staat bij Desk 8:

[[Bestand: nieuwe_arena.png]]

===Veranderen robot controller ===
De robots moeten elkaar nu herkennen, hier op reageren en vervolgens weer doorgaan met het ophalen van artikelen. We moeten veel gaan veranderen aan de controller. We nemen dit stap voor stap door:

'''Stap 1:'''
We hebben een extra Radar nodig om een ontwijkactie te starten en we moeten kunnen meten of de robot een goede actie gedaan heeft. Dit doen we met een collission sensor. De always sensor is nodig om de taak weer op te pakken na de ontwijkactie:
[[Bestand: add_radar.png]]

'''Stap 2:'''
De ontwijkactie houdt in dat de robot, na het detecteren van een andere robot, een aantal seconden rondjes draait, weg loopt van de robot en daarna zijn taak weer oppakt. Dit definiëren we in een extra state:
[[Bestand: add_state.png]]

'''Stap 3:'''
Voeg extra game properties toe:
[[Bestand: add_game_property.png]]

'''Stap 4:'''
Het script moet ook onder handen genomen worden. Er moet een extra package geïmporteerd worden omdat we de robot een willekeurige waarde geven voor het draaien om zijn eigen as en het weglopen van de radar locatie:

<syntaxhighlight lang="Python" line>
# import necessary packages
import bge
import GameLogic
import re
import random
</syntaxhighlight>

De extra sensors moeten gedefinieerd worden:

<syntaxhighlight lang="Python" line>
# get sensors and actuators
start_sens = cont.sensors["Start"]
shelf_sens = cont.sensors["Shelf"]
track_act = cont.actuators["TrackTo"]
robot_radar = cont.sensors["RobotRadar"]
robot_collission = cont.sensors["RobotCollission"]
</syntaxhighlight>

Wanneer de robot voor de eerste keer begint met de order, worden de parameters gedefinieerd die te maken hebben met het ontwijken van de andere robot:

<syntaxhighlight lang="Python" line>
if start_sens.positive:
cont.activate(track_act)
print("Start new order:")
get_order()
# set avoidance parameters and evaluation variables
print("begin")
if robot["active"] == False:
robot["sec_rot"] = random.uniform(0,2)
robot["sec_walk"] = random.uniform(0,2)
robot["active"] =True
</syntaxhighlight>

Wanneer een robot iemand op de radar heeft, moet de robot de ontwijkactie uit gaan voeren in de andere state. Ook moet bijgehouden worden of de robot alsnog tegen een ander aan stoot. Wanneer de robot een slechte ontwijkactie heeft en vaak tegen iemand op botst, willen we dat deze robot een nieuwe ontwijkreactie krijgt. Dit noemen we een “reset”. Dit is nodig als de robot ergens vast zit:

<syntaxhighlight lang="Python" line>
if robot_radar.positive == True:
cont.deactivate(track_act)
robot["radar"] +=1
robot["time"] = 0.0
robot.state = 2

if robot_collission.positive:
robot["collission"] +=1

if robot["collission"] >=20:
#reset parameters because its stuck
robot["sec_rot"] = random.uniform(0,2)
robot["sec_walk"] = random.uniform(0,2)
</syntaxhighlight>

In de extra state hebben we gezien dat er nog een “avoiding.py” gemaakt moet worden. Deze ziet er als volgt uit:

<syntaxhighlight lang="Python" line>
# import necessary packages
import bge
import GameLogic
import re

# get the current controller
cont = bge.logic.getCurrentController()
robot = cont.owner
robot["robot_id"] = robot.name[6:]

# get sensors and actuators
rot_act = cont.actuators["Rotate"]
walk_act = cont.actuators["Walk"]
robot_collission2 = cont.sensors["RobotCollission2"]
robot_radar2 = cont.sensors["RobotRadar2"]

robot["time"] += 1/60

if robot["time"] < robot["sec_rot"]:
cont.activate(rot_act)

if robot["time"] > robot["sec_rot"] and robot["time"] < (robot["sec_rot"] + robot["sec_walk"]):
cont.deactivate(rot_act)
cont.activate(walk_act)

if robot["time"] > (robot["sec_rot"] + robot["sec_walk"]):
robot.state =1

if robot_collission2.positive:
robot["collission"] +=1

if robot_radar2.positive:
robot["radar"] +=1
robot["time"] = 0.0
</syntaxhighlight>

Wanneer je de robots nu laat starten met het ophalen van bestellingen, zie je dat ze op elkaar reageren en hun ontwijkactie uitvoeren. De acties die ze uitvoeren zijn hetzelfde maar hoelang ze deze actie uit voeren kan verschillen. Sommige robots zullen beter kunnen ontwijken en sneller door kunnen gaan met hun bestelling dan andere robots. De robots die een goede ontwijkstrategie hebben kunnen hun strategie doorgeven aan de andere robots.

==Optimaliseren van reactie==
Wanneer de robots met hun eigen ontwijkingsstrategie orders gaan verzamelen, zul je verschillen zien in de aanpak. De ene robot draait lang een rondje terwijl de andere robot bijna gelijk weer verder gaat met de bestelling. Je wilt dat de robots van elkaar leren en de beste strategieën nadoen zodat ze totaal zo min mogelijk botsen. Botsen kan er namelijk voor zorgen dat de robot kapot gaat of dat een artikel op de grond valt.
Omdat we 6 robots hebben beginnen we met 6 verschillende strategieën (ieder tweetal met het aantal seconden rondjes draaien en rechtdoor lopen is een strategie). Na een bepaalde tijd moeten we weten hoe goed de strategie van iedere robot is zodat de goede robots dit door kunnen geven aan de andere robots.
Het uitwisselen van deze informatie en het veranderen van de strategie gebeurd in de centrale controller op de volgende manier:

'''Stap 1:'''
Importeer extra package numpy:

<syntaxhighlight lang="Python" line>
# import necessary packages
import bge
import GameLogic
import random
import numpy
</syntaxhighlight>

'''Stap 2:'''
Voeg een extra team toe met robot 6 en 7. Je weet van de vorige les al hoe dit moet.

'''Stap 3:'''
Voeg een extra tijd meting toe om de strategieën te kunnen updaten:
<syntaxhighlight lang="Python" line>
central["time"]+= 1/60
central["time_minute"]+= 1/60
</syntaxhighlight>

'''Stap 4:'''
Per minuut gaan we de strategieën van de robots herzien en veranderen op de volgende manier:
<syntaxhighlight lang="Python" line>
if central["time_minute"] >=60:
central["time_minute"] = 0
robots = ["Robot_6", "Robot_7", "Robot_8", "Robot_9", "Robot_10", "Robot_11"]
result = [[0,0,0,""] for i in range(len(robots))]
alg_result = 0
for i in range(len(robots)):
robot = scene.objects[robots[i]]
result[i][0] = robot["collission"]
result[i][1] = robot["sec_rot"]
result[i][2] = robot["sec_walk"]
result[i][3] = robot
alg_result += robot["collission"]
robot["collission"] = 0
robot["radar"]=0
central["algorithm"].append(alg_result)
# print number of collissions per minute
print(central["algorithm"])
result = sorted(result, key=lambda a_entry: a_entry[0])
print(result)
print("Total walked distance:")
print(central["distance"])
print(central["time"])
# update values
for i in range(len(robots)):
robot = scene.objects[robots[i]]
take_from = random.choice([0,1])
robot["sec_rot"] = max(0,result[take_from][1] + random.gauss(0, 0.1))
robot["sec_walk"] = max(0,result[take_from][2] + random.gauss(0, 0.1))
</syntaxhighlight>

Wat we in deze functie doen is het evalueren van de prestatie van de robots. Met prestatie bedoelen we het aantal keer opbotsen tegen de andere robots. Hoe minder dit gebeurd, hoe beter. Voor iedere robot wordt dit aantal opgeslagen samen met de twee waarden die hiervoor zorgden. Deze prestatie wordt opgeteld bij het algehele resultaat van de groep en de waarden worden weer op 0 gezet voor de volgende minuut.
Vervolgens worden de strategieën van de robots aangepast. We nemen de strategieën van de 2 beste robots, de robots met het minste aantal botsingen, om door te geven aan de anderen. Op deze waarden passen we nog een kleine variatie toe om te kijken of we in de volgende minuut nog een betere strategie tegen gaan komen. Zo kunnen de robots blijven leren.

==Experimenten==
Wanneer je de robots nu aan het werk zet zie je per minuut een update van de prestatie van het algoritme uitgeprint in de Terminal. Het is moeilijk te analyseren of deze methode echt werkt als je alleen naar deze geprinte waarden. Je kan de robots aan het werk zetten en een aantal boxen laten vullen en deze cijfers in de gaten houden maar je kan er pas echt wat over zeggen als je een goed experiment uitvoert. Dit gaan we doen in Les 7.

==Plusopdracht==
Denk alvast na over hoe je kan testen of dit algoritme werkt.

Logistieke Robots/les 6

2014-12-09T15:40:43Z

Jacqueline:

{{Zijbalk Logistieke Robots}}

==Les 6 - Robots van elkaar laten leren ==
Voordat we naar les 6 gaan, bespreken we een aantal verbeteringen in de huidige code zodat we er vervolgens makkelijker mee kunnen werken. Deze verandering moet je ook doorvoeren als je door wilt werken met je huidige bestand. Je mag ook les 6 starten met de file "warehouse_team_collission.blend".

==Verbetering code na les 5 ==
We gaan een functie set_articles() maken zodat er een array aangemaakt
wordt met de artikelen.

<syntaxhighlight lang="Python" line>
def get_order():
# get articles from central controller
set_articles()
print(robot["articles"])
# set game properties
robot["article_number"] = 1
robot["target_desk"] = False
# distance variables
robot["distance"] = 0.0
robot["location1"] = robot.position[0]
robot["location2"] = robot.position[1]
robot["location3"] = robot.position[2]
</syntaxhighlight>

Vervang ook de declaratie van robot[“robot_id”] door onderstaande. De central controller hoeft zo niet meer te vertellen om welke robot het gaat.

<syntaxhighlight lang="Python" line>
# get the current controller
cont = bge.logic.getCurrentController()
robot = cont.owner
robot["robot_id"] = robot.name[6:]
</syntaxhighlight>

De functie set_articles() ziet er als volgt uit:

<syntaxhighlight lang="Python" line>
def set_articles():
message = start_sens.bodies[0][1:]
order_length = len(re.findall(r'[^\s ]+', message))
robot["articles"] = [""]*order_length
for i in range(order_length):
robot["articles"][i] = re.findall(r'[^\s ]+', message)[i]
</syntaxhighlight>

De main() functie ziet er nu overzichtelijker uit:

<syntaxhighlight lang="Python" line>
def main():
if robot["target_desk"] == False:
shelf_sens.propName = "Shelf"
if robot["article_number"] <= len(robot["articles"]):
track_act.target = robot["articles"][robot["article_number"]-1]
else:
shelf_sens.propName = "Desk"
track_act.target = "Desk_" + str(robot["robot_id"])
if shelf_sens.positive:
if robot["target_desk"] == True:
robot["article_number"] += 1
if robot["article_number"] == len(robot["articles"]) +1:
cont.deactivate(track_act)
print("done robot "+ str(robot["robot_id"]))
GameLogic.sendMessage("Done", robot["robot_id"] , "Ground", "")
GameLogic.sendMessage("Done", str(robot["distance"]) , "Ground", "")
robot["target_desk"]= not robot["target_desk"]
</syntaxhighlight>

We veranderen ook de physics van de robot zodat de robot niet om kan vallen. Ga op de robot staan en ga in het rechter window naar:

[[Bestand:balk_physics.png]]

Verander dan de form factor in 0.0:

[[Bestand:form_factor.png]]

Doe dit voor beide robots.

==Hervat les 6 - Robots van elkaar laten leren ==
Nu we weten hoe we een team aan kunnen sturen en we weten dat er efficiëntie winst te bepalen viel, willen we dit natuurlijk op grote schaal toepassen. Wanneer we meer teams in gaan zetten lopen we wel tegen het probleem aan dat ze elkaar voor de voeten kunnen lopen. Dit probleem gaan we ontdekken en een manier vinden om dit op te lossen.
We kunnen zo’n “botsingen probleem” op 2 manieren op lossen. We kunnen de robot vertellen wat hij moet doen of we kunnen de robot een manier aangeven waardoor de robot zelf kan leren wat een optimaal ontwijkingsmechanisme is. De robots worden nu zelf lerend. Dit laatste is natuurlijk veel leuker en daarom gaan we dat doen.

==Observeren van botsingen==
Open het bestand “warehouse_team_collission.blend” en voeg hier nog twee Morsy robots aan toe op dezelfde manier als in les 5 met de namen Robot_9 en Robot_8.
De centrale controller moet ook veranderd worden omdat we nu twee teams hebben. Doe daarvoor de volgende aanpassingen:

<syntaxhighlight lang="Python" line>
if sens.positive:
robot_team = ["10","11"]
central["active_robots"] = [0,0,0,0,0,0,0,0,0,0,0]
central["distance"] =0
central["time"] = 0.0
Send_order(robot_team)
</syntaxhighlight>

<syntaxhighlight lang="Python" line>
if message.positive:
central["active_robots"][int(message.bodies[0])-1]=0
central["distance"] += float(message.bodies[1])
if central["boxes_done"] < central["boxes_tot"]-1 and central["active_robots"][10-1]+central["active_robots"][11-1]==0:
central["boxes_done"] +=1
print("number of boxes done:")
print(central["boxes_done"])
Send_order(["10","11"])
if central["boxes_done"] < central["boxes_tot"]-1 and central["active_robots"][9-1]+central["active_robots"][8-1]==0:
central["boxes_done"] +=1
print("number of boxes done:")
print(central["boxes_done"])
Send_order(["8","9"])
if sum(central["active_robots"]) == 0:
print("Total walked distance:")
print(central["distance"])
print(central["time"])
</syntaxhighlight>

Wanneer je nu de robots de orders laat verzamelen zie je dat de paden van de robots elkaar kunnen kruizen. Wanneer ze elkaar tegemoet lopen reageren ze niet op elkaar en botsen ze dus tegen elkaar op. Omdat ze allebei naar voren bewegen, komen ze allebei niet voorruit. We kunnen, zoals eerder genoemd, nu twee aanpakken kiezen om hier mee om te gaan:
# We kunnen gedragsregels opstellen voor de robots. De robots weten dat wanneer ze een artikel opgehaald hebben, ze weer terug naar tafel moeten en op deze manier kunnen we ze ook vertellen wat ze moeten doen als ze een andere robot zien. Bijvoorbeeld: doe altijd een stap naar links als je dicht bij een andere robot bent.
# We kunnen de robots ook een methode geven om van elkaar te leren hoe ze om moeten gaan met elkaar. Dit kun je doen als je zelf ook niet precies weet hoe de robots zich moeten gedragen. Deze methode die we hiervoor kunnen gebruiken heet een evolutionair algoritme. Voor een voorbeeld kun je kijken op : https://www.youtube.com/watch?v=AnuLXVp-Zf0. In dit filmpje zie je een e-puck robot aan het leren om obstakels te ontwijken. Dit is ook wat wij willen bereiken.
We kiezen voor algoritme 2 om te laten zien hoe je een robot van slimme kennis voorziet.

== Kunnen reageren op andere robots ==
We gaan er in deze paragraaf voor zorgen dat de robots elkaar kunnen herkennen en op elkaar kunnen reageren. Hiervoor moeten we veranderingen doorvoeren in de opzet van het pakhuis en veranderingen doorvoeren in de controller van de robot.

===Veranderen pakhuis omgeving===
Omdat we de controller van de robot gaan veranderen, mag je robot 9, 10 en 11 weer verwijderen. En de volgende stappen uitvoeren:

'''Stap 1:'''
Voeg aan de robot een string game property toe met de naam “Robot”. Dit is om elkaar te kunnen herkennen met een Radar

'''Stap 2:'''
Zet de Physics Type op Character en vink de box Actor aan:

[[Bestand: balk_actor.png]]

[[Bestand: set_as_actor.png]]

'''Stap 3:'''
Omdat we de robots nu niet meer helemaal kunnen controleren, ze kunnen immers afwijken van de directe route tussen de tafel en de kast, moeten we het pakhuis iets veranderen. Verander de physics van de kasten op de volgende manier:

[[Bestand: change_physics.png]]

Creëer extra wanden door de bestaande wanden te kopiëren, te verplaatsen en om hun as te draaien zodat we er doorheen kunnen blijven kijken. Verwijder Desk 1 t/m Desk 5 en verdeel Desk 6 t/m Desk 11 over de ruimte. De arena ziet er nu als volgt uit, waarbij er bij jou maar 1 robot staat bij Desk 8:

[[Bestand: nieuwe_arena.png]]

===Veranderen robot controller ===
De robots moeten elkaar nu herkennen, hier op reageren en vervolgens weer doorgaan met het ophalen van artikelen. We moeten veel gaan veranderen aan de controller. We nemen dit stap voor stap door:

'''Stap 1:'''
We hebben een extra Radar nodig om een ontwijkactie te starten en we moeten kunnen meten of de robot een goede actie gedaan heeft. Dit doen we met een collission sensor. De always sensor is nodig om de taak weer op te pakken na de ontwijkactie:
[[Bestand: add_radar.png]]

'''Stap 2:'''
De ontwijkactie houdt in dat de robot, na het detecteren van een andere robot, een aantal seconden rondjes draait, weg loopt van de robot en daarna zijn taak weer oppakt. Dit definiëren we in een extra state:
[[Bestand: add_state.png]]

'''Stap 3:'''
Voeg extra game properties toe:
[[Bestand: add_game_property.png]]

'''Stap 4:'''
Het script moet ook onder handen genomen worden. Er moet een extra package geïmporteerd worden omdat we de robot een willekeurige waarde geven voor het draaien om zijn eigen as en het weglopen van de radar locatie:

<syntaxhighlight lang="Python" line>
# import necessary packages
import bge
import GameLogic
import re
import random
</syntaxhighlight>

De extra sensors moeten gedefinieerd worden:

<syntaxhighlight lang="Python" line>
# get sensors and actuators
start_sens = cont.sensors["Start"]
shelf_sens = cont.sensors["Shelf"]
track_act = cont.actuators["TrackTo"]
robot_radar = cont.sensors["RobotRadar"]
robot_collission = cont.sensors["RobotCollission"]
</syntaxhighlight>

Wanneer de robot voor de eerste keer begint met de order, worden de parameters gedefinieerd die te maken hebben met het ontwijken van de andere robot:

<syntaxhighlight lang="Python" line>
if start_sens.positive:
cont.activate(track_act)
print("Start new order:")
get_order()
# set avoidance parameters and evaluation variables
print("begin")
if robot["active"] == False:
robot["sec_rot"] = random.uniform(0,2)
robot["sec_walk"] = random.uniform(0,2)
robot["active"] =True
</syntaxhighlight>

Wanneer een robot iemand op de radar heeft, moet de robot de ontwijkactie uit gaan voeren in de andere state. Ook moet bijgehouden worden of de robot alsnog tegen een ander aan stoot. Wanneer de robot een slechte ontwijkactie heeft en vaak tegen iemand op botst, willen we dat deze robot een nieuwe ontwijkreactie krijgt. Dit noemen we een “reset”. Dit is nodig als de robot ergens vast zit:

<syntaxhighlight lang="Python" line>
if robot_radar.positive == True:
cont.deactivate(track_act)
robot["radar"] +=1
robot["time"] = 0.0
robot.state = 2

if robot_collission.positive:
robot["collission"] +=1

if robot["collission"] >=20:
#reset parameters because its stuck
robot["sec_rot"] = random.uniform(0,2)
robot["sec_walk"] = random.uniform(0,2)
</syntaxhighlight>

In de extra state hebben we gezien dat er nog een “avoiding.py” gemaakt moet worden. Deze ziet er als volgt uit:

<syntaxhighlight lang="Python" line>
# import necessary packages
import bge
import GameLogic
import re

# get the current controller
cont = bge.logic.getCurrentController()
robot = cont.owner
robot["robot_id"] = robot.name[6:]

# get sensors and actuators
rot_act = cont.actuators["Rotate"]
walk_act = cont.actuators["Walk"]
robot_collission2 = cont.sensors["RobotCollission2"]
robot_radar2 = cont.sensors["RobotRadar2"]

robot["time"] += 1/60

if robot["time"] < robot["sec_rot"]:
cont.activate(rot_act)

if robot["time"] > robot["sec_rot"] and robot["time"] < (robot["sec_rot"] + robot["sec_walk"]):
cont.deactivate(rot_act)
cont.activate(walk_act)

if robot["time"] > (robot["sec_rot"] + robot["sec_walk"]):
robot.state =1

if robot_collission2.positive:
robot["collission"] +=1

if robot_radar2.positive:
robot["radar"] +=1
robot["time"] = 0.0
</syntaxhighlight>

Wanneer je de robots nu laat starten met het ophalen van bestellingen, zie je dat ze op elkaar reageren en hun ontwijkactie uitvoeren. De acties die ze uitvoeren zijn hetzelfde maar hoelang ze deze actie uit voeren kan verschillen. Sommige robots zullen beter kunnen ontwijken en sneller door kunnen gaan met hun bestelling dan andere robots. De robots die een goede ontwijkstrategie hebben kunnen hun strategie doorgeven aan de andere robots.

==Optimaliseren van reactie==

Bestand:Add game property.png

2014-12-09T15:36:46Z

Jacqueline:

Bestand:Add state.png

2014-12-09T15:36:27Z

Jacqueline: