PI-32Beginner

Raspberry Pi Pico binaire klok (6 leds + knop)

Deze klok heeft geen cijfers! We bouwen een klok met een Raspberry Pi Pico die de tijd binair toont. De 6 leds zijn de plaatsen 32-16-8-4-2-1; tel de brandende op en je leest de seconden, minuten of uren. Eén knop wisselt van veld en stelt de tijd in en elk heel uur loopt er een lichtveeg over de leds.

0.0(0)
Raspberry Pi Pico binaire klok (6 leds + knop)
Een klok die de tijd met licht in plaats van cijfers aangeeft: zes leds tonen de seconden, minuten of uren binair. Van links naar rechts zijn de leds 32, 16, 8, 4, 2 en 1 waard en door de brandende op te tellen krijg je de huidige waarde. Met één knop wissel je tussen seconden, minuten en uren, met een lange druk stel je de tijd in en op het hele uur loopt er een lichtveeg over de leds.

Video

Schakelschema

Raspberry Pi Pico binaire klok (6 leds + knop) - Schakelschema

Broncode

MicroPython
1# ─────────────────────────────────────────
2#   BlueGrays · bluegrays.com
3#   Raspberry Pi Pico binaire klok (6 leds + knop)
4# ─────────────────────────────────────────
5# Een klok die de tijd als binaire getallen toont. De 6 leds zijn de
6# plaatsen 32-16-8-4-2-1; de brandende leds tellen op tot de waarde. Kort
7# indrukken wisselt tussen seconden, minuten en uren; lang indrukken stelt
8# het veld in. Elk heel uur loopt een lichtveeg, en de onboard-led tikt de
9# seconden.
10#
11# Pinnen:
12#   GP2  -> Led 1 (bit 0), via 220 ohm
13#   GP3  -> Led 2 (bit 1), via 220 ohm
14#   GP4  -> Led 4 (bit 2), via 220 ohm
15#   GP5  -> Led 8 (bit 3), via 220 ohm
16#   GP6  -> Led 16 (bit 4), via 220 ohm
17#   GP7  -> Led 32 (bit 5), via 220 ohm
18#   GP15 -> Knop (andere poot naar GND)
19#   LED  -> Onboard-led (secondetik)
20#   GND  -> Led-kathodes, knop
21
22from machine import Pin
23import time
24
25# ============ INSTELLINGEN ============
26START_TIME = (12, 59, 50)  # Starttijd (u, m, s)
27SEC, MIN, HOUR = range(3)
28START_MODE = SEC       # Veld dat bij de start getoond wordt
29LONG_MS = 800          # Tijd voor lang indrukken
30DEBOUNCE_MS = 20       # Debouncetijd van de knop
31MODE_MS = 500          # Hoe lang de modusmarkering zichtbaar is
32BLINK_MS = 300         # Knipperperiode in instelmodus
33SET_TIMEOUT_MS = 10000 # Instelmodus slaat op na deze rusttijd
34SWEEP_STEP_MS = 60     # Stap van de veeg bij een heel uur
35SWEEP_ROUNDS = 2       # Aantal vegen
36TICK_MS = 100          # Flitslengte van de onboard-led
37LOOP_MS = 5            # Lusstap
38
39# In volgorde bit 0 (1) ... bit 5 (32)
40LED_PINS = (2, 3, 4, 5, 6, 7)
41MODE_NAMES = ("SECONDEN", "MINUTEN", "UREN")
42# Modusmarkering: 1, 2 of 3 leds van links (seconden, minuten, uren)
43MODE_MARKS = (0b100000, 0b110000, 0b111000)
44
45
46# ============ HARDWARE ============
47leds = [Pin(gp, Pin.OUT, value=0) for gp in LED_PINS]
48# De naam "LED" vindt de onboard-led op zowel de Pico als de Pico W (geen GP-pin op de W)
49tick_led = Pin("LED", Pin.OUT, value=0)   # De onboard-led van de Pico
50
51
52class Button:
53    # Pull-upknop: leest 0 als ingedrukt. update() 1 = ingedrukt, -1 = losgelaten
54    def __init__(self, gp):
55        self.pin = Pin(gp, Pin.IN, Pin.PULL_UP)
56        self.down = False
57        self.changed_at = time.ticks_ms()
58
59    def update(self, now):
60        pressed = self.pin.value() == 0
61        if pressed != self.down and time.ticks_diff(now, self.changed_at) >= DEBOUNCE_MS:
62            self.down = pressed
63            self.changed_at = now
64            return 1 if pressed else -1
65        return 0
66
67    def held_ms(self, now):
68        return time.ticks_diff(now, self.changed_at)
69
70
71button = Button(15)
72shown = -1                 # Laatste patroon op de leds
73
74
75def show_bits(pattern):
76    # Als het patroon veranderd is, schrijf de 6 leds: bit i -> led i
77    global shown
78    if pattern == shown:
79        return
80    shown = pattern
81    for i, led in enumerate(leds):
82        led.value((pattern >> i) & 1)
83
84
85def binary(v):
86    # Binaire tekst van 6 cijfers, bijv. 13 -> 001101
87    return "".join("1" if v >> i & 1 else "0" for i in range(5, -1, -1))
88
89
90# ============ KLOK ============
91clock_s = (START_TIME[0] * 3600 + START_TIME[1] * 60 + START_TIME[2]) % 86400
92start = time.ticks_ms()
93next_second = time.ticks_add(start, 1000)
94tick_off_at = start
95
96
97def hms():
98    return clock_s // 3600, clock_s // 60 % 60, clock_s % 60
99
100
101def field_value(m):
102    h, mi, s = hms()
103    return (s, mi, h)[m]
104
105
106def time_text():
107    return "%02d:%02d:%02d" % hms()
108
109
110# ============ STATUS ============
111mode = START_MODE
112setting = False            # Instelmodus
113long_done = False          # Lang indrukken afgehandeld voor deze druk
114marker_until = start       # Wanneer de modusmarkering eindigt
115sweep_at = None            # Begin van de lichtveeg
116blink_ref = start          # Begin van de knippercyclus
117last_press = start         # Laatste druk in instelmodus
118
119
120def report(prefix):
121    v = field_value(mode)
122    print("%s %s: %d = %s  (%s)" % (prefix, MODE_NAMES[mode], v, binary(v), time_text()))
123
124
125def save_setting(now):
126    global setting
127    setting = False
128    print("Tijd ingesteld: %s" % time_text())
129
130
131def on_short(now):
132    global mode, marker_until, clock_s, blink_ref, last_press
133    if setting:
134        # In instelmodus telt elke korte druk 1 op bij het gekozen veld
135        h, mi, s = hms()
136        if mode == HOUR:
137            h = (h + 1) % 24
138        else:
139            mi = (mi + 1) % 60
140        clock_s = h * 3600 + mi * 60 + s
141        blink_ref = now
142        last_press = now
143        report("+1")
144    else:
145        mode = (mode + 1) % 3
146        marker_until = time.ticks_add(now, MODE_MS)
147        report("Modus")
148
149
150def on_long(now):
151    global setting, clock_s, next_second, blink_ref, last_press
152    if setting:
153        if mode == MIN:
154            # Na het instellen van de minuten beginnen de seconden weer bij nul
155            clock_s -= clock_s % 60
156            next_second = time.ticks_add(now, 1000)
157        save_setting(now)
158    elif mode == SEC:
159        # In secondemodus zet lang indrukken de seconden op nul (synchroniseren met een tijdsignaal)
160        clock_s -= clock_s % 60
161        next_second = time.ticks_add(now, 1000)
162        print("Seconden op nul: %s" % time_text())
163    else:
164        setting = True
165        blink_ref = now
166        last_press = now
167        report("Instellen")
168
169
170def frame(now):
171    # Het ledpatroon nu: veeg > modusmarkering > instellen (knipperend) > waarde
172    if sweep_at is not None:
173        step = time.ticks_diff(now, sweep_at) // SWEEP_STEP_MS
174        pos = step % 10
175        return 1 << (pos if pos < 6 else 10 - pos)     # heen en weer
176    if time.ticks_diff(marker_until, now) > 0:
177        return MODE_MARKS[mode]
178    if setting and time.ticks_diff(now, blink_ref) // BLINK_MS % 2:
179        return 0
180    return field_value(mode)
181
182
183# ============ HOOFDLUS ============
184print("== BlueGrays · bluegrays.com ==")
185print("Pico Binaire klok")
186print("Kort indrukken: volgend veld, lang: instellen")
187print("LEDs: 32 16 8 4 2 1")
188report("Modus")
189
190next_loop = time.ticks_ms()
191while True:
192    now = time.ticks_ms()
193
194    # Secondeteller: elke volgende seconde wordt bij de vorige opgeteld, zodat hij nooit afwijkt
195    if time.ticks_diff(now, next_second) >= 0:
196        next_second = time.ticks_add(next_second, 1000)
197        clock_s = (clock_s + 1) % 86400
198        tick_led.value(1)
199        tick_off_at = time.ticks_add(now, TICK_MS)
200        if clock_s % 60 == 0:
201            print("Tijd %s" % time_text()[:5])
202        if clock_s % 3600 == 0 and not setting:
203            sweep_at = now                 # Heel uur: lichtveeg
204    if not setting and time.ticks_diff(now, tick_off_at) >= 0:
205        tick_led.value(0)
206    if sweep_at is not None and time.ticks_diff(now, sweep_at) >= SWEEP_STEP_MS * 10 * SWEEP_ROUNDS:
207        sweep_at = None
208
209    # Knop: kort indrukken werkt bij loslaten, lang indrukken zodra LONG_MS verstrijkt
210    b = button.update(now)
211    if b == 1:
212        long_done = False
213        sweep_at = None                    # Een druk stopt de veeg
214    elif button.down and not long_done and button.held_ms(now) >= LONG_MS:
215        long_done = True
216        on_long(now)
217    elif b == -1 and not long_done:
218        on_short(now)
219
220    if setting:
221        tick_led.value(1)          # Onboard-led aan tijdens het instellen
222        if time.ticks_diff(now, last_press) >= SET_TIMEOUT_MS:
223            save_setting(now)
224
225    show_bits(frame(now))
226
227    # Vaste stap: wacht tot de volgende 5 ms
228    next_loop = time.ticks_add(next_loop, LOOP_MS)
229    wait = time.ticks_diff(next_loop, time.ticks_ms())
230    if wait > 0:
231        time.sleep_ms(wait)
232    else:
233        next_loop = time.ticks_ms()
234

