added people.json, results and ordering script

HW/timer_button/~timer_button.kicad_sch.lck

@@ -1 +0,0 @@
-{"hostname":"spock","username":"angoosh"}

SW/PC/Stopwatch/main.py

@@ -0,0 +1,201 @@
+import gi
+import threading
+import time
+import usb.core
+import usb.util
+import requests
+import json
+
+gi.require_version('Gtk', '4.0')
+from gi.repository import Gtk, Gio, Gdk, GLib
+
+DEBUG = False
+
+if DEBUG == True:
+    index = 2
+else:
+    index = 1
+activeCards = []    
+
+TIME = 60
+
+USB_IF      = 0 # Interface
+USB_TIMEOUT = 5 # Timeout in ms
+USB_VENDOR  = 0xffff # Vendor-ID:
+USB_PRODUCT = 0x0035 # Product-ID
+
+with open('people.json', 'r') as f:
+    db = json.load(f)
+
+class UsbCardReader():
+    def __init__(self, **kargs):
+        # Find the HID device by vendor/product ID
+        self.dev = usb.core.find(idVendor=USB_VENDOR, idProduct=USB_PRODUCT)
+        # Get and store the endpoint
+        self.endpoint = self.dev[0][(0,0)][0]
+        if self.dev.is_kernel_driver_active(USB_IF) is True:
+            self.dev.detach_kernel_driver(USB_IF)
+        # Claim the device
+        usb.util.claim_interface(self.dev, USB_IF)
+        self.receivedNumber = 0
+        
+        cardread=threading.Thread(target=self.read)
+        cardread.start()
+        
+    def read(self):
+        global win, activeCards, db
+        
+        print("Waiting for card")
+        receivedNumber = 0
+        
+        while True:
+            control = None
+            try:
+                control = self.dev.read(self.endpoint.bEndpointAddress, self.endpoint.wMaxPacketSize, USB_TIMEOUT)
+                if (control[2] != 40) & (control[2] != 0):
+                    receivedDigit = control[2] - 29
+                    if receivedDigit == 10:
+                        receivedDigit = 0
+                    receivedNumber = 10 * receivedNumber + receivedDigit
+                    
+                if (( control[0] == 0 )) & (( control[2] == 40 )) & (( not receivedNumber == 0 )):
+                    try:
+                        with open('people.json', 'r') as f:
+                            db = json.load(f)
+                        for i in db:
+                            if db[i] == receivedNumber:
+                                if i not in activeCards:
+                                    activeCards.append(i)
+                                    GLib.idle_add(win.arb, i)
+                                else:
+                                    print("Card is active now")
+                    except Exception as e: print(e)
+                    receivedNumber = 0
+                    
+            except KeyboardInterrupt:
+                exit()
+            except:
+                pass
+            
+            time.sleep(0.001)
+
+class GridRow():
+    def __init__(self, parent, runner, index):
+        self.id = runner
+        self.index = index
+        self.parent = parent
+        
+        self.grid = Gtk.Grid()
+        
+        if index % 2 == 0:
+            self.grid.set_name("lightgrid")
+        else:
+            self.grid.set_name("darkgrid")
+        
+        self.runid = Gtk.Label(label=str(runner), name="gridlabel")
+        self.runid.set_justify(2)
+        self.runid.set_width_chars(10)
+        
+        self.runb = Gtk.Label(label='00:00', name="gridlabel")
+        self.runb.set_hexpand(1)
+        
+        self.grid.attach(self.runid, 0, 0, 1, 1)
+        self.grid.attach(self.runb, 1, 0, 1, 1)
+        
+        parent.grid.attach(self.grid, 0, index, 2, 1)
+        
+        countdown=threading.Thread(target=self.updateTime)
+        countdown.start()
+        
+    def printIndex(self, button):
+        print(self.index)
+        
+    def updateTime(self):
+        t = TIME
+        while t >= -10:
+            if t < 0:
+                mins, secs = divmod((t * -1), 60)
+                timer = '-{:02d}:{:02d}'.format(mins, secs)
+            else:
+                mins, secs = divmod(t, 60)
+                timer = '{:02d}:{:02d}'.format(mins, secs)
+            GLib.idle_add(self.runb.set_label, timer)
+            time.sleep(1) 
+            t -= 1
+            if t == 10:
+                if self.grid.get_name() == "lightgrid":
+                    GLib.idle_add(self.grid.set_name, "lredgrid")
+                else:
+                    GLib.idle_add(self.grid.set_name, "dredgrid")
+            
+        GLib.idle_add(GridWindow.remRow, self.parent)
+
+class GridWindow(Gtk.ApplicationWindow):
+    def __init__(self, **kargs):
+        super().__init__(**kargs, title='Alkator Clock')
+        
+        css_provider = Gtk.CssProvider()
+        css_provider.load_from_file(Gio.File.new_for_path("style.css"))
+        Gtk.StyleContext.add_provider_for_display(Gdk.Display.get_default(), css_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
+        self.set_default_size(640, 480)
+
+        button1 = Gtk.Button(label='addrow')
+        button2 = Gtk.Button(label='rmrow')
+        
+        button1.connect("clicked", self.arb)
+        button2.connect("clicked", self.rrb)
+        
+        runlabel = Gtk.Label(label="ID", name="gridlabel")
+        runlabel.set_justify(2)
+        cntlabel = Gtk.Label(label="Countdown", name="gridlabel")
+        cntlabel.set_justify(2)
+        
+        self.runners = []
+
+        self.grid = Gtk.Grid()
+        if DEBUG == True:
+            self.grid.attach(button1, 0, 0, 1, 1)
+            self.grid.attach(button2, 1, 0, 2, 1)
+            self.grid.attach(runlabel, 0, 1, 1, 1)
+            self.grid.attach(cntlabel, 1, 1, 2, 1)
+        else:
+            self.grid.attach(runlabel, 0, 0, 1, 1)
+            self.grid.attach(cntlabel, 1, 0, 2, 1)
+
+        self.set_child(self.grid)
+        
+    def arb(self, personId):
+        global index
+        self.runners.append(GridRow(self, personId, index))
+        index += 1
+        
+    def rrb(self, button):
+        global index
+        self.remRow()
+        
+    def addRow(self, runner, index):
+        runid = Gtk.Label(label=str(runner))
+        runb = Gtk.Button(label='time_placeholder')
+        
+        self.grid.attach(runid, 0, index, 1, 1)
+        self.grid.attach(runb, 1, index, 1, 1)
+        
+    def remRow(self):
+        global index, activeCards
+        if index > 1:
+            self.grid.remove_row(1)
+            index -= 1
+            del activeCards[0]
+
+
+def on_activate(app):
+    # Create window
+    global win
+    win = GridWindow(application=app)
+    win.present()
+
+UsbCardReader()
+app = Gtk.Application(application_id='com.example.App')
+app.connect('activate', on_activate)
+
+app.run(None)

SW/PC/Stopwatch/order.py

@@ -0,0 +1,23 @@
+import operator
+import json
+
+db=""
+res={}
+
+with open('times.json', 'r') as f:
+    db = json.load(f)
+
+for i in db:
+    try:
+        res[i] = db[i]["duration"]
+        print(i, db[i]["duration"])
+    except:
+        print(i)
+        pass
+
+#print(res)
+
+order = dict(sorted(res.items(), key=lambda item: item[1]))
+
+with open("results.json", 'a') as f:
+    f.write(json.dumps(order, indent = 4))

SW/PC/Stopwatch/people.json

@@ -0,0 +1,102 @@
+{
+    "1": 1114418469,
+    "2": 1111554085,
+    "3": 1112605381,
+    "4": 1362080126,
+    "5": 1632101230,
+    "6": 1114533941,
+    "7": 1364901054,
+    "8": 1364587710,
+    "9": 1364867822,
+    "10": 1364554558,
+    "11": 1364968750,
+    "12": 1111614357,
+    "13": 1362569198,
+    "14": 1364867662,
+    "15": 1112618821,
+    "16": 1364967150,
+    "17": 1364592718,
+    "18": 1364487310,
+    "19": 458336708,
+    "20": 1111590293,
+    "21": 1114448773,
+    "22": 1364550814,
+    "23": 1112421509,
+    "24": 1364529422,
+    "25": 1364916590,
+    "26": 455988804,
+    "27": 1631963022,
+    "28": 1114508533,
+    "29": 1364590606,
+    "30": 1364796894,
+    "31": 1112489029,
+    "32": 1114588261,
+    "33": 1111733589,
+    "34": 1112469509,
+    "35": 1632521678,
+    "36": 1631957710,
+    "37": 1111682853,
+    "38": 1111882197,
+    "39": 1631960974,
+    "40": 1362260606,
+    "41": 1364521806,
+    "42": 1364489406,
+    "43": 1361969902,
+    "44": 1364581838,
+    "45": 1364520526,
+    "46": 1361806574,
+    "47": 1364581310,
+    "48": 1364551150,
+    "49": 1364916158,
+    "50": 1364529662,
+    "51": 1632026766,
+    "52": 1364588798,
+    "53": 1631955550,
+    "54": 1631972606,
+    "55": 1364797086,
+    "56": 1364627198,
+    "57": 1364556446,
+    "58": 1632070414,
+    "59": 1631951758,
+    "60": 1364794654,
+    "61": 1632101166,
+    "62": 1361810574,
+    "63": 1114573589,
+    "64": 1361967886,
+    "65": 1632544222,
+    "66": 1111582085,
+    "67": 1362569438,
+    "68": 1364593198,
+    "69": 1364761406,
+    "70": 1631927918,
+    "71": 1364544414,
+    "72": 1362264958,
+    "73": 1364767006,
+    "74": 1364590110,
+    "75": 1362082334,
+    "76": 1364799166,
+    "77": 1632028398,
+    "78": 1361970078,
+    "79": 1364485118,
+    "80": 1364490846,
+    "81": 1632150846,
+    "82": 1362569342,
+    "83": 1362599998,
+    "84": 1632523854,
+    "85": 1364765134,
+    "86": 1631952062,
+    "87": 1364559822,
+    "88": 1364783854,
+    "89": 1362081950,
+    "90": 1111644021,
+    "91": 1631959326,
+    "92": 1364901422,
+    "93": 1632100830,
+    "94": 1111707429,
+    "95": 1632026702,
+    "96": 1362569022,
+    "97": 1114560181,
+    "98": 1364588510,
+    "99": 1364785486,
+    "100": 1361969950
+}

SW/PC/Stopwatch/results.json

@@ -0,0 +1,34 @@
+{
+    "2": "0:35:59.818971",
+    "29": "1:10:52.076408",
+    "14": "1:11:35.670162",
+    "9": "1:14:40",
+    "10": "1:16:02.174205",
+    "12": "1:18:12.521345",
+    "26": "1:21:24.962008",
+    "8": "1:23:45.241021",
+    "5": "1:24:33.080748",
+    "3": "1:25:36.486060",
+    "25": "1:26:57.409779",
+    "27": "1:32:49.493213",
+    "18": "1:35:04.610546",
+    "6": "1:35:28.914085",
+    "21": "1:35:29.494112",
+    "28": "1:37:56.900763",
+    "13": "1:39:20.394593",
+    "17": "1:39:59.664271",
+    "4": "1:40:15.602185",
+    "15": "1:41:16.795669",
+    "20": "1:43:29.166855",
+    "16": "1:48:28.014745",
+    "19": "1:48:37.692711",
+    "30": "1:48:51.712639",
+    "11": "1:48:56.350571",
+    "22": "1:49:04.450512",
+    "31": "2:05:10.107744",
+    "24": "2:05:33.883454",
+    "7": "2:05:42.955540",
+    "32": "2:06:17.053222",
+    "23": "2:11:50.391043",
+    "1": "2:24:50.507501"
+}

SW/PC/Stopwatch/rfid_read.py

@@ -0,0 +1,51 @@
+import usb.core 
+import usb.util 
+import time 
+import requests 
+import json
+ 
+USB_IF      = 0 # Interface 
+USB_TIMEOUT = 5 # Timeout in MS 
+USB_VENDOR  = 0xffff # Vendor-ID:  
+USB_PRODUCT = 0x0035 # Product-ID 
+ 
+# Find the HID device by vender/product ID
+dev = usb.core.find(idVendor=USB_VENDOR, idProduct=USB_PRODUCT) 
+ 
+# Get and store the endpoint 
+endpoint = dev[0][(0,0)][0] 
+ 
+if dev.is_kernel_driver_active(USB_IF) is True: 
+    dev.detach_kernel_driver(USB_IF) 
+ 
+# Claim the device 
+usb.util.claim_interface(dev, USB_IF) 
+ 
+receivedNumber = 0 
+while True: 
+    control = None 
+     
+    try: 
+        # Read a character from the device 
+        control = dev.read(endpoint.bEndpointAddress, endpoint.wMaxPacketSize, USB_TIMEOUT)
+        # Here you have to analyze what's coming in.
+        # In my case you had to check the first byte (command)
+        if (control[2] != 40) & (control[2] != 0):
+            # Convert ascii to a number, there's probably better ways to do so.
+            receivedDigit = control[2] - 29
+        
+            if receivedDigit == 10: 
+                receivedDigit = 0
+                
+            # Append the digit to the number
+            receivedNumber = 10 * receivedNumber + receivedDigit 
+        
+        # Check if the received character is CRLF
+        if (( control[0] == 0 )) & (( control[2] == 40 )) & (( not receivedNumber == 0 )): 
+            print('cardNumber:', receivedNumber)
+    except KeyboardInterrupt: 
+        exit()
+    except: 
+        pass 
+     
+    time.sleep(0.001) # Let CTRL+C actually exit 

SW/PC/Stopwatch/run.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+GTK_THEME=Adwaita:light python ./main.py

SW/PC/Stopwatch/start_finish_stopwatch.py

@@ -0,0 +1,110 @@
+import threading
+import time
+import usb.core
+import usb.util
+import requests
+import json
+import datetime
+
+DEBUG = False
+
+if DEBUG == True:
+    index = 2
+else:
+    index = 1
+activeCards = []    
+
+TIME = 600
+
+USB_IF      = 0 # Interface
+USB_TIMEOUT = 5 # Timeout in ms
+USB_VENDOR  = 0xffff # Vendor-ID:
+USB_PRODUCT = 0x0035 # Product-ID
+
+with open('people.json', 'r') as f:
+    db = json.load(f)
+
+try:
+    times = {}
+    with open('times.json', 'r') as f:
+        times_json = json.load(f)
+    for i in times_json:
+        times[i] = {}
+        times[i]['start'] = datetime.datetime.strptime(times_json[i]['start'],"%d/%m/%Y, %H:%M:%S")
+        try:
+            times[i]['end'] = datetime.datetime.strptime(times_json[i]['end'],"%d/%m/%Y, %H:%M:%S")
+            times[i]['duration'] = times[i]['end'] - times[i]['start']
+        except:
+            print(i, "Not finished yet")
+    print(times)
+except Exception as e: print(e)
+#except:
+#    times = {}
+#    times_json = {}
+
+class UsbCardReader():
+    def __init__(self, **kargs):
+        # Find the HID device by vendor/product ID
+        self.dev = usb.core.find(idVendor=USB_VENDOR, idProduct=USB_PRODUCT)
+        # Get and store the endpoint
+        self.endpoint = self.dev[0][(0,0)][0]
+        if self.dev.is_kernel_driver_active(USB_IF) is True:
+            self.dev.detach_kernel_driver(USB_IF)
+        # Claim the device
+        usb.util.claim_interface(self.dev, USB_IF)
+        self.receivedNumber = 0
+        
+        cardread=threading.Thread(target=self.read)
+        cardread.start()
+        
+    def read(self):
+        global activeCards, db, times, times_json
+        
+        print("Waiting for card")
+        receivedNumber = 0
+        
+        while True:
+            control = None
+            try:
+                control = self.dev.read(self.endpoint.bEndpointAddress, self.endpoint.wMaxPacketSize, USB_TIMEOUT)
+                if (control[2] != 40) & (control[2] != 0):
+                    receivedDigit = control[2] - 29
+                    if receivedDigit == 10:
+                        receivedDigit = 0
+                    receivedNumber = 10 * receivedNumber + receivedDigit
+                    
+                if (( control[0] == 0 )) & (( control[2] == 40 )) & (( not receivedNumber == 0 )):
+                    try:
+                        with open('people.json', 'r') as f:
+                            db = json.load(f)
+                        for i in db:
+                            if db[i] == receivedNumber:
+                                print("Runner:", i)
+                                print(db)
+                                runner_found = False
+                                for j in times:
+                                    if j == i:
+                                        runner_found = True
+                                        times[j]['end'] = datetime.datetime.now()
+                                        times[j]['duration'] = times[j]['end'] - times[j]['start']
+                                        times_json[j]['end'] = times[j]['end'].strftime("%d/%m/%Y, %H:%M:%S")
+                                        times_json[j]['duration'] = str(times[j]['duration'])
+                                if runner_found == False:
+                                    times[i] = {}
+                                    times[i]['start'] = datetime.datetime.now()
+                                    times_json[i] = {}
+                                    times_json[i]['start'] = times[i]['start'].strftime("%d/%m/%Y, %H:%M:%S")
+                                with open("times.json", 'w') as f:
+                                    f.write(json.dumps(times_json, indent = 4))
+                                print(times)
+                    except Exception as e: print(e)
+                    receivedNumber = 0
+                    
+            except KeyboardInterrupt:
+                exit()
+            except:
+                pass
+            
+            time.sleep(0.001)
+
+UsbCardReader()

SW/PC/Stopwatch/style.css

@@ -0,0 +1,20 @@
+#lightgrid {
+    background-color: #F0F0F0;
+}
+
+#darkgrid {
+    background-color: #D0D0D0;
+}
+
+#lredgrid {
+    background-color: #FF8888;
+}
+
+#dredgrid {
+    background-color: #FF6666;
+}
+
+#gridlabel {
+    font-size: 16pt;
+    font-weight: bold;
+}

