ചലനം

ആമുഖം

ഒരു റോബോട്ടിന്റെ ഭാഗങ്ങൾ എങ്ങനെ നീങ്ങുന്നുവെന്ന് മോട്ടോറുകൾ നിയന്ത്രിക്കുന്നു. ഒരു കൈ ഉയർത്താനോ, ഒരു നഖം തിരിക്കാനോ, ഒരു ചക്രം കറക്കാനോ, അല്ലെങ്കിൽ ഒരു ബിൽഡിന്റെ മറ്റൊരു ഭാഗം ചലിപ്പിക്കാനോ മോട്ടോറുകൾ ഉപയോഗിക്കാം. മുഴുവൻ റോബോട്ടിനെയും ചലിപ്പിക്കാനും തിരിക്കാനും രണ്ട് മോട്ടോറുകൾ ഒരുമിച്ച് ഒരു ഡ്രൈവ്‌ട്രെയിൻ ആയി പ്രവർത്തിക്കും.

ഓരോ മോട്ടോറും ഡിവൈസസ് വിൻഡോയിൽ കോൺഫിഗർ ചെയ്‌തിരിക്കുന്നു. ബിൽഡിനെ ആശ്രയിച്ച്, മോട്ടോർ പേരുകൾ മാറാം. ഉദാഹരണത്തിന്, കോംപറ്റീഷൻ അഡ്വാൻസ്ഡ് 2.0 ബിൽഡിൽ arm_motorഎന്ന് പേരുള്ള ഒരു മോട്ടോർ ഉണ്ട്. ഒരു കസ്റ്റം റോബോട്ട് വ്യത്യസ്ത മോട്ടോർ പേരുകൾ ഉപയോഗിച്ചേക്കാം.

സ്ഥിരസ്ഥിതിയായി, FORWARD ഒരു മോട്ടോർ എതിർ ഘടികാരദിശയിൽ കറക്കുന്നു, REVERSE ഒരു മോട്ടോർ ഘടികാരദിശയിൽ കറക്കുന്നു. ഉപകരണ വിൻഡോയിൽ ഒരു മോട്ടോർ റിവേഴ്‌സ് ചെയ്യാൻ സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ആ ദിശകൾ മാറും.

മോട്ടോറുകൾ കോഡ് ചെയ്യാൻ നിരവധി മാർഗങ്ങളുണ്ട്. എല്ലാ ചലന രീതികളുടെയും ഒരു ലിസ്റ്റ് താഴെ കൊടുക്കുന്നു:

പ്രവർത്തനങ്ങൾ — മോട്ടോറുകൾ നിർത്തി കറക്കുക.

• spin — ഒരു മോട്ടോർ മുന്നോട്ട് കറക്കുകയോ എന്നെന്നേക്കുമായി പിന്നോട്ട് കറക്കുകയോ ചെയ്യുന്നു.

• spin_for — ഒരു പ്രത്യേക ദൂരത്തേക്ക് ഒരു മോട്ടോർ കറക്കുന്നു.

• spin_to_position — ഒരു മോട്ടോർ ഒരു പ്രത്യേക സ്ഥാനത്തേക്ക് കറക്കുന്നു.

• stop — ഒരു മോട്ടോർ കറങ്ങുന്നത് തടയുന്നു.

മ്യൂട്ടേറ്ററുകൾ — മോട്ടോർ ക്രമീകരണങ്ങൾ ക്രമീകരിക്കുക.

• set_velocity — ഒരു മോട്ടോർ എത്ര വേഗത്തിൽ കറങ്ങണമെന്ന് പറയുന്നു.

• set_max_torque — കറങ്ങുമ്പോൾ ഒരു മോട്ടോർ എത്രത്തോളം ശക്തമായി തള്ളാൻ അനുവദിക്കണമെന്ന് സജ്ജമാക്കുന്നു.

• set_position — മോട്ടോറിന്റെ നിലവിലെ സ്ഥാനം ഒരു പുതിയ മൂല്യത്തിലേക്ക് മാറ്റുന്നു.

• set_stopping — ഒരു മോട്ടോർ എങ്ങനെ ചലനം നിർത്തുമെന്ന് സജ്ജമാക്കുന്നു: ബ്രേക്കിംഗ്, കോസ്റ്റിംഗ് അല്ലെങ്കിൽ ഹോൾഡിംഗ് വഴി.

