ചലനം#

ആമുഖം #

VEX AIM കോഡിംഗ് റോബോട്ട് മുന്നോട്ട്, പിന്നോട്ട്, ഇടത്തോട്ടോ വലത്തോട്ടോ അല്ലെങ്കിൽ ഒരു കോണിലോ നീങ്ങാൻ ഒരു ഹോളോണമിക് ഡ്രൈവ്ട്രെയിൻ ഉപയോഗിക്കുന്നു, അതേസമയം സ്വതന്ത്രമായി തിരിയാനും കഴിയും. റോബോട്ട് എങ്ങനെ ചലിക്കുകയും തിരിയുകയും ചെയ്യുന്നു, എത്ര വേഗത്തിൽ നീങ്ങുന്നു, അതിന്റെ x, y സ്ഥാനം എങ്ങനെ ട്രാക്ക് ചെയ്യപ്പെടുന്നു എന്നിവ ചലന രീതികളാണ് നിയന്ത്രിക്കുന്നത്.

നേവി ബ്ലൂ സ്‌ക്രീനുള്ള ഇരുണ്ട ചാരനിറത്തിലുള്ള ഡിസ്‌പ്ലേയെ ചുറ്റിപ്പറ്റി 0 മുതൽ 315 ഡിഗ്രി വരെയുള്ള വൃത്താകൃതിയിലുള്ള കോമ്പസ് ഡയൽ. കോമ്പസ് ഡയലിൽ റോബോട്ടിന്റെ മുൻഭാഗം 0 ഡിഗ്രി അഭിമുഖീകരിക്കുന്നു.

ലഭ്യമായ രീതികളുടെ ഒരു ലിസ്റ്റ് താഴെ കൊടുക്കുന്നു:

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

move_at — റോബോട്ടിനെ ഒരു പ്രത്യേക കോണിൽ എന്നെന്നേക്കുമായി നീക്കുന്നു.
move_for — ഒരു പ്രത്യേക ദൂരത്തേക്ക് ഒരു പ്രത്യേക കോണിൽ റോബോട്ടിനെ നീക്കുന്നു.
move_with_vectors — വെക്റ്റർ അടിസ്ഥാനമാക്കിയുള്ള x, y, ഭ്രമണ മൂല്യങ്ങൾ ഉപയോഗിച്ച് റോബോട്ട് നീക്കുന്നു.
turn — റോബോട്ടിനെ എന്നെന്നേക്കുമായി ഇടത്തോട്ടോ വലത്തോട്ടോ തിരിക്കുന്നു.
turn_for — ഒരു നിശ്ചിത എണ്ണം ഡിഗ്രികൾക്കായി റോബോട്ടിനെ ഇടത്തോട്ടോ വലത്തോട്ടോ തിരിക്കുന്നു.
turn_to — ഒരു പ്രത്യേക തലക്കെട്ടിന് അഭിമുഖമായി റോബോട്ടിനെ തിരിക്കുന്നു.
stop_all_movement — റോബോട്ടിന്റെ എല്ലാ ചലനങ്ങളും നിർത്തുന്നു.

മ്യൂട്ടേറ്ററുകൾ — റോബോട്ട് ചലന മൂല്യങ്ങൾ സജ്ജമാക്കുക.

set_move_velocity — റോബോട്ടിനോട് എത്ര വേഗത്തിൽ നീങ്ങണമെന്ന് പറയുന്നു.
set_turn_velocity — എത്ര വേഗത്തിൽ തിരിയണമെന്ന് റോബോട്ടിനോട് പറയുന്നു.
set_xy_position — റോബോട്ടിന്റെ നിലവിലെ x, y സ്ഥാനം പുതിയ മൂല്യങ്ങളിലേക്ക് മാറ്റുന്നു.

ഗെറ്ററുകൾ — റോബോട്ട് അവസ്ഥയും സ്ഥാനവും തിരികെ നൽകുക.

get_x_position — റോബോട്ടിന്റെ നിലവിലെ x-കോർഡിനേറ്റ് തിരികെ നൽകുന്നു.
get_y_position — റോബോട്ടിന്റെ നിലവിലെ y-കോർഡിനേറ്റ് തിരികെ നൽകുന്നു.
is_move_active — റോബോട്ട് നീങ്ങുന്നുണ്ടോ എന്ന് നൽകുന്നു.
is_turn_active — റോബോട്ട് തിരിയുന്നുണ്ടോ എന്ന് നൽകുന്നു.
is_stopped — റോബോട്ട് ചലിക്കുന്നില്ലെങ്കിലോ തിരിയുന്നില്ലെങ്കിലോ എന്ന് നൽകുന്നു.

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

