1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

# code.py ## Workout Rest-Interval Helper (CircuitPython, Particle Argon)
import time
import os
import board
import analogio
import pwmio
import keypad
from tm1637 import TM1637

# CONFIG — adjust pins here if your wiring differs
CLK_PIN = board.A4        # TM1637 clock
DIO_PIN = board.A5        # TM1637 data   (swap A4/A5 if digits look scrambled)
POT_PIN = board.A0        # potentiometer wiper (try board.A1 if no response)
BUZZER_PIN = board.D4     # piezo buzzer  (try board.D5 if silent)
BUTTON_PIN = board.D2     # push button

# Some Grove button modules drive the line HIGH when pressed — flip this if so.
BUTTON_ACTIVE_HIGH = os.getenv("BUTTON_ACTIVE_HIGH", "0") == "1"

# Interval range: 0:15 ... 2:00 in 5s steps
MIN_SECONDS = 15
MAX_SECONDS = 120
STEP_SECONDS = 5
NUM_STEPS = (MAX_SECONDS - MIN_SECONDS) // STEP_SECONDS

BRIGHTNESS = int(os.getenv("DISPLAY_BRIGHTNESS", "5"))    # 0-7
BEEP_HZ = int(os.getenv("BEEP_HZ", "2300"))

display = TM1637(CLK_PIN, DIO_PIN, brightness=BRIGHTNESS)
pot = analogio.AnalogIn(POT_PIN)
buzzer = pwmio.PWMOut(BUZZER_PIN, frequency=BEEP_HZ, duty_cycle=0,
                      variable_frequency=True)
keys = keypad.Keys((BUTTON_PIN,), value_when_pressed=BUTTON_ACTIVE_HIGH,
                   pull=True)


def read_selected_seconds():
    """Average a few ADC samples and quantise to the nearest 5s step."""
    total = 0
    for _ in range(8):
        total += pot.value
    raw = total // 8
    step = (raw * NUM_STEPS + 32768) // 65535      # round to nearest step
    step = max(0, min(NUM_STEPS, step))
    return MIN_SECONDS + step * STEP_SECONDS


def beep_done():
    """Three short beeps spanning ~1 second."""
    for i in range(3):
        buzzer.frequency = BEEP_HZ
        buzzer.duty_cycle = 32768          # 50% -> tone on
        time.sleep(0.15)
        buzzer.duty_cycle = 0              # tone off
        if i < 2:
            time.sleep(0.20)


IDLE, RUNNING, PAUSED = range(3)
state = IDLE
remaining = 0
last_tick = 0.0
colon = True
last_pause_blink = 0.0
pause_visible = True

print("Workout helper ready. Turn the pot to set a rest interval, press to start.")

while True:
    event = keys.events.get()
    pressed = bool(event and event.pressed)
    now = time.monotonic()

    if state == IDLE:
        display.show_time(read_selected_seconds(), colon=True)
        if pressed:
            remaining = read_selected_seconds()
            last_tick = now
            colon = True
            display.show_time(remaining, colon=colon)
            state = RUNNING

    elif state == RUNNING:
        if now - last_tick >= 1.0:
            last_tick += 1.0
            remaining -= 1
            colon = not colon                      # blink the colon each second
            if remaining <= 0:
                display.show_time(0, colon=True)
                beep_done()
                state = IDLE
                continue
            display.show_time(remaining, colon=colon)
        if pressed:
            display.show_time(remaining, colon=True)   # steady colon = paused
            last_pause_blink = now
            pause_visible = True
            state = PAUSED

    elif state == PAUSED:
        if now - last_pause_blink >= 0.5:
            last_pause_blink = now
            pause_visible = not pause_visible
            if pause_visible:
                display.show_time(remaining, colon=True)
            else:
                display.clear()
        if pressed:
            display.show_time(remaining, colon=True)
            last_tick = now                            # resume cleanly
            state = RUNNING

    time.sleep(0.01)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

# tm1637.py — minimal bit-banged driver for the TM1637 4-digit 7-segment display.
#
# The TM1637 uses a 2-wire protocol that *looks* like I2C but is not: there is
# no device address and the data line is read on a fixed clock edge. So we
# bit-bang it on two ordinary GPIO pins (CLK + DIO) with digitalio.
#
# Adapted for CircuitPython from the widely used MicroPython tm1637 driver
# (Mike Causer, MIT). Push-pull outputs are used and the ACK bit is clocked but
# ignored, which is reliable on the Grove TM1637 modules (they have pull-ups).

import time
from digitalio import DigitalInOut, Direction

# Command bytes
_CMD_DATA = const(0x40)   # data command: automatic address increment
_CMD_ADDR = const(0xC0)   # address command: 0xC0 | position (0-3)
_CMD_DISP = const(0x80)   # display control: 0x80 | on-bit | brightness
_DISP_ON = const(0x08)    # display-on bit (OR with brightness 0-7)

_COLON = const(0x80)      # high bit of digit 1 drives the center colon

# 7-segment patterns for 0-9 then A-F (gfedcba bit order)
_SEGMENTS = (
    0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07,
    0x7F, 0x6F, 0x77, 0x7C, 0x39, 0x5E, 0x79, 0x71,
)

# Short delay so we stay under the TM1637's ~250 kHz clock limit. The call
# overhead alone is usually enough, but the explicit sleep keeps it safe.
def _tick():
    time.sleep(5e-6)


class TM1637:
    def __init__(self, clk, dio, brightness=5):
        self.clk = DigitalInOut(clk)
        self.dio = DigitalInOut(dio)
        self.clk.direction = Direction.OUTPUT
        self.dio.direction = Direction.OUTPUT
        self.clk.value = True
        self.dio.value = True
        self.brightness = max(0, min(7, brightness))
        self.clear()

    # --- low-level protocol ---------------------------------------------
    def _start(self):
        self.dio.value = False
        _tick()
        self.clk.value = False
        _tick()

    def _stop(self):
        self.clk.value = False
        _tick()
        self.dio.value = False
        _tick()
        self.clk.value = True
        _tick()
        self.dio.value = True
        _tick()

    def _write_byte(self, b):
        for _ in range(8):
            self.clk.value = False
            _tick()
            self.dio.value = bool(b & 1)
            _tick()
            self.clk.value = True
            _tick()
            b >>= 1
        # 9th clock = ACK (we clock it but don't read it back)
        self.clk.value = False
        _tick()
        self.clk.value = True
        _tick()
        self.clk.value = False
        _tick()

    # --- public API ------------------------------------------------------
    def write(self, segments, pos=0):
        """Write raw segment bytes (a list of up to 4 ints) starting at pos."""
        self._start()
        self._write_byte(_CMD_DATA)
        self._stop()

        self._start()
        self._write_byte(_CMD_ADDR | (pos & 0x03))
        for seg in segments:
            self._write_byte(seg)
        self._stop()

        self._start()
        self._write_byte(_CMD_DISP | _DISP_ON | self.brightness)
        self._stop()

    def clear(self):
        self.write([0, 0, 0, 0])

    def show_time(self, total_seconds, colon=True):
        """Render seconds as MM:SS (zero-padded) across the four digits."""
        if total_seconds < 0:
            total_seconds = 0
        mm = total_seconds // 60
        ss = total_seconds % 60
        segs = [
            _SEGMENTS[(mm // 10) % 10],
            _SEGMENTS[mm % 10] | (_COLON if colon else 0),
            _SEGMENTS[(ss // 10) % 10],
            _SEGMENTS[ss % 10],
        ]
        self.write(segs)