• set_timeout — ഒരു മോട്ടോർ ഒരു ചലനം പൂർത്തിയാക്കാൻ എത്ര സമയം ശ്രമിക്കുമെന്ന് സജ്ജമാക്കുന്നു.

ഗെറ്ററുകൾ — മോട്ടോർ സ്റ്റാറ്റസ് പരിശോധിക്കുക.

• get_position — മോട്ടോറിന്റെ നിലവിലെ സ്ഥാനം നൽകുന്നു.

• get_velocity — മോട്ടോർ എത്ര വേഗത്തിൽ കറങ്ങുന്നുവെന്ന് -100% മുതൽ 100% വരെയുള്ള ശതമാനമായി നൽകുന്നു.

• get_current — ബാറ്ററിയിൽ നിന്ന് മോട്ടോർ എത്ര പവർ ഉപയോഗിക്കുന്നുവെന്ന് 0% മുതൽ 100% വരെയുള്ള ശതമാനമായി നൽകുന്നു.

• is_stopped — മോട്ടോർ നീങ്ങുന്നത് പൂർത്തിയായോ എന്ന് ഒരു ബൂളിയൻ മൂല്യമായി നൽകുന്നു.

• is_moving — മോട്ടോർ കറങ്ങുന്നുണ്ടോ എന്ന് ഒരു ബൂളിയൻ മൂല്യമായി നൽകുന്നു.

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

spin

spin ഒരു മോട്ടോർ എന്നെന്നേക്കുമായി മുന്നോട്ടോ പിന്നോട്ടോ കറക്കുന്നു. മറ്റൊരു ദിശയിലേക്ക് കറങ്ങുകയോ നിർത്തുകയോ പോലുള്ള മറ്റൊരു പ്രവർത്തനം നൽകുന്നതുവരെ മോട്ടോർ കറങ്ങിക്കൊണ്ടിരിക്കും.

Usage:
arm_motor.spin(direction)

പാരാമീറ്ററുകൾ	വിവരണം
direction	മോട്ടോർ കറങ്ങുന്ന ദിശ: FORWARD അല്ലെങ്കിൽ REVERSE.

# Build Used: Competition Advanced 2.0
def main():
    # Raise the ArmMotor, then stop
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

spin_for

spin_for ഒരു മോട്ടോർ ഒരു നിശ്ചിത ദൂരത്തേക്ക് കറക്കുന്നു. മോട്ടോറിന്റെ നിലവിലെ സ്ഥാനവുമായി ആപേക്ഷികമായാണ് സ്പിൻ. കോഡിന്റെ അടുത്ത വരി പ്രവർത്തിക്കുന്നതിന് മുമ്പ് മോട്ടോർ കറങ്ങുന്നത് വരെ പ്രോജക്റ്റ് കാത്തിരിക്കും.

Usage:
arm_motor.spin_for(direction, angle, units, wait)

പാരാമീറ്ററുകൾ	വിവരണം
direction	മോട്ടോർ കറങ്ങുന്ന ദിശ: FORWARD അല്ലെങ്കിൽ REVERSE.
angle	മോട്ടോർ കറങ്ങുന്ന ദൂരം. DEGREES പൂർണ്ണസംഖ്യകൾ ഉപയോഗിക്കുന്നു. TURNS പൂർണ്ണസംഖ്യകളോ ദശാംശങ്ങളോ ഉപയോഗിക്കാം.
units	ഓപ്ഷണൽ. ദൂര യൂണിറ്റ്: DEGREES (സ്ഥിരസ്ഥിതി) അല്ലെങ്കിൽ TURNS.
wait	ഓപ്ഷണൽ. wait=True (ഡിഫോൾട്ട്) കോഡിന്റെ അടുത്ത വരി പ്രവർത്തിക്കുന്നതിന് മുമ്പ് മോട്ടോർ കറങ്ങുന്നത് വരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ അനുവദിക്കുന്നു. wait=False കോഡിന്റെ അടുത്ത വരി ഉടനടി പ്രവർത്തിപ്പിക്കുന്നു.

