6-ആക്സിസ് ആം#

ആമുഖം #

CTE വർക്ക്സെല്ലിൽ ഉപയോഗിക്കുന്ന ഒരു റോബോട്ടിക് മാനിപ്പുലേറ്ററാണ് VEX 6-ആക്സിസ് റോബോട്ടിക് ആം. VEXcode EXP-ൽ, ആം രീതികൾ ഒരു EXP ബ്രെയിനിനെ 6-ആക്സിസ് ആം ചലിപ്പിക്കാനും, അതിന്റെ എൻഡ് ഇഫക്റ്റർ തിരിക്കാനും, ചലനങ്ങൾ സാധ്യമാണോ എന്ന് പരിശോധിക്കാനും, മാഗ്നെറ്റ് പിക്കപ്പ് ടൂൾ അല്ലെങ്കിൽ പെൻ ഹോൾഡർ ടൂൾ പോലുള്ള അറ്റാച്ച് ചെയ്ത ഉപകരണങ്ങൾ നിയന്ത്രിക്കാനും അനുവദിക്കുന്നു.

6-ആക്സിസ് ആം ഒരു EXP ബ്രെയിനുമായി ബന്ധിപ്പിച്ചിരിക്കുന്ന CTE വർക്ക്സെൽ പ്രോജക്റ്റുകൾക്കുള്ളതാണ് ഈ പേജ്. നിങ്ങൾ CTE ടൈലിനൊപ്പം 6-ആക്സിസ് ആം സ്വന്തമായി ഉപയോഗിക്കുകയാണെങ്കിൽ, പകരം CTE ആം API പേജ് ഉപയോഗിക്കുക.

ഈ പേജിലെ ഉദാഹരണങ്ങൾ arm1 എന്ന് പേരുള്ള ഒരു കോൺഫിഗർ ചെയ്ത 6-ആക്സിസ് ആം ഉപയോഗിക്കുന്നു.

ലഭ്യമായ എല്ലാ രീതികളുടെയും ഒരു ലിസ്റ്റ് താഴെ കൊടുക്കുന്നു:

പ്രവർത്തനങ്ങൾ — 6-ആക്സിസ് ആം സ്ഥാനങ്ങളിലേക്കോ ഓറിയന്റേഷനുകളിലേക്കോ നീക്കുക.

move_to — എൻഡ് ഇഫക്റ്ററിനെ ഒരു നിർദ്ദിഷ്ട x, y, z കോർഡിനേറ്റിലേക്ക് നീക്കുന്നു.
move_inc — എൻഡ് ഇഫക്റ്ററിനെ അതിന്റെ നിലവിലെ സ്ഥാനത്ത് നിന്ന് ഒരു നിശ്ചിത ദൂരം നീക്കുന്നു.
move_end_effector_to — എൻഡ് ഇഫക്റ്ററിനെ ഒരു നിർദ്ദിഷ്ട യാവ്, റോൾ, പിച്ച് ഓറിയന്റേഷനിലേക്ക് തിരിക്കുന്നു.
move_end_effector_inc — ഒരു നിശ്ചിത യാവ്, റോൾ, പിച്ച് തുക ഉപയോഗിച്ച് എൻഡ് ഇഫക്റ്ററിനെ തിരിക്കുന്നു.

മ്യൂട്ടേറ്ററുകൾ — ചലനം, ഉപകരണങ്ങൾ, നിയന്ത്രണ ക്രമീകരണങ്ങൾ എന്നിവ കോൺഫിഗർ ചെയ്യുക.

set_speed — 6-ആക്സിസ് ആം ഉപയോഗിക്കുന്ന ചലന വേഗത സജ്ജമാക്കുന്നു.
set_end_effector_type — 6-ആക്സിസ് ആം ഘടിപ്പിച്ചിരിക്കുന്ന എൻഡ് ഇഫക്റ്ററിന്റെ തരം സജ്ജമാക്കുന്നു.
set_end_effector_magnet — മാഗ്നെറ്റ് പിക്കപ്പ് ടൂൾ ഇടപഴകുകയോ റിലീസ് ചെയ്യുകയോ ചെയ്യുന്നു.
set_pen_offset — പെൻ ഹോൾഡർ ടൂളിനൊപ്പം ഉപയോഗിക്കുന്ന z-ആക്സിസ് ഓഫ്‌സെറ്റ് സജ്ജമാക്കുന്നു.
set_control_stop — 6-ആക്സിസ് ആം-നുള്ള കൺട്രോൾ സ്റ്റോപ്പ് പ്രാപ്തമാക്കുന്നു.
set_timeout — 6-ആക്സിസ് ആം മൂവ്മെന്റ് രീതികൾ ഉപയോഗിക്കുന്ന ടൈംഔട്ട് സജ്ജമാക്കുന്നു.

