6 tengelyes kar#

Bevezetés #

A VEX 6-tengelyes robotkar egy robotmanipulátor, amelyet a CTE munkacellában használnak. A VEXcode EXP-ben az Arm metódusok lehetővé teszik az EXP Brain számára, hogy mozgassa a 6-tengelyes kart, forgatja annak effektorát, ellenőrizze, hogy lehetséges-e mozgás, és vezérelje a csatlakoztatott eszközöket, például a Magnet Pickup Toolt vagy a Pen Holder Toolt.

Ez az oldal olyan CTE Workcell projektekhez készült, ahol a 6-tengelyes kar egy EXP Brainhez van csatlakoztatva. Ha a 6-tengelyes kart önmagában használja a CTE csempével, akkor használja a CTE Arm API oldalt.

Az ezen az oldalon található példák egy arm1 nevű, konfigurált 6 tengelyes kart használnak.

Az alábbiakban felsoroljuk az összes elérhető módszert:

Műveletek — Mozgassa a 6 tengelyes kart a kívánt pozíciókba vagy irányokba.

move_to — A megadott x, y és z koordinátára mozgatja az effektort.
move_inc — A megadott távolsággal elmozdítja az effektort az aktuális pozíciójától.
move_end_effector_to — Elforgatja az effektort egy megadott elfordulási, gördülési és bólintási irányba.
move_end_effector_inc — Elforgatja az effektort a megadott elfordulás, hengerlés és bólintás mértékével.

Mutátorok – Mozgás, eszközök és vezérlési beállítások konfigurálása.

set_speed — Beállítja a 6 tengelyes kar által használt mozgási sebességet.
set_end_effector_type — Beállítja a 6 tengelyes karhoz csatlakoztatott effektor típusát.
set_end_effector_magnet — Bekapcsolja vagy kioldja a mágnesfelvevő eszközt.
set_pen_offset — Beállítja a Tolltartó eszközzel használt z-tengely eltolását.
set_control_stop — Engedélyezi a 6 tengelyes kar vezérlésének leállítását.
set_timeout — Beállítja a 6 tengelyes kar mozgási metódusai által használt időtúllépést.

Getterek – Mozgási állapotot, pozíciót, orientációt és csatlakozási értékeket adnak vissza.

is_done — Visszaadja, hogy a 6 tengelyes kar mozgása befejeződött-e.
is_crashed — Visszaadja, hogy a 6 tengelyes kar mozgás közben összeomlott-e.
get_x — Visszaadja az effektor végpontjának aktuális x pozícióját.
get_y — Visszaadja az effektor végpontjának aktuális y pozícióját.
get_z — Visszaadja az effektor végpontjának aktuális z pozícióját.
get_pitch — Visszaadja az effektor végpontjának aktuális hangmagasságát.
get_roll — Visszaadja az effektor aktuális tekercsét.
get_yaw — Visszaadja az effektor aktuális elfordulását.
can_arm_reach_to — Visszaadja, hogy a 6 tengelyes kar eléri-e a megadott pozíciót.
can_arm_reach_inc — Visszaadja, hogy a 6 tengelyes kar elmozdulhat-e egy megadott távolságot.
can_end_effector_reach_to — Visszaadja, hogy az effektor eléri-e a megadott orientációt.
can_end_effector_reach_inc — Visszaadja, hogy az effektor elforgatható-e egy megadott mértékben.
get_timeout — Visszaadja a mozgásmetódusok által használt aktuális időtúllépési értéket.
is_connected — Visszaadja, hogy a 6 tengelyes kar csatlakoztatva van-e az EXP Brainhez.

Visszahívások — Függvények futtatása élesítési események bekövetkeztekor.

control_stopped — Regisztrál egy függvényt, amely akkor fut, amikor a vezérlés leállítása engedélyezve van.
crashed — Regisztrál egy függvényt, amely összeomlás észlelésekor fut.

Konstruktor — 6 tengelyes kar objektum manuális létrehozása.

Arm — Létrehoz egy 6 tengelyes kar objektumot.

Műveletek #

move_to #

move_to A 6 tengelyes kart a megadott x, y és z koordinátára mozgatja.

