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

ആമുഖം#

ഹീറോ ബോട്ട്, ഡിസ്കോ, ഒരു മോട്ടോർ ഗ്രൂപ്പ്, ലൈൻ ട്രാക്കർ, ഒപ്റ്റിക്കൽ സെൻസർ, ഗെയിം പൊസിഷനിംഗ് സിസ്റ്റം (ജിപിഎസ്) സെൻസർ എന്നിവ ഉൾക്കൊള്ളുന്നു.

V5 22-23 സ്പിൻ അപ്പ് പ്ലേഗ്രൗണ്ടിൽ ഉപയോഗിക്കാൻ എല്ലാ സ്റ്റാൻഡേർഡ് 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 — മോട്ടോർ ഗ്രൂപ്പ് എത്ര വേഗത്തിൽ കറങ്ങുന്നുവെന്ന് നൽകുന്നു.

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

  • പ്രിന്റ്

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

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

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

  • മോണിറ്റർ

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

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

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

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

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

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

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

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

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

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

  • ജിപിഎസ്

    • x_position – ഫീൽഡിലെ ഒരു GPS സെൻസറിന്റെ നിലവിലെ x കോർഡിനേറ്റ് തിരികെ നൽകുന്നു.

    • y_position – ഫീൽഡിലെ ഒരു GPS സെൻസറിന്റെ നിലവിലെ y കോർഡിനേറ്റ് നൽകുന്നു.

    • heading – GPS സെൻസറിന്റെ 0 മുതൽ 359 ഡിഗ്രി വരെയുള്ള റീഡിംഗുകളെ അടിസ്ഥാനമാക്കി റോബോട്ട് നിലവിൽ അഭിമുഖീകരിക്കുന്ന തലക്കെട്ട് നൽകുന്നു.

  • ലൈൻ ട്രാക്കർ

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

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

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

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 ഒരു മോട്ടോർ ഗ്രൂപ്പിനെ എന്നെന്നേക്കുമായി മുന്നോട്ടോ പിന്നോട്ടോ കറക്കുന്നു. മറ്റൊരു ദിശയിലേക്ക് കറങ്ങുകയോ നിർത്തുകയോ പോലുള്ള മറ്റൊരു പ്രവർത്തനം നൽകുന്നതുവരെ മോട്ടോർ ഗ്രൂപ്പ് കറങ്ങിക്കൊണ്ടിരിക്കും.

Usage:
intake_motor_group.spin(direction)

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

വിവരണം

direction

മോട്ടോർ ഗ്രൂപ്പ് കറങ്ങുന്ന ദിശ:

  • FORWARD — ഇൻടേക്ക് ദിശയിൽ കറങ്ങുന്നു.
  • REVERSE — ഔട്ട്ടേക്ക് ദിശയിൽ കറങ്ങുന്നു.

 
def main():
    # Spin the intake forward then stop
    intake_motor_group.spin(FORWARD)
    wait(0.5, SECONDS)
    intake_motor_group.stop()

# VR threads — Do not delete
vr_thread(main)

സ്പിൻ_ഫോർ#

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

Usage:
intake_motor_group.spin_for(direction, distance, units, wait)

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

വിവരണം

direction

മോട്ടോർ ഗ്രൂപ്പ് കറങ്ങുന്ന ദിശ:

  • FORWARD — ഇൻടേക്ക് ദിശയിൽ കറങ്ങുന്നു.
  • REVERSE — ഔട്ട്ടേക്ക് ദിശയിൽ കറങ്ങുന്നു.

distance

മോട്ടോർ ഗ്രൂപ്പ് കറങ്ങുന്ന ദൂരം. DEGREES പൂർണ്ണസംഖ്യകൾ ഉപയോഗിക്കുന്നു. TURNS പൂർണ്ണസംഖ്യകളോ ദശാംശങ്ങളോ ഉപയോഗിക്കാം.

units

ഓപ്ഷണൽ. ദൂര യൂണിറ്റ്: DEGREES (സ്ഥിരസ്ഥിതി) അല്ലെങ്കിൽ TURNS.

wait