move_at #

move_at റോബോട്ടിനെ ഒരു പ്രത്യേക കോണിൽ എന്നെന്നേക്കുമായി ചലിപ്പിക്കുന്നു. ആ കോൺ റോബോട്ടിന്റെ നിലവിലെ സ്ഥാനവുമായി ആപേക്ഷികമാണ്. മറ്റൊരു കോണിൽ നീങ്ങുക, തിരിയുക, അല്ലെങ്കിൽ നിർത്തുക തുടങ്ങിയ മറ്റൊരു പ്രവർത്തനം നൽകുന്നതുവരെ റോബോട്ട് ചലിക്കുന്നത് തുടരും.

ഉപയോഗം:

robot.move_at(angle, velocity, units)

പാരാമീറ്ററുകൾ	വിവരണം
`angle`	റോബോട്ട് ചലിക്കുന്ന കോൺ, ഡിഗ്രിയിൽ. ഇത് -360 മുതൽ 360 വരെയുള്ള ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം.
`velocity`	ഓപ്ഷണൽ. `PERCENT`ഉപയോഗിക്കുമ്പോൾ 0% മുതൽ 100% വരെയോ, `MMPS`ഉപയോഗിക്കുമ്പോൾ സെക്കൻഡിൽ 0 മുതൽ 200 മില്ലിമീറ്റർ വരെയോ സഞ്ചരിക്കേണ്ട വേഗത. ഇത് ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം (ഫ്ലോട്ട്). വേഗത നൽകിയിട്ടില്ലെങ്കിൽ, റോബോട്ട് നിലവിലെ ചലന വേഗതയിൽ നീങ്ങുന്നു.
`units`	ഓപ്ഷണൽ. പ്രവേഗ യൂണിറ്റ്: `PERCENT` (സ്ഥിരസ്ഥിതി) അല്ലെങ്കിൽ `MMPS` (മില്ലിമീറ്റർ പെർ സെക്കൻഡ്).

# Move right, then move forward and stop.
robot.move_at(90)
wait(1,SECONDS)
robot.move_at(0)
wait(1,SECONDS)
robot.stop_all_movement()

# Move right slowly, move in reverse quickly and stop.
robot.move_at(90, 25)
wait(2, SECONDS)
robot.move_at(180, 100, PERCENT)
wait(1, SECONDS)
robot.stop_all_movement()

# Move diagonally to the right and stop.
robot.move_at(45.33)
wait(1,SECONDS)
robot.stop_all_movement()

move_for #

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

ഉപയോഗം:

robot.move_for(distance, angle, velocity, units, wait)

പാരാമീറ്ററുകൾ	വിവരണം
`distance`	റോബോട്ട് സഞ്ചരിക്കുന്ന ദൂരം മില്ലിമീറ്ററിൽ (മില്ലീമീറ്റർ). ഇത് ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ (ഫ്ലോട്ട്) ആകാം.
`angle`	റോബോട്ട് ചലിക്കുന്ന കോൺ, ഡിഗ്രിയിൽ. ഇത് -360 മുതൽ 360 വരെയുള്ള ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം.
`velocity`	ഓപ്ഷണൽ. `PERCENT`ഉപയോഗിക്കുമ്പോൾ 0% മുതൽ 100% വരെയോ, `MMPS`ഉപയോഗിക്കുമ്പോൾ സെക്കൻഡിൽ 0 മുതൽ 200 മില്ലിമീറ്റർ വരെയോ സഞ്ചരിക്കേണ്ട വേഗത. ഇത് ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം (ഫ്ലോട്ട്). വേഗത നൽകിയിട്ടില്ലെങ്കിൽ, റോബോട്ട് നിലവിലെ ചലന വേഗതയിൽ നീങ്ങുന്നു.
`units`	ഓപ്ഷണൽ. പ്രവേഗ യൂണിറ്റ്: `PERCENT` (സ്ഥിരസ്ഥിതി) അല്ലെങ്കിൽ `MMPS` (മില്ലിമീറ്റർ പെർ സെക്കൻഡ്).
`wait`	ഓപ്ഷണൽ. `wait=True` (ഡിഫോൾട്ട്) റോബോട്ട് നീങ്ങുന്നത് വരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ പ്രേരിപ്പിക്കുന്നു, തുടർന്ന് കോഡിന്റെ അടുത്ത വരി പ്രവർത്തിക്കുന്നു. `wait=False` കോഡിന്റെ അടുത്ത വരി ഉടനടി പ്രവർത്തിപ്പിക്കുന്നു.

