റോബോട്ട്-നിർദ്ദിഷ്ട പൈത്തൺ

ആമുഖം

ഹീറോ ബോട്ട്, ഹ്യൂയിയിൽ രണ്ട് മോട്ടോർ ഓപ്ഷനുകൾ ഉൾപ്പെടുന്നു, ഐക്യു എഐ വിഷൻ സെൻസർ, ഒപ്റ്റിക്കൽ സെൻസർ, ടച്ച് എൽഇഡി.

IQ 25-26 മിക്സ് & മാച്ച് പ്ലേഗ്രൗണ്ടിൽ ഉപയോഗിക്കാൻ എല്ലാ സ്റ്റാൻഡേർഡ് VEXcode VR രീതികളും ലഭ്യമാണ്.

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

ഡ്രൈവ്ട്രെയിൻ - റോബോട്ട് നീക്കി തിരിക്കുക.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• നേടുന്നവർ

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

  • rotation — റോബോട്ടിന്റെ നിലവിലെ റൊട്ടേഷൻ നൽകുന്നു.

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

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

  • velocity — റോബോട്ട് എത്ര വേഗത്തിൽ ഡ്രൈവ് ചെയ്യുന്നുവെന്ന് നൽകുന്നു.

ചലനം - റോബോട്ടിന്റെ മോട്ടോറുകൾ നീക്കി ട്രാക്ക് ചെയ്യുക.

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

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

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

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

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

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

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

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

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

• നേടുന്നവർ

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

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

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

  • velocity — മോട്ടോർ എത്ര വേഗത്തിൽ കറങ്ങുന്നുവെന്ന് നൽകുന്നു.

AI വിഷൻ - IQ AI വിഷൻ സെൻസർ ഉപയോഗിച്ച് വസ്തുക്കൾ പിടിച്ചെടുക്കുകയും വിശകലനം ചെയ്യുകയും ചെയ്യുക.

• നേടുന്നവർ

  • take_snapshot - ഒരു പ്രത്യേക ഒപ്പിനായി കണ്ടെത്തിയ വസ്തുക്കളുടെ ഒരു ട്യൂപ്പിൾ തിരികെ നൽകുന്നു.

• പ്രോപ്പർട്ടികൾ

  • width - കണ്ടെത്തിയ വസ്തുവിന്റെ വീതി പിക്സലുകളിൽ.

  • height - കണ്ടെത്തിയ വസ്തുവിന്റെ ഉയരം പിക്സലുകളിൽ.

  • centerX - പിക്സലുകളിൽ വസ്തുവിന്റെ കേന്ദ്രത്തിന്റെ X സ്ഥാനം.

  • centerY - വസ്തുവിന്റെ കേന്ദ്രത്തിന്റെ Y സ്ഥാനം പിക്സലുകളിൽ.

  • originX - പിക്സലുകളിൽ വസ്തുവിന്റെ മുകളിൽ ഇടത് കോണിന്റെ X സ്ഥാനം.

  • originY - പിക്സലുകളിൽ വസ്തുവിന്റെ മുകളിൽ ഇടത് കോണിന്റെ Y സ്ഥാനം.

  • id - വസ്തുവിന്റെ വർഗ്ഗീകരണം അല്ലെങ്കിൽ ടാഗ് ഐഡി.

കൺസോൾ – കൺസോളിലേക്ക് പ്രിന്റ് ചെയ്ത് മൂല്യങ്ങൾ നിരീക്ഷിക്കുക.

• പ്രിന്റ്

  • brain.screen.print — കൺസോളിൽ ടെക്സ്റ്റ്, നമ്പറുകൾ അല്ലെങ്കിൽ വേരിയബിൾ മൂല്യങ്ങൾ പ്രദർശിപ്പിക്കുന്നു.

  • brain.screen.next_row — കൺസോൾ കഴ്‌സർ അടുത്ത വരിയുടെ തുടക്കത്തിലേക്ക് നീക്കുന്നു.

  • brain.screen.clear_screen — കൺസോളിൽ നിന്ന് എല്ലാ വരികളും മായ്‌ക്കുന്നു.

• മോണിറ്റർ

  • monitor_variable — മോണിറ്റർ ടാബിലേക്ക് ഒന്നോ അതിലധികമോ മുൻകൂട്ടി നിശ്ചയിച്ച വേരിയബിളുകൾ ചേർക്കുന്നു.

  • monitor_sensor — മോണിറ്റർ ടാബിലേക്ക് ഒന്നോ അതിലധികമോ സെൻസർ മൂല്യങ്ങൾ ചേർക്കുന്നു.

സെൻസിങ് - റോബോട്ടിന്റെ വിവിധ സെൻസറുകൾ പ്രയോജനപ്പെടുത്തുക.

• എൽഇഡി സ്പർശിക്കുക

  • set_color - ടച്ച് LED ഒരു തിരഞ്ഞെടുത്ത നിറത്തിലേക്ക് സജ്ജമാക്കുന്നു.

• ഒപ്റ്റിക്കൽ

  • is_near_object – Returns whether the Optical Sensor detects an object within range.

  • color – ഒപ്റ്റിക്കൽ സെൻസർ കണ്ടെത്തിയ നിറം നൽകുന്നു.

  • brightness – വസ്തുവിൽ നിന്ന് പ്രതിഫലിക്കുന്ന പ്രകാശത്തിന്റെ അളവ് നൽകുന്നു.

  • hue – ഒപ്റ്റിക്കൽ സെൻസർ കണ്ടെത്തിയ നിറം തിരികെ നൽകുന്നു.

  • object_detected – ഒപ്റ്റിക്കൽ സെൻസർ ഒരു വസ്തുവിനെ കണ്ടെത്തുമ്പോൾ വിളിക്കേണ്ട ഒരു ഫംഗ്ഷൻ രജിസ്റ്റർ ചെയ്യുന്നു.

  • object_lost – ഒപ്റ്റിക്കൽ സെൻസർ ഒരു വസ്തു നഷ്ടപ്പെടുമ്പോൾ വിളിക്കേണ്ട ഒരു ഫംഗ്ഷൻ രജിസ്റ്റർ ചെയ്യുന്നു.