SW/PC/Stopwatch/times.json

@@ -0,0 +1,160 @@
+{
+    "1": {
+        "start": "31/05/2025, 10:00:08",
+        "end": "31/05/2025, 12:24:58",
+        "duration": "2:24:50.507501"
+    },
+    "2": {
+        "start": "31/05/2025, 10:05:37",
+        "end": "31/05/2025, 10:41:37",
+        "duration": "0:35:59.818971"
+    },
+    "3": {
+        "start": "31/05/2025, 10:10:09",
+        "end": "31/05/2025, 11:35:45",
+        "duration": "1:25:36.486060"
+    },
+    "4": {
+        "start": "31/05/2025, 10:15:14",
+        "end": "31/05/2025, 11:55:30",
+        "duration": "1:40:15.602185"
+    },
+    "5": {
+        "start": "31/05/2025, 10:20:08",
+        "end": "31/05/2025, 11:44:41",
+        "duration": "1:24:33.080748"
+    },
+    "6": {
+        "start": "31/05/2025, 10:25:01",
+        "end": "31/05/2025, 12:00:30",
+        "duration": "1:35:28.914085"
+    },
+    "7": {
+        "start": "31/05/2025, 10:30:01",
+        "end": "31/05/2025, 12:35:44",
+        "duration": "2:05:42.955540"
+    },
+    "8": {
+        "start": "31/05/2025, 10:35:05",
+        "end": "31/05/2025, 11:58:50",
+        "duration": "1:23:45.241021"
+    },
+    "9": {
+        "start": "31/05/2025, 10:39:57"
+    },
+    "10": {
+        "start": "31/05/2025, 10:42:01",
+        "end": "31/05/2025, 11:58:03",
+        "duration": "1:16:02.174205"
+    },
+    "11": {
+        "start": "31/05/2025, 10:45:03",
+        "end": "31/05/2025, 12:33:59",
+        "duration": "1:48:56.350571"
+    },
+    "12": {
+        "start": "31/05/2025, 10:49:58",
+        "end": "31/05/2025, 12:08:10",
+        "duration": "1:18:12.521345"
+    },
+    "13": {
+        "start": "31/05/2025, 10:55:01",
+        "end": "31/05/2025, 12:34:21",
+        "duration": "1:39:20.394593"
+    },
+    "14": {
+        "start": "31/05/2025, 10:59:57",
+        "end": "31/05/2025, 12:11:33",
+        "duration": "1:11:35.670162"
+    },
+    "15": {
+        "start": "31/05/2025, 11:05:09",
+        "end": "31/05/2025, 12:46:25",
+        "duration": "1:41:16.795669"
+    },
+    "16": {
+        "start": "31/05/2025, 11:10:01",
+        "end": "31/05/2025, 12:58:29",
+        "duration": "1:48:28.014745"
+    },
+    "17": {
+        "start": "31/05/2025, 11:15:00",
+        "end": "31/05/2025, 12:55:00",
+        "duration": "1:39:59.664271"
+    },
+    "18": {
+        "start": "31/05/2025, 11:20:01",
+        "end": "31/05/2025, 12:55:05",
+        "duration": "1:35:04.610546"
+    },
+    "19": {
+        "start": "31/05/2025, 11:25:00",
+        "end": "31/05/2025, 13:13:38",
+        "duration": "1:48:37.692711"
+    },
+    "20": {
+        "start": "31/05/2025, 11:29:58",
+        "end": "31/05/2025, 13:13:27",
+        "duration": "1:43:29.166855"
+    },
+    "21": {
+        "start": "31/05/2025, 11:35:30",
+        "end": "31/05/2025, 13:11:00",
+        "duration": "1:35:29.494112"
+    },
+    "22": {
+        "start": "31/05/2025, 11:40:02",
+        "end": "31/05/2025, 13:29:06",
+        "duration": "1:49:04.450512"
+    },
+    "23": {
+        "start": "31/05/2025, 11:44:59",
+        "end": "31/05/2025, 13:56:49",
+        "duration": "2:11:50.391043"
+    },
+    "24": {
+        "start": "31/05/2025, 11:50:45",
+        "end": "31/05/2025, 13:56:19",
+        "duration": "2:05:33.883454"
+    },
+    "25": {
+        "start": "31/05/2025, 11:55:04",
+        "end": "31/05/2025, 13:22:02",
+        "duration": "1:26:57.409779"
+    },
+    "26": {
+        "start": "31/05/2025, 12:00:00",
+        "end": "31/05/2025, 13:21:24",
+        "duration": "1:21:24.962008"
+    },
+    "27": {
+        "start": "31/05/2025, 12:05:01",
+        "end": "31/05/2025, 13:37:51",
+        "duration": "1:32:49.493213"
+    },
+    "28": {
+        "start": "31/05/2025, 12:10:03",
+        "end": "31/05/2025, 13:48:00",
+        "duration": "1:37:56.900763"
+    },
+    "29": {
+        "start": "31/05/2025, 12:14:58",
+        "end": "31/05/2025, 13:25:50",
+        "duration": "1:10:52.076408"
+    },
+    "30": {
+        "start": "31/05/2025, 12:20:02",
+        "end": "31/05/2025, 14:08:54",
+        "duration": "1:48:51.712639"
+    },
+    "31": {
+        "start": "31/05/2025, 12:50:10",
+        "end": "31/05/2025, 14:55:20",
+        "duration": "2:05:10.107744"
+    },
+    "32": {
+        "start": "31/05/2025, 12:50:13",
+        "end": "31/05/2025, 14:56:30",
+        "duration": "2:06:17.053222"
+    }
+}