# Build Used: Competition Advanced 2.0
def main():
    # Raise and lower the ArmMotor
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    arm_motor.spin_for(FORWARD, 180, DEGREES)

# Start threads — Do not delete
start_thread(main)

spin_to_position

spin_to_position ഒരു മോട്ടോർ ഒരു പ്രത്യേക സ്ഥാനത്തേക്ക് തിരിക്കുന്നു.

ഒരു മോട്ടോറിന്റെ സ്ഥാനം അത് എത്ര ദൂരം കറങ്ങി എന്നതിനെയാണ് സൂചിപ്പിക്കുന്നത്, ഇത് DEGREES അല്ലെങ്കിൽ TURNSൽ അളക്കുന്നു. ഒരു ടേൺ 360 ഡിഗ്രിക്ക് തുല്യമാണ്. ഒരു പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ, മോട്ടോർ സ്ഥാനം 0 ഡിഗ്രിയായി സജ്ജീകരിച്ചിരിക്കുന്നു. set_position രീതി ഉപയോഗിച്ചും മോട്ടോർ സ്ഥാനം സജ്ജമാക്കാൻ കഴിയും.

സ്ഥാന മൂല്യങ്ങൾ കേവലമാണ്. ഇതിനർത്ഥം സ്പിന്നിന്റെ ദിശ മോട്ടോറിന്റെ നിലവിലെ സ്ഥാനത്തെ ആശ്രയിച്ചിരിക്കുന്നു എന്നാണ്.

ഉദാഹരണത്തിന്, മോട്ടോർ 0 ഡിഗ്രിയിൽ ആരംഭിച്ച് 720 ഡിഗ്രി സ്ഥാനത്തേക്ക് കറങ്ങുകയാണെങ്കിൽ, അത് രണ്ട് തിരിവുകൾ മുന്നോട്ട് കറങ്ങും. പിന്നീട് 360 ഡിഗ്രി സ്ഥാനത്തേക്ക് കറങ്ങുകയാണെങ്കിൽ, അത് ഒരു തിരിവ് പിന്നിലേക്ക് കറങ്ങും, കാരണം 360 720 നേക്കാൾ കുറവാണ്.

Usage:
arm_motor.spin_to_position(angle, units, wait)

പാരാമീറ്ററുകൾ	വിവരണം
angle	മോട്ടോർ കറങ്ങുന്ന സ്ഥാന മൂല്യം. DEGREES പൂർണ്ണസംഖ്യകൾ ഉപയോഗിക്കുന്നു. TURNS പൂർണ്ണസംഖ്യകളോ ദശാംശങ്ങളോ ഉപയോഗിക്കാം.
units	ഓപ്ഷണൽ. സ്ഥാന യൂണിറ്റ്: DEGREES (സ്ഥിരസ്ഥിതി) അല്ലെങ്കിൽ TURNS.
wait	ഓപ്ഷണൽ. wait=True (ഡിഫോൾട്ട്) കോഡിന്റെ അടുത്ത വരി പ്രവർത്തിക്കുന്നതിന് മുമ്പ് മോട്ടോർ കറങ്ങുന്നത് വരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ അനുവദിക്കുന്നു. wait=False കോഡിന്റെ അടുത്ത വരി ഉടനടി പ്രവർത്തിപ്പിക്കുന്നു.

# Build Used: Competition Advanced 2.0
def main():
    # Return ArmMotor to 0 degrees after raising
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    arm_motor.spin_to_position(0, DEGREES)

# Start threads — Do not delete
start_thread(main)

stop

stop ഒരു മോട്ടോർ കറങ്ങുന്നത് നിർത്തുന്നു.

Usage:
arm_motor.stop()

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

# Build Used: Competition Advanced 2.0
def main():
    # Raise the ArmMotor
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

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

set_velocity

set_velocity ഒരു മോട്ടോർ എത്ര വേഗത്തിൽ കറങ്ങണമെന്ന് പറയുന്നു. ഉയർന്ന ശതമാനം മോട്ടോർ കറങ്ങുന്നത് വേഗത്തിലാക്കുന്നു, കുറഞ്ഞ ശതമാനം മോട്ടോർ കറങ്ങുന്നത് മന്ദഗതിയിലാക്കുന്നു.

