കൺട്രോളർ#

ആമുഖം #

VEX EXP കൺട്രോളറിൽ ബട്ടണുകളും രണ്ട് ജോയ്സ്റ്റിക്കുകളും ഉണ്ട്. ബട്ടൺ അമർത്തലുകൾ പരിശോധിക്കുന്നതിനും, ജോയ്സ്റ്റിക്ക് ചലനം വായിക്കുന്നതിനും, കോൺഫിഗർ ചെയ്ത കൺട്രോളർ പ്രവർത്തനങ്ങൾ പ്രാപ്തമാക്കുന്നതിനോ അപ്രാപ്തമാക്കുന്നതിനോ, അല്ലെങ്കിൽ കൺട്രോളർ ഇവന്റുകൾ സംഭവിക്കുമ്പോൾ ഫംഗ്ഷനുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനും കൺട്രോളർ രീതികൾ ഉപയോഗിക്കാം.

കോൺഫിഗർ ചെയ്‌ത കൺട്രോളർ പ്രവർത്തനങ്ങൾ എന്നത് ഉപകരണ മെനുവിൽ സജ്ജീകരിച്ചിരിക്കുന്ന കൺട്രോളർ പെരുമാറ്റങ്ങളാണ്. ഒരു പ്രോജക്റ്റ് സമയത്ത് കോൺഫിഗർ ചെയ്‌ത പ്രവർത്തനങ്ങൾ താൽക്കാലികമായി പ്രവർത്തനക്ഷമമാക്കാനോ പ്രവർത്തനരഹിതമാക്കാനോ remote_control_code_enabled ഉപയോഗിക്കുക.

ഈ പേജിൽ ഉദാഹരണ കൺട്രോളർ നാമമായി controller ഉപയോഗിക്കുന്നു. ആവശ്യാനുസരണം നിങ്ങളുടെ സ്വന്തം കോൺഫിഗർ ചെയ്ത പേര് ഉപയോഗിച്ച് അത് മാറ്റിസ്ഥാപിക്കുക.

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

പ്രവർത്തനം — കോൺഫിഗർ ചെയ്‌ത കൺട്രോളർ പ്രവർത്തനങ്ങൾ ഓൺ അല്ലെങ്കിൽ ഓഫ് ചെയ്യുക.

remote_control_code_enabled — ഉപകരണ മെനുവിൽ കോൺഫിഗർ ചെയ്‌തിരിക്കുന്ന കൺട്രോളർ പ്രവർത്തനങ്ങൾ പ്രവർത്തനക്ഷമമാക്കുകയോ പ്രവർത്തനരഹിതമാക്കുകയോ ചെയ്യുന്നു.

ഗെറ്ററുകൾ — ബട്ടൺ സ്റ്റേറ്റുകളും ജോയിസ്റ്റിക്ക് പൊസിഷനുകളും വായിക്കുക.

.pressing — ഒരു നിർദ്ദിഷ്ട ബട്ടൺ അമർത്തുന്നുണ്ടോ എന്ന് നൽകുന്നു.
.position — ഒരു നിർദ്ദിഷ്ട ജോയിസ്റ്റിക്ക് അച്ചുതണ്ടിന്റെ സ്ഥാനം നൽകുന്നു.

കോൾബാക്കുകൾ — കൺട്രോളർ ഇൻപുട്ട് മാറുമ്പോൾ ഫംഗ്ഷനുകൾ പ്രവർത്തിപ്പിക്കുക.

.pressed — ഒരു നിർദ്ദിഷ്ട ബട്ടൺ അമർത്തുമ്പോൾ ഒരു ഫംഗ്ഷൻ പ്രവർത്തിപ്പിക്കുന്നു.
.released — ഒരു നിർദ്ദിഷ്ട ബട്ടൺ റിലീസ് ചെയ്യുമ്പോൾ ഒരു ഫംഗ്ഷൻ പ്രവർത്തിപ്പിക്കുന്നു.
.changed — ജോയിസ്റ്റിക്കിന്റെ സ്ഥാനം ഒരു നിർദ്ദിഷ്ട അക്ഷത്തിൽ മാറുമ്പോൾ ഒരു ഫംഗ്ഷൻ പ്രവർത്തിപ്പിക്കുന്നു.

കൺസ്ട്രക്റ്റർ — ഒരു കൺട്രോളർ ഒബ്ജക്റ്റ് സ്വമേധയാ സൃഷ്ടിക്കുക.