# Move right, then move forward.
robot.move_for(50, 90)
robot.move_for(100, 0)

# Move in reverse slowly, then move forward quickly.
robot.move_for(100, 180, 25)
robot.move_for(100, 0, 100, PERCENT)

# Drive forward and blink all LEDs red.
robot.move_for(100, 0, wait=False)
robot.led.on(ALL_LEDS, RED)
wait(0.5, SECONDS)
robot.led.on(ALL_LEDS, BLACK)
wait(0.5, SECONDS)
robot.led.on(ALL_LEDS, RED)
wait(0.5, SECONDS)
robot.led.on(ALL_LEDS, BLACK)

move_with_vectors #

ഒരു വസ്തുവിന്റെ ചലന വേഗതയും അതിന്റെ ചലന ദിശയും വിവരിക്കുന്നതിനുള്ള ഒരു മാർഗമാണ് വെക്റ്റർ. move_with_vectors വെക്റ്റർ അടിസ്ഥാനമാക്കിയുള്ള ചലനം ഉപയോഗിച്ച് റോബോട്ടിനെ ചലിപ്പിക്കുന്നു. സുഗമമായ ചലനം സൃഷ്ടിക്കുന്നതിന് റോബോട്ട് മുന്നോട്ടും വലത്തോട്ടും ഭ്രമണ പ്രവേഗ മൂല്യങ്ങളും സംയോജിപ്പിക്കുന്നു. മറ്റൊരു കോണിൽ നീങ്ങുക, തിരിയുക, നിർത്തുക തുടങ്ങിയ മറ്റൊരു പ്രവർത്തനം നൽകുന്നതുവരെ റോബോട്ട് ഈ വെക്റ്റർ ഉപയോഗിച്ച് നീങ്ങുന്നത് തുടരും.

കുറിപ്പ്: ഈ രീതി ചലനത്തിന്റെയും തിരിവിന്റെയും പ്രവേഗ മൂല്യങ്ങൾ നേരിട്ട് സജ്ജമാക്കുന്നു, അതിനാൽ ഇത് set_move_velocity അല്ലെങ്കിൽ set_turn_velocity ഉപയോഗിക്കുന്നില്ല.

ഉപയോഗം:

robot.move_with_vectors(forward, rightward, rotation)

പാരാമീറ്ററുകൾ	വിവരണം
`forward`	y-അക്ഷത്തിൽ റോബോട്ടിന്റെ വേഗത -100% മുതൽ 100% വരെയാണ്. നെഗറ്റീവ് മൂല്യങ്ങൾ റോബോട്ടിനെ പിന്നോട്ടും പോസിറ്റീവ് മൂല്യങ്ങൾ മുന്നോട്ടും നീക്കുന്നു.
`rightward`	x-അക്ഷത്തിൽ റോബോട്ടിന്റെ വേഗത -100% മുതൽ 100% വരെ. നെഗറ്റീവ് മൂല്യങ്ങൾ റോബോട്ടിനെ ഇടത്തേക്ക് നീക്കുന്നു, പോസിറ്റീവ് മൂല്യങ്ങൾ വലത്തേക്ക് നീക്കുന്നു.
`rotation`	റോബോട്ടിന്റെ ഭ്രമണ പ്രവേഗം, -100% മുതൽ 100% വരെ. നെഗറ്റീവ് മൂല്യങ്ങൾ റോബോട്ടിനെ എതിർ ഘടികാരദിശയിലും പോസിറ്റീവ് മൂല്യങ്ങൾ ഘടികാരദിശയിലും തിരിക്കുന്നു.

# Move at 15°
robot.move_with_vectors(48.3, 12.95, 0)
wait(2, SECONDS)
robot.stop_all_movement()

# Move at 45° while turning counterclockwise.
robot.move_with_vectors(50, 50, -30)
wait(2, SECONDS)
robot.stop_all_movement()

