Maak een Pick-and-Place-robot

Voorbereiden
- Lees deze informatie voor jou als docent door.
- Als je denkt dat het nodig is, bereid dan een les voor met behulp van het ‘Aan de slag’-materiaal in de EV3 Labsoftware of EV3-programmeerapp. Daardoor raken je leerlingen vertrouwd met LEGO^® MINDSTORMS^® Education EV3.

Activeren (30 min.)
- Maak gebruik van de ideeën in het deel Start een gesprek hieronder om met je leerlingen een gesprek over dit project te voeren.
- Leg het project uit.
- Verdeel de klas in teams van twee leerlingen.
- Laat de leerlingen enige tijd brainstormen.

Onderzoeken (30 min.)
- Laat de leerlingen meerdere prototypes maken.
- Moedig ze aan om zowel het bouwen als het programmeren uit te proberen.
- Laat elk duo twee oplossingen bouwen en testen.
- Geef de leerlingen grote vellen ruitjespapier en kleurpotloden of stiften.

Uitleggen (60 min.)
- Vraag de leerlingen om hun oplossingen te testen en de beste te kiezen.
- Zorg ervoor dat ze hun eigen testtabellen kunnen maken.
- Geef de teams wat tijd om hun project af te ronden en om gegevens te verzamelen voor een verslag over hun werk.

Uitbreiden (60 min.)
- Geef de leerlingen wat tijd om hun definitieve verslag te maken.
- Organiseer een bespreekmoment waarin elk team zijn resultaten presenteert.

Evalueren
- Geef elke leerling feedback over zijn of haar prestaties.
- Je kunt gebruikmaken van de meegeleverde suggestie voor evaluatierubrieken om dit eenvoudiger te maken.

Pick-and-Place-robots zijn een bepaald soort industriële robots die in staat zijn om voorwerpen te verplaatsen van en naar vooraf gedefinieerde plaatsen. Afhankelijk van de vorm, het gewicht en de breekbaarheid van de voorwerpen kunnen verschillende soorten grijpers worden gebruikt om de voorwerpen voorzichtig en zorgvuldig op te pakken en weer los te laten.

Moedig een actief brainstormproces aan.

Vraag de leerlingen na te denken over deze vragen:

• Wat is een Pick-and-Place-robot en waar worden ze gebruikt?
• Welk soort gemotoriseerd mechanisme kun je gebruiken om het voorwerp op te pakken?
  * Hoe kan de robot het voorwerp verplaatsen?
• Hoe kan de robot het voorwerp voorzichtig en nauwkeurig op een andere locatie neerzetten?

Moedig de leerlingen aan om hun eerste ideeën op te schrijven en uit te leggen waarom ze kiezen voor de oplossing die ze voor hun eerste prototype gaan gebruiken. Vraag ze om te beschrijven hoe ze hun ideeën tijdens het project gaan evalueren. Daardoor hebben ze achteraf specifieke informatie die ze kunnen gebruiken voor het evalueren van hun oplossing en om te kunnen beslissen of deze al dan niet efficiënt was.

Taaluitbreiding

Laat de leerlingen voor de ontwikkeling van hun taalvaardigheid:

Optie 1

• gebruikmaken van hun aantekeningen, schetsen, en/of foto's om hun ontwerpproces samen te vatten en een eindverslag te maken.
• een video maken, waarin hun ontwerpproces te volgen is, vanaf hun eerste ideeën tot het voltooide project.
• een presentatie maken over hun programma.
• een presentatie maken waarin zij hun project vergelijken met realistische toepassingen van soortgelijke systemen en waarin ze beschrijven welke nieuwe uitvindingen kunnen worden gedaan op basis van wat ze hebben gemaakt.

Optie 2
Laat de leerlingen voor de ontwikkeling van hun taalvaardigheid:

• verschillende machines onderzoeken die medicijnen en vaccins voorbereiden en laat ze vervolgens een verslag schrijven over werken in een geautomatiseerd laboratorium waar medicijnen worden gemaakt, met daarin een voordeel en een nadeel van geautomatiseerde medicijnproductie

• vanuit het perspectief van gegevensbescherming bespreken welke copyrightrisico’s er zijn wat betreft het opslaan in een online systeem van ‘medicijnrecepten’ die mogelijk miljoenen waard zijn, waarbij ze rekening houden met het volgende:

• De mogelijke gevolgen wanneer een bedrijf medicijngegevens kwijtraakt

• De voordelen van het opslaan van gevoelige informatie in online systemen

Rekenuitbreiding

In deze les hebben je leerlingen een pick-and-place-robot gemaakt. Net als met andere geautomatiseerde systemen is het testen en verbeteren van de prestaties van deze robot cruciaal. Door middel van machine learning kunnen pick-and-place-robots hun eigen prestaties meten en aanpassingen maken om die prestaties te behouden of te verbeteren.

