ഡ്രൈവ്‌ട്രെയിൻ#

ആമുഖം#

റോബോട്ട് എങ്ങനെ ഓടിക്കുന്നു, തിരിയുന്നു എന്നിവ നിയന്ത്രിക്കുന്ന ചക്രങ്ങളും മോട്ടോറുകളും ഡ്രൈവ്‌ട്രെയിനിൽ ഉൾപ്പെടുന്നു. കോഡ് ബേസ് 2.0, സൂപ്പർ കാർ, അല്ലെങ്കിൽ ഒരു കസ്റ്റം റോബോട്ട് പോലുള്ള ബിൽഡുകളിൽ ഡ്രൈവ്‌ട്രെയിനുകൾ കാണാം.

ക്രാഷുകൾ കണ്ടെത്തുന്നതിനും റോബോട്ടിനെ കൃത്യമായി ചലിപ്പിക്കാനും തിരിയാനും സഹായിക്കുന്നതിനും ഡ്രൈവ്‌ട്രെയിനുകൾ തലച്ചോറിലെ ഇനേർഷ്യൽ സെൻസർ ഉപയോഗിക്കുന്നു. ഓരോ പ്രോജക്റ്റിന്റെയും തുടക്കത്തിൽ, ഡ്രൈവ്‌ട്രെയിൻ യാന്ത്രികമായി ഇനേർഷ്യൽ സെൻസർ കാലിബ്രേറ്റ് ചെയ്യുന്നു. കാലിബ്രേഷൻ സമയത്ത് റോബോട്ടിനെ ഏകദേശം 2 സെക്കൻഡ് നിശ്ചലമായി നിർത്തുക, അങ്ങനെ റോബോട്ടിന് ശരിയായി നീങ്ങാനും തിരിയാനും കഴിയും.

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

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

  • drive — റോബോട്ടിനെ മുന്നോട്ട് നീക്കുകയോ എന്നെന്നേക്കുമായി പിന്നിലേക്ക് നീക്കുകയോ ചെയ്യുന്നു.

  • drive_for — ഒരു പ്രത്യേക ദൂരത്തേക്ക് റോബോട്ടിനെ മുന്നോട്ട് അല്ലെങ്കിൽ പിന്നിലേക്ക് നീക്കുന്നു.

  • drive_until — ഐ സെൻസർ ഒരു വസ്തുവിനെ കണ്ടെത്തുന്നതുവരെയോ റോബോട്ട് ഒരു ക്രാഷ് കണ്ടെത്തുന്നതുവരെയോ റോബോട്ട് മുന്നോട്ട് നീക്കുന്നു.

  • turn — റോബോട്ടിനെ എന്നെന്നേക്കുമായി ഇടത്തോട്ടോ വലത്തോട്ടോ തിരിക്കുന്നു.

  • turn_for — ഒരു നിശ്ചിത എണ്ണം ഡിഗ്രികൾക്കായി റോബോട്ടിനെ ഇടത്തോട്ടോ വലത്തോട്ടോ തിരിക്കുന്നു.

  • turn_to_heading — -359 മുതൽ 359 ഡിഗ്രി വരെയുള്ള ഒരു പ്രത്യേക തലക്കെട്ടിന് അഭിമുഖമായി റോബോട്ടിനെ തിരിക്കുന്നു. ലക്ഷ്യ തലക്കെട്ടിൽ എത്താൻ റോബോട്ട് ഏറ്റവും കുറഞ്ഞ ദിശ തിരിക്കും.

  • turn_to_rotation — റോബോട്ടിനെ ഒരു പ്രത്യേക ഭ്രമണത്തിലേക്ക് തിരിക്കുന്നു.

  • stop — റോബോട്ടിന്റെ ചലനം നിർത്തുന്നു.

