diagram.json

from micropython import const
from primitives import Pushbutton
import uasyncio as asyncio


class ButtonTypeMode:
    BTM_START_PAUSE = const( 0 )      
    BTM_START_ONLY = const( 1 )
    BTM_AUTO_START_PAUSE = const( 2 )  
    BTM_AUTO_START = const( 3 )

class ButtonModeSpecial:
    BMS_LONG_PRESS = const( 0 )     #Will be use to activate config mode, probably 5 seconds
    BMS_CONFIRMATION = const( 1 )   #Will be use to accept or cancel the current settings
    BMS_SHORT_LONG = const( 2 )     #Will be use to cycle the value and proceed to next digit

class ButtonModeRegular:
    BMR_INCREMENT = const( 0 )
    BMR_DECREMENT = const( 1 )

class ButtonFunctionTypes:
    BFT_LONG_FUNC = const( 0 )
    BFT_DOUBLE_FUNC = const( 1 )
    BFT_RELEASE_FUNC = const( 2 )
    BFT_PRESS_FUNC = const( 3 )

class ButtonFunction:
    def __init__(self, btn_funct_type:ButtonFunctionTypes , funct, args=()):
        self.btn_funct_type = btn_funct_type
        self.funct = funct
        self.args = args

    def update(self, others):
        self.btn_funct_type = others.btn_funct_type
        self.funct = others.funct

    def __call__(self):
        return self.funct

    def __eq__(self, others):
        return self.btn_funct_type == others.btn_funct_type

class ButtonFunctionSets:
    def __init__(self, name ):
        self.name = name
        self.set_functions = []

    def add(self, btn_funct:ButtonFunction):
        if btn_funct:
            if self.__notFound(btn_funct=btn_funct):
                self.set_functions.append(btn_funct)

    def getFunc(self, btn_funct_type:ButtonFunctionTypes):
        res = [ funct for funct in self.set_functions if funct.btn_funct_type == btn_funct_type ]
        if res:
            return res[0]
        return False

    def __notFound(self, btn_funct:ButtonFunction):
        if btn_funct in self.set_functions:
            [funct for funct in self.set_functions if funct == btn_funct][0].update(btn_funct)
            return False

        return True

class ButtonConfig:
    def __init__(self, name, pin:Input ,func_calls):
        self.name = name
        self.pin = pin
        self.functions = func_calls

class Buttons:
    def __init__(self):
        self.buttons = []

    def initialize(self):
        pass

    def add(self, button:ButtonConfig):
        btn = Pushbutton(button.pin(), suppress=True)
        self.__setBtnFunc(btn, button.functions[0]) #Always the first function from the list will be set as default
        self.buttons.append( (btn,button) )

    def update(self, name, funct_name):
        btn_spcl = self.__getSpecial()
        if btn_spcl:
            res = [ btn_func for btn_func in btn_spcl[0][1].functions if btn_func.name==funct_name ]
            if res:
                self.__setBtnFunc( btn_spcl[0][0],res[0] )
                return True
        return False

    def process(self, funct,value):
        asyncio.run(self.__main(funct,value))

    async def __main(self, funct,value):
        #'set our button function here
        f = funct
        while True:
            await asyncio.sleep_ms(5)
            f(*value)

    def __setBtnFunc( self, btn, button_functs ):
        press = button_functs.getFunc(ButtonFunctionTypes.BFT_PRESS_FUNC)
        release = button_functs.getFunc(ButtonFunctionTypes.BFT_RELEASE_FUNC)
        double_press = button_functs.getFunc(ButtonFunctionTypes.BFT_DOUBLE_FUNC)
        long_press = button_functs.getFunc(ButtonFunctionTypes.BFT_LONG_FUNC)
        if press:
            btn.press_func( press.funct, press.args )     
        if release:
            btn.release_func( release.funct, release.args )  
        if double_press:
            btn.double_func( double_press.funct, double_press.args )  
        if long_press:
            btn.long_func( long_press.funct, long_press.args )  

    def __getSpecial(self):
        return [ btn for btn in self.buttons if len(btn[1].functions) > 1 ]

buttons.py

from micropython import const
from output import Output
from machine import PWM
from nosleep import NoSleep
import time

class BuzzerFlow:
    BF_NONE = const( 0 )
    BF_BUZZ_ON = const( 1 )    
    BF_BUZZ_ON_LEN = const( 2 )
    BF_BUZZ_OFF = const( 3 )
    BF_BUZZ_OFF_LEN = const( 4 )
    BF_DONE = const( 5 )
    BF_PROCESS_ON = const( 6 )
    BF_PROCESS_OFF = const( 7 )

class BuzzerConfig:
    def __init__(self, output_pin:Output, frequency, duty_cycle ):
        self.output_pin = output_pin
        self.frequency = frequency
        self.duty_cycle = duty_cycle

