misplaced start and finish

SW/PC/Alkator_count_results.py

@@ -30,8 +30,3 @@ for id in data_dict:
 print(results)
 dict(sorted(results.items(), key=lambda item: item[0]))
 print(results)
-
-    
-
-    
-        

SW/PC/Stopwatch/config.json

@@ -0,0 +1,7 @@
+{
+    "station_id": 2,
+    "host": "https://beta.alkator.cz",
+    "login": "station_register@alkator.cz",
+    "password": "password_heslo",
+    "countdown_seconds": 60
+}

SW/PC/Stopwatch/log.json

@@ -0,0 +1 @@
+[]

SW/PC/Stopwatch/main.py

@@ -1,88 +1,103 @@
 import gi
 import threading
 import time
-import usb.core
-import usb.util
+import datetime
 import requests
 import json
 
 gi.require_version('Gtk', '4.0')
+from queue import Queue
 from gi.repository import Gtk, Gio, Gdk
+from requests.adapters import HTTPAdapter, Retry
+from usbcardreader import UsbCardReader
+
+
+with open('config.json', 'r') as f:
+    config = json.load(f)
 
-DEBUG = False
 
-if DEBUG == True:
-    index = 2
-else:
-    index = 1
 activeCards = []
 
-TIME = 600
+TIME = config['countdown_seconds']
 
-USB_IF      = 0 # Interface
-USB_TIMEOUT = 5 # Timeout in ms
-USB_VENDOR  = 0xffff # Vendor-ID:
-USB_PRODUCT = 0x0035 # Product-ID
+db = {}
 
-with open('people.json', 'r') as f:
-    db = json.load(f)
+queue_to_send = []
 
-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()
+session = requests.Session()
 
-    def read(self):
-        global win, activeCards, db
 
-        print("Waiting for card")
-        receivedNumber = 0
+retries = Retry(total=10,
+                backoff_factor=1,
+                status_forcelist=[ 500, 502, 503, 504 ])
 
+session.mount('https://', HTTPAdapter(max_retries=retries))
+
+
+session.post(config['host'] + '/api/login', {'email':config['login'], 'password': config['password']})
+
+def refreshDb():
+    global db
+    resp = session.get(config['host'] + '/api/racers')
+    if resp.status_code == 200:
+        json = resp.json()
+        db = {}
+        for racer in json:
+            if racer["card_id"]:
+                db[racer["card_id"]] = racer
+
+
+def refreshDbEvery3mins():
     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
+        refreshDb()
+        time.sleep(3 * 60)
 
-                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)
-                                    win.arb(i)
+
+threading.Thread(target=refreshDbEvery3mins).start()
+
+log = []
+
+
+with open('log.json', 'r') as f:
+    log = json.loads(f.read())
+
+
+queue = Queue()
+
+
+def worker():
+    while True:
+        item = queue.get()
+        log.append(item)
+        with open('log.json', 'w') as f:
+            f.write(json.dumps(log))
+        response = session.post(item['url'], json=item['json'])
+        print(item, response)
+
+
+threading.Thread(target=worker).start()
+
+
+def callbackOnCard(card_id):
+    global win, activeCards, db
+    if card_id not in db:
+        refreshDb()
+    if card_id in db:
+        if card_id not in activeCards:
+            activeCards.append(card_id)
+            win.arb(db[card_id])
+            print('Card is active now')
         else:
-                                    print("Card is active now")
-                    except Exception as e: print(e)
-                    receivedNumber = 0
+            print('Card is already active')
+    else:
+        print(f'Card {card_id} not found in db')
 
-            except KeyboardInterrupt:
-                exit()
-            except:
-                pass
-            
-            time.sleep(0.001)
 
 class GridRow():
-    def __init__(self, parent, runner, index):
-        self.id = runner
-        self.index = index
+    def __init__(self, parent, racer, index):
+        global queue_to_send
+        self.id = racer['starting_number']
         self.parent = parent
 
         self.grid = Gtk.Grid()
@@ -92,7 +107,7 @@ class GridRow():
         else:
             self.grid.set_name("darkgrid")
 
-        self.runid = Gtk.Label(label=str(runner), name="gridlabel")
+        self.runid = Gtk.Label(label=str(racer["starting_number"]), name="gridlabel")
         self.runid.set_justify(2)
         self.runid.set_width_chars(10)
 
@@ -107,6 +122,12 @@ class GridRow():
         countdown=threading.Thread(target=self.updateTime)
         countdown.start()
 
+        queue.put({'url': config['host'] + '/api/station/register', 'json': {
+            'card_id': racer['card_id'],
+            'station_id': config['station_id'],
+            'time': datetime.datetime.now().strftime('%d.%m.%Y %H:%M:%S.%f')
+        }})
+
     def printIndex(self, button):
         print(self.index)
 