മ്യൂട്ടേറ്ററുകൾ — ഡ്രൈവ്‌ട്രെയിൻ ക്രമീകരണങ്ങൾ ക്രമീകരിക്കുക.

  • set_drive_velocity — റോബോട്ടിനോട് എത്ര വേഗത്തിൽ ഡ്രൈവ് ചെയ്യണമെന്ന് പറയുന്നു.

  • set_turn_velocity — എത്ര വേഗത്തിൽ തിരിയണമെന്ന് റോബോട്ടിനോട് പറയുന്നു.

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

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

  • set_heading — റോബോട്ടിന്റെ നിലവിലെ തലക്കെട്ട് ഒരു പുതിയ തലക്കെട്ടിലേക്ക് മാറ്റുന്നു.

  • set_rotation — റോബോട്ടിന്റെ നിലവിലെ ഭ്രമണത്തെ ഒരു പുതിയ ഭ്രമണത്തിലേക്ക് മാറ്റുന്നു.

ഗെറ്ററുകൾ — ചലന നില പരിശോധിക്കുക.

  • get_heading — റോബോട്ടിന്റെ നിലവിലെ തലക്കെട്ട് 0 മുതൽ 359 ഡിഗ്രി വരെ തിരികെ നൽകുന്നു.

  • get_rotation — റോബോട്ടിന്റെ നിലവിലെ ഭ്രമണം തിരികെ നൽകുന്നു.

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

  • get_yaw — റോബോട്ടിന്റെ നിലവിലെ yaw തിരികെ നൽകുന്നു.

  • get_roll — റോബോട്ടിന്റെ നിലവിലെ റോൾ തിരികെ നൽകുന്നു.

  • get_pitch — റോബോട്ടിന്റെ നിലവിലെ പിച്ച് തിരികെ നൽകുന്നു.

  • get_crashed — റോബോട്ട് ഒരു ക്രാഷ് കണ്ടെത്തിയോ എന്ന് ബൂളിയൻ മൂല്യമായി നൽകുന്നു.

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

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

drive#

drive റോബോട്ടിനെ എന്നെന്നേക്കുമായി മുന്നോട്ട് അല്ലെങ്കിൽ പിന്നിലേക്ക് നീക്കുന്നു. തിരിയുകയോ നിർത്തുകയോ പോലുള്ള മറ്റൊരു പ്രവർത്തനം നൽകുന്നതുവരെ റോബോട്ട് നീങ്ങുന്നത് തുടരും.

Usage:
drivetrain.drive(direction)

പാരാമീറ്ററുകൾ

വിവരണം

direction

റോബോട്ട് നീങ്ങുന്ന ദിശ: FORWARD അല്ലെങ്കിൽ REVERSE.

 
# Build Used: Code Base 2.0
def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

drive_for#

drive_for റോബോട്ടിനെ ഒരു പ്രത്യേക ദൂരത്തേക്ക് മുന്നോട്ടോ പിന്നോട്ടോ നീക്കുന്നു.

Usage:
drivetrain.drive_for(direction, distance, units, wait)

പാരാമീറ്ററുകൾ

വിവരണം

direction

റോബോട്ട് നീങ്ങുന്ന ദിശ: FORWARD അല്ലെങ്കിൽ REVERSE.

distance

റോബോട്ട് ഓടിക്കുന്ന ദൂരം. ഇത് ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം.

units

ഓപ്ഷണൽ. ദൂര യൂണിറ്റ്: MM (മില്ലിമീറ്റർ, സ്ഥിരസ്ഥിതി) അല്ലെങ്കിൽ INCHES.

wait

ഓപ്ഷണൽ. wait=True (ഡിഫോൾട്ട്) റോബോട്ട് നീങ്ങുന്നത് വരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ പ്രേരിപ്പിക്കുന്നു, തുടർന്ന് കോഡിന്റെ അടുത്ത വരി പ്രവർത്തിക്കുന്നു. wait=False കോഡിന്റെ അടുത്ത വരി ഉടനടി പ്രവർത്തിപ്പിക്കുന്നു.

 
# Build Used: Code Base 2.0
def main():
    # Drive back and forth
    drivetrain.drive_for(FORWARD, 100, MM)
    drivetrain.drive_for(REVERSE, 4, INCHES)
    

# Start threads — Do not delete
start_thread(main)

drive_until#