Laat de leerlingen voor de ontwikkeling van hun rekenvaardigheid en inzicht in machine learning:

• de termen nauwkeurigheid en precisie omschrijven en laat ze deze omschrijvingen toepassen in hun eigen roboticaprojecten
• de variabelen in hun systemen identificeren die verband houden met nauwkeurigheid en precisie (zo kan de snelheid van hun robot invloed hebben op de nauwkeurigheid, de precisie of op beide)
• mini-experimenten bedenken waarmee ze kunnen testen of de gekozen variabelen de correctheid, nauwkeurigheid of beide beïnvloeden

Bouwideeën
Geef de leerlingen de gelegenheid om enkele voorbeelden te bouwen die via onderstaande links te vinden zijn. Moedig ze aan om te onderzoeken hoe deze systemen werken en te brainstormen hoe deze systemen kunnen bijdragen aan een oplossing voor het ontwerpplan.

• Grijper
• Gyrosensor
• Kaken
• Wip
• Tastsensor
• Draaischijf
• Ultrasone sensor

Tips voor het testen
Moedig de leerlingen aan om een eigen testopstelling en testprocedure te ontwerpen om de beste oplossing te kunnen selecteren. Deze tips kunnen de leerlingen helpen bij het opzetten van hun test:

• Markeer de positie van de machine op het ruitjespapier, zodat je hem voor iedere test op dezelfde positie kan zetten.
• Gebruik rasterlijnen met vierkantjes van 1 cm x 1 cm om de resultaten van elke test mee vast te leggen.
• Markeer met een kleurpotlood of stift de verwachte locaties en de daadwerkelijke locaties waar de robot het voorwerp neerzet.
• Maak testtabellen om je waarnemingen in te noteren.
• Beoordeel de precisie van de robot door de verwachte resultaten met de daadwerkelijke resultaten te vergelijken.
• Herhaal de test minstens drie keer.

Voorbeeldoplossing
Hieronder vind je een voorbeeldoplossing die voldoet aan de criteria uit het Ontwerpplan:

EV3 MicroPython Voorbeeldprogramma

#!/usr/bin/env pybricks-micropython

from pybricks import ev3brick as brick
from pybricks.ev3devices import Motor, TouchSensor, ColorSensor
from pybricks.parameters import (Port, Stop, Direction, Button,
                                 ImageFile, SoundFile)
from pybricks.tools import wait

# Configure the gripper motor with default settings.
gripper_motor = Motor(Port.A)

# Configure the elbow motor.  It has an 8-tooth and a 40-tooth gear
# connected to it.  Set the motor direction to counterclockwise, so
# that positive speed values make the arm move upward.
elbow_motor = Motor(Port.B, Direction.COUNTERCLOCKWISE, [8, 40])

# Configure the motor that rotates the base.  It has a 12-tooth and a
# 36-tooth gear connected to it.  Set the motor direction to
# counterclockwise, so that positive speed values make the arm move
# away from the Touch Sensor.
base_motor = Motor(Port.C, Direction.COUNTERCLOCKWISE, [12, 36])

# Limit the elbow and base accelerations.  This results in very smooth
# motion, like that of an industrial robot.
elbow_motor.set_run_settings(60, 120)
base_motor.set_run_settings(60, 120)

# Set up the Touch Sensor.  It is used to detect when the base has
# moved to its starting position.
touch_sensor = TouchSensor(Port.S1)

# Set up the Color Sensor.  It is used in Reflected Light Intensity
# Mode to detect the white beam when the elbow is in its starting
# position.
color_sensor = ColorSensor(Port.S3)

# Initialize the elbow.  This is done by first moving down for 1 second
# and then slowly moving up until the Color Sensor detects the white
# beam.  Then the motor stops, holds its position, and resets the angle
# to "0."  This means that when it rotates backward to "0" later on, it
# returns to this starting position.
elbow_motor.run_time(-30, 1000)
elbow_motor.run(15)
while color_sensor.reflection() < 30:
    wait(10)
elbow_motor.stop(Stop.HOLD)
elbow_motor.reset_angle(0)

# Initialize the base.  This is done by first running the base motor
# counterclockwise until the Touch Sensor is pressed.  Then the motor
# stops, holds its position, and resets the angle to "0."  This means
# that when it rotates backward to "0" later on, it returns to this
# starting position.
base_motor.run(-60)
while not touch_sensor.pressed():
    wait(10)
base_motor.stop(Stop.HOLD)
base_motor.reset_angle(0)