ഓപ്ഷണൽ.

  • wait=True (ഡിഫോൾട്ട്) — കോഡിന്റെ അടുത്ത വരി പ്രവർത്തിക്കുന്നതിന് മുമ്പ് മോട്ടോർ ഗ്രൂപ്പ് കറങ്ങുന്നത് വരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ അനുവദിക്കുന്നു.
  • wait=False — കോഡിന്റെ അടുത്ത വരി ഉടനടി പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുന്നു.

 
def main():
    # Spin the intake forward then stop
    intake_motor_group.spin_for(FORWARD, 360, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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

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

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

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

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

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

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

വിവരണം

angle

മോട്ടോർ ഗ്രൂപ്പ് കറങ്ങുന്ന സ്ഥാന മൂല്യം. DEGREES പൂർണ്ണസംഖ്യകൾ ഉപയോഗിക്കുന്നു. TURNS പൂർണ്ണസംഖ്യകളോ ദശാംശങ്ങളോ ഉപയോഗിക്കാം.

units

ഓപ്ഷണൽ. സ്ഥാന യൂണിറ്റ്: DEGREES (സ്ഥിരസ്ഥിതി) അല്ലെങ്കിൽ TURNS.

wait

ഓപ്ഷണൽ.

  • wait=True (ഡിഫോൾട്ട്) — കോഡിന്റെ അടുത്ത വരി പ്രവർത്തിക്കുന്നതിന് മുമ്പ് മോട്ടോർ ഗ്രൂപ്പ് കറങ്ങുന്നത് വരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ അനുവദിക്കുന്നു.
  • wait=False — കോഡിന്റെ അടുത്ത വരി ഉടനടി പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുന്നു.

 
def main():
    # Spin the intake forward then stop
    intake_motor_group.spin_to_position(55, DEGREES)

# VR threads — Do not delete
vr_thread(main)

നിർത്തുക#

stop ഒരു മോട്ടോർ ഗ്രൂപ്പിനെ കറങ്ങുന്നതിൽ നിന്ന് തടയുന്നു.

Usage:
intake_motor_group.stop()

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

വിവരണം

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

 
def main():
    # Spin the intake forward then stop
    intake_motor_group.spin(FORWARD)
    wait(0.5, SECONDS)
    intake_motor_group.stop()

# VR threads — Do not delete
vr_thread(main)

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

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

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

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

Usage:
intake_motor_group.set_position(position, units)

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

വിവരണം

position

മോട്ടോർ ഗ്രൂപ്പിനായി സജ്ജമാക്കേണ്ട സ്ഥാന മൂല്യം. DEGREES പൂർണ്ണസംഖ്യകൾ ഉപയോഗിക്കുന്നു. TURNS പൂർണ്ണസംഖ്യകളോ ദശാംശങ്ങളോ ഉപയോഗിക്കാം.

units

ഓപ്ഷണൽ. സ്ഥാന യൂണിറ്റ്: DEGREES (സ്ഥിരസ്ഥിതി) അല്ലെങ്കിൽ TURNS.

 
def main():
    # Spin the intake forward then stop
    intake_motor_group.set_position(90, DEGREES)
    intake_motor_group.spin_to_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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

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

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

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

Usage:
intake_motor_group.set_velocity(velocity, units)

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

വിവരണം

velocity

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

units

പ്രവേഗ യൂണിറ്റ്: PERCENT.

 
def main():
    # Spin the intake forward then stop
    intake_motor_group.set_velocity(75, PERCENT)
    intake_motor_group.spin_to_position(180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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

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

Usage:
intake_motor_group.set_timeout(value, units)

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

വിവരണം

value

മോട്ടോർ ഗ്രൂപ്പിന് ഒരു ചലനം പൂർത്തിയാക്കാൻ ശ്രമിക്കാൻ കഴിയുന്ന സമയം. ഇത് ഒരു പോസിറ്റീവ് integer അല്ലെങ്കിൽ ദശാംശം ആകാം (float).

units

സമയ യൂണിറ്റ്: SECONDS അല്ലെങ്കിൽ MSEC (മില്ലിസെക്കൻഡ്).

 
def main():
    # Spin the intake forward then stop
    intake_motor_group.set_timeout(2, SECONDS)
    intake_motor_group.spin_to_position(270, DEGREES)

# VR threads — Do not delete
vr_thread(main)

ഗെറ്ററുകൾ#

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

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

  • True — മോട്ടോർ ഗ്രൂപ്പ് നീങ്ങുന്നത് പൂർത്തിയായി.

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

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

Usage:
intake_motor_group.is_done()

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

വിവരണം

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

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

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

  • True — മോട്ടോർ ഗ്രൂപ്പ് കറങ്ങിക്കൊണ്ടിരിക്കുന്നു.

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

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

Usage:
intake_motor_group.is_spinning()

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

വിവരണം

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

സ്ഥാനം#

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

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

Usage:
intake_motor_group.position(units)

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

വിവരണം

units

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

വേഗത#

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

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

Usage:
intake_motor_group.velocity(units)

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

വിവരണം

units

നൽകേണ്ട പ്രവേഗ യൂണിറ്റ്: PERCENT.

കൺസോൾ#

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

അച്ചടിക്കുക#

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

brain.screen.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)

VEXcode കൺസോൾ, കൺസോൾ കാണിക്കുന്നതും "ഹലോ, റോബോട്ട്!" എന്ന വാചകവും പ്രദർശിപ്പിക്കുന്നു.

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

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)