Veelgestelde vragen

Hoe lees ik een binaire klok?

Van links naar rechts zijn de leds 32, 16, 8, 4, 2 en 1 waard. Tel de waarden van de brandende leds op: in het patroon 001101 branden 8, 4 en 1, dus de waarde is 13. Uren komen nooit boven 23, dus de meest linkse led blijft in het urenveld donker. De Serial Monitor toont elke waarde met zijn binaire vorm.

Waarom zijn 6 leds genoeg?

Met 6 bits tel je van 0 tot 63 (2 tot de macht 6 = 64 waarden). Seconden en minuten gaan tot 59 en uren tot 23, dus ze passen allemaal in 6 bits. Om uren, minuten en seconden tegelijk te zien heb je voor elk veld een aparte rij leds nodig (17 leds in totaal).

Reset de klok na een stroomuitval?

Ja. De Pico heeft geen klok met batterijback-up, dus de code start bij elke opstart vanaf `START_TIME`. Een RTC-module met batterij, zoals de DS1307, zou de tijd bewaren. In dit project stel je na het inschakelen binnen een paar seconden met de knop de uren en minuten in.

Kan ik leds van verschillende kleuren gebruiken?

Ja. Rode, groene, gele en oranje leds branden bij 3,3 V prima met 220 Ω. Blauwe en witte leds hebben ongeveer 3 V nodig en kunnen bij 3,3 V zwak lijken; verlaag hun weerstand naar 100 Ω. Een andere kleur voor de hoge plaatsen maakt de klok makkelijker te lezen.