ഗെറ്ററുകൾ — ചലന നില, സ്ഥാനം, ഓറിയന്റേഷൻ, കണക്ഷൻ മൂല്യങ്ങൾ എന്നിവ തിരികെ നൽകുക.

is_done — 6-ആക്സിസ് ആം ചലിക്കുന്നത് അവസാനിച്ചോ എന്ന് നൽകുന്നു.
is_crashed — ചലിക്കുമ്പോൾ 6-ആക്സിസ് ആം തകർന്നോ എന്ന് നൽകുന്നു.
get_x — എൻഡ് ഇഫക്റ്ററിന്റെ നിലവിലെ x സ്ഥാനം നൽകുന്നു.
get_y — എൻഡ് ഇഫക്റ്ററിന്റെ നിലവിലെ y സ്ഥാനം നൽകുന്നു.
get_z — എൻഡ് ഇഫക്റ്ററിന്റെ നിലവിലെ z സ്ഥാനം നൽകുന്നു.
get_pitch — എൻഡ് ഇഫക്റ്ററിന്റെ നിലവിലെ പിച്ച് നൽകുന്നു.
get_roll — എൻഡ് ഇഫക്ടറിന്റെ നിലവിലെ റോൾ തിരികെ നൽകുന്നു.
get_yaw — എൻഡ് ഇഫക്റ്ററിന്റെ നിലവിലെ yaw തിരികെ നൽകുന്നു.
can_arm_reach_to — 6-ആക്സിസ് ആം ഒരു നിർദ്ദിഷ്ട സ്ഥാനത്ത് എത്താൻ കഴിയുമോ എന്ന് നൽകുന്നു.
can_arm_reach_inc — 6-ആക്സിസ് ആം ഒരു നിശ്ചിത ദൂരം നീങ്ങാൻ കഴിയുമോ എന്ന് നൽകുന്നു.
can_end_effector_reach_to — എൻഡ് ഇഫക്റ്ററിന് ഒരു നിർദ്ദിഷ്ട ഓറിയന്റേഷനിൽ എത്താൻ കഴിയുമോ എന്ന് നൽകുന്നു.
can_end_effector_reach_inc — എൻഡ് ഇഫക്റ്ററിന് ഒരു നിശ്ചിത അളവിൽ തിരിക്കാൻ കഴിയുമോ എന്ന് നൽകുന്നു.
get_timeout — ചലന രീതികൾ ഉപയോഗിക്കുന്ന നിലവിലെ ടൈംഔട്ട് മൂല്യം നൽകുന്നു.
is_connected — 6-ആക്സിസ് ആം EXP ബ്രെയിനുമായി ബന്ധിപ്പിച്ചിട്ടുണ്ടോ എന്ന് നൽകുന്നു.

കോൾബാക്കുകൾ — ആം ഇവന്റുകൾ സംഭവിക്കുമ്പോൾ ഫംഗ്ഷനുകൾ പ്രവർത്തിപ്പിക്കുക.

control_stopped — കൺട്രോൾ സ്റ്റോപ്പ് പ്രാപ്തമാക്കുമ്പോൾ പ്രവർത്തിപ്പിക്കുന്നതിനായി ഒരു ഫംഗ്ഷൻ രജിസ്റ്റർ ചെയ്യുന്നു.
crashed — ഒരു ക്രാഷ് കണ്ടെത്തുമ്പോൾ പ്രവർത്തിപ്പിക്കുന്നതിനായി ഒരു ഫംഗ്ഷൻ രജിസ്റ്റർ ചെയ്യുന്നു.

കൺസ്ട്രക്ടർ — ഒരു 6-ആക്സിസ് ആം ഒബ്‌ജക്റ്റ് സ്വമേധയാ സൃഷ്ടിക്കുക.

Arm — ഒരു 6-Axis Arm ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്നു.

പ്രവർത്തനങ്ങൾ #

move_to #

move_to 6-ആക്സിസ് ആർമിനെ ഒരു നിശ്ചിത x, y, z കോർഡിനേറ്റിലേക്ക് നീക്കുന്നു.

x, y, z എന്നീ കോർഡിനേറ്റുകൾ ത്രിമാന സ്ഥലത്ത് എൻഡ് ഇഫക്റ്ററിന്റെ സ്ഥാനം വിവരിക്കുന്നു. ലക്ഷ്യ സ്ഥാനം 6-ആക്സിസ് ആമിന്റെ എത്തിച്ചേരാവുന്ന വർക്ക്‌സ്‌പെയ്‌സിന് പുറത്താണെങ്കിൽ ഈ രീതിക്ക് മുമ്പ് can_arm_reach_to ഉപയോഗിക്കുക.

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