VEXcode കൺസോൾ, കൺസോൾ, ആദ്യ വരിയിൽ "വരി 1" എന്നും രണ്ടാമത്തെ വരിയിൽ "വരി 2" എന്നും കാണിച്ചിരിക്കുന്നു.

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

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

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

  • ബ്രെയിൻ
    • brain.timer.time
  • ഡ്രൈവ്ട്രെയിൻ
    • drivetrain.is_done
    • drivetrain.is_moving
    • drivetrain.heading
    • drivetrain.rotation
    • drivetrain.velocity_rpm
    • drivetrain.velocity_percent
  • ഇൻടേക്ക് മോട്ടോർ ഗ്രൂപ്പ്
    • intake_motor_group.is_done
    • intake_motor_group.is_spinning
    • intake_motor_group.position_degrees
    • intake_motor_group.position_turns
    • intake_motor_group.velocity_rpm
    • intake_motor_group.velocity_percent
  • ഫോർക്ക് മോട്ടോർ ഗ്രൂപ്പ്
    • fork_motor_group.is_done
    • fork_motor_group.is_spinning
    • fork_motor_group.position_degrees
    • fork_motor_group.position_turns
    • fork_motor_group.velocity_rpm
    • fork_motor_group.velocity_percent
  • താഴെയുള്ള ദൂര സെൻസർ
    • bottom_distance.is_object_detected
    • bottom_distance.object_distance_mm
    • bottom_distance.object_distance_inches
  • ഇടത് ദൂര സെൻസർ
    • left_distance.is_object_detected
    • left_distance.object_distance_mm
    • left_distance.object_distance_inches
  • സെന്റർ ദൂര സെൻസർ
    • center_distance.is_object_detected
    • center_distance.object_distance_mm
    • center_distance.object_distance_inches
  • Right Distance Sensor
    • right_distance.is_object_detected
    • right_distance.object_distance_mm
    • right_distance.object_distance_inches
  • Line Trackers
    • bottom_line_tracker.reflectivity
    • middle_line_tracker.reflectivity
    • top_line_tracker.reflectivity
  • റോളർ ഒപ്റ്റിക്കൽ സെൻസർ
    • roller_optical.is_near_object
    • roller_optical.color
    • roller_optical.brightness
    • roller_optical.hue
  • ഒപ്റ്റിക്കൽ സെൻസർ
    • optical.is_near_object
    • optical.color
    • optical.brightness
    • optical.hue
  • GPS സെൻസർ
    • gps.position_mm
    • gps.position_inches
    • gps.heading
  • റൊട്ടേഷൻ സെൻസർ
    • rotation.angle
    • rotation.position

 
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)

സെൻസിംഗ്#

ഒപ്റ്റിക്കൽ#

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

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

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

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

Usage:
roller_optical.is_near_object()

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

വിവരണം

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

നിറം#

കണ്ടെത്തിയ ഹ്യൂ മൂല്യത്തെ അടിസ്ഥാനമാക്കി, 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:
roller_optical.color()

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

വിവരണം

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

തെളിച്ചം#

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

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

Usage:
roller_optical.brightness()

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

വിവരണം

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

നിറം#

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

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

