You could just take the remainder when dividing by 65535 with the modulo operator %:

In [114]: int(time.perf_counter()*1000) % 65535
Out[114]: 29548

If you also are interested to know how many times the timer has been resetted, you can use divmod:

In [115]: divmod(int(time.perf_counter()*1000),65535)
Out[115]: (31, 30036)

You have two options; your code doesn't work because you are trying to reset the clock but instead you reset elapsed, which does nothing.

Using modulo division.

start = time.clock()
while True:
  elapsed = (time.clock() - start)
  if int(elapsed) % 10:
    print("MOTION")

Resetting the clock.

start = time.clock()
while True:
  elapsed = (time.clock() - start)
  if elapsed >= 10:
    print("MOTION")
    start = time.clock()

Not entirely clear what you are asking. If you want to reset the counter some time after the button has been clicked, you can add a call to after at the end of the function:

def onClick(event=None):
    counter.set(counter.get() + 1)
    root.after(3000, lambda: counter.set(0))

This will start a countdown the first time the button is clicked (and every other time thereafter) and reset the counter to 0 when the countdown finishes. Note that the countdown itself is not reset with later clicks, though.

If you do not want the after callbacks to stack, you can keep a reference to the ID of the last after event and cancel it before issuing the next one:

last_after = None
def onClick(event=None):
    counter.set(counter.get() + 1)

    global last_after
    if last_after:
        root.after_cancel(last_after)
    last_after = root.after(3000, lambda: counter.set(0))

If you just want to measure the elapsed wall-clock time between two points, you could use time.time():

import time

start = time.time()
print("hello")
end = time.time()
print(end - start)

This gives the execution time in seconds.

Another option since 3.3 might be to use perf_counter or process_time, depending on your requirements. Before 3.3 it was recommended to use time.clock . However, it is currently deprecated:

On Unix, return the current processor time as a floating point number expressed in seconds. The precision, and in fact the very definition of the meaning of “processor time”, depends on that of the C function of the same name.

On Windows, this function returns wall-clock seconds elapsed since the first call to this function, as a floating point number, based on the Win32 function QueryPerformanceCounter(). The resolution is typically better than one microsecond.

Deprecated since version 3.3: The behaviour of this function depends on the platform: use perf_counter() or process_time() instead, depending on your requirements, to have a well defined behaviour.

I would suggest using the time module for something like this:

from time import time, sleep
from datetime import datetime, timedelta

nowtime = time()

#Put your script here
x = 1
for k in range(1000):
        x+=1
        sleep(0.01)

sec = timedelta(seconds=int(time()-nowtime))
d = datetime(1,1,1)+sec

print("DAYS:HOURS:MIN:SEC")
print("%d:%d:%d:%d" % (d.day-1, d.hour, d.minute, d.second))

This assigns the time in seconds at the beginning to a variable, and after the main script has finished, it subtracts the previous time from the current time and formats it in days, hours, minutes, and seconds.

Here is it running:

bash-3.2$ python timing.py
DAYS:HOURS:MIN:SEC
0:0:0:10
bash-3.2$ 

You could also use the Threading module, which has a built-in cancel method:

>>> import threading
>>> def hello():
...     print "This will print after a desired period of time"
... 
>>> timer = threading.Timer(3.0, hello)
>>> timer.start() #After 3.0 seconds, "This will print after a desired period of time" will be printed
>>> This will print after a desired period of time

>>> timer.start()
>>> timer = threading.Timer(3.0, hello)
>>> timer.start()
>>> timer.cancel()
>>> 

This is expected as time is passed "by value" (you copy the content of the variable "into the function").

Perhaps you need to change your approach to "timer" as there appears to be no equivalent to "get_timer" to get the time left before the event is fired.

I'm not exactly sure how your whole game is developed, but you probably need to track the time yourself so that you can check the time left.

I'm not fluent in pygame, but, based on your previous question and pygame's documentation, perhaps something like this would work:

...

class Singlebullet(object):

    def __init__(self):
        self.img = pygame.image.load(r'C:\Users\Salem\Documents\MyGame1\bullet.png')
        self.state = 'ready'
        self.speed = 0
        self.firerate = 700 # assuming ms
        # this is new:
        self.bullet_time_left = self.firerate
        self.clock = pygame.time.Clock()
    
    def shoot(self):
        if current_bullet_type == 'single':
            if self.state == 'ready':
                self.x = myplane.x + 71 
                self.y = myplane.y 
            elif self.state == 'fire': # use elif instead of if
                self.speed = -13
                
                
            for event in events:
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_SPACE and self.state == 'ready':
                        self.clock = pygame.time.Clock()
                        self.bullet_time_left = self.firerate
                        self.state = 'fire'
                        
            delay = self.clock.tick()
            if self.state == 'fire':
                self.bullet_time_left -= delay
                if self.bullet_time_left <= 0:
                    self.bullet_time_left = self.firerate
                    self.state = 'ready'
                else:
                    reload_time = myfont.render(self.bullet_time_left, True, 'black')
                    MyScrollingScreen.blit(reload_time, (670, 650))
                    

            MyScrollingScreen.blit(self.img, (self.x, self.y))
            
            self.y += self.speed
s1 = Singlebullet()
...
while running:
    ...
    s1.shoot()
    ...

That's the gist of it. You start a "Clock" when you fire the bullet; each update, you "update" it via it's tick() method to check how much time has passed since the last "tick()". You remove that time from the "time left"; once that counter gets below 0, you know that you're done and should clean it up. You have access to the time left so you can use it to update your label.

You'll probably want to rearrange some of what I wrote to suit your needs.

As I mentioned, I'm not fluent with pygame, and so maybe someone else has a better approach to propose.