Az x, y és z koordináták a végrehajtó egység pozícióját írják le a háromdimenziós térben. Használja a can_arm_reach_to függvényt a metódus előtt, ha a célpozíció a 6 tengelyes kar elérhető munkaterületén kívül eshet.

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

Paraméter	Leírás
`x`	A célpozíció x koordinátája milliméterben.
`y`	A célpozíció y koordinátája milliméterben.
`z`	A célpozíció z-koordinátája milliméterben.
`wait`	Opcionális. `wait=True` (alapértelmezett) esetén a projekt megvárja a mozgás befejeződését a folytatás előtt. `wait=False` esetén a mozgás elindul, és azonnal a kód következő sorával folytatódik.

# 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 A 6 tengelyes kart a jelenlegi pozíciójából a megadott távolsággal elmozdítja az x, y és z tengelyek mentén.

Ezzel a módszerrel mozgathatod a végrehajtó egységet ahhoz képest, ahol most éppen van. Használd a can_arm_reach_inc metódust a metódus előtt, ha a mozgás a 6 tengelyes kart a rendelkezésre álló munkaterületen kívülre helyezheti.

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

Paraméter	Leírás
`x`	Az x tengely mentén elmozdítandó távolság milliméterben.
`y`	Az y tengely mentén elmozdítandó távolság milliméterben.
`z`	A z tengely mentén elmozdítandó távolság milliméterben.
`wait`	Opcionális. `wait=True` (alapértelmezett) esetén a projekt megvárja a mozgás befejeződését a folytatás előtt. `wait=False` esetén a mozgás elindul, és azonnal a kód következő sorával folytatódik.

# 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 paraméterrel a 6 tengelyes kar effektora elforgatható a megadott elfordulási, gördülési és bólintási irányba.

Az orientáció leírja, hogyan forog az effektor. yaw a z tengely körül forog, roll az x tengely körül forog, és pitch az y tengely körül forog.

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

Paraméter	Leírás
`yaw`	A célzott elfordulási szög fokban.
`roll`	A célzott dőlésszög fokban.
`pitch`	A cél dőlésszöge fokban.
`wait`	Opcionális. `wait=True` (alapértelmezett) esetén a projekt megvárja a mozgás befejeződését a folytatás előtt. `wait=False` esetén a mozgás elindul, és azonnal a kód következő sorával folytatódik.

# 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 A 6 tengelyes kar effektorát a megadott elfordulási, gördülési és dőlési értékkel forgatja el az aktuális irányából.

Ezzel a módszerrel forgathatja a végrehajtó egységet az aktuális elforduláshoz, hengerléshez vagy dőlésszöghöz képest.

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

Paraméter	Leírás
`yaw`	Az elfordulás változása fokban.
`roll`	A gördülés változása fokban.
`pitch`	A hangmagasság változása fokban.
`wait`	Opcionális. `wait=True` (alapértelmezett) esetén a projekt megvárja a mozgás befejeződését a folytatás előtt. `wait=False` esetén a mozgás elindul, és azonnal a kód következő sorával folytatódik.

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

Mutátorok #

set_speed #

set_speed beállítja a 6 tengelyes kar által a mozgásmetódusokhoz használt mozgási sebességet.

A 6 tengelyes kar sebességét a projekt elején 50%-ra kell állítani.

Usage:
arm1.set_speed(speed)

Paraméter	Leírás
`speed`	A 6 tengelyes kar mozgási sebessége `1` és `100` százalék között.

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

set_end_effector_type #

set_end_effector_type beállítja a 6 tengelyes karhoz csatlakoztatott effektor típusát.

Amikor a végrehajtó egység típusa megváltozik, a 6 tengelyes kar automatikusan a kiválasztott eszközhöz igazítja a z-eltolást. A végrehajtó egység típusa a projekt elején MAGNET értékre van állítva.

Usage:
arm1.set_end_effector_type(type)

Paraméter	Leírás
`type`	A 6 tengelyes karhoz rögzített szerszám: `MAGNET` (Mágnesfelvevő szerszám) vagy `PEN` (Tolltartó szerszám).

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

set_end_effector_magnet #

set_end_effector_magnet Bekapcsolja vagy kioldja a mágnesfelvevő eszközt.

A mágnes állapota aktív marad, amíg egy másik set_end_effector_magnet metódus meg nem változtatja. A projekt elején a mágnes állapota visszaáll False értékre.

