Bras à 6 axes#

Introduction #

Le bras robotique VEX 6 axes déplace un effecteur terminal dans l’espace tridimensionnel, contrôle l’orientation de l’effecteur terminal et fonctionne avec des outils attachés tels que l’outil de ramassage magnétique ou l’outil porte-stylo.

Vous trouverez ci-dessous la liste de toutes les méthodes disponibles :

Actions — Déplacer le bras à 6 axes vers des positions ou des orientations.

move_to — Déplace l’effecteur final vers une coordonnée x, y et z spécifiée.
move_inc — Déplace l’effecteur terminal d’une distance spécifiée à partir de sa position actuelle.
move_end_effector_to — Fait pivoter l’effecteur terminal vers une orientation de lacet, de roulis et de tangage spécifiée.
move_end_effector_inc — Fait pivoter l’effecteur terminal d’une valeur spécifiée de lacet, de roulis et de tangage.

Modificateurs — Configurez les mouvements, les outils et les paramètres de contrôle.

set_speed — Définit la vitesse de déplacement utilisée par le bras à 6 axes.
set_end_effector_type — Définit le type d’effecteur terminal attaché au bras à 6 axes.
set_end_effector_magnet — Engage ou libère l’outil de ramassage magnétique.
set_pen_offset — Définit le décalage de l’axe z utilisé avec l’outil Porte-stylo.
set_control_stop — Active l’arrêt de contrôle pour le bras à 6 axes.
set_timeout — Définit le délai d’attente utilisé par les méthodes de mouvement du bras à 6 axes.

Getters — Renvoie l’état du mouvement, la position, l’orientation et les valeurs de connexion.

is_done — Renvoie si le bras à 6 axes a fini de se déplacer.
get_x — Renvoie la position x actuelle de l’effecteur terminal.
get_y — Renvoie la position y actuelle de l’effecteur terminal.
get_z — Renvoie la position z actuelle de l’effecteur terminal.
get_pitch — Renvoie la hauteur actuelle de l’effecteur terminal.
get_roll — Renvoie le roulement actuel de l’effecteur terminal.
get_yaw — Renvoie le lacet actuel de l’effecteur terminal.
can_arm_reach_to — Renvoie si le bras à 6 axes peut atteindre une position spécifiée.
can_arm_reach_inc — Renvoie si le bras à 6 axes peut se déplacer d’une distance spécifiée.
can_end_effector_reach_to — Renvoie si l’effecteur terminal peut atteindre une orientation spécifiée.
can_end_effector_reach_inc — Renvoie si l’effecteur terminal peut pivoter d’une quantité spécifiée.
get_timeout — Renvoie la valeur de délai d’attente actuelle utilisée par les méthodes de déplacement.
is_connected — Renvoie si le bras à 6 axes est connecté au cerveau.

Rappels — Exécuter des fonctions lorsque des événements ARM se produisent.

control_stopped — Enregistre une fonction à exécuter lorsque l’arrêt du contrôle est activé.

Constructeur — Créez manuellement un objet Bras à 6 axes.

Arm — Crée un objet Bras à 6 axes.

Cette page concerne l’utilisation du bras à 6 axes seul avec la dalle CTE. Pour utiliser le bras à 6 axes avec d’autres composants de cellule de travail CTE, tels que des systèmes pneumatiques ou des convoyeurs, connectez le bras à 6 axes à un module EXP et utilisez la page Bras EXP correspondante.

Actes #

move_to #

La commande move_to déplace le bras à 6 axes vers une coordonnée x, y et z spécifiée.

Les coordonnées x, y et z décrivent la position de l’effecteur terminal dans l’espace tridimensionnel. Utilisez can_arm_reach_to avant cette méthode si la position cible peut se trouver en dehors de l’espace de travail accessible du bras à 6 axes.

Usage:
arm.move_to(x, y, z, wait)

Paramètre	Description
`x`	La coordonnée x de la position cible en millimètres.
`y`	La coordonnée y de la position cible en millimètres.
`z`	La coordonnée z de la position cible en millimètres.
`wait`	Optionnel. `wait=True` (par défaut) : le projet attend la fin du déplacement avant de continuer. `wait=False` : le déplacement démarre et passe immédiatement à la ligne de code suivante.

# Move the 6-Axis Arm to (40, 140, 210)
arm.move_to(40, 140, 210)

# Start moving, then print the y-position while the arm moves
arm.move_to(-100, 200, 100, wait=False)

while not arm.is_done():
    brain.print(arm.get_y())
    brain.new_line()
    wait(0.25, SECONDS)

move_inc #

move_inc déplace le bras à 6 axes d’une distance spécifiée à partir de sa position actuelle le long des axes x, y et z.