ഐ സെൻസർ ഒരു വസ്തുവിനെ കണ്ടെത്തുന്നതുവരെയോ റോബോട്ട് ഒരു ക്രാഷ് കണ്ടെത്തുന്നതുവരെയോ drive_until റോബോട്ടിനെ മുന്നോട്ട് നീക്കുന്നു.

Usage:
drivetrain.drive_until(condition, wait)

പാരാമീറ്ററുകൾ

വിവരണം

condition

റോബോട്ടിനെ നിർത്തുന്ന അവസ്ഥ: OBJECT അല്ലെങ്കിൽ CRASH.

wait

ഓപ്ഷണൽ. wait=True (ഡിഫോൾട്ട്) റോബോട്ട് നീങ്ങുന്നത് വരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ പ്രേരിപ്പിക്കുന്നു, തുടർന്ന് കോഡിന്റെ അടുത്ത വരി പ്രവർത്തിക്കുന്നു. wait=False കോഡിന്റെ അടുത്ത വരി ഉടനടി പ്രവർത്തിപ്പിക്കുന്നു.

 
# Build Used: Code Base 2.0
def main():
    # Turn right after a crash
    drivetrain.drive_until(CRASH)
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

turn#

turn റോബോട്ടിനെ എന്നെന്നേക്കുമായി ഇടത്തോട്ടോ വലത്തോട്ടോ തിരിക്കുന്നു. നിർത്താൻ വാഹനമോടിക്കുന്നത് പോലുള്ള മറ്റൊരു പ്രവർത്തനം നൽകുന്നതുവരെ റോബോട്ട് തിരിയുന്നത് തുടരും.

Usage:
drivetrain.turn(direction)

പാരാമീറ്ററുകൾ

വിവരണം

direction

റോബോട്ട് തിരിയുന്ന ദിശ: LEFT അല്ലെങ്കിൽ RIGHT.

 
# Build Used: Code Base 2.0
def main():
    # Turn right and left, then stop
    drivetrain.turn(RIGHT)
    wait(2, SECONDS)
    drivetrain.turn(LEFT)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

turn_for#

turn_for റോബോട്ടിനെ ഒരു നിശ്ചിത എണ്ണം ഡിഗ്രികൾക്ക് ഇടത്തോട്ടോ വലത്തോട്ടോ തിരിക്കുന്നു. റോബോട്ടിന്റെ നിലവിലെ സ്ഥാനവുമായി തിരിവ് ആപേക്ഷികമാണ്.

Usage:
drivetrain.turn_for(direction, angle, wait)

പാരാമീറ്ററുകൾ

വിവരണം

direction

റോബോട്ട് തിരിയുന്ന ദിശ: LEFT അല്ലെങ്കിൽ RIGHT.

angle

റോബോട്ട് തിരിയുന്ന ഡിഗ്രികളുടെ എണ്ണം. ഇത് ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം.

wait

ഓപ്ഷണൽ. wait=True (ഡിഫോൾട്ട്) റോബോട്ട് അടുത്ത വരി കോഡ് പ്രവർത്തിപ്പിക്കുന്നതുവരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ അനുവദിക്കുന്നു. wait=False കോഡിന്റെ അടുത്ത വരി ഉടനടി പ്രവർത്തിപ്പിക്കുന്നു.

 
# Build Used: Code Base 2.0
def main():
    # Turn right then left
    drivetrain.turn_for(RIGHT, 90)
    drivetrain.turn_for(LEFT, 90)

# Start threads — Do not delete
start_thread(main)

turn_to_heading#

ഒരു തലക്കെട്ട് എന്നത് റോബോട്ടിന്റെ തലച്ചോറ് അഭിമുഖീകരിക്കുന്ന ദിശയാണ്, ഇത് ഡിഗ്രിയിൽ അളക്കുന്നു. turn_to_heading റോബോട്ടിനെ -359 മുതൽ 359 ഡിഗ്രി വരെയുള്ള ഒരു പ്രത്യേക തലക്കെട്ടിന് അഭിമുഖമായി തിരിക്കുന്നു. ലക്ഷ്യ തലക്കെട്ടിൽ എത്താൻ റോബോട്ട് ഏറ്റവും കുറഞ്ഞ ദിശയിലേക്ക് തിരിക്കും.

