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

ആമുഖം #

ഹീറോ ബോട്ട്, സ്നാപ്പ്ഷോട്ടിൽ രണ്ട് മോട്ടോർ ഓപ്ഷനുകളും ഒപ്റ്റിക്കൽ സെൻസറും ഉൾപ്പെടുന്നു.

IQ 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 — മോട്ടോർ എത്ര വേഗത്തിൽ കറങ്ങുന്നുവെന്ന് നൽകുന്നു.

ഇവന്റുകൾ - ഒരു സെൻസർ അവസ്ഥ മാറുമ്പോൾ കോഡ് പ്രവർത്തിപ്പിക്കുക.

ബമ്പർ
- pressed - ഇൻടേക്ക് ബമ്പർ അമർത്തുമ്പോൾ ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ രജിസ്റ്റർ ചെയ്യുന്നു.
- released - ഇൻടേക്ക് ബമ്പർ റിലീസ് ചെയ്യുമ്പോൾ ഒരു കോൾബാക്ക് ഫംഗ്‌ഷൻ രജിസ്റ്റർ ചെയ്യുന്നു.
ഒപ്റ്റിക്കൽ
- object_detected – ഒപ്റ്റിക്കൽ സെൻസർ ഒരു വസ്തുവിനെ കണ്ടെത്തുമ്പോൾ വിളിക്കേണ്ട ഒരു ഫംഗ്ഷൻ രജിസ്റ്റർ ചെയ്യുന്നു.
- object_lost – ഒപ്റ്റിക്കൽ സെൻസർ ഒരു വസ്തു നഷ്ടപ്പെടുമ്പോൾ വിളിക്കേണ്ട ഒരു ഫംഗ്ഷൻ രജിസ്റ്റർ ചെയ്യുന്നു.

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

പ്രിന്റ്
- brain.screen.print — കൺസോളിൽ ടെക്സ്റ്റ്, നമ്പറുകൾ അല്ലെങ്കിൽ വേരിയബിൾ മൂല്യങ്ങൾ പ്രദർശിപ്പിക്കുന്നു.
- brain.screen.next_row — കൺസോൾ കഴ്‌സർ അടുത്ത വരിയുടെ തുടക്കത്തിലേക്ക് നീക്കുന്നു.
- brain.screen.clear_screen — കൺസോളിൽ നിന്ന് എല്ലാ വരികളും മായ്‌ക്കുന്നു.
മോണിറ്റർ
- monitor_variable — മോണിറ്റർ ടാബിലേക്ക് ഒന്നോ അതിലധികമോ മുൻകൂട്ടി നിശ്ചയിച്ച വേരിയബിളുകൾ ചേർക്കുന്നു.
- monitor_sensor — മോണിറ്റർ ടാബിലേക്ക് ഒന്നോ അതിലധികമോ സെൻസർ മൂല്യങ്ങൾ ചേർക്കുന്നു.

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

ബമ്പർ
- pressingഅമർത്തുന്നു - ഇൻടേക്ക് ബമ്പർ നിലവിൽ അമർത്തിയോ എന്ന് നൽകുന്നു.
ഒപ്റ്റിക്കൽ
- is_near_object – Returns whether the Optical Sensor detects an object within range.
- color – ഒപ്റ്റിക്കൽ സെൻസർ കണ്ടെത്തിയ നിറം നൽകുന്നു.
- brightness – വസ്തുവിൽ നിന്ന് പ്രതിഫലിക്കുന്ന പ്രകാശത്തിന്റെ അളവ് നൽകുന്നു.
- hue – ഒപ്റ്റിക്കൽ സെൻസർ കണ്ടെത്തിയ നിറം തിരികെ നൽകുന്നു.

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

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

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

മോട്ടോർ	കമാൻഡ്
`intake_motor`	`intake_motor.spin(direction)` — ഇൻടേക്ക് മോട്ടോർ
`arm_motor`	`arm_motor.spin(direction)` — ആം മോട്ടോർ

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