# Scaling movement using the controller joystick
while True:
    # Move forward (and backwards) slower than axis1 input
    forward   = controller.axis1.position() * 0.7
    
    # Move right (and left) faster than axis2 input
    rightward = controller.axis2.position() * 1.5    

    robot.move_with_vectors(forward, rightward, 0)

    wait(5, MSEC)

turn #

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

ഉപയോഗം:

robot.turn(direction, velocity, units)

പാരാമീറ്ററുകൾ	വിവരണം
`direction`	റോബോട്ട് തിരിയുന്ന ദിശ: `LEFT` അല്ലെങ്കിൽ `RIGHT`.
`velocity`	ഓപ്ഷണൽ. `PERCENT`ഉപയോഗിക്കുമ്പോൾ 0% മുതൽ 100% വരെയോ, `DPS`ഉപയോഗിക്കുമ്പോൾ സെക്കൻഡിൽ 0 മുതൽ 150 ഡിഗ്രി വരെയോ തിരിയേണ്ട വേഗത. ഇത് ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം (ഫ്ലോട്ട്). വേഗത നൽകിയിട്ടില്ലെങ്കിൽ, റോബോട്ട് നിലവിലെ ടേൺ പ്രവേഗത്തിൽ തിരിയുന്നു.
`units`	ഓപ്ഷണൽ. പ്രവേഗ യൂണിറ്റ്: `DPS` (ഡിഗ്രി പെർ സെക്കൻഡ്, ഡിഫോൾട്ട്) അല്ലെങ്കിൽ `PERCENT`.

# Turn left, then stop.
robot.turn(LEFT)
wait(1, SECONDS)
robot.stop_all_movement()

# Turn left quickly, turn right slowly, then stop.
robot.turn(LEFT, 80)
wait(2, SECONDS)
robot.turn(RIGHT, 20, PERCENT)
wait(3, SECONDS)
robot.stop_all_movement()

turn_for #

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

ഉപയോഗം:

robot.turn_for(direction, angle, velocity, units, wait)

പാരാമീറ്ററുകൾ	വിവരണം
`direction`	റോബോട്ട് തിരിയുന്ന ദിശ: `LEFT` അല്ലെങ്കിൽ `RIGHT`.
`angle`	റോബോട്ട് തിരിയുന്ന ഡിഗ്രികളുടെ എണ്ണം -360 മുതൽ 360 ഡിഗ്രി വരെയാണ്. ഇത് ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം (ഫ്ലോട്ട്).
`velocity`	ഓപ്ഷണൽ. `PERCENT`ഉപയോഗിക്കുമ്പോൾ 0% മുതൽ 100% വരെയോ, `DPS`ഉപയോഗിക്കുമ്പോൾ സെക്കൻഡിൽ 0 മുതൽ 150 ഡിഗ്രി വരെയോ തിരിയേണ്ട വേഗത. ഇത് ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം (ഫ്ലോട്ട്). വേഗത നൽകിയിട്ടില്ലെങ്കിൽ, റോബോട്ട് നിലവിലെ ടേൺ പ്രവേഗത്തിൽ തിരിയുന്നു.
`units`	ഓപ്ഷണൽ. പ്രവേഗ യൂണിറ്റ്: `DPS` (ഡിഗ്രി പെർ സെക്കൻഡ്, ഡിഫോൾട്ട്) അല്ലെങ്കിൽ `PERCENT`.
`wait`	ഓപ്ഷണൽ. `wait=True` (ഡിഫോൾട്ട്) റോബോട്ട് അടുത്ത വരി കോഡ് പ്രവർത്തിപ്പിക്കുന്നതുവരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ അനുവദിക്കുന്നു. `wait=False` കോഡിന്റെ അടുത്ത വരി ഉടനടി പ്രവർത്തിപ്പിക്കുന്നു.

# Turn left, then turn around to the right.
robot.turn_for(LEFT, 90)
robot.turn_for(RIGHT, 180)

# Turn left quickly, then turn right slowly.
robot.turn_for(LEFT, 90, 100)
robot.turn_for(RIGHT, 180, 15, PERCENT)

# Turn right and blink all LEDs blue.
robot.turn_for(RIGHT, 180, wait=False)
robot.led.on(ALL_LEDS, BLUE)
wait(0.5, SECONDS)
robot.led.off(ALL_LEDS)
wait(0.5, SECONDS)
robot.led.on(ALL_LEDS, BLUE)
wait(0.5, SECONDS)
robot.led.off(ALL_LEDS)