SW/PC/Stopwatch/zapis_zavodniku.py

@@ -0,0 +1,84 @@
+import time
+import usb.core
+import usb.util
+import requests
+import json
+import threading
+
+USB_IF      = 0 # Interface
+USB_TIMEOUT = 5 # Timeout in ms
+USB_VENDOR  = 0xffff # Vendor-ID:
+USB_PRODUCT = 0x0035 # Product-ID
+
+activeCards = {}
+
+try:
+    with open('people.json', 'r') as f:
+        activeCards = json.load(f)
+except:
+    print("No people.json found")
+
+class UsbCardReader():
+    def __init__(self, **kargs):
+        # Find the HID device by vendor/product ID
+        self.dev = usb.core.find(idVendor=USB_VENDOR, idProduct=USB_PRODUCT)
+        # Get and store the endpoint
+        self.endpoint = self.dev[0][(0,0)][0]
+        if self.dev.is_kernel_driver_active(USB_IF) is True:
+            self.dev.detach_kernel_driver(USB_IF)
+        # Claim the device
+        usb.util.claim_interface(self.dev, USB_IF)
+        self.receivedNumber = 0
+        
+    def read(self):
+        global activeCards
+        
+        print("Priloz kartu")
+        
+        while True:
+            control = None
+            try:
+                control = self.dev.read(self.endpoint.bEndpointAddress, self.endpoint.wMaxPacketSize, USB_TIMEOUT)
+                if (control[2] != 40) & (control[2] != 0):
+                    receivedDigit = control[2] - 29
+                    if receivedDigit == 10:
+                        receivedDigit = 0
+                    self.receivedNumber = 10 * self.receivedNumber + receivedDigit
+                    
+                if (( control[0] == 0 )) & (( control[2] == 40 )) & (( not self.receivedNumber == 0 )):
+                    try:
+                        cardPresent = False
+                        for i in activeCards:
+                            if activeCards[i] == self.receivedNumber:
+                                cardPresent = True
+                                break
+                        if cardPresent == False:
+                            assign=threading.Thread(target=self.assign)
+                            assign.start()
+                        else:
+                            print("Naramek jiz zaregistrovan")
+                            self.receivedNumber = 0
+                            print("Priloz kartu")
+                    except Exception as e: print(e)
+                    
+            except KeyboardInterrupt:
+                exit()
+            except:
+                pass
+            
+            time.sleep(0.001)
+
+    def assign(self):
+        global activeCards
+        
+        n = input("Cislo zavodnika: ")
+        activeCards[str(n)] = self.receivedNumber
+        with open('people.json', 'w') as f:
+            f.write(json.dumps(activeCards, indent = 4))
+            self.receivedNumber = 0
+        print("Ulozeno, priloz kartu")
+            
+if __name__ == "__main__":
+    reader = UsbCardReader()
+    print("Zapis zavodniku ready")
+    reader.read()