ആരംഭ തലക്കെട്ട് 0 ഡിഗ്രി ആണ്.

തലക്കെട്ടിന്റെ ദിശകൾ കാണിക്കുന്ന ഒരു VEX GO കോഡ് ബേസ് 2.0: 0 ഡിഗ്രി മുന്നോട്ട്, 90 ഡിഗ്രി വലത്തേക്ക്, 180 ഡിഗ്രി പിന്നിലേക്ക്, 270 ഡിഗ്രി ഇടത്തേക്ക്.

Usage:
drivetrain.turn_to_heading(angle, wait)

പാരാമീറ്ററുകൾ

വിവരണം

angle

ഒരു പൂർണ്ണസംഖ്യയായി റോബോട്ട് അഭിമുഖീകരിക്കേണ്ട ദിശ, -359 മുതൽ 359 ഡിഗ്രി വരെയാണ്.

wait

ഓപ്ഷണൽ. wait=True (ഡിഫോൾട്ട്) റോബോട്ട് അടുത്ത വരി കോഡ് പ്രവർത്തിപ്പിക്കുന്നതുവരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ അനുവദിക്കുന്നു. wait=False കോഡിന്റെ അടുത്ത വരി ഉടനടി പ്രവർത്തിപ്പിക്കുന്നു.

 
# Build Used: Code Base 2.0
def main():
    # Turn to face the cardinal directions
    drivetrain.turn_to_heading(90)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(180)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(270)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(0)

# Start threads — Do not delete
start_thread(main)

turn_to_rotation#

turn_to_rotation റോബോട്ടിനെ ഒരു പ്രത്യേക ഭ്രമണത്തിലേക്ക് തിരിക്കുന്നു.

ഭ്രമണം എന്നത് റോബോട്ട് എത്രമാത്രം തിരിഞ്ഞിരിക്കുന്നു എന്നതാണ്, അത് ഡിഗ്രിയിൽ അളക്കുന്നു. ഒരു പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ, ഭ്രമണ മൂല്യം 0 ഡിഗ്രിയായി സജ്ജീകരിച്ചിരിക്കുന്നു. set_rotation ഉപയോഗിച്ചും ഭ്രമണം സജ്ജമാക്കാം.

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

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

വലത്തോട്ടും ഇടത്തോട്ടും കറങ്ങുന്ന അമ്പടയാളങ്ങൾ കാണിക്കുന്ന ഒരു VEX GO കോഡ് ബേസ് 2.0. ഇടത് അമ്പടയാളം "മൈനസ്" ഉം വലത് അമ്പടയാളം "പ്ലസ്" ഉം കാണിക്കുന്നു.

Usage:
drivetrain.turn_to_rotation(angle, wait)

പാരാമീറ്ററുകൾ

വിവരണം

angle

റോബോട്ട് തിരിയുന്ന ഭ്രമണ മൂല്യം, ഡിഗ്രികളിൽ. ഇത് ഒരു പൂർണ്ണസംഖ്യ ആകാം.

wait

ഓപ്ഷണൽ. wait=True (ഡിഫോൾട്ട്) റോബോട്ട് അടുത്ത വരി കോഡ് പ്രവർത്തിപ്പിക്കുന്നതുവരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ അനുവദിക്കുന്നു. wait=False കോഡിന്റെ അടുത്ത വരി ഉടനടി പ്രവർത്തിപ്പിക്കുന്നു.

 
# Build Used: Code Base 2.0
def main():
    # Make one full turn to the right
    drivetrain.turn_to_rotation(360)
    # Make another full turn to the right
    drivetrain.turn_to_rotation(720)
    # Make one full turn to the left, returning to 360 degrees
    drivetrain.turn_to_rotation(360)
# Start threads — Do not delete
start_thread(main)

stop#

stop റോബോട്ടിന്റെ ചലനം നിർത്തുന്നു.

Usage:
drivetrain.stop()

പാരാമീറ്ററുകൾ

