6osé rameno#

Zavedení #

VEX 6osé robotické rameno je robotický manipulátor používaný v pracovní buňce CTE. V kódu VEXcode EXP umožňují metody Arm EXP Brainu pohybovat 6osým ramenem, otáčet jeho koncovým efektorem, kontrolovat, zda jsou pohyby možné, a ovládat připojené nástroje, jako je magnetický snímací nástroj nebo držák pera.

Tato stránka je určena pro projekty CTE Workcell, kde je 6osé rameno připojeno k EXP Brainu. Pokud používáte 6osé rameno samostatně s dlaždicí CTE, použijte místo toho stránku CTE Arm API.

Příklady na této stránce používají nakonfigurované 6osé rameno s názvem arm1.

Níže je uveden seznam všech dostupných metod:

Akce – Pohyb 6osého ramene do pozic nebo orientací.

move_to — Přesune koncový efektor na zadanou souřadnici x, y a z.
move_inc — Přesune koncový efektor o zadanou vzdálenost od jeho aktuální pozice.
move_end_effector_to — Otočí koncový efektor do zadané orientace stáčení, klopení a stoupání.
move_end_effector_inc — Otočí koncový efektor o zadanou hodnotu stáčení, klopení a stoupání.

Mutátory – Konfigurace pohybu, nástrojů a nastavení ovládání.

set_speed — Nastavuje rychlost pohybu používanou 6osým ramenem.
set_end_effector_type — Nastaví typ koncového efektoru připojeného k 6osému ramenu.
set_end_effector_magnet — Zapne nebo uvolní nástroj pro snímání magnetu.
set_pen_offset — Nastaví posun osy z použitý s nástrojem Držák pera.
set_control_stop — Povolí zastavení řízení pro 6osé rameno.
set_timeout — Nastaví časový limit používaný metodami pohybu 6osého ramene.

Gettery – Vracejí stav pohybu, pozici, orientaci a hodnoty připojení.

is_done — Vrátí, zda se pohyb 6osého ramene dokončil.
is_crashed — Vrátí, zda došlo k havárii 6osého ramene během pohybu.
get_x — Vrátí aktuální pozici x koncového efektoru.
get_y — Vrátí aktuální pozici y koncového efektoru.
get_z — Vrátí aktuální pozici z koncového efektoru.
get_pitch — Vrátí aktuální výšku tónu koncového efektoru.
get_roll — Vrátí aktuální hod koncového efektoru.
get_yaw — Vrátí aktuální natočení koncového efektoru.
can_arm_reach_to — Vrátí, zda 6osé rameno může dosáhnout zadané polohy.
can_arm_reach_inc — Vrátí, zda se 6osé rameno může pohybovat o zadanou vzdálenost.
can_end_effector_reach_to — Vrací, zda koncový efektor může dosáhnout zadané orientace.
can_end_effector_reach_inc — Vrátí, zda se koncový efektor může otočit o zadanou hodnotu.
get_timeout — Vrátí aktuální hodnotu časového limitu používanou metodami pohybu.
is_connected — Vrátí, zda je 6osé rameno připojeno k EXP Brainu.

Zpětná volání — Spouštějí funkce, když dojde k událostem arm.

control_stopped — Registruje funkci, která se má spustit, když je povoleno zastavení řízení.
crashed — Zaregistruje funkci, která se spustí při detekci havárie.

Konstruktor – Ručně vytvořte objekt 6osého ramene.

Arm — Vytvoří objekt Rameno se 6 osami.

Akce #

move_to #

move_to přesune 6osé rameno na zadanou souřadnici x, y a z.

Souřadnice x, y a z popisují polohu koncového efektoru v trojrozměrném prostoru. Pokud cílová poloha může být mimo dosažitelný pracovní prostor 6osého ramene, použijte před touto metodou can_arm_reach_to.

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

Parametr	Popis
`x`	Souřadnice x cílové polohy v milimetrech.
`y`	Souřadnice y cílové polohy v milimetrech.
`z`	Souřadnice z cílové polohy v milimetrech.
`wait`	Volitelné. `wait=True` (výchozí) způsobí, že projekt bude čekat na dokončení pohybu, než bude pokračovat. `wait=False` spustí pohyb a okamžitě pokračuje na další řádek kódu.

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

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

while not arm1.is_done():
    brain.screen.print(arm1.get_y())
    brain.screen.next_row()
    wait(0.25, SECONDS)