മുകളിൽ 0° മുതൽ 360° വരെ 30-ഡിഗ്രി വർദ്ധനവിൽ വർദ്ധിക്കുന്ന, ചുറ്റളവിന് ചുറ്റും ഡിഗ്രി മൂല്യങ്ങൾ ലേബൽ ചെയ്ത നിറങ്ങളുടെ പൂർണ്ണ സ്പെക്ട്രം പ്രദർശിപ്പിക്കുന്ന ഒരു വൃത്താകൃതിയിലുള്ള വർണ്ണ ചക്രം.

Usage:
roller_optical.hue()

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

വിവരണം

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

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

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

Usage:
roller_optical.object_detected(callback, arg)

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

വിവരണം

callback

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

arg

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

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

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

Usage:
roller_optical.object_lost(callback, arg)

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

വിവരണം

callback

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

arg

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

ജിപിഎസ്#

x_സ്ഥാനം#

x_position ഫീൽഡിലെ ഒരു GPS (ഗെയിം പൊസിഷനിംഗ് സിസ്റ്റം™) സെൻസറിന്റെ നിലവിലെ x കോർഡിനേറ്റ് തിരികെ നൽകുന്നു.

Usage:
gps.x_position(units)

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

വിവരണം

യൂണിറ്റുകൾ

ഓഫ്‌സെറ്റ് മൂല്യത്തിന്റെ യൂണിറ്റ്: INCHES അല്ലെങ്കിൽ MM

y_സ്ഥാനം#

y_position ഫീൽഡിലെ ഒരു GPS (ഗെയിം പൊസിഷനിംഗ് സിസ്റ്റം™) സെൻസറിന്റെ നിലവിലെ y കോർഡിനേറ്റ് തിരികെ നൽകുന്നു.

Usage:
gps.y_position(units)

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

വിവരണം

യൂണിറ്റുകൾ

ഓഫ്‌സെറ്റ് മൂല്യത്തിന്റെ യൂണിറ്റ്: INCHES അല്ലെങ്കിൽ MM

തലക്കെട്ട്#

heading , GPS (ഗെയിം പൊസിഷനിംഗ് സിസ്റ്റം™) സെൻസറിന്റെ 0 മുതൽ 359 ഡിഗ്രി വരെയുള്ള റീഡിംഗുകളെ അടിസ്ഥാനമാക്കി റോബോട്ട് നിലവിൽ അഭിമുഖീകരിക്കുന്ന തലക്കെട്ട് നൽകുന്നു.

Usage:
gps.heading()

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

വിവരണം

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

ലൈൻ ട്രാക്കർ#

പ്രതിഫലനശേഷി#

reflectivity ഉപരിതലത്തിൽ നിന്ന് പ്രതിഫലിക്കുന്ന പ്രകാശത്തിന്റെ അളവിനെ ഒരു ശതമാനമായി പ്രതിനിധീകരിക്കുന്ന ഒരു പൂർണ്ണസംഖ്യ നൽകുന്നു.

  • 0% പ്രതിഫലനം എന്നാൽ വസ്തു വളരെ ഇരുണ്ടതാണെന്ന് അർത്ഥമാക്കുന്നു.

  • 100% പ്രതിഫലനം എന്നാൽ വസ്തു വളരെ തിളക്കമുള്ളതാണെന്ന് അർത്ഥമാക്കുന്നു.

ഉപയോഗം:
താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ, ഈ രീതി ഉപയോഗിച്ച് ലഭ്യമായ മൂന്ന് line_tracker ഒബ്‌ജക്റ്റുകളിൽ ഒന്ന് ഉപയോഗിക്കാം:

ലൈൻ_ട്രാക്കർ

കമാൻഡ്

top_line_tracker

top_line_tracker.reflectivity(units) — ടോപ്പ് ലൈൻ ട്രാക്കർ

middle_line_tracker

middle_line_tracker.reflectivity(units) — മിഡിൽ ലൈൻ ട്രാക്കർ

bottom_line_tracker

bottom_line_tracker.reflectivity(units) — ബോട്ടം ലൈൻ ട്രാക്കർ

പാരാമീറ്റർ

വിവരണം

യൂണിറ്റുകൾ

ഓപ്ഷണൽ. പ്രതിഫലനം തിരികെ നൽകേണ്ട യൂണിറ്റ്:

  • PERCENT (സ്ഥിരസ്ഥിതി)
On this page