class Buzzer:
    def __init__(self, buzzer_config:BuzzerConfig, no_pwm = False, debug=False) -> None:
        self.no_pwm = no_pwm
        self.buzzer_config = buzzer_config
        self.buzzer = None
        self.buzz_flow = BuzzerFlow.BF_NONE
        self.buzz_count = 0
        self.timer = NoSleep( 50, name="BuzzerBuzz", debug=False )
        self.debug = debug

    def initialize(self):
        if self.no_pwm:
            self.buzzer = self.buzzer_config.output_pin
        else:
            self.buzzer = PWM(self.buzzer_config.output_pin())
            self.buzzer.freq( self.buzzer_config.frequency )

    def buzz(self):
        if self.no_pwm:
            self.buzzer.on()
        else:
            self.buzzer.duty_u16(self.buzzer_config.duty_cycle)

    def stop(self):
        if self.no_pwm:
            self.buzzer.off()
        else:
            self.buzzer.duty_u16(0)
            self.buzzer.deinit()

    def setBuzzerCount(self, buzz_count = 1):
        self.buzz_count = buzz_count
        self.buzz_flow = BuzzerFlow.BF_BUZZ_ON
        self.timer.start()

    def addBuzzCount(self, buzz_count = 0):
        if self.buzz_count != 0:
            self.buzz_count += buzz_count
        else:
            self.setBuzzerCount(buzz_count)

    def process(self):
        res = self.timer.restart
        up = self.timer.update
        buz = self.buzz
        stst = self.timer.setTimeout
        s = self.stop

        if self.buzz_flow == BuzzerFlow.BF_BUZZ_ON:
            buz()
            stst(30)
            res()
            self.buzz_flow = BuzzerFlow.BF_PROCESS_ON
            if self.debug:
                print("BF_BUZZ_ON")
        elif self.buzz_flow == BuzzerFlow.BF_PROCESS_ON:
            if self.debug:
                print("BF_PROCESS_ON")
            if up():
                self.buzz_flow = BuzzerFlow.BF_BUZZ_OFF
        elif self.buzz_flow == BuzzerFlow.BF_BUZZ_OFF:
            if self.debug:
                print("BF_BUZZ_OFF")
            s()
            stst(20)
            res()
            if self.buzz_count > 0:
                self.buzz_flow = BuzzerFlow.BF_PROCESS_OFF
            else:
                self.buzz_flow = BuzzerFlow.BF_DONE
        elif self.buzz_flow == BuzzerFlow.BF_PROCESS_OFF:   
            if self.debug:
                print("BF_PROCESS_OFF")         
            if up():
                self.buzz_flow = BuzzerFlow.BF_DONE
        elif self.buzz_flow == BuzzerFlow.BF_DONE:      
            if self.debug:
                print("BF_DONE")
            if self.buzz_count > 1:
                self.buzz_count -= 1   
                self.buzz_flow = BuzzerFlow.BF_BUZZ_ON  
            elif self.buzz_count < 0:
                self.buzz_count = 0
                self.buzz_flow = BuzzerFlow.BF_NONE
            


buzzer.py

config.json

import ujson

class Config:
    def __init__(self, config_name ):
        self.config_name = config_name

    def read(self):
        try:
            with open(self.config_name) as fp:
                data = ujson.load(fp)        
            return data
        except:
            return False

    def write(self, config):
        try:
            dt = ujson.dumps(config)
            with open( self.config_name, "w+" ) as fp:
                fp.write(dt)
            return True
        except:
            return False

config.py

class DigitConfig:
    def __init__(self, value):
        self.value = value

    def upDigit(self):
        self.value += 1

        if self.value > 60:
            self.value = 1

    def downDigit(self):
        self.value -= 1

        if self.value < 1:
            self.value = 60;            


digit.py

from micropython import const
from machine import Pin
from tm1637 import TM1637Decimal, TM1637
from nosleep import NoSleep

class DisplayType:
    DT_NONE = const( 0 )
    DT_TIME = const( 1 )
    DT_CENT = const( 2 )

class DisplayConfig:
    def __init__(self, clock, data, display_type, brightness):
        self.clock = clock
        self.data = data
        self.display_type = display_type
        self.brightness = brightness

class Display:
    def __init__(self, display_config: DisplayConfig) -> None:
        self.display_type = display_config.display_type
        self.clock = display_config.clock
        self.data = display_config.data
        self.brightness = display_config.brightness
        self.tm = None
        self.tmr_display = NoSleep(500, name="display")
        self.tmr_display_show = False

    def setTM(self, display_type):
        self.display_type = display_type

    def initialize(self):
        if self.display_type == DisplayType.DT_CENT:
            self.tm = TM1637Decimal(clk=Pin(self.clock), dio=Pin(self.data), brightness=self.brightness)
        else:
            self.tm = TM1637(clk=Pin(self.clock), dio=Pin(self.data), brightness=self.brightness)   
        self.tmr_display.start()    

    def showStr(self, value) -> None:
        value = "{0}".format(value)
        self.tm.show(value)

    def addCredit(self, value, blink = False) -> None:
        chk = self.tmr_display.update
        ts = self.tm.show

        if blink == False:
            self.tmr_display_show = True

        if chk() or blink == False:
            if value < 100 :
                value = '{0:0>5.2f}'.format(value)
            elif value > 99:
                value = '{0:0>5.1f}'.format(value)      
            if self.tmr_display_show == False:
                value = "  .  " #value[:-1] + " "
            ts(value, False)
        self.tmr_display_show = not(self.tmr_display_show) 

    def showConfig(self, value) -> None:
        chk = self.tmr_display.update
        if chk():
            if self.tmr_display_show:
                self.tm.show("  .{0:0>2}".format(value))
            else:
                self.tm.show("  {0:0>2}".format(value))
            self.tmr_display_show = not(self.tmr_display_show)    

    def showDeductExceed(self, value) -> None:
        self.addCredit(value, True)

    def show(self, value, blink = False) -> None:
        if blink == False:
            if self.display_type == DisplayType.DT_CENT:
                self.tm.show(value, False)
            else:
                self.tm.numbers(value[0], value[1])
        else:
            chk = self.tmr_display.update
            ts = self.tm.show
            tn = self.tm.numbers
            if chk():    
                if self.tmr_display_show:
                    if self.display_type == DisplayType.DT_CENT:
                        ts(value, False)
                    else:
                        tn(value[0], value[1])
                else:
                    if self.display_type == DisplayType.DT_CENT:
                        value = value.replace(".", "")
                    else:
                        value = "{0:0>2}{1:0>2}".format(value[0], value[1])
                    ts(value, False)                   
                self.tmr_display_show = not(self.tmr_display_show)      
    
    def scroll(self, value) -> None:
        self.tm.scroll(value)

display.py

from machine import Pin

class Input:
    def __init__(self, io) -> None:
        self.io = io
        self.pin = Pin(self.io, Pin.IN, Pin.PULL_UP)

    def __call__(self):
        return self.pin

    def read(self) -> bool:
        return self.pin.value()


inpt.py

from time import ticks_ms, ticks_diff, ticks_us
from micropython import const

class TimerFlow:
    TF_NONE = const(0)
    TF_START = const(1)
    TF_PROCESS = const(2)
    TF_PAUSE = const(3)
    TF_DONE = const(4)