turn_to #

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

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

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

ഉപയോഗം:

robot.turn_to(heading, velocity, units, wait)

പാരാമീറ്ററുകൾ	വിവരണം
`heading`	റോബോട്ട് അഭിമുഖീകരിക്കേണ്ട തലക്കെട്ട് -360 മുതൽ 360 ഡിഗ്രി വരെയാണ്.
`velocity`	ഓപ്ഷണൽ. `PERCENT`ഉപയോഗിക്കുമ്പോൾ 0% മുതൽ 100% വരെയോ, `DPS`ഉപയോഗിക്കുമ്പോൾ സെക്കൻഡിൽ 0 മുതൽ 150 ഡിഗ്രി വരെയോ തിരിയേണ്ട വേഗത. ഇത് ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം (ഫ്ലോട്ട്). വേഗത നൽകിയിട്ടില്ലെങ്കിൽ, റോബോട്ട് നിലവിലെ ടേൺ പ്രവേഗത്തിൽ തിരിയുന്നു.
`units`	ഓപ്ഷണൽ. പ്രവേഗ യൂണിറ്റ്: `DPS` (ഡിഗ്രി പെർ സെക്കൻഡ്, ഡിഫോൾട്ട്) അല്ലെങ്കിൽ `PERCENT`.
`wait`	ഓപ്ഷണൽ. `wait=True` (ഡിഫോൾട്ട്) റോബോട്ട് അടുത്ത വരി കോഡ് പ്രവർത്തിപ്പിക്കുന്നതുവരെ പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ അനുവദിക്കുന്നു. `wait=False` കോഡിന്റെ അടുത്ത വരി ഉടനടി പ്രവർത്തിപ്പിക്കുന്നു.

# Turn to face each cardinal directions.
robot.turn_to(90)
wait(2, SECONDS)
robot.turn_to(180)
wait(2, SECONDS)
robot.turn_to(270)
wait(2, SECONDS)
robot.turn_to(0)

# Turn to face backward slowly, then face forward quickly.
robot.turn_to(180, 25)
wait(1, SECONDS)
robot.turn_to(0, 90, PERCENT)

# Turn around quickly and blink all LEDs green.
robot.turn_to(180, 100, wait=False)
robot.led.on(ALL_LEDS, GREEN)
wait(0.5, SECONDS)
robot.led.off(ALL_LEDS)
wait(0.5, SECONDS)
robot.led.on(ALL_LEDS, GREEN)
wait(0.5, SECONDS)
robot.led.off(ALL_LEDS)

stop_all_movement #

stop_all_movement റോബോട്ടിന്റെ എല്ലാ ചലനങ്ങളും നിർത്തുന്നു.

ഉപയോഗം:

robot.stop_all_movement()

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

# Turn right, then stop moving
robot.turn(RIGHT)
wait(1, SECONDS)
robot.stop_all_movement()

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

set_move_velocity #

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

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

100% ചലന വേഗത സെക്കൻഡിൽ 200 മില്ലിമീറ്ററിന് തുല്യമാണ്.

ഉപയോഗം:

robot.set_move_velocity(velocity, units)

പാരാമീറ്ററുകൾ	വിവരണം
`velocity`	`PERCENT`ഉപയോഗിക്കുമ്പോൾ 0% മുതൽ 100% വരെയോ, `MMPS`ഉപയോഗിക്കുമ്പോൾ സെക്കൻഡിൽ 0 മുതൽ 200 മില്ലിമീറ്റർ വരെയോ സഞ്ചരിക്കേണ്ട വേഗത. ഇത് ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം (ഫ്ലോട്ട്).
`units`	ഓപ്ഷണൽ. പ്രവേഗ യൂണിറ്റ്: `PERCENT` (സ്ഥിരസ്ഥിതി) അല്ലെങ്കിൽ `MMPS` (മില്ലിമീറ്റർ പെർ സെക്കൻഡ്).

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

വിവരണം

velocity

PERCENTഉപയോഗിക്കുമ്പോൾ 0% മുതൽ 100% വരെയോ, MMPSഉപയോഗിക്കുമ്പോൾ സെക്കൻഡിൽ 0 മുതൽ 200 മില്ലിമീറ്റർ വരെയോ സഞ്ചരിക്കേണ്ട വേഗത. ഇത് ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം (ഫ്ലോട്ട്).