ഈ പേജിലെ ഉദാഹരണങ്ങൾ ഡിഫോൾട്ട് പ്ലേഗ്രൗണ്ട് ആരംഭ സ്ഥാനം ഉപയോഗിക്കുന്നു.

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

VR റോബോട്ട് എങ്ങനെ ഡ്രൈവ് ചെയ്യുന്നുവെന്നും തിരിയുന്നുവെന്നും ഡ്രൈവ്‌ട്രെയിൻ നിയന്ത്രിക്കുന്നു. ഡ്രൈവ്‌ട്രെയിനിന് മുന്നോട്ട് അല്ലെങ്കിൽ പിന്നോട്ട് നീങ്ങാനും, ഇടത്തോട്ടോ വലത്തോട്ടോ തിരിയാനും, തലക്കെട്ടുകളിലേക്ക് തിരിയാനും, അതിന്റെ ഭ്രമണം ട്രാക്ക് ചെയ്യാനും കഴിയും.

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

ഡ്രൈവ് ചെയ്യുക

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

Usage:
drivetrain.drive(direction)

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

def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

ഡ്രൈവ്_ഫോർ

drive_for റോബോട്ടിനെ ഒരു പ്രത്യേക ദൂരത്തേക്ക് മുന്നോട്ടോ പിന്നോട്ടോ നീക്കുന്നു. അടുത്ത കോഡ് വരി പ്രവർത്തിക്കുന്നതിന് മുമ്പ് റോബോട്ട് നീങ്ങുന്നത് പൂർത്തിയാകുന്നതുവരെ പ്രോജക്റ്റ് കാത്തിരിക്കും.

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

പാരാമീറ്ററുകൾ	വിവരണം
direction	റോബോട്ട് നീങ്ങുന്ന ദിശ: FORWARD അല്ലെങ്കിൽ REVERSE.
distance	റോബോട്ട് ഓടിക്കുന്ന ദൂരം. ഇത് integer അല്ലെങ്കിൽ ദശാംശ സംഖ്യ (float ) ആകാം.
units	ഓപ്ഷണൽ. ദൂര യൂണിറ്റ്: INCHES (ഡിഫോൾട്ട്) അല്ലെങ്കിൽ MM (മില്ലിമീറ്റർ).
wait	ഓപ്ഷണൽ. wait=True (ഡിഫോൾട്ട്) റോബോട്ട് നീങ്ങുന്നത് വരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ പ്രേരിപ്പിക്കുന്നു, തുടർന്ന് കോഡിന്റെ അടുത്ത വരി പ്രവർത്തിക്കുന്നു. wait=False കോഡിന്റെ അടുത്ത വരി ഉടനടി പ്രവർത്തിപ്പിക്കുന്നു.

def main():
    # Drive forward and backward
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.drive_for(REVERSE, 200, MM)

# VR threads — Do not delete
vr_thread(main)

തിരിയുക

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

Usage:
drivetrain.turn(direction)

പാരാമീറ്ററുകൾ	വിവരണം
direction	റോബോട്ട് തിരിയുന്ന ദിശ: LEFT അല്ലെങ്കിൽ RIGHT.

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

# VR threads — Do not delete
vr_thread(main)

ടേൺ_ഫോർ

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

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

പാരാമീറ്ററുകൾ	വിവരണം
direction	റോബോട്ട് തിരിയുന്ന ദിശ: LEFT അല്ലെങ്കിൽ RIGHT.
angle	റോബോട്ട് തിരിയുന്ന ഡിഗ്രികളുടെ എണ്ണം. ഇത് integer അല്ലെങ്കിൽ ദശാംശം (float ) ആകാം.
units	ഓപ്ഷണൽ. റൊട്ടേഷൻ യൂണിറ്റ്: DEGREES (സ്ഥിരസ്ഥിതി).
wait	ഓപ്ഷണൽ. wait=True (ഡിഫോൾട്ട്) റോബോട്ട് അടുത്ത വരി കോഡ് പ്രവർത്തിപ്പിക്കുന്നതുവരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ അനുവദിക്കുന്നു. wait=False കോഡിന്റെ അടുത്ത വരി ഉടനടി പ്രവർത്തിപ്പിക്കുന്നു.

def main():
    # Turn the robot right and left
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_for(LEFT, 90, DEGREES)

# VR threads — Do not delete
vr_thread(main)

തലക്കെട്ടിലേക്ക് തിരിയുക

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

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

റോബോട്ട് തിരിയുന്നത് വരെ പ്രോജക്റ്റ് കാത്തിരിക്കും, തുടർന്ന് അടുത്ത കോഡ് വരി പ്രവർത്തിക്കും.

Usage:
drivetrain.turn_to_heading(angle, units, wait)

പാരാമീറ്ററുകൾ	വിവരണം
angle	റോബോട്ട് അഭിമുഖീകരിക്കേണ്ട ദിശ, ഡിഗ്രികളിൽ. ഇത് -359 മുതൽ 359 വരെയുള്ള ഒരു integer അല്ലെങ്കിൽ ദശാംശ (float) ആകാം.
units	ഓപ്ഷണൽ. റൊട്ടേഷൻ യൂണിറ്റ്: DEGREES (സ്ഥിരസ്ഥിതി).
wait	ഓപ്ഷണൽ. wait=True (ഡിഫോൾട്ട്) റോബോട്ട് അടുത്ത വരി കോഡ് പ്രവർത്തിപ്പിക്കുന്നതുവരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ അനുവദിക്കുന്നു. wait=False കോഡിന്റെ അടുത്ത വരി ഉടനടി പ്രവർത്തിപ്പിക്കുന്നു.