വിവരണം

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

 
# Build Used: Code Base 2.0
def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

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

set_drive_velocity#

set_drive_velocity റോബോട്ടിനോട് എത്ര വേഗത്തിൽ ഡ്രൈവ് ചെയ്യണമെന്ന് പറയുന്നു. ഉയർന്ന ശതമാനം റോബോട്ടിനെ വേഗത്തിലാക്കാനും കുറഞ്ഞ ശതമാനം റോബോട്ടിനെ വേഗത കുറയ്ക്കാനും സഹായിക്കുന്നു.

എല്ലാ പ്രോജക്റ്റുകളും ആരംഭിക്കുന്നത് റോബോട്ട് സ്വതവേ 50% വേഗതയിൽ ഓടിച്ചാണ്.

കുറിപ്പ്: ഉയർന്ന വേഗത റോബോട്ട് വേഗത്തിൽ ഓടിക്കാൻ സഹായിക്കുന്നു, പക്ഷേ കൃത്യത കുറവായിരിക്കാം. കുറഞ്ഞ വേഗത റോബോട്ട് വേഗത കുറയ്ക്കുന്നു, പക്ഷേ കൂടുതൽ കൃത്യതയുള്ളതായിരിക്കണം.

Usage:
drivetrain.set_drive_velocity(velocity)

പാരാമീറ്ററുകൾ

വിവരണം

velocity

പൂജ്യത്തിൽ നിന്ന് 100% വരെ വാഹനമോടിക്കാനുള്ള വേഗത.

 
# Build Used: Code Base 2.0
def main():
    # Drive at different velocities
    drivetrain.drive_for(FORWARD, 100, MM)
    wait(1, SECONDS)
    # Drive slow
    drivetrain.set_drive_velocity(20)
    drivetrain.drive_for(FORWARD, 100, MM)
    wait(1, SECONDS)
    # Drive fast
    drivetrain.set_drive_velocity(100)
    drivetrain.drive_for(FORWARD, 100, MM)

# Start threads — Do not delete
start_thread(main)

set_turn_velocity#

set_turn_velocity റോബോട്ടിനോട് എത്ര വേഗത്തിൽ തിരിയണമെന്ന് പറയുന്നു. ഉയർന്ന ശതമാനം റോബോട്ടിനെ വേഗത്തിലാക്കാനും കുറഞ്ഞ ശതമാനം റോബോട്ടിനെ മന്ദഗതിയിലാക്കാനും സഹായിക്കുന്നു.

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

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

Usage:
drivetrain.set_turn_velocity(velocity)

പാരാമീറ്ററുകൾ

വിവരണം

velocity

0% മുതൽ 100% വരെ തിരിയാനുള്ള വേഗത.

 
# Build Used: Code Base 2.0
def main():
    # Turn at different velocities
    drivetrain.turn_for(RIGHT, 180)
    wait(1, SECONDS)
    # Turn fast
    drivetrain.set_turn_velocity(100)
    drivetrain.turn_for(RIGHT, 180)

# Start threads — Do not delete
start_thread(main)

set_stopping#

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

Usage:
drivetrain.set_stopping(brake)

പാരാമീറ്ററുകൾ

വിവരണം

brake

റോബോട്ട് എങ്ങനെ നിർത്തും:

  • BRAKE — ഉടനടി നിർത്തുന്നു.
  • COAST — പതുക്കെ നിർത്തുന്നു.
  • HOLD — ഉടനടി നിർത്തി ചക്രങ്ങളുടെ സ്ഥാനം നിലനിർത്തുന്നു.

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

# Build Used: Code Base 2.0
def main():
    # Drive, then coast to a stop
    drivetrain.set_drive_velocity(100)
    drivetrain.set_stopping(COAST)
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

set_timeout#

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

Usage:
drivetrain.set_timeout(value, units)

പാരാമീറ്ററുകൾ

വിവരണം

value

ഒരു ചലനം പൂർത്തിയാക്കാൻ റോബോട്ടിന് എത്ര സമയം ശ്രമിക്കാൻ കഴിയും. ഇത് ഒരു പൂർണ്ണ സംഖ്യയോ ദശാംശമോ ആകാം.