ഓരോ പ്രോജക്റ്റും ആരംഭിക്കുന്നത് ഓരോ മോട്ടോറും സ്ഥിരസ്ഥിതിയായി 50% വേഗതയിൽ കറങ്ങുന്ന രീതിയിലാണ്.

കുറിപ്പ്: ഉയർന്ന വേഗത മോട്ടോർ കറക്കത്തെ വേഗത്തിലാക്കുന്നു, പക്ഷേ കൃത്യത കുറവായിരിക്കാം. കുറഞ്ഞ വേഗത മോട്ടോർ കറക്കത്തെ മന്ദഗതിയിലാക്കുന്നു, പക്ഷേ കൂടുതൽ കൃത്യതയുള്ളതാകാം.

Usage:
arm_motor.set_velocity(velocity)

പാരാമീറ്ററുകൾ	വിവരണം
velocity	കറങ്ങാനുള്ള വേഗത 0% മുതൽ 100% വരെ. ഇത് ഒരു integer അല്ലെങ്കിൽ ദശാംശം ആകാം (float).

# Build Used: Competition Advanced 2.0
def main():
    # Move the ArmMotor at different velocities
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    # Move slow
    arm_motor.set_velocity(20)
    arm_motor.spin_for(FORWARD, 180, DEGREES)
    wait(1, SECONDS)
    # Move fast
    arm_motor.set_velocity(100)
    arm_motor.spin_for(REVERSE, 180, DEGREES)

# Start threads — Do not delete
start_thread(main)

set_max_torque

ടോർക്ക് ഒരു ടേണിംഗ് ഫോഴ്‌സാണ്. ഒരു മോട്ടോർ കറങ്ങുമ്പോൾ എത്രത്തോളം ശക്തമായി തള്ളാനോ വലിക്കാനോ കഴിയുമെന്ന് ഇത് കാണിക്കുന്നു.

set_max_torque ഒരു മോട്ടോർ ഉപയോഗിക്കാൻ അനുവദനീയമായ ഏറ്റവും ഉയർന്ന ടോർക്ക് സജ്ജമാക്കുന്നു.

ഉയർന്ന ശതമാനം മോട്ടോർ കൂടുതൽ ശക്തമായി തള്ളാൻ അനുവദിക്കുന്നു, ഉദാഹരണത്തിന് ഭാരമേറിയ ഒരു വസ്തു ഉയർത്തുമ്പോൾ. കുറഞ്ഞ ശതമാനം മോട്ടോർ എത്രത്തോളം ശക്തമായി തള്ളുമെന്ന് പരിമിതപ്പെടുത്തുന്നു. മോട്ടോർ കുടുങ്ങിപ്പോകുകയോ എത്ര ദൂരം നീങ്ങാൻ കഴിയുമെന്നതിന്റെ അവസാനം എത്തുകയോ ചെയ്താൽ റോബോട്ടിനെ സംരക്ഷിക്കാൻ ഇത് സഹായിക്കും.

ഓരോ പ്രോജക്ടും ആരംഭിക്കുന്നത് ഓരോ മോട്ടോറിന്റെയും ടോർക്ക് സ്ഥിരസ്ഥിതിയായി 50% ൽ നിന്നുകൊണ്ടാണ്.

Usage:
arm_motor.set_max_torque(value)

പാരാമീറ്ററുകൾ	വിവരണം
value	മോട്ടോറിന് ഉപയോഗിക്കാൻ കഴിയുന്ന പരമാവധി ടോർക്ക് 0% മുതൽ 100% വരെയാകാം. ഇത് integer അല്ലെങ്കിൽ ദശാംശം (float ) ആകാം.

# Build Used: Competition Advanced 2.0
def main():
    # Move the ArmMotor at different torques
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    # Move with less torque
    arm_motor.set_max_torque(20)
    arm_motor.spin_for(FORWARD, 180, DEGREES)
    wait(1, SECONDS)
    # Move with maximum torque
    arm_motor.set_max_torque(100)
    arm_motor.spin_for(REVERSE, 180, DEGREES)

# Start threads — Do not delete
start_thread(main)

set_position