പാരാമീറ്റർ	വിവരണം
`x`	ലക്ഷ്യ സ്ഥാനത്തിന്റെ x-കോർഡിനേറ്റ് മില്ലിമീറ്ററിൽ.
`y`	ലക്ഷ്യ സ്ഥാനത്തിന്റെ y-കോർഡിനേറ്റ് മില്ലിമീറ്ററിൽ.
`z`	ലക്ഷ്യ സ്ഥാനത്തിന്റെ z-കോർഡിനേറ്റ് മില്ലിമീറ്ററിൽ.
`wait`	ഓപ്ഷണൽ. `wait=True` (ഡിഫോൾട്ട്) പ്രോജക്റ്റിനെ ചലനം പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കാൻ പ്രേരിപ്പിക്കുന്നു, തുടർന്ന് തുടരും. `wait=False` ചലനം ആരംഭിച്ച് ഉടൻ തന്നെ കോഡിന്റെ അടുത്ത വരിയിലേക്ക് പോകുന്നു.

# 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 6-ആക്സിസ് ആർമിനെ അതിന്റെ നിലവിലെ സ്ഥാനത്ത് നിന്ന് x, y, z അക്ഷങ്ങളിലൂടെ ഒരു നിശ്ചിത ദൂരം നീക്കുന്നു.

എൻഡ് ഇഫക്റ്റർ ഇപ്പോൾ ഉള്ളിടത്തേക്ക് ആപേക്ഷികമായി നീങ്ങാൻ ഈ രീതി ഉപയോഗിക്കുക. ചലനം 6-ആക്സിസ് ആം അതിന്റെ എത്തിച്ചേരാവുന്ന വർക്ക്‌സ്‌പെയ്‌സിന് പുറത്ത് സ്ഥാപിക്കാൻ സാധ്യതയുണ്ടെങ്കിൽ, ഈ രീതിക്ക് മുമ്പ് can_arm_reach_inc ഉപയോഗിക്കുക.

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

പാരാമീറ്റർ	വിവരണം
`x`	x-അക്ഷത്തിലൂടെ സഞ്ചരിക്കേണ്ട ദൂരം മില്ലിമീറ്ററിൽ.
`y`	y-അക്ഷത്തിലൂടെ സഞ്ചരിക്കേണ്ട ദൂരം മില്ലിമീറ്ററിൽ.
`z`	z-അക്ഷത്തിലൂടെ സഞ്ചരിക്കേണ്ട ദൂരം മില്ലിമീറ്ററിൽ.
`wait`	ഓപ്ഷണൽ. `wait=True` (ഡിഫോൾട്ട്) പ്രോജക്റ്റിനെ ചലനം പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കാൻ പ്രേരിപ്പിക്കുന്നു, തുടർന്ന് തുടരും. `wait=False` ചലനം ആരംഭിച്ച് ഉടൻ തന്നെ കോഡിന്റെ അടുത്ത വരിയിലേക്ക് പോകുന്നു.

# 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 6-ആക്സിസ് ആംസിന്റെ എൻഡ് ഇഫക്റ്ററിനെ ഒരു നിർദ്ദിഷ്ട യാവ്, റോൾ, പിച്ച് ഓറിയന്റേഷനിലേക്ക് തിരിക്കുന്നു.

ഓറിയന്റേഷൻ എൻഡ് ഇഫക്റ്റർ എങ്ങനെ തിരിക്കുന്നുവെന്ന് വിവരിക്കുന്നു. yaw z-അക്ഷത്തിന് ചുറ്റും കറങ്ങുന്നു, roll x-അക്ഷത്തിന് ചുറ്റും കറങ്ങുന്നു, pitch y-അക്ഷത്തിന് ചുറ്റും കറങ്ങുന്നു.

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

പാരാമീറ്റർ	വിവരണം
`yaw`	ലക്ഷ്യ സ്ഥാനചലന ആംഗിൾ, ഡിഗ്രികളിൽ.
`roll`	ലക്ഷ്യ റോൾ ആംഗിൾ, ഡിഗ്രികളിൽ.
`pitch`	ലക്ഷ്യ പിച്ച് ആംഗിൾ, ഡിഗ്രികളിൽ.
`wait`	ഓപ്ഷണൽ. `wait=True` (ഡിഫോൾട്ട്) പ്രോജക്റ്റിനെ ചലനം പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കാൻ പ്രേരിപ്പിക്കുന്നു, തുടർന്ന് തുടരും. `wait=False` ചലനം ആരംഭിച്ച് ഉടൻ തന്നെ കോഡിന്റെ അടുത്ത വരിയിലേക്ക് പോകുന്നു.