move_inc #

move_inc posune 6osé rameno o zadanou vzdálenost od jeho aktuální polohy podél os x, y a z.

Tuto metodu použijte pro pohyb vzhledem k aktuálnímu umístění koncového efektoru. Pokud pohyb může umístit 6osé rameno mimo jeho dosažitelný pracovní prostor, použijte před touto metodou can_arm_reach_inc.

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

Parametr	Popis
`x`	Vzdálenost, o kterou se má posunout podél osy x v milimetrech.
`y`	Vzdálenost, o kterou se má posunout podél osy y v milimetrech.
`z`	Vzdálenost, o kterou se má posunout podél osy z v milimetrech.
`wait`	Volitelné. `wait=True` (výchozí) způsobí, že projekt bude čekat na dokončení pohybu, než bude pokračovat. `wait=False` spustí pohyb a okamžitě pokračuje na další řádek kódu.

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

move_end_effector_to #

move_end_effector_to otáčí koncový efektor 6osého ramene do zadané orientace stáčení, klopení a náklonu.

Orientace popisuje, jak se koncový efektor otáčí. yaw otáčí kolem osy z, roll otáčí kolem osy x a pitch otáčí kolem osy y.

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

Parametr	Popis
`yaw`	Cílový úhel stáčení ve stupních.
`roll`	Úhel náklonu cíle ve stupních.
`pitch`	Cílový úhel náklonu ve stupních.
`wait`	Volitelné. `wait=True` (výchozí) způsobí, že projekt bude čekat na dokončení pohybu, než bude pokračovat. `wait=False` spustí pohyb a okamžitě pokračuje na další řádek kódu.

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

move_end_effector_inc #

move_end_effector_inc otočí koncový efektor 6osého ramene o zadanou hodnotu vybočení, naklonění a stoupání oproti jeho aktuální orientaci.

Tuto metodu použijte k otočení vzhledem k aktuálnímu stáčení, klopení nebo stoupání koncového efektoru.

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

Parametr	Popis
`yaw`	Změna stáčení ve stupních.
`roll`	Změna náklonu ve stupních.
`pitch`	Změna výšky tónu, ve stupních.
`wait`	Volitelné. `wait=True` (výchozí) způsobí, že projekt bude čekat na dokončení pohybu, než bude pokračovat. `wait=False` spustí pohyb a okamžitě pokračuje na další řádek kódu.

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

Mutátory #

set_speed #

set_speed nastavuje rychlost pohybu používanou 6osým ramenem pro metody pohybu.

Rychlost 6osého ramene je na začátku projektu nastavena na 50 %.

Usage:
arm1.set_speed(speed)

Parametr	Popis
`speed`	The movement speed of the 6-Axis Arm, from `1` to `100` percent.

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

set_end_effector_type #

set_end_effector_type nastavuje typ koncového efektoru připojeného k 6osému ramenu.

Když se změní typ koncového efektoru, 6osé rameno automaticky upraví svůj z-offset tak, aby odpovídal vybranému nástroji. Typ koncového efektoru je na začátku projektu nastaven na MAGNET.

Usage:
arm1.set_end_effector_type(type)

Parametr	Popis
`type`	Nástroj připojený k 6osému ramenu: `MAGNET` (nástroj pro snímání magnetu) nebo `PEN` (nástroj pro držák pera).

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

set_end_effector_magnet #

set_end_effector_magnet zapne nebo uvolní nástroj pro snímání magnetu.

Stav magnetu zůstává aktivní, dokud jej nezmění jiná metoda set_end_effector_magnet Stav magnetu se na začátku projektu resetuje na False.

Usage:
arm1.set_end_effector_magnet(state)

Parametr	Popis
`state`	Stav nástroje pro magnetické sbírání: `True` pro zvednutí a držení předmětů nebo `False` pro upuštění jakéhokoli drženého předmětu a zastavení zvedání nových předmětů.

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

set_pen_offset #

set_pen_offset nastavuje ofset osy z použitý, když je nástroj Držák pera připojen k 6osému ramenu.

Před použitím této metody nastavte typ koncového efektoru na PEN Pokud není vybrán nástroj Držák pera, tato metoda nemá žádný účinek.

Posunutí pera je vzdálenost od horní části držáku pera ke špičce fixu stíratelného za sucha. Na začátku projektu je posunutí pera nastaveno na 0Posunutí pera 0 umístí počátek osy z ramene do bodu, kde se držák pera připojuje k 6osému rameni.

