View difference between Paste ID: PaMrFU7u and SbEwRbzX

 import cv2
 import time
 import threading
 from collections import deque
 from datetime import datetime
 import socket
 import os
 import re
 
 # ================== KONFIGURACJA ==================
 
 CAMERAS = {
-    # nazwa_kamery : URL RTSP
+
 }
-    # w przyszłości możesz dodać np.:
+
-    # "KAMERA2": "rtsp://admin:[email protected]:554/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif",
+PRE_SECONDS = 10      # ile sekund PRZED triggerem ma być w nagraniu
 POST_SECONDS = 15     # ile sekund PO triggerze ma być w nagraniu
 FPS_DEFAULT = 25      # stały fps do pliku
-PRE_SECONDS = 20        # ile sekund wstecz ma być w nagraniu (dla pierwszego nagrania po przerwie)
+
-POST_SECONDS = 60       # ile sekund po triggerze nagrywać
+OUTPUT_DIR = r"D:\wideo"
-FPS_DEFAULT = 25        # używane gdy kamera nie zwraca sensownego FPS
+RETENTION_DAYS = 1    # na testy 1 dzień, potem możesz dać 30
 
-# ŚCIEŻKA NA DYSK USB – ZMIEŃ LITERĘ DYSKU JEŚLI POTRZEBA:
+TCP_HOST = "0.0.0.0"
-OUTPUT_DIR = r"E:\Nagrania"
+TCP_PORT = 5000
 
-RETENTION_DAYS = 30     # ile dni trzymać nagrania, starsze są kasowane
+
 # ================== POMOCNICZE ==================
-TCP_HOST = "0.0.0.0"    # nasłuch na wszystkich interfejsach
+
-TCP_PORT = 5000         # port, na który HMI wysyła kod części
+
     os.makedirs(OUTPUT_DIR, exist_ok=True)
 
 
 def cleanup_old_files():
     now = time.time()
     cutoff = now - RETENTION_DAYS * 24 * 3600
 
     for filename in os.listdir(OUTPUT_DIR):
         filepath = os.path.join(OUTPUT_DIR, filename)
-    """
+        if os.path.isfile(filepath):
-    Usuwa pliki starsze niż RETENTION_DAYS w OUTPUT_DIR.
+            if os.path.getmtime(filepath) < cutoff:
-    """
+                print(f"[CLEANUP] Usuwam stary plik: {filename}")
                 os.remove(filepath)
 
 
-    try:
+
-        for filename in os.listdir(OUTPUT_DIR):
+
-            filepath = os.path.join(OUTPUT_DIR, filename)
+
-            if os.path.isfile(filepath):
+        time.sleep(24 * 3600)
-                mtime = os.path.getmtime(filepath)
+
-                if mtime < cutoff:
+
-                    print(f"[CLEANUP] Usuwam stary plik: {filename}")
+
-                    os.remove(filepath)
+
-    except Exception as e:
+
-        print(f"[CLEANUP] Błąd podczas czyszczenia: {e}")
+
     return re.sub(r"[^0-9A-Za-z_-]", "_", part_code)
 
 
-    """
+# ================== KAMERA ==================
-    Wątek, który co 24h uruchamia cleanup_old_files().
+
-    """
+
     def __init__(self, name, url):
         super().__init__(daemon=True)
-        time.sleep(24 * 3600)  # 24 godziny
+
         self.url = url
         self.lock = threading.Lock()
 
-    """
+
-    Czyści kod części tak, by nadawał się do nazwy pliku.
+
-    Zostawiamy tylko cyfry, litery, _, -.
+
-    """
+        self.fps = FPS_DEFAULT
         self.width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH) or 640)
         self.height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT) or 480)
 
-    safe = re.sub(r"[^0-9A-Za-z_-]", "_", part_code)
+        # bufor: (timestamp, frame)
-    return safe
+        self.buffer = deque()
         self.buffer_max_seconds = PRE_SECONDS + 2  # mały zapas
 
-# ================== KLASA DO OBSŁUGI KAMERY ==================
+        self.recording = False
         self.record_end_time = 0.0
         self.writer = None
 
         print(f"[{self.name}] Start. W={self.width} H={self.height}, fps={self.fps}")
 
     def _open_stream(self):
         if self.cap:
             self.cap.release()
         print(f"[{self.name}] Otwieram RTSP...")
         self.cap = cv2.VideoCapture(self.url)