class NoSleep:
    def __init__(self, timeout = 0, is_enabled = False, name="", debug=False):
        self.currentMillis = 0
        self.previousMillis = 0
        self.timeout = timeout
        self.is_enabled = is_enabled
        self.name = name
        self.debug = debug
        self.is_pause = False
        self.time_diff = 0
        self.excess = 0
        if is_enabled:
            self.previousMillis = ticks_ms()
        
        if self.debug:
            print("{0}:{1}".format(self.name,timeout))
        
    def setTimeout(self, timeout):
        self.timeout = timeout
        if self.debug:
            print("New Timeout for {0}:{1}".format(self.name,timeout))

    def start(self):
        self.previousMillis = ticks_ms()
        self.is_enabled = True

    def stop(self):
        self.previousMillis = 0
        self.is_enabled = False

    def update(self):
        if self.is_enabled == False:
            return False
        self.currentMillis = ticks_ms()
        
        self.time_diff = ticks_diff(self.currentMillis, self.previousMillis)

        if self.time_diff >= self.timeout:
            self.previousMillis = self.currentMillis 
            if self.debug:
                print("{0}:{1}".format(self.name,self.time_diff))
            return True

        return False
    
    def isPause(self):
        return self.is_pause

    def setPause(self):
        if not self.is_pause:
            self.time_diff = ticks_diff(self.currentMillis, self.previousMillis)
            self.stop()
            self.is_pause = True

    def unPause(self):
        if self.is_pause:
            self.start()
            self.is_pause = False
            # timediff 600
            # current 2000
            # previousMillis = currentMillis -  timediff 
            # x = 2000 - 600 
            # x = 1400
            # timediff = 2000 - 1400

            self.previousMillis = ticks_ms() - self.time_diff
        
    def restart(self):
        self.stop()
        self.start()
        if self.debug:
            print("{0} is reset".format(self.name))

    def setName(self, name):
        self.name = name
    
  
if __name__ == "__main__":
    timer = NoSleep(1000)
    
    seconds_per_credit = 60
    coins = 2
    
    total_seconds = seconds_per_credit * coins
    deducter = 1/seconds_per_credit
    timer.start()
    while True:
        if timer.update():
            total_seconds -= 1
            coins -= deducter
            mm, ss = divmod(total_seconds,60)
            print("{0:0>2d}:{1:0>2d} = {2:0>3.1f}".format(mm,ss,coins))
                  
        if total_seconds <= 0:
           break

nosleep.py

from machine import Pin

class Output:
    def __init__(self, io) -> None:
        self.io = io
        self.pin = Pin(self.io, Pin.OUT)

    def __call__(self):
        return self.pin

    def on(self):
        self.pin.on()

    def off(self):
        self.pin.off()


output.py

# pushbutton.py

# Copyright (c) 2018-2022 Peter Hinch
# Released under the MIT License (MIT) - see LICENSE file

import uasyncio as asyncio
import utime as time
from utime import ticks_add, ticks_diff, ticks_ms

try:
    from machine import TouchPad
except ImportError:
    pass

async def _g():
    pass
type_coro = type(_g())

def launch(func, tup_args):
    res = func(*tup_args)
    if isinstance(res, type_coro):
        res = asyncio.create_task(res)
    return res

def set_global_exception():
    def _handle_exception(loop, context):
        import sys
        sys.print_exception(context["exception"])
        sys.exit()
    loop = asyncio.get_event_loop()
    loop.set_exception_handler(_handle_exception)

class Delay_ms:

    class DummyTimer:  # Stand-in for the timer class. Can be cancelled.
        def cancel(self):
            pass
    _fake = DummyTimer()

    def __init__(self, func=None, args=(), duration=1000):
        self._func = func
        self._args = args
        self._durn = duration  # Default duration
        self._retn = None  # Return value of launched callable
        self._tend = None  # Stop time (absolute ms).
        self._busy = False
        self._trig = asyncio.ThreadSafeFlag()
        self._tout = asyncio.Event()  # Timeout event
        self.wait = self._tout.wait  # Allow: await wait_ms.wait()
        self.clear = self._tout.clear
        self.set = self._tout.set
        self._ttask = self._fake  # Timer task
        self._mtask = asyncio.create_task(self._run()) #Main task

    async def _run(self):
        while True:
            await self._trig.wait()  # Await a trigger
            self._ttask.cancel()  # Cancel and replace
            await asyncio.sleep_ms(0)
            dt = max(ticks_diff(self._tend, ticks_ms()), 0)  # Beware already elapsed.
            self._ttask = asyncio.create_task(self._timer(dt))

    async def _timer(self, dt):
        await asyncio.sleep_ms(dt)
        self._tout.set()  # Only gets here if not cancelled.
        self._busy = False
        if self._func is not None:
            self._retn = launch(self._func, self._args)

# API
    # trigger may be called from hard ISR.
    def trigger(self, duration=0):  # Update absolute end time, 0-> ctor default
        if self._mtask is None:
            raise RuntimeError("Delay_ms.deinit() has run.")
        self._tend = ticks_add(ticks_ms(), duration if duration > 0 else self._durn)
        self._retn = None  # Default in case cancelled.
        self._busy = True
        self._trig.set()

    def stop(self):
        self._ttask.cancel()
        self._ttask = self._fake
        self._busy = False
        self._tout.clear()

    def __call__(self):  # Current running status
        return self._busy

    running = __call__

    def rvalue(self):
        return self._retn

    def callback(self, func=None, args=()):
        self._func = func
        self._args = args

    def deinit(self):
        self.stop()
        self._mtask.cancel()
        self._mtask = None