# 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 6-ആക്സിസ് ആമിന്റെ എൻഡ് ഇഫക്റ്ററിനെ അതിന്റെ നിലവിലെ ഓറിയന്റേഷനിൽ നിന്ന് ഒരു നിശ്ചിത യാവ്, റോൾ, പിച്ച് തുക ഉപയോഗിച്ച് തിരിക്കുന്നു.

എൻഡ് ഇഫക്റ്ററിന്റെ കറന്റ് യാവ്, റോൾ അല്ലെങ്കിൽ പിച്ചിന് ആപേക്ഷികമായി തിരിക്കാൻ ഈ രീതി ഉപയോഗിക്കുക.

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

പാരാമീറ്റർ	വിവരണം
`yaw`	യാവിലെ മാറ്റം, ഡിഗ്രികളിൽ.
`roll`	റോളിലെ മാറ്റം, ഡിഗ്രികളിൽ.
`pitch`	പിച്ചിലെ മാറ്റം, ഡിഗ്രികളിൽ.
`wait`	ഓപ്ഷണൽ. `wait=True` (ഡിഫോൾട്ട്) പ്രോജക്റ്റിനെ ചലനം പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കാൻ പ്രേരിപ്പിക്കുന്നു, തുടർന്ന് തുടരും. `wait=False` ചലനം ആരംഭിച്ച് ഉടൻ തന്നെ കോഡിന്റെ അടുത്ത വരിയിലേക്ക് പോകുന്നു.

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

മ്യൂട്ടേറ്ററുകൾ #

set_speed #

set_speed എന്നത് ചലന രീതികൾക്കായി 6-ആക്സിസ് ആം ഉപയോഗിക്കുന്ന ചലന വേഗത സജ്ജമാക്കുന്നു.

ഒരു പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ 6-ആക്സിസ് ആം വേഗത 50% ആയി സജ്ജീകരിച്ചിരിക്കുന്നു.

Usage:
arm1.set_speed(speed)

പാരാമീറ്റർ	വിവരണം
`speed`	6-ആക്സിസ് ആം ന്റെ ചലന വേഗത, `1` മുതൽ `100` ശതമാനം വരെ.

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

set_end_effector_type #

set_end_effector_type എന്നത് 6-ആക്സിസ് ആമിൽ ഘടിപ്പിച്ചിരിക്കുന്ന എൻഡ് ഇഫക്ടറിന്റെ തരം സജ്ജമാക്കുന്നു.

എൻഡ് ഇഫക്റ്റർ തരം മാറ്റുമ്പോൾ, തിരഞ്ഞെടുത്ത ടൂളുമായി പൊരുത്തപ്പെടുന്നതിന് 6-ആക്സിസ് ആം അതിന്റെ z-ഓഫ്‌സെറ്റ് യാന്ത്രികമായി ക്രമീകരിക്കുന്നു. ഒരു പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ എൻഡ് ഇഫക്റ്റർ തരം MAGNET ആയി സജ്ജീകരിച്ചിരിക്കുന്നു.

Usage:
arm1.set_end_effector_type(type)

പാരാമീറ്റർ	വിവരണം
`type`	6-ആക്സിസ് ആമിൽ ഘടിപ്പിച്ചിരിക്കുന്ന ഉപകരണം: `MAGNET` (മാഗ്നറ്റ് പിക്കപ്പ് ടൂൾ) അല്ലെങ്കിൽ `PEN` (പെൻ ഹോൾഡർ ടൂൾ).

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

set_end_effector_magnet #

set_end_effector_magnet മാഗ്നെറ്റ് പിക്കപ്പ് ടൂളിനെ ഇടപഴകുകയോ റിലീസ് ചെയ്യുകയോ ചെയ്യുന്നു.

മറ്റൊരു set_end_effector_magnet രീതി മാറ്റുന്നതുവരെ കാന്താവസ്ഥ സജീവമായി തുടരും. ഒരു പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ കാന്താവസ്ഥ False ആയി പുനഃസജ്ജമാക്കും.

Usage:
arm1.set_end_effector_magnet(state)

പാരാമീറ്റർ	വിവരണം
`state`	മാഗ്നറ്റ് പിക്കപ്പ് ടൂൾ ഇങ്ങനെ പറയുന്നു: വസ്തുക്കൾ എടുത്ത് പിടിക്കാൻ `True` അല്ലെങ്കിൽ പിടിച്ചിരിക്കുന്ന ഏതെങ്കിലും വസ്തുക്കൾ താഴെയിട്ട് പുതിയ വസ്തുക്കൾ എടുക്കുന്നത് നിർത്താൻ `False`.

പാരാമീറ്റർ

വിവരണം

state