Utilisez cette méthode pour vous déplacer par rapport à la position actuelle de l’effecteur terminal. Utilisez can_arm_reach_inc avant cette méthode si le mouvement risque de placer le bras à 6 axes hors de son espace de travail accessible.

Usage:
arm.move_inc(x, y, z, wait)

Paramètre	Description
`x`	Distance à parcourir le long de l’axe x en millimètres.
`y`	Distance à parcourir le long de l’axe y en millimètres.
`z`	Distance à parcourir le long de l’axe z en millimètres.
`wait`	Optionnel. `wait=True` (par défaut) : le projet attend la fin du déplacement avant de continuer. `wait=False` : le déplacement démarre et passe immédiatement à la ligne de code suivante.

# Move the 6-Axis Arm 100 millimeters along the y-axis
arm.move_inc(0, 100, 0)

move_end_effector_to #

La commande move_end_effector_to fait pivoter l’effecteur terminal du bras à 6 axes vers une orientation de lacet, de roulis et de tangage spécifiée.

L’orientation décrit la rotation de l’effecteur terminal. yaw rotation autour de l’axe z, roll rotation autour de l’axe x et pitch rotation autour de l’axe y.

Usage:
arm.move_end_effector_to(yaw, roll, pitch, wait)

Paramètre	Description
`yaw`	L’angle de lacet cible, en degrés.
`roll`	L’angle de roulis cible, en degrés.
`pitch`	L’angle de tangage cible, en degrés.
`wait`	Optionnel. `wait=True` (par défaut) : le projet attend la fin du déplacement avant de continuer. `wait=False` : le déplacement démarre et passe immédiatement à la ligne de code suivante.

# Rotate the end effector to 90 degrees of roll
arm.move_end_effector_to(0, 90, 0)

move_end_effector_inc #

move_end_effector_inc fait pivoter l’effecteur terminal du bras à 6 axes d’une valeur spécifiée de lacet, de roulis et de tangage par rapport à son orientation actuelle.

Utilisez cette méthode pour effectuer une rotation par rapport au lacet, au roulis ou au tangage actuel de l’effecteur terminal.

Usage:
arm.move_end_effector_inc(yaw, roll, pitch, wait)

Paramètre	Description
`yaw`	La variation du lacet, en degrés.
`roll`	Le changement de roulis, en degrés.
`pitch`	Le changement de hauteur, en degrés.
`wait`	Optionnel. `wait=True` (par défaut) : le projet attend la fin du déplacement avant de continuer. `wait=False` : le déplacement démarre et passe immédiatement à la ligne de code suivante.

# Rotate the end effector -50 degrees in pitch
arm.move_end_effector_inc(0, 0, -50)

Mutateurs #

set_speed #

set_speed définit la vitesse de déplacement utilisée par le bras à 6 axes pour les méthodes de déplacement.

La vitesse du bras à 6 axes est réglée à 50 % au début d’un projet.

Usage:
arm.set_speed(speed)

Paramètre	Description
`speed`	La vitesse de déplacement du bras à 6 axes, de `1` à `100` pour cent.

# Set the 6-Axis Arm speed to 30%
arm.set_speed(30)

set_end_effector_type #

set_end_effector_type définit le type d’effecteur terminal attaché au bras à 6 axes.

Lorsque le type d’effecteur est modifié, le bras à 6 axes ajuste automatiquement son décalage Z en fonction de l’outil sélectionné. Le type d’effecteur est défini sur Arm.MAGNET au début d’un projet.

Usage:
arm.set_end_effector_type(type)

Paramètre	Description
`type`	L’outil fixé au bras à 6 axes : `Arm.MAGNET` (outil de ramassage magnétique) ou `Arm.PEN` (outil porte-stylo).

# Set the end effector type to the Pen Holder Tool
arm.set_end_effector_type(Arm.PEN)

set_end_effector_magnet #

set_end_effector_magnet engage ou libère l’outil de ramassage magnétique.

The magnet state stays active until another set_end_effector_magnet method changes it. The magnet state is reset to False at the start of a project.

Usage:
arm.set_end_effector_magnet(state)

Paramètre	Description
`state`	L’état de l’outil de ramassage magnétique : `True` pour ramasser et maintenir des objets ou `False` pour laisser tomber tout objet tenu et arrêter de ramasser de nouveaux objets.

# Pick up objects and then drop them
arm.set_end_effector_type(Arm.MAGNET)
arm.set_end_effector_magnet(True)
wait(2, SECONDS)
arm.set_end_effector_magnet(False)

set_pen_offset #