units

ഓപ്ഷണൽ. പ്രവേഗ യൂണിറ്റ്: PERCENT (സ്ഥിരസ്ഥിതി) അല്ലെങ്കിൽ MMPS (മില്ലിമീറ്റർ പെർ സെക്കൻഡ്).

# Move forward at the default velocity,
robot.set_move_velocity(50)
robot.move_for(100, 0)
wait(1, SECONDS)
# Move slower than the default velocity
robot.set_move_velocity(20)
robot.move_for(100, 0)
wait(1, SECONDS)
# Move faster than the default velocity
robot.set_move_velocity(100)
robot.move_for(100, 0)

set_turn_velocity #

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

എല്ലാ പ്രോജക്റ്റുകളും ആരംഭിക്കുന്നത് റോബോട്ട് സ്ഥിരസ്ഥിതിയായി 50% വേഗതയിൽ (സെക്കൻഡിൽ 75 ഡിഗ്രി) തിരിയുന്നതിലൂടെയാണ്.

ഉപയോഗം:

robot.set_turn_velocity(velocity, units)

പാരാമീറ്ററുകൾ	വിവരണം
`velocity`	`PERCENT`ഉപയോഗിക്കുമ്പോൾ 0% മുതൽ 100% വരെ തിരിയാനുള്ള വേഗത, അല്ലെങ്കിൽ `DPS`ഉപയോഗിക്കുമ്പോൾ സെക്കൻഡിൽ 0 മുതൽ 150 ഡിഗ്രി വരെ തിരിയാനുള്ള വേഗത. ഇത് ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം (ഫ്ലോട്ട്).
`units`	ഓപ്ഷണൽ. പ്രവേഗ യൂണിറ്റ്: `DPS` (ഡിഗ്രി പെർ സെക്കൻഡ്, ഡിഫോൾട്ട്) അല്ലെങ്കിൽ `PERCENT`.

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

വിവരണം

velocity

PERCENTഉപയോഗിക്കുമ്പോൾ 0% മുതൽ 100% വരെ തിരിയാനുള്ള വേഗത, അല്ലെങ്കിൽ DPSഉപയോഗിക്കുമ്പോൾ സെക്കൻഡിൽ 0 മുതൽ 150 ഡിഗ്രി വരെ തിരിയാനുള്ള വേഗത. ഇത് ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം (ഫ്ലോട്ട്).

units

ഓപ്ഷണൽ. പ്രവേഗ യൂണിറ്റ്: DPS (ഡിഗ്രി പെർ സെക്കൻഡ്, ഡിഫോൾട്ട്) അല്ലെങ്കിൽ PERCENT.

# Turn around at default velocity
robot.set_turn_velocity(50)
robot.turn_for(RIGHT, 180)
wait(1, SECONDS)
# Turn around slower than the default velocity
robot.set_turn_velocity(20)
robot.turn_for(RIGHT, 180)
wait(1, SECONDS)
# Turn around faster than the default velocity
robot.set_turn_velocity(100)
robot.turn_for(RIGHT, 180)

set_xy_position #

set_xy_position റോബോട്ടിന്റെ നിലവിലെ x, y സ്ഥാനങ്ങൾ പുതിയ മൂല്യങ്ങളിലേക്ക് മാറ്റുന്നു.

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

ഉപയോഗം:

robot.set_xy_position(x, y)

പാരാമീറ്ററുകൾ	വിവരണം
`x`	റോബോട്ടിനായി സജ്ജമാക്കേണ്ട x-സ്ഥാന മൂല്യം, mm-ൽ. ഇത് ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം (ഫ്ലോട്ട്).
`y`	റോബോട്ടിനായി സജ്ജമാക്കേണ്ട y-സ്ഥാന മൂല്യം, mm-ൽ. ഇത് ഒരു പൂർണ്ണസംഖ്യയോ ദശാംശമോ ആകാം (ഫ്ലോട്ട്).

# Set the robot's current position
# Move forward and print the new coordinate
robot.set_xy_position(100, 50)
robot.move_for(150, 0)
robot.screen.print("X:", robot.get_x_position())
robot.screen.next_row()
robot.screen.print("Y:", robot.get_y_position())

ഗെറ്ററുകൾ #