മാഗ്നറ്റ് പിക്കപ്പ് ടൂൾ ഇങ്ങനെ പറയുന്നു: വസ്തുക്കൾ എടുത്ത് പിടിക്കാൻ True അല്ലെങ്കിൽ പിടിച്ചിരിക്കുന്ന ഏതെങ്കിലും വസ്തുക്കൾ താഴെയിട്ട് പുതിയ വസ്തുക്കൾ എടുക്കുന്നത് നിർത്താൻ False.

# 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 പെൻ ഹോൾഡർ ടൂൾ 6-ആക്സിസ് ആമിൽ ഘടിപ്പിക്കുമ്പോൾ ഉപയോഗിക്കുന്ന z-ആക്സിസ് ഓഫ്‌സെറ്റ് സജ്ജമാക്കുന്നു.

ഈ രീതി ഉപയോഗിക്കുന്നതിന് മുമ്പ് എൻഡ് ഇഫക്റ്റർ തരം PEN ആയി സജ്ജമാക്കുക. പെൻ ഹോൾഡർ ടൂൾ തിരഞ്ഞെടുത്തിട്ടില്ലെങ്കിൽ, ഈ രീതിക്ക് യാതൊരു ഫലവുമില്ല.

പെൻ ഹോൾഡർ ടൂളിന്റെ മുകളിൽ നിന്ന് ഡ്രൈ-ഇറേസ് മാർക്കറിന്റെ അഗ്രത്തിലേക്കുള്ള ദൂരമാണ് പെൻ ഓഫ്‌സെറ്റ്. ഒരു പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ, പെൻ ഓഫ്‌സെറ്റ് 0ആയി സജ്ജീകരിച്ചിരിക്കുന്നു. 0 ന്റെ ഒരു പെൻ ഓഫ്‌സെറ്റ്, പെൻ ഹോൾഡർ ടൂൾ 6-ആക്സിസ് ആമുമായി ബന്ധിപ്പിക്കുന്ന പോയിന്റിൽ ആംസിന്റെ z-ആക്സിസ് ഉത്ഭവം സ്ഥാപിക്കുന്നു.

Usage:
arm1.set_pen_offset(zOffset)

പാരാമീറ്റർ	വിവരണം
`zOffset`	പെൻ ഓഫ്‌സെറ്റ് മൂല്യം മില്ലിമീറ്ററിൽ.

# 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 6-ആക്സിസ് ആമിനുള്ള കൺട്രോൾ സ്റ്റോപ്പ് പ്രാപ്തമാക്കുന്നു.

കൺട്രോൾ സ്റ്റോപ്പ് പ്രവർത്തനക്ഷമമാക്കുമ്പോൾ, 6-ആക്സിസ് ആം ഉടനടി ഏതൊരു ചലനവും നിർത്തുന്നു, കൂടാതെ പ്രോജക്റ്റ് പുനരാരംഭിക്കുന്നത് വരെ മറ്റ് ആം മൂവ്മെന്റ് രീതികളൊന്നും പ്രവർത്തിപ്പിക്കില്ല.

Usage:
arm1.set_control_stop(state)

പാരാമീറ്റർ	വിവരണം
`state`	ഓപ്ഷണൽ. `True` (സ്ഥിരസ്ഥിതി) നിയന്ത്രണ സ്റ്റോപ്പ് പ്രാപ്തമാക്കുന്നു. `False` നിയന്ത്രണ സ്റ്റോപ്പ് പ്രാപ്തമാക്കുന്നില്ല.

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

set_timeout #

set_timeout 6-ആക്സിസ് ആം നീക്കുമ്പോൾ ഉപയോഗിക്കുന്ന ടൈംഔട്ട് മൂല്യം സജ്ജമാക്കുന്നു.

സമയപരിധി എത്തുന്നതിനുമുമ്പ് ഒരു ചലനം പൂർത്തിയായില്ലെങ്കിൽ, പ്രോജക്റ്റ് അടുത്ത കോഡ് വരിയിലേക്ക് തുടരും.

Usage:
arm1.set_timeout(timeout, units)

പാരാമീറ്റർ	വിവരണം
`timeout`	പുതിയ ടൈംഔട്ട് മൂല്യം.
`units`	ഓപ്ഷണൽ. സമയ യൂണിറ്റ്: `MSEC` (മില്ലിസെക്കൻഡ്, ഡിഫോൾട്ട്), `SECONDS`, അല്ലെങ്കിൽ `SEC`.

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

ഗെറ്ററുകൾ #

is_done #

is_done എന്നത് 6-ആക്സിസ് ആം ചലനം അവസാനിച്ചോ എന്ന് നൽകുന്നു.

wait=False ഉപയോഗിച്ച് ഒരു മൂവ്മെന്റ് മെത്തേഡ് വിളിച്ചതിന് ശേഷം ഈ രീതി ഉപയോഗപ്രദമാണ്.