def main():
    # Turn to face the cardinal directions
    drivetrain.turn_to_heading(90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(180, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(270, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

ഭ്രമണത്തിലേക്ക്_തിരിയുക

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

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

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

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

റോബോട്ട് തിരിയുന്നത് വരെ പ്രോജക്റ്റ് കാത്തിരിക്കും, തുടർന്ന് അടുത്ത കോഡ് വരി പ്രവർത്തിക്കും.

Usage:
drivetrain.turn_to_rotation(angle, units, wait)

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

def main():
    # Turn left, then spin in a circle
    # clockwise and face right
    drivetrain.turn_to_rotation(-90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_rotation(450, DEGREES)

# VR threads — Do not delete
vr_thread(main)

നിർത്തുക

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

Usage:
drivetrain.stop()

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

def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

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

സെറ്റ്_ഹെഡിംഗ്

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

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

Usage:
drivetrain.set_heading(heading, units)

പാരാമീറ്ററുകൾ	വിവരണം
heading	റോബോട്ടിനായി സജ്ജമാക്കേണ്ട ഡിഗ്രികളിലെ ഹെഡിംഗ് മൂല്യം. ഇത് integer അല്ലെങ്കിൽ ദശാംശം (float ) ആകാം.
units	ഓപ്ഷണൽ. ഹെഡിംഗ് യൂണിറ്റ്: DEGREES (ഡിഫോൾട്ട്).

def main():
    # Face the new 0 degrees
    drivetrain.set_heading(90, DEGREES)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

സെറ്റ്_റൊട്ടേഷൻ

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

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

Usage:
drivetrain.set_rotation(rotation, units)

പാരാമീറ്ററുകൾ	വിവരണം
rotation	റോബോട്ടിനായി സജ്ജമാക്കേണ്ട ഡിഗ്രികളിൽ, ഭ്രമണ മൂല്യം. ഇത് integer അല്ലെങ്കിൽ ദശാംശം ആകാം (float).
units	ഓപ്ഷണൽ. റൊട്ടേഷൻ യൂണിറ്റ്: DEGREES (സ്ഥിരസ്ഥിതി).

def main():
    # Spin counterclockwise two times
    drivetrain.set_rotation(720, DEGREES)
    drivetrain.turn_to_rotation(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

സെറ്റ്_ടൈമൗട്ട്

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

Usage:
drivetrain.set_timeout(value, units)

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

def main():
    # Turn right after driving forward
    drivetrain.set_timeout(1, SECONDS)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    drivetrain.turn_for(RIGHT, 90)

# VR threads — Do not delete
vr_thread(main)

സെറ്റ്_ഡ്രൈവ്_വെലോസിറ്റി

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

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

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

Usage:
drivetrain.set_drive_velocity(velocity, units)

പാരാമീറ്ററുകൾ	വിവരണം
velocity	0% മുതൽ 100% വരെ ഡ്രൈവ് ചെയ്യേണ്ട വേഗത. ഇത് ഒരു integer അല്ലെങ്കിൽ ദശാംശ സംഖ്യ (float ) ആകാം.
units	ഓപ്ഷണൽ. പ്രവേഗ യൂണിറ്റ്: PERCENT (സ്ഥിരസ്ഥിതി).

def main():
    # Drive forward at different velocities
    # Default velocity
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive slower
    drivetrain.set_drive_velocity(20, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive faster
    drivetrain.set_drive_velocity(100, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)

# VR threads — Do not delete
vr_thread(main)

സെറ്റ്_ടേൺ_വെലോസിറ്റി

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

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

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

Usage:
drivetrain.set_turn_velocity(velocity, units)

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

def main():
    # Turn at different velocities
    # Default velocity
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn slower
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)

# VR threads — Do not delete
vr_thread(main)

ഗെറ്ററുകൾ

തലക്കെട്ട്

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

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

Usage:
drivetrain.heading(units)

പാരാമീറ്ററുകൾ	വിവരണം
units	ഓപ്ഷണൽ. ഹെഡിംഗ് യൂണിറ്റ്: DEGREES (ഡിഫോൾട്ട്).

def main():
    # Display the heading after turning
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.screen.print("Heading: ")
    brain.screen.print(drivetrain.heading(DEGREES))

# VR threads — Do not delete
vr_thread(main)

ഭ്രമണം

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

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

Usage:
drivetrain.rotation(units)

പാരാമീറ്ററുകൾ	വിവരണം
units	ഓപ്ഷണൽ. റൊട്ടേഷൻ യൂണിറ്റ്: DEGREES (സ്ഥിരസ്ഥിതി).

def main():
    # Display the rotation after turning
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.screen.print("Rotation: ")
    brain.screen.print(drivetrain.rotation(DEGREES))

# VR threads — Do not delete
vr_thread(main)

ചെയ്തു കഴിഞ്ഞു

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

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

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

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

Usage:
drivetrain.is_done()

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

നീങ്ങുന്നു

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

• True — റോബോട്ട് നീങ്ങുന്നു.

• False — റോബോട്ട് നീങ്ങുന്നില്ല.

Usage:
drivetrain.is_moving()

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

വേഗത

റോബോട്ട് എത്ര വേഗത്തിൽ ഓടിക്കുന്നു എന്ന് velocity നിന്ന് -100% മുതൽ 100% വരെയുള്ള ശതമാനത്തിൽ ലഭിക്കും.

Usage:
drivetrain.velocity(units)

പാരാമീറ്ററുകൾ	വിവരണം
units	ഓപ്ഷണൽ. പ്രവേഗ യൂണിറ്റ്: PERCENT (സ്ഥിരസ്ഥിതി).

ഉദാഹരണം

def main():
    # Display the velocity after driving
    drivetrain.drive_for(FORWARD, 150, MM)
    brain.screen.print("Velocity: ")
    brain.screen.print(drivetrain.velocity(PERCENT))

ചലനം

പിന്നുകളും ബീമുകളും എടുക്കാനോ ഉപേക്ഷിക്കാനോ കഴിയുന്ന തരത്തിൽ ക്ലാവ് തുറക്കാനും അടയ്ക്കാനും ഹ്യൂയി ക്ലാവ് മോട്ടോർ ഉപയോഗിക്കുന്നു. ലിഫ്റ്റ് മോട്ടോർ പിന്നുകളെയോ ബീമുകളെയോ പരസ്പരം ബന്ധിപ്പിക്കാൻ കഴിയുന്ന തരത്തിൽ ഉയർത്തുകയും താഴ്ത്തുകയും ചെയ്യുന്നു.

ഓരോ മോട്ടോറിനും അതിന്റേതായ ദിശാ പെരുമാറ്റമുണ്ട്. ഹ്യൂയിയിൽ ഓരോ ദിശയും ആ മോട്ടോർ എങ്ങനെ ചലിപ്പിക്കുന്നുവെന്ന് ദിശാ വിവരണങ്ങൾ വിശദീകരിക്കുന്നു.

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

കറക്കുക

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

ഉപയോഗം:
താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ, ഈ രീതി ഉപയോഗിച്ച് ലഭ്യമായ രണ്ട് മോട്ടോർ വസ്തുക്കളിൽ ഒന്ന് ഉപയോഗിക്കാം:

മോട്ടോർ	കമാൻഡ്
claw_motor	claw_motor.spin(direction) — ക്ലോ മോട്ടോർ
lift_motor	lift_motor.spin(direction) — ലിഫ്റ്റ് മോട്ടോർ

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

def main():
    # Raise the lift, drive forward, then open the claw.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

സ്പിൻ_ഫോർ

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

ഉപയോഗം:
താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ, ഈ രീതി ഉപയോഗിച്ച് ലഭ്യമായ രണ്ട് മോട്ടോർ വസ്തുക്കളിൽ ഒന്ന് ഉപയോഗിക്കാം:

മോട്ടോർ	കമാൻഡ്
claw_motor	claw_motor.spin_for(direction, distance, units, wait=True) — ക്ലോ മോട്ടോർ
lift_motor	lift_motor.spin_for(direction, distance, units, wait=True) — ലിഫ്റ്റ് മോട്ടോർ

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

def main():
    # Raise the lift, drive forward, then open the claw.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

സ്ഥാനത്തേക്ക്_തിരിക്കുക

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

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

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

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

ഉപയോഗം:
താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ, ഈ രീതി ഉപയോഗിച്ച് ലഭ്യമായ രണ്ട് മോട്ടോർ വസ്തുക്കളിൽ ഒന്ന് ഉപയോഗിക്കാം:

മോട്ടോർ	കമാൻഡ്
claw_motor	claw_motor.spin_to_position(angle, units, wait=True) — ക്ലോ മോട്ടോർ
lift_motor	lift_motor.spin_to_position(angle, units, wait=True) — ലിഫ്റ്റ് മോട്ടോർ

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

def main():
    # Raise the lift to a known position, drive, then open the claw
    lift_motor.spin_to_position(-720, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

സ്റ്റോപ്പ് മോട്ടോർ

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

ഉപയോഗം:
താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ, ഈ രീതി ഉപയോഗിച്ച് ലഭ്യമായ രണ്ട് മോട്ടോർ വസ്തുക്കളിൽ ഒന്ന് ഉപയോഗിക്കാം:

മോട്ടോർ	കമാൻഡ്
claw_motor	claw_motor.stop() — ക്ലോ മോട്ടോർ
lift_motor	lift_motor.stop() — ലിഫ്റ്റ് മോട്ടോർ

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

def main():
    # Raise the lift for 2 seconds, then stop
    lift_motor.spin(REVERSE)
    wait(2, SECONDS)
    lift_motor.stop()
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

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

സെറ്റ്_പൊസിഷൻ

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

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

ഉപയോഗം:
താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ, ഈ രീതി ഉപയോഗിച്ച് ലഭ്യമായ രണ്ട് മോട്ടോർ വസ്തുക്കളിൽ ഒന്ന് ഉപയോഗിക്കാം:

മോട്ടോർ	കമാൻഡ്
claw_motor	claw_motor.set_position(position, units) — ക്ലോ മോട്ടോർ
lift_motor	lift_motor.set_position(position, units) — ലിഫ്റ്റ് മോട്ടോർ

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

def main():
    # Reset the lift position, then move to a new target.
    lift_motor.set_position(100, DEGREES)
    lift_motor.spin_to_position(-500, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

സെറ്റ്_വെലോസിറ്റി

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

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

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

ഉപയോഗം:
താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ, ഈ രീതി ഉപയോഗിച്ച് ലഭ്യമായ രണ്ട് മോട്ടോർ വസ്തുക്കളിൽ ഒന്ന് ഉപയോഗിക്കാം:

മോട്ടോർ	കമാൻഡ്
claw_motor	claw_motor.set_velocity(velocity, units) — ക്ലോ മോട്ടോർ
lift_motor	lift_motor.set_velocity(velocity, units) — ലിഫ്റ്റ് മോട്ടോർ

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

def main():
    # Set lift speed, then raise it.
    lift_motor.set_velocity(100, PERCENT)
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

സെറ്റ്_ടൈമൗട്ട്

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

ഉപയോഗം:
താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ, ഈ രീതി ഉപയോഗിച്ച് ലഭ്യമായ രണ്ട് മോട്ടോർ വസ്തുക്കളിൽ ഒന്ന് ഉപയോഗിക്കാം:

മോട്ടോർ	കമാൻഡ്
claw_motor	claw_motor.set_timeout(value, units) — ക്ലോ മോട്ടോർ
lift_motor	lift_motor.set_timeout(value, units) — ലിഫ്റ്റ് മോട്ടോർ

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

def main():
    # Limit how long the lift waits to reach its target.
    lift_motor.set_timeout(2, SECONDS)
    lift_motor.spin_for(REVERSE, 1800, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

ഗെറ്ററുകൾ

ചെയ്തു കഴിഞ്ഞു

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

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

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

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

ഉപയോഗം:
താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ, ഈ രീതി ഉപയോഗിച്ച് ലഭ്യമായ രണ്ട് മോട്ടോർ വസ്തുക്കളിൽ ഒന്ന് ഉപയോഗിക്കാം:

മോട്ടോർ	കമാൻഡ്
claw_motor	claw_motor.is_done() — ക്ലോ മോട്ടോർ
lift_motor	lift_motor.is_done() — ലിഫ്റ്റ് മോട്ടോർ

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

def main():
    # Flash the Touch LED while the lift is moving.
    lift_motor.spin_for(REVERSE, 600, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while not lift_motor.is_done():
        touchled.set_color(RED)
        wait(0.5, SECONDS)
        touchled.set_color(NONE)
        wait(0.5, SECONDS)

# VR threads — Do not delete
vr_thread(main)

സ്പിന്നിംഗ്_സ്പിന്നിംഗ്

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

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

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

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

ഉപയോഗം:
താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ, ഈ രീതി ഉപയോഗിച്ച് ലഭ്യമായ രണ്ട് മോട്ടോർ വസ്തുക്കളിൽ ഒന്ന് ഉപയോഗിക്കാം:

മോട്ടോർ	കമാൻഡ്
claw_motor	claw_motor.is_spinning() — ക്ലോ മോട്ടോർ
lift_motor	lift_motor.is_spinning() — ലിഫ്റ്റ് മോട്ടോർ

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

def main():
    # Flash the Touch LED while the lift is spinning.
    lift_motor.spin_for(REVERSE, 600, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while lift_motor.is_spinning():
        touchled.set_color(RED)
        wait(0.5, SECONDS)
        touchled.set_color(NONE)
        wait(0.5, SECONDS)

# VR threads — Do not delete
vr_thread(main)

സ്ഥാനം

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

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

ഉപയോഗം:
താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ, ഈ രീതി ഉപയോഗിച്ച് ലഭ്യമായ രണ്ട് മോട്ടോർ വസ്തുക്കളിൽ ഒന്ന് ഉപയോഗിക്കാം:

മോട്ടോർ	കമാൻഡ്
claw_motor	claw_motor.position(units) — ക്ലോ മോട്ടോർ
lift_motor	lift_motor.position(units) — ലിഫ്റ്റ് മോട്ടോർ

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

def main():
    # Raise the lift until it reaches roughly 600 degrees.
    lift_motor.spin(REVERSE)
    while not lift_motor.position(DEGREES) <= -600:
        wait(2, MSEC)
    lift_motor.stop()
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

വേഗത

velocity മോട്ടോർ എത്ര വേഗത്തിൽ കറങ്ങുന്നുവെന്ന് നൽകുന്നു.

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

ഉപയോഗം:
താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ, ഈ രീതി ഉപയോഗിച്ച് ലഭ്യമായ രണ്ട് മോട്ടോർ വസ്തുക്കളിൽ ഒന്ന് ഉപയോഗിക്കാം:

മോട്ടോർ	കമാൻഡ്
claw_motor	claw_motor.velocity(units) — ക്ലോ മോട്ടോർ
lift_motor	lift_motor.velocity(units) — ലിഫ്റ്റ് മോട്ടോർ

പാരാമീറ്ററുകൾ	വിവരണം
units	നൽകേണ്ട പ്രവേഗ യൂണിറ്റ്: PERCENT.

def main():
    # Print the lift velocity while it is moving.
    lift_motor.set_velocity(100, PERCENT)
    lift_motor.spin_for(REVERSE, 600, DEGREES, wait=False)
    wait(0.5, SECONDS)
    brain.screen.print(lift_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

എഐ വിഷൻ

ഗെറ്ററുകൾ

ടേക്ക്_സ്നാപ്പ്ഷോട്ട്

take_snapshot , IQ AI വിഷൻ സെൻസർ ഫ്രെയിമിൽ നിന്ന് ഡാറ്റ ഒരു സിംഗിൾ സിഗ്നേച്ചറിലേക്ക് ഫിൽട്ടർ ചെയ്യുന്നു - ഫീൽഡിലെ ഒരു ഗെയിം എലമെന്റ് പോലുള്ള സെൻസറിന് തിരിച്ചറിയാൻ കഴിയുന്ന ഒന്നിന്റെ സംരക്ഷിച്ച വിവരണം - ഒരു ട്യൂപ്പിൾ തിരികെ നൽകുന്നു.

സൂചിക 0 മുതൽ വീതി അനുസരിച്ച് ഏറ്റവും വലുത് മുതൽ ചെറുത് വരെ ക്രമീകരിച്ച വസ്തുക്കളെ ട്യൂപ്പിൾ സംഭരിക്കുന്നു. ഓരോ വസ്തുവിന്റെയും പ്രോപ്പർട്ടികൾ അതിന്റെ സൂചിക ഉപയോഗിച്ച് ആക്‌സസ് ചെയ്യാൻ കഴിയും. പൊരുത്തപ്പെടുന്ന വസ്തുക്കളൊന്നും കണ്ടെത്തിയില്ലെങ്കിൽ ഒരു ശൂന്യമായ ട്യൂപ്പിൾ തിരികെ നൽകും.

Usage:
ai_vision.take_snapshot(signature)

പാരാമീറ്ററുകൾ	വിവരണം
signature	നൽകിയിരിക്കുന്ന ഒപ്പിന്റെ ഡാറ്റ മാത്രം ഉൾപ്പെടുത്തുന്നതിനായി ഡാറ്റാസെറ്റ് ഫിൽട്ടർ ചെയ്യുന്നു. ലഭ്യമായ ഒപ്പുകൾ ഇവയാണ്: AiVision.ALL_AIOBJS - ബീമുകളും നീല, ചുവപ്പ്, ഓറഞ്ച് പിന്നുകളും കണ്ടെത്തുന്നു.

def main():
    # Place the Red Pin on the top-left Blue Pin.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.turn_for(LEFT, 38, DEGREES)

    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    while not ai_objects[0].width > 48:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        drivetrain.drive(FORWARD)

    drivetrain.drive_for(FORWARD, 160, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

പ്രോപ്പർട്ടികൾ

take_snapshot ഉപയോഗിച്ചതിനുശേഷം ഒരു ട്യൂപ്പിളിൽ സൂക്ഷിച്ചിരിക്കുന്ന ഓരോ ഒബ്‌ജക്റ്റിലും ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഏഴ് പ്രോപ്പർട്ടികൾ ഉണ്ട്.

.id ഒഴികെയുള്ള എല്ലാ പ്രോപ്പർട്ടി മൂല്യങ്ങളും take_snapshot ഉപയോഗിച്ച സമയത്ത് IQ AI വിഷൻ സെൻസറിന്റെ വ്യൂവിൽ കണ്ടെത്തിയ വസ്തുവിന്റെ സ്ഥാനവും വലുപ്പവും വിവരിക്കുന്നു. സെൻസറിന്റെ 320 ബൈ 240 പിക്സൽ റെസല്യൂഷനെ അടിസ്ഥാനമാക്കി ഈ മൂല്യങ്ങൾ പിക്സലുകളിലാണ് അളക്കുന്നത്.

.വീതി

.width കണ്ടെത്തിയ വസ്തുവിന്റെ വീതി പിക്സലുകളിൽ നൽകുന്നു, ഇത് 1 നും 320 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].width)

# VR threads — Do not delete
vr_thread(main)

.ഉയരം

.height കണ്ടെത്തിയ വസ്തുവിന്റെ ഉയരം പിക്സലുകളിൽ നൽകുന്നു, ഇത് 1 നും 240 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].height)

# VR threads — Do not delete
vr_thread(main)

.സെന്റർഎക്സ്

.centerX കണ്ടെത്തിയ വസ്തുവിന്റെ കേന്ദ്രത്തിന്റെ x-കോർഡിനേറ്റ് പിക്സലുകളിൽ നൽകുന്നു, ഇത് 0 നും 320 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].centerX)

# VR threads — Do not delete
vr_thread(main)

.സെന്റർവൈ

.centerY കണ്ടെത്തിയ വസ്തുവിന്റെ കേന്ദ്രത്തിന്റെ y-കോർഡിനേറ്റ് പിക്സലുകളിൽ നൽകുന്നു, ഇത് 0 നും 240 നും ഇടയിലുള്ള ഒരു പൂർണ്ണസംഖ്യയാണ്.

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].centerY)

# VR threads — Do not delete
vr_thread(main)

.ഒറിജിൻഎക്സ്

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

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].originX)

# VR threads — Do not delete
vr_thread(main)

.ഒറിജിൻവൈ

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

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].originY)