Usage:
arm1.set_pen_offset(zOffset)

Parametr	Popis
`zOffset`	Hodnota odsazení pera v milimetrech.

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

set_control_stop #

set_control_stop povoluje zastavení řízení pro 6osé rameno.

Je-li povoleno zastavení řízení, 6osé rameno okamžitě zastaví jakýkoli pohyb a nespustí žádné další metody pohybu ramene, dokud nebude projekt restartován.

Usage:
arm1.set_control_stop(state)

Parametr	Popis
`state`	Volitelné. `True` (výchozí) povoluje zastavení řízení. `False` nepovoluje zastavení řízení.

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

set_timeout #

set_timeout nastavuje hodnotu časového limitu použitého při pohybu 6osého ramene.

Pokud pohyb nedokončí před uplynutím časového limitu, projekt pokračuje na další řádek kódu.

Usage:
arm1.set_timeout(timeout, units)

Parametr	Popis
`timeout`	Nová hodnota časového limitu.
`units`	Volitelné. Časová jednotka: `MSEC` (milisekundy, výchozí), `SECONDS`nebo `SEC`.

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

Gettery #

is_done #

is_done vrací, zda se pohyb 6osého ramene dokončil.

Tato metoda je užitečná po volání metody pohybu s hodnotou wait=False.

True — Pohyb 6osého ramene byl dokončen.
False — 6osé rameno se stále pohybuje.

Usage:
arm1.is_done()

Parametry	Popis
	Tato metoda nemá žádné parametry.

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

while not arm1.is_done():
    brain.screen.print(arm1.get_y())
    brain.screen.next_row()
    wait(0.25, SECONDS)

is_crashed #

is_crashed vrací, zda došlo k havárii 6osého ramene během pohybu.

Pokud je detekována havárie, 6osé rameno zastaví pohyb motoru a může se zdát, že se zablokovalo. To snižuje namáhání a pomáhá chránit motory před náhodným poškozením.

True — Došlo k havárii 6osého ramene.
False — 6osé rameno se nezhroutilo.

Usage:
arm1.is_crashed()

Parametry	Popis
	Tato metoda nemá žádné parametry.

# Quickly move to a new location
arm1.set_speed(100)
arm1.move_to(-30, 240, 40, wait=False)

# While moving, check for a crash
while True:
    if arm1.is_crashed():
        # Indicate a crash with the Signal Tower and Brain screen
        brain.screen.print("Crash Detected")
        signal_tower_2.set_color(SignalTower.GREEN, SignalTower.OFF)
        signal_tower_2.set_color(SignalTower.RED, SignalTower.ON)
        break

    wait(5, MSEC)

get_x #

get_x vrací aktuální pozici x koncového efektoru v milimetrech.

Tuto metodu použijte k odečtení aktuálně umístěné polohy koncového efektoru podél osy x.

Usage:
arm1.get_x()

Parametry	Popis
	Tato metoda nemá žádné parametry.

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

get_y #

get_y vrací aktuální pozici y koncového efektoru v milimetrech.

Tuto metodu použijte k odečtení aktuální polohy koncového efektoru podél osy y.

Usage:
arm1.get_y()

Parametry	Popis
	Tato metoda nemá žádné parametry.

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

get_z #

get_z vrací aktuální polohu z koncového efektoru v milimetrech.

Tuto metodu použijte k odečtení aktuálně umístěné polohy koncového efektoru podél osy z.

Usage:
arm1.get_z()

Parametry	Popis
	Tato metoda nemá žádné parametry.

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

get_pitch #

get_pitch vrací aktuální sklon koncového efektoru ve stupních.

Usage:
arm1.get_pitch()

Parametry	Popis
	Tato metoda nemá žádné parametry.

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

get_roll #

get_roll vrací aktuální natočení koncového efektoru ve stupních.

Usage:
arm1.get_roll()

Parametry	Popis
	Tato metoda nemá žádné parametry.

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

get_yaw #

get_yaw vrací aktuální natočení koncového efektoru ve stupních.

Usage:
arm1.get_yaw()

Parametry	Popis
	Tato metoda nemá žádné parametry.

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

can_arm_reach_to #

can_arm_reach_to vrací, zda 6osé rameno může pohybovat koncovým efektorem na zadanou souřadnici x, y a z.

Tuto metodu použijte ke kontrole cílové pozice před použitím move_to.