@@ -138,12 +159,6 @@ class GridWindow(Gtk.ApplicationWindow):
         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)
 
-        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")
@@ -152,24 +167,15 @@ class GridWindow(Gtk.ApplicationWindow):
         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 arb(self, racer):
+        self.runners.append(GridRow(self, racer, len(activeCards)))
 
     def rrb(self, button):
-        global index
         self.remRow()
 
     def addRow(self, runner, index):
@@ -180,10 +186,9 @@ class GridWindow(Gtk.ApplicationWindow):
         self.grid.attach(runb, 1, index, 1, 1)
 
     def remRow(self):
-        global index, activeCards
-        if index > 1:
+        global activeCards
+        if len(activeCards) > 0:
             self.grid.remove_row(1)
-            index -= 1
             del activeCards[0]
 
 
@@ -193,7 +198,7 @@ def on_activate(app):
     win = GridWindow(application=app)
     win.present()
 
-UsbCardReader()
+UsbCardReader(callbackOnCard)
 app = Gtk.Application(application_id='com.example.App')
 app.connect('activate', on_activate)
 

SW/PC/Stopwatch/registrace.py

@@ -0,0 +1,184 @@
+import sys
+import datetime
+import requests
+import threading
+import json
+from PyQt6 import QtWidgets, uic, QtGui, QtCore
+from PyQt6.QtCore import pyqtSignal as Signal, pyqtSlot as Slot
+from queue import Queue
+
+from requests.adapters import HTTPAdapter, Retry
+from usbcardreader import UsbCardReader
+
+app = QtWidgets.QApplication(sys.argv)
+
+with open('config.json', 'r') as f:
+    config = json.load(f)
+
+session = requests.Session()
+session.post(config['host'] + '/api/login', {'email':config['login'], 'password': config['password']})
+
+
+retries = Retry(total=10,
+                backoff_factor=1,
+                status_forcelist=[ 500, 502, 503, 504 ],)
+
+session.mount('https://', HTTPAdapter(max_retries=retries))
+
+
+last_card = 0
+last_time = datetime.datetime.now()
+
+racers = []
+
+log = []
+
+
+with open('log.json', 'r') as f:
+    log = json.loads(f.read())
+
+
+queue = Queue()
+
+
+class Worker(QtCore.QThread):
+    returned_state = Signal(str)
+    def __init__(self):
+        super().__init__()
+        self.returned_state.connect(self.handle_returned_state)
+        self.worker_thread = threading.Thread(target=self.worker)
+        self.worker_thread.start()
+
+    def worker(self):
+        while True:
+            item = queue.get()
+            log.append({
+                'url': item['url'],
+                'json': item['json'],
+            })
+            with open('log.json', 'w') as f:
+                f.write(json.dumps(log))
+            response = session.post(item['url'], json=item['json'])
+            if response.status_code == 200:
+                if item.get('on_success'):
+                    item['on_success']()
+                if item.get('message'):
+                    self.returned_state.emit(f'{item['message']}')
+            else:
+                if item.get('failed'):
+                    self.returned_state.emit(f'{item['failed']}')
+
+            print(item, response)
+    def handle_returned_state(self, state):
+        mb = QtWidgets.QMessageBox(text=f"{state}")
+        mb.exec()
+
+
+worker = Worker()
+
+
+def register_racer():
+    card_id = last_card
+    index = window.racers.currentIndex()
+    if not index.data():
+        mb = QtWidgets.QMessageBox(text='Prosím vyberte závodníka!')
+        mb.exec()
+        return
+    racer_id = int(index.data().split(' ')[-1])
+    try:
+        starting_number = max(filter(lambda r: r['starting_number'], racers), key=lambda racer: racer['starting_number'])['starting_number'] + 1
+    except ValueError:
+        starting_number = 1
+    racer = list(filter(lambda x: x['racer_id'] == racer_id, racers))[0]
+
+    def register_update_racer():
+        racer['card_id'] = card_id
+        racer['starting_number'] = starting_number
+        racer['started'] = False
+        updateRacers()
+
+    queue.put({
+        'url': config['host'] + '/api/card/register',
+        'json': {'racer_id': racer_id, 'starting_number': starting_number, 'card_id': card_id, 'time': datetime.datetime.now().strftime('%d.%m.%Y %H:%M:%S.%f')},
+        'message': f"Úspěšné zaregistrování závodníka {racer['first_name']} {racer['last_name']} se startovním číslem {starting_number}!",
+        'failed': f"Neúspěšná registrace závodníka {racer['first_name']} {racer['last_name']}",
+        'on_success': register_update_racer,
+    })
+
+
+model = QtGui.QStandardItemModel()
+
+def updateRacers():
+    model.clear()
+    for racer in racers:
+        if racer['starting_number'] or racer['card_id']:
+            continue
+        item = QtGui.QStandardItem(f"{racer['last_name']} {racer['first_name']} {racer['date_of_birth']} {racer['racer_id']}")
+        model.appendRow(item)
+
+
+updateRacers()
+
+
+def reload_racers():
+    global racers
+    response = session.get(config['host'] + '/api/racers')
+
+    racers = response.json()
+    updateRacers()
+
+
+reload_racers()
+
+
+def findByCard(card_id):
+    for racer in racers:
+        if racer['card_id'] == card_id:
+            return racer
+
+
+def updateLastCard(card_id):
+    global last_card, last_time
+    if card_id == last_card and datetime.datetime.now() - last_time < datetime.timedelta(seconds=15):
+        return
+    time = last_time = datetime.datetime.now()
+    last_card = card_id
+    window.lastCard.setText(str(card_id))
+
+    racer = findByCard(card_id)
+    if racer:
+        if racer['started']:
+            def finish_update_racer():
+                racer['card_id'] = None
+            queue.put({
+                'url': config['host'] + '/api/card/unregister',
+                'json': {'racer_id': racer['racer_id'], 'starting_number': racer['starting_number'], 'card_id': card_id, 'time': time.strftime('%d.%m.%Y %H:%M:%S.%f')},
+                'message': f"Úspěšné odhlášení závodníka {racer['starting_number']}!",
+                'failed': f"Neúspěšné odhlášení karty závodníka {racer['starting_number']}",
+                'on_success': finish_update_racer,
+            })
+        else:
+            def start_update_racer():
+                racer['started'] = True
+            queue.put({
+                'url': config['host'] + '/api/station/register',
+                'json': {'card_id': card_id, 'time': time.strftime('%d.%m.%Y %H:%M:%S.%f'), 'station_id': 1},
+                'message': f"Úspěšné odstartování závodníka {racer['starting_number']}!",
+                'failed': f"Núspěšné odstartování závodníka {racer['starting_number']}, prosím registraci opakujte!",
+                'on_success': start_update_racer,
+            })
+
+
+UsbCardReader(updateLastCard)
+
+
+
+
+window = uic.loadUi("registrace.ui")
+window.racers.setModel(model)
+window.register_racer.clicked.connect(register_racer)
+window.reload_racers.clicked.connect(reload_racers)
+window.show()
+
+
+app.exec()