# VR threads — Do not delete
vr_thread(main)

.ഐഡി

.id കണ്ടെത്തിയ AI ക്ലാസിഫിക്കേഷന്റെ ഐഡി ഒരു പൂർണ്ണസംഖ്യയായി നൽകുന്നു.

AI വർഗ്ഗീകരണം	ഐഡി	ഒപ്പ്
ബീം	0	GameElements.BEAM
നീല പിൻ	1	GameElements.BLUE_PIN
ചുവന്ന പിൻ	2	GameElements.RED_PIN
ഓറഞ്ച് പിൻ	3	GameElements.ORANGE_PIN

def main():
    # Find the nearest Blue Pin in the current snapshot.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    object_count = 1
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) > 0:
        for repeat_count in range(len(ai_objects)):
            if ai_objects[repeat_count].id == GameElements.BLUE_PIN:
                brain.screen.print(str("Closest Blue Pin is ") + str(object_count))
                break
            object_count = object_count + 1

# VR threads — Do not delete
vr_thread(main)

കൺസോൾ

ഒരു പ്രോജക്റ്റ് പ്രവർത്തിക്കുമ്പോൾ കൺസോൾ ടെക്സ്റ്റ്, നമ്പറുകൾ, വേരിയബിൾ മൂല്യങ്ങൾ എന്നിവ പ്രദർശിപ്പിക്കുന്നു. കൺസോൾ രീതികൾക്ക് കഴ്‌സർ ഒരു പുതിയ വരിയിലേക്ക് നീക്കാനും കൺസോൾ മായ്‌ക്കാനും മോണിറ്റർ ടാബിലേക്ക് വേരിയബിളുകളോ സെൻസർ മൂല്യങ്ങളോ ചേർക്കാനും കഴിയും.

