Implement a Stopwatch Implement a simple digital Stopwatch,
which will display the time elapsed in seconds and minutes, as described below.

Important
Please read both Display and Controls sections !

Display
Time elapsed, should be displayed in the MM:SS format,
by replacing the previously displayed time string &quot;in-place&quot;
(clearing the whole or a part of the screen is also allowed).
The stopwatch must be updated at least every second.
Examples:
0 minutes, 0 seconds
00:00

0 minutes, 33 seconds
00:33

1 minute, 50 seconds
01:50

Initially, you can start with '00:00' or with any other value in range [00:00-59:59].
Once your Stopwatch reaches 59:59, it should reset to 00:00 and continue afresh.
You can use a different base (instead of decimal) or even a different numeral system if you wish, as long as you follow the general pattern.
For example 13:03 can be displayed as:
Decimal
13:03

Hexadecimal
0D:03

Base64
N:D

Quater-imaginary base
10101:3

Roman Numerals
XIII:III

Beware that if you use a non-decimal numeral system/base, it must be encoded using printable ASCII (or Unicode) characters, e.g. using two binary (unprintable) bytes for minutes and seconds is not allowed.
You must also left-pad your output with zeroes as appropriate, if your numerical system allows for that.
Replacing the separator character : with any other printable character (including digits) is also acceptable.
Controls
The stopwatch should start paused, and stay in this state, until user explicitly starts it, by pressing the 'control' key (see below).
If, while stopwatch is counting, user presses the 'control' key again, the stopwatch should pause (keeping the current time), until the 'control' key is pressed a one more time.
The 'control' key can be a single keystroke, e.g. s,
or any combination of keys, e.g. Ctrl+Shift+X, but it must be 'atomic', pressing multiple keys in sequence, e.g. s then Enter, is not allowed.
The same 'control' key (or combination) must be used to pause and resume the stopwatch.
You must use a specific 'control' key, i.e. 'any key' is not allowed.
Alternatively, you can use a single or double mouse-click, instead of a keypress for 'control'.

Rules

This is code-golf, the shortest answer in bytes wins;
Standard code-golf loopholes apply;
Your program must (theoretically) be capable of running forever.
Python 2, 167 129 bytes

-36 bytes mostly* from using Maltysen's idea of catching ctrl-c using an exception - go give credit!
-4 bytes thanks to DLosc (init n and b to 0 rather than f())
-1 byte thanks to FlipTack (use p^=1 rather than p=1-p)
-2 bytes thanks to Felipe Nardi Batista (remove precision specifiers)



import time
f=time.time
n=b=p=0
while 1:
 try:n=[n,f()][p];t=n-b;print'\r%02d:%02d'%(t/60%60,t%60),
 except:b=[b-n+f(),b][p];p^=1


Works the same as my original, below, but with the control key sequence of ctrl+c.
(Tested by me with Python 2.7.8 on Windows 7, 64bit;
Tested by Brian Minton with Python 2.7.13 on linux, 64bit)

* also collapsed if statement to a list lookup in order to get the try as a one-liner.

My original:

import time,msvcrt as m
f=time.time
n=b=p=0
while 1:
 if m.kbhit()and m.getch()==b'p':b=[b-n+f(),b][p];p^=1
 if p:n=f()
 t=n-b;print'\r%0.2d:%0.2d'%(t/60%60,t%60),


(Tested by me with Python 2.7.8 on Windows 7, 64bit - this code, however, is Windows specific due to the use of the msvcrt library)

The control key is 'p'.

n and b are initialised to the same value at start-up, giving an "offset" of 0; p is initialised to 0, indicating a paused state.

Whenever the control key is pressed the value of p is switched. When switching from a paused state to an active state b is updated to a new value keeping any current offset from the previous active state(s) with b-n.

During an active state n is repeatedly updated to the current time by calling time.time().

The difference between n and b, t, is then the total number of seconds (including a fractional part) elapsed during active state(s).

The minutes elapsed are then t/60 and each of the minutes and seconds are displayed mod 60 with (t/60%60,t%60). Leading zeros are prepended for each using string formatting of the integer part with '...%0.2d...'. Printing a tuple (the trailing ,) where the first item has a leading carriage return (the \r) causes the previously printed text to be overwritten.