വിവരണം

direction

മോട്ടോർ കറങ്ങുന്ന ദിശ:

FORWARD — ഇൻടേക്ക് മോട്ടോർ ഇൻടേക്ക് ദിശയിൽ കറക്കുന്നു അല്ലെങ്കിൽ ആം മോട്ടോർ ഉയർത്തുന്നു.
REVERSE — ഔട്ട്ടേക്ക് ദിശയിൽ ഇൻടേക്ക് മോട്ടോർ കറക്കുന്നു അല്ലെങ്കിൽ ആം മോട്ടോർ താഴ്ത്തുന്നു.

def main():
    # Spin the Intake Motor to collect a Disc
    intake_motor.spin(FORWARD)
    wait(1, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

സ്പിൻ_ഫോർ #

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

മോട്ടോർ	കമാൻഡ്
`intake_motor`	`intake_motor.spin_for(direction, distance, units, wait=True)` — ഇൻടേക്ക് മോട്ടോർ
`arm_motor`	`arm_motor.spin_for(direction, distance, units, wait=True)` — ആം മോട്ടോർ

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

def main():
    # Collect the preloaded Disc
    intake_motor.spin_for(FORWARD, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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

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

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

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

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

മോട്ടോർ	കമാൻഡ്
`intake_motor`	`intake_motor.spin_to_position(angle, units, wait=True)` — ഇൻടേക്ക് മോട്ടോർ
`arm_motor`	`arm_motor.spin_to_position(angle, units, wait=True)` — ആം മോട്ടോർ

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

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

വിവരണം

angle

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

units

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

wait

ഓപ്ഷണൽ.

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

def main():
    # Raise the Arm to reach over the barrier
    arm_motor.spin_to_position(600, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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

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

മോട്ടോർ	കമാൻഡ്
`intake_motor`	`intake_motor.stop()` — ഇൻടേക്ക് മോട്ടോർ
`arm_motor`	`arm_motor.stop()` — ആം മോട്ടോർ

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

def main():
    # Raise the Arm briefly, then stop it
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_motor.stop()

# VR threads — Do not delete
vr_thread(main)

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

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

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

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

മോട്ടോർ	കമാൻഡ്
`intake_motor`	`intake_motor.set_position(position, units)` — ഇൻടേക്ക് മോട്ടോർ
`arm_motor`	`arm_motor.set_position(position, units)` — ആം മോട്ടോർ

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

def main():
    # Set the Intake Motor position, then return to 0 degrees
    intake_motor.set_position(180, DEGREES)
    intake_motor.spin_to_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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

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

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

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

മോട്ടോർ	കമാൻഡ്
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — ഇൻടേക്ക് മോട്ടോർ
`arm_motor`	`arm_motor.set_velocity(velocity, units)` — ആം മോട്ടോർ

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

def main():
    # Set the Intake Motor speed before collecting a Disc
    intake_motor.set_velocity(75, PERCENT)
    intake_motor.spin_for(FORWARD, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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

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

മോട്ടോർ	കമാൻഡ്
`intake_motor`	`intake_motor.set_timeout(value, units)` — ഇൻടേക്ക് മോട്ടോർ
`arm_motor`	`arm_motor.set_timeout(value, units)` — ആം മോട്ടോർ

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

def main():
    # Limit how long the Arm Motor waits to reach its target
    arm_motor.set_timeout(2, SECONDS)
    arm_motor.spin_for(FORWARD, 1080, DEGREES)

# VR threads — Do not delete
vr_thread(main)

ഗെറ്ററുകൾ #

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

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

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

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

മോട്ടോർ	കമാൻഡ്
`intake_motor`	`intake_motor.is_done()` — ഇൻടേക്ക് മോട്ടോർ
`arm_motor`	`arm_motor.is_done()` — ആം മോട്ടോർ

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

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

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

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

മോട്ടോർ	കമാൻഡ്
`intake_motor`	`intake_motor.is_spinning()` — ഇൻടേക്ക് മോട്ടോർ
`arm_motor`	`arm_motor.is_spinning()` — ആം മോട്ടോർ

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

സ്ഥാനം #

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

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

മോട്ടോർ	കമാൻഡ്
`intake_motor`	`intake_motor.position(units)` — intake മോട്ടോർ
`arm_motor`	`arm_motor.position(units)` — ആം മോട്ടോർ

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

def main():
    # Print the current Arm Motor position
    brain.screen.print(arm_motor.position(DEGREES))

# VR threads — Do not delete
vr_thread(main)

വേഗത #

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

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

മോട്ടോർ	കമാൻഡ്
`intake_motor`	`intake_motor.velocity(units)` — intake മോട്ടോർ
`arm_motor`	`arm_motor.velocity(units)` — ആം മോട്ടോർ

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

def main():
    # Print the current Intake Motor velocity
    brain.screen.print(intake_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

ഇവന്റുകൾ #

ബമ്പർ #

അമർത്തി #

pressed ഇൻടേക്ക് ബമ്പർ അമർത്തുമ്പോൾ ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ രജിസ്റ്റർ ചെയ്യുന്നു.

Usage:
intake_bumper.pressed(callback)

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

def stop_intake():
    intake_motor.stop()

def main():
    # Stop the Intake Motor when a Disc reaches the Intake Bumper
    intake_bumper.pressed(stop_intake)
    intake_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

പുറത്തിറങ്ങി #

ഇൻടേക്ക് ബമ്പർ റിലീസ് ചെയ്യുമ്പോൾ released ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ രജിസ്റ്റർ ചെയ്യുന്നു.

Usage:
intake_bumper.released(callback)

പാരാമീറ്ററുകൾ	വിവരണം
`callback`	ഇൻടേക്ക് ബമ്പർ റിലീസ് ചെയ്യുമ്പോൾ വിളിക്കപ്പെടുന്ന ഒരു ഫംഗ്ഷൻ.

def lower_arm():
    arm_motor.spin_to_position(0, DEGREES)

def main():
    # Lower the Arm when the Intake Bumper is released
    intake_bumper.released(lower_arm)

# VR threads — Do not delete
vr_thread(main)

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

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

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

Usage:
front_optical.object_detected(callback, arg)

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

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

വിവരണം

callback

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

arg

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

def stop_intake():
    intake_motor.stop()

def main():
    # Stop the Intake Motor when the Optical Sensor detects a Disc
    front_optical.object_detected(stop_intake)
    intake_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

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

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

Usage:
front_optical.object_lost(callback, arg)

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

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

വിവരണം

callback

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

arg

def resume_intake():
    intake_motor.spin(FORWARD)

def main():
    # Restart the Intake Motor when the Optical Sensor no longer detects a Disc
    front_optical.object_lost(resume_intake)

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

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`	നിരീക്ഷിക്കുന്നതിനായി മുൻകൂട്ടി നിശ്ചയിച്ച ഒരു ഗ്ലോബൽ വേരിയബിളിന്റെ പേര്, ഒരു സ്ട്രിംഗായി നൽകിയിരിക്കുന്നു. ഒന്നിലധികം വേരിയബിളുകൾ നിരീക്ഷിക്കാൻ, ഓരോ വേരിയബിൾ നാമവും കോമ ഉപയോഗിച്ച് വേർതിരിക്കുക.

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

വിവരണം

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_rpm` `drivetrain.velocity_percent` Arm Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position_degrees` `arm_motor.position_turns` `arm_motor.velocity_rpm` `arm_motor.velocity_percent` Arm Motor Group `arm_motor_group.is_done` `arm_motor_group.is_spinning` `arm_motor_group.position_degrees` `arm_motor_group.position_turns` `arm_motor_group.velocity_rpm` `arm_motor_group.velocity_percent` Intake Motor `intake_motor.is_done` `intake_motor.is_spinning` `intake_motor.position_degrees` `intake_motor.position_turns` `intake_motor.velocity_rpm` `intake_motor.velocity_percent` Intake Motor Group `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` Catapult Motor `catapult_motor.is_done` `catapult_motor.is_spinning` `catapult_motor.position_degrees` `catapult_motor.position_turns` `catapult_motor.velocity_rpm` `catapult_motor.velocity_percent` Catapult Tension Motor `catapult_tension_motor.is_done` `catapult_tension_motor.is_spinning` `catapult_tension_motor.position_degrees` `catapult_tension_motor.position_turns` `catapult_tension_motor.velocity_rpm` `catapult_tension_motor.velocity_percent` Bumpers `intake_bumper.pressing` `bumper.pressing` 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` Color Sensor `color.is_near_object` `color.color` `color.brightness` `color.hue`

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

വിവരണം

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_rpm
- drivetrain.velocity_percent
Arm Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position_degrees
- arm_motor.position_turns
- arm_motor.velocity_rpm
- arm_motor.velocity_percent
Arm Motor Group
- arm_motor_group.is_done
- arm_motor_group.is_spinning
- arm_motor_group.position_degrees
- arm_motor_group.position_turns
- arm_motor_group.velocity_rpm
- arm_motor_group.velocity_percent
Intake Motor
- intake_motor.is_done
- intake_motor.is_spinning
- intake_motor.position_degrees
- intake_motor.position_turns
- intake_motor.velocity_rpm
- intake_motor.velocity_percent
Intake Motor Group
- 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
Catapult Motor
- catapult_motor.is_done
- catapult_motor.is_spinning
- catapult_motor.position_degrees
- catapult_motor.position_turns
- catapult_motor.velocity_rpm
- catapult_motor.velocity_percent
Catapult Tension Motor
- catapult_tension_motor.is_done
- catapult_tension_motor.is_spinning
- catapult_tension_motor.position_degrees
- catapult_tension_motor.position_turns
- catapult_tension_motor.velocity_rpm
- catapult_tension_motor.velocity_percent
Bumpers
- intake_bumper.pressing
- bumper.pressing
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
Color Sensor
- color.is_near_object
- color.color
- color.brightness
- color.hue

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)

സെൻസിംഗ്#

ബമ്പർ #

അമർത്തുന്നു #

pressing അമർത്തുമ്പോൾ, ഇൻടേക്ക് ബമ്പർ നിലവിൽ അമർത്തിയോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ തിരികെ നൽകുന്നു.

True - ഇൻടേക്ക് ബമ്പർ അമർത്തി.
False - ഇൻടേക്ക് ബമ്പർ അമർത്തിയിട്ടില്ല.

Usage:
intake_bumper.pressing()

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

def main():
    # Print whether the Intake Bumper is pressed
    brain.screen.print(intake_bumper.pressing())

# VR threads — Do not delete
vr_thread(main)

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

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

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

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

Usage:
front_optical.is_near_object()

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

def main():
    # Print whether the Front Optical Sensor detects a nearby Disc
    brain.screen.print(front_optical.is_near_object())

# 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:
front_optical.color()

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

def main():
    # Print the color detected by the Front Optical Sensor
    brain.screen.print(front_optical.color())

# VR threads — Do not delete
vr_thread(main)

തെളിച്ചം #

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

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

Usage:
front_optical.brightness()

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

def main():
    # Print the Front Optical Sensor brightness
    brain.screen.print(front_optical.brightness())

# VR threads — Do not delete
vr_thread(main)

നിറം #

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

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

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

Usage:
front_optical.hue()

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

def main():
    # Print the hue detected by the Front Optical Sensor
    brain.screen.print(front_optical.hue())

# VR threads — Do not delete
vr_thread(main)