അച്ചടിക്കുക

ബ്രെയിൻ.സ്ക്രീൻ.പ്രിന്റ്

brain.screen.print നിലവിലെ കഴ്‌സർ സ്ഥാനം ഉപയോഗിച്ച് കൺസോളിൽ ടെക്സ്റ്റ്, നമ്പറുകൾ അല്ലെങ്കിൽ വേരിയബിൾ മൂല്യങ്ങൾ പ്രദർശിപ്പിക്കുന്നു. ഇത് കൺസോൾ API പേജിൽ print പോലെ പ്രവർത്തിക്കുന്നു.

അടുത്ത പ്രിന്റ് ചെയ്ത മൂല്യം ഒരു പുതിയ വരിയിൽ ആരംഭിക്കണമെങ്കിൽ brain.screen.next_row ഉപയോഗിക്കുക.

Usage:
brain.screen.print(value)

പാരാമീറ്ററുകൾ	വിവരണം
value	കൺസോളിൽ പ്രദർശിപ്പിക്കേണ്ട വാചകം, നമ്പർ അല്ലെങ്കിൽ വേരിയബിൾ മൂല്യം.

def main():
    # Display a message in the Console
    brain.screen.print("Hello, robot!")

# VR threads — Do not delete
vr_thread(main)

ബ്രെയിൻ.സ്ക്രീൻ.അടുത്ത_വരി