True — 6-ആക്സിസ് ഭുജം നീങ്ങുന്നത് അവസാനിച്ചു.
False — 6-ആക്സിസ് ഭുജം ഇപ്പോഴും ചലിച്ചുകൊണ്ടിരിക്കുന്നു.

Usage:
arm1.is_done()

പാരാമീറ്ററുകൾ	വിവരണം
	ഈ രീതിക്ക് പാരാമീറ്ററുകൾ ഇല്ല.

# 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 ചലിക്കുമ്പോൾ 6-Axis Arm തകർന്നോ എന്ന് നൽകുന്നു.

ഒരു ക്രാഷ് കണ്ടെത്തുമ്പോൾ, 6-ആക്സിസ് ആം മോട്ടോർ ചലനം നിർത്തുകയും അത് തളരുന്നതായി തോന്നുകയും ചെയ്യും. ഇത് ആയാസം കുറയ്ക്കുകയും മോട്ടോറുകളെ ആകസ്മികമായ കേടുപാടുകളിൽ നിന്ന് സംരക്ഷിക്കാൻ സഹായിക്കുകയും ചെയ്യുന്നു.

True — 6-ആക്സിസ് ആം തകർന്നു.
False — 6-ആക്സിസ് ആം തകർന്നിട്ടില്ല.

Usage:
arm1.is_crashed()

പാരാമീറ്ററുകൾ	വിവരണം
	ഈ രീതിക്ക് പാരാമീറ്ററുകൾ ഇല്ല.

# 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 എൻഡ് ഇഫക്റ്ററിന്റെ നിലവിലെ x സ്ഥാനം മില്ലിമീറ്ററിൽ നൽകുന്നു.

x-അക്ഷത്തിൽ എൻഡ് ഇഫക്റ്റർ നിലവിൽ എവിടെയാണെന്ന് വായിക്കാൻ ഈ രീതി ഉപയോഗിക്കുക.

Usage:
arm1.get_x()

പാരാമീറ്ററുകൾ	വിവരണം
	ഈ രീതിക്ക് പാരാമീറ്ററുകൾ ഇല്ല.

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

get_y #

get_y എൻഡ് ഇഫക്റ്ററിന്റെ നിലവിലെ y സ്ഥാനം മില്ലിമീറ്ററിൽ നൽകുന്നു.

y-അക്ഷത്തിൽ എൻഡ് ഇഫക്റ്റർ നിലവിൽ എവിടെയാണെന്ന് വായിക്കാൻ ഈ രീതി ഉപയോഗിക്കുക.

Usage:
arm1.get_y()

പാരാമീറ്ററുകൾ	വിവരണം
	ഈ രീതിക്ക് പാരാമീറ്ററുകൾ ഇല്ല.

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

get_z #

get_z എൻഡ് ഇഫക്റ്ററിന്റെ നിലവിലെ z സ്ഥാനം മില്ലിമീറ്ററിൽ നൽകുന്നു.

z-അക്ഷത്തിൽ എൻഡ് ഇഫക്റ്റർ നിലവിൽ എവിടെയാണെന്ന് വായിക്കാൻ ഈ രീതി ഉപയോഗിക്കുക.

Usage:
arm1.get_z()

പാരാമീറ്ററുകൾ	വിവരണം
	ഈ രീതിക്ക് പാരാമീറ്ററുകൾ ഇല്ല.

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

get_pitch #

get_pitch എൻഡ് ഇഫക്റ്ററിന്റെ നിലവിലെ പിച്ച് ഡിഗ്രികളിൽ നൽകുന്നു.

Usage:
arm1.get_pitch()

പാരാമീറ്ററുകൾ	വിവരണം
	ഈ രീതിക്ക് പാരാമീറ്ററുകൾ ഇല്ല.

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

get_roll #

get_roll എൻഡ് ഇഫക്റ്ററിന്റെ നിലവിലെ റോൾ ഡിഗ്രികളിൽ നൽകുന്നു.

Usage:
arm1.get_roll()

പാരാമീറ്ററുകൾ	വിവരണം
	ഈ രീതിക്ക് പാരാമീറ്ററുകൾ ഇല്ല.

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

get_yaw #

get_yaw എൻഡ് ഇഫക്റ്ററിന്റെ നിലവിലെ യാവിനെ ഡിഗ്രികളിൽ തിരികെ നൽകുന്നു.

Usage:
arm1.get_yaw()

പാരാമീറ്ററുകൾ	വിവരണം
	ഈ രീതിക്ക് പാരാമീറ്ററുകൾ ഇല്ല.

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

can_arm_reach_to #

can_arm_reach_to എന്നത് 6-Axis Arm ന് എൻഡ് ഇഫക്റ്ററിനെ ഒരു നിർദ്ദിഷ്ട x, y, z കോർഡിനേറ്റിലേക്ക് നീക്കാൻ കഴിയുമോ എന്ന് നൽകുന്നു.