-        fps = self.cap.get(cv2.CAP_PROP_FPS) if self.cap else 0
+
-        if fps <= 0 or fps > 120:
+            print(f"[{self.name}] ❌ Nie można otworzyć strumienia RTSP!")
-            fps = FPS_DEFAULT
+
-        self.fps = fps
+    def _trim_buffer(self, now: float):
         cutoff = now - self.buffer_max_seconds
         while self.buffer and self.buffer[0][0] < cutoff:
             self.buffer.popleft()
 
-        maxlen = int(self.fps * PRE_SECONDS)
+
-        self.buffer = deque(maxlen=maxlen)
+
         Tworzy nowy plik i:
-        self.recording = False       # czy aktualnie nagrywamy post-trigger
+        - jeśli use_prebuffer=True -> zapisuje dokładnie PRE_SECONDS wstecz,
           a POTEM ustawia record_end_time = teraz + POST_SECONDS
         - jeśli use_prebuffer=False -> od razu ustawia record_end_time = teraz + POST_SECONDS
         """
         # czas wyzwolenia do nazwy pliku
-        print(f"[{self.name}] Start. FPS={self.fps}, {self.width}x{self.height}, bufor={maxlen} klatek")
+        trigger_time_for_name = time.time()
         ts_name = datetime.fromtimestamp(trigger_time_for_name).strftime("%Y_%m_%d_%H_%M_%S")
         code = sanitize_part_code(part_code)
-        if self.cap is not None:
+        filename = f"{ts_name}_{code}_{self.name}.mp4"
         filepath = os.path.join(OUTPUT_DIR, filename)
-        print(f"[{self.name}] Otwieram strumień RTSP: {self.url}")
+
         print(f"[{self.name}] Start nagrania: {filename} | pre={use_prebuffer}")
 
-            print(f"[{self.name}] ❌ Nie można otworzyć strumienia!")
+
             filepath,
             cv2.VideoWriter_fourcc(*"mp4v"),
             self.fps,
-        Tworzy nowy plik wideo:
+
-        - use_prebuffer = True  -> zapisuje bufor (-20 s)
+
-        - use_prebuffer = False -> nagrywa tylko od triggera (bez cofania)
+
-        Nazwa pliku: RRRR_MM_DD_GG_MM_SS_KODCZESCI_KAMERA.mp4
+
             print(f"[{self.name}] ❌ Błąd otwierania pliku!")
-        now = time.time()
+
-        timestamp_str = datetime.fromtimestamp(now).strftime("%Y_%m_%d_%H_%M_%S")
+
-        safe_code = sanitize_part_code(part_code)
+        # najpierw zapisujemy pre-buffer (10s wstecz)
         if use_prebuffer:
-        filename = f"{timestamp_str}_{safe_code}_{self.name}.mp4"
+            # cutoff liczymy od momentu triggera (sprzed chwili)
             cutoff = trigger_time_for_name - PRE_SECONDS
             frames_to_write = [frame for (t, frame) in list(self.buffer) if t >= cutoff]
-        print(f"[{self.name}] Nowe nagranie: część={part_code}, plik={filename}, prebuffer={use_prebuffer}")
+            print(f"[{self.name}] Zapisuję pre-buffer: {len(frames_to_write)} klatek (~{PRE_SECONDS}s)")
             for frame in frames_to_write:
                 writer.write(frame)
 
         # UWAGA: koniec nagrywania liczymy OD TEGO MOMENTU,
         # czyli po zapisaniu pre-buffer (żeby nie ucinało po 5s).
         self.recording = True
         self.record_end_time = time.time() + POST_SECONDS
 
         return writer
-            print(f"[{self.name}] ❌ Nie można otworzyć pliku do zapisu!")
+
     def trigger(self, part_code: str):
         with self.lock:
-        # jeśli mamy użyć bufora wstecznego (-20 s)
+
             if self.recording and self.writer:
-            print(f"[{self.name}] Zapis bufora (~{PRE_SECONDS} s wstecz, {len(self.buffer)} klatek)...")
+                print(f"[{self.name}] Kończę poprzednie nagranie (nowy trigger).")
-            for (_t_frame, frame) in self.buffer:
+
                     self.writer.release()
                 except Exception:
-        # ustaw parametry nagrywania post-trigger
+
                 self.writer = None
-        self.record_end_time = now + POST_SECONDS
+
                 # nowe nagranie BEZ pre-buffer
                 self.writer = self._start_new_writer(part_code, use_prebuffer=False)
             else:
                 # pierwsze / po przerwie – z pre-buffer
                 self.writer = self._start_new_writer(part_code, use_prebuffer=True)
-        Wywoływane, gdy przychodzi trigger z kodem części.
+
             if self.writer:
-        Logika:
+
-        - jeżeli NIE nagrywamy -> nagranie z buforem (-20 s) + 60 s w przód
+
-        - jeżeli JUŻ nagrywamy -> kończymy poprzednie, nowe nagranie bez bufora,
+                print(f"[{self.name}] ❌ Nie udało się rozpocząć nagrania.")
-          60 s w przód od TEGO momentu.
+
     def run(self):
-        Dzięki temu pliki czasowo NIE nachodzą na siebie.
+
             if not self.cap.isOpened():
                 time.sleep(1)
-            if self.recording and self.writer is not None:
+
-                # trwa nagranie poprzedniej części -> przerywamy je w tym momencie
+
-                print(f"[{self.name}] Przerywam poprzednie nagranie i zamykam plik.")
+
             ret, frame = self.cap.read()
             if not ret:
                 time.sleep(0.5)
                 self._open_stream()
                 continue
 
             now = time.time()
-                # nowe nagranie -> BEZ bufora (-20), tylko od TEGO momentu
+
             with self.lock:
                 # aktualizacja bufora
                 self.buffer.append((now, frame.copy()))
-                # nie nagrywaliśmy nic -> pierwsze nagranie po przerwie
+                self._trim_buffer(now)
-                # nagranie z buforem (-20 s)
+
                 # zapis post-trigger
                 if self.recording and self.writer:
-            if self.writer is None:
+
-                # nie udało się stworzyć pliku
+
                         print(f"[{self.name}] Koniec nagrania (post {POST_SECONDS}s).")
-                self.record_end_time = 0.0
+
                             self.writer.release()
                         except Exception:
                             pass
                         self.writer = None
                         self.recording = False
-            if self.cap is None or not self.cap.isOpened():
+
-                print(f"[{self.name}] Próba ponownego połączenia za 1 s...")
+
 # ================== TCP SERVER ==================
 
 def tcp_server(cameras):
     srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     srv.bind((TCP_HOST, TCP_PORT))
-                print(f"[{self.name}] Brak klatki, reconnect...")
+
 
     print(f"[TCP] Nasłuch na {TCP_HOST}:{TCP_PORT}")
 
     while True:
         conn, addr = srv.accept()
-            # zapis do bufora (dla potencjalnego pre-triggera)
+
-            self.buffer.append((now, frame.copy()))
+
                 data = conn.recv(1024)
-            # jeśli trwa nagrywanie post-trigger -> zapisuj bieżące klatki
+
                     continue
-                if self.recording and self.writer is not None:
+                code = data.decode(errors="ignore").strip()
                 print(f"[TCP] Kod części: {code!r}")
                 if not code:
-                        print(f"[{self.name}] Koniec nagrania post-trigger, zamykam plik.")
+
                 for cam in cameras:
                     cam.trigger(code)
             except Exception as e:
                 print("[TCP] Błąd:", e)
 
 
 # ================== MAIN ==================
 
-# ================== SERWER TCP DO ODBIORU KODU CZĘŚCI ==================
+
     ensure_output_dir()
-def tcp_server(camera_objects):
+
-    """
+
-    Prosty serwer TCP:
+
-    - HMI łączy się z IP mini-komputera:TCP_PORT
+
-    - wysyła tekst z kodem części + np. \n
+
-    - serwer wywołuje trigger() dla wszystkich kamer
+
-    """
+
     threading.Thread(target=cleanup_worker, daemon=True).start()
     threading.Thread(target=tcp_server, args=(cameras,), daemon=True).start()
 
     print("=== SYSTEM NAGRYWANIA URUCHOMIONY ===")
     print("Katalog:", OUTPUT_DIR)
     print(f"Pre: {PRE_SECONDS} s, Post: {POST_SECONDS} s")
     print(f"Retencja: {RETENTION_DAYS} dni\n")
 
-        print(f"[TCP] Połączenie od: {addr}")
+
         time.sleep(1)
 
 
 if __name__ == "__main__":
     main()
-                part_code = data.decode("utf-8", errors="ignore").strip()
+
-                print(f"[TCP] Otrzymano kod części: '{part_code}'")
+