ഒരു മോട്ടോറിന്റെ സ്ഥാനം അത് എത്ര ദൂരം കറങ്ങി എന്നതിനെയാണ് സൂചിപ്പിക്കുന്നത്, ഇത് DEGREES അല്ലെങ്കിൽ TURNSഒരു ടേൺ 360 ഡിഗ്രിക്ക് തുല്യമാണ്. set_position മോട്ടോറിന്റെ നിലവിലെ സ്ഥാനം ഒരു പുതിയ മൂല്യത്തിലേക്ക് മാറ്റുന്നു.

ഉദാഹരണത്തിന്, ഒരു മോട്ടോർ 180 ഡിഗ്രിയിലേക്ക് കറങ്ങിയിട്ടുണ്ടെങ്കിൽ, സ്ഥാനം 0 ഡിഗ്രിയിലേക്ക് സജ്ജമാക്കുന്നത് ആ സ്ഥാനം 180 ൽ നിന്ന് 0 ഡിഗ്രിയിലേക്ക് പുനഃസജ്ജമാക്കും. തുടർന്ന് ആ പുതിയ മൂല്യത്തെ അടിസ്ഥാനമാക്കി മോട്ടോറിന് സ്ഥാനങ്ങളിലേക്ക് കറങ്ങാൻ കഴിയും.

Usage:
arm_motor.set_position(position, units)

പാരാമീറ്ററുകൾ	വിവരണം
position	മോട്ടോറിനായി സജ്ജമാക്കേണ്ട സ്ഥാന മൂല്യം. DEGREES പൂർണ്ണസംഖ്യകൾ ഉപയോഗിക്കുന്നു. TURNS പൂർണ്ണസംഖ്യകളോ ദശാംശങ്ങളോ ഉപയോഗിക്കാം.
units	ഓപ്ഷണൽ. സ്ഥാന യൂണിറ്റ്: DEGREES (സ്ഥിരസ്ഥിതി) അല്ലെങ്കിൽ TURNS.

# Build Used: Competition Advanced 2.0
def main():
    # Return ArmMotor to 0 degrees after raising
    arm_motor.set_position(0, DEGREES)
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    arm_motor.spin_to_position(0, DEGREES)

# Start threads — Do not delete
start_thread(main)

set_stopping

set_stopping ഒരു മോട്ടോർ എങ്ങനെ ചലനം നിർത്തുമെന്ന് സജ്ജമാക്കുന്നു: ബ്രേക്കിംഗ്, കോസ്റ്റിംഗ് അല്ലെങ്കിൽ ഹോൾഡിംഗ് വഴി.

Usage:
arm_motor.set_stopping(mode)

പാരാമീറ്ററുകൾ	വിവരണം
mode	മോട്ടോർ എങ്ങനെ നിർത്തും: BRAKE — ഉടനടി നിർത്തുന്നു. COAST — പതുക്കെ നിർത്തുന്നു. HOLD — ഉടനടി നിർത്തി മോട്ടോറിന്റെ സ്ഥാനം നിലനിർത്തുന്നു.

ഉദാഹരണത്തിന്, ഒരു കോംപറ്റീഷൻ അഡ്വാൻസ്ഡ് 2.0 ബിൽഡ് ഉപയോഗിക്കുകയും arm_motor HOLDആയി സജ്ജമാക്കുകയും ചെയ്താൽ, മറ്റൊരു കൈ ചലനം സംഭവിക്കുന്നത് വരെ മോട്ടോർ കൈയെ അതിന്റെ നിലവിലെ സ്ഥാനത്ത് നിലനിർത്തും. അതായത്, കൈ ഉയർത്തി മോട്ടോർ നിർത്തിയാൽ കൈ വായുവിൽ നിലനിർത്താൻ മോട്ടോർ ഗുരുത്വാകർഷണത്തിനെതിരെ പ്രവർത്തിക്കും.

ഈ രീതി ഉപയോഗിക്കുന്നില്ലെങ്കിൽ, മോട്ടോർ നിർത്തുമ്പോൾ BRAKE ഉപയോഗിക്കും.

# Build Used: Competition Advanced 2.0
def main():
    # Move the ArmMotor, then coast to a stop
    arm_motor.set_velocity(20)
    arm_motor.set_stopping(COAST)
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

set_timeout