Usage:
arm1.set_end_effector_magnet(state)

Paraméter	Leírás
`state`	A Mágnes Felszedő Eszköz állapota: `True` tárgyak felvételéhez és megtartásához vagy `False` a megtartott tárgyak elejtéséhez és új tárgyak felvételének leállításához.

# 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 beállítja a z tengely eltolását, amelyet akkor használunk, amikor a tolltartó eszköz a 6 tengelyes karhoz van rögzítve.

A módszer használata előtt állítsa az effektor típusát PEN értékre. Ha a Tolltartó eszköz nincs kiválasztva, a módszernek nincs hatása.

A toll eltolás a Tolltartó eszköz tetejétől a szárazon törölhető filctoll hegyéig mért távolság. A projekt elején a toll eltolás értéke 0A 0 -as toll eltolás a kar z tengelyének origóját arra a pontra helyezi, ahol a Tolltartó eszköz csatlakozik a 6 tengelyes karhoz.

Usage:
arm1.set_pen_offset(zOffset)

Paraméter	Leírás
`zOffset`	A toll eltolás értéke milliméterben.

# 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 engedélyezi a 6 tengelyes kar vezérlésének leállítását.

Amikor a vezérlés leállítása engedélyezve van, a 6 tengelyes kar azonnal leállít minden mozgást, és nem futtat további karmozgási metódusokat, amíg a projekt újra nem indul.

Usage:
arm1.set_control_stop(state)

Paraméter	Leírás
`state`	Opcionális. `True` (alapértelmezett) engedélyezi a vezérlés leállítását. `False` nem engedélyezi a vezérlés leállítását.

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

set_timeout #

set_timeout beállítja az időtúllépési értéket, amely a 6 tengelyes kar mozgatásakor használatos.

Ha egy mozgás nem fejeződik be az időkorlát elérése előtt, a projekt a kód következő sorával folytatódik.

Usage:
arm1.set_timeout(timeout, units)

Paraméter	Leírás
`timeout`	Az új időtúllépési érték.
`units`	Opcionális. Az időegység: `MSEC` (milliszekundum, alapértelmezett), `SECONDS`vagy `SEC`.

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

Getterek #

is_done #

is_done visszaadja, hogy a 6 tengelyes kar mozgása befejeződött-e.

Ez a metódus akkor hasznos, ha egy movement metódust hívunk meg wait=False értékkel.

True — A 6 tengelyes kar mozgása befejeződött.
False — A 6 tengelyes kar még mindig mozog.

Usage:
arm1.is_done()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

# 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 Visszaadja, hogy a 6 tengelyes kar mozgás közben összeomlott-e.

Ütközés észlelésekor a 6 tengelyes kar leállítja a motor mozgását, és úgy tűnhet, mintha ernyedni kezdene. Ez csökkenti a terhelést és segít megvédeni a motorokat a véletlen sérülésektől.

True — A 6 tengelyes kar összeomlott.
False — A 6 tengelyes kar nem omlott össze.

Usage:
arm1.is_crashed()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

# 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 visszaadja az effektor aktuális x pozícióját milliméterben.

Ezzel a módszerrel leolvashatja, hogy az effektor jelenleg hol helyezkedik el az x tengely mentén.

Usage:
arm1.get_x()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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

get_y #

get_y visszaadja az effektor aktuális y pozícióját milliméterben.

Ezzel a módszerrel leolvashatja, hogy az effektor jelenleg hol helyezkedik el az y tengely mentén.

Usage:
arm1.get_y()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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

get_z #

get_z visszaadja az effektor aktuális z pozícióját milliméterben.

Ezzel a módszerrel leolvashatja, hogy hol helyezkedik el jelenleg az effektor a z tengely mentén.

Usage:
arm1.get_z()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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

get_pitch #

get_pitch visszaadja az effektor aktuális hangmagasságát fokban.

Usage:
arm1.get_pitch()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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

get_roll #

get_roll visszaadja az effektor aktuális elfordulását fokban.

Usage:
arm1.get_roll()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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

get_yaw #

get_yaw visszaadja az effektor aktuális elfordulását fokban.

Usage:
arm1.get_yaw()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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