brain.screen.next_row കൺസോളിലെ അടുത്ത വരിയിലെ കോളം 1 ലേക്ക് കഴ്‌സർ നീക്കുന്നു. പ്രിന്റ് ചെയ്‌ത അടുത്ത മൂല്യം ആ വരിയിൽ ദൃശ്യമാകും.

Usage:
brain.screen.next_row()

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

def main():
    # Print on two rows
    brain.screen.print("Row 1")
    brain.screen.next_row()
    brain.screen.print("Row 2")

# VR threads — Do not delete
vr_thread(main)

ബ്രെയിൻ.സ്ക്രീൻ.ക്ലിയർ_സ്ക്രീൻ

brain.screen.clear_screen കൺസോളിൽ നിന്ന് എല്ലാ വരികളും മായ്‌ക്കുകയും കഴ്‌സർ 1 വരിയിലേക്ക് തിരികെ നീക്കുകയും ചെയ്യുന്നു.

Usage:
brain.screen.clear_screen()

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

def main():
    # Display text, then clear it after two seconds
    brain.screen.print("This will disappear...")
    wait(2, SECONDS)
    brain.screen.clear_screen()

# VR threads — Do not delete
vr_thread(main)

മോണിറ്റർ

മോണിറ്റർ_വേരിയബിൾ