set_pen_offset définit le décalage de l’axe z utilisé lorsque l’outil porte-stylo est fixé au bras à 6 axes.

Avant d’utiliser cette méthode, définissez le type d’effecteur terminal sur Arm.PEN Si l’outil Porte-stylo n’est pas sélectionné, cette méthode est sans effet.

Le décalage du stylo correspond à la distance entre le haut du porte-stylo et la pointe du marqueur effaçable à sec. Au début d’un projet, ce décalage est défini sur 0Un décalage de 0 place l’origine de l’axe Z du bras au point de connexion du porte-stylo au bras à 6 axes.

Usage:
arm.set_pen_offset(zOffset)

Paramètre	Description
`zOffset`	Valeur du décalage du stylo en millimètres.

# Set the end effector type to the Pen Holder Tool and set the pen offset
arm.set_end_effector_type(Arm.PEN)
arm.set_pen_offset(25)

set_control_stop #

set_control_stop active l’arrêt de contrôle pour le bras à 6 axes.

Lorsque l’arrêt de contrôle est activé, le bras à 6 axes arrête immédiatement tout mouvement et n’exécutera plus aucune méthode de mouvement du bras jusqu’à ce que le projet soit redémarré.

Usage:
arm.set_control_stop(state)

Paramètre	Description
`state`	Facultatif. `True` (par défaut) active l’arrêt contrôlé. `False` désactive l’arrêt contrôlé.

# Stop the 6-Axis Arm and prevent further movement
arm.set_control_stop()

set_timeout #

set_timeout définit la valeur du délai d’attente utilisé lors du déplacement du bras à 6 axes.

Si un mouvement ne se termine pas avant l’expiration du délai, le projet passe à la ligne de code suivante.

Usage:
arm.set_timeout(timeout, units)

Paramètre	Description
`timeout`	La nouvelle valeur de délai d’attente.
`units`	Facultatif. L’unité de temps : `MSEC` (millisecondes, par défaut), `SECONDS`ou `SEC`.

# Set the 6-Axis Arm timeout to 2 seconds
arm.set_timeout(2, SECONDS)

Getters #

is_done #

is_done indique si le bras à 6 axes a terminé son mouvement.

Cette méthode est utile après qu’une méthode de mouvement soit appelée avec wait=False.

True — Le bras à 6 axes a terminé son mouvement.
False — Le bras à 6 axes est toujours en mouvement.

Usage:
arm.is_done()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

# Display the 6-Axis Arm's y-position while it moves
arm.move_to(-100, 200, 100, wait=False)

while not arm.is_done():
    brain.print(arm.get_y())
    brain.new_line()
    wait(0.25, SECONDS)

get_x #

get_x renvoie la position x actuelle de l’effecteur terminal en millimètres.

Utilisez cette méthode pour lire la position actuelle de l’effecteur terminal le long de l’axe x.

Usage:
arm.get_x()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

# Print the current x position of the 6-Axis Arm
brain.print(arm.get_x())

get_y #

get_y renvoie la position y actuelle de l’effecteur terminal en millimètres.

Utilisez cette méthode pour lire la position actuelle de l’effecteur terminal le long de l’axe y.

Usage:
arm.get_y()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

# Print the current y position of the 6-Axis Arm
brain.print(arm.get_y())

get_z #

get_z renvoie la position z actuelle de l’effecteur terminal en millimètres.

Utilisez cette méthode pour lire la position actuelle de l’effecteur terminal le long de l’axe z.

Usage:
arm.get_z()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

# Print the current z position of the 6-Axis Arm
brain.print(arm.get_z())

get_pitch #

get_pitch renvoie le pas actuel de l’effecteur terminal en degrés.

Usage:
arm.get_pitch()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

# Print the current pitch of the end effector
brain.print(arm.get_pitch())

get_roll #

get_roll renvoie le roulis actuel de l’effecteur terminal en degrés.

Usage:
arm.get_roll()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

# Print the current roll of the end effector
brain.print(arm.get_roll())

get_yaw #

get_yaw renvoie le lacet actuel de l’effecteur terminal en degrés.

Usage:
arm.get_yaw()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

# Print the current yaw of the end effector
brain.print(arm.get_yaw())

can_arm_reach_to #

La fonction can_arm_reach_to indique si le bras à 6 axes peut déplacer l’effecteur terminal vers une coordonnée x, y et z spécifiée.

Utilisez cette méthode pour vérifier une position cible avant d’utiliser move_to.

True — Le bras à 6 axes peut atteindre la position demandée.
False — Le bras à 6 axes ne peut pas atteindre la position demandée.

Usage:
arm.can_arm_reach_to(x, y, z)