can_arm_reach_to #

can_arm_reach_to Visszaadja, hogy a 6 tengelyes kar képes-e a megadott x, y és z koordinátára mozgatni az effektort.

Ezzel a metódussal ellenőrizheted a célpozíciót a move_to metódus használata előtt.

True — A 6 tengelyes kar eléri a kért pozíciót.
False — A 6 tengelyes kar nem éri el a kért pozíciót.

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

Paraméter	Leírás
`x`	A célpozíció x koordinátája milliméterben.
`y`	A célpozíció y koordinátája milliméterben.
`z`	A célpozíció z-koordinátája milliméterben.

# 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 Visszaadja, hogy a 6 tengelyes kar el tudja-e mozgatni az effektort a megadott x, y és z távolsággal az aktuális pozíciójától.

Ezzel a módszerrel ellenőrizheti a relatív mozgást a move_inc használata előtt.

True — A 6 tengelyes kar képes elvégezni a kért mozgást.
False — A 6 tengelyes kar nem tudja végrehajtani a kért mozgást.

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

Paraméter	Leírás
`x`	Az x tengely mentén elmozdítandó távolság milliméterben.
`y`	Az y tengely mentén elmozdítandó távolság milliméterben.
`z`	A z tengely mentén elmozdítandó távolság milliméterben.

# 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 visszaadja, hogy az effektor el tud-e forgatni egy megadott elfordulási, gördülési és bólintási irányba.

Ezzel a módszerrel ellenőrizheti a célpont orientációját a move_end_effector_to metódus használata előtt.

True — A végrehajtó egység elérheti a kért orientációt.
False — A végrehajtó egység nem tudja elérni a kért tájolást.

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

Paraméter	Leírás
`yaw`	A célzott elfordulási szög fokban.
`roll`	A célzott dőlésszög fokban.
`pitch`	A cél dőlésszöge fokban.

# 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 visszaadja, hogy az effektor el tud-e forgatni egy megadott elfordulási, hengerlési és dőlésszög-értékkel az aktuális irányából.

Ezzel a módszerrel ellenőrizheti a relatív orientációs mozgást a move_end_effector_inc használata előtt.

True — A végrehajtó egység elvégezheti a kért forgatást.
False — A végrehajtó egység nem tudja végrehajtani a kért forgatást.

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

Paraméter	Leírás
`yaw`	Az elfordulás változása fokban.
`roll`	A gördülés változása fokban.
`pitch`	A hangmagasság változása fokban.

# 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 Visszaadja a 6 tengelyes kar mozgásmetódusai által használt időtúllépési értéket milliszekundumban.

Usage:
arm1.get_timeout()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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

is_connected #

is_connected visszaadja, hogy a 6 tengelyes kar csatlakoztatva van-e az EXP Brain-hez.

True — A 6 tengelyes kar az EXP agyhoz van csatlakoztatva.
False — A 6 tengelyes kar nincs csatlakoztatva az EXP agyhoz.

Usage:
arm1.is_connected()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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

Visszahívások #

control_stopped #

control_stopped regisztrál egy függvényt, amely akkor fut, amikor a vezérlés leállítása engedélyezve van.

Ez a metódus a Event osztály egy példányát adja vissza.

Usage:
arm1.control_stopped(callback, arg)

Paraméter	Leírás
`callback`	Egy korábban definiált függvény, amely akkor fut, amikor a vezérlés leállítása engedélyezve van.
`arg`	Opcionális. Egy tuple, amely argumentumokat tartalmaz a visszahívó függvénynek átadandó. További információkért lásd a Függvények használata paraméterekkel részt.

# 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 Egy olyan függvényt regisztrál, amely akkor fut le, amikor a 6 tengelyes kar mozgás közben összeomlik.

Usage:
arm1.crashed(callback)

Paraméter	Leírás
`callback`	Egy korábban definiált függvény, amely összeomlás észlelésekor fut le.

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

Konstruktorok #

Arm #

Arm parancs egy 6 tengelyes Kar objektumot hoz létre.

Usage:
Arm(smartport)

Paraméter	Leírás
`smartport`	Az az intelligens port, amelyhez a 6 tengelyes kar csatlakozik, `Ports.PORTx`formában írva, ahol `x` a port száma.

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