SW/RPi_Pico_Button/main.py

@@ -11,7 +11,9 @@ BRIGHTNESS = 0.2  # Adjust the brightness (0.0 - 1.0)
 
 led_strip = neopixel.NeoPixel(Pin(ws_pin), led_num)
 
-push_button = Pin(24,Pin.IN,Pin.PULL_UP)
+push_button = Pin(24, Pin.IN, Pin.PULL_UP)
+buzzer = Pin(3, Pin.OUT)
+led = Pin(25, Pin.OUT)
 
 pushbutton_pressed = 0
 blink_interrupted = 0
@@ -80,19 +82,24 @@ def blink_and_beep(times):
     blink_delay = 0.2
     
     #insert beep
+    buzzer.value(1)
     for i in range(0, times):
         set_neopixel_color(255, 0, 0)
+        buzzer.value(0)
         time.sleep(blink_delay)
         set_neopixel_color(0, 0, 0)
+        buzzer.value(1)
         time.sleep(blink_delay)
         if pushbutton_pressed == 1:
             pushbutton_pressed = 0
             blink_interrupted = 1
             i = times
+            buzzer.value(0)
             return
+    buzzer.value(0)
     
 ten_min_timer = 0
-ten_min_timer_led_index = 0
+ten_min_timer_led_index = 11
 def count_10_min():
     global ten_min_timer, ten_min_timer_led_index, pushbutton_pressed, blink_interrupted
     
@@ -107,7 +114,7 @@ def count_10_min():
     if (ten_min_timer % 60) == 0:
         if ten_min_timer_led_index == 10:
             pushbutton_pressed = 0
-            blink_and_beep(60)
+            blink_and_beep(15)
             if blink_interrupted == 1:
                 blink_interrupted = 0
                 return
@@ -135,6 +142,22 @@ def button_callback(push_button):
 set_neopixel_color(0,0,0)
 push_button.irq(trigger=Pin.IRQ_FALLING, handler=button_callback)
 
+green = (0, 255, 0)
+green = set_neopixel_brightness(green)
+led_strip[0] = green
+led_strip[2] = green
+led_strip[4] = green
+led_strip[6] = green
+led_strip[8] = green
+led_strip.write()
+
+led_state = False
 while True:
     count_10_min()
     time.sleep(1)
+    if led_state:
+        led.low()
+        led_state = False
+    else:
+        led.high()
+        led_state = True