Créer un robot de manutention

Préparer
- Lisez cette documentation destinée aux enseignants.
- Si nécessaire, prévoyez un cours préalable à l’aide du matériel de mise en route disponible dans le logiciel EV3 Lab ou l’application de programmation EV3. Cela permettra à vos élèves de se familiariser avec l’ensemble LEGO^® MINDSTORMS^® Education EV3.

Éveiller (30 min)
- Utilisez les idées évoquées dans la section Lancer une discussion ci-dessous pour engager une discussion en lien avec ce projet.
- Présentez le projet.
- Répartissez les élèves en binômes.
- Donnez à vos élèves le temps de rechercher des idées.

Explorer (30 min)
- Demandez à vos élèves de créer plusieurs prototypes.
- Encouragez-les à construire et à programmer.
- Demandez à chaque binôme de construire et de tester deux solutions.
- Fournissez-leur une grande feuille de papier millimétré et des crayons de couleur ou des marqueurs.

Expliquer (60 min)
- Demandez à vos élèves de tester leurs solutions et de choisir la meilleure.
- Vérifiez qu’ils sont en mesure de créer leurs propres bancs de test.
- Accordez un peu de temps à chaque équipe pour finaliser leur projet et collecter des ressources pour documenter leur travail.

Développer (60 min)
- Laissez le temps à vos élèves de créer leur rapport final.
- Animez une session de partage au cours de laquelle chaque équipe présentera ses résultats.

Évaluer
- Commentez les performances de chaque élève.
- N’hésitez pas à utiliser les rubriques d’évaluation fournies.

Les robots de manutention sont un type de robots industriels capables de déplacer des objets d’un emplacement prédéfini à un autre. Suivant la forme, le poids et la fragilité des objets, différents types de pinces peuvent être utilisées pour saisir et relâcher les objets en toute sécurité et avec précision.

Encouragez la réflexion interactive.

Demandez à vos élèves de réfléchir à ces questions :

• Qu’est-ce qu’un robot de manutention et dans quel contexte en utilise-t-on ?
• Quel type de mécanisme motorisé peut-on utiliser pour saisir l’objet ?
• Comment le robot peut-il déplacer l’objet ?
• Comment le robot peut-il reposer délicatement et précisément l’objet à un autre endroit ?

Incitez vos élèves à documenter leurs idées initiales et à expliquer pourquoi ils ont choisi cette solution pour leur premier prototype. Demandez-leur de décrire comment ils comptent évaluer leurs idées tout au long du projet. Ainsi, lors de la phase de révision et d’adaptation, ils disposeront d’informations spécifiques pour évaluer leur solution et décider si elle est efficace.

Extension Langue française

Pour intégrer des notions d’arts du langage, demandez à vos élèves de :

Option 1

• Utiliser leur travail écrit, leurs croquis et/ou leurs photos pour récapituler leur processus de conception et créer un rapport final.
• Enregistrer une vidéo qui détaille leur processus de conception, en commençant par leurs idées initiales et en finissant par le projet réalisé.
• Créer une présentation sur leur programme.
• Créer une présentation mettant leur projet en relation avec des applications réelles de systèmes similaires et décrivant de nouvelles inventions qui pourraient être imaginées grâce à ce qu’ils ont fabriqué.

Option 2
Pour intégrer des notions d’arts du langage, demandez à vos élèves de :

• Effectuer des recherches sur différentes machines qui préparent des médicaments et des vaccins, puis élaborer un récit sur le déroulement des opérations dans un laboratoire automatisé de fabrication de médicaments, en formulant un avantage et un inconvénient de la production automatisée de médicaments ;

• Concernant la protection des données, discuter de la problématique du copyright des « recettes » de médicaments valant potentiellement des milliards de dollars qui sont stockées dans un système en ligne, en évoquant :

• les conséquences potentielles pour une entreprise qui perd des données relatives à des médicaments ;

