ടൈമർ#

ആമുഖം #

VEX AIR ഡ്രോൺ കൺട്രോളറിന്റെ ടൈമർ ഒരു പ്രോജക്റ്റ് ആരംഭിച്ചതുമുതൽ കഴിഞ്ഞുപോയ സമയം ട്രാക്ക് ചെയ്യുന്നു. എന്തെങ്കിലും എത്ര സമയമെടുക്കുന്നുവെന്ന് അളക്കാനോ പുതിയ സമയ പ്രവർത്തനങ്ങൾക്കായി പുനഃസജ്ജമാക്കാനോ ഇത് ഉപയോഗിക്കാം.

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

പ്രവർത്തനം - ടൈമർ നിയന്ത്രിക്കുക.

reset – ടൈമർ പൂജ്യത്തിലേക്ക് പുനഃസജ്ജമാക്കുന്നു.

ഗെറ്റർ - നിലവിലെ ടൈമർ മൂല്യം റിപ്പോർട്ട് ചെയ്യുക.

time – എത്ര സമയം കടന്നുപോയി എന്ന് നൽകുന്നു.

കോൾബാക്ക് - കാലതാമസത്തിനുശേഷം പ്രവർത്തനങ്ങൾ ട്രിഗർ ചെയ്യുന്നു.

event – ഒരു നിശ്ചിത എണ്ണം മില്ലിസെക്കൻഡുകൾക്ക് ശേഷം വിളിക്കേണ്ട ഒരു ഫംഗ്ഷൻ രജിസ്റ്റർ ചെയ്യുന്നു.

കൺസ്ട്രക്ടർ - സമയം ട്രാക്ക് ചെയ്യാൻ ഒരു ടൈമർ സൃഷ്ടിക്കുക.

Timer - ഈ രീതികൾക്കൊപ്പം ഉപയോഗിക്കാൻ കഴിയുന്ന ഒരു പുതിയ ടൈമർ ഒബ്‌ജക്റ്റ് സൃഷ്ടിക്കുക.

ആക്ഷൻ #

reset #

reset ടൈമർ പൂജ്യത്തിലേക്ക് സജ്ജമാക്കുന്നു. ഒരേ പ്രോജക്റ്റിനുള്ളിൽ കോഡിന്റെ അധിക ഭാഗങ്ങൾ സമയബന്ധിതമാക്കാൻ ഇത് ഉപയോഗിക്കാം.

Usage:
timer.reset()

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

# Display the time the drone takes to climb upwards.
drone.take_off(500)
timer.reset()
drone.climb_for(UP, 500)
controller.screen.print("Time elapsed: ")
controller.screen.print(timer.time(SECONDS))
drone.land()

ഗെറ്റർ #

time #

time എന്നത് ടൈമർ അവസാനമായി ഡെസിമൽ ആയി പുനഃസജ്ജമാക്കിയതിനു ശേഷമുള്ള സമയം നൽകുന്നു. ഒരു പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ ടൈമർ യാന്ത്രികമായി പുനഃസജ്ജമാക്കപ്പെടും.

Usage:
timer.time(units)

പാരാമീറ്ററുകൾ	വിവരണം
`units`	സമയത്തെ പ്രതിനിധീകരിക്കുന്ന യൂണിറ്റ്: `MSEC` (സ്ഥിരസ്ഥിതി) – മില്ലിസെക്കൻഡ്, അല്ലെങ്കിൽ `SECONDS`

# Display the time in two units.
while True:
    controller.screen.clear_screen()
    controller.screen.set_cursor(1, 1)
    controller.screen.print("Time: {} ms".format(timer.time(MSEC)))
    controller.screen.next_row()
    controller.screen.print("Time: {:.2f} s".format(timer.time(SECONDS)))
    wait(50, MSEC)

തിരിച്ചുവിളിക്കുക #

event #

event ഒരു നിശ്ചിത സമയം കഴിഞ്ഞതിന് ശേഷം ഒരു ഫംഗ്ഷൻ വിളിക്കുന്നു.

ഉപയോഗം:

timer.event(callback, delay, arg)

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

# Create a function to play a looping sound.
def on_timer():
    controller.sound.play(LOOPING)

# Play the sound after 4 seconds (4000 mS).
timer.event(on_timer, 4000)

കൺസ്ട്രക്ടർ #

Timer #

Timer ഒരു പുതിയ ടൈമർ സൃഷ്ടിക്കുന്നു. ഒരു Timer ഒബ്ജക്റ്റ് സൃഷ്ടിച്ച നിമിഷം ഉടൻ എണ്ണാൻ തുടങ്ങും, കൂടാതെ എല്ലാ timer രീതികളുമായും പ്രവർത്തിക്കും.

Usage:
Timer()

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

# Display 2 timers with a 2 second difference.
wait(2, SECONDS)

stopwatch = Timer()

while True:
    controller.screen.clear_screen()

    controller.screen.set_cursor(1, 1)
    controller.screen.print("Timer: ")
    controller.screen.print(timer.time(SECONDS))

    controller.screen.set_cursor(4, 1)
    controller.screen.print("Stopwatch: ")
    controller.screen.print(stopwatch.time(SECONDS))

    wait(0.1, SECONDS)