move_to ഉപയോഗിക്കുന്നതിന് മുമ്പ് ഒരു ലക്ഷ്യ സ്ഥാനം പരിശോധിക്കാൻ ഈ രീതി ഉപയോഗിക്കുക.

True — 6-ആക്സിസ് ആം അഭ്യർത്ഥിച്ച സ്ഥാനത്ത് എത്താൻ കഴിയും.
False — 6-ആക്സിസ് ആം അഭ്യർത്ഥിച്ച സ്ഥാനത്ത് എത്താൻ കഴിയില്ല.

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

പാരാമീറ്റർ	വിവരണം
`x`	ലക്ഷ്യ സ്ഥാനത്തിന്റെ x-കോർഡിനേറ്റ് മില്ലിമീറ്ററിൽ.
`y`	ലക്ഷ്യ സ്ഥാനത്തിന്റെ y-കോർഡിനേറ്റ് മില്ലിമീറ്ററിൽ.
`z`	ലക്ഷ്യ സ്ഥാനത്തിന്റെ z-കോർഡിനേറ്റ് മില്ലിമീറ്ററിൽ.

# 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 6-ആക്സിസ് ആം എൻഡ് ഇഫക്റ്ററിനെ അതിന്റെ നിലവിലെ സ്ഥാനത്ത് നിന്ന് ഒരു നിശ്ചിത x, y, z ദൂരം നീക്കാൻ കഴിയുമോ എന്ന് നൽകുന്നു.

move_inc ഉപയോഗിക്കുന്നതിന് മുമ്പ് ഒരു ആപേക്ഷിക ചലനം പരിശോധിക്കാൻ ഈ രീതി ഉപയോഗിക്കുക.

True — 6-ആക്സിസ് ഭുജത്തിന് അഭ്യർത്ഥിച്ച ചലനം നടത്താൻ കഴിയും.
False — 6-ആക്സിസ് ഭുജത്തിന് അഭ്യർത്ഥിച്ച ചലനം നടത്താൻ കഴിയില്ല.

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

പാരാമീറ്റർ	വിവരണം
`x`	x-അക്ഷത്തിലൂടെ സഞ്ചരിക്കേണ്ട ദൂരം മില്ലിമീറ്ററിൽ.
`y`	y-അക്ഷത്തിലൂടെ സഞ്ചരിക്കേണ്ട ദൂരം മില്ലിമീറ്ററിൽ.
`z`	z-അക്ഷത്തിലൂടെ സഞ്ചരിക്കേണ്ട ദൂരം മില്ലിമീറ്ററിൽ.

# 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 എന്നത് എൻഡ് ഇഫക്റ്ററിന് ഒരു നിർദ്ദിഷ്ട യാവ്, റോൾ, പിച്ച് ഓറിയന്റേഷനിലേക്ക് തിരിക്കാൻ കഴിയുമോ എന്ന് നൽകുന്നു.

move_end_effector_to ഉപയോഗിക്കുന്നതിന് മുമ്പ് ഒരു ലക്ഷ്യ ഓറിയന്റേഷൻ പരിശോധിക്കാൻ ഈ രീതി ഉപയോഗിക്കുക.

True — എൻഡ് ഇഫക്റ്ററിന് അഭ്യർത്ഥിച്ച ഓറിയന്റേഷനിൽ എത്താൻ കഴിയും.
False — എൻഡ് ഇഫക്റ്ററിന് അഭ്യർത്ഥിച്ച ഓറിയന്റേഷനിൽ എത്താൻ കഴിയില്ല.

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

പാരാമീറ്റർ	വിവരണം
`yaw`	ലക്ഷ്യ സ്ഥാനചലന ആംഗിൾ, ഡിഗ്രികളിൽ.
`roll`	ലക്ഷ്യ റോൾ ആംഗിൾ, ഡിഗ്രികളിൽ.
`pitch`	ലക്ഷ്യ പിച്ച് ആംഗിൾ, ഡിഗ്രികളിൽ.

# 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 എൻഡ് ഇഫക്റ്ററിന് അതിന്റെ നിലവിലെ ഓറിയന്റേഷനിൽ നിന്ന് ഒരു നിശ്ചിത യാവ്, റോൾ, പിച്ച് തുക ഉപയോഗിച്ച് തിരിക്കാൻ കഴിയുമോ എന്ന് നൽകുന്നു.

move_end_effector_inc ഉപയോഗിക്കുന്നതിന് മുമ്പ് ഒരു ആപേക്ഷിക ഓറിയന്റേഷൻ ചലനം പരിശോധിക്കാൻ ഈ രീതി ഉപയോഗിക്കുക.