monitor_variable VEXcode-ലെ മോണിറ്റർ ടാബിലേക്ക് ഒന്നോ അതിലധികമോ മുൻകൂട്ടി നിശ്ചയിച്ച വേരിയബിളുകൾ ചേർക്കുന്നു. ഒരു പ്രോജക്റ്റ് പ്രവർത്തിക്കുമ്പോൾ ഒരു വേരിയബിളിന്റെ മൂല്യം മാറുന്നത് കാണാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

monitor_variable വിജയകരമായി നിരീക്ഷിക്കുന്നതിന് വേരിയബിളുകൾ ഗ്ലോബൽ ആയിരിക്കണം. ഓരോ വേരിയബിൾ നാമവും ഒരു സ്ട്രിംഗായി നൽകുക.

Usage:
monitor_variable(“variable”)
monitor_variable(“variable1”, “variable2”)

പാരാമീറ്ററുകൾ	വിവരണം
variable	നിരീക്ഷിക്കുന്നതിനായി മുൻകൂട്ടി നിശ്ചയിച്ച ഒരു ഗ്ലോബൽ വേരിയബിളിന്റെ പേര്, ഒരു സ്ട്രിംഗായി നൽകിയിരിക്കുന്നു. ഒന്നിലധികം വേരിയബിളുകൾ നിരീക്ഷിക്കാൻ, ഓരോ വേരിയബിൾ നാമവും കോമ ഉപയോഗിച്ച് വേർതിരിക്കുക.

def main():
    # Monitor the amount of loops
    global loops
    monitor_variable("loops")

    # Drive in a square 3 times
    for loops in range(12):
        drivetrain.turn_for(RIGHT, 90, DEGREES)
        drivetrain.drive_for(FORWARD, 150, MM)

# VR threads — Do not delete
vr_thread(main)

മോണിറ്റർ_സെൻസർ

monitor_sensor VEXcode-ലെ മോണിറ്റർ ടാബിലേക്ക് ഒന്നോ അതിലധികമോ സെൻസർ മൂല്യങ്ങൾ ചേർക്കുന്നു. ഒരു പ്രോജക്റ്റ് പ്രവർത്തിക്കുമ്പോൾ സെൻസർ മൂല്യങ്ങൾ മാറുന്നത് കാണാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

ഓരോ സെൻസർ മൂല്യവും ഒരു സ്ട്രിംഗായി നൽകുക.

Usage:
monitor_sensor(“sensor”)
monitor_sensor(“sensor1”, “sensor2”)

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

വിവരണം

sensor

The sensor value to monitor, given as a string. To monitor more than one sensor value, separate each sensor value with a comma. Supported sensor identifiers include: Brain brain.timer.time Drivetrain drivetrain.is_done drivetrain.is_moving drivetrain.heading drivetrain.rotation drivetrain.velocity Pusher Motor pusher_motor.is_done pusher_motor.is_spinning pusher_motor.position pusher_motor.velocity Arm Motor arm_motor.is_done arm_motor.is_spinning arm_motor.position arm_motor.velocity Front Distance Sensor front_distance.is_object_detected front_distance.object_distance_mm front_distance.object_distance_inches Front Optical Sensor front_optical.is_near_object front_optical.color front_optical.brightness front_optical.hue GPS Sensor gps.position_mm gps.position_inches gps.heading Pusher Rotation Sensor pusher_rotation.angle pusher_rotation.position AI Vision Sensor ai_vision.object_count ai_vision.height ai_vision.width ai_vision.centerX ai_vision.centerY ai_vision.originX ai_vision.originY ai_vision.id

def main():
    # Monitor the robot's heading
    monitor_sensor("drivetrain.heading")
    drivetrain.turn_for(RIGHT, 450, DEGREES)

# VR threads — Do not delete
vr_thread(main)

സെൻസിംഗ്

ടച്ച് LED

സെറ്റ്_കളർ

set_color ടച്ച് LED യുടെ നിറം സജ്ജമാക്കുന്നു.

Usage:
touchled.set_color(color)

പാരാമീറ്ററുകൾ	വിവരണം
color	ടച്ച് LED-യെ ഈ നിറത്തിലേക്ക് സജ്ജമാക്കേണ്ട നിറം: NONE - ടച്ച് LED ഓഫാക്കുന്നു RED GREEN BLUE YELLOW ORANGE PURPLE WHITE RED_VIOLET VIOLET BLUE_VIOLET BLUE_GREEN YELLOW_GREEN YELLOW_ORANGE RED_ORANGE

def main():
    # Light the Touch LED while placing a Pin.
    touchled.set_color(RED)
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)
    touchled.set_color(NONE)

# VR threads — Do not delete
vr_thread(main)

ഒപ്റ്റിക്കൽ

വസ്തുവിന്_സമീപമാണ്

is_near_object എന്നത് ഒപ്റ്റിക്കൽ സെൻസർ പരിധിക്കുള്ളിൽ ഒരു വസ്തുവിനെ കണ്ടെത്തുന്നുണ്ടോ ഇല്ലയോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു.