True — 6osé rameno může dosáhnout požadované polohy.
False — 6osé rameno nemůže dosáhnout požadované polohy.

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

Parametr	Popis
`x`	Souřadnice x cílové polohy v milimetrech.
`y`	Souřadnice y cílové polohy v milimetrech.
`z`	Souřadnice z cílové polohy v milimetrech.

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

can_arm_reach_inc #

can_arm_reach_inc vrací, zda 6osé rameno může posunout koncový efektor o zadanou vzdálenost x, y a z od jeho aktuální polohy.

Tuto metodu použijte ke kontrole relativního pohybu před použitím move_inc.

True — 6osé rameno může provést požadovaný pohyb.
False — 6osé rameno nemůže provést požadovaný pohyb.

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

Parametr	Popis
`x`	Vzdálenost, o kterou se má posunout podél osy x v milimetrech.
`y`	Vzdálenost, o kterou se má posunout podél osy y v milimetrech.
`z`	Vzdálenost, o kterou se má posunout podél osy z v milimetrech.

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

can_end_effector_reach_to #

can_end_effector_reach_to vrací, zda se koncový efektor může otáčet do zadané orientace stáčení, klopení a stoupání.

Tuto metodu použijte ke kontrole orientace cíle před použitím move_end_effector_to.

True — Koncový efektor může dosáhnout požadované orientace.
False — Koncový efektor nemůže dosáhnout požadované orientace.

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

Parametr	Popis
`yaw`	Cílový úhel stáčení ve stupních.
`roll`	Úhel náklonu cíle ve stupních.
`pitch`	Cílový úhel náklonu ve stupních.

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

can_end_effector_reach_inc #

can_end_effector_reach_inc vrací, zda se koncový efektor může otočit o zadanou hodnotu stáčení, klopení a stoupání od své aktuální orientace.

Tuto metodu použijte ke kontrole relativního orientačního pohybu před použitím move_end_effector_inc.

True — Koncový efektor může provést požadovanou rotaci.
False — Koncový efektor nemůže provést požadovanou rotaci.

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

Parametr	Popis
`yaw`	Změna stáčení ve stupních.
`roll`	Změna náklonu ve stupních.
`pitch`	Změna výšky tónu, ve stupních.

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

get_timeout #

get_timeout vrací hodnotu časového limitu používanou metodami pohybu 6osého ramene v milisekundách.

Usage:
arm1.get_timeout()

Parametry	Popis
	Tato metoda nemá žádné parametry.

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

is_connected #

is_connected vrací, zda je 6osé rameno připojeno k EXP Brainu.

True — 6osé rameno je připojeno k EXP mozku.
False — 6osé rameno není připojeno k EXP Brainu.

Usage:
arm1.is_connected()

Parametry	Popis
	Tato metoda nemá žádné parametry.

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

Zpětná volání #

control_stopped #

control_stopped registruje funkci, která se spustí, když je povoleno zastavení řízení.

Tato metoda vrací instanci třídy Event.

Usage:
arm1.control_stopped(callback, arg)

Parametr	Popis
`callback`	Dříve definovaná funkce, která se spustí, když je povoleno zastavení řízení.
`arg`	Volitelné. N-tice obsahující argumenty, které se mají předat funkci zpětného volání. Další informace naleznete v části Použití funkcí s parametry.

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

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

crashed #

crashed registruje funkci, která se spustí, když 6osé rameno havaruje během pohybu.

Pokud je detekována havárie, 6osé rameno zastaví pohyb motoru a může se zdát, že se zablokovalo. To snižuje namáhání a pomáhá chránit motory před náhodným poškozením.

Usage:
arm1.crashed(callback)

Parametr	Popis
`callback`	Dříve definovaná funkce, která se spustí při detekci havárie.

# Define what happens if a crash is detected
def arm_crash():
    brain.screen.print("Crash Detected")
    signal_tower_2.set_color(SignalTower.RED, SignalTower.ON)

# Run arm_crash when the 6-Axis Arm crashes
arm1.crashed(arm_crash)

Konstruktéři #

Arm #

Arm vytvoří objekt 6osého ramene.

Usage:
Arm(smartport)

Parametr	Popis
`smartport`	Inteligentní port, ke kterému je připojeno 6osé rameno, zapsaný jako `Ports.PORTx`, kde `x` je číslo portu.

# Construct a 6-Axis Arm named arm1 with the Arm class
arm1 = Arm(Ports.PORT1)