Controller — ഒരു കൺട്രോളർ ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്നു.

ആക്ഷൻ #

remote_control_code_enabled #

remote_control_code_enabled എന്നത് ഉപകരണ മെനുവിൽ കോൺഫിഗർ ചെയ്‌തിരിക്കുന്ന കൺട്രോളർ പ്രവർത്തനങ്ങൾ പ്രവർത്തനക്ഷമമാക്കുകയോ പ്രവർത്തനരഹിതമാക്കുകയോ ചെയ്യുന്ന ഒരു വേരിയബിളാണ്. കൺട്രോളർ കോൺഫിഗർ ചെയ്‌ത പ്രവർത്തനങ്ങൾ സ്ഥിരസ്ഥിതിയായി പ്രവർത്തനക്ഷമമാക്കും.

Usage:
remote_control_code_enabled = state

വില	വിവരണം
`True`	കൺട്രോളർ കോൺഫിഗർ ചെയ്ത പ്രവർത്തനങ്ങൾ പ്രാപ്തമാക്കുന്നു.
`False`	കൺട്രോളർ കോൺഫിഗർ ചെയ്ത പ്രവർത്തനങ്ങൾ പ്രവർത്തനരഹിതമാക്കുന്നു.

# Drive forward or backward using the left joystick
remote_control_code_enabled = False

while True:
    if controller.axis3.position() > 0:
        drivetrain.drive(FORWARD)
    elif controller.axis3.position() < 0:
        drivetrain.drive(REVERSE)
    # Press A to use controller configured actions again
    elif controller.buttonA.pressing():
        break
    else:
        drivetrain.stop()

    wait(20, MSEC)

remote_control_code_enabled = True

ഗെറ്ററുകൾ #

.pressing #

.pressing അമർത്തുന്നത് കൺട്രോളറിലെ ഒരു പ്രത്യേക ബട്ടൺ നിലവിൽ അമർത്തുന്നുണ്ടോ എന്ന് നൽകുന്നു. ഈ രീതി controller.buttonA പോലുള്ള ഒരു പ്രത്യേക ബട്ടൺ ഒബ്ജക്റ്റിലാണ് വിളിക്കേണ്ടത്.

True — നിർദ്ദിഷ്ട ബട്ടൺ അമർത്തിക്കൊണ്ടിരിക്കുന്നു.
False — വ്യക്തമാക്കിയ ബട്ടൺ അമർത്തുന്നില്ല.

ഉപയോഗം:
ലഭ്യമായ ബട്ടൺ ഒബ്‌ജക്റ്റുകളിൽ ഒന്ന് ഈ രീതി ഉപയോഗിച്ച് ഉപയോഗിക്കാം:

ബട്ടൺ	കമാൻഡ്
`buttonA`	`controller.buttonA.pressing()` — A ബട്ടൺ
`buttonB`	`controller.buttonB.pressing()` — B ബട്ടൺ
`buttonDown`	`controller.buttonDown.pressing()` — ഡൗൺ ബട്ടൺ
`buttonUp`	`controller.buttonUp.pressing()` — മുകളിലേക്കുള്ള ബട്ടൺ
`buttonL1`	`controller.buttonL1.pressing()` — L1 ബട്ടൺ
`buttonL2`	`controller.buttonL2.pressing()` — L2 ബട്ടൺ
`buttonL3`	`controller.buttonL3.pressing()` — L3 ബട്ടൺ
`buttonR1`	`controller.buttonR1.pressing()` — R1 ബട്ടൺ
`buttonR2`	`controller.buttonR2.pressing()` — R2 ബട്ടൺ
`buttonR3`	`controller.buttonR3.pressing()` — R3 ബട്ടൺ

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

# Turn right while L1 is pressed
while True:
    if controller.buttonL1.pressing():
        drivetrain.turn(RIGHT)
    else:
        drivetrain.stop()

    wait(20, MSEC)

.position #

.position ഒരു ജോയിസ്റ്റിക്ക് അച്ചുതണ്ടിന്റെ സ്ഥാനം -100 മുതൽ 100 വരെയുള്ള ഒരു സംഖ്യയായി നൽകുന്നു.

ഈ രീതി controller.axis1 പോലുള്ള ഒരു പ്രത്യേക അച്ചുതണ്ട് വസ്തുവിൽ വിളിക്കണം.