• les avantages du stockage d’informations sensibles dans des systèmes en ligne.

Extension Maths

Dans le cadre de cette leçon, vos élèves ont créé un robot de transfert. Comme c’est le cas pour de nombreux systèmes automatisés, l’évaluation et l’amélioration des performances revêtent une importance cruciale. L’apprentissage automatique est un processus qui permet aux robots de transfert de mesurer leur propre niveau de performances et d’apporter les modifications nécessaires pour le maintenir ou l’améliorer.

Pour intégrer des notions de mathématiques et explorer le thème de l’apprentissage automatique, demandez à vos élèves :

• de définir les termes « justesse » et « précision », et d’appliquer ces définitions à leurs projets de robotique ;
• d’identifier les variables relatives à la justesse et à la précision dans leurs systèmes (p. ex., la vitesse de leur robot peut avoir un impact sur sa justesse, sa précision ou les deux) ;
• d’élaborer des mini-expériences permettant de vérifier si les variables choisies ont un impact sur la justesse, la précision ou les deux.

Idées de construction
Demandez à vos élèves de construire quelques-uns des exemples fournis via les liens ci-dessous. Encouragez-les à observer comment ces systèmes fonctionnent et à réfléchir à la façon dont ils pourraient s’en inspirer pour résoudre le problème exposé.

• Pince
• Capteur gyroscopique
• Mâchoire
• Bascule
• Capteur tactile
• Plaque tournante
• Capteur à ultrasons

Astuces de test
Incitez vos élèves à élaborer leurs propres configuration et procédure de test pour sélectionner la meilleure solution. Les astuces suivantes peuvent aider vos élèves à mettre leur test en place :

• Marquez la position de la machine sur le papier millimétré afin de la placer dans la même position à chaque fois.
• Utilisez le quadrillage pour identifier des carrés de 1 cm x 1 cm ; cela facilitera l’enregistrement des résultats de chaque test.
• Utilisez des crayons de couleur ou des marqueurs pour indiquer l’emplacement attendu et l’emplacement où le robot a réellement déposé l’objet.
• Créez des bancs de test pour enregistrer vos observations.
• Évaluez la précision de votre robot en comparant les résultats attendus avec les résultats réels.
• Répétez le test au moins trois fois.

Exemple de solution
Voici un exemple de solution répondant aux critères de la présentation du problème :

Exemple de programme EV3 MicroPython

#!/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)

Les élèves qui ont apprécié ce cours pourraient être intéressés par les secteurs professionnels suivants :

• Technologies de l’information (programmation informatique)
• Fabrication et ingénierie (technologie des machines)

Checklist d’observation de l’enseignant
Créez un barème adapté à vos besoins, par exemple :

1. Objectif partiellement atteint
2. Objectif atteint
3. Objectif dépassé

Utilisez les critères suivants pour évaluer la progression de vos élèves :

• Les élèves évaluent la conception de solutions concurrentes en fonction de critères prioritaires et de compromis.
• Les élèves développent de manière autonome une solution opérationnelle et créative.
• Les élèves communiquent clairement leurs idées.

Auto-évaluation
Une fois que vos élèves ont recueilli des données sur les performances, donnez-leur le temps de réfléchir à leurs solutions. N’hésitez pas à leur poser des questions comme :

• Votre solution répond-elle aux critères de la présentation du problème ?
• Pouvez-vous rendre les mouvements de votre robot plus précis ?
• Comment les autres ont-ils résolu ce problème ?

Demandez à vos élèves de réfléchir et de documenter deux façons d’améliorer leurs solutions.

Commentaires des camarades
Encouragez vos élèves à s’évaluer entre eux en évaluant leur propre projet mais aussi ceux des autres. Ce processus d’évaluation permet aux élèves d’apprendre à formuler des commentaires constructifs, à développer leur esprit d’analyse et à utiliser des données objectives pour avancer des arguments.