Paramètre	Description
`x`	La coordonnée x de la position cible en millimètres.
`y`	La coordonnée y de la position cible en millimètres.
`z`	La coordonnée z de la position cible en millimètres.

# Move the 6-Axis Arm to (100, -20, 50) if it can reach
if arm.can_arm_reach_to(100, -20, 50):
    arm.move_to(100, -20, 50)

can_arm_reach_inc #

can_arm_reach_inc indique si le bras à 6 axes peut déplacer l’effecteur terminal d’une distance x, y et z spécifiée à partir de sa position actuelle.

Utilisez cette méthode pour vérifier un mouvement relatif avant d’utiliser move_inc.

True — Le bras à 6 axes peut effectuer le mouvement demandé.
False — Le bras à 6 axes ne peut pas effectuer le mouvement demandé.

Usage:
arm.can_arm_reach_inc(x, y, z)

Paramètre	Description
`x`	Distance à parcourir le long de l’axe x en millimètres.
`y`	Distance à parcourir le long de l’axe y en millimètres.
`z`	Distance à parcourir le long de l’axe z en millimètres.

# Increment the 6-Axis Arm 100 mm along the x-axis if possible
if arm.can_arm_reach_inc(100, 0, 0):
    arm.move_inc(100, 0, 0)

can_end_effector_reach_to #

can_end_effector_reach_to renvoie si l’effecteur terminal peut pivoter vers une orientation de lacet, de roulis et de tangage spécifiée.

Utilisez cette méthode pour vérifier une orientation cible avant d’utiliser move_end_effector_to.

True — L’effecteur terminal peut atteindre l’orientation demandée.
False — L’effecteur terminal ne peut pas atteindre l’orientation demandée.

Usage:
arm.can_end_effector_reach_to(yaw, roll, pitch)

Paramètre	Description
`yaw`	L’angle de lacet cible, en degrés.
`roll`	L’angle de roulis cible, en degrés.
`pitch`	L’angle de tangage cible, en degrés.

# Rotate the end effector to 90 degrees of roll if possible
if arm.can_end_effector_reach_to(0, 90, 0):
    arm.move_end_effector_to(0, 90, 0)

can_end_effector_reach_inc #

can_end_effector_reach_inc renvoie si l’effecteur terminal peut pivoter d’une valeur spécifiée de lacet, de roulis et de tangage à partir de son orientation actuelle.

Utilisez cette méthode pour vérifier un mouvement d’orientation relative avant d’utiliser move_end_effector_inc.

True — L’effecteur terminal peut effectuer la rotation demandée.
False — L’effecteur terminal ne peut pas effectuer la rotation demandée.

Usage:
arm.can_end_effector_reach_inc(yaw, roll, pitch)

Paramètre	Description
`yaw`	La variation du lacet, en degrés.
`roll`	Le changement de roulis, en degrés.
`pitch`	Le changement de hauteur, en degrés.

# Increment the end effector by 10 degrees of pitch if possible
if arm.can_end_effector_reach_inc(0, 0, 10):
    arm.move_end_effector_inc(0, 0, 10)

get_timeout #

get_timeout renvoie la valeur de délai d’attente utilisée par les méthodes de mouvement du bras à 6 axes en millisecondes.

Usage:
arm.get_timeout()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

# Print the current movement timeout in milliseconds
brain.print(arm.get_timeout())

is_connected #

is_connected indique si le bras à 6 axes est connecté au cerveau.

True — Le bras à 6 axes est connecté au cerveau.
False — Le bras à 6 axes n’est pas connecté au cerveau.

Usage:
arm.is_connected()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

# Print whether the 6-Axis Arm is connected
brain.print(arm.is_connected())

Rappels #

control_stopped #

control_stopped enregistre une fonction qui s’exécute lorsque l’arrêt du contrôle est activé.

Cette méthode renvoie une instance de la classe Event.

Usage:
arm.control_stopped(callback, arg)

Paramètre	Description
`callback`	Une fonction précédemment définie qui s’exécute lorsque l’arrêt du contrôle est activé.
`arg`	Facultatif. Un tuple contenant les arguments à transmettre à la fonction de rappel. Voir Utilisation des fonctions avec paramètres pour plus d’informations.

# Define a function to run when control stop is enabled
def when_control_stopped():
    brain.print("The arm has been control stopped")

# Run when_control_stopped when the 6-Axis Arm is control stopped
arm.control_stopped(when_control_stopped)

Constructeurs #

Arm #

Arm crée un objet Bras à 6 axes.

Usage:
Arm()

Paramètres	Description
	Ce constructeur n’a pas de paramètres.

# Construct a 6-Axis Arm named arm with the Arm class
arm = Arm()