get_x_position #

get_x_position റോബോട്ടിന്റെ നിലവിലെ x-കോർഡിനേറ്റ് മില്ലിമീറ്ററിൽ തിരികെ നൽകുന്നു.

ഒരു പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ, റോബോട്ടിന്റെ x-സ്ഥാനം 0 ആയി സജ്ജീകരിച്ചിരിക്കുന്നു. റോബോട്ട് ഇടത്തോട്ടോ വലത്തോട്ടോ നീങ്ങുമ്പോൾ x-സ്ഥാനം മാറുന്നു, കൂടാതെ set_xy_position രീതി ഉപയോഗിച്ച് ഇത് സജ്ജമാക്കാൻ കഴിയും.

ഉപയോഗം:

robot.get_x_position()

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

# Print the start and end x-value 
# of the robot's position after moving
robot.screen.print("Start X:", robot.get_x_position())
robot.move_for(200, 90)
robot.screen.next_row()
robot.screen.print("End X:", robot.get_x_position())

get_y_position #

get_y_position റോബോട്ടിന്റെ നിലവിലെ y-കോർഡിനേറ്റ് മില്ലിമീറ്ററിൽ തിരികെ നൽകുന്നു.

ഒരു പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ, റോബോട്ടിന്റെ y-സ്ഥാനം 0 ആയി സജ്ജീകരിച്ചിരിക്കുന്നു. റോബോട്ട് മുന്നോട്ട് അല്ലെങ്കിൽ പിന്നോട്ട് നീങ്ങുമ്പോൾ y-സ്ഥാനം മാറുന്നു, കൂടാതെ set_xy_position രീതി ഉപയോഗിച്ച് ഇത് സജ്ജമാക്കാൻ കഴിയും.

ഉപയോഗം:

robot.get_y_position()

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

# Print the start and end y-value 
# of the robot's position after moving
robot.screen.print("Start Y:", robot.get_y_position())
robot.move_for(200, 0)
robot.screen.next_row()
robot.screen.print("End Y:", robot.get_y_position())

is_move_active #

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

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

move_for പോലുള്ള wait പാരാമീറ്റർ ഉള്ള Motion രീതികളുമായി ഈ രീതി ഒരുമിച്ച് പ്രവർത്തിക്കുന്നു.

ഉപയോഗം:

robot.is_move_active()

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

# Blink all the LEDs when the robot is moving.
robot.move_for(200, 0, wait=False)

while robot.is_move_active():
    robot.led.on(ALL_LEDS, ORANGE)
    wait(0.5, SECONDS)
    robot.led.on(ALL_LEDS, CYAN)
    wait(0.5, SECONDS)

robot.led.off(ALL_LEDS)

is_turn_active #

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

True — റോബോട്ട് തിരിയുന്നു.
False — റോബോട്ട് തിരിയുന്നില്ല.

turn_for ഉം turn_to ഉം പോലുള്ള wait പാരാമീറ്റർ ഉള്ള Motion രീതികളുമായി ഈ രീതി ഒരുമിച്ച് പ്രവർത്തിക്കുന്നു.

ഉപയോഗം:

robot.is_turn_active()

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

# Blink all the LEDs while the robot is turning
robot.turn_for(RIGHT, 180, wait=False) 

while robot.is_turn_active():
    robot.led.on(ALL_LEDS, GREEN)
    wait(0.5, SECONDS)
    robot.led.on(ALL_LEDS, CYAN)
    wait(0.5, SECONDS)

robot.led.off(ALL_LEDS)

is_stopped #

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

True — റോബോട്ട് ചലിക്കുകയോ തിരിയുകയോ ചെയ്യുന്നില്ല.
False — റോബോട്ട് ചലിക്കുകയോ തിരിയുകയോ ചെയ്യുന്നു.

ഉപയോഗം:

robot.is_stopped()

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

# Blink all the LEDs while the robot is moving or turning

def light_show():
    # Flash LEDs while the robot is moving or turning
    while not robot.is_stopped():
        robot.led.on(ALL_LEDS, GREEN)
        wait(.5, SECONDS)
        robot.led.on(ALL_LEDS, PURPLE)
        wait(.5, SECONDS)

    robot.led.off(ALL_LEDS)

robot.move_for(200, 0, wait=False)
light_show()

robot.turn_for(RIGHT, 180, wait=False)
light_show()