units

ഓപ്ഷണൽ. സമയത്തിന്റെ യൂണിറ്റ്: SECONDS (സ്ഥിരസ്ഥിതി) അല്ലെങ്കിൽ MSEC (മില്ലിസെക്കൻഡ്).

 
# Build Used: Code Base 2.0
def main():
    # Drive as far as possible for 1 second before turning right
    drivetrain.set_timeout(1, SECONDS)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

set_heading#

ഒരു തലക്കെട്ട് എന്നത് റോബോട്ടിന്റെ തലച്ചോറ് അഭിമുഖീകരിക്കുന്ന ദിശയാണ്, ഇത് ഡിഗ്രിയിൽ അളക്കുന്നു. set_heading റോബോട്ടിന്റെ നിലവിലെ തലക്കെട്ടിനെ ഒരു പുതിയ തലക്കെട്ട് മൂല്യത്തിലേക്ക് മാറ്റുന്നു.

ഉദാഹരണത്തിന്, റോബോട്ട് വലത്തേക്ക് അഭിമുഖമായി തിരിഞ്ഞിട്ടുണ്ടെങ്കിൽ, തലക്കെട്ട് 0 ഡിഗ്രിയിലേക്ക് സജ്ജമാക്കുന്നത് ആ വലതുവശത്തുള്ള സ്ഥാനത്തെ പുതിയ 0 ഡിഗ്രിയാക്കുന്നു. തുടർന്ന് ആ പുതിയ തലക്കെട്ടിനെ അടിസ്ഥാനമാക്കി റോബോട്ടിന് മറ്റ് സ്ഥാനങ്ങളിലേക്ക് തിരിയാൻ കഴിയും.

Usage:
drivetrain.set_heading(value)

പാരാമീറ്ററുകൾ

വിവരണം

value

റോബോട്ടിനായി സജ്ജമാക്കേണ്ട തലക്കെട്ട് മൂല്യം, ഡിഗ്രികളിൽ. ഇത് 0 മുതൽ 359 വരെയുള്ള ഒരു പൂർണ്ണ സംഖ്യയാകാം.

 
# Build Used: Code Base 2.0
def main():
    # Face the new 0 degree heading
    drivetrain.set_heading(90)
    drivetrain.turn_to_heading(0)

# Start threads — Do not delete
start_thread(main)

set_rotation#

ഭ്രമണം എന്നത് റോബോട്ട് എത്രമാത്രം തിരിഞ്ഞിരിക്കുന്നു എന്നതാണ്, ഡിഗ്രിയിൽ അളക്കുന്നു. ഒരു പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ, ഭ്രമണ മൂല്യം 0 ഡിഗ്രിയായി സജ്ജീകരിച്ചിരിക്കുന്നു. set_rotation റോബോട്ടിന്റെ നിലവിലെ ഭ്രമണത്തെ ഒരു പുതിയ മൂല്യത്തിലേക്ക് മാറ്റുന്നു.

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

Usage:
drivetrain.set_rotation(value)

പാരാമീറ്ററുകൾ

വിവരണം

value

റോബോട്ടിനായി സജ്ജമാക്കേണ്ട ഭ്രമണ മൂല്യം, ഡിഗ്രികളിൽ. ഇത് ഒരു പൂർണ്ണസംഖ്യ ആകാം.

 
# Build Used: Code Base 2.0
def main():
    # Spin counterclockwise two times
    drivetrain.set_rotation(720)
    drivetrain.turn_to_rotation(0)

# Start threads — Do not delete
start_thread(main)

ഗെറ്ററുകൾ#

get_heading#

ഒരു തലക്കെട്ട് എന്നത് റോബോട്ടിന്റെ തലച്ചോറ് അഭിമുഖീകരിക്കുന്ന ദിശയാണ്, ഇത് ഡിഗ്രിയിൽ അളക്കുന്നു. get_heading ആ തലക്കെട്ട് 0 മുതൽ 359 ഡിഗ്രി വരെ തിരികെ നൽകുന്നു.