ഉപയോഗം:
ഈ രീതി ഉപയോഗിച്ച് ലഭ്യമായ ആക്സിസ് ഒബ്ജക്റ്റുകളിൽ ഒന്ന് ഉപയോഗിക്കാം:

ജോയിസ്റ്റിക്ക് അച്ചുതണ്ട് നമ്പറുകൾ ചുവപ്പ് നിറത്തിൽ ഹൈലൈറ്റ് ചെയ്തിരിക്കുന്ന EXP കൺട്രോളറിന്റെ മുൻവശം. കൺട്രോളറിന്റെ ഉപരിതലത്തിൽ, ഇടത് ജോയിസ്റ്റിക്ക് ഇടത് വലത് ചലനത്തിന് ആക്സിസ് 4 എന്നും മുകളിലേക്കും താഴേക്കും ചലനത്തിന് ആക്സിസ് 3 എന്നും, വലത് ജോയിസ്റ്റിക്ക് ഇടത് വലത് ചലനത്തിന് ആക്സിസ് 1 എന്നും മുകളിലേക്കും താഴേക്കും ചലനത്തിന് ആക്സിസ് 2 എന്നും ലേബൽ ചെയ്തിരിക്കുന്നു.

അച്ചുതണ്ട്	കമാൻഡ്
`axis1`	`controller.axis1.position()` — വലത് ജോയിസ്റ്റിക്കിന്റെ തിരശ്ചീന അക്ഷം
`axis2`	`controller.axis2.position()` — വലത് ജോയിസ്റ്റിക്കിന്റെ ലംബ അക്ഷം
`axis3`	`controller.axis3.position()` — ഇടത് ജോയിസ്റ്റിക്കിന്റെ ലംബ അക്ഷം
`axis4`	`controller.axis4.position()` — ഇടത് ജോയിസ്റ്റിക്കിന്റെ തിരശ്ചീന അക്ഷം

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

# Turn with the left joystick
remote_control_code_enabled = False

while True:
    if controller.axis4.position() > 10:
        drivetrain.turn(RIGHT)
    elif controller.axis4.position() < -10:
        drivetrain.turn(LEFT)
    else:
        drivetrain.stop()

    wait(20, MSEC)

കോൾബാക്കുകൾ #

.pressed #

.pressed നിർദ്ദിഷ്ട ബട്ടൺ അമർത്തുമ്പോൾ ഒരു ഫംഗ്ഷൻ പ്രവർത്തിപ്പിക്കുന്നു. ഒരിക്കൽ ഉപയോഗിച്ചുകഴിഞ്ഞാൽ, ആ ബട്ടൺ അമർത്തുമ്പോഴെല്ലാം ഫംഗ്ഷൻ യാന്ത്രികമായി പ്രവർത്തിക്കും.

ബട്ടൺ	കമാൻഡ്
`buttonA`	`controller.buttonA.pressed(callback, arg)` — A ബട്ടൺ
`buttonB`	`controller.buttonB.pressed(callback, arg)` — B ബട്ടൺ
`buttonDown`	`controller.buttonDown.pressed(callback, arg)` — ഡൗൺ ബട്ടൺ
`buttonUp`	`controller.buttonUp.pressed(callback, arg)` — Up ബട്ടൺ
`buttonL1`	`controller.buttonL1.pressed(callback, arg)` — L1 ബട്ടൺ
`buttonL2`	`controller.buttonL2.pressed(callback, arg)` — L2 ബട്ടൺ
`buttonL3`	`controller.buttonL3.pressed(callback, arg)` — L3 ബട്ടൺ
`buttonR1`	`controller.buttonR1.pressed(callback, arg)` — R1 ബട്ടൺ
`buttonR2`	`controller.buttonR2.pressed(callback, arg)` — R2 ബട്ടൺ
`buttonR3`	`controller.buttonR3.pressed(callback, arg)` — R3 ബട്ടൺ

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

പാരാമീറ്റർ

വിവരണം

callback

നിർദ്ദിഷ്ട ബട്ടൺ അമർത്തുമ്പോഴെല്ലാം പ്രവർത്തിപ്പിക്കുന്നതിനായി മുമ്പ് നിർവചിച്ച ഒരു ഫംഗ്ഷൻ.

arg

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

# Drive forward when R1 is pressed
def drive_forward():
    drivetrain.drive_for(FORWARD, 200, MM)

controller.buttonR1.pressed(drive_forward)

.released #