# Initialize the gripper.  This is done by running the motor forward
# until it stalls.  This means that it cannot move any further.  From
# this closed gripper position, the motor rotates backward by 90
# degrees, so the gripper opens up.  This is the starting position.
gripper_motor.run_until_stalled(200, Stop.COAST, 50)
gripper_motor.reset_angle(0)
gripper_motor.run_target(200, -90)

def robot_pick(position):
    # This function rotates the base to the pick up position.  There,
    # it lowers the arm, closes the gripper, and raises the arm to pick
    # up the wheel stack.
    base_motor.run_target(60, position, Stop.HOLD)
    elbow_motor.run_target(60, -45)
    gripper_motor.run_until_stalled(200, Stop.HOLD, 50)
    elbow_motor.run_target(60, 0, Stop.HOLD)

def robot_release(position):
    # This function rotates the base to the drop-off position.  There,
    # it lowers the arm, opens the gripper to release the wheel stack,
    # and raises the arm again.
    base_motor.run_target(60, position, Stop.HOLD)
    elbow_motor.run_target(60, -45)
    gripper_motor.run_target(200, -90)
    elbow_motor.run_target(60, 0, Stop.HOLD)

# Define the 3 destinations for picking up and dropping off the wheel
# stacks.
LEFT = 200
CENTER = 100
RIGHT = 0

# Rotate the base to the center.
base_motor.run_target(60, CENTER, Stop.HOLD)

# This is the main part of the program.  It is a loop that repeats
# endlessly.
#
# First, the robot waits until the Up or Down Button is pressed.
# Second, the robot waits until the Center Button is pressed.
# Finally, the robot picks up the wheel stack and drops it off in the
# center.
#
# Then the process starts over, so the robot can pick up another wheel
# stack.
while True:

    # Display a question mark to indicate that the robot should await
    # instructions.
    brick.display.image(ImageFile.QUESTION_MARK)

    # Wait until the Up or Down Button is pressed.
    while True:
        # First, wait until any button is pressed.
        while not any(brick.buttons()):
            wait(10)
        # Then store which button was pressed.
        button = brick.buttons()[0]
        # If the Up or Down Button was pressed, break out of the loop.
        if button in (Button.UP, Button.DOWN):
            break

    # Play a sound and display an arrow to show where the arm will move.
    brick.sound.file(SoundFile.AIR_RELEASE)
    if button == Button.UP:
        brick.display.image(ImageFile.FORWARD)
    elif button == Button.DOWN:
        brick.display.image(ImageFile.BACKWARD)

    # Wait until the Center Button is pressed, then display a check
    # mark to indicate that the instruction has been accepted.
    while not Button.CENTER in brick.buttons():
        wait(10)
    brick.display.image(ImageFile.ACCEPT)

    # Pick up the wheel stack. Depending on which button was pressed,
    # move left or right.
    if button == Button.UP:
        robot_pick(RIGHT)
    elif button == Button.DOWN:
        robot_pick(LEFT)

    # Drop off the wheel stack in the center.
    robot_release(CENTER)

Leerlingen die deze les leuk vonden, zijn misschien geïnteresseerd in een van de studierichtingen:

• Informatietechnologie (computerprogrammering)
• Productie en techniek (machinetechnologie)

Observatiechecklist docent
Maak naar eigen inzicht een schaalverdeling, bijvoorbeeld:

1. Gedeeltelijk uitgevoerd
2. Volledig uitgevoerd
3. Boven verwachting uitgevoerd

Gebruik de volgende criteria om de voortgang van je leerlingen te beoordelen:

• Leerlingen kunnen verschillende ontwerpoplossingen beoordelen aan de hand van welke criteria het zwaarst moeten wegen en welke voor- en nadelen ze bieden.
• Leerlingen kunnen zelfstandig een werkende en creatieve oplossing ontwikkelen.
• Leerlingen kunnen hun ideeën duidelijk communiceren.

Zelfevaluatie
Geef de leerlingen de tijd om over hun oplossingen na te denken als ze eenmaal een aantal gegevens over de prestaties van hun oplossingen hebben verzameld. Help ze daarbij door vragen te stellen als:

• Voldoet jullie oplossing aan de criteria uit het Ontwerpplan?
• Is het mogelijk de robot nauwkeuriger te laten bewegen?
• Welke oplossingen hebben anderen gebruikt?

Vraag de leerlingen om te brainstormen en twee manieren op te schrijven waarmee ze hun oplossingen zouden kunnen verbeteren.

Feedback van elkaar
Laat leerlingen elkaars werk evalueren en maak elk team verantwoordelijk voor de evaluatie van zowel hun eigen project als het project van anderen. Dit evaluatieproces kan de leerlingen helpen bij het ontwikkelen van vaardigheden voor het geven van opbouwende kritiek en bij het verbeteren van hun analysevaardigheden en het gebruik van objectieve gegevens ter ondersteuning van een argument.