class Pushbutton:
    debounce_ms = 50
    long_press_ms = 1000
    double_click_ms = 400

    def __init__(self, pin, suppress=False, sense=None):
        self._pin = pin  # Initialise for input
        self._supp = suppress
        self._dblpend = False  # Doubleclick waiting for 2nd click
        self._dblran = False  # Doubleclick executed user function
        self._tf = False
        self._ff = False
        self._df = False
        self._ld = False  # Delay_ms instance for long press
        self._dd = False  # Ditto for doubleclick
        # Convert from electrical to logical value
        self._sense = pin.value() if sense is None else sense
        self._state = self.rawstate()  # Initial state
        self._run = asyncio.create_task(self._go())  # Thread runs forever

    async def _go(self):
        while True:
            self._check(self.rawstate())
            # Ignore state changes until switch has settled. Also avoid hogging CPU.
            # See https://github.com/peterhinch/micropython-async/issues/69
            await asyncio.sleep_ms(Pushbutton.debounce_ms)

    def _check(self, state):
        if state == self._state:
            return
        # State has changed: act on it now.
        self._state = state
        if state:  # Button pressed: launch pressed func
            if self._tf:
                launch(self._tf, self._ta)
            if self._ld:  # There's a long func: start long press delay
                self._ld.trigger(Pushbutton.long_press_ms)
            if self._df:
                if self._dd():  # Second click: timer running
                    self._dd.stop()
                    self._dblpend = False
                    self._dblran = True  # Prevent suppressed launch on release
                    launch(self._df, self._da)
                else:
                    # First click: start doubleclick timer
                    self._dd.trigger(Pushbutton.double_click_ms)
                    self._dblpend = True  # Prevent suppressed launch on release
        else:  # Button release. Is there a release func?
            if self._ff:
                if self._supp:
                    d = self._ld
                    # If long delay exists, is running and doubleclick status is OK
                    if not self._dblpend and not self._dblran:
                        if (d and d()) or not d:
                            launch(self._ff, self._fa)
                else:
                    launch(self._ff, self._fa)
            if self._ld:
                self._ld.stop()  # Avoid interpreting a second click as a long push
            self._dblran = False

    def _ddto(self):  # Doubleclick timeout: no doubleclick occurred
        self._dblpend = False
        if self._supp and not self._state:
            if not self._ld or (self._ld and not self._ld()):
                launch(self._ff, self._fa)

    # ****** API ******
    def press_func(self, func=False, args=()):
        if func is None:
            self.press = asyncio.Event()
        self._tf = self.press.set if func is None else func
        self._ta = args

    def release_func(self, func=False, args=()):
        if func is None:
            self.release = asyncio.Event()
        self._ff = self.release.set if func is None else func
        self._fa = args

    def double_func(self, func=False, args=()):
        if func is None:
            self.double = asyncio.Event()
            func = self.double.set
        self._df = func
        self._da = args
        if func:  # If double timer already in place, leave it
            if not self._dd:
                self._dd = Delay_ms(self._ddto)
        else:
            self._dd = False  # Clearing down double func

    def long_func(self, func=False, args=()):
        if func is None:
            self.long = asyncio.Event()
            func = self.long.set
        if func:
            if self._ld:
                self._ld.callback(func, args)
            else:
                self._ld = Delay_ms(func, args)
        else:
            self._ld = False

    # Current non-debounced logical button state: True == pressed
    def rawstate(self):
        return bool(self._pin() ^ self._sense)

    # Current debounced state of button (True == pressed)
    def __call__(self):
        return self._state

    def deinit(self):
        self._run.cancel()


class ESP32Touch(Pushbutton):
    thresh = (80 << 8) // 100

    @classmethod
    def threshold(cls, val):
        if not (isinstance(val, int) and 0 < val < 100):
            raise ValueError("Threshold must be in range 1-99")
        cls.thresh = (val << 8) // 100

    def __init__(self, pin, suppress=False):
        self._thresh = 0  # Detection threshold
        self._rawval = 0
        try:
            self._pad = TouchPad(pin)
        except ValueError:
            raise ValueError(pin)  # Let's have a bit of information :)
        super().__init__(pin, suppress, False)

    # Current logical button state: True == touched
    def rawstate(self):
        rv = self._pad.read()  # ~220μs
        if rv > self._rawval:  # Either initialisation or pad was touched
            self._rawval = rv  # when initialised and has now been released
            self._thresh = (rv * ESP32Touch.thresh) >> 8
            return False  # Untouched
        return rv < self._thresh



primitives.py