റോബോട്ടിന്റെ ആരംഭ തലക്കെട്ട് 0 ഡിഗ്രിയാണ്.

ഒരു VEX GO ബ്രെയിൻ തലക്കെട്ടിന്റെ ദിശകൾ കാണിക്കുന്നു: 0 ഡിഗ്രി മുന്നോട്ട്, 90 ഡിഗ്രി വലത്തേക്ക്, 180 ഡിഗ്രി പിന്നിലേക്ക്, 270 ഡിഗ്രി ഇടത്തേക്ക്.

Usage:
drivetrain.get_heading()

പാരാമീറ്ററുകൾ

വിവരണം

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

 
# Build Used: Code Base 2.0
def main():
    # Display the heading while turning
    monitor_sensor("drivetrain.get_heading")
    drivetrain.turn_for(RIGHT, 450)


# Start threads — Do not delete
start_thread(main)

get_rotation#

റോബോട്ട് എത്ര തിരിഞ്ഞിരിക്കുന്നു എന്നതാണ് ഭ്രമണം, ഡിഗ്രിയിൽ അളക്കുന്നു. ഒരു പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ, ഭ്രമണ മൂല്യം 0 ഡിഗ്രിയായി സജ്ജീകരിച്ചിരിക്കുന്നു. get_rotation റോബോട്ടിന്റെ നിലവിലെ ഭ്രമണം നൽകുന്നു.

വലത്തേക്ക് തിരിയുന്നത് ഭ്രമണം വർദ്ധിപ്പിക്കുന്നു, ഇടത്തേക്ക് തിരിയുന്നത് ഭ്രമണം കുറയ്ക്കുന്നു. ഉദാഹരണത്തിന്, വലത്തേക്ക് രണ്ട് പൂർണ്ണ തിരിവുകൾ നടത്തുന്നത് 720 ഡിഗ്രി ഭ്രമണം തിരികെ നൽകും.

വലത്തോട്ടും ഇടത്തോട്ടും കറങ്ങുന്ന അമ്പടയാളങ്ങൾ കാണിക്കുന്ന ഒരു VEX GO കോഡ് ബേസ് 2.0. ഇടത് അമ്പടയാളം "മൈനസ്" ഉം വലത് അമ്പടയാളം "പ്ലസ്" ഉം കാണിക്കുന്നു.

Usage:
drivetrain.get_rotation()

പാരാമീറ്ററുകൾ

വിവരണം

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

 
# Build Used: Code Base 2.0
def main():
    # Display the rotation while turning
    monitor_sensor("drivetrain.get_rotation")
    drivetrain.turn_for(RIGHT, 450)


# Start threads — Do not delete
start_thread(main)

get_velocity#

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

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

Usage:
drivetrain.get_velocity()

പാരാമീറ്ററുകൾ

വിവരണം

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

 
# Build Used: Code Base 2.0
def main():
    # Display the velocity of the robot before and while moving
    console.print("Start: ")
    console.print(drivetrain.get_velocity())
    console.new_line()
    drivetrain.drive(FORWARD)
    wait(0.5, SECONDS)
    console.print("Moving: ")
    console.print(drivetrain.get_velocity())
    drivetrain.stop()


# Start threads — Do not delete
start_thread(main)

get_yaw#

റോബോട്ട് അതിന്റെ ആരംഭ സ്ഥാനത്ത് നിന്ന് എത്ര ഇടത്തോട്ടോ വലത്തോട്ടോ തിരിഞ്ഞിരിക്കുന്നു എന്നതാണ് യാവ്, ഇത് ഡിഗ്രിയിൽ അളക്കുന്നു. get_yaw റോബോട്ടിന്റെ നിലവിലെ യാവ് മൂല്യം നൽകുന്നു.

വലത്തേക്ക് തിരിയുമ്പോൾ യാവ് മൂല്യം വർദ്ധിക്കുന്നു, ഇടത്തേക്ക് തിരിയുമ്പോൾ യാവ് മൂല്യം കുറയുന്നു.

Usage:
drivetrain.get_yaw()

പാരാമീറ്ററുകൾ