.released നിർദ്ദിഷ്ട ബട്ടൺ റിലീസ് ചെയ്യുമ്പോൾ ഒരു ഫംഗ്ഷൻ പ്രവർത്തിപ്പിക്കുന്നു. ഒരിക്കൽ ഉപയോഗിച്ചുകഴിഞ്ഞാൽ, ആ ബട്ടൺ റിലീസ് ചെയ്യുമ്പോഴെല്ലാം ഫംഗ്ഷൻ യാന്ത്രികമായി പ്രവർത്തിക്കും.

ബട്ടൺ	കമാൻഡ്
`buttonA`	`controller.buttonA.released(callback, arg)` — A ബട്ടൺ
`buttonB`	`controller.buttonB.released(callback, arg)` — B ബട്ടൺ
`buttonDown`	`controller.buttonDown.released(callback, arg)` — ഡൗൺ ബട്ടൺ
`buttonUp`	`controller.buttonUp.released(callback, arg)` — Up ബട്ടൺ
`buttonL1`	`controller.buttonL1.released(callback, arg)` — L1 ബട്ടൺ
`buttonL2`	`controller.buttonL2.released(callback, arg)` — L2 ബട്ടൺ
`buttonL3`	`controller.buttonL3.released(callback, arg)` — L3 ബട്ടൺ
`buttonR1`	`controller.buttonR1.released(callback, arg)` — R1 ബട്ടൺ
`buttonR2`	`controller.buttonR2.released(callback, arg)` — R2 ബട്ടൺ
`buttonR3`	`controller.buttonR3.released(callback, arg)` — R3 ബട്ടൺ

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

പാരാമീറ്റർ

വിവരണം

callback

നിർദ്ദിഷ്ട ബട്ടൺ റിലീസ് ചെയ്യുമ്പോഴെല്ലാം പ്രവർത്തിപ്പിക്കുന്നതിനായി മുമ്പ് നിർവചിച്ച ഒരു ഫംഗ്ഷൻ.

arg

# Stop driving when R1 is released
def stop_driving():
    drivetrain.stop()

controller.buttonR1.released(stop_driving)

.changed #

.changed ജോയിസ്റ്റിക്കിന്റെ സ്ഥാനം നിർദ്ദിഷ്ട അക്ഷത്തിൽ മാറുമ്പോൾ ഒരു ഫംഗ്ഷൻ പ്രവർത്തിപ്പിക്കുന്നു. ഒരിക്കൽ ഉപയോഗിച്ചുകഴിഞ്ഞാൽ, ആ അക്ഷത്തിൽ ജോയിസ്റ്റിക്കിന്റെ സ്ഥാനം മാറുമ്പോഴെല്ലാം ഫംഗ്ഷൻ യാന്ത്രികമായി പ്രവർത്തിക്കും.

അച്ചുതണ്ട്	കമാൻഡ്
`axis1`	`controller.axis1.changed(callback, arg)` — വലത് ജോയിസ്റ്റിക്കിന്റെ തിരശ്ചീന അക്ഷം
`axis2`	`controller.axis2.changed(callback, arg)` — വലത് ജോയിസ്റ്റിക്കിന്റെ ലംബ അക്ഷം
`axis3`	`controller.axis3.changed(callback, arg)` — ഇടത് ജോയിസ്റ്റിക്കിന്റെ ലംബ അക്ഷം
`axis4`	`controller.axis4.changed(callback, arg)` — ഇടത് ജോയിസ്റ്റിക്കിന്റെ തിരശ്ചീന അക്ഷം

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

പാരാമീറ്റർ

വിവരണം

callback

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

arg

# Play a sound when the left joystick moves
def beep():
    brain.play_sound(SoundType.TADA)

controller.axis3.changed(beep)

കൺസ്ട്രക്‌ടർമാർ #

Controller #

Controller ഒരു കൺട്രോളർ ഒബ്‌ജക്റ്റ് സൃഷ്ടിക്കുന്നു. VEXcode-ന് പുറത്ത് ഒരു കൺട്രോളർ കോൺഫിഗർ ചെയ്യുമ്പോൾ മാത്രമേ ഒരു കൺട്രോളർ ഒബ്‌ജക്റ്റ് സ്വമേധയാ സൃഷ്ടിക്കേണ്ടതുള്ളൂ.

Usage:
Controller()

പാരാമീറ്ററുകൾ	വിവരണം
	ഈ കൺസ്ട്രക്റ്ററിന് പാരാമീറ്ററുകൾ ഇല്ല.

# Create a Controller object
my_controller = Controller()