set_timeout ഒരു മോട്ടോർ ഒരു ചലനം പൂർത്തിയാക്കാൻ എത്ര സമയം ശ്രമിക്കുമെന്ന് സജ്ജമാക്കുന്നു. ആ സമയത്തിനുള്ളിൽ മോട്ടോർ പൂർത്തിയാക്കാൻ കഴിയുന്നില്ലെങ്കിൽ, അത് ശ്രമം നിർത്തി അടുത്ത കോഡ് വരിയിലേക്ക് നീങ്ങും. ഇത് മോട്ടോർ ഒരു ചലനത്തിൽ കുടുങ്ങിപ്പോകുന്നത് തടയുന്നു.

Usage:
arm_motor.set_timeout(value, units)

പാരാമീറ്ററുകൾ	വിവരണം
value	ഒരു ചലനം പൂർത്തിയാക്കാൻ മോട്ടോറിന് എത്ര സമയം ശ്രമിക്കാൻ കഴിയും. ഇത് ഒരു പോസിറ്റീവ് integer അല്ലെങ്കിൽ ദശാംശം ആകാം (float).
units	ഓപ്ഷണൽ. സമയത്തിന്റെ യൂണിറ്റ്: SECONDS (സ്ഥിരസ്ഥിതി) അല്ലെങ്കിൽ MSEC (മില്ലിസെക്കൻഡ്).

# Build Used: Competition Advanced 2.0
def main():
    # Move ArmMotor as far as possible for 1 second before resetting
    arm_motor.set_position(0, DEGREES)
    arm_motor.set_timeout(1, SECONDS)
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    arm_motor.spin_to_position(0, DEGREES)

# Start threads — Do not delete
start_thread(main)

ഗെറ്ററുകൾ

get_position

ഒരു മോട്ടോറിന്റെ സ്ഥാനം അത് എത്ര ദൂരം കറങ്ങി എന്നതിനെയാണ് സൂചിപ്പിക്കുന്നത്, ഇത് DEGREES അല്ലെങ്കിൽ TURNSഒരു ടേൺ 360 ഡിഗ്രിക്ക് തുല്യമാണ്. get_position മോട്ടോറിന്റെ നിലവിലെ സ്ഥാനം നൽകുന്നു.

ഒരു പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ, മോട്ടോർ സ്ഥാനം 0 ഡിഗ്രിയായി സജ്ജീകരിച്ചിരിക്കുന്നു. മോട്ടോർ ഒരു തിരിവ് മുന്നോട്ട് കറങ്ങുകയാണെങ്കിൽ, സ്ഥാനം 360 ഡിഗ്രി അല്ലെങ്കിൽ 1 തിരിവ് ആയിരിക്കും. മോട്ടോർ മറുവശത്ത് കറങ്ങുകയാണെങ്കിൽ, സ്ഥാനം നെഗറ്റീവ് ആയിരിക്കും.

Usage:
arm_motor.get_position(units)

പാരാമീറ്ററുകൾ	വിവരണം
units	ഓപ്ഷണൽ. മോട്ടോർ സ്ഥാനം തിരികെ നൽകേണ്ട യൂണിറ്റ്: DEGREES (സ്ഥിരസ്ഥിതി) അല്ലെങ്കിൽ TURNS.

# Build Used: Competition Advanced 2.0
def main():
    # Display how far the ArmMotor moves after one second
    arm_motor.set_position(0, DEGREES)
    console.print("Start: ")
    console.print(arm_motor.get_position(DEGREES))
    console.new_line()
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()
    console.print("After: ")
    console.print(arm_motor.get_position(DEGREES))

# Start threads — Do not delete
start_thread(main)

get_velocity

get_velocity മോട്ടോർ എത്ര വേഗത്തിൽ കറങ്ങുന്നുവെന്ന് -100% മുതൽ 100% വരെയുള്ള ശതമാനമായി നൽകുന്നു.

ഒരു പോസിറ്റീവ് മൂല്യം മോട്ടോർ മുന്നോട്ട് കറങ്ങുന്നു എന്നാണ് അർത്ഥമാക്കുന്നത്. ഒരു നെഗറ്റീവ് മൂല്യം മോട്ടോർ വിപരീത ദിശയിൽ കറങ്ങുന്നു എന്നാണ് അർത്ഥമാക്കുന്നത്.

Usage:
arm_motor.get_velocity()

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