SW/PC/Stopwatch/registrace.ui

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Frame</class>
+ <widget class="QFrame" name="Frame">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>315</width>
+    <height>289</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Registrace závodníků</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="4" column="0">
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Orientation::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>40</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="0" column="0">
+    <widget class="QPushButton" name="register_racer">
+     <property name="text">
+      <string>Registrovat</string>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="0">
+    <widget class="QLineEdit" name="lastCard"/>
+   </item>
+   <item row="1" column="0">
+    <widget class="QLabel" name="label_2">
+     <property name="text">
+      <string>číslo karty</string>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="1" rowspan="5">
+    <widget class="QListView" name="racers"/>
+   </item>
+   <item row="3" column="0">
+    <widget class="QPushButton" name="reload_racers">
+     <property name="text">
+      <string>Obnovit Závodníky</string>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

SW/PC/Stopwatch/usbcardreader.py

@@ -0,0 +1,52 @@
+import usb.core
+import usb.util
+import threading
+import time
+
+
+USB_IF      = 0 # Interface
+USB_TIMEOUT = 5 # Timeout in ms
+USB_VENDOR  = 0xffff # Vendor-ID:
+USB_PRODUCT = 0x0035 # Product-ID
+
+
+class UsbCardReader:
+    def __init__(self, callback):
+        #fn called on found card
+        self.callback = callback
+        # 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):
+        receivedNumber = 0
+
+        while True:
+            control = None
+            try:
+                control = self.dev.read(self.endpoint.bEndpointAddress, self.endpoint.wMaxPacketSize, USB_TIMEOUT)
+                if (control[2] != 40) and (control[2] != 0):
+                    receivedDigit = control[2] - 29
+                    if receivedDigit == 10:
+                        receivedDigit = 0
+                    receivedNumber = 10 * receivedNumber + receivedDigit
+
+                if ( control[0] == 0 ) and ( control[2] == 40 ) and ( not receivedNumber == 0 ):
+                    self.callback(receivedNumber)
+                    receivedNumber = 0
+            except KeyboardInterrupt:
+                exit()
+            except:
+                receivedNumber = 0
+                pass
+
+            time.sleep(0.001)

SW/PC/main.py

@@ -90,7 +90,6 @@ def main():
     elif rw == '':
         s.write('r\r'.encode())
         read(s)
-        
     else:
         print('Invalid option')
 

SW/RPi_Pico_Reader/NFC_PN532.py

@@ -406,4 +406,3 @@ class PN532:
             _COMMAND_INDATAEXCHANGE, params=params, response_length=1
         )
         return response[0] == 0x00
-