• True – ഒപ്റ്റിക്കൽ സെൻസർ ഒരു വസ്തുവിനെ കണ്ടെത്തുന്നു.

• False – ഒപ്റ്റിക്കൽ സെൻസർ ഒരു വസ്തുവിനെ കണ്ടെത്തുന്നില്ല.

Usage:
optical.is_near_object()

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

def main():
    # Wait until the claw no longer detects an object, then lower the lift.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)
    while optical.is_near_object():
        wait(2, MSEC)
    lift_motor.spin_to_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

നിറം

കണ്ടെത്തിയ ഹ്യൂ മൂല്യത്തെ അടിസ്ഥാനമാക്കി, color ഒരു Color ക്ലാസിന്റെ ഒരു ഉദാഹരണം നൽകുന്നു. കണ്ടീഷണൽ സ്റ്റേറ്റ്‌മെന്റുകൾ സൃഷ്ടിക്കുന്നതിന് ഇവയെ മുൻകൂട്ടി നിശ്ചയിച്ച Color ഒബ്‌ജക്റ്റുകളുമായി താരതമ്യം ചെയ്യാം.

സാധ്യമായ നിറങ്ങൾ ഇവയാണ്:

• NONE

• RED - 340° - 20° യ്ക്ക് ഇടയിലുള്ള ഒരു ഹ്യൂ മൂല്യം

• GREEN - 80° - 140° യ്ക്ക് ഇടയിലുള്ള ഒരു ഹ്യൂ മൂല്യം

• BLUE - 200° - 240° യ്ക്ക് ഇടയിലുള്ള ഒരു ഹ്യൂ മൂല്യം

• YELLOW - 40° - 60° യ്ക്ക് ഇടയിലുള്ള ഒരു ഹ്യൂ മൂല്യം

• ORANGE - 20° - 40° വരെയുള്ള ഒരു ഹ്യൂ മൂല്യം

• PURPLE - 240° - 280° യ്ക്ക് ഇടയിലുള്ള ഒരു ഹ്യൂ മൂല്യം

• CYAN - 140° - 200° യ്ക്ക് ഇടയിലുള്ള ഒരു ഹ്യൂ മൂല്യം

കുറിപ്പ്: ഒപ്റ്റിക്കൽ സെൻസർ നിർദ്ദിഷ്ട നിറവുമായി പൊരുത്തപ്പെടുന്ന ഹ്യൂ ശ്രേണികൾക്കായി തിരയുന്നു. നിർദ്ദിഷ്ട ഹ്യൂ ശ്രേണികൾ കണ്ടെത്തുന്നതിന്, hue കാണുക.

Usage:
optical.color()

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

def main():
    # Wait until the Optical Sensor detects red, then lower the lift.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)
    while not optical.color() == RED:
        wait(5, MSEC)
    lift_motor.spin_to_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

തെളിച്ചം

brightness വസ്തുവിൽ നിന്ന് പ്രതിഫലിക്കുന്ന പ്രകാശത്തിന്റെ അളവ് ഒരു ദശാംശമായി (float) നൽകുന്നു, ഇത് ഒരു ശതമാനത്തെ പ്രതിനിധീകരിക്കുന്നു.

ഉയർന്ന ശതമാനം എന്നാൽ കൂടുതൽ പ്രകാശം ഒപ്റ്റിക്കൽ സെൻസറിലേക്ക് പ്രതിഫലിക്കുന്നു എന്നാണ്. കുറഞ്ഞ ശതമാനം എന്നാൽ കുറഞ്ഞ പ്രകാശം തിരികെ പ്രതിഫലിക്കുന്നു എന്നാണ്.

Usage:
optical.brightness()

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

def main():
    # Lower the lift once the claw sees a darker object.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)
    while not 30 > optical.brightness():
        wait(5, MSEC)
    lift_motor.spin_to_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

നിറം

hue കണ്ടെത്തിയ നിറത്തിന്റെ hue മൂല്യം 0 മുതൽ 359 വരെ ഒരു ദശാംശമായി (float) നൽകുന്നു.

വർണ്ണചക്രത്തിന് ചുറ്റുമുള്ള അക്കങ്ങൾ ഉപയോഗിച്ച് നിറങ്ങളെ വിവരിക്കുന്നതിനുള്ള ഒരു മാർഗമാണ് ഹ്യൂ.

Usage:
optical.hue()

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

def main():
    # Lower the lift once the Optical Sensor reports a hue value.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)
    while not optical.hue() > 0:
        wait(5, MSEC)
    lift_motor.spin_to_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

ഒബ്ജക്റ്റ്_ഡിറ്റക്റ്റഡ്

object_detected എന്നത് ഒപ്റ്റിക്കൽ സെൻസർ ഒരു പുതിയ വസ്തുവിനെ കണ്ടെത്തുമ്പോഴെല്ലാം വിളിക്കേണ്ട ഒരു ഫംഗ്‌ഷൻ രജിസ്റ്റർ ചെയ്യുന്നു.

Usage:
optical.object_detected(callback, arg)

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

def pin_in_claw():
    touchled.set_color(RED)

def main():
    # Change the Touch LED color when the claw detects an object.
    optical.object_detected(pin_in_claw)
    touchled.set_color(GREEN)
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

വസ്തു_നഷ്ടപ്പെട്ടു

ഒപ്റ്റിക്കൽ സെൻസർ കണ്ടെത്തിയ ഒരു വസ്തു നഷ്ടപ്പെടുമ്പോഴെല്ലാം വിളിക്കേണ്ട ഒരു ഫംഗ്ഷൻ object_lost രജിസ്റ്റർ ചെയ്യുന്നു.

Usage:
optical.object_lost(callback, arg)

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

def lower_lift():
    # Lower the lift when the claw no longer holds an object.
    lift_motor.spin_to_position(0, DEGREES)

def main():
    optical.object_lost(lower_lift)
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)