# Build Used: Competition Advanced 2.0
def main():
    # Display the ArmMotor's velocity when it moves
    console.print("Resting: ")
    console.print(arm_motor.get_velocity())
    console.new_line()
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    console.print("Moving: ")
    console.print(arm_motor.get_velocity())
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

get_current

get_current ബാറ്ററിയിൽ നിന്ന് മോട്ടോർ എത്ര പവർ ഉപയോഗിക്കുന്നു എന്ന് 0% മുതൽ 100% വരെയുള്ള ശതമാനത്തിൽ നൽകുന്നു.

ഉയർന്ന കറന്റ് മൂല്യം എന്നാൽ മോട്ടോർ കൂടുതൽ പവർ ഉപയോഗിക്കുന്നു എന്നാണ് അർത്ഥമാക്കുന്നത്. മോട്ടോർ ഭാരമുള്ള എന്തെങ്കിലും ഉയർത്തുമ്പോഴോ, ഒരു വസ്തുവിനെതിരെ തള്ളുമ്പോഴോ, അത് കുടുങ്ങിക്കിടക്കുമ്പോൾ ചലിക്കാൻ ശ്രമിക്കുമ്പോഴോ ഇത് സംഭവിക്കാം.

Usage:
arm_motor.get_current()

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

# Build Used: Competition Advanced 2.0
def main():
    # Display the motor's current when it moves
    console.print("Resting: ")
    console.print(arm_motor.get_current())
    console.new_line()
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    console.print("Moving: ")
    console.print(arm_motor.get_current())
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

is_stopped

is_stopped എന്നത് മോട്ടോർ നീങ്ങുന്നത് അവസാനിച്ചോ എന്ന് ഒരു ബൂളിയൻ മൂല്യമായി നൽകുന്നു. മോട്ടോറിന്റെ ചലനത്തെ അടിസ്ഥാനമാക്കി മറ്റ് പെരുമാറ്റങ്ങളുടെ സമയം നിയന്ത്രിക്കാൻ ഇത് ഉപയോഗിക്കാം.

• True — മോട്ടോർ ചലിച്ചു കഴിഞ്ഞു.

• False — മോട്ടോർ ഇപ്പോഴും ചലിച്ചുകൊണ്ടിരിക്കുന്നു.

ഈ രീതി wait പാരാമീറ്റർ ഉള്ള ഇനിപ്പറയുന്ന മോഷൻ രീതികളുമായി സംയോജിച്ച് പ്രവർത്തിക്കുന്നു: spin_for ഉം spin_to_position.

Usage:
arm_motor.is_stopped()

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

# Build Used: Competition Advanced 2.0
def main():
    # Turn the Eye Sensor's light on while ArmMotor is moving
    arm_motor.spin_for(REVERSE, 180, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while True:
        if arm_motor.is_stopped():
            eye.set_light(OFF)
        else:
            eye.set_light(ON)

# Start threads — Do not delete
start_thread(main)

is_moving

is_moving എന്നത് മോട്ടോർ കറങ്ങുന്നുണ്ടോ എന്ന് ഒരു ബൂളിയൻ മൂല്യമായി നൽകുന്നു. മോട്ടോറിന്റെ ചലനത്തെ അടിസ്ഥാനമാക്കി മറ്റ് പെരുമാറ്റങ്ങളുടെ സമയം നിയന്ത്രിക്കാൻ ഇത് ഉപയോഗിക്കാം.

• True — മോട്ടോർ കറങ്ങുന്നു.

• False — മോട്ടോർ കറങ്ങുന്നില്ല.

ഈ രീതി wait പാരാമീറ്റർ ഉള്ള ഇനിപ്പറയുന്ന മോഷൻ രീതികളുമായി സംയോജിച്ച് പ്രവർത്തിക്കുന്നു: spin_for ഉം spin_to_position.

Usage:
arm_motor.is_moving()

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

# Build Used: Competition Advanced 2.0
def main():
    # Turn the Eye Sensor's light on while ArmMotor is moving
    arm_motor.spin_for(REVERSE, 180, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while True:
        if arm_motor.is_moving():
            eye.set_light(ON)
        else:
            eye.set_light(OFF)

# Start threads — Do not delete
start_thread(main)