"""
MicroPython TM1637 quad 7-segment LED display driver
https://github.com/mcauser/micropython-tm1637

MIT License
Copyright (c) 2016 Mike Causer

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""

#from time import sleep_us
#from time import sleep_ms
from time import sleep as sleep_us
from time import sleep as sleep_ms
from micropython import const
from machine import Pin

TM1637_CMD1 = const(64)  # 0x40 data command
TM1637_CMD2 = const(192) # 0xC0 address command
TM1637_CMD3 = const(128) # 0x80 display control command
TM1637_DSP_ON = const(8) # 0x08 display on
#TM1637_DELAY = const(10) # 10us delay between clk/dio pulses
TM1637_DELAY = 0.00001 # 10us delay between clk/dio pulses
TM1637_MSB = const(128)  # msb is the decimal point or the colon depending on your display

# 0-9, a-z, blank, dash, star
_SEGMENTS = bytearray(b'\x3F\x06\x5B\x4F\x66\x6D\x7D\x07\x7F\x6F\x77\x7C\x39\x5E\x79\x71\x3D\x76\x06\x1E\x76\x38\x55\x54\x3F\x73\x67\x50\x6D\x78\x3E\x1C\x2A\x76\x6E\x5B\x00\x40\x63')

class TM1637:
    """Library for quad 7-segment LED modules based on the TM1637 LED driver."""
    def __init__(self, clk, dio, brightness=7):
        self.clk = clk
        self.dio = dio

        if not 0 <= brightness <= 7:
            raise ValueError("Brightness out of range")
        self._brightness = brightness

        self.clk.init(Pin.OUT, value=0)
        self.dio.init(Pin.OUT, value=0)
        sleep_us(TM1637_DELAY)

        self._write_data_cmd()
        self._write_dsp_ctrl()

    def _start(self):
        self.dio(0)
        sleep_us(TM1637_DELAY)
        self.clk(0)
        sleep_us(TM1637_DELAY)

    def _stop(self):
        self.dio(0)
        sleep_us(TM1637_DELAY)
        self.clk(1)
        sleep_us(TM1637_DELAY)
        self.dio(1)

    def _write_data_cmd(self):
        # automatic address increment, normal mode
        self._start()
        self._write_byte(TM1637_CMD1)
        self._stop()

    def _write_dsp_ctrl(self):
        # display on, set brightness
        self._start()
        self._write_byte(TM1637_CMD3 | TM1637_DSP_ON | self._brightness)
        self._stop()

    def _write_byte(self, b):
        for i in range(8):
            self.dio((b >> i) & 1)
            sleep_us(TM1637_DELAY)
            self.clk(1)
            sleep_us(TM1637_DELAY)
            self.clk(0)
            sleep_us(TM1637_DELAY)
        self.clk(0)
        sleep_us(TM1637_DELAY)
        self.clk(1)
        sleep_us(TM1637_DELAY)
        self.clk(0)
        sleep_us(TM1637_DELAY)

    def brightness(self, val=None):
        """Set the display brightness 0-7."""
        # brightness 0 = 1/16th pulse width
        # brightness 7 = 14/16th pulse width
        if val is None:
            return self._brightness
        if not 0 <= val <= 7:
            raise ValueError("Brightness out of range")

        self._brightness = val
        self._write_data_cmd()
        self._write_dsp_ctrl()
        return None

    def write(self, segments, pos=0):
        """Display up to 6 segments moving right from a given position.
        The MSB in the 2nd segment controls the colon between the 2nd
        and 3rd segments."""
        if not 0 <= pos <= 5:
            raise ValueError("Position out of range")
        self._write_data_cmd()
        self._start()

        self._write_byte(TM1637_CMD2 | pos)
        for seg in segments:
            self._write_byte(seg)
        self._stop()
        self._write_dsp_ctrl()

    def encode_digit(self, digit):
        """Convert a character 0-9, a-f to a segment."""
        return _SEGMENTS[digit & 0x0f]

    def encode_string(self, string):
        """Convert an up to 4 character length string containing 0-9, a-z,
        space, dash, star to an array of segments, matching the length of the
        source string."""
        segments = bytearray(len(string))
        for pair in enumerate(string):
            segments[pair[0]] = self.encode_char(pair[1])
        return segments

    def encode_char(self, char):
        """Convert a character 0-9, a-z, space, dash or star to a segment."""
        o = ord(char)
        if o == 32:
            return _SEGMENTS[36] # space
        if o == 42:
            return _SEGMENTS[38] # star/degrees
        if o == 45:
            return _SEGMENTS[37] # dash
        if 90 >= o >= 65:
            return _SEGMENTS[o-55] # uppercase A-Z
        if 122 >= o >= 97:
            return _SEGMENTS[o-87] # lowercase a-z
        if 57 >= o >= 48:
            return _SEGMENTS[o-48] # 0-9
        raise ValueError("Character out of range: {:d} '{:s}'".format(o, chr(o)))

    def hex(self, val):
        """Display a hex value 0x0000 through 0xffff, right aligned."""
        string = '{:04x}'.format(val & 0xffff)
        self.write(self.encode_string(string))

    def number(self, num):
        """Display a numeric value -999 through 9999, right aligned."""
        # limit to range -999 to 9999
        num = max(-999, min(num, 9999))
        string = '{0: >4d}'.format(num)
        self.write(self.encode_string(string))

    def numbers(self, num1, num2, colon=True):
        """Display two numeric values -9 through 99, with leading zeros
        and separated by a colon."""
        num1 = max(-9, min(num1, 99))
        num2 = max(-9, min(num2, 99))
        segments = self.encode_string('{0:0>2d}{1:0>2d}'.format(num1, num2))
        if colon:
            segments[1] |= 0x80 # colon on
        self.write(segments)

    def temperature(self, num):
        if num < -9:
            self.show('lo') # low
        elif num > 99:
            self.show('hi') # high
        else:
            string = '{0: >2d}'.format(num)
            self.write(self.encode_string(string))
        self.write([_SEGMENTS[38], _SEGMENTS[12]], 2) # degrees C

    def show(self, string, colon=False):
        segments = self.encode_string(string)
        if len(segments) > 1 and colon:
            segments[1] |= 128
        self.write(segments[:4])

    #def scroll(self, string, delay=250):
    def scroll(self, string, delay=0.250):        
        segments = string if isinstance(string, list) else self.encode_string(string)
        data = [0] * 8
        data[4:0] = list(segments)
        for i in range(len(segments) + 5):
            self.write(data[0+i:4+i])
            sleep_ms(delay)


class TM1637Decimal(TM1637):
    """Library for quad 7-segment LED modules based on the TM1637 LED driver.

    This class is meant to be used with decimal display modules (modules
    that have a decimal point after each 7-segment LED).
    """

    def encode_string(self, string):
        """Convert a string to LED segments.

        Convert an up to 4 character length string containing 0-9, a-z,
        space, dash, star and '.' to an array of segments, matching the length of
        the source string."""
        segments = bytearray(len(string.replace('.','')))
        j = 0
        for pair in enumerate(string):
            if pair[1] == '.' and j > 0:
                segments[j-1] |= TM1637_MSB
                continue
            segments[j] = self.encode_char(pair[1])
            j += 1
        return segments


tm1637.py

from micropython import const
from buzzer import Buzzer, BuzzerConfig, BuzzerFlow
from inpt import Input
from output import Output
from primitives import Pushbutton
from time import sleep_us, sleep_ms , ticks_ms, ticks_diff, sleep, ticks_us
from display import Display, DisplayType, DisplayConfig
from buttons import Buttons, ButtonFunction, ButtonFunctionTypes, ButtonFunctionSets, ButtonConfig, ButtonTypeMode
from nosleep import NoSleep, TimerFlow
from config import Config
from digit import DigitConfig

title = "Tamayo Technology"
seconds_per_credit = 60 #seconds per credits, temporarily 60s per 1 credit
temp_seconds_per_credit = 60
is_spc = False
autostart = False

button_type_mode = ButtonTypeMode.BTM_START_PAUSE
temp_button_type_mode = ButtonTypeMode.BTM_START_PAUSE

timer_flow = TimerFlow.TF_NONE         

done_countdown = False
only_after_boot = True

credits = 0
deducter = 0.10
is_started = False
is_pause = True
temp_is_pause = True

is_config = False
dconf = None
temp_spc = 0
myButtons = None
after_five_sec_spc = None

timer = None
interval_timer = 0
buzzer_buzz = None
auto_start_idle = None

total_time = 0
final_time = 0


def setAutoStart():
    global autostart

    if button_type_mode == ButtonTypeMode.BTM_AUTO_START_PAUSE or button_type_mode == ButtonTypeMode.BTM_AUTO_START:
        autostart = True
    else:
        autostart = False

def secretSettings():
    global button_type_mode  

    if is_config:
        return 

    if only_after_boot == False:
        return

    if credits > 0:
        return 

    button_type_mode += 1

    if button_type_mode > 3:
        button_type_mode = 0

    buzzer_buzz.setBuzzerCount(button_type_mode + 1)
    setAutoStart()
    #print("Button type mode: {0}".format(button_type_mode))


def plusCredits(value):
    global credits
    global total_seconds

    if is_config:
        return     

    if autostart:
        auto_start_idle.restart()

    buzzer_buzz.addBuzzCount(1)
    credits += value
    #print( "{0}*{1}={2}".format(seconds_per_credit,credits,total_seconds ) )

def startTimer():
    global is_pause
    global deducter
    global timer_flow
    global is_started

    if is_config:
        return

    if is_pause == False:
        return

    if credits <= 0:
        return

    is_started = True

    interval_timer = seconds_per_credit * 0.1 * 1000
    timer.setTimeout( interval_timer )

    timer_flow = TimerFlow.TF_START
    deducter = 0.10 #(1 * reducer)/seconds_per_credit  # we are using 500ms in timer so we need to half this   
    buzzer_buzz.setBuzzerCount(1)

    is_pause = False
    start_pause_action_interval.restart()

def pauseTimer():
    global is_pause
    global timer_flow 

    if is_config:
        return

    if button_type_mode == ButtonTypeMode.BTM_AUTO_START and button_type_mode == ButtonTypeMode.BTM_START_ONLY:
        return

    if is_pause:
        return

    timer_flow = TimerFlow.TF_PAUSE
    buzzer_buzz.setBuzzerCount(2)

    is_pause = True
    start_pause_action_interval.restart()

def spcUp():
    global seconds_per_credit
    global is_config
    global is_spc

    if credits > 0:
        return

    if not is_spc:
        is_spc = True
        is_config = True
        buzzer_buzz.setBuzzerCount(1)
        return

    seconds_per_credit += 1

    if seconds_per_credit > 60:
        seconds_per_credit = 1

    after_five_sec_spc.restart()      
     
    buzzer_buzz.setBuzzerCount(1)

def spcDown():
    global seconds_per_credit
    global is_config
    global is_spc

    if credits > 0:
        return    

    if not is_spc:
        is_spc = True
        is_config = True
        buzzer_buzz.setBuzzerCount(1)
        return

    seconds_per_credit -= 1

    if seconds_per_credit < 1:
        seconds_per_credit = 60

    after_five_sec_spc.restart()  
 
    buzzer_buzz.setBuzzerCount(1) 

def spcSave():
    global temp_seconds_per_credit
    global is_config
    global is_spc

    if is_config == False:
        return

    is_config = False   
    is_spc = False        

    if temp_seconds_per_credit == seconds_per_credit:
        return

    def writeConfig(value):
        config = Config("config.json")
        conf = config.read()
        conf["seconds_per_credit"]["value"] = value
        if config.write(conf):
            print("Write successfully SPC")
        else:
            print("Write failed SPC")  

    temp_seconds_per_credit = seconds_per_credit

    writeConfig( seconds_per_credit )       
    buzzer_buzz.setBuzzerCount(2)

      
def btmSave():
    #print("Button type mode: {0} -> {1}".format(temp_button_type_mode, button_type_mode))
    if temp_button_type_mode == button_type_mode:
        return

    def writeConfig(value):
        config = Config("config.json")
        conf = config.read()
        conf["button_mode"]["value"] = value
        if config.write(conf):
            print("Write successfully BTM")
        else:
            print("Write failed BTM")

    writeConfig( button_type_mode )    
    buzzer_buzz.setBuzzerCount(6)      
 
def readConfig():
    global seconds_per_credit
    global temp_seconds_per_credit
    global title
    global button_type_mode
    global temp_button_type_mode

    def removeStr(value):
        new_value = ""
        for char in value:
            if char in "0123456789":
                new_value += char     
        return new_value      

    config = Config("config.json")
    conf = config.read()
    if conf:
        passed = True
        if "button_mode" not in conf and "value" not in conf["button_mode"] and "idle_seconds" not in conf["button_mode"]:
            passed = False

        if passed:
            if  type(conf["button_mode"]["value"]) is int:
                button_type_mode = conf["button_mode"]["value"]
                temp_button_type_mode = button_type_mode
                setAutoStart()

        passed = True
        if "title" not in conf and "value" not in conf["title"]:
            passed = False

        if passed:
            title = conf["title"]["value"]

        passed = True
        if "seconds_per_credit" not in conf and "value" not in conf["seconds_per_credit"]:
            passed = False

        if passed:
            if type(conf["seconds_per_credit"]["value"]) is int:
                seconds_per_credit = conf["seconds_per_credit"]["value"]
            elif type(conf["seconds_per_credit"]["value"]) is str:              
                seconds_per_credit =  int(removeStr(conf["seconds_per_credit"]["value"]))
            
            temp_seconds_per_credit=seconds_per_credit

def timed_function(f, *args, **kwargs):
    myname = str(f).split(' ')[1]
    def new_func(*args, **kwargs):
        t = ticks_us()
        result = f(*args, **kwargs)
        delta = ticks_diff(ticks_us(), t)
        print('Function {} Time = {:6.3f}ms'.format(myname, delta/1000))
        return result
    return new_func            

if __name__ == "__main__":
    Pushbutton.long_press_ms = 3000
    readConfig()
    timer = NoSleep( 1000, name="timer" ) # let's try using 500ms and devide deducter by 2
    after_five_sec_spc = NoSleep( 5000, name="AFSS" )
    after_on_boot = NoSleep( 30000, name="AOB" )
    start_pause_action_interval = NoSleep( 1000, name="SPAI" ) # This will be use to check if the pause start can be repress
    auto_start_idle = NoSleep( 1000, name="ASI")
    tm1637_conf = DisplayConfig(clock=14, data=15, display_type=DisplayType.DT_CENT, brightness=7)
    disp = Display(tm1637_conf)
    disp.initialize()

    buzzer_pin = Output(2)

    buzzer_config = BuzzerConfig(buzzer_pin, 1047, 50 )
    buzzer_buzz = Buzzer(buzzer_config, False)
    buzzer_buzz.initialize()

    plus_one_pin = Input(3)
    plus_five_pin = Input(4)
    plus_ten_pin = Input(5)

    plus_sec_per_credit_pin = Input(6)
    minus_sec_per_credit_pin = Input(7)

    secret_settings_pin = Input(8)

    start_pin = Input(9)

    relay_pin = Output(10)

    plus_one_press = ButtonFunction(btn_funct_type=ButtonFunctionTypes.BFT_PRESS_FUNC, funct=plusCredits, args=(1,))
    plus_five_press = ButtonFunction(btn_funct_type=ButtonFunctionTypes.BFT_PRESS_FUNC, funct=plusCredits, args=(5,))
    plus_ten_press = ButtonFunction(btn_funct_type=ButtonFunctionTypes.BFT_PRESS_FUNC, funct=plusCredits, args=(10,))

    plus_sec_per_credit_press = ButtonFunction(btn_funct_type=ButtonFunctionTypes.BFT_PRESS_FUNC, funct=spcUp, args=())
    minus_sec_per_credit_press = ButtonFunction(btn_funct_type=ButtonFunctionTypes.BFT_PRESS_FUNC, funct=spcDown, args=())

    start_press = ButtonFunction(btn_funct_type=ButtonFunctionTypes.BFT_PRESS_FUNC, funct=startTimer, args=())
    pause_press = ButtonFunction(btn_funct_type=ButtonFunctionTypes.BFT_PRESS_FUNC, funct=pauseTimer, args=())

    settings_long = ButtonFunction(btn_funct_type=ButtonFunctionTypes.BFT_LONG_FUNC, funct=secretSettings, args=())

    plus_one_set_func = ButtonFunctionSets("+one")
    plus_one_set_func.add(plus_one_press)

    plus_five_set_func = ButtonFunctionSets("+five")
    plus_five_set_func.add(plus_five_press)

    plus_ten_set_func = ButtonFunctionSets("+ten")
    plus_ten_set_func.add(plus_ten_press) 

    plus_sec_per_credit_func =ButtonFunctionSets( "+spc" )
    plus_sec_per_credit_func.add(plus_sec_per_credit_press)

    minus_sec_per_credit_func = ButtonFunctionSets( "-spc" )
    minus_sec_per_credit_func.add(minus_sec_per_credit_press)

    start_set_func = ButtonFunctionSets("start")
    start_set_func.add(start_press)

    pause_set_func = ButtonFunctionSets("pause")
    pause_set_func.add(pause_press)      

    secret_settings_set_func =  ButtonFunctionSets("secret_settings")
    secret_settings_set_func.add(settings_long)

    plus_one_btnconf = ButtonConfig( name="btnPlusOne", pin=plus_one_pin, func_calls=[plus_one_set_func] )
    plus_five_btnconf = ButtonConfig( name="btnPlusFive", pin=plus_five_pin, func_calls=[plus_five_set_func] )
    plus_ten_btnconf = ButtonConfig( name="btnPlusTen", pin=plus_ten_pin, func_calls=[plus_ten_set_func] )

    plus_sec_per_credit_btnconf = ButtonConfig( name="btnPlusSPC", pin=plus_sec_per_credit_pin, func_calls=[plus_sec_per_credit_func] )
    minus_sec_per_credit_btnconf = ButtonConfig( name="btnMinussSPC", pin=minus_sec_per_credit_pin, func_calls=[minus_sec_per_credit_func] )

    start_pause_btnf = ButtonConfig( name="btnStartPause", pin=start_pin,  func_calls=[start_set_func,pause_set_func] )

    secret_settings_btnconf = ButtonConfig( name="btnSecretSettings", pin=secret_settings_pin,  func_calls=[secret_settings_set_func] )

    myButtons = Buttons()
    myButtons.add(plus_one_btnconf)
    myButtons.add(plus_five_btnconf)
    myButtons.add(plus_ten_btnconf)
    myButtons.add(plus_sec_per_credit_btnconf)
    myButtons.add(minus_sec_per_credit_btnconf)    
    myButtons.add(start_pause_btnf)
    myButtons.add(secret_settings_btnconf)

    @micropython.native
    def auto_start_event(auto_start_idle):
        check = auto_start_idle.update
        off = auto_start_idle.stop
        on = auto_start_idle.restart
        stmr = startTimer
        if autostart:
            if credits > 0:
                if check():
                    off()
                    stmr()
            else:
                on()

    @micropython.native
    def count_down(timer):
        global timer_flow
        global total_time
        global credits
        global is_pause
        global done_countdown
        global is_started
        global total_time
        global final_time

        check = timer.update
        on = timer.start
        off = timer.stop
        pau = timer.setPause
        unp = timer.unPause
        isp = timer.isPause

        if  timer_flow == TimerFlow.TF_START:
            if isp():
                unp()
            else:
                on()
            timer_flow = TimerFlow.TF_PROCESS
        elif timer_flow == TimerFlow.TF_PROCESS:
            if check():
                credits -= deducter

                if credits <= 1.0 and credits >= 0.01:
                    buzzer_buzz.setBuzzerCount(1)

                if credits <= 0:
                    credits = 0
                    off()
                    timer_flow = TimerFlow.TF_DONE
                
                if total_time >= timer.timeout:
                    total_time = total_time - timer.timeout
                    credits -= deducter
                final_time += timer.time_diff
                total_time += timer.time_diff - timer.timeout
        elif timer_flow == TimerFlow.TF_DONE:
            done_countdown = True
            timer_flow = TimerFlow.TF_NONE
            is_pause = True
            is_started = False
            off()
            print("Total Time: {0}".format(final_time/1000))
        elif timer_flow == TimerFlow.TF_PAUSE:
            #off()
            pau()    
            total_time += timer.time_diff - timer.timeout
            final_time += timer.time_diff
            timer_flow = TimerFlow.TF_NONE   
                       
    @micropython.native             
    def display(disp):
        global done_countdown

        ds = disp.scroll
        dsc = disp.showConfig
        dac = disp.addCredit
        dsh = disp.show

        if done_countdown: # When count down is done
            done_countdown = False
            #ds("Done Thank You")
            #dsh("Done")
            #sleep_ms(500)
            buzzer_buzz.setBuzzerCount(3)
        elif is_spc: #temp_seconds_per_credit != seconds_per_credit: # When config is up
            dsc(seconds_per_credit)
        elif is_pause: # Adding credits
            if is_started == False:
                dac(credits)
            else:             
                dac(credits, True)         
        else: # When count down is started
            if credits < 100:
                dsh('{0:0>5.2f}'.format(credits))
            elif credits > 100:
                dsh('{0:0>5.1f}'.format(credits))                                          

    @micropython.native
    def relay(relay_pin):
        off = relay_pin.off
        on = relay_pin.on

        if credits <= 0 or is_pause:
            off()
        elif credits > 0:
            on()

    @micropython.native
    def beep(buzzer_buzz):
        bbp = buzzer_buzz.process 
        bbp()

    @micropython.native
    def pauseStartInterval( start_pause_action_interval ):
        global is_pause
        global temp_is_pause

        apaiu = start_pause_action_interval.update
        apair = start_pause_action_interval.restart
        mu =  myButtons.update

        if button_type_mode == ButtonTypeMode.BTM_START_PAUSE or button_type_mode == ButtonTypeMode.BTM_AUTO_START_PAUSE:
            if temp_is_pause != is_pause:
                if apaiu():
                    if is_pause == False:
                        mu( name="btnStartPause", funct_name="pause")
                    else:
                        mu( name="btnStartPause", funct_name="start")
                    temp_is_pause = is_pause
            else:
                apair()
        else:
            apair()

    @micropython.native
    def afterOnBoot( after_on_boot ):
        global only_after_boot

        aobu = after_on_boot.update
        aobs = after_on_boot.stop
        bs = btmSave

        if only_after_boot:
            if credits > 0 or aobu():
                aobs()
                bs()
                only_after_boot = False

    @micropython.native
    def afterFiveSec( after_five_sec_spc ):
        afssu = after_five_sec_spc.update
        ss = spcSave

        if credits > 0:
            return

        if afssu():
            ss()

    @micropython.native
    def finalFunc(disp, relay_pin, buzzer_buzz, timer, auto_start_idle , start_pause_action_interval, after_on_boot, after_five_sec_spc):
        afs = afterFiveSec
        aob = afterOnBoot
        psi = pauseStartInterval
        ase = auto_start_event
        r = relay
        cd = count_down
        d = display        
        b = beep

        afs( after_five_sec_spc )
        aob( after_on_boot )
        psi( start_pause_action_interval )
        ase(auto_start_idle)
        r(relay_pin)
        cd(timer)
        r(relay_pin)
        d(disp)
        b(buzzer_buzz)

    disp.scroll(title)
    disp.showStr("00.00")

    buzzer_buzz.buzz()
    sleep_ms(50)
    buzzer_buzz.stop()

    # relay_pin.on()
    # sleep_us(100)
    # relay_pin.off()

    after_five_sec_spc.start()
    start_pause_action_interval.start() # let start it now. and restart it later
    after_on_boot.start() # let start the timer now.
    myButtons.process(finalFunc, ( disp, relay_pin, buzzer_buzz, timer, auto_start_idle, start_pause_action_interval, after_on_boot, after_five_sec_spc) )



main.py

Task 1 -> Done
  Alway 4 digit
  00.00 when less 100 but greather than 1
  000.0 when greather than 99
  .00 when less than 1 <- only for MMSS timer

  if value < 1:
      value = str(value % 1)[1:]    
  elif value < 100 :
      value = '{0:0>5.2f}'.format(value)
  elif value > 99:
      value = '{0:0>5.1f}'.format(value)      

Task 2 -> Done
  Use Pull_Down in button

Task 3 -> Done
  Config button is the same button for increment, long press to accept
  00-60 -> right adjustment only .60
  +Start button
  -Pause Button

Task 4 -> Done
  after boot
  30s window checking time
  press and hold the Pause button for 3 sec
  to change the start mode
  Start Mode:
    1. start/pause
    2. start only
    3. auto start + start/pause
    4. auto start 
  Default: 1
  This will only secret setting is only active after boot
  last setting will be saved. Every boot this will be Use
  unless change from secret settings
  This only be available when
  after boot, within 30s, 00 credit

Task 5 -> Done
  Secret Setting sound selection
    1 beep start/pause
    2 beep start only
    3 beep auto start + start/pause
    4 beep auto start 

Task 6 -> Done
  1 beep start
  2 beep pause

Task 7 -> Done
  01.00 t 00.01
  Warning beep 500ms interval

Task 8 -> Done
  Idle auto start is 1s

Task 9 -> Done
  Blink the digit except the period
  01.00 -> __.__
  __.__ -> 01.00

Task 10 -> Done
  Don't deduct when at pause

Task 11 -> Done
  Start/Pause have 1sec action interval

Task 12 -> Done
  Add adjustment button ( we can reuse the -1, -5 or -10 for this and we still have 1 free button)
  new button for second per credit +
  new button for second per credit -
  No event +/- for 5sec will save automatically
  this can only be trigger when credit is 0

Task 13 -> Done
  Change setings function to secret settings and can only be use 
  in span of 30 sec after boot up

Task 14 -> Done
  remove button -1, -5, -10

Task 15 -> Done
  use only 1 button for start and pause