True — എൻഡ് ഇഫക്റ്ററിന് അഭ്യർത്ഥിച്ച റൊട്ടേഷൻ നടത്താൻ കഴിയും.
False — എൻഡ് ഇഫക്റ്ററിന് അഭ്യർത്ഥിച്ച റൊട്ടേഷൻ നടത്താൻ കഴിയില്ല.

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

പാരാമീറ്റർ	വിവരണം
`yaw`	യാവിലെ മാറ്റം, ഡിഗ്രികളിൽ.
`roll`	റോളിലെ മാറ്റം, ഡിഗ്രികളിൽ.
`pitch`	പിച്ചിലെ മാറ്റം, ഡിഗ്രികളിൽ.

# 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 6-Axis Arm movement രീതികൾ ഉപയോഗിക്കുന്ന ടൈംഔട്ട് മൂല്യം മില്ലിസെക്കൻഡുകളിൽ നൽകുന്നു.

Usage:
arm1.get_timeout()

പാരാമീറ്ററുകൾ	വിവരണം
	ഈ രീതിക്ക് പാരാമീറ്ററുകൾ ഇല്ല.

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

is_connected #

is_connected എന്നത് 6-Axis Arm EXP Brain-മായി ബന്ധിപ്പിച്ചിട്ടുണ്ടോ എന്ന് നൽകുന്നു.

True — 6-ആക്സിസ് ആം EXP തലച്ചോറുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു.
False — 6-ആക്സിസ് ആം EXP തലച്ചോറുമായി ബന്ധിപ്പിച്ചിട്ടില്ല.

Usage:
arm1.is_connected()

പാരാമീറ്ററുകൾ	വിവരണം
	ഈ രീതിക്ക് പാരാമീറ്ററുകൾ ഇല്ല.

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

കോൾബാക്കുകൾ #

control_stopped #

control_stopped രജിസ്റ്റർ ചെയ്യുന്നു.

ഈ രീതി Event ക്ലാസ്സിന്റെ ഒരു ഉദാഹരണം നൽകുന്നു.

Usage:
arm1.control_stopped(callback, arg)

പാരാമീറ്റർ	വിവരണം
`callback`	കൺട്രോൾ സ്റ്റോപ്പ് പ്രവർത്തനക്ഷമമാക്കുമ്പോൾ പ്രവർത്തിക്കുന്ന, മുമ്പ് നിർവചിച്ച ഒരു ഫംഗ്ഷൻ.
`arg`	ഓപ്ഷണൽ. കോൾബാക്ക് ഫംഗ്ഷനിലേക്ക് കൈമാറുന്നതിനുള്ള ആർഗ്യുമെന്റുകൾ അടങ്ങിയ ഒരു ട്യൂപ്പിൾ. കൂടുതൽ വിവരങ്ങൾക്ക് പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നു കാണുക.

പാരാമീറ്റർ

വിവരണം

callback

കൺട്രോൾ സ്റ്റോപ്പ് പ്രവർത്തനക്ഷമമാക്കുമ്പോൾ പ്രവർത്തിക്കുന്ന, മുമ്പ് നിർവചിച്ച ഒരു ഫംഗ്ഷൻ.

arg

ഓപ്ഷണൽ. കോൾബാക്ക് ഫംഗ്ഷനിലേക്ക് കൈമാറുന്നതിനുള്ള ആർഗ്യുമെന്റുകൾ അടങ്ങിയ ഒരു ട്യൂപ്പിൾ. കൂടുതൽ വിവരങ്ങൾക്ക് പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നു കാണുക.

# 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 ചലിക്കുമ്പോൾ 6-ആക്സിസ് ആം ക്രാഷ് ആകുമ്പോൾ പ്രവർത്തിക്കുന്ന ഒരു ഫംഗ്ഷൻ രജിസ്റ്റർ ചെയ്യുന്നു.

Usage:
arm1.crashed(callback)

പാരാമീറ്റർ	വിവരണം
`callback`	ഒരു ക്രാഷ് കണ്ടെത്തുമ്പോൾ പ്രവർത്തിക്കുന്ന, മുമ്പ് നിർവചിച്ച ഒരു ഫംഗ്ഷൻ.

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

കൺസ്ട്രക്‌ടർമാർ #

Arm #

Arm ഒരു 6-Axis Arm object സൃഷ്ടിക്കുന്നു.

Usage:
Arm(smartport)

പാരാമീറ്റർ	വിവരണം
`smartport`	6-ആക്സിസ് ആം ബന്ധിപ്പിച്ചിരിക്കുന്ന സ്മാർട്ട് പോർട്ട്, `Ports.PORTx`എന്ന് എഴുതിയിരിക്കുന്നു, ഇവിടെ `x` എന്നത് പോർട്ട് നമ്പറാണ്.

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