വിവരണം

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

 
# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the yaw while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_yaw")
    while True:
        if drivetrain.get_yaw() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_yaw() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_roll#

റോബോട്ട് ഇടത്തോട്ടോ വലത്തോട്ടോ എത്രത്തോളം ചരിഞ്ഞിരിക്കുന്നു എന്നതാണ് റോൾ, ഇത് ഡിഗ്രിയിൽ അളക്കുന്നു. get_roll റോബോട്ടിന്റെ നിലവിലെ റോൾ മൂല്യം നൽകുന്നു.

ബ്രെയിൻ മുന്നോട്ട് അഭിമുഖീകരിച്ച്, ഇടത്തേക്ക് ചരിഞ്ഞാൽ റോൾ മൂല്യം വർദ്ധിക്കും, വലത്തേക്ക് ചരിഞ്ഞാൽ റോൾ മൂല്യം കുറയും.

Usage:
drivetrain.get_roll()

പാരാമീറ്ററുകൾ

വിവരണം

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

 
# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the roll while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_roll")
    while True:
        if drivetrain.get_roll() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_roll() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_pitch#

പിച്ച് എന്നത് റോബോട്ട് എത്ര മുന്നോട്ട് അല്ലെങ്കിൽ പിന്നോട്ട് ചരിയുന്നു എന്നതാണ്, ഇത് ഡിഗ്രിയിൽ അളക്കുന്നു. get_pitch റോബോട്ടിന്റെ നിലവിലെ പിച്ച് മൂല്യം നൽകുന്നു.

തലച്ചോറ് മുന്നോട്ട് അഭിമുഖമായി നിൽക്കുമ്പോൾ, മുന്നോട്ട് ചരിഞ്ഞാൽ പിച്ച് മൂല്യം വർദ്ധിക്കും, പിന്നിലേക്ക് ചരിഞ്ഞാൽ പിച്ച് മൂല്യം കുറയും.

Usage:
drivetrain.get_pitch()

പാരാമീറ്ററുകൾ

വിവരണം

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

 
# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the pitch while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_pitch")
    while True:
        if drivetrain.get_pitch() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_pitch() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_crashed#

get_crashed റോബോട്ട് ഒരു ക്രാഷ് കണ്ടെത്തിയോ എന്ന് ഒരു ബൂളിയൻ മൂല്യമായി നൽകുന്നു.

  • True — ഒരു ക്രാഷ് കണ്ടെത്തി.

  • False — ഒരു ക്രാഷ് കണ്ടെത്തിയിട്ടില്ല.

Usage:
drivetrain.get_crashed()

പാരാമീറ്ററുകൾ

വിവരണം

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

 
# Build Used: Super Code Base 2.0
def main():
    # Drive until a crash
    drivetrain.drive(FORWARD)
    while not drivetrain.get_crashed():
        wait(50, MSEC)
    drivetrain.stop()
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

is_stopped#

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

  • True — റോബോട്ട് നീങ്ങുന്നത് പൂർത്തിയായി.

  • False — റോബോട്ട് ഇപ്പോഴും ചലിച്ചുകൊണ്ടിരിക്കുകയാണ്.

ഈ രീതി wait പാരാമീറ്റർ ഉള്ള ഇനിപ്പറയുന്ന ഡ്രൈവ്‌ട്രെയിൻ രീതികളുമായി സംയോജിച്ച് പ്രവർത്തിക്കുന്നു: drive_for, drive_until, turn_for, turn_to_heading, turn_to_rotation.

Usage:
drivetrain.is_stopped()

പാരാമീറ്ററുകൾ

വിവരണം

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

 
# Build Used: Code Base 2.0
def main():
    # Turn when the drivetrain is done moving forward
    drivetrain.drive_for(FORWARD, 100, MM, wait=False)
    wait(0.25, SECONDS)
    while True:
        if drivetrain.is_stopped():
            drivetrain.turn_for(RIGHT, 180)
            break
        else:
            console.print("Still moving...")
            wait(0.1, SECONDS)
            console.clear()

# Start threads — Do not delete
start_thread(main)
On this page