da2eth_controller_V16.py

# DA2ETH Controller
# Copyright (C) 2025  Peter Jusna (Hopsi)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.

# ── Kontrola závislostí ────────────────────────────────────────────────────
# Spustí se před načtením ostatních modulů — srozumitelně informuje uživatele
# co má doinstalovat pokud něco chybí
def _check_dependencies():
    missing = []
    try:
        import PyQt6
    except ImportError:
        missing.append("PyQt6")
    try:
        import pyqtgraph
    except ImportError:
        missing.append("pyqtgraph")
    if missing:
        print("=" * 60)
        print("CHYBA: Chybí potřebné knihovny!")
        print("=" * 60)
        print("Nainstaluj je příkazem:")
        print()
        print(f"    pip install {' '.join(missing)}")
        print()
        print("Nebo nainstaluj všechny závislosti najednou:")
        print()
        print("    pip install -r requirements.txt")
        print()
        print("=" * 60)
        import sys
        sys.exit(1)

_check_dependencies()

# ──────────────────────────────────────────────────────────────────────────
"""
DA2ETH Controller – Ovládací program pro D/A převodník Papouch DA2ETH
Komunikace přes Modbus TCP (server mód zařízení)
Výstupní rozsah RAW: 0–65535 (16-bit)
"""

import sys
import os
import time
import threading
import pyqtgraph as pg
from PyQt6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
    QGroupBox, QLabel, QLineEdit, QPushButton, QSlider, QSpinBox, QRadioButton,
    QDoubleSpinBox, QComboBox, QCheckBox, QStatusBar, QFrame, QScrollBar,
    QGridLayout, QProgressBar, QTabWidget, QTextEdit, QPlainTextEdit, QSizePolicy,
    QMessageBox, QScrollArea, QSplitter, QFileDialog, QDialog, QGridLayout,
)
from PyQt6.QtCore import Qt, QTimer, QSize, QThread, pyqtSignal, QObject, QSettings, QEvent, QRect
from PyQt6.QtGui import QFont, QColor, QPalette, QAction, QPainter, QPen, QTextFormat

import socket   # pro čisté TCP spojení — Spinel nevyžaduje žádnou externí knihovnu

import logging  # systémový log pro debugging a diagnostiku

# ── Konstanty Spinel protokolu ─────────────────────────────────────────────
# Protokol Spinel Formát 97 (binární) dle dokumentace Papouch DA2xxx
SPINEL_PRE  = 0x2A   # Prefix — vždy znak '*'
SPINEL_FRM  = 0x61   # Číslo formátu 97
SPINEL_ADR  = 0x31   # Konkrétní adresa DA2ETH (výchozí tovární hodnota dle manuálu)
SPINEL_CR   = 0x0D   # Zakončovací znak

# Kódy instrukcí DA2ETH (ze Spinel manuálu DA2xxx)
INST_WRITE_RAW    = 0x40   # Zápis RAW hodnoty (0–65535) na výstup
INST_READ_RAW     = 0x41   # Čtení aktuální RAW hodnoty výstupu
INST_ALLOW_CONFIG = 0xE4   # Povolení konfigurace — musí předcházet 0xC0
INST_SET_RANGE    = 0xC0   # Nastavení výstupního rozsahu

# Kódy výstupních rozsahů DA2ETH dle Spinel manuálu strana 15 (instrukce 0xC0)
RANGE_CODES = {
    "0–10 V":   0x01,   # rozsah 0–10 V (výchozí tovární nastavení)
    "0–5 V":    0x02,   # rozsah 0–5 V
    "±10 V":    0x03,   # rozsah ±10 V
    "±5 V":     0x04,   # rozsah ±5 V
    "4–20 mA":  0x05,   # rozsah 4–20 mA
    "0–20 mA":  0x06,   # rozsah 0–20 mA
    "0–24 mA":  0x07,   # rozsah 0–24 mA
}

# Kódy potvrzení (ACK) v odpovědi
ACK_OK = 0x00   # Instrukce provedena v pořádku

# ── Pomocné funkce pro Spinel pakety ───────────────────────────────────────

def build_spinel_reset(sig: int = 0x01) -> bytes:
    """Sestaví Spinel paket pro reset zařízení (0xE3)."""
    body = bytes([SPINEL_PRE, SPINEL_FRM, 0x00, 0x05,
                  SPINEL_ADR, sig, 0xE3])
    return body + bytes([spinel_checksum(body), SPINEL_CR])

def spinel_checksum(data: bytes) -> int:
    """Vypočítá kontrolní součet Spinel paketu.
    SUMA = 255 – součet všech bytů kromě CR."""
    return (255 - sum(data)) & 0xFF

def build_spinel_allow_config(sig: int = 0x01) -> bytes:
    """Sestaví Spinel paket pro povolení konfigurace (0xE4).
    DŮLEŽITÉ: Tato instrukce NESMÍ používat univerzální adresu 0xFE —
    musí být použita konkrétní adresa zařízení (výchozí 0x31 dle manuálu).
    Instrukce nemá žádná data — NUM=0x05."""
    body = bytes([SPINEL_PRE, SPINEL_FRM, 0x00, 0x05,
                  0x31, sig, INST_ALLOW_CONFIG])   # 0x31 = konkrétní adresa DA2ETH
    return body + bytes([spinel_checksum(body), SPINEL_CR])

def build_spinel_set_range(channel: int, range_code: int, sig: int = 0x01) -> bytes:
    """Sestaví Spinel paket pro nastavení výstupního rozsahu (0xC0).
    Musí být předcházeno instrukcí 0xE4 (povolení konfigurace).
    Struktura: PRE FRM 00 07 ADR SIG C0 chann range_code SUMA CR
    channel: 1 nebo 2, range_code: viz RANGE_CODES."""
    body = bytes([SPINEL_PRE, SPINEL_FRM, 0x00, 0x07,
                  SPINEL_ADR, sig, INST_SET_RANGE, channel & 0xFF, range_code & 0xFF])
    return body + bytes([spinel_checksum(body), SPINEL_CR])

def build_spinel_write_raw(channel: int, raw_value: int, sig: int = 0x01) -> bytes:
    """Sestaví Spinel paket pro zápis RAW hodnoty na výstup (0x40).
    Struktura: PRE FRM 00 08 ADR SIG 40 chann val_hi val_lo SUMA CR
    channel: 1 nebo 2, raw_value: 0–65535."""
    ch = channel & 0xFF
    hi = (raw_value >> 8) & 0xFF
    lo = raw_value & 0xFF
    body = bytes([SPINEL_PRE, SPINEL_FRM, 0x00, 0x08,
                  SPINEL_ADR, sig, INST_WRITE_RAW, ch, hi, lo])
    return body + bytes([spinel_checksum(body), SPINEL_CR])

def parse_spinel_response(data: bytes) -> tuple[bool, str]:
    """Zparsuje Spinel odpověď a vrátí (ok, zpráva).
    Validuje: délku, header, zakončovací CR, checksum a ACK."""
    if len(data) < 9:
        return False, f"Příliš krátká odpověď ({len(data)} bytů)"
    if data[0] != SPINEL_PRE or data[1] != SPINEL_FRM:
        return False, f"Neplatný Spinel header: {data[:2].hex()}"
    # Validace zakončovacího CR
    if data[-1] != SPINEL_CR:
        return False, f"Chybí zakončovací CR (poslední byte: {data[-1]:02X}H)"
    # Validace checksumu — SUMA = 255 - součet všech bytů kromě CR
    expected = spinel_checksum(data[:-2])   # všechny byty kromě SUMA a CR
    received  = data[-2]
    if expected != received:
        return False, (f"Chybný checksum "
                      f"(očekáván: {expected:02X}H, přijat: {received:02X}H)")
    # Validace deklarované délky packetu (NUM = bytes[2:4])
    declared_len = (data[2] << 8) | data[3]
    actual_len   = len(data) - 4   # počet bytů za NUM
    if declared_len != actual_len:
        return False, (f"Nesouhlasí délka packetu "
                      f"(deklarována: {declared_len}, skutečná: {actual_len})")
    ack = data[6]
    ack_msgs = {
        0x00: "OK",
        0x01: "Jiná chyba zařízení",
        0x02: "Neplatný kód instrukce",
        0x03: "Neplatná data",
        0x04: "Přístup odmítnut",
        0x05: "Porucha zařízení",
        0x06: "Nejsou k dispozici žádná data",
    }
    msg = ack_msgs.get(ack, f"Neznámý ACK: {ack:02X}H")
    return ack == ACK_OK, msg

# ── Spinel komunikační vlákno ───────────────────────────────────────────────

class SpinelWorker(QThread):
    """Vlákno pro asynchronní Spinel TCP komunikaci se zařízením DA2ETH
     (připojení, zápis RAW, čtení, reset, změna rozsahu).
    Používá čisté TCP sockety — nevyžaduje žádnou externí knihovnu.
    Zařízení musí být v režimu TCP server (Komunikační režim v záložce Síť)."""

    connected  = pyqtSignal(bool, str)       # (úspěch, zpráva)
    write_done = pyqtSignal(int, bool, str)  # (kanál, úspěch, zpráva)
    range_done = pyqtSignal(int, bool, str)  # (kanál, úspěch, zpráva)
    read_done  = pyqtSignal(dict, str)  # ({kanál: raw}, zpráva)

    def __init__(self):
        super().__init__()
        self._sock: socket.socket | None = None
        self.ip   = "192.168.1.254"
        self.port = 10001   # výchozí Spinel port DA2ETH
        self._lock = threading.Lock()   # zabraňuje souběžným zápisům
        self._connected = False
        self._sig = 0   # čítač podpisů zpráv (0–255, pak se přetočí)
        self._last_raw = {0: None, 1: None}   # poslední odeslaná RAW hodnota pro každý kanál
        self._busy = threading.Event()   # thread-safe příznak probíhající komunikace
        self._recv_buf = bytearray()
        self._fail_count = 0          # počítadlo po sobě jdoucích chyb zápisu
        self._fail_limit = 5          # po kolika chybách za sebou se odpojíme

    def connect_device(self, ip: str, port: int):
        """Otevře TCP spojení se zařízením DA2ETH na zadané IP a portu."""
        self.ip, self.port = ip, port
        self._close_socket()
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(3.0)   # 3 sekundy timeout pro připojení i čtení
            sock.connect((ip, port))
            self._sock = sock
            self._connected = True
            self._fail_count = 0   # při novém připojení vždy resetuj počítadlo chyb
            self.connected.emit(True, f"Připojeno (Spinel TCP) na {ip}:{port}")
        except Exception as e:
            self._connected = False
            self.connected.emit(False, f"Chyba připojení: {e}")

    def disconnect_device(self):
        """Uzavře TCP spojení."""
        self._close_socket()
        self._connected = False
        self.connected.emit(False, "Odpojeno")

    def _close_socket(self):
        """Bezpečně zavře socket pokud je otevřený."""
        if self._sock:
            try:
                self._sock.close()
            except Exception:
                pass
            self._sock = None

    def _transition_to_disconnected_state(self, reason: str):
        """Centralizovaný přechod do odpojeného stavu.
        Volá se ze VŠECH míst kde dochází k odpojení — zabraňuje race conditions.
        Nastaví flagy, zavře socket, vyčistí stav a emituje signál."""
        with self._lock:
            if not self._connected:
                return   # již odpojeno — zabraň dvojitému volání
            self._connected = False
            self._busy.clear()
            self._recv_buf  = bytearray()   # vymaž buffer
        self._close_socket()
        self.connected.emit(False, reason)
        logger.info("DISCONNECT reason=%s", reason)

    def _register_failure(self, msg: str, immediate: bool = False):
        """Zaregistruje selhání komunikace.
        immediate=True: odpoj okamžitě (socket chyby).
        immediate=False: počítej ACK chyby, odpoj až po _fail_limit."""
        logger.warning("FAILURE immediate=%s msg=%s", immediate, msg)
        if immediate:
            self._fail_count = 0
            self._transition_to_disconnected_state(msg)
        else:
            self._fail_count += 1
            if self._fail_count >= self._fail_limit:
                self._fail_count = 0
                self._transition_to_disconnected_state(
                    f"⚠ {self._fail_limit}× po sobě chybná odpověď — {msg}")

    def _register_success(self):
        """Zaregistruje úspěšnou komunikaci — resetuje čítač chyb."""
        self._fail_count = 0

    def _next_sig(self) -> int:
        """Vrátí další podpis zprávy (0–254, přeskočí 0x0D = CR)."""
        self._sig = (self._sig + 1) % 255
        if self._sig == 0x0D:   # CR je zakončovací znak — nesmí být jako SIG
            self._sig += 1
        return self._sig

    def write_output(self, channel: int, raw_value: int):
        """Odešle Spinel instrukci WRITE_RAW (0x40) a přečte odpověď.
        channel: 0 = OUT1, 1 = OUT2 (interně převedeno na 1 a 2 dle Spinel spec)."""
        if not self._connected or not self._sock:
            self.write_done.emit(channel, False, "Není připojeno")
            return
        if channel not in (0, 1):
            self.write_done.emit(channel, False, f"Neplatný index kanálu: {channel}")
            return
        # Spinel čísluje kanály od 1, program interně od 0
        spinel_ch = channel + 1
        self._busy.set()
        sig = self._next_sig()
        packet = build_spinel_write_raw(spinel_ch, raw_value, sig)
        logger.debug("TX ch=%d raw=%d packet=%s", channel, raw_value, packet.hex())
        detail = ""
        try:
            with self._lock:
                if not self._sock:
                    self.write_done.emit(channel, False, "Není připojeno (socket zavřen)")
                    return
                self._sock.sendall(packet)
                response = self._read_response()
            ok, msg = parse_spinel_response(response)
            if ok:
                self._last_raw[channel] = raw_value
                self._register_success()   # úspěšný zápis — resetuj počítadlo chyb
                logger.debug("RX ch=%d ok=%s detail=%s", channel, ok, detail)
            else:
                self._fail_count += 1  # ACK chyba — zařízení odpovědělo ale odmítlo
            detail = f"OUT{channel+1} RAW={raw_value} → {msg}"
            self.write_done.emit(channel, ok, detail)
        except socket.timeout:
            self._register_failure("Timeout — spojení přerušeno", immediate=True)
            self.write_done.emit(channel, False, "Timeout — zařízení neodpovědělo")
        except ConnectionResetError:
            self._register_failure("Spojení resetováno zařízením", immediate=True)
            self.write_done.emit(channel, False, "Spojení resetováno zařízením (WinError 10054)")
        except ConnectionAbortedError:
            self._register_failure("Spojení přerušeno", immediate=True)
            self.write_done.emit(channel, False, "Spojení přerušeno")
        except OSError as e:
            self._register_failure(f"Chyba socketu: {e}", immediate=True)
            self.write_done.emit(channel, False, f"Chyba socketu: {e}")
        except Exception as e:
            # Neočekávaná chyba — loguj podrobně pro debugging
            self._register_failure(f"Neočekávaná chyba: {type(e).__name__}: {e}", immediate=True)
            self.write_done.emit(channel, False, f"Neočekávaná chyba: {type(e).__name__}: {e}")
        finally:
            self._busy.clear()
    
    def reset_device(self):
        """Odešle instrukci Reset (0xE3) — zařízení se restartuje."""
        if not self._connected or not self._sock:
            return
        try:
            with self._lock:
                pkt = build_spinel_reset(self._next_sig())
                self._sock.sendall(pkt)
                self._read_response()
        except Exception as e:
            self._transition_to_disconnected_state(f"Chyba při resetu zařízení: {e}")

    def read_outputs(self):
        """Přečte aktuální RAW hodnoty obou výstupů instrukcí 0x41.
        Výsledek emituje přes signál read_done jako slovník {0: raw1, 1: raw2}."""
        if not self._connected or not self._sock:
            return
        try:
            with self._lock:
                if not self._sock:
                    return
                sig = self._next_sig()
                body = bytes([SPINEL_PRE, SPINEL_FRM, 0x00, 0x05,
                              SPINEL_ADR, sig, 0x41])
                pkt = body + bytes([spinel_checksum(body), SPINEL_CR])
                self._sock.sendall(pkt)
                resp = self._read_response()

            # Odpověď: ... ACK CH1 HI1 LO1 CH2 HI2 LO2 SUMA CR
            # Po ACK (index 6) následují dvojice (chann, hi, lo)
            if len(resp) < 13:
                self.read_done.emit({}, f"Krátká odpověď: {resp.hex(' ')}")
                return
            ok, msg = parse_spinel_response(resp)
            if not ok:
                self.read_done.emit({}, f"Chyba čtení: {msg}")
                return

            # Parsuj data — přeskoč PRE FRM NUM NUM ADR SIG ACK
            data = resp[7:]
            values = {}
            i = 0
            while i + 2 < len(data) - 2:   # -2 = SUMA + CR
                ch   = data[i] - 1          # 0x01→0, 0x02→1
                hi   = data[i + 1]
                lo   = data[i + 2]
                raw  = (hi << 8) | lo
                if ch in (0, 1):
                    values[ch] = raw
                i += 3

            self.read_done.emit(values, "OK")
        except socket.timeout:
            self._register_failure("Timeout — spojení přerušeno")
            self.read_done.emit({}, "Timeout — zařízení neodpovědělo")
        except ConnectionResetError:
            self._register_failure("Spojení resetováno zařízením")
            self.read_done.emit({}, "Spojení resetováno zařízením (WinError 10054)")
        except ConnectionAbortedError:
            self._register_failure("Spojení přerušeno")
            self.read_done.emit({}, "Spojení přerušeno")
        except OSError as e:
            self._register_failure(f"Chyba socketu: {e}")
            self.read_done.emit({}, f"Chyba socketu: {e}")
        except Exception as e:
            # Neočekávaná chyba — loguj podrobně pro debugging
            self._register_failure(f"Neočekávaná chyba: {type(e).__name__}: {e}")
            self.read_done.emit({}, f"Neočekávaná chyba: {type(e).__name__}: {e}")

    def set_range(self, channel: int, range_name: str):
        """Nastaví výstupní rozsah kanálu přes Spinel instrukce 0xE4 + 0xC0."""
        if not self._connected or not self._sock:
            self.range_done.emit(channel, False, "Není připojeno")
            return
        if range_name not in RANGE_CODES:
            self.range_done.emit(channel, False, f"Neznámý rozsah: {range_name}")
            return
        spinel_ch  = channel + 1
        range_code = RANGE_CODES[range_name]
        try:
            with self._lock:
                # Krok 1: povolení konfigurace (0xE4)
                sig1 = self._next_sig()
                pkt_allow = build_spinel_allow_config(sig1)
                self._sock.sendall(pkt_allow)
                resp1 = self._read_response()
                ok1, msg1 = parse_spinel_response(resp1)
                if not ok1:
                    self.range_done.emit(channel, False,
                                        f"Povolení konfigurace selhalo: {msg1}")
                    return

                # Krok 2: nastavení rozsahu (0xC0)
                sig2 = self._next_sig()
                pkt_range = build_spinel_set_range(spinel_ch, range_code, sig2)
                self._sock.sendall(pkt_range)
                resp2 = self._read_response()
                ok2, msg2 = parse_spinel_response(resp2)
                detail = f"OUT{channel+1} rozsah={range_name} → {msg2}"
                self.range_done.emit(channel, ok2, detail)

                # Krok 3: obnov poslední RAW hodnotu
                if ok2 and self._last_raw[channel] is not None:
                    sig3 = self._next_sig()
                    pkt_raw = build_spinel_write_raw(
                        spinel_ch, self._last_raw[channel], sig3)
                    self._sock.sendall(pkt_raw)
                    self._read_response()

        except socket.timeout:
            self._register_failure("Timeout — spojení přerušeno")
            self.range_done.emit(channel, False, "Timeout — zařízení neodpovědělo")
        except ConnectionResetError:
            self._register_failure("Spojení resetováno zařízením")
            self.range_done.emit(channel, False, "Spojení resetováno zařízením (WinError 10054)")
        except ConnectionAbortedError:
            self._register_failure("Spojení přerušeno")
            self.range_done.emit(channel, False, "Spojení přerušeno")
        except OSError as e:
            self._register_failure(f"Chyba socketu: {e}")
            self.range_done.emit(channel, False, f"Chyba socketu: {e}")
        except Exception as e:
            # Neočekávaná chyba — loguj podrobně pro debugging
            self._register_failure(f"Neočekávaná chyba: {type(e).__name__}: {e}")
            self.range_done.emit(channel, False, f"Neočekávaná chyba: {type(e).__name__}: {e}")

    def _read_response(self) -> bytes:
        """Čte odpověď ze socketu s persistentním bufferem.
        Správně zpracovává fragmentované TCP packety i slepené odpovědi.
        Packet je kompletní když obsahuje CR a délka odpovídá deklarované NUM."""
        
        while True:
            # Zkus sestavit kompletní packet z bufferu
            packet = self._try_extract_packet()
            if packet is not None:
                return packet

            # Buffer neobsahuje kompletní packet — načti další data
            try:
                chunk = self._sock.recv(256)
            except socket.timeout:
                raise   # timeout propagujeme výš
            if not chunk:
                raise ConnectionResetError("Spojení přerušeno během čtení")
            self._recv_buf.extend(chunk)

    def _try_extract_packet(self) -> bytes | None:
        """Pokusí se extrahovat kompletní Spinel packet z persistentního bufferu.
        Vrátí bytes pokud je packet kompletní, jinak None."""
        buf = self._recv_buf
        if len(buf) < 9:
            return None
        if buf[0] != SPINEL_PRE or buf[1] != SPINEL_FRM:
            try:
                next_pre = buf.index(SPINEL_PRE, 1)
                self._recv_buf = buf[next_pre:]
            except ValueError:
                self._recv_buf = bytearray()
            return None
        if len(buf) < 4:
            return None
        declared_len = (buf[2] << 8) | buf[3]
        total_len    = 4 + declared_len
        if len(buf) < total_len:
            return None
        packet = bytes(buf[:total_len])
        self._recv_buf = buf[total_len:]
        return packet

    @property
    def is_connected(self) -> bool:
        return self._connected

# ── Pomocné konverzní funkce ────────────────────────────────────────────────

def raw_to_phys(raw: int, range_name: str) -> float:
    """Převede RAW (0–65535) na fyzikální hodnotu odpovídající zvolenému rozsahu."""
    lo, hi, _ = OUTPUT_RANGES[range_name]
    return lo + (hi - lo) * raw / RAW_MAX

def phys_to_raw(phys: float, range_name: str) -> int:
    """Převede fyzikální hodnotu na RAW (0–65535), oříznutou na platný rozsah."""
    lo, hi, _ = OUTPUT_RANGES[range_name]
    if hi == lo:
        return 0
    return max(RAW_MIN, min(RAW_MAX, round((phys - lo) / (hi - lo) * RAW_MAX)))

def raw_to_percent(raw: int) -> float:
    """Převede RAW na procenta celého rozsahu (0–100 %)."""
    return raw / RAW_MAX * 100.0

def percent_to_raw(pct: float) -> int:
    """Převede procenta (0–100) na RAW (0–65535)."""
    return max(0, min(RAW_MAX, round(pct / 100.0 * RAW_MAX)))

def raw_to_phys_delta(raw: int, range_name: str) -> float:
    """Převede RAW rozdíl (krok) na fyzikální rozdíl — BEZ offsetu rozsahu.
    Např. krok 6 RAW v rozsahu 4–20 mA = 6/65535 * 16 = 0.00147 mA (ne 4.00147 mA)."""
    lo, hi, _ = OUTPUT_RANGES[range_name]
    return (hi - lo) * raw / RAW_MAX

def phys_to_raw_delta(phys: float, range_name: str) -> int:
    """Převede fyzikální rozdíl (krok) na RAW rozdíl — BEZ offsetu rozsahu."""
    lo, hi, _ = OUTPUT_RANGES[range_name]
    span = hi - lo
    if span == 0:
        return 0
    return max(1, min(RAW_MAX, round(phys / span * RAW_MAX)))

def section_label(text: str) -> QLabel:
    """Vytvoří popisek sekce — tučný, zvětšený font, barevný podtitulek."""
    lbl = QLabel(text)
    font = QFont()
    font.setPointSize(10)
    font.setBold(True)
    lbl.setFont(font)
    lbl.setStyleSheet("color: #7eb8e8; margin-top: 4px;")
    return lbl

# ── Logging subsystem ──────────────────────────────────────────────────────
def _setup_logger() -> logging.Logger:
    """Inicializuje logger pro DA2ETH controller.
    Zapisuje do souboru da2eth_debug.log a volitelně do konzole."""
    logger = logging.getLogger("da2eth")
    logger.setLevel(logging.DEBUG)
    # Formát: čas | úroveň | zpráva
    fmt = logging.Formatter("%(asctime)s | %(levelname)-8s | %(message)s",
                            datefmt="%Y-%m-%d %H:%M:%S")
    # Handler pro soubor — rotující, max 1 MB, 3 zálohy
    from logging.handlers import RotatingFileHandler
    fh = RotatingFileHandler("da2eth_debug.log", maxBytes=1_000_000,
                             backupCount=3, encoding="utf-8")
    fh.setLevel(logging.DEBUG)
    fh.setFormatter(fmt)
    logger.addHandler(fh)
    return logger

logger = _setup_logger()

class TranslationManager:
    """Spravuje překlady GUI do různých jazyků.
    Překlady se načítají z JSON souborů ve složce translations/."""

    LANGUAGES = {
        "cs": "Čeština",
        "en": "English",
        "de": "Deutsch",
        "fr": "Français",
        "es": "Español",
    }

    def __init__(self):
        self._lang    = "cs"
        self._strings = {}
        self._widgets: list[tuple] = []   # [(widget, metoda, klíč), ...]
        base = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                            "translations")
        self._base_dir = base
        self.load("cs")

    def load(self, lang: str) -> bool:
        """Načte překlad ze souboru translations/{lang}.json.
        Vrátí True při úspěchu, False při chybě."""
        path = os.path.join(self._base_dir, f"{lang}.json")
        try:
            with open(path, encoding="utf-8") as f:
                import json
                self._strings = json.load(f)
            self._lang = lang
            logger.info("Jazyk načten: %s", lang)
            return True
        except FileNotFoundError:
            logger.warning("Překladový soubor nenalezen: %s", path)
            if lang == "cs":
                logger.error("Chybí výchozí překladový soubor cs.json — program nemusí zobrazovat texty správně.")
            return False
        except Exception as e:
            logger.error("Chyba načítání překladu %s: %s", lang, e)
            return False

    def tr(self, key: str, **kwargs) -> str:
        """Vrátí přeložený řetězec pro daný klíč.
        Pokud klíč neexistuje, vrátí klíč samotný (viditelná chyba překladu)."""
        text = self._strings.get(key, f"[{key}]")
        if kwargs:
            try:
                text = text.format(**kwargs)
            except KeyError:
                pass
        return text
        
    def tr_list(self, key: str) -> list[str]:
        """Vrátí přeložený seznam řetězců pro daný klíč.
        Pokud klíč neexistuje nebo není seznam, vrátí prázdný seznam."""
        val = self._strings.get(key, [])
        if isinstance(val, list):
            return val
        return [str(val)]

    def register(self, widget, method: str, key: str, **kwargs):
        """Zaregistruje widget pro automatickou aktualizaci při změně jazyka."""
        self._widgets.append((widget, method, key, kwargs))

    def switch(self, lang: str) -> bool:
        """Přepne jazyk a aktualizuje všechny zaregistrované widgety."""
        if not self.load(lang):
            return False
        for widget, method, key, kwargs in self._widgets:
            try:
                getattr(widget, method)(self.tr(key, **kwargs))
            except Exception as e:
                logger.warning("Chyba aktualizace widgetu %s.%s: %s",
                               widget, method, e)
        return True

# Globální instance překladového systému
tr_mgr = TranslationManager()

def tr(key: str, **kwargs) -> str:
    """Zkratka pro tr_mgr.tr() — použití: tr('btn_connect')"""
    return tr_mgr.tr(key, **kwargs)

def tr_list(key: str) -> list[str]:
    """Zkratka pro tr_mgr.tr_list()"""
    return tr_mgr.tr_list(key)

# ── Konstanty ──────────────────────────────────────────────────────────────
RAW_MAX = 65535   # Maximální 16-bit RAW hodnota
RAW_MIN = 0       # Minimální RAW hodnota

# Definice výstupních rozsahů: název → (fyzikální_min, fyzikální_max, jednotka)
OUTPUT_RANGES = {
    "0–10 V":   (0.0,   10.0,  "V"),
    "0–5 V":    (0.0,    5.0,  "V"),
    "±10 V":   (-10.0,  10.0,  "V"),
    "±5 V":    (-5.0,    5.0,  "V"),
    "4–20 mA":  (4.0,   20.0, "mA"),
    "0–20 mA":  (0.0,   20.0, "mA"),
    "0–24 mA":  (0.0,   24.0, "mA"),
}

# ── Slider s pravítkem a přímým skokem ─────────────────────────────────────

class RulerSlider(QWidget):
    """Složený widget: QSlider + pravítko nakreslené pomocí QPainter.
    Pravítko zobrazuje fyzické dílky jako na pravítku a každých 10 % zobrazí
    hodnotu v procentech a RAW. Kliknutí kdekoliv skočí přímo na danou pozici.
    Táhnutí za jezdce funguje standardně."""

    valueChanged = pyqtSignal(int)   # emituje se při každé změně hodnoty

    # Výška pravítka v pixelech — dostatečná aby se vešly 2 řádky textu (% + RAW)
    RULER_H = 46

    def __init__(self, parent=None):
        super().__init__(parent)
        layout = QVBoxLayout(self)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(0)

        # QSlider — wider groove via stylesheet, standard drag functionality
        self.slider = QSlider(Qt.Orientation.Horizontal)
        self.slider.setMinimum(0)
        self.slider.setMaximum(RAW_MAX)
        self.slider.setValue(0)
        # Skryté ticky — pravítko kreslíme sami
        self.slider.setTickPosition(QSlider.TickPosition.NoTicks)
        # Styl: silnější groove (linka slideru)
        self.slider.setStyleSheet(
            "QSlider::groove:horizontal {"
            "  height: 8px;"
            "  background: #555;"
            "  border-radius: 4px;"
            "}"
            "QSlider::handle:horizontal {"
            "  background: #7eb8e8;"
            "  border: 1px solid #4a8ab5;"
            "  width: 16px;"
            "  height: 16px;"
            "  margin: -5px 0;"
            "  border-radius: 8px;"
            "}"
            "QSlider::sub-page:horizontal {"
            "  background: #4a8ab5;"
            "  border-radius: 4px;"
            "}"
        )
        # Přímý skok kliknutím (ale ne při táhnutí — to řeší Qt sám)
        self.slider.installEventFilter(self)
        self.slider.valueChanged.connect(self.valueChanged.emit)
        layout.addWidget(self.slider)

        # Pravítko — vlastní widget který kreslíme přes QPainter
        self.ruler = _RulerWidget(self.slider)
        self.ruler.setFixedHeight(self.RULER_H)
        layout.addWidget(self.ruler)

    def eventFilter(self, obj, event):
        """Zachytí kliknutí myší a skočí přímo na kliknutou pozici.
        Táhnutí (MouseMove) nechává Qt zpracovat standardně — jezdec se táhne normálně."""
        if obj is self.slider and event.type() == QEvent.Type.MouseButtonPress:
            if event.button() == Qt.MouseButton.LeftButton:
                x    = event.position().x()
                w    = self.slider.width()
                lo   = self.slider.minimum()
                hi   = self.slider.maximum()
                val  = int(lo + (hi - lo) * max(0.0, min(1.0, x / w)))
                # Zkontroluj zda kliknutí není přímo na jezdci
                # Jezdec má šířku 16px — zkontroluj zda kliknutí je mimo jezdec
                current_x = int((self.slider.value() - lo) / (hi - lo) * w)
                if abs(x - current_x) > 10:   # 10px tolerance — mimo jezdec
                    self.slider.setValue(val)
        return super().eventFilter(obj, event)

    # ── Proxy metody delegující na vnitřní QSlider ──────────────────────

    def value(self):
        return self.slider.value()

    def setValue(self, v: int):
        self.slider.setValue(v)
        self.ruler.update()   # překresli pravítko

    def setMinimum(self, v: int):
        self.slider.setMinimum(v)
        self.ruler.update()

    def setMaximum(self, v: int):
        self.slider.setMaximum(v)
        self.ruler.update()

    def minimum(self):
        return self.slider.minimum()

    def maximum(self):
        return self.slider.maximum()

    def blockSignals(self, b: bool):
        self.slider.blockSignals(b)
        return super().blockSignals(b)

    def setToolTip(self, tip: str):
        self.slider.setToolTip(tip)
        super().setToolTip(tip)


class _RulerWidget(QWidget):
    """Pravítko nakreslené přes QPainter — zobrazuje dílky a hodnoty.
    Sdílí referenci na QSlider aby vědělo o aktuálním minimu a maximu."""

    def __init__(self, slider: QSlider, parent=None):
        super().__init__(parent)
        self._slider = slider   # reference na slider pro čtení min/max

    def paintEvent(self, event):
        """Nakreslí pravítko s 100 dílky, značkami po 10 % a hodnotami."""
        painter = QPainter(self)
        painter.setRenderHint(QPainter.RenderHint.Antialiasing)

        w  = self.width()
        h  = self.height()
        lo = self._slider.minimum()
        hi = self._slider.maximum()
        if hi <= lo:
            return

        # Barvy
        color_tick  = QColor("#888888")
        color_major = QColor("#aaaaaa")
        color_text  = QColor("#bbbbbb")
        font_small  = QFont()
        font_small.setPointSize(7)

        # Kreslíme 101 dílků (0..100 %)
        NUM_TICKS = 100
        for i in range(NUM_TICKS + 1):
            x = int(i * w / NUM_TICKS)
            major = (i % 10 == 0)   # každých 10 % je hlavní dílek

            if major:
                tick_h = int(h * 0.45)   # hlavní dílek — vyšší
                painter.setPen(QPen(color_major, 1))
            else:
                tick_h = int(h * 0.22)   # vedlejší dílek — nižší
                painter.setPen(QPen(color_tick, 1))

            painter.drawLine(x, 0, x, tick_h)

            # U každého hlavního dílku zobraz % a RAW hodnotu
            if major:
                raw_val = int(lo + (hi - lo) * i / NUM_TICKS)
                pct_val = int(i)

                painter.setFont(font_small)
                painter.setPen(color_text)

                # Řádek 1: procenta
                pct_str = f"{pct_val}%"
                # Řádek 2: RAW hodnota
                raw_str = str(raw_val)

                # Horizontální pozice textu — první a poslední zarovnáme ke kraji
                text_w = 40
                if i == 0:
                    tx = 0
                elif i == NUM_TICKS:
                    tx = w - text_w
                else:
                    tx = x - text_w // 2

                # Nakresli oba řádky textu pod dílkem
                pct_rect = QRect(tx, tick_h + 1, text_w, 12)
                raw_rect = QRect(tx, tick_h + 13, text_w, 12)
                painter.drawText(pct_rect, Qt.AlignmentFlag.AlignHCenter, pct_str)
                painter.drawText(raw_rect, Qt.AlignmentFlag.AlignHCenter, raw_str)

        painter.end()

# ── Widget jednoho výstupního kanálu ───────────────────────────────────────

class SweepController:
    """Řídí sweep funkci jednoho výstupního kanálu.
    Odděluje sweep stav a logiku od ChannelWidget."""

    def __init__(self, channel_widget):
        self._cw = channel_widget   # reference na ChannelWidget
        self.timer     = QTimer()
        self.direction = 1          # +1 = dopředu, -1 = zpět (ping-pong)
        self.paused_raw = None      # pozice kde byl sweep zastaven
        self.from_raw:  int = 0
        self.to_raw:    int = RAW_MAX
        self.step_raw:  int = 500
        self.timer.timeout.connect(self._step)

    def val_to_raw(self, val: float, unit_idx: int, rng: str,
                   is_step: bool = False) -> int:
        """Převede hodnotu sweep políčka na RAW."""
        if unit_idx == 0:
            return max(0, min(RAW_MAX, int(val)))
        elif unit_idx == 1:
            return percent_to_raw(val)
        else:
            if is_step:
                return phys_to_raw_delta(val, rng)
            else:
                return phys_to_raw(val, rng)

    def sync_raw(self):
        """Přečte aktuální hodnoty sweep spinboxů a uloží je jako RAW."""
        cw  = self._cw
        idx = cw.cmb_step_unit.currentIndex()
        rng = cw.cmb_range.currentText()
        self.from_raw = self.val_to_raw(cw.spin_sweep_from.value(), idx, rng, False)
        self.to_raw   = self.val_to_raw(cw.spin_sweep_to.value(),   idx, rng, False)
        self.step_raw = self.val_to_raw(cw.spin_sweep_step.value(), idx, rng, True)

    def start(self):
        """Zastaví sweep a spustí od počáteční hodnoty."""
        cw = self._cw
        self.timer.stop()
        self.paused_raw = None
        self.direction  = 1
        start = max(cw._origin_to_raw(), int(cw.spin_sweep_from.value()))
        cw.current_raw = start
        cw._refresh_display()
        cw.btn_sweep.blockSignals(True)
        cw.btn_sweep.setChecked(True)
        cw.btn_sweep.blockSignals(False)
        cw.btn_sweep.setText("■  Zastavit")
        self.timer.start(cw.spin_sweep_ms.value())

    def _step(self):
        """Jeden tik sweep časovače — posune výstup o nastavený krok."""
        cw         = self._cw
        origin_raw = cw._origin_to_raw()
        frm = max(origin_raw, self.from_raw)
        to  = self.to_raw
        new = cw.current_raw + self.direction * self.step_raw

        if new >= to:
            new = to
            if cw.chk_sweep_loop.isChecked():
                self.direction = -1
            else:
                cw.btn_sweep.setChecked(False)
        elif new <= frm:
            new = frm
            if cw.chk_sweep_loop.isChecked():
                self.direction = 1
            else:
                cw.btn_sweep.setChecked(False)

        cw.current_raw = new
        cw._refresh_display()
        cw.request_write.emit(cw.ch, new)
        self.timer.setInterval(cw.spin_sweep_ms.value())

class ChannelWidget(QGroupBox):
    """Ovládací panel pro jeden analogový výstup DA2ETH (OUT1 nebo OUT2).
    Obsahuje slider s pravítkem, přímé zadání, kroky, bod počátku,
    sweep a progress bary."""

    request_write = pyqtSignal(int, int)    # (index_kanálu, raw_hodnota)
    request_range = pyqtSignal(int, str)    # (index_kanálu, název_rozsahu)

    def __init__(self, channel_idx: int, label: str, parent=None):
        super().__init__(label, parent)
        self.ch          = channel_idx   # 0 = OUT1, 1 = OUT2
        self.current_raw = 0             # aktuální RAW hodnota výstupu
        self.sweep    = SweepController(self)   # sweep subsystem
        self._updating = False
        self._step_raw: int = 100   # uložená RAW hodnota kroku — zdroj pravdy
        self._build_ui()

    def _connect_select_all(self):
        """Při kliknutí do libovolného spinboxu se automaticky označí celý obsah."""
        for widget in self.findChildren((QDoubleSpinBox, QSpinBox)):
            widget.installEventFilter(self)

    def eventFilter(self, obj, event):
        """Zachytí fokus na spinboxu a označí celý obsah."""
        from PyQt6.QtCore import QEvent
        if event.type() == QEvent.Type.FocusIn:
            if isinstance(obj, (QDoubleSpinBox, QSpinBox)):
                obj.lineEdit().selectAll()
        return super().eventFilter(obj, event)
        
    # ── Sestavení UI ───────────────────────────────────────────────────────

    def _build_ui(self):
        """Sestaví celý ovládací panel kanálu uvnitř ScrollArea."""
        # ScrollArea zabraňuje prolínání prvků při zmenšení okna
        outer = QVBoxLayout(self)
        outer.setContentsMargins(2, 2, 2, 2)

        scroll = QScrollArea()
        scroll.setWidgetResizable(True)
        scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
        scroll.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
        scroll.setFrameShape(QFrame.Shape.NoFrame)
        outer.addWidget(scroll)

        inner = QWidget()
        scroll.setWidget(inner)
        main = QVBoxLayout(inner)
        main.setSpacing(6)
        main.setContentsMargins(6, 4, 6, 4)

        # ═══ SEKCE: Výstupní rozsah ═══════════════════════════════════════
        self._sec_range_lbl = section_label(tr("sec_range"))
        tr_mgr.register(self._sec_range_lbl, "setText", "sec_range")
        main.addWidget(self._sec_range_lbl)
        row_range = QHBoxLayout()
        self._lbl_range = QLabel(tr("lbl_range"))
        tr_mgr.register(self._lbl_range, "setText", "lbl_range")
        row_range.addWidget(self._lbl_range)
        self.cmb_range = QComboBox()
        self.cmb_range.addItems(list(OUTPUT_RANGES.keys()))
        self.cmb_range.currentTextChanged.connect(self._on_range_changed)
        self.cmb_range.setToolTip(tr("cmb_range_tip"))
        tr_mgr.register(self.cmb_range, "setToolTip", "cmb_range_tip")
        row_range.addWidget(self.cmb_range)
        row_range.addStretch()
        main.addLayout(row_range)

        # ═══ SEKCE: Aktuální hodnota a Slider ═════════════════════════════
        self._sec_slider_lbl = section_label(tr("sec_slider"))
        tr_mgr.register(self._sec_slider_lbl, "setText", "sec_slider")
        main.addWidget(self._sec_slider_lbl)

        # Velký popisek aktuální fyzikální hodnoty
        self.lbl_phys = QLabel("0.000 V")
        self.lbl_phys.setAlignment(Qt.AlignmentFlag.AlignRight)
        font_big = QFont()
        font_big.setPointSize(16)
        font_big.setBold(True)
        self.lbl_phys.setFont(font_big)
        main.addWidget(self.lbl_phys)

        # Slider s pravítkem — kliknutí skočí přímo, táhnutí funguje normálně
        self.slider = RulerSlider()
        self.slider.setToolTip(tr("slider_tip"))
        tr_mgr.register(self.slider, "setToolTip", "slider_tip")
        self.slider.valueChanged.connect(self._on_slider)
        main.addWidget(self.slider)

        # Popisek procent pod sliderem/pravítkem
        pct_row = QHBoxLayout()
        self.lbl_pct_left = QLabel("origin=0")
        self.lbl_pct_left.setStyleSheet("font-size: 12pt; color: #FCA31C;") #Velikost a barva popistu Origin pod slide barem
        pct_row.addWidget(self.lbl_pct_left)
        pct_row.addStretch()
        self.lbl_pct = QLabel("0.0 %")
        self.lbl_pct.setAlignment(Qt.AlignmentFlag.AlignCenter)
        pct_row.addWidget(self.lbl_pct)
        pct_row.addStretch()
        pct_row.addWidget(QLabel("100 %"))
        main.addLayout(pct_row)

        # ═══ SEKCE: Přímé zadání ══════════════════════════════════════════
        sep = QFrame(); sep.setFrameShape(QFrame.Shape.HLine)
        main.addWidget(sep)
        self._sec_direct_lbl = section_label(tr("sec_direct"))
        tr_mgr.register(self._sec_direct_lbl, "setText", "sec_direct")
        main.addWidget(self._sec_direct_lbl)

        # Grid — popisek hned před políčkem (minimální mezera)
        grid = QGridLayout()
        grid.setColumnMinimumWidth(0, 165)
        grid.setContentsMargins(0, 0, 0, 0)
        grid.setHorizontalSpacing(4)   # malá mezera mezi popiskem a políčkem
        grid.setVerticalSpacing(5)
        ROW_H = 28

        # Řádek fyzikální hodnoty
        lbl0 = QLabel(tr("lbl_phys"))
        tr_mgr.register(lbl0, "setText", "lbl_phys")
        lbl0.setMinimumHeight(ROW_H)
        lbl0.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
        grid.addWidget(lbl0, 0, 0)
        self.spin_phys = QDoubleSpinBox()
        self.spin_phys.setDecimals(3)
        self.spin_phys.setMinimumHeight(ROW_H)
        self.spin_phys.setToolTip(tr("spin_phys_tip"))
        tr_mgr.register(self.spin_phys, "setToolTip", "spin_phys_tip")

        self.spin_phys.editingFinished.connect(self._set_from_phys)
        grid.addWidget(self.spin_phys, 0, 1)
        self.lbl_phys_unit = QLabel("V")
        grid.addWidget(self.lbl_phys_unit, 0, 2)
        btn0 = QPushButton(tr("btn_set"))
        tr_mgr.register(btn0, "setText", "btn_set")
        btn0.setMinimumHeight(ROW_H)
        btn0.clicked.connect(self._set_from_phys)
        grid.addWidget(btn0, 0, 3)

        # Řádek RAW hodnoty
        lbl1 = QLabel(tr("lbl_raw"))
        tr_mgr.register(lbl1, "setText", "lbl_raw")
        lbl1.setMinimumHeight(ROW_H)
        lbl1.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
        grid.addWidget(lbl1, 1, 0)
        self.spin_raw = QSpinBox()
        self.spin_raw.setRange(0, RAW_MAX)
        self.spin_raw.setMinimumHeight(ROW_H)
        self.spin_raw.setToolTip(tr("spin_raw_tip"))
        tr_mgr.register(self.spin_raw, "setToolTip", "spin_raw_tip")
        
        self.spin_raw.editingFinished.connect(self._set_from_raw)
        grid.addWidget(self.spin_raw, 1, 1)
        btn1 = QPushButton(tr("btn_set"))
        tr_mgr.register(btn1, "setText", "btn_set")
        btn1.setMinimumHeight(ROW_H)
        btn1.clicked.connect(self._set_from_raw)
        grid.addWidget(btn1, 1, 3)

        # Řádek procent
        lbl2 = QLabel(tr("lbl_pct"))
        tr_mgr.register(lbl2, "setText", "lbl_pct")
        lbl2.setMinimumHeight(ROW_H)
        lbl2.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
        grid.addWidget(lbl2, 2, 0)
        self.spin_pct_direct = QDoubleSpinBox()
        self.spin_pct_direct.setRange(0, 100)
        self.spin_pct_direct.setDecimals(2)
        self.spin_pct_direct.setMinimumHeight(ROW_H)
        self.spin_pct_direct.setToolTip(tr("spin_pct_tip"))
        tr_mgr.register(self.spin_pct_direct, "setToolTip", "spin_pct_tip")

        self.spin_pct_direct.editingFinished.connect(self._set_from_pct)
        grid.addWidget(self.spin_pct_direct, 2, 1)
        grid.addWidget(QLabel("%"), 2, 2)
        btn2 = QPushButton(tr("btn_set"))
        tr_mgr.register(btn2, "setText", "btn_set")
        btn2.setMinimumHeight(ROW_H)
        btn2.clicked.connect(self._set_from_pct)
        grid.addWidget(btn2, 2, 3)

        main.addLayout(grid)

        # ═══ SKUPINA: Kroky + Bod počátku + Sweep ═════════════════════════
        # QGroupBox = rámeček s nadpisem který vizuálně sjednocuje příbuzné sekce
        group_box = QGroupBox(tr("grp_auto"))
        tr_mgr.register(group_box, "setTitle", "grp_auto")
        group_box.setStyleSheet(
            "QGroupBox { font-weight: bold; color: #7eb8e8; "
            "border: 2px solid #7eb8e8; border-radius: 4px; margin-top: 8px; }"
            "QGroupBox::title { subcontrol-origin: margin; left: 8px; padding: 0 4px; }"
        )
        # group_inner je vnitřní layout rámečku — do něj přidáváme sekce místo do main
        group_inner = QVBoxLayout(group_box)
        group_inner.setSpacing(6)
        group_inner.setContentsMargins(6, 8, 6, 6)
        main.addWidget(group_box)

        # ═══ SEKCE: Kroky ═════════════════════════════════════════════════
        self._sec_step_lbl = section_label(tr("sec_step"))
        tr_mgr.register(self._sec_step_lbl, "setText", "sec_step")
        group_inner.addWidget(self._sec_step_lbl)

        step_layout = QHBoxLayout()
        self._lbl_unit = QLabel(tr("lbl_unit"))
        tr_mgr.register(self._lbl_unit, "setText", "lbl_unit")
        step_layout.addWidget(self._lbl_unit)
        self.cmb_step_unit = QComboBox()
        self.cmb_step_unit.addItems(tr_list("cmb_step_unit_items"))
        self._prev_unit_idx = 0   # výchozí jednotka je RAW (index 0)
        self.cmb_step_unit.currentIndexChanged.connect(self._on_unit_changed)
        self.cmb_step_unit.setToolTip(tr("cmb_step_unit_tip"))
        tr_mgr.register(self.cmb_step_unit, "setToolTip", "cmb_step_unit_tip")

        step_layout.addWidget(self.cmb_step_unit)
        step_layout.addStretch()   # pružná mezera — roztáhne se podle dostupného místa

        self._lbl_step_size = QLabel(tr("lbl_step_size"))
        tr_mgr.register(self._lbl_step_size, "setText", "lbl_step_size")
        step_layout.addWidget(self._lbl_step_size)
        self.spin_step = QDoubleSpinBox()
        self.spin_step.setRange(0.001, 10000)
        self.spin_step.setValue(100)
        self.spin_step.setDecimals(0)
        self.spin_step.setToolTip(tr("spin_step_tip"))
        tr_mgr.register(self.spin_step, "setToolTip", "spin_step_tip")

        step_layout.addWidget(self.spin_step)
        self.lbl_step_unit = QLabel("RAW")
        step_layout.addWidget(self.lbl_step_unit)
        step_layout.addStretch()

        btn_minus = QPushButton(tr("btn_step_down"))
        btn_minus.setMinimumWidth(90)
        btn_minus.clicked.connect(self._step_down)
        btn_minus.setToolTip(tr("btn_step_down_tip"))
        tr_mgr.register(btn_minus, "setText", "btn_step_down")
        tr_mgr.register(btn_minus, "setToolTip", "btn_step_down_tip")
        btn_plus = QPushButton(tr("btn_step_up"))
        btn_plus.setMinimumWidth(90)
        btn_plus.clicked.connect(self._step_up)
        btn_plus.setToolTip(tr("btn_step_up_tip"))
        tr_mgr.register(btn_plus, "setText", "btn_step_up")
        tr_mgr.register(btn_plus, "setToolTip", "btn_step_up_tip")
        step_layout.addWidget(btn_minus)
        step_layout.addWidget(btn_plus)
        group_inner.addLayout(step_layout)

        # ═══ SEKCE: Bod počátku ═══════════════════════════════════════════
        sep3 = QFrame(); sep3.setFrameShape(QFrame.Shape.HLine)
        group_inner.addWidget(sep3)
        self._sec_origin_lbl = section_label(tr("sec_origin"))
        tr_mgr.register(self._sec_origin_lbl, "setText", "sec_origin")
        group_inner.addWidget(self._sec_origin_lbl)

        # Grid místo HBoxLayout — popisky těsně u políček
        origin_grid = QGridLayout()
        origin_grid.setHorizontalSpacing(4)
        origin_grid.setVerticalSpacing(4)
        origin_grid.setColumnMinimumWidth(0, 160)

        lbl_origin_val = QLabel(tr("lbl_origin_val"))
        tr_mgr.register(lbl_origin_val, "setText", "lbl_origin_val")
        lbl_origin_val.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
        origin_grid.addWidget(lbl_origin_val, 0, 0)

        # Políčko hodnoty počátku — jednotka se synchronizuje s krokem.
        # Hodnota se aplikuje až po stisku Enter (editingFinished) nebo
        # kliknutím na tlačítko "Přejít na počátek" — NE průběžně při psaní.
        self.spin_origin = QDoubleSpinBox()
        self.spin_origin.setDecimals(0)
        self.spin_origin.setRange(0, RAW_MAX)
        self.spin_origin.setValue(0)
        self.spin_origin.setToolTip(tr("spin_origin_tip"))
        tr_mgr.register(self.spin_origin, "setToolTip", "spin_origin_tip")

        # editingFinished = Enter nebo ztráta fokusu po editaci (ne průběžně při psaní)
        self.spin_origin.editingFinished.connect(self._on_origin_changed)
        origin_grid.addWidget(self.spin_origin, 0, 1)
        self.lbl_origin_unit = QLabel("RAW")
        origin_grid.addWidget(self.lbl_origin_unit, 0, 2)

        btn_use_origin = QPushButton(tr("btn_go_origin"))
        btn_use_origin.clicked.connect(self._go_to_origin)
        btn_use_origin.setToolTip(tr("btn_go_origin_tip"))
        tr_mgr.register(btn_use_origin, "setText", "btn_go_origin")
        tr_mgr.register(btn_use_origin, "setToolTip", "btn_go_origin_tip")
        origin_grid.addWidget(btn_use_origin, 0, 3)

        btn_save_origin = QPushButton(tr("btn_save_origin"))
        btn_save_origin.clicked.connect(self._save_origin)
        btn_save_origin.setToolTip(tr("btn_save_origin_tip"))
        tr_mgr.register(btn_save_origin, "setText", "btn_save_origin")
        tr_mgr.register(btn_save_origin, "setToolTip", "btn_save_origin_tip")
        origin_grid.addWidget(btn_save_origin, 0, 4)

        btn_reset_origin = QPushButton(tr("btn_reset_origin"))
        btn_reset_origin.clicked.connect(self._reset_origin)
        btn_reset_origin.setToolTip(tr("btn_reset_origin_tip"))
        tr_mgr.register(btn_reset_origin, "setText", "btn_reset_origin")
        tr_mgr.register(btn_reset_origin, "setToolTip", "btn_reset_origin_tip")
        origin_grid.addWidget(btn_reset_origin, 0, 5)

        group_inner.addLayout(origin_grid)

        # ═══ SEKCE: Sweep ═════════════════════════════════════════════════
        sep4 = QFrame(); sep4.setFrameShape(QFrame.Shape.HLine)
        group_inner.addWidget(sep4)
        self._sec_sweep_lbl = section_label(tr("sec_sweep"))
        tr_mgr.register(self._sec_sweep_lbl, "setText", "sec_sweep")
        group_inner.addWidget(self._sec_sweep_lbl)

        # Grid pro sweep — popisky těsně u políček
        sweep_grid = QGridLayout()
        sweep_grid.setHorizontalSpacing(4)
        sweep_grid.setVerticalSpacing(4)
        sweep_grid.setColumnMinimumWidth(0, 160)

        # Řádek 0: Od, Do, Krok, ms
        # Poznámka: QDoubleSpinBox místo QSpinBox — jednotka se mění spolu s krokem
        lbl_od = QLabel(tr("lbl_sweep_from"))
        tr_mgr.register(lbl_od, "setText", "lbl_sweep_from")
        lbl_od.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
        sweep_grid.addWidget(lbl_od, 0, 0)
        self.spin_sweep_from = QDoubleSpinBox()
        self.spin_sweep_from.setDecimals(0)
        self.spin_sweep_from.setRange(0, RAW_MAX)
        self.spin_sweep_from.setValue(0)
        self.spin_sweep_from.setToolTip(tr("spin_sweep_from_tip"))
        tr_mgr.register(self.spin_sweep_from, "setToolTip", "spin_sweep_from_tip")
        sweep_grid.addWidget(self.spin_sweep_from, 0, 1)
        self.lbl_sweep_from_unit = QLabel("RAW")   # uložíme jako atribut — budeme měnit
        sweep_grid.addWidget(self.lbl_sweep_from_unit, 0, 2)

        lbl_do = QLabel(tr("lbl_sweep_to"))
        tr_mgr.register(lbl_do, "setText", "lbl_sweep_to")
        lbl_do.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
        sweep_grid.addWidget(lbl_do, 0, 3)
        self.spin_sweep_to = QDoubleSpinBox()
        self.spin_sweep_to.setDecimals(0)
        self.spin_sweep_to.setRange(0, RAW_MAX)
        self.spin_sweep_to.setValue(RAW_MAX)
        self.spin_sweep_to.setToolTip(tr("spin_sweep_to_tip"))
        tr_mgr.register(self.spin_sweep_to, "setToolTip", "spin_sweep_to_tip")
        sweep_grid.addWidget(self.spin_sweep_to, 0, 4)
        self.lbl_sweep_to_unit = QLabel("RAW")
        sweep_grid.addWidget(self.lbl_sweep_to_unit, 0, 5)

        lbl_krok = QLabel(tr("lbl_sweep_step"))
        tr_mgr.register(lbl_krok, "setText", "lbl_sweep_step")
        lbl_krok.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
        sweep_grid.addWidget(lbl_krok, 0, 6)
        self.spin_sweep_step = QDoubleSpinBox()
        self.spin_sweep_step.setDecimals(0)
        self.spin_sweep_step.setRange(0.001, RAW_MAX)
        self.spin_sweep_step.setValue(500)
        self.spin_sweep_step.setToolTip(tr("spin_sweep_step_tip"))
        tr_mgr.register(self.spin_sweep_step, "setToolTip", "spin_sweep_step_tip")

        # Při změně hodnoty uživatelem uložíme RAW — zdroj pravdy pro přepočty
        self.spin_sweep_from.valueChanged.connect(self.sweep.sync_raw)
        self.spin_sweep_to.valueChanged.connect(self.sweep.sync_raw)
        self.spin_sweep_step.valueChanged.connect(self.sweep.sync_raw)
        self.spin_step.valueChanged.connect(self._sync_step_raw)
        sweep_grid.addWidget(self.spin_sweep_step, 0, 7)
        self.lbl_sweep_step_unit = QLabel("RAW")
        sweep_grid.addWidget(self.lbl_sweep_step_unit, 0, 8)

        lbl_ms = QLabel(tr("lbl_sweep_ms"))
        tr_mgr.register(lbl_ms, "setText", "lbl_sweep_ms")
        lbl_ms.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
        sweep_grid.addWidget(lbl_ms, 0, 9)
        self.spin_sweep_ms = QSpinBox()
        self.spin_sweep_ms.setRange(10, 60000)
        self.spin_sweep_ms.setValue(100)
        self.spin_sweep_ms.setToolTip(tr("spin_sweep_ms_tip"))
        tr_mgr.register(self.spin_sweep_ms, "setToolTip", "spin_sweep_ms_tip")
        sweep_grid.addWidget(self.spin_sweep_ms, 0, 10)
        sweep_grid.addWidget(QLabel("ms"), 0, 11)

        group_inner.addLayout(sweep_grid)

        # Řádek 1: smyčka + tlačítka
        sweep_btn_row = QHBoxLayout()
        self.chk_sweep_loop = QCheckBox(tr("chk_sweep_loop"))
        self.chk_sweep_loop.setToolTip(tr("chk_sweep_loop_tip"))
        tr_mgr.register(self.chk_sweep_loop, "setText", "chk_sweep_loop")
        tr_mgr.register(self.chk_sweep_loop, "setToolTip", "chk_sweep_loop_tip")
        sweep_btn_row.addWidget(self.chk_sweep_loop)

        self.btn_sweep = QPushButton(tr("btn_sweep_run"))
        tr_mgr.register(self.btn_sweep, "setText", "btn_sweep_run")
        self.btn_sweep.setCheckable(True)
        self.btn_sweep.toggled.connect(self._toggle_sweep_resume)
        self.btn_sweep.setToolTip(tr("btn_sweep_run_tip"))
        tr_mgr.register(self.btn_sweep, "setToolTip", "btn_sweep_run_tip")
        sweep_btn_row.addWidget(self.btn_sweep)

        btn_sweep_restart = QPushButton(tr("btn_sweep_restart"))
        btn_sweep_restart.clicked.connect(self.sweep.start)
        btn_sweep_restart.setToolTip(tr("btn_sweep_restart_tip"))
        tr_mgr.register(btn_sweep_restart, "setText", "btn_sweep_restart")
        tr_mgr.register(btn_sweep_restart, "setToolTip", "btn_sweep_restart_tip")
        sweep_btn_row.addStretch()
        group_inner.addLayout(sweep_btn_row)

        # ═══ SEKCE: Rychlé předvolby ══════════════════════════════════════
        sep5 = QFrame(); sep5.setFrameShape(QFrame.Shape.HLine)
        main.addWidget(sep5)
        self._sec_presets_lbl = section_label(tr("sec_presets"))
        tr_mgr.register(self._sec_presets_lbl, "setText", "sec_presets")
        main.addWidget(self._sec_presets_lbl)

        preset_layout = QHBoxLayout()
        for lbl_text, pct in [("0 %", 0), ("25 %", 25), ("50 %", 50), ("75 %", 75), ("100 %", 100)]:
            rv = percent_to_raw(pct)
            btn = QPushButton(lbl_text)
            btn.clicked.connect(lambda _, r=rv: self._set_raw_and_send(r))
            btn.setToolTip(tr("preset_tip", pct=pct, rv=rv))
            preset_layout.addWidget(btn)
        main.addLayout(preset_layout)

        # ═══ SEKCE: Ukazatele ═════════════════════════════════════════════
        sep6 = QFrame(); sep6.setFrameShape(QFrame.Shape.HLine)
        main.addWidget(sep6)
        self._sec_indicators_lbl = section_label(tr("sec_indicators"))
        tr_mgr.register(self._sec_indicators_lbl, "setText", "sec_indicators")
        main.addWidget(self._sec_indicators_lbl)

        # Progress bar nastavovací (origin → MAX) — levý konec = bod počátku
        lbl_set = QLabel(tr("lbl_progress_set"))
        tr_mgr.register(lbl_set, "setText", "lbl_progress_set")
        lbl_set.setStyleSheet("font-size: 8pt; color: #aaa;")
        main.addWidget(lbl_set)
        self.progress_set = QProgressBar()
        self.progress_set.setRange(0, RAW_MAX)
        self.progress_set.setValue(0)
        self.progress_set.setTextVisible(True)
        self.progress_set.setMinimumHeight(18)
        self.progress_set.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
        self.progress_set.setToolTip(tr("progress_set_tip"))
        tr_mgr.register(self.progress_set, "setToolTip", "progress_set_tip")

        main.addWidget(self.progress_set)

        # Progress bar referenční (0 → MAX, absolutní) — stejná šířka jako nastavovací
        lbl_ref = QLabel(tr("lbl_progress_ref"))
        tr_mgr.register(lbl_ref, "setText", "lbl_progress_ref")
        lbl_ref.setStyleSheet("font-size: 8pt; color: #aaa;")
        main.addWidget(lbl_ref)
        self.progress_ref = QProgressBar()
        self.progress_ref.setRange(0, RAW_MAX)
        self.progress_ref.setValue(0)
        self.progress_ref.setTextVisible(True)
        self.progress_ref.setMinimumHeight(14)
        self.progress_ref.setMaximumHeight(14)
        self.progress_ref.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
        self.progress_ref.setToolTip(tr("progress_ref_tip"))
        tr_mgr.register(self.progress_ref, "setToolTip", "progress_ref_tip")
        main.addWidget(self.progress_ref)

        # Spodní odsazení aby progress_ref nebyl oříznutý scrollarea
        main.addSpacing(12)

        # Inicializuj rozsahy políčka fyzikální hodnoty
        self._update_spin_range()
        # Příznak: inicializace dokončena — od teď se změny rozsahu posílají do zařízení
        self._initialized = True
        self._connect_select_all()

    # ── Pomocné metody pro rozsahy a jednotky ──────────────────────────────

    def _update_spin_range(self):
        """Nastaví rozsah a suffix políčka fyzikální hodnoty dle zvoleného rozsahu."""
        rng = self.cmb_range.currentText()
        lo, hi, unit = OUTPUT_RANGES[rng]
        self.spin_phys.setRange(lo, hi)
        self.lbl_phys_unit.setText(unit)

    def _on_unit_changed(self):
        """Reakce na změnu jednotky kroku — aktualizuje suffix kroku i bodu počátku.
        KLÍČOVÉ: origin_raw čteme pomocí PŘEDCHOZÍHO indexu jednotky (self._prev_unit_idx),
        aby se číslo 20 RAW správně přepočítalo na ~0.03 % a ne na 20 %."""
        new_idx  = self.cmb_step_unit.currentIndex()
        rng = self.cmb_range.currentText()
        lo, hi, unit = OUTPUT_RANGES[rng]

        # 1) Přečti origin v RAW pomocí STARÉ jednotky (před přepnutím)
        origin_raw = self._origin_to_raw_with_idx(self._prev_unit_idx)

        # Přečti sweep hodnoty jako RAW ještě před přepsáním _prev_unit_idx
        old_idx = self._prev_unit_idx

        # 2) Zapamatuj nový index jako "předchozí" pro příští přepnutí
        self._prev_unit_idx = new_idx

        # 3) Změň suffix, desetinná místa a přepočítej hodnotu kroku z uložené RAW
        suffixes_step = ["RAW", "% rozsahu", unit]
        self.spin_step.blockSignals(True)
        if new_idx == 0:      # RAW — celá čísla 1–65535
            self.spin_step.setDecimals(0)
            self.spin_step.setRange(1, RAW_MAX)
            self.spin_step.setValue(self._step_raw)
            self.lbl_step_unit.setText("RAW")
        elif new_idx == 1:    # % — 0,01–100 %
            self.spin_step.setDecimals(2)
            self.spin_step.setRange(0.01, 100)
            self.spin_step.setValue(raw_to_percent(self._step_raw))
            self.lbl_step_unit.setText("%")
        else:                 # fyzikální — krok je relativní rozdíl, max = celý rozsah
            self.spin_step.setDecimals(3)
            self.spin_step.setRange(0.001, hi - lo)   # hi-lo = velikost rozsahu (např. 16 mA)
            self.spin_step.setValue(raw_to_phys_delta(self._step_raw, rng))
            self.lbl_step_unit.setText(unit)
        self.spin_step.blockSignals(False)

        # 4) Přepočítej a nastav origin do nové jednotky
        self.spin_origin.blockSignals(True)
        if new_idx == 0:     # RAW
            self.spin_origin.setDecimals(0)
            self.spin_origin.setRange(0, RAW_MAX)
            self.lbl_origin_unit.setText("RAW")
            self.spin_origin.setValue(origin_raw)
        elif new_idx == 1:   # %
            self.spin_origin.setDecimals(4)
            self.spin_origin.setRange(0, 100)
            self.lbl_origin_unit.setText("%")
            self.spin_origin.setValue(raw_to_percent(origin_raw))
        else:                 # fyzikální
            self.spin_origin.setDecimals(3)
            self.spin_origin.setRange(lo, hi)
            self.lbl_origin_unit.setText(unit)
            self.spin_origin.setValue(raw_to_phys(origin_raw, rng))
        self.spin_origin.blockSignals(False)
        # 5) Přepočítej hodnoty Sweep do nové jednotky
        # Čteme uložené RAW hodnoty — ne ze spinboxů, aby nevznikaly zaokrouhlovací chyby
        sweep_from_raw = self.sweep.from_raw
        sweep_to_raw   = self.sweep.to_raw
        sweep_step_raw = self.sweep.step_raw

        self.spin_sweep_from.blockSignals(True)
        self.spin_sweep_to.blockSignals(True)
        self.spin_sweep_step.blockSignals(True)

        if new_idx == 0:     # RAW
            for sp in (self.spin_sweep_from, self.spin_sweep_to):
                sp.setDecimals(0); sp.setRange(0, RAW_MAX)
            self.spin_sweep_step.setDecimals(0)
            self.spin_sweep_step.setRange(1, RAW_MAX)
            self.spin_sweep_from.setValue(sweep_from_raw)
            self.spin_sweep_to.setValue(sweep_to_raw)
            self.spin_sweep_step.setValue(max(1, sweep_step_raw))
            for lbl in (self.lbl_sweep_from_unit, self.lbl_sweep_to_unit, self.lbl_sweep_step_unit):
                lbl.setText("RAW")
        elif new_idx == 1:   # %
            for sp in (self.spin_sweep_from, self.spin_sweep_to):
                sp.setDecimals(2); sp.setRange(0, 100)
            self.spin_sweep_step.setDecimals(2)
            self.spin_sweep_step.setRange(0.01, 100)
            self.spin_sweep_from.setValue(raw_to_percent(sweep_from_raw))
            self.spin_sweep_to.setValue(raw_to_percent(sweep_to_raw))
            self.spin_sweep_step.setValue(max(0.01, raw_to_percent(sweep_step_raw)))
            for lbl in (self.lbl_sweep_from_unit, self.lbl_sweep_to_unit, self.lbl_sweep_step_unit):
                lbl.setText("%")
        else:                # fyzikální
            for sp in (self.spin_sweep_from, self.spin_sweep_to):
                sp.setDecimals(3); sp.setRange(lo, hi)
            self.spin_sweep_step.setDecimals(3)
            self.spin_sweep_step.setRange(0.001, hi - lo)
            self.spin_sweep_from.setValue(raw_to_phys(sweep_from_raw, rng))
            self.spin_sweep_to.setValue(raw_to_phys(sweep_to_raw, rng))
            self.spin_sweep_step.setValue(max(0.001, raw_to_phys_delta(sweep_step_raw, rng)))
            for lbl in (self.lbl_sweep_from_unit, self.lbl_sweep_to_unit, self.lbl_sweep_step_unit):
                lbl.setText(unit)

        self.spin_sweep_from.blockSignals(False)
        self.spin_sweep_to.blockSignals(False)
        self.spin_sweep_step.blockSignals(False)
        self._refresh_display()

    def _on_range_changed(self):
        """Reakce na změnu výstupního rozsahu — aktualizuje zobrazení
        a odešle požadavek na změnu hardwarového rozsahu DA2ETH přes Spinel.
        Signál se emituje jen pokud je widget plně inicializován (ne při startu)."""
        self._update_spin_range()
        self._on_unit_changed()
        # Emituj jen pokud uživatel sám změnil rozsah (ne při inicializaci)
        if hasattr(self, '_initialized') and self._initialized:
            self.request_range.emit(self.ch, self.cmb_range.currentText())

    def _origin_to_raw(self) -> int:
        """Vrátí aktuální hodnotu bodu počátku převedenou na RAW (aktuální jednotka)."""
        return self._origin_to_raw_with_idx(self.cmb_step_unit.currentIndex())

    def _origin_to_raw_with_idx(self, unit_idx: int) -> int:
        """Převede hodnotu spin_origin na RAW pomocí zadaného indexu jednotky.
        Odděleno od _origin_to_raw aby šlo číst se starou jednotkou při přepínání."""
        val = self.spin_origin.value()
        rng = self.cmb_range.currentText()
        if unit_idx == 0:    # RAW
            return int(val)
        elif unit_idx == 1:  # %
            return percent_to_raw(val)
        else:                # fyzikální
            return phys_to_raw(val, rng)
        
    def _sync_step_raw(self):
        """Přečte aktuální hodnotu políčka Krok a uloží ji jako RAW.
        Volá se při každé změně hodnoty uživatelem — ne při přepočtu jednotek."""
        idx = self.cmb_step_unit.currentIndex()
        rng = self.cmb_range.currentText()
        if idx == 0:      # RAW
            self._step_raw = max(1, int(self.spin_step.value()))
        elif idx == 1:    # %
            self._step_raw = percent_to_raw(self.spin_step.value())
        else:             # fyzikální — krok je relativní rozdíl, ne absolutní hodnota
            self._step_raw = phys_to_raw_delta(self.spin_step.value(),
                                               self.cmb_range.currentText())

    # ── Aktualizace všech vizuálních prvků ─────────────────────────────────

    def _refresh_display(self):
        """Aktualizuje všechny vizuální prvky (slider, progress bary, políčka)
        podle aktuální RAW hodnoty. Příznak _updating zabraňuje rekurzi."""
        if self._updating:
            return
        self._updating = True
        try:
            rng       = self.cmb_range.currentText()
            lo, hi, unit = OUTPUT_RANGES[rng]
            phys      = raw_to_phys(self.current_raw, rng)
            pct       = raw_to_percent(self.current_raw)
            origin_raw = self._origin_to_raw()

            # Velký popisek fyzikální hodnoty
            self.lbl_phys.setText(f"{phys:.3f} {unit}")
            self.lbl_pct.setText(f"{pct:.1f} %")
            self.lbl_pct_left.setText(f"origin={origin_raw}")

            # Políčka Přímého zadání — aktualizuj jen pokud nemají focus
            if not self.spin_phys.hasFocus():
                self.spin_phys.setValue(phys)
            if not self.spin_raw.hasFocus():
                self.spin_raw.setValue(self.current_raw)
            if not self.spin_pct_direct.hasFocus():
                self.spin_pct_direct.setValue(pct)

            # Referenční progress bar: absolutní poloha 0–65535
            self.progress_ref.setValue(self.current_raw)

            # Nastavovací progress bar: rozsah origin→MAX
            set_span = RAW_MAX - origin_raw
            if set_span > 0:
                self.progress_set.setRange(0, set_span)
                self.progress_set.setValue(max(0, self.current_raw - origin_raw))
            else:
                self.progress_set.setRange(0, 1)
                self.progress_set.setValue(0)

            # Slider: minimum = origin, hodnota = max(origin, current_raw)
            self.slider.blockSignals(True)
            self.slider.setMinimum(origin_raw)
            self.slider.setValue(max(origin_raw, self.current_raw))
            self.slider.blockSignals(False)

        finally:
            self._updating = False

    def _set_raw_and_send(self, raw: int):
        """Nastaví výstup na danou RAW hodnotu (oříznutou na origin),
        aktualizuje GUI a odešle zápis."""
        # Oříznutí na minimum = bod počátku (platí pro slider, přímé zadání i rychlé předvolby)
        clamped = max(self._origin_to_raw(), max(RAW_MIN, min(RAW_MAX, raw)))
        self.current_raw = clamped
        self._refresh_display()
        self.request_write.emit(self.ch, self.current_raw)

    # ── Přímé zadání ───────────────────────────────────────────────────────

    def _set_from_phys(self):
        """Nastaví výstup z políčka fyzikální hodnoty (Enter nebo tlačítko)."""
        self._set_raw_and_send(phys_to_raw(self.spin_phys.value(), self.cmb_range.currentText()))

    def _set_from_raw(self):
        """Nastaví výstup z políčka RAW hodnoty (Enter nebo tlačítko)."""
        self._set_raw_and_send(self.spin_raw.value())

    def _set_from_pct(self):
        """Nastaví výstup z políčka procent (Enter nebo tlačítko)."""
        self._set_raw_and_send(percent_to_raw(self.spin_pct_direct.value()))

    # ── Slider ─────────────────────────────────────────────────────────────

    def _on_slider(self, raw: int):
        """Reakce na pohyb slideru — nastaví výstup a odešle zápis.
        Slider má minimum = origin, takže pod počátek klesnou nemůže."""
        if self._updating:
            return
        self.current_raw = raw
        self._refresh_display()
        self.request_write.emit(self.ch, raw)

    # ── Kroky ──────────────────────────────────────────────────────────────

    def _step_raw_val(self) -> int:
        """Vrátí aktuální velikost kroku v RAW — používá uloženou hodnotu jako zdroj pravdy."""
        return self._step_raw

    def _step_up(self):
        self._set_raw_and_send(min(RAW_MAX, self.current_raw + self._step_raw_val()))

    def _step_down(self):
        # _set_raw_and_send ořízne na origin automaticky
        self._set_raw_and_send(self.current_raw - self._step_raw_val())

    # ── Bod počátku ────────────────────────────────────────────────────────

    def _on_origin_changed(self):
        """Reakce na změnu bodu počátku — přesune slider a ořízne výstup."""
        origin_raw = self._origin_to_raw()
        if self.current_raw < origin_raw:
            # Výstup je pod novým počátkem — přesuň ho na počátek
            self.current_raw = origin_raw
            self.request_write.emit(self.ch, self.current_raw)
        self._refresh_display()

    def _go_to_origin(self):
        """Přeskočí výstup i slider na hodnotu bodu počátku."""
        self._set_raw_and_send(self._origin_to_raw())

    def _save_origin(self):
        """Uloží aktuální výstupní hodnotu jako nový bod počátku."""
        unit_idx = self.cmb_step_unit.currentIndex()
        rng = self.cmb_range.currentText()
        self.spin_origin.blockSignals(True)
        if unit_idx == 0:
            self.spin_origin.setValue(self.current_raw)
        elif unit_idx == 1:
            self.spin_origin.setValue(raw_to_percent(self.current_raw))
        else:
            self.spin_origin.setValue(raw_to_phys(self.current_raw, rng))
        self.spin_origin.blockSignals(False)
        self._refresh_display()

    def _reset_origin(self):
        """Vrátí bod počátku na 0 a nastaví výstup na 0 — slider od nuly."""
        self.spin_origin.blockSignals(True)
        self.spin_origin.setValue(0)
        self.spin_origin.blockSignals(False)
        self._set_raw_and_send(0)

    # ── Sweep ──────────────────────────────────────────────────────────────

    def _toggle_sweep_resume(self, checked: bool):
        """Spustí sweep od zapamatované pozice nebo zastaví a pozici si zapamatuje."""
        if checked:
            self.btn_sweep.setText("■  Zastavit")
            if self.sweep.paused_raw is not None:
                self.current_raw = self.sweep.paused_raw
            self._refresh_display()
            self.sweep.timer.start(self.spin_sweep_ms.value())
        else:
            self.sweep.timer.stop()
            self.sweep.paused_raw = self.current_raw
            self.btn_sweep.setText("▶  Spustit / Pokračovat")

# ── Hlavní okno ────────────────────────────────────────────────────────────

class LineNumberArea(QWidget):
    """Postranní panel zobrazující čísla řádků vedle editoru.
    Je to samostatný widget který se překresluje společně s editorem."""

    def __init__(self, editor):
        super().__init__(editor)
        self.editor = editor   # reference na editor ke kterému patří

    def sizeHint(self):
        return QSize(self.editor._line_number_area_width(), 0)

    def paintEvent(self, event):
        self.editor._paint_line_numbers(event)


class LineNumberPlainTextEdit(QPlainTextEdit):
    """QPlainTextEdit rozšířený o panel s čísly řádků vlevo.
    Číslují se pouze neprázdné, nekomentářové řádky — stejně jak je počítá engine."""

    def __init__(self, parent=None, program_editor=None):
        super().__init__(parent)
        self._program_editor = program_editor   # přímá reference na ProgramEditor
        self._finished_flag = False   # příznak konce programu
        self.line_number_area = LineNumberArea(self)
        # Napojení signálů — při změně obsahu nebo posunu překresli čísla řádků
        self.blockCountChanged.connect(self._update_line_number_area_width)
        self.updateRequest.connect(self._update_line_number_area)
        self.cursorPositionChanged.connect(self.line_number_area.update)
        self._update_line_number_area_width(0)

    def _line_number_area_width(self) -> int:
        """Vypočítá šířku panelu čísel řádků podle počtu řádků."""
        digits = len(str(max(1, self.blockCount())))
        # fontMetrics().horizontalAdvance = šířka znaku v pixelech
        return 6 + self.fontMetrics().horizontalAdvance("9") * (digits + 1)

    def _update_line_number_area_width(self, _):
        """Nastaví levý okraj editoru aby panel čísel řádků nezakrýval text."""
        self.setViewportMargins(self._line_number_area_width(), 0, 0, 0)

    def _update_line_number_area(self, rect, dy):
        """Posune nebo překreslí panel čísel řádků při scrollování."""
        if dy:
            self.line_number_area.scroll(0, dy)
        else:
            self.line_number_area.update(
                0, rect.y(), self.line_number_area.width(), rect.height()
            )

    def resizeEvent(self, event):
        super().resizeEvent(event)
        cr = self.contentsRect()
        self.line_number_area.setGeometry(
            cr.left(), cr.top(), self._line_number_area_width(), cr.height()
        )

    def keyPressEvent(self, event):
        """Přepíše zpracování kláves aby nešlo částečně mazat řádky příkazů.
        Řádky příkazů (platné příkazy) lze smazat pouze celé — Backspace nebo Delete
        na řádku s příkazem smaže celý řádek. Normální text lze upravovat volně."""
        from PyQt6.QtCore import Qt
        cursor      = self.textCursor()
        block       = self.document().findBlockByNumber(cursor.blockNumber())
        line        = block.text().strip()
        first       = line.split()[0].upper() if line else ""
        is_command  = first in VALID_COMMANDS

        if is_command:
            # Na řádku s příkazem — povolíme pouze smazání celého řádku
            if event.key() in (Qt.Key.Key_Backspace, Qt.Key.Key_Delete):
                # Vyber celý řádek a smaž ho
                cursor.select(cursor.SelectionType.LineUnderCursor)
                # Zkontroluj zda je vybrán celý řádek nebo jen část
                selected = cursor.selectedText()
                if selected.strip() in (line, ""):
                    cursor.removeSelectedText()
                    # Odstraň i prázdný řádek který zůstal
                    cursor2 = self.textCursor()
                    cursor2.select(cursor2.SelectionType.LineUnderCursor)
                    if not cursor2.selectedText().strip():
                        cursor2.removeSelectedText()
                        cursor2.deletePreviousChar()
                    self.setTextCursor(cursor2)
                return   # ignoruj jiné klávesy na řádku s příkazem
            elif event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter,
                                  Qt.Key.Key_Up, Qt.Key.Key_Down,
                                  Qt.Key.Key_Left, Qt.Key.Key_Right,
                                  Qt.Key.Key_Home, Qt.Key.Key_End,
                                  Qt.Key.Key_PageUp, Qt.Key.Key_PageDown):
                super().keyPressEvent(event)   # pohyb kurzoru povolen
            else:
                return   # ostatní klávesy na řádku s příkazem ignoruj
        else:
            super().keyPressEvent(event)   # na komentářích a prázdných řádcích vše povoleno

    def _paint_line_numbers(self, event):
        """Vykreslí čísla řádků — číslují se jen aktivní řádky (ne komentáře, ne prázdné)."""
        from PyQt6.QtGui import QPainter, QColor
        painter = QPainter(self.line_number_area)
        painter.fillRect(event.rect(), QColor("#2a2a2e"))   # tmavé pozadí panelu

        block       = self.firstVisibleBlock()
        block_num   = block.blockNumber()
        top         = int(self.blockBoundingGeometry(block)
                         .translated(self.contentOffset()).top())
        bottom      = top + int(self.blockBoundingRect(block).height())

        # Průchod přes viditelné bloky (řádky) editoru
        active_num = 0   # čítač aktivních řádků (bez komentářů a prázdných)
        # Nejdřív spočítáme čísla všech řádků od začátku
        all_blocks = []
        b = self.document().begin()
        n = 0
        while b.isValid():
            text  = b.text().strip()
            first = text.split()[0].upper() if text else ""
            if text and not text.startswith("#") and first in VALID_COMMANDS:
                n += 1
                all_blocks.append(n)   # platný příkaz — dostane číslo
            else:
                all_blocks.append(None)   # komentář, prázdný nebo neplatný — tečka
            b = b.next()

        block     = self.firstVisibleBlock()
        block_num = block.blockNumber()
        top       = int(self.blockBoundingGeometry(block)
                       .translated(self.contentOffset()).top())
        bottom    = top + int(self.blockBoundingRect(block).height())

        while block.isValid() and top <= event.rect().bottom():
            if block.isVisible() and bottom >= event.rect().top():
                num = all_blocks[block_num] if block_num < len(all_blocks) else None
                if num is not None:
                    painter.setPen(QColor("#7eb8e8"))
                    painter.drawText(
                        0, top,
                        self.line_number_area.width() - 3,
                        self.fontMetrics().height(),
                        Qt.AlignmentFlag.AlignRight,
                        str(num)
                    )
                else:
                    # Komentář nebo prázdný řádek — šedá tečka
                    painter.setPen(QColor("#555555"))
                    painter.drawText(
                        0, top,
                        self.line_number_area.width() - 3,
                        self.fontMetrics().height(),
                        Qt.AlignmentFlag.AlignRight,
                        "·"
                    )
            block      = block.next()
            block_num += 1
            top        = bottom
            bottom     = top + int(self.blockBoundingRect(block).height())

        painter.end()

class CommandDialog(QDialog):
    """Dialogové okno pro zadání parametrů příkazu.
    QDialog = vyskakovací okno které čeká na potvrzení uživatelem."""

    def __init__(self, cmd: str, parent=None,
                 first_range: str = None, first_unit_idx: int = None,
                 trigger_programs: dict = None, source_channel: int = 0,
                 last_ramp_to: float = None, last_ramp_step: float = None,
                 last_ramp_ms: int = None, last_ramp_range: str = None,
                 last_ramp_unit_idx: int = None,
                 prev_end_val: float = None, prev_end_rng: str = None,
                 prev_end_unit_idx: int = None):
        super().__init__(parent)
        self.cmd              = cmd
        self.first_range      = first_range
        self.first_unit_idx   = first_unit_idx
        self._trigger_programs = trigger_programs or {}
        self._source_channel  = source_channel
        self._last_ramp_to       = last_ramp_to
        self._last_ramp_range    = last_ramp_range
        self._last_ramp_unit_idx = last_ramp_unit_idx
        self._last_ramp_step = last_ramp_step
        self._last_ramp_ms   = last_ramp_ms
        self._prev_end_val      = prev_end_val
        self._prev_end_rng      = prev_end_rng
        self._prev_end_unit_idx = prev_end_unit_idx
        self.setWindowTitle(f"Příkaz: {cmd}")
        self.setModal(True)     # modální = blokuje hlavní okno dokud není zavřeno
        self._build_ui()

    def _build_ui(self):
        """Sestaví obsah dialogu podle typu příkazu."""
        layout = QVBoxLayout(self)
        layout.setSpacing(8)

        # Každý příkaz má jiné parametry — přidáme příslušné prvky
        if self.cmd == "SET":
            self._build_set(layout)
        elif self.cmd == "WAIT":
            self._build_wait(layout)
        elif self.cmd == "RAMP":
            self._build_ramp(layout)
        elif self.cmd == "JUMP":
            self._build_jump(layout)
        elif self.cmd == "REPEAT":
            self._build_repeat(layout)
        elif self.cmd == "TRIGGER":
            self._build_trigger(layout)

        # Tlačítka OK / Zrušit
        btn_row = QHBoxLayout()
        btn_ok = QPushButton(tr("btn_ok"))
        btn_ok.setDefault(True)   # Enter potvrdí dialog
        btn_ok.clicked.connect(self.accept)   # accept = zavři dialog s výsledkem OK
        btn_cancel = QPushButton(tr("btn_cancel"))
        btn_cancel.clicked.connect(self.reject)   # reject = zavři dialog se zrušením
        btn_row.addStretch()
        btn_row.addWidget(btn_ok)
        btn_row.addWidget(btn_cancel)
        layout.addLayout(btn_row)

    def _build_set(self, layout):
        """Parametry příkazu SET — hodnota, jednotka, rozsah výstupu."""
        layout.addWidget(QLabel(tr("dlg_set_desc")))
        grid = QGridLayout()

        grid.addWidget(QLabel(tr("lbl_set_range")), 0, 0)
        self.cmb_range = QComboBox()
        self.cmb_range.addItems(list(OUTPUT_RANGES.keys()))
        self.cmb_range.currentIndexChanged.connect(self._update_set_range)
        grid.addWidget(self.cmb_range, 0, 1)

        grid.addWidget(QLabel(tr("lbl_set_unit")), 1, 0)
        self.cmb_set_unit = QComboBox()
        self.cmb_set_unit.addItems(tr_list("cmb_unit_items"))
        self.cmb_set_unit.currentIndexChanged.connect(self._update_set_range)
        grid.addWidget(self.cmb_set_unit, 1, 1)

        grid.addWidget(QLabel(tr("lbl_set_value")), 2, 0)
        self.spin_set_val = QDoubleSpinBox()
        self.spin_set_val.setDecimals(3)
        self.spin_set_val.setRange(0, 100)
        self.spin_set_val.setValue(50)
        grid.addWidget(self.spin_set_val, 2, 1)
        self.lbl_set_unit = QLabel("%")
        grid.addWidget(self.lbl_set_unit, 2, 2)

        layout.addLayout(grid)
        self._update_set_range()

        # Přednastavení rozsahu a jednotky podle prvního SET — blokujeme signály
        # aby se nespustil _update_set_range dřív než jsou obě hodnoty nastaveny
        if self.first_range is not None and self.first_range in OUTPUT_RANGES:
            self.cmb_range.blockSignals(True)
            self.cmb_range.setCurrentIndex(
                list(OUTPUT_RANGES.keys()).index(self.first_range))
            self.cmb_range.blockSignals(False)
        if self.first_unit_idx is not None:
            self.cmb_set_unit.blockSignals(True)
            self.cmb_set_unit.setCurrentIndex(self.first_unit_idx)
            self.cmb_set_unit.blockSignals(False)
        self._update_set_range()   # aktualizuj rozsah spinboxu

    def _update_set_range(self):
        """Aktualizuje rozsah a jednotku políčka hodnoty podle zvoleného rozsahu a jednotky."""
        rng  = self.cmb_range.currentText()
        idx  = self.cmb_set_unit.currentIndex()
        lo, hi, unit = OUTPUT_RANGES[rng]
        if idx == 0:      # %
            self.spin_set_val.setRange(0, 100)
            self.spin_set_val.setDecimals(2)
            self.lbl_set_unit.setText("%")
        elif idx == 1:    # RAW
            self.spin_set_val.setRange(0, RAW_MAX)
            self.spin_set_val.setDecimals(0)
            self.lbl_set_unit.setText("RAW")
        else:             # fyzikální
            self.spin_set_val.setRange(lo, hi)
            self.spin_set_val.setDecimals(3)
            self.lbl_set_unit.setText(unit)
        
    def _build_wait(self, layout):
        """Parametry příkazu WAIT — doba čekání."""
        layout.addWidget(QLabel(tr("dlg_wait_desc")))
        row = QHBoxLayout()
        row.addWidget(QLabel(tr("lbl_wait_time")))
        self.spin_wait = QDoubleSpinBox()
        self.spin_wait.setRange(0.001, 3600)   # 1 ms až 1 hodina
        self.spin_wait.setDecimals(3)
        self.spin_wait.setValue(1.0)
        row.addWidget(self.spin_wait)
        row.addWidget(QLabel(tr("lbl_wait_unit")))
        row.addStretch()
        layout.addLayout(row)

    def _build_ramp(self, layout):
        """Parametry příkazu RAMP — plynulý přechod."""
        layout.addWidget(QLabel(tr("dlg_ramp_desc")))
        grid = QGridLayout()

        grid.addWidget(QLabel(tr("lbl_ramp_range")), 0, 0)
        self.cmb_ramp_range = QComboBox()
        self.cmb_ramp_range.addItems(list(OUTPUT_RANGES.keys()))
        self.cmb_ramp_range.currentIndexChanged.connect(self._update_ramp_range)
        grid.addWidget(self.cmb_ramp_range, 0, 1, 1, 2)

        grid.addWidget(QLabel(tr("lbl_ramp_unit")), 1, 0)
        self.cmb_ramp_unit = QComboBox()
        self.cmb_ramp_unit.addItems(tr_list("cmb_unit_items"))
        self.cmb_ramp_unit.currentIndexChanged.connect(self._update_ramp_range)
        grid.addWidget(self.cmb_ramp_unit, 1, 1, 1, 2)

        grid.addWidget(QLabel(tr("lbl_ramp_from")), 2, 0)
        self.spin_ramp_from = QDoubleSpinBox()
        self.spin_ramp_from.setRange(0, 100)
        self.spin_ramp_from.setDecimals(2)
        self.spin_ramp_from.setValue(0)
        grid.addWidget(self.spin_ramp_from, 2, 1)
        self.lbl_ramp_unit1 = QLabel("%")
        grid.addWidget(self.lbl_ramp_unit1, 2, 2)
        self.chk_from_prev = QCheckBox(tr("chk_from_prev"))
        self.chk_from_prev.setToolTip(tr("chk_from_prev_tip"))
        self.chk_from_prev.setEnabled(
            self._last_ramp_to is not None or self._prev_end_val is not None)
        self.chk_from_prev.toggled.connect(self._on_ramp_prev_toggled)
        grid.addWidget(self.chk_from_prev, 2, 3)

        grid.addWidget(QLabel(tr("lbl_ramp_to")), 3, 0)
        self.spin_ramp_to = QDoubleSpinBox()
        self.spin_ramp_to.setRange(0, 100)
        self.spin_ramp_to.setDecimals(2)
        self.spin_ramp_to.setValue(100)
        grid.addWidget(self.spin_ramp_to, 3, 1)
        self.lbl_ramp_unit2 = QLabel("%")
        grid.addWidget(self.lbl_ramp_unit2, 3, 2)

        grid.addWidget(QLabel(tr("lbl_ramp_step")), 4, 0)
        self.spin_ramp_step = QDoubleSpinBox()
        self.spin_ramp_step.setRange(0.001, RAW_MAX)
        self.spin_ramp_step.setDecimals(2)
        self.spin_ramp_step.setValue(1)
        grid.addWidget(self.spin_ramp_step, 4, 1)
        self.lbl_ramp_unit3 = QLabel("%")
        grid.addWidget(self.lbl_ramp_unit3, 4, 2)
        self.chk_step_prev = QCheckBox(tr("chk_step_prev"))
        self.chk_step_prev.setToolTip(tr("chk_step_prev_tip"))
        self.chk_step_prev.setEnabled(self._last_ramp_to is not None)
        self.chk_step_prev.toggled.connect(self._on_ramp_step_toggled)
        grid.addWidget(self.chk_step_prev, 4, 3)

        grid.addWidget(QLabel(tr("lbl_ramp_ms")), 5, 0)
        self.spin_ramp_ms = QSpinBox()
        self.spin_ramp_ms.setRange(1, 60000)
        self.spin_ramp_ms.setValue(100)
        grid.addWidget(self.spin_ramp_ms, 5, 1)
        grid.addWidget(QLabel(tr("lbl_ramp_ms_unit")), 5, 2)
        self.chk_ms_prev = QCheckBox(tr("chk_ms_prev"))
        self.chk_ms_prev.setToolTip(tr("chk_ms_prev_tip"))
        self.chk_ms_prev.setEnabled(self._last_ramp_to is not None)
        self.chk_ms_prev.toggled.connect(self._on_ramp_ms_toggled)
        grid.addWidget(self.chk_ms_prev, 5, 3)

        layout.addLayout(grid)

        if self.first_range is not None and self.first_range in OUTPUT_RANGES:
            self.cmb_ramp_range.blockSignals(True)
            self.cmb_ramp_range.setCurrentIndex(
                list(OUTPUT_RANGES.keys()).index(self.first_range))
            self.cmb_ramp_range.blockSignals(False)
        if self.first_unit_idx is not None:
            self.cmb_ramp_unit.blockSignals(True)
            self.cmb_ramp_unit.setCurrentIndex(self.first_unit_idx)
            self.cmb_ramp_unit.blockSignals(False)
        self._update_ramp_range()

    def _update_ramp_range(self):
        """Aktualizuje rozsahy RAMP spinboxů podle zvolené jednotky."""
        rng = self.cmb_ramp_range.currentText()
        idx = self.cmb_ramp_unit.currentIndex()
        lo, hi, unit = OUTPUT_RANGES[rng]
        if idx == 0:
            for sp in (self.spin_ramp_from, self.spin_ramp_to):
                sp.setRange(0, 100); sp.setDecimals(2)
            self.spin_ramp_step.setRange(0.01, 100)
            for lb in (self.lbl_ramp_unit1, self.lbl_ramp_unit2, self.lbl_ramp_unit3):
                lb.setText("%")
        elif idx == 1:
            for sp in (self.spin_ramp_from, self.spin_ramp_to):
                sp.setRange(0, RAW_MAX); sp.setDecimals(0)
            self.spin_ramp_step.setRange(1, RAW_MAX)
            for lb in (self.lbl_ramp_unit1, self.lbl_ramp_unit2, self.lbl_ramp_unit3):
                lb.setText("RAW")
        else:
            for sp in (self.spin_ramp_from, self.spin_ramp_to):
                sp.setRange(lo, hi); sp.setDecimals(3)
            self.spin_ramp_step.setRange(0.001, hi - lo)
            for lb in (self.lbl_ramp_unit1, self.lbl_ramp_unit2, self.lbl_ramp_unit3):
                lb.setText(unit)

    def _on_ramp_prev_toggled(self, checked: bool):
        val  = self._last_ramp_to      if self._last_ramp_to      is not None else self._prev_end_val
        rng  = self._last_ramp_range   if self._last_ramp_range   is not None else self._prev_end_rng
        uidx = self._last_ramp_unit_idx if self._last_ramp_unit_idx is not None else self._prev_end_unit_idx
        if checked and val is not None:
            if rng and rng in OUTPUT_RANGES:
                self.cmb_ramp_range.setCurrentIndex(list(OUTPUT_RANGES.keys()).index(rng))
            if uidx is not None:
                self.cmb_ramp_unit.setCurrentIndex(uidx)
            self._update_ramp_range()
            self.spin_ramp_from.setValue(val)
            self.spin_ramp_from.setEnabled(False)
        else:
            self.spin_ramp_from.setEnabled(True)

    def _on_ramp_step_toggled(self, checked: bool):
        """Checkbox Krok: — přepíše pole hodnotou kroku z posledního RAMP dialogu."""
        if checked and self._last_ramp_to is not None:
            self.spin_ramp_step.setValue(
                self._last_ramp_step if hasattr(self, '_last_ramp_step') and
                self._last_ramp_step is not None else self.spin_ramp_step.value())
            self.spin_ramp_step.setEnabled(False)
        else:
            self.spin_ramp_step.setEnabled(True)

    def _on_ramp_ms_toggled(self, checked: bool):
        """Checkbox Interval: — přepíše pole hodnotou ms z posledního RAMP dialogu."""
        if checked and self._last_ramp_to is not None:
            self.spin_ramp_ms.setValue(
                self._last_ramp_ms if hasattr(self, '_last_ramp_ms') and
                self._last_ramp_ms is not None else self.spin_ramp_ms.value())
            self.spin_ramp_ms.setEnabled(False)
        else:
            self.spin_ramp_ms.setEnabled(True)
    
    def _build_jump(self, layout):
        """Parametry příkazu JUMP — skok na řádek s počtem opakování."""
        layout.addWidget(QLabel(tr("dlg_jump_desc")))
        grid = QGridLayout()

        grid.addWidget(QLabel(tr("lbl_jump_line")), 0, 0)
        self.spin_jump = QSpinBox()
        self.spin_jump.setRange(1, 9999)
        self.spin_jump.setValue(1)
        self.spin_jump.setToolTip(tr("spin_jump_tip"))
        grid.addWidget(self.spin_jump, 0, 1)

        grid.addWidget(QLabel(tr("lbl_jump_repeat")), 1, 0)
        self.spin_jump_repeat = QSpinBox()
        self.spin_jump_repeat.setRange(0, 99999)
        self.spin_jump_repeat.setValue(1)
        self.spin_jump_repeat.setToolTip(tr("spin_jump_repeat_tip"))

        grid.addWidget(self.spin_jump_repeat, 1, 1)
        grid.addWidget(QLabel(tr("lbl_jump_inf")), 1, 2)

        layout.addLayout(grid)

    def _build_repeat(self, layout):
        """Parametry příkazu REPEAT — opakování programu."""
        layout.addWidget(QLabel(tr("dlg_repeat_desc")))
        row = QHBoxLayout()
        row.addWidget(QLabel(tr("lbl_repeat_count")))
        self.spin_repeat = QSpinBox()
        self.spin_repeat.setRange(0, 99999)
        self.spin_repeat.setValue(0)
        self.spin_repeat.setToolTip(tr("spin_repeat_tip"))
        row.addWidget(self.spin_repeat)
        row.addWidget(QLabel(tr("lbl_repeat_inf")))
        row.addStretch()
        layout.addLayout(row)

    def _build_trigger(self, layout):
        """Parametry příkazu TRIGGER — spuštění nebo zastavení druhého výstupu."""
        layout.addWidget(QLabel(tr("dlg_trigger_desc")))
        grid = QGridLayout()

        # Cílový výstup
        grid.addWidget(QLabel(tr("lbl_trigger_target")), 0, 0)
        self.cmb_trigger_target = QComboBox()
        self.cmb_trigger_target.addItems(["OUT1", "OUT2"])
        # Přednastavíme na druhý výstup než je zdrojový
        if hasattr(self, '_source_channel'):
            self.cmb_trigger_target.setCurrentIndex(
                1 if self._source_channel == 0 else 0)
        grid.addWidget(self.cmb_trigger_target, 0, 1)

        # Akce
        grid.addWidget(QLabel(tr("lbl_trigger_action")), 1, 0)
        self.cmb_trigger_action = QComboBox()
        self.cmb_trigger_action.addItems(["START", "STOP"])
        self.cmb_trigger_action.currentIndexChanged.connect(
            self._on_trigger_action_changed)
        grid.addWidget(self.cmb_trigger_action, 1, 1)

        # Číslo řádku (pouze pro START)
        self.lbl_trigger_line = QLabel(tr("lbl_trigger_line"))
        grid.addWidget(self.lbl_trigger_line, 2, 0)
        self.spin_trigger_line = QSpinBox()
        self.spin_trigger_line.setRange(1, 9999)
        self.spin_trigger_line.setValue(1)
        self.spin_trigger_line.setToolTip(tr("spin_trigger_line_tip"))
        grid.addWidget(self.spin_trigger_line, 2, 1)

        # Režim čekání (pouze pro START)
        self.lbl_trigger_mode = QLabel(tr("lbl_trigger_mode"))
        grid.addWidget(self.lbl_trigger_mode, 3, 0)
        self.cmb_trigger_mode = QComboBox()
        self.cmb_trigger_mode.addItems(["PARALLEL", "WAIT"])
        self.cmb_trigger_mode.setToolTip(tr("cmb_trigger_mode_tip"))
        grid.addWidget(self.cmb_trigger_mode, 3, 1)

        # Chování při STOP
        self.lbl_trigger_stop = QLabel(tr("lbl_trigger_stop"))
        grid.addWidget(self.lbl_trigger_stop, 4, 0)
        self.cmb_trigger_stop = QComboBox()
        self.cmb_trigger_stop.addItems(["ZERO", "KEEP"])
        self.cmb_trigger_stop.setToolTip(tr("cmb_trigger_stop_tip"))
        grid.addWidget(self.cmb_trigger_stop, 4, 1)

        # Varování
        self.lbl_trigger_warning = QLabel("")
        self.lbl_trigger_warning.setStyleSheet(
            "color: #e85c5c; font-weight: bold;")
        self.lbl_trigger_warning.setWordWrap(True)
        grid.addWidget(self.lbl_trigger_warning, 5, 0, 1, 2)

        layout.addLayout(grid)
        self._on_trigger_action_changed(0)   # inicializuj zobrazení

        self.cmb_trigger_target.currentIndexChanged.connect(
            self._validate_trigger)
        self.cmb_trigger_action.currentIndexChanged.connect(
            self._validate_trigger)
        self.cmb_trigger_mode.currentIndexChanged.connect(
            self._validate_trigger)
        self._validate_trigger()

    def _on_trigger_action_changed(self, idx: int):
        """Zobrazí/skryje relevantní pole podle zvolené akce."""
        is_start = self.cmb_trigger_action.currentText() == "START"
        self.lbl_trigger_line.setVisible(is_start)
        self.spin_trigger_line.setVisible(is_start)
        self.lbl_trigger_mode.setVisible(is_start)
        self.cmb_trigger_mode.setVisible(is_start)
        self.lbl_trigger_stop.setVisible(not is_start)
        self.cmb_trigger_stop.setVisible(not is_start)
        self.lbl_trigger_warning.setText("")
        self.adjustSize()

    def _validate_trigger(self):
        """Validuje parametry příkazu TRIGGER.
        Kontroluje zda cílový výstup má program a zda neobsahuje REPEAT 0 při WAIT."""
        target     = self.cmb_trigger_target.currentText()
        target_ch  = 0 if target == "OUT1" else 1
        action     = self.cmb_trigger_action.currentText()
        mode       = self.cmb_trigger_mode.currentText() if action == "START" else ""
        program    = self._trigger_programs.get(target_ch, [])

        # Zkontroluj zda cílový výstup má program
        if not program:
            self.lbl_trigger_warning.setText(tr("trigger_warn_no_program", target=target))
            self.findChild(QPushButton, "").setEnabled(False) \
                if self.findChild(QPushButton) else None
            self.adjustSize()
            return

        # Zkontroluj REPEAT 0 při WAIT režimu
        if action == "START" and mode == "WAIT":
            has_infinite_repeat = any(
                ln.upper().startswith("REPEAT") and
                ln.split()[1] == "0"
                for ln in program
                if len(ln.split()) > 1
            )
            if has_infinite_repeat:
                self.lbl_trigger_warning.setText(
                    tr("trigger_warn_infinite", target=target))
                self.adjustSize()
                return

        # Validace čísla řádku
        if action == "START":
            max_line = len(program)
            self.spin_trigger_line.setMaximum(max_line)
            if self.spin_trigger_line.value() > max_line:
                self.spin_trigger_line.setValue(max_line)

        self.lbl_trigger_warning.setText("")
        self.adjustSize()

    def get_command_line(self) -> str:
        """Sestaví textový řádek příkazu z hodnot zadaných v dialogu.
        Tento řádek se vloží do editoru programu."""
        if self.cmd == "SET":
            rng  = self.cmb_range.currentText()
            idx  = self.cmb_set_unit.currentIndex()
            val  = self.spin_set_val.value()
            unit = ["%", "RAW", OUTPUT_RANGES[rng][2]][idx]
            return f"SET {val} {unit} {rng}"
        elif self.cmd == "WAIT":
            return f"WAIT {self.spin_wait.value()} s"
        elif self.cmd == "RAMP":
            rng  = self.cmb_ramp_range.currentText()
            idx  = self.cmb_ramp_unit.currentIndex()
            unit = ["%", "RAW", OUTPUT_RANGES[rng][2]][idx]
            return (f"RAMP {self.spin_ramp_from.value()} {unit} "
                    f"{self.spin_ramp_to.value()} {unit} "
                    f"{self.spin_ramp_step.value()} {unit} "
                    f"{self.spin_ramp_ms.value()}ms {rng}")
        elif self.cmd == "JUMP":
            return f"JUMP {self.spin_jump.value()} {self.spin_jump_repeat.value()} x"
        elif self.cmd == "REPEAT":
            return f"REPEAT {self.spin_repeat.value()} x"
        elif self.cmd == "TRIGGER":
            target = self.cmb_trigger_target.currentText()
            action = self.cmb_trigger_action.currentText()
            if action == "START":
                line = self.spin_trigger_line.value()
                mode = self.cmb_trigger_mode.currentText()
                return f"TRIGGER {target} START {line} {mode}"
            else:
                stop = self.cmb_trigger_stop.currentText()
                return f"TRIGGER {target} STOP {stop}"
        return self.cmd
    
# Množina platných příkazů programového enginu
# Řádky které nezačínají tímto příkazem jsou považovány za komentáře
VALID_COMMANDS = {"SET", "WAIT", "RAMP", "JUMP", "REPEAT", "TRIGGER"}
class ProgramRunner(QObject):
 # Nejdřív projdeme příkazy a najdeme REPEAT pokud existuje(QObject):
    """Engine který čte a vykonává příkazy z programového editoru.
    Běží ve vedlejším vlákně — nekomunikuje přímo s GUI ani se zařízením,
    místo toho vysílá signály které hlavní vlákno zpracuje.

    Signály:
        command_write  — požadavek na zápis RAW hodnoty na výstup (channel, raw)
        log_message    — zpráva do logu
        finished       — program skončil (channel, důvod)
        error          — chyba v programu (channel, řádek, popis)
    """
    command_write = pyqtSignal(int, int, bool)   # channel, raw, from_program
    log_message   = pyqtSignal(str)
    finished      = pyqtSignal(int, str)       # channel, důvod ukončení
    error         = pyqtSignal(int, int, str)  # channel, řádek, popis chyby
    line_changed  = pyqtSignal(int, int)   # channel, číslo aktivního řádku (od 1)
    trigger_request = pyqtSignal(int, int, str, int, str)    # (source_channel, target_channel, action, line, mode)

    def __init__(self, channel: int, lines: list[str], parent=None):
        super().__init__(parent)
        self.channel  = channel
        self.lines    = lines    # seznam aktivních řádků příkazů (bez komentářů)
        self._stop    = False    # příznak pro zastavení zvenčí
        self.current_raw = 0   # aktuální RAW hodnota — čte ji graf
        self.current_range: str | None = None   # aktuální rozsah — nastaví se při SET/RAMP
        self._waiting_for_trigger = False   # příznak čekání na TRIGGER WAIT
        self._trigger_infinite    = False   # příznak nekonečného opakování cíle

    def stop(self):
        """Požádá engine aby se co nejdříve zastavil."""
        self._stop = True

    def run(self):
        """Hlavní smyčka enginu — zachytí všechny neočekávané výjimky."""
        try:
            self._run_internal()
        except Exception as e:
            self.error.emit(self.channel, 0,
                           f"Neočekávaná chyba enginu: {e}")
            self.finished.emit(self.channel, f"Program ukončen chybou: {e}")

    def _run_internal(self):
        """Skutečná implementace hlavní smyčky enginu."""
        pc = 0     # program counter = index aktuálního řádku
        jump_counters: dict[int, int] = {}
        repeat_total   = 1
        repeat_current = 0   # počítadlo dokončených průchodů
        last_line = self.lines[-1].split()[0].upper() if self.lines else ""
        if last_line == "REPEAT":
            try:
                repeat_total = int(self.lines[-1].split()[1])
            except (IndexError, ValueError):
                repeat_total = 0   # chybný parametr = nekonečně

        self.log_message.emit(
            f"▶ OUT{self.channel+1}: spouštím program "
            f"({'∞' if repeat_total == 0 else repeat_total}× opakování), "
            f"{len(self.lines)} příkazů"
        )

        while not self._stop:
            if pc >= len(self.lines):
                # Dosáhli jsme konce bez REPEAT — program proběhl jednou
                self.finished.emit(self.channel, "Program dokončen")
                return

            # Informuj GUI o aktuálně vykonávaném řádku
            self.line_changed.emit(self.channel, pc + 1)

            line  = self.lines[pc]
            parts = line.split()
            cmd   = parts[0].upper() if parts else ""

            if cmd == "SET":
                raw = self._parse_set(parts, pc)
                if raw is None:
                    return   # chyba — engine se zastavil
                self.current_raw = raw
                self.command_write.emit(self.channel, raw, True)
                pc += 1

            elif cmd == "WAIT":
                try:
                    seconds = float(parts[1])
                except (IndexError, ValueError):
                    self.error.emit(self.channel, pc+1,
                                   f"WAIT: neplatný čas '{line}'")
                    return
                # Čekáme po malých kouscích aby šlo program zastavit
                # time.sleep() nelze přerušit zvenčí — proto dělíme na 50ms kousky
                import time
                elapsed = 0.0
                while elapsed < seconds and not self._stop:
                    time.sleep(0.05)
                    elapsed += 0.05
                pc += 1

            elif cmd == "RAMP":
                if not self._execute_ramp(parts, pc):
                    return   # chyba
                pc += 1

            elif cmd == "JUMP":
                try:
                    target      = int(parts[1]) - 1   # cílový řádek (od 0)
                    jump_limit  = int(parts[2]) if len(parts) > 2 else 0
                    # jump_counters[pc] = kolik skoků z tohoto JUMP již proběhlo
                    jump_counters.setdefault(pc, 0)

                    if jump_limit == 0 or jump_counters[pc] < jump_limit:
                        # Ještě nebylo dosaženo limitu — skoč
                        if target < 0 or target >= len(self.lines):
                            raise ValueError("cíl mimo rozsah")
                        jump_counters[pc] += 1
                        pc = target
                        # Počkej jeden cyklus aby se nový řádek načetl před znovu-nastavením
                        continue
                    else:
                        # Limit dosažen — resetuj čítač a pokračuj za JUMP
                        jump_counters[pc] = 0
                        pc += 1

                except (IndexError, ValueError) as e:
                    self.error.emit(self.channel, pc+1,
                                   f"JUMP: neplatný příkaz '{line}' — {e}")
                    return

            elif cmd == "REPEAT":
                # REPEAT = konec průchodu programem — zkontroluj počet opakování
                repeat_current += 1
                if repeat_total != 0 and repeat_current >= repeat_total:
                    self.finished.emit(self.channel, "Program dokončen")
                    return
                # Další průchod — resetuj pc a jump čítače
                jump_counters.clear()
                pc = 0
                continue
                
            elif cmd == "TRIGGER":
                if not self._execute_trigger(parts, pc):
                    return
                pc += 1

            else:
                self.error.emit(self.channel, pc+1,
                               f"Neznámý příkaz: '{cmd}'")
                return

        self.finished.emit(self.channel, "Zastaveno uživatelem")

    def _parse_set(self, parts: list[str], pc: int) -> int | None:
        """Zparsuje příkaz SET a vrátí RAW hodnotu nebo None při chybě.
        Formát: SET [hodnota] [jednotka] [rozsah]
        Příklad: SET 50.0 % 4-20mA"""
        try:
            val  = float(parts[1])
            unit = parts[2]    # %, RAW, nebo fyzikální jednotka (V/mA)
            rng  = " ".join(parts[3:])   # rozsah může obsahovat mezeru (např. "0-10 V")
            self.current_range = rng
            if unit == "%":
                return percent_to_raw(val)
            elif unit == "RAW":
                return max(0, min(RAW_MAX, int(val)))
            else:
                self.current_range = rng
                return phys_to_raw(val, rng)
        except (IndexError, ValueError) as e:
            self.error.emit(self.channel, pc+1,
                           f"SET: chybný formát příkazu — {e}")
            return None

    def _execute_ramp(self, parts: list[str], pc: int) -> bool:
        """Vykoná příkaz RAMP — plynulý přechod.
        Formát: RAMP [od] [do] [krok] [ms] [jednotka] [rozsah]
        Vrátí True při úspěchu, False při chybě."""
        import time
        try:
            # Formát: RAMP [od] [j] [do] [j] [krok] [j] [ms] [rozsah...]
            val_from = float(parts[1])
            unit     = parts[2]
            val_to   = float(parts[3])
            val_step = float(parts[5])
            ms       = int(parts[7].replace("ms", ""))
            rng      = " ".join(parts[8:])
            self.current_range = rng

            # Převeď hodnoty na RAW
            if unit == "%":
                raw_from = percent_to_raw(val_from)
                raw_to   = percent_to_raw(val_to)
                raw_step = percent_to_raw(val_step)
            elif unit == "RAW":
                raw_from = int(val_from)
                raw_to   = int(val_to)
                raw_step = int(val_step)
            else:
                raw_from = phys_to_raw(val_from, rng)
                raw_to   = phys_to_raw(val_to,   rng)
                raw_step = phys_to_raw_delta(val_step, rng)

            raw_step = max(1, raw_step)   # krok musí být alespoň 1
            direction = 1 if raw_to >= raw_from else -1
            current   = raw_from

            self.log_message.emit(
                f"  RAMP OUT{self.channel+1}: "
                f"{val_from}→{val_to} {unit}, krok {val_step}, {ms} ms/krok"
            )

            while not self._stop:
                self.current_raw = max(0, min(RAW_MAX, current))
                self.command_write.emit(self.channel, self.current_raw, True)
                if (direction > 0 and current >= raw_to) or \
                   (direction < 0 and current <= raw_to):
                    break
                current += direction * raw_step
                time.sleep(ms / 1000.0)

            # Nastav přesně cílovou hodnotu
            self.current_raw = max(0, min(RAW_MAX, raw_to))
            self.command_write.emit(self.channel, self.current_raw, True)
            self.current_range = rng
            return True

        except (IndexError, ValueError) as e:
            self.error.emit(self.channel, pc+1,
                           f"RAMP: chybný formát příkazu — {e}")
            return False
        
    def _execute_trigger(self, parts: list[str], pc: int) -> bool:
        """Vykoná příkaz TRIGGER — spustí nebo zastaví program druhého výstupu.
        Formát START: TRIGGER OUT1/OUT2 START [řádek] PARALLEL/WAIT
        Formát STOP:  TRIGGER OUT1/OUT2 STOP ZERO/KEEP"""
        import time
        try:
            target  = parts[1].upper()   # OUT1 nebo OUT2
            action  = parts[2].upper()   # START nebo STOP
            target_ch = 0 if target == "OUT1" else 1

            if action == "START":
                line = int(parts[3])
                mode = parts[4].upper()   # PARALLEL nebo WAIT
                self.log_message.emit(
                    f"  TRIGGER: {target} START od řádku {line} ({mode})")
                self.trigger_request.emit(
                    self.channel, target_ch, "START", line, mode)
                if mode == "WAIT":
                    # Čekej dokud cílový program neskončí
                    # _trigger_done se nastaví zvenčí když cílový program skončí
                    self._waiting_for_trigger = True
                    while self._waiting_for_trigger and not self._stop:
                        time.sleep(0.1)
                    # Zkontroluj zda se nezastavil kvůli REPEAT 0
                    if getattr(self, '_trigger_infinite', False):
                        self.log_message.emit(
                            f"⚠ TRIGGER WAIT: {target} má nekonečné opakování "
                            f"— oba programy se zastaví")
                        self.finished.emit(self.channel,
                            f"Zastaveno: {target} má nekonečné opakování (REPEAT 0)")
                        return False
            elif action == "STOP":
                stop_mode = parts[3].upper()   # ZERO nebo KEEP
                self.log_message.emit(f"  TRIGGER: {target} STOP ({stop_mode})")
                self.trigger_request.emit(
                    self.channel, target_ch, f"STOP_{stop_mode}", 0, "")
            return True
        except (IndexError, ValueError) as e:
            self.error.emit(self.channel, pc+1,
                           f"TRIGGER: chybný formát příkazu — {e}")
            return False

class OutputGraph(QWidget):
    """Widget zobrazující časový průběh výstupní hodnoty v reálném čase."""

    MAX_SAMPLES = 36000

    def __init__(self, channel: int, parent=None):
        super().__init__(parent)
        self.channel     = channel
        self._times      = []
        self._values     = []
        self._unit       = "mA"
        self._paused     = False
        self._start_time = None
        self._view_range = 30
        self._lo         = 0.0
        self._hi         = 1.0
        self._recording  = False   # příznak: záznam probíhá
        self.save_dir = ""   # výchozí složka pro ukládání — nastavuje hlavní okno
        self._scrolling  = False   # příznak: graf se posouvá v reálném čase
        self._build_ui()

    def _build_ui(self):
        """Sestaví UI grafu."""
        layout = QVBoxLayout(self)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(2)

        # Horní řádek: ovládání grafu
        ctrl_row = QHBoxLayout()

        self._lbl_time = QLabel(tr("graph_lbl_time"))
        tr_mgr.register(self._lbl_time, "setText", "graph_lbl_time")
        ctrl_row.addWidget(self._lbl_time)
        self.spin_range = QSpinBox()
        self.spin_range.setRange(5, 3600)
        self.spin_range.setValue(30)
        self.spin_range.setSuffix(" s")
        self.spin_range.setMaximumWidth(80)
        self.spin_range.setToolTip(tr("graph_spin_tip"))
        tr_mgr.register(self.spin_range, "setToolTip", "graph_spin_tip")
        self.spin_range.valueChanged.connect(self._on_range_changed)
        ctrl_row.addWidget(self.spin_range)

        ctrl_row.addSpacing(10)

        self.btn_clear_graph = QPushButton(tr("btn_clear_graph"))
        self.btn_clear_graph.setToolTip(tr("btn_clear_graph_tip"))
        tr_mgr.register(self.btn_clear_graph, "setText", "btn_clear_graph")
        tr_mgr.register(self.btn_clear_graph, "setToolTip", "btn_clear_graph_tip")
        self.btn_clear_graph.clicked.connect(self._clear)
        ctrl_row.addWidget(self.btn_clear_graph)

        self.btn_save_graph = QPushButton(tr("btn_save_graph"))
        self.btn_save_graph.setToolTip(tr("btn_save_graph_tip"))
        tr_mgr.register(self.btn_save_graph, "setText", "btn_save_graph")
        tr_mgr.register(self.btn_save_graph, "setToolTip", "btn_save_graph_tip")
        self.btn_save_graph.clicked.connect(self._save)
        ctrl_row.addWidget(self.btn_save_graph)

        ctrl_row.addStretch()

        self.lbl_current = QLabel("— ")
        self.lbl_current.setStyleSheet("font-weight: bold; color: #4caf50; font-size: 14pt;")
        ctrl_row.addWidget(self.lbl_current)

        layout.addLayout(ctrl_row)

        # Graf
        self.plot_widget = pg.PlotWidget()
        self.plot_widget.setBackground("#1e1e1e")
        self.plot_widget.showGrid(x=True, y=True, alpha=0.3)
        self.plot_widget.setLabel("left", tr("graph_axis_value"), units=self._unit)
        self.plot_widget.setLabel("bottom", tr("graph_axis_time"), units="s")
        self.plot_widget.setMinimumHeight(120)
        self.plot_widget.setMaximumHeight(270)   #  Nastavení výšky grafu
        # Automatické škálování Y — nezávisle pro každý graf
        self.plot_widget.enableAutoRange(axis='y', enable=True)
        self.plot_widget.enableAutoRange(axis='x', enable=False)

        pen = pg.mkPen(color="#4caf50", width=2)
        self.curve = self.plot_widget.plot([], [], pen=pen)
        layout.addWidget(self.plot_widget)

        # Posuvník
        self.scrollbar = QScrollBar(Qt.Orientation.Horizontal)
        self.scrollbar.setStyleSheet(
            "QScrollBar:horizontal { height: 12px; background: #2a2a2e; }"
            "QScrollBar::handle:horizontal { background: #494d47; border-radius: 4px; min-width: 20px; }"  # Barva vodorovného posuvníku grafů
            "QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal { width: 0px; }"
        )
        self.scrollbar.setMinimum(0)
        self.scrollbar.setMaximum(0)
        self.scrollbar.valueChanged.connect(self._on_scroll)
        self.scrollbar.setToolTip(tr("graph_scroll_tip"))
        tr_mgr.register(self.scrollbar, "setToolTip", "graph_scroll_tip")
        layout.addWidget(self.scrollbar)

    def start_recording(self):
        """Spustí nový záznam — vymaže předchozí historii."""
        self._times      = []
        self._values     = []
        self._start_time = None
        self._recording  = True
        self._scrolling  = True
        self.curve.setData([], [])
        self.scrollbar.setMaximum(0)
        self.lbl_current.setText("— ")

    def stop_recording(self):
        """Zastaví záznam i posouvání grafu."""
        self._recording = False
        self._scrolling = False

    def set_y_range(self, lo: float, hi: float, unit: str):
        """Nastaví rozsah svislé osy Y podle rozsahu výstupu.
        Volá se při spuštění programu podle prvního příkazu SET."""
        self._lo   = lo
        self._hi   = hi
        self._unit = unit
        self._range_name = None   # resetuj název rozsahu — použijeme lo/hi přímo
        self.plot_widget.setLabel("left", "Hodnota", units=unit)
        self.plot_widget.setYRange(lo, hi, padding=0.1)
        self.plot_widget.enableAutoRange(axis='y', enable=False)

    def add_sample(self, raw: int, range_name: str, t: float = None):
        """Přidá nový vzorek do historie průběhu."""
        if not self._recording:
            return
        import time
        if self._start_time is None:
            self._start_time = time.monotonic()
        if t is None:
            t = time.monotonic() - self._start_time
        lo, hi, unit = OUTPUT_RANGES[range_name]
        val = lo + (hi - lo) * raw / RAW_MAX
        # Pokud byl nastaven pevný rozsah přes set_y_range, použij ho pro jednotku
        if hasattr(self, '_lo') and hasattr(self, '_hi') and self._unit:
            unit = self._unit
            lo   = self._lo
            hi   = self._hi
            val  = lo + (hi - lo) * raw / RAW_MAX

        self._times.append(t)
        self._values.append(val)

        if unit != self._unit and not hasattr(self, '_range_name'):
            self._unit = unit
            self.plot_widget.setLabel("left", "Hodnota", units=unit)

        if len(self._times) > self.MAX_SAMPLES:
            self._times  = self._times[-self.MAX_SAMPLES:]
            self._values = self._values[-self.MAX_SAMPLES:]

        self._update_scrollbar()
        self.lbl_current.setText(f"{val:.3f} {unit}")
        self._redraw()

    def _redraw(self):
        """Překreslí graf podle aktuální pozice posuvníku."""
        if not self._times:
            return

        t_max  = self._times[-1]
        t_end  = t_max
        sb_max = self.scrollbar.maximum()

        if sb_max > 0 and self.scrollbar.value() < sb_max:
            ratio = self.scrollbar.value() / sb_max
            t_end = self._times[0] + ratio * (t_max - self._times[0])

        t_start = max(-1.0, t_end - self._view_range)

        times_view  = []
        values_view = []
        for t, v in zip(self._times, self._values):
            if t_start <= t <= t_end:
                times_view.append(t)
                values_view.append(v)

        self.curve.setData(times_view, values_view)
        self.plot_widget.setXRange(t_start, t_end, padding=0.02)

    def _update_scrollbar(self):
        """Aktualizuje rozsah posuvníku podle délky historie."""
        if not self._times:
            return
        total = self._times[-1] - self._times[0]
        if total > self._view_range:
            was_at_end = self.scrollbar.maximum() == 0 or \
                         self.scrollbar.value() >= self.scrollbar.maximum() - 10
            self.scrollbar.setMaximum(1000)
            if not self._paused and was_at_end:
                # Byl na konci — drž ho na konci
                self.scrollbar.setValue(1000)
        else:
            self.scrollbar.setMaximum(0)

    def _on_scroll(self, value: int):
        self._redraw()
    
    def _on_range_changed(self, value: int):
        self._view_range = value
        self._redraw()

    def _clear(self):
        self._times      = []
        self._values     = []
        self._start_time = None
        self.curve.setData([], [])
        self.scrollbar.setMaximum(0)
        self.lbl_current.setText("— ")

    def _save(self):
        """Uloží historii průběhu do CSV souboru."""
        from PyQt6.QtWidgets import QFileDialog
        if not self._times:
            return
        import os
        default = os.path.join(self.save_dir, f"pruběh_out{self.channel+1}.csv")
        path, _ = QFileDialog.getSaveFileName(
            self, tr("graph_save_title").format(n=self.channel+1),
            default,
            tr("graph_save_filter")
        )
        if not path:
            return
        try:
            with open(path, "w", encoding="utf-8") as f:
                f.write(tr("graph_save_header").format(unit=self._unit) + "\n")
                for t, v in zip(self._times, self._values):
                    f.write(f"{t:.3f};{v:.3f}\n")
        except Exception as e:
            print(f"Chyba při ukládání grafu: {e}")

class ProgramEditor(QWidget):
    """Widget jednoho programového okna — editor příkazů pro jeden výstup.
    Obsahuje textové okno s příkazy, zaškrtávací políčka a tlačítka pro
    povolení zápisu a aktivaci výstupu."""

    def __init__(self, channel: int, parent=None):
        super().__init__(parent)
        # channel = 0 pro OUT1, 1 pro OUT2
        self.channel = channel
        label = f"OUT{channel + 1}"
        self._build_ui(label)
        self._update_active_checkbox()   # výchozí stav — políčko zakázáno
        self._active_line = 0   # aktuálně vykonávaný řádek (0 = žádný)
        self._prog_finished = False   # příznak: program skončil — zobrazí červenou tečku
        self._last_ramp_to: float | None = None      # poslední hodnota "Do:" z RAMP
        self._last_ramp_range: str | None = None     # poslední rozsah z RAMP
        self._last_ramp_unit_idx: int | None = None  # poslední index jednotky z RAMP

    def _build_ui(self, label: str):
        """Sestaví UI jednoho programového editoru."""
        layout = QVBoxLayout(self)
        layout.setContentsMargins(4, 4, 4, 4)
        layout.setSpacing(4)

        # Horní řádek: název výstupu + zaškrtávací políčko pro povolení zápisu
        top_row = QHBoxLayout()
        lbl_name = QLabel(f"<b>{label}</b>")
        top_row.addWidget(lbl_name)
        top_row.addStretch()
        # chk_write = zaškrtávací políčko (QCheckBox) — povoluje vkládání příkazů do tohoto okna
        self.chk_write = QCheckBox(tr("chk_write"))
        self.chk_write.setToolTip(tr("chk_write_tip", label=label))
        tr_mgr.register(self.chk_write, "setText", "chk_write")

        top_row.addWidget(self.chk_write)
        layout.addLayout(top_row)

        # Textové okno pro příkazy — QPlainTextEdit je editor prostého textu
        # (na rozdíl od QTextEdit který podporuje formátování — zde ho nepotřebujeme)
        self.editor = LineNumberPlainTextEdit(program_editor=self)
        self.editor.setMinimumHeight(120)
        self.editor.setMaximumHeight(200)
        self.editor.setFont(QFont("Courier New", 10))
        self.editor.textChanged.connect(self._update_active_checkbox)
        self.editor.setPlaceholderText(tr("editor_placeholder", label=label))

        self.editor.setToolTip(tr("editor_tip"))
        tr_mgr.register(self.editor, "setToolTip", "editor_tip")
        layout.addWidget(self.editor)

        # Spodní řádek: pouze indikátor stavu běhu
        bot_row = QHBoxLayout()
        self.chk_active = QCheckBox(tr("chk_active", label=label))
        self.chk_active.setToolTip(tr("chk_active_tip", label=label))

        bot_row.addWidget(self.chk_active)
        bot_row.addStretch()
        self.lbl_status = QLabel(tr("lbl_status_stopped"))
        tr_mgr.register(self.lbl_status, "setText", "lbl_status_stopped")
        self.lbl_status.setStyleSheet("color: gray; font-weight: bold;")
        bot_row.addWidget(self.lbl_status)
        layout.addLayout(bot_row)

        # Tlačítko Vymazat vše — přidá se do řádku tlačítek v _build_program_tab
        self.btn_clear = QPushButton(tr("btn_clear_prog"))
        self.btn_clear.setToolTip(tr("btn_clear_prog_tip", label=label))
        tr_mgr.register(self.btn_clear, "setText", "btn_clear_prog")
        self.btn_clear.clicked.connect(self._safe_clear)

    def set_running(self, running: bool):
        """Vizuálně zobrazí zda program právě běží nebo je zastaven.
        Zároveň zamkne/odemkne editor — za běhu nelze editovat."""
        self.editor.setReadOnly(running)
        if running:
            self.lbl_status.setText(tr("lbl_status_running"))
            self.lbl_status.setStyleSheet("color: #4caf50; font-weight: bold;")
        else:
            self.lbl_status.setText(tr("lbl_status_stopped"))
            self.lbl_status.setStyleSheet("color: gray; font-weight: bold;")

    def _safe_clear(self):
        """Smaže program pouze pokud neběží — za běhu ignoruje."""
        if self.editor.isReadOnly():
            return
        self.editor.clear()

    def highlight_line(self, active_line: int, finished: bool = False):
        """Zvýrazní aktuálně vykonávaný řádek barevným pozadím.
        Zelená = běží, červená = zastaveno/dokončeno."""
        self._active_line   = active_line
        self._prog_finished = finished
        self.editor._finished_flag = finished

        # Projdi bloky editoru a najdi aktivní řádek
        color = QColor("#3a5c3a") if not finished else QColor("#5c3a3a")
        selections = []
        doc    = self.editor.document()
        n      = 0   # čítač aktivních řádků
        for i in range(doc.blockCount()):
            block = doc.findBlockByNumber(i)
            text  = block.text().strip()
            first = text.split()[0].upper() if text else ""
            if text and not text.startswith("#") and first in VALID_COMMANDS:
                n += 1
                if n == active_line and active_line > 0:
                    # Tento blok je aktivní — zvýrazni ho
                    sel = QTextEdit.ExtraSelection()
                    sel.format.setBackground(color)
                    sel.format.setProperty(
                        QTextFormat.Property.FullWidthSelection, True)
                    cursor = self.editor.textCursor()
                    cursor.setPosition(block.position())
                    sel.cursor = cursor
                    selections.append(sel)
                    break

        self.editor.setExtraSelections(selections)

    def insert_command(self, cmd: str):
        """Vloží příkaz na nový řádek v editoru.
        Za příkaz REPEAT nelze vložit další příkaz — REPEAT musí být posledním příkazem."""
        if not self.chk_write.isChecked():
            return
        text  = self.editor.toPlainText()
        lines = text.splitlines()

        # Najdi pozici REPEAT pokud existuje
        repeat_block_idx = None
        doc = self.editor.document()
        for i in range(doc.blockCount()):
            if doc.findBlockByNumber(i).text().strip().upper().startswith("REPEAT"):
                repeat_block_idx = i
                break

        cursor = self.editor.textCursor()
        current_block_idx = cursor.blockNumber()

        # Pokud vkládáme REPEAT — vždy na konec
        if cmd.strip().upper().startswith("REPEAT"):
            cursor.movePosition(cursor.MoveOperation.End)
            cursor.insertText("\n" + cmd)
            self.editor.setTextCursor(cursor)
            return

        # Pokud program obsahuje REPEAT a kurzor je na něm nebo za ním — vlož před REPEAT
        if repeat_block_idx is not None and current_block_idx >= repeat_block_idx:
            block = doc.findBlockByNumber(repeat_block_idx)
            cursor.setPosition(block.position())
            cursor.insertText(cmd + "\n")
            self.editor.setTextCursor(cursor)
            return

        # Jinak vlož za aktuální řádek kurzoru
        cursor.movePosition(cursor.MoveOperation.EndOfLine)
        current_line = doc.findBlockByNumber(current_block_idx).text().strip()
        if current_line:
            cursor.insertText("\n" + cmd)
        else:
            cursor.insertText(cmd)
        cursor.movePosition(cursor.MoveOperation.EndOfLine)
        self.editor.setTextCursor(cursor)

    def _update_active_checkbox(self):
        """Povolí zaškrtnutí políčka Aktivní pouze pokud editor obsahuje
        alespoň jeden platný příkaz."""
        has_commands = len(self.get_program()) > 0
        self.chk_active.setEnabled(has_commands)
        if not has_commands:
            self.chk_active.setChecked(False)
            self.chk_active.setToolTip(tr("chk_active_tip_empty"))
        else:
            self.chk_active.setToolTip(tr("chk_active_tip_ready"))

    def get_program(self) -> list[str]:
        """Vrátí seznam řádků programu — prázdné řádky, komentáře
        a řádky s neplatným příkazem jsou vynechány."""
        lines = self.editor.toPlainText().splitlines()
        result = []
        for ln in lines:
            ln = ln.strip()
            if not ln or ln.startswith("#"):
                continue   # prázdný řádek nebo komentář
            first = ln.split()[0].upper()
            if first in VALID_COMMANDS:
                result.append(ln)
            # else: neplatný příkaz — tiše přeskočíme jako poznámku
        return result

class DA2ETHController(QMainWindow):
    """Hlavní okno aplikace DA2ETH Controller."""

    def __init__(self):
        super().__init__()
        self.setWindowTitle(tr("app_title"))
        tr_mgr.register(self, "setWindowTitle", "app_title")
        self.setMinimumSize(950, 720)

        # QSettings ukládá nastavení mezi spuštěními
        self.settings = QSettings("Papouch", "DA2ETH")
        self.log_save_dir = self.settings.value("log_save_dir", os.path.expanduser("~"))

        # Spinel worker — komunikuje se zařízením přes TCP socket v separátním vlákně.
        # Nevyžaduje žádnou externí knihovnu — používá standardní Python socket.
        self.worker = SpinelWorker()
        self.worker.connected.connect(self._on_connected)
        self.worker.write_done.connect(self._on_write_done)
        self.worker.range_done.connect(self._on_range_done)
        self.worker.read_done.connect(self._on_read_done)

        # Throttle: pending_writes drží poslední hodnotu pro každý kanál.
        # Flush timer je odešle každých 100 ms — zabraňuje zahlcení Modbus sběrnice.
        self._pending_writes = {}
        self._write_timer = QTimer()
        self._write_timer.setInterval(100)
        self._write_timer.timeout.connect(self._flush_writes)
        self._write_timer.start()

        # Vzorkovací frekvence logu — minimální interval mezi záznamy v ms.
        # 0 = loguj každou změnu (bez omezení).
        self._log_rate_ms = int(self.settings.value("log_rate_ms", 0))
        self._last_log_time: dict[int, float] = {}   # kanál → čas posledního logu

        # Interval hlídání stavu výstupů v sekundách (0 = vypnuto)
        self._monitor_interval = int(self.settings.value("monitor_interval", 5))
        # Timer pro periodické čtení hodnot ze zařízení
        self._monitor_timer = QTimer()
        self._monitor_timer.timeout.connect(self._monitor_outputs)
        # Příznak: True = odpojení bylo ruční (tlačítkem), False = neočekávané
        self._manual_disconnect = False
        self._ever_connected = False   # True až po prvním ručním připojení
        # Časovač pro automatické opakování připojení po neočekávaném odpojení
        self._reconnect_timer = QTimer()
        self._reconnect_timer.setSingleShot(True)   # spustí se jen jednou, ne opakovaně
        self._reconnect_timer.timeout.connect(self._auto_reconnect)
        # Watchdog timer — hlídá jestli komunikace nezamrzla (busy flag příliš dlouho True)
        self._busy_since: float | None = None   # čas kdy začal aktuální přenos
        self._watchdog_timer = QTimer()
        self._watchdog_timer.setInterval(1000)   # kontrola každou sekundu
        self._watchdog_timer.timeout.connect(self._check_busy_watchdog)
        self._watchdog_timer.start()

        # Nastavení chování po zastavení programu — výchozí: nastavit na minimum
        self._stop_to_zero = {0: True, 1: True}
        self._save_dir = ""   # výchozí složka pro ukládání — prázdná = poslední použitá
        # Načti uložené nastavení při startu programu
        self._settings = QSettings("Papouch", "DA2ETH_Controller")
        self._save_dir = self._settings.value("save_dir", "")
        self._stop_to_zero[0] = self._settings.value(
            "stop_to_zero_0", True, type=bool)
        self._stop_to_zero[1] = self._settings.value(
            "stop_to_zero_1", True, type=bool)
        self._prog_running = {0: False, 1: False}   # příznak běhu programu pro každý kanál
        self._last_ramp_to:       dict[int, float | None] = {0: None, 1: None}
        self._last_ramp_step:     dict[int, float | None] = {0: None, 1: None}
        self._last_ramp_ms:       dict[int, int   | None] = {0: None, 1: None}
        self._last_ramp_range:    dict[int, str   | None] = {0: None, 1: None}
        self._last_ramp_unit_idx: dict[int, int   | None] = {0: None, 1: None}
        self._last_line = {0: 1, 1: 1}   # poslední vykonávaný řádek pro každý kanál
        self._graph_stop_time = {0: None, 1: None}   # čas zastavení programu pro každý kanál
        self._packet_trace = False   # True = vypisuj TX/RX pakety do GUI logu

        # Timer pro vzorkování výstupních hodnot do grafů
        self._graph_timer = QTimer()
        self._graph_timer.setInterval(100)   # vzorkování 10×/s
        self._graph_timer.timeout.connect(self._sample_graphs)
        self._graph_timer.start()

        self._build_menu()
        self._build_ui()
        self._load_settings()

    # ── Menu ───────────────────────────────────────────────────────────────

    def _build_menu(self):
        """Vytvoří horní menu Možnosti."""
        menubar = self.menuBar()
        moznosti = menubar.addMenu(tr("menu_options"))
        tr_mgr.register(moznosti, "setTitle", "menu_options")

        # Menu jazyk
        menu_lang = self.menuBar().addMenu(tr("menu_language"))
        tr_mgr.register(menu_lang, "setTitle", "menu_language")
        for code, name in TranslationManager.LANGUAGES.items():
            act = QAction(name, self)
            act.setCheckable(True)
            act.setChecked(code == "cs")
            act.triggered.connect(lambda checked, c=code: self._switch_language(c))
            menu_lang.addAction(act)
        self._lang_menu = menu_lang

        act_log_dir = QAction(tr("menu_act_log_dir"), self)
        tr_mgr.register(act_log_dir, "setText", "menu_act_log_dir")
        act_log_dir.triggered.connect(self._choose_log_dir)
        moznosti.addAction(act_log_dir)

        act_monitor = QAction(tr("menu_act_monitor"), self)
        act_monitor.setToolTip(tr("menu_act_monitor_tip"))
        tr_mgr.register(act_monitor, "setText", "menu_act_monitor")
        tr_mgr.register(act_monitor, "setToolTip", "menu_act_monitor_tip")
        act_monitor.triggered.connect(self._set_monitor_interval)
        moznosti.addAction(act_monitor)

        # Vzorkovací frekvence logu — jak často se zapisuje do logu při změnách
        act_log_rate = QAction(tr("menu_act_log_rate"), self)
        act_log_rate.setToolTip(tr("menu_act_log_rate_tip"))
        tr_mgr.register(act_log_rate, "setText", "menu_act_log_rate")
        tr_mgr.register(act_log_rate, "setToolTip", "menu_act_log_rate_tip")
        act_log_rate.triggered.connect(self._set_log_rate)
        moznosti.addAction(act_log_rate)

        moznosti.addSeparator()
        act_stop_cfg = QAction(tr("menu_act_stop_cfg"), self)
        act_save_dir = QAction(tr("menu_act_save_dir"), self)
        act_save_dir.setToolTip(tr("menu_act_save_dir_tip"))
        tr_mgr.register(act_stop_cfg, "setText", "menu_act_stop_cfg")
        tr_mgr.register(act_save_dir, "setText", "menu_act_save_dir")
        tr_mgr.register(act_save_dir, "setToolTip", "menu_act_save_dir_tip")
        act_save_dir.triggered.connect(self._set_save_dir)
        moznosti.addAction(act_save_dir)    
        act_stop_cfg.setToolTip(tr("menu_act_stop_cfg_tip"))
        tr_mgr.register(act_stop_cfg, "setToolTip", "menu_act_stop_cfg_tip")
        act_stop_cfg.triggered.connect(self._show_stop_config)
        moznosti.addAction(act_stop_cfg)

        act_about = QAction(tr("menu_act_about"), self)
        act_about.triggered.connect(lambda: QMessageBox.information(
            self, tr("menu_act_about"), tr("menu_about_text")))
        tr_mgr.register(act_about, "setText", "menu_act_about")
        moznosti.addAction(act_about)

    def _switch_language(self, lang: str):
        if not tr_mgr.switch(lang):
            self._log(f"⚠ Jazyk '{lang}' není k dispozici")
            return
        # Aktualizuj text oušek záložek
        for i, key in enumerate(["tab_out1", "tab_out2"]):
            self.tabs.setTabText(i, tr(key))
        self.tabs.setTabText(2, tr("tab_both"))
        self.tabs.setTabText(3, tr("tab_program"))
        for act in self._lang_menu.actions():
            act.setChecked(act.text() == TranslationManager.LANGUAGES.get(lang))
        self._log(f"Jazyk přepnut: {TranslationManager.LANGUAGES.get(lang, lang)}")

    # ── UI ─────────────────────────────────────────────────────────────────

    def _build_ui(self):
        """Sestaví hlavní okno aplikace."""
        central = QWidget()
        self.setCentralWidget(central)
        root = QVBoxLayout(central)
        root.setSpacing(8)
        root.setContentsMargins(10, 10, 10, 10)

        # Panel připojení
        conn_box = QGroupBox(tr("grp_connection"))
        tr_mgr.register(conn_box, "setTitle", "grp_connection")
        conn_lay = QHBoxLayout(conn_box)

        self._lbl_ip = QLabel(tr("lbl_ip"))
        tr_mgr.register(self._lbl_ip, "setText", "lbl_ip")
        conn_lay.addWidget(self._lbl_ip)
        self.edit_ip = QLineEdit("192.168.1.254")
        self.edit_ip.setMaximumWidth(150)
        self.edit_ip.setToolTip(tr("edit_ip_tip"))
        tr_mgr.register(self.edit_ip, "setToolTip", "edit_ip_tip")
        conn_lay.addWidget(self.edit_ip)

        self._lbl_port = QLabel(tr("lbl_port"))
        tr_mgr.register(self._lbl_port, "setText", "lbl_port")
        conn_lay.addWidget(self._lbl_port)
        self.spin_port = QSpinBox()
        self.spin_port.setRange(1, 65535)
        self.spin_port.setValue(10001)   # výchozí Spinel TCP port DA2ETH
        self.spin_port.setMaximumWidth(80)
        self.spin_port.setToolTip(tr("spin_port_tip"))
        tr_mgr.register(self.spin_port, "setToolTip", "spin_port_tip")
        conn_lay.addWidget(self.spin_port)

        self.btn_connect = QPushButton(tr("btn_connect"))
        tr_mgr.register(self.btn_connect, "setText", "btn_connect")
        self.btn_connect.setCheckable(True)
        self.btn_connect.toggled.connect(self._toggle_connect)
        self.btn_connect.setToolTip(tr("btn_connect_tip"))
        tr_mgr.register(self.btn_connect, "setToolTip", "btn_connect_tip")
        conn_lay.addWidget(self.btn_connect)

        self.chk_packet_trace = QCheckBox("Packet trace")
        self.chk_packet_trace.setToolTip(
            "Zobrazuje raw TX/RX pakety v logu — pouze pro debugging")
        self.chk_packet_trace.toggled.connect(
            lambda v: setattr(self, "_packet_trace", v))

        btn_reset = QPushButton(tr("btn_reset"))
        btn_reset.clicked.connect(self._reset_device)
        btn_reset.setToolTip(tr("btn_reset_tip"))
        tr_mgr.register(btn_reset, "setText", "btn_reset")
        tr_mgr.register(btn_reset, "setToolTip", "btn_reset_tip")
        conn_lay.addWidget(btn_reset)

        self.lbl_conn_status = QLabel(tr("lbl_disconnected"))
        self.lbl_conn_status.setStyleSheet("color: red; font-weight: bold;")
        conn_lay.addWidget(self.lbl_conn_status)
        conn_lay.addStretch()

        root.addWidget(conn_box)

        # Záložky kanálů
        self.tabs = QTabWidget()
        tabs = self.tabs
        self.ch_widgets = []
        for i, key in enumerate(["tab_out1", "tab_out2"]):
            label = tr(key)
            ch = ChannelWidget(i, label)
            ch.setTitle("")   # nadpis QGroupBox není potřeba — název je v oušku záložky
            ch.request_write.connect(self._queue_write)
            ch.request_range.connect(self._send_range)
            self.ch_widgets.append(ch)
            tabs.addTab(ch, label)

        # ── Záložka: Oba výstupy ──────────────────────────────────────────
        both_widget = QWidget()
        both_outer = QVBoxLayout(both_widget)
        both_outer.setContentsMargins(10, 10, 10, 10)

        sync_box = QGroupBox(tr("grp_sync"))
        tr_mgr.register(sync_box, "setTitle", "grp_sync")
        sync_lay = QVBoxLayout(sync_box)
        self._lbl_sync_desc = QLabel(tr("lbl_sync_desc"))
        tr_mgr.register(self._lbl_sync_desc, "setText", "lbl_sync_desc")
        sync_lay.addWidget(self._lbl_sync_desc)

        # Výběr rozsahu pro oba výstupy
        range_row = QHBoxLayout()
        self._lbl_both_range = QLabel(tr("lbl_both_range"))
        tr_mgr.register(self._lbl_both_range, "setText", "lbl_both_range")
        range_row.addWidget(self._lbl_both_range)
        self.cmb_both_range = QComboBox()
        self.cmb_both_range.addItems(list(OUTPUT_RANGES.keys()))
        self.cmb_both_range.setToolTip(tr("cmb_both_range_tip"))
        tr_mgr.register(self.cmb_both_range, "setToolTip", "cmb_both_range_tip")
        self.cmb_both_range.currentTextChanged.connect(self._on_both_range_changed)
        range_row.addWidget(self.cmb_both_range)
        range_row.addStretch()
        sync_lay.addLayout(range_row)

        # Výběr jednotky pro záložku Oba výstupy
        unit_row = QHBoxLayout()
        self._lbl_both_unit = QLabel(tr("lbl_both_unit"))
        tr_mgr.register(self._lbl_both_unit, "setText", "lbl_both_unit")
        unit_row.addWidget(self._lbl_both_unit)
        self.cmb_both_unit = QComboBox()
        self.cmb_both_unit.addItems(tr_list("cmb_both_unit_items"))
        self.cmb_both_unit.currentIndexChanged.connect(self._on_both_unit_changed)
        self.cmb_both_unit.setToolTip(tr("cmb_both_unit_tip"))
        tr_mgr.register(self.cmb_both_unit, "setToolTip", "cmb_both_unit_tip")
        unit_row.addWidget(self.cmb_both_unit)
        unit_row.addStretch()
        sync_lay.addLayout(unit_row)

        # Políčko pro zadání hodnoty + tlačítka
        sync_ctrl = QHBoxLayout()
        self._lbl_sync_value = QLabel(tr("lbl_sync_value"))
        tr_mgr.register(self._lbl_sync_value, "setText", "lbl_sync_value")
        sync_ctrl.addWidget(self._lbl_sync_value)
        self.spin_sync = QDoubleSpinBox()
        self.spin_sync.setRange(0, 100)
        self.spin_sync.setDecimals(2)
        self.spin_sync.setToolTip(tr("spin_sync_tip"))
        tr_mgr.register(self.spin_sync, "setToolTip", "spin_sync_tip")
        self.spin_sync.editingFinished.connect(self._sync_both)
        sync_ctrl.addWidget(self.spin_sync)
        self.lbl_sync_unit = QLabel("%")
        sync_ctrl.addWidget(self.lbl_sync_unit)

        btn_sync = QPushButton(tr("btn_sync_both"))
        btn_sync.clicked.connect(self._sync_both)
        btn_sync.setToolTip(tr("btn_sync_both_tip"))
        tr_mgr.register(btn_sync, "setText", "btn_sync_both")
        tr_mgr.register(btn_sync, "setToolTip", "btn_sync_both_tip")
        sync_ctrl.addWidget(btn_sync)

        btn_sync_zero = QPushButton(tr("btn_sync_zero"))
        btn_sync_zero.clicked.connect(lambda: self._sync_both_raw(0))
        btn_sync_zero.setToolTip(tr("btn_sync_zero_tip"))
        tr_mgr.register(btn_sync_zero, "setText", "btn_sync_zero")
        tr_mgr.register(btn_sync_zero, "setToolTip", "btn_sync_zero_tip")
        sync_ctrl.addWidget(btn_sync_zero)

        btn_sync_full = QPushButton(tr("btn_sync_full"))
        btn_sync_full.clicked.connect(lambda: self._sync_both_raw(RAW_MAX))
        btn_sync_full.setToolTip(tr("btn_sync_full_tip"))
        tr_mgr.register(btn_sync_full, "setText", "btn_sync_full")
        tr_mgr.register(btn_sync_full, "setToolTip", "btn_sync_full_tip")
        sync_ctrl.addWidget(btn_sync_full)

        sync_ctrl.addStretch()
        sync_lay.addLayout(sync_ctrl)
        both_outer.addWidget(sync_box)
        both_outer.addStretch()
        tabs.addTab(both_widget, tr("tab_both"))

        # ── Záložka: Programové nastavení výstupu ────────────────────────
        self.prog_widget = self._build_program_tab()
        tabs.addTab(self.prog_widget, tr("tab_program"))
        # Uložíme referenci na záložky abychom je mohli zamykat/odemykat
        self._tabs = tabs
        self._tab_program_idx = tabs.count() - 1   # index programové záložky

        # Splitter: záložky nahoře, log dole — výšku lze táhnout
        splitter = QSplitter(Qt.Orientation.Vertical)
        splitter.addWidget(tabs)

        log_container = QWidget()
        log_lay_outer = QVBoxLayout(log_container)
        log_lay_outer.setContentsMargins(0, 0, 0, 0)

        log_box = QGroupBox(tr("grp_log"))
        tr_mgr.register(log_box, "setTitle", "grp_log")
        log_inner = QVBoxLayout(log_box)

        self.log_edit = QTextEdit()
        self.log_edit.setReadOnly(True)
        self.log_edit.setFont(QFont("Courier New", 9))
        log_inner.addWidget(self.log_edit)

        log_btn_row = QHBoxLayout()
        btn_clear = QPushButton(tr("btn_clear_log"))
        tr_mgr.register(btn_clear, "setText", "btn_clear_log")
        btn_clear.clicked.connect(self.log_edit.clear)
        log_btn_row.addWidget(btn_clear)

        btn_save_log = QPushButton(tr("btn_save_log"))
        btn_save_log.clicked.connect(self._save_log)
        btn_save_log.setToolTip(tr("btn_save_log_tip"))
        tr_mgr.register(btn_save_log, "setText", "btn_save_log")
        tr_mgr.register(btn_save_log, "setToolTip", "btn_save_log_tip")
        log_btn_row.addWidget(btn_save_log)
        log_btn_row.addStretch()
        log_inner.addLayout(log_btn_row)

        log_lay_outer.addWidget(log_box)
        splitter.addWidget(log_container)
        splitter.setStretchFactor(0, 3)
        splitter.setStretchFactor(1, 1)

        root.addWidget(splitter)

        self.status_bar = QStatusBar()
        self.setStatusBar(self.status_bar)
        self.status_bar.showMessage(tr("status_ready"))

    def _build_program_tab(self) -> QWidget:
        """Sestaví záložku Programové nastavení výstupu.
        Záložka je výchozně zamknutá — odemkne se zaškrtnutím hlavního políčka."""
        outer = QWidget()
        outer_lay = QVBoxLayout(outer)
        outer_lay.setContentsMargins(10, 10, 10, 10)
        outer_lay.setSpacing(8)

        # Horní řádek: hlavní zaškrtávací políčko které odemkne celou záložku
        lock_row = QHBoxLayout()
        self.chk_prog_unlock = QCheckBox(tr("chk_prog_unlock"))
        tr_mgr.register(self.chk_prog_unlock, "setText", "chk_prog_unlock")
        self.chk_prog_unlock.setStyleSheet("font-weight: bold; color: #e8a87e;")
        self.chk_prog_unlock.setToolTip(tr("chk_prog_unlock_tip"))
        tr_mgr.register(self.chk_prog_unlock, "setToolTip", "chk_prog_unlock_tip")
        self.chk_prog_unlock.clicked.connect(self._on_prog_unlock)
        lock_row.addWidget(self.chk_prog_unlock)
        lock_row.addStretch()
        outer_lay.addLayout(lock_row)

        # Hlavní obsah záložky — výchozně skrytý, zobrazí se po odemknutí
        self.prog_content = QWidget()
        content_lay = QVBoxLayout(self.prog_content)
        content_lay.setContentsMargins(0, 0, 0, 0)
        content_lay.setSpacing(8)
        
        # Horní část: dva editory vedle sebe s příkazovými tlačítky uprostřed
        editors_row = QHBoxLayout()
        editors_row.setSpacing(8)

        # Levý editor — OUT1
        self.prog_out1 = ProgramEditor(0)
        editors_row.addWidget(self.prog_out1)

        # Střed: příkazová tlačítka
        cmd_panel = QVBoxLayout()
        cmd_panel.setSpacing(4)
        cmd_panel.addStretch()

        # Definice příkazových tlačítek: (text tlačítka, tooltip)
        cmd_buttons = [
            ("SET",     "cmd_set_tip"),
            ("WAIT",    "cmd_wait_tip"),
            ("RAMP",    "cmd_ramp_tip"),
            ("JUMP",    "cmd_jump_tip"),
            ("REPEAT",  "cmd_repeat_tip"),
            ("TRIGGER", "cmd_trigger_tip"),
        ]
        for cmd, tip_key in cmd_buttons:
            btn = QPushButton(cmd)
            btn.setToolTip(tr(tip_key))
            tr_mgr.register(btn, "setToolTip", tip_key)
            btn.setFixedWidth(80)
            # lambda s výchozím parametrem cmd=cmd zabrání tomu aby všechna tlačítka
            # volala stejný příkaz — klasická past v Pythonu s uzávěrami (closure)
            btn.clicked.connect(lambda checked, c=cmd: self._insert_command(c))
            cmd_panel.addWidget(btn)

        cmd_panel.addStretch()
        editors_row.addLayout(cmd_panel)

        # Pravý editor — OUT2
        self.prog_out2 = ProgramEditor(1)
        editors_row.addWidget(self.prog_out2)

        content_lay.addLayout(editors_row)

        # Spodní část: tlačítka a políčka pod každým editorem
        bottom_row = QHBoxLayout()
        bottom_row.setSpacing(8)

        # Levý sloupec — OUT1
        out1_ctrl = QVBoxLayout()
        out1_ctrl.setSpacing(4)

        # Zaškrtávací políčko Aktivní — nad tlačítky
        out1_chk_row = QHBoxLayout()
        out1_chk_row.addWidget(self.prog_out1.chk_active)
        out1_chk_row.addStretch()
        out1_ctrl.addLayout(out1_chk_row)

        # Řádek tlačítek OUT1
        out1_btn_row = QHBoxLayout()
        out1_btn_row.setSpacing(4)
        self.btn_prog_run1 = QPushButton(tr("btn_prog_run"))
        tr_mgr.register(self.btn_prog_run1, "setText", "btn_prog_run")
        self.btn_prog_run1.setStyleSheet("font-weight: bold; color: #4caf50;")
        self.btn_prog_run1.setToolTip(tr("btn_prog_run_tip1"))
        tr_mgr.register(self.btn_prog_run1, "setToolTip", "btn_prog_run_tip1")
        self.btn_prog_run1.clicked.connect(lambda: self._prog_run(0))
        out1_btn_row.addWidget(self.btn_prog_run1)

        self.btn_prog_stop1 = QPushButton(tr("btn_prog_stop"))
        tr_mgr.register(self.btn_prog_stop1, "setText", "btn_prog_stop")
        self.btn_prog_stop1.setStyleSheet("font-weight: bold; color: #e85c5c;")
        self.btn_prog_stop1.setToolTip(tr("btn_prog_stop_tip1"))
        tr_mgr.register(self.btn_prog_stop1, "setToolTip", "btn_prog_stop_tip1")
        self.btn_prog_stop1.setEnabled(False)
        self.btn_prog_stop1.clicked.connect(lambda: self._prog_stop(0))
        out1_btn_row.addWidget(self.btn_prog_stop1)

        self._btn_save1 = QPushButton(tr("btn_prog_save1"))
        self._btn_save1.setToolTip(tr("btn_prog_save1_tip"))
        tr_mgr.register(self._btn_save1, "setText", "btn_prog_save1")
        tr_mgr.register(self._btn_save1, "setToolTip", "btn_prog_save1_tip")
        self._btn_save1.clicked.connect(lambda: self._prog_save(0))
        out1_btn_row.addWidget(self._btn_save1)

        self._btn_load1 = QPushButton(tr("btn_prog_load1"))
        self._btn_load1.setToolTip(tr("btn_prog_load1_tip"))
        tr_mgr.register(self._btn_load1, "setText", "btn_prog_load1")
        tr_mgr.register(self._btn_load1, "setToolTip", "btn_prog_load1_tip")
        self._btn_load1.clicked.connect(lambda: self._prog_load(0))
        out1_btn_row.addWidget(self._btn_load1)

        out1_btn_row.addWidget(self.prog_out1.btn_clear)
        self._btn_copy1to2 = QPushButton(tr("btn_copy1to2"))
        self._btn_copy1to2.setToolTip(tr("btn_copy1to2_tip"))
        tr_mgr.register(self._btn_copy1to2, "setText", "btn_copy1to2")
        tr_mgr.register(self._btn_copy1to2, "setToolTip", "btn_copy1to2_tip")
        self._btn_copy1to2.clicked.connect(lambda: self._prog_copy(0, 1))
        out1_btn_row.addWidget(self._btn_copy1to2)
        out1_btn_row.addStretch()
        out1_ctrl.addLayout(out1_btn_row)

        # Zaškrtávací políčko pro synchronizaci — pod tlačítky
        self.chk_both_run = QCheckBox(tr("chk_both_run"))
        self.chk_both_run.setToolTip(tr("chk_both_run_tip"))
        tr_mgr.register(self.chk_both_run, "setText", "chk_both_run")
        tr_mgr.register(self.chk_both_run, "setToolTip", "chk_both_run_tip")
        chk_both_row = QHBoxLayout()
        chk_both_row.addWidget(self.chk_both_run)
        chk_both_row.addStretch()
        out1_ctrl.addLayout(chk_both_row)
        bottom_row.addLayout(out1_ctrl)

        # Mezera mezi sloupci — stejná šířka jako panel příkazových tlačítek
        bottom_row.addSpacing(96)

        # Pravý sloupec — OUT2
        out2_ctrl = QVBoxLayout()
        out2_ctrl.setSpacing(4)

        # Zaškrtávací políčko Aktivní — nad tlačítky
        out2_chk_row = QHBoxLayout()
        out2_chk_row.addWidget(self.prog_out2.chk_active)
        out2_chk_row.addStretch()
        out2_ctrl.addLayout(out2_chk_row)

        # Řádek tlačítek OUT2
        out2_btn_row = QHBoxLayout()
        out2_btn_row.setSpacing(4)
        self.btn_prog_run2 = QPushButton(tr("btn_prog_run"))
        tr_mgr.register(self.btn_prog_run2, "setText", "btn_prog_run")
        self.btn_prog_run2.setStyleSheet("font-weight: bold; color: #4caf50;")
        self.btn_prog_run2.setToolTip(tr("btn_prog_run_tip2"))
        tr_mgr.register(self.btn_prog_run2, "setToolTip", "btn_prog_run_tip2")
        self.btn_prog_run2.clicked.connect(lambda: self._prog_run(1))
        out2_btn_row.addWidget(self.btn_prog_run2)

        self.btn_prog_stop2 = QPushButton(tr("btn_prog_stop"))
        tr_mgr.register(self.btn_prog_stop2, "setText", "btn_prog_stop")
        self.btn_prog_stop2.setStyleSheet("font-weight: bold; color: #e85c5c;")
        self.btn_prog_stop2.setToolTip(tr("btn_prog_stop_tip2"))
        tr_mgr.register(self.btn_prog_stop2, "setToolTip", "btn_prog_stop_tip2")
        self.btn_prog_stop2.setEnabled(False)
        self.btn_prog_stop2.clicked.connect(lambda: self._prog_stop(1))
        out2_btn_row.addWidget(self.btn_prog_stop2)

        self._btn_save2 = QPushButton(tr("btn_prog_save2"))
        self._btn_save2.setToolTip(tr("btn_prog_save2_tip"))
        tr_mgr.register(self._btn_save2, "setText", "btn_prog_save2")
        tr_mgr.register(self._btn_save2, "setToolTip", "btn_prog_save2_tip")
        self._btn_save2.clicked.connect(lambda: self._prog_save(1))
        out2_btn_row.addWidget(self._btn_save2)

        self._btn_load2 = QPushButton(tr("btn_prog_load2"))
        self._btn_load2.setToolTip(tr("btn_prog_load2_tip"))
        tr_mgr.register(self._btn_load2, "setText", "btn_prog_load2")
        tr_mgr.register(self._btn_load2, "setToolTip", "btn_prog_load2_tip")
        self._btn_load2.clicked.connect(lambda: self._prog_load(1))
        out2_btn_row.addWidget(self._btn_load2)

        out2_btn_row.addWidget(self.prog_out2.btn_clear)
        self._btn_copy2to1 = QPushButton(tr("btn_copy2to1"))
        self._btn_copy2to1.setToolTip(tr("btn_copy2to1_tip"))
        tr_mgr.register(self._btn_copy2to1, "setText", "btn_copy2to1")
        tr_mgr.register(self._btn_copy2to1, "setToolTip", "btn_copy2to1_tip")
        self._btn_copy2to1.clicked.connect(lambda: self._prog_copy(1, 0))
        out2_btn_row.addWidget(self._btn_copy2to1)
        out2_btn_row.addStretch()
        out2_ctrl.addLayout(out2_btn_row)

        # Prázdný řádek — zarovná výšku s OUT1 který má chk_both_run navíc
        lbl_spacer = QLabel("")
        lbl_spacer.setFixedHeight(self.chk_both_run.sizeHint().height() + 4)
        out2_ctrl.addWidget(lbl_spacer)

        bottom_row.addLayout(out2_ctrl)

        content_lay.addLayout(bottom_row)

        # Grafy průběhu výstupů — pod editory a tlačítky
        graphs_row = QHBoxLayout()
        graphs_row.setSpacing(8)
        self.graph_out1 = OutputGraph(0)
        self.graph_out1.save_dir = self._save_dir
        self.graph_out2 = OutputGraph(1)
        self.graph_out2.save_dir = self._save_dir
        graphs_row.addWidget(self.graph_out1)
        graphs_row.addWidget(self.graph_out2)
        content_lay.addLayout(graphs_row)

        outer_lay.addWidget(self.prog_content)
        outer_lay.addStretch()

        # Výchozně zamknutý obsah
        self.prog_content.setEnabled(False)
        return outer

    def _on_prog_unlock(self, unlocked: bool):
        """Odemkne/zamkne programovou záložku a ostatní záložky.
        Nelze zamknout pokud právě běží program některého výstupu."""
        if not unlocked:
            # Pokus o zamknutí — zkontroluj zda neběží program
            if self._prog_running.get(0, False) or self._prog_running.get(1, False):
                self._log("⚠ Nelze zamknout kartu — program stále běží. "
                         "Nejdřív zastav všechny běžící programy.")
                # Vrať políčko zpět do zaškrtnutého stavu
                self.chk_prog_unlock.blockSignals(True)
                self.chk_prog_unlock.setChecked(True)
                self.chk_prog_unlock.blockSignals(False)
                return
        self.prog_content.setEnabled(unlocked)
        for i in range(self._tabs.count()):
            if i != self._tab_program_idx:
                self._tabs.setTabEnabled(i, not unlocked)

    def _insert_command(self, cmd: str):
        """Otevře dialogové okno pro zadání parametrů příkazu.
        Pokud rozsah neodpovídá prvnímu SET v daném okně, přidá varování jako komentář."""
        # Rozsah podle prvního aktivního okna pro zápis
        write_to_out1 = self.prog_out1.chk_write.isChecked()
        write_to_out2 = self.prog_out2.chk_write.isChecked()

        if write_to_out1:
            first_range, first_unit_idx = self._get_first_set_range(0)
            prev_val, prev_rng, prev_unit_idx = self._get_prev_end_value(0)
        elif write_to_out2:
            first_range, first_unit_idx = self._get_first_set_range(1)
            prev_val, prev_rng, prev_unit_idx = self._get_prev_end_value(1)
        else:
            first_range, first_unit_idx = None, None
            prev_val, prev_rng, prev_unit_idx = None, None, None

        active_ch = 0 if write_to_out1 else 1
        last_ramp_to       = self._last_ramp_to.get(active_ch)
        last_ramp_step     = self._last_ramp_step.get(active_ch)
        last_ramp_ms       = self._last_ramp_ms.get(active_ch)
        last_ramp_range    = self._last_ramp_range.get(active_ch)
        last_ramp_unit_idx = self._last_ramp_unit_idx.get(active_ch)

        # Pro TRIGGER předáme informace o programech obou výstupů
        trigger_programs = None
        if cmd == "TRIGGER":
            trigger_programs = {
                0: self.prog_out1.get_program(),
                1: self.prog_out2.get_program()
            }
        dlg = CommandDialog(cmd, self,
                           first_range=first_range,
                           first_unit_idx=first_unit_idx,
                           trigger_programs=trigger_programs,
                           source_channel=0 if write_to_out1 else 1,
                           last_ramp_to=last_ramp_to,
                           last_ramp_step=last_ramp_step,
                           last_ramp_ms=last_ramp_ms,
                           last_ramp_range=last_ramp_range,
                           last_ramp_unit_idx=last_ramp_unit_idx,
                           prev_end_val=prev_val,
                           prev_end_rng=prev_rng,
                           prev_end_unit_idx=prev_unit_idx)
        if dlg.exec() != QDialog.DialogCode.Accepted:
            return
        line = dlg.get_command_line()

        # Vlož příkaz do každého okna zvlášť a zkontroluj rozsah
        for ch, editor in ((0, self.prog_out1), (1, self.prog_out2)):
            if not editor.chk_write.isChecked():
                continue   # zápis do tohoto okna není povolen
            rng, unit_idx = self._get_first_set_range(ch)
            # Zkontroluj zda rozsah odpovídá prvnímu SET v tomto okně
            if rng is not None and (cmd == "SET" or cmd == "RAMP"):
                parts = line.split()
                if cmd == "SET":
                    # Formát: SET [hodnota] [jednotka] [rozsah...]
                    cmd_unit = parts[2] if len(parts) > 2 else ""
                    cmd_rng  = " ".join(parts[3:]) if len(parts) > 3 else ""
                elif cmd == "RAMP":
                    # Formát: RAMP [od] [j] [do] [j] [krok] [j] [ms] [rozsah...]
                    cmd_unit = parts[2] if len(parts) > 2 else ""
                    cmd_rng  = " ".join(parts[8:]) if len(parts) > 8 else ""
                else:
                    cmd_unit = ""
                    cmd_rng  = ""
                cmd_unit_idx = 0 if cmd_unit == "%" else \
                               1 if cmd_unit == "RAW" else 2
                if cmd_rng != rng or cmd_unit_idx != unit_idx:
                    # Rozsah neodpovídá — vlož příkaz s varováním jako komentář
                    editor.insert_command(line)
                    if cmd == "RAMP":
                        parts_r = line.split()
                        try:
                            self._last_ramp_to[ch]       = float(parts_r[3])
                            self._last_ramp_step[ch]     = float(parts_r[5])
                            self._last_ramp_ms[ch]       = int(parts_r[7].replace("ms", ""))
                            self._last_ramp_range[ch]    = " ".join(parts_r[8:])
                            self._last_ramp_unit_idx[ch] = 0 if parts_r[2] == "%" else \
                                                   1 if parts_r[2] == "RAW" else 2
                        except (IndexError, ValueError):
                            pass
                    editor.insert_command(
                        f"# ⚠ VAROVÁNÍ: rozsah {cmd_rng} neodpovídá "
                        f"prvnímu SET ({rng}) — zkontroluj nastavení!"
                    )
                    self._log(f"⚠ OUT{ch+1}: příkaz {cmd} má jiný rozsah "
                             f"než první SET ({rng})")
                    continue
            editor.insert_command(line)
            if cmd == "RAMP":
                parts_r = line.split()
                try:
                    self._last_ramp_to[ch]       = float(parts_r[3])
                    self._last_ramp_step[ch]     = float(parts_r[5])
                    self._last_ramp_ms[ch]       = int(parts_r[7].replace("ms", ""))
                    self._last_ramp_range[ch]    = " ".join(parts_r[8:])
                    self._last_ramp_unit_idx[ch] = 0 if parts_r[2] == "%" else \
                                                   1 if parts_r[2] == "RAW" else 2
                except (IndexError, ValueError):
                    pass

    def _get_first_set_range(self, channel: int):
        """Najde první příkaz SET v editoru zadaného kanálu a vrátí jeho rozsah a jednotku.
        channel = 0 pro OUT1, 1 pro OUT2 — každý výstup má vlastní hlídání rozsahu."""
        editor = self.prog_out1 if channel == 0 else self.prog_out2
        for ln in editor.editor.toPlainText().splitlines():
            ln = ln.strip()
            if ln.upper().startswith("SET"):
                parts = ln.split()
                try:
                    unit = parts[2]
                    rng  = " ".join(parts[3:])
                    if unit == "%":
                        return rng, 0
                    elif unit == "RAW":
                        return rng, 1
                    else:
                        return rng, 2
                except IndexError:
                    pass
        return None, None
    
    def _get_prev_end_value(self, channel: int) -> tuple[float | None, str | None, int | None]:
        """Najde poslední hodnotu Do: z příkazu SET nebo RAMP před aktuální pozicí kurzoru.
        Vrátí (hodnota, rozsah, unit_idx) nebo (None, None, None) pokud nenalezeno."""
        editor = self.prog_out1 if channel == 0 else self.prog_out2
        cursor = editor.editor.textCursor()
        current_block = cursor.blockNumber()
        doc = editor.editor.document()
        last_val, last_rng, last_unit_idx = None, None, None
        # Projdi všechny řádky od začátku až po aktuální pozici kurzoru
        for i in range(current_block):
            ln = doc.findBlockByNumber(i).text().strip()
            if not ln or ln.startswith("#"):
                continue
            parts = ln.split()
            cmd = parts[0].upper()
            try:
                if cmd == "SET":
                    last_val      = float(parts[1])
                    last_unit_idx = 0 if parts[2] == "%" else 1 if parts[2] == "RAW" else 2
                    last_rng      = " ".join(parts[3:])
                elif cmd == "RAMP":
                    last_val      = float(parts[3])
                    last_unit_idx = 0 if parts[2] == "%" else 1 if parts[2] == "RAW" else 2
                    last_rng      = " ".join(parts[8:])
            except (IndexError, ValueError):
                continue
        return last_val, last_rng, last_unit_idx

    def _prog_run(self, channel: int):
        # Pokud je zaškrtnuto společné spuštění, simulujeme stisk obou tlačítek
        if self.chk_both_run.isChecked():
            channels = [0, 1]
        else:
            channels = [channel]

        for ch in channels:
            editor   = self.prog_out1  if ch == 0 else self.prog_out2
            btn_run  = self.btn_prog_run1  if ch == 0 else self.btn_prog_run2
            btn_stop = self.btn_prog_stop1 if ch == 0 else self.btn_prog_stop2

            if not editor.chk_active.isChecked():
                self._log(f"⚠ OUT{ch+1}: není aktivní — program se nespustí")
                continue

            lines = editor.get_program()
            if not lines:
                self._log(f"⚠ OUT{ch+1}: program je prázdný")
                continue

            # Vytvoř engine a napoj signály
            runner = ProgramRunner(ch, lines)
            runner.command_write.connect(self._queue_write)
            runner.log_message.connect(self._log)
            runner.finished.connect(self._on_prog_finished)
            runner.error.connect(self._on_prog_error)
            runner.line_changed.connect(self._on_prog_line_changed)
            runner.trigger_request.connect(self._on_trigger_request)

            # Uložíme runner abychom ho mohli zastavit
            if not hasattr(self, "_runners"):
                self._runners = {}
            self._runners[ch] = runner

            editor.set_running(True)
            btn_run.setEnabled(False)
            btn_stop.setEnabled(True)
            self._prog_running[ch] = True
            graph = self.graph_out1 if ch == 0 else self.graph_out2
            graph.start_recording()
            # Nastav Y osu podle prvního SET v programu
            first_range, _ = self._get_first_set_range(ch)
            if first_range and first_range in OUTPUT_RANGES:
                lo, hi, unit = OUTPUT_RANGES[first_range]
                graph.set_y_range(lo, hi, unit)
            self._set_file_buttons_enabled(False)
            # Odstraň zelenou tečku z editoru
            editor._prog_finished = True
            editor._active_line = self._last_line.get(channel, 1)
            editor.editor._finished_flag = True   # uložíme příznak přímo do editoru
            editor.editor.line_number_area.repaint()   # repaint = okamžité překreslení
            
            # Spustíme ve vedlejším vlákně
            import threading
            t = threading.Thread(target=runner.run, daemon=True)
            t.start()
            self._log(f"▶ OUT{ch+1}: program spuštěn")

    def _prog_stop(self, channel: int):
        """Zastaví program zadaného kanálu.
        Podle nastavení v menu Možnosti nastaví výstup na minimum nebo ponechá hodnotu."""
        if self.chk_both_run.isChecked():
            channels = [0, 1]
        else:
            channels = [channel]
        for ch in channels:
            if hasattr(self, "_runners") and ch in self._runners:
                self._runners[ch].stop()
           
    def _on_prog_finished(self, channel: int, reason: str):
        """Zavolá se když program skončí — přirozeně nebo zastavením."""
        editor   = self.prog_out1  if channel == 0 else self.prog_out2
        btn_run  = self.btn_prog_run1  if channel == 0 else self.btn_prog_run2
        btn_stop = self.btn_prog_stop1 if channel == 0 else self.btn_prog_stop2
        editor.set_running(False)
        btn_run.setEnabled(True)
        btn_stop.setEnabled(False)
        self._prog_running[channel] = False
        if hasattr(self, "_runners") and channel in self._runners:
            del self._runners[channel]
        # Nejdřív nastav výstup na minimum — pak zastav záznam aby se minimum zaznamenalo
        set_zero = self._stop_to_zero.get(channel, True)
        if set_zero:
            runner = getattr(self, "_runners", {}).get(channel)
            runner_rng = getattr(runner, "current_range", None) if runner else None
            rng = runner_rng if runner_rng else self.ch_widgets[channel].cmb_range.currentText()
            lo, hi, unit = OUTPUT_RANGES[rng]
            raw_min = phys_to_raw(lo, rng)
            graph = self.graph_out1 if channel == 0 else self.graph_out2
            import time
            if graph._start_time is not None:
                t = time.monotonic() - graph._start_time
                graph.add_sample(raw_min, rng, t)
            self._queue_write(channel, raw_min)
            self._log(f"  → OUT{channel+1} nastaven na minimum ({lo} {unit})")

        graph = self.graph_out1 if channel == 0 else self.graph_out2
        graph.stop_recording()
        # Znovu aktivuj tlačítka pouze pokud neběží ani druhý program
        if not self._prog_running.get(0, False) and \
           not self._prog_running.get(1, False):
            self._set_file_buttons_enabled(True)
        editor.highlight_line(self._last_line.get(channel, 1), finished=True)
        # Zvýrazni poslední řádek červeně
        last = self._last_line.get(channel, 1)
        editor.highlight_line(last, finished=True)

    def _on_prog_error(self, channel: int, line_num: int, description: str):
        """Zavolá se když engine narazí na chybu v programu."""
        self._on_prog_finished(channel, f"Chyba na řádku {line_num}: {description}")
        self._log(f"✗ OUT{channel+1} řádek {line_num}: {description}")

    def _on_trigger_request(self, source_ch: int, target_ch: int,
                            action: str, line: int, mode: str):
        """Zpracuje požadavek TRIGGER z runneru — spustí nebo zastaví cílový program."""
        target_editor = self.prog_out1 if target_ch == 0 else self.prog_out2
        source_runner = self._runners.get(source_ch)

        if action == "START":
            # Kontrola zda je cílový výstup aktivní
            if not target_editor.chk_active.isChecked():
                self._log(f"⚠ TRIGGER: OUT{target_ch+1} není aktivní — program se nespustí")
                if source_runner:
                    source_runner._waiting_for_trigger = False
                return
            program = target_editor.get_program()
            if not program:
                self._log(f"⚠ TRIGGER: OUT{target_ch+1} nemá program")
                if source_runner:
                    source_runner._waiting_for_trigger = False
                return
            # Pokud cílový kanál už běží (spuštěn předchozím TRIGGER), nespouštěj znovu
            if self._prog_running.get(target_ch, False):
                self._log(f"↷ TRIGGER: OUT{target_ch+1} již běží — přeskočeno")
                return
            # Zkontroluj REPEAT 0
            has_infinite = any(
                ln.upper().startswith("REPEAT") and
                len(ln.split()) > 1 and ln.split()[1] == "0"
                for ln in program
            )
            if has_infinite and mode == "WAIT":
                if source_runner:
                    source_runner._trigger_infinite = True
                    source_runner._waiting_for_trigger = False
                return
            # Najdi první SET v celém programu — vezmi rozsah a RAW hodnotu předem
            # bez fyzického vykonání SET příkazu (aby neposunul časování programu)
            first_set_range = None
            first_set_raw   = None
            for ln in program:
                p = ln.split()
                if not p or p[0].upper() != "SET":
                    continue
                try:
                    tmp_runner = ProgramRunner(target_ch, [ln])
                    raw = tmp_runner._parse_set(p, 0)
                    if raw is not None:
                        first_set_raw   = raw
                        first_set_range = " ".join(p[3:])
                except Exception:
                    pass
                break

            # Ořízni program od zadaného řádku a odstraň případný úvodní SET
            if line > 1:
                program = program[line-1:]
            # Spočítej offset před odstraněním SET
            jump_offset = (line - 1)
            if program and program[0].split()[0].upper() == "SET":
                program = program[1:]
                jump_offset += 1
            # Přepočítej cíle JUMP příkazů podle offsetu
            adjusted = []
            for ln in program:
                p = ln.split()
                if p and p[0].upper() == "JUMP":
                    try:
                        target_line = int(p[1]) - jump_offset
                        p[1] = str(max(1, target_line))
                        ln = " ".join(p)
                    except (IndexError, ValueError):
                        pass
                adjusted.append(ln)
            program = adjusted

            target_runner = ProgramRunner(target_ch, program)
            if first_set_range is not None:
                target_runner.current_range = first_set_range
            if first_set_raw is not None:
                target_runner.current_raw = first_set_raw
            target_runner.command_write.connect(self._queue_write)
            target_runner.log_message.connect(self._log)
            target_runner.line_changed.connect(self._on_prog_line_changed)
            offset = line - 1  # o kolik řádků je program oříznutý
            target_runner.line_changed.connect(
                lambda ch, ln, off=offset: self._on_prog_line_changed(ch, ln + off))
            target_runner.error.connect(self._on_prog_error)
            # Při dokončení cílového programu uvolni čekání zdrojového
            def _on_target_done(ch, reason, src_runner=source_runner,
                               tgt_ch=target_ch):
                self._on_prog_finished(ch, reason)
                if src_runner and mode == "WAIT":
                    src_runner._waiting_for_trigger = False
            target_runner.finished.connect(_on_target_done)
            target_runner.trigger_request.connect(self._on_trigger_request)
            if not hasattr(self, "_runners"):
                self._runners = {}
            self._runners[target_ch] = target_runner

            btn_run  = self.btn_prog_run1  if target_ch == 0 else self.btn_prog_run2
            btn_stop = self.btn_prog_stop1 if target_ch == 0 else self.btn_prog_stop2
            target_editor.set_running(True)
            btn_run.setEnabled(False)
            btn_stop.setEnabled(True)
            self._prog_running[target_ch] = True
            graph = self.graph_out1 if target_ch == 0 else self.graph_out2
            graph.start_recording()
            if first_set_range and first_set_range in OUTPUT_RANGES:
                lo, hi, unit = OUTPUT_RANGES[first_set_range]
                graph.set_y_range(lo, hi, unit)
            # Nastav Y osu podle prvního SET v programu cílového výstupu
            first_range, _ = self._get_first_set_range(target_ch)
            if first_range and first_range in OUTPUT_RANGES:
                lo, hi, unit = OUTPUT_RANGES[first_range]
                graph.set_y_range(lo, hi, unit)

            import threading
            t = threading.Thread(target=target_runner.run, daemon=True)
            t.start()
            self._log(f"▶ TRIGGER: OUT{target_ch+1} spuštěn od řádku {line}")

        elif action.startswith("STOP"):
            stop_mode = action.split("_")[1] if "_" in action else "ZERO"
            self._prog_stop(target_ch)
            if stop_mode == "ZERO":
                rng = self.ch_widgets[target_ch].cmb_range.currentText()
                lo, hi, unit = OUTPUT_RANGES[rng]
                raw_min = phys_to_raw(lo, rng)
                self._queue_write(target_ch, raw_min)
            self._log(f"■ TRIGGER: OUT{target_ch+1} zastaven ({stop_mode})")
            if source_runner:
                source_runner._waiting_for_trigger = False

    def _set_file_buttons_enabled(self, enabled: bool):
        """Aktivuje nebo deaktivuje tlačítka která by mohla narušit běžící program."""
        for btn in (self._btn_save1, self._btn_load1,
                    self._btn_save2, self._btn_load2,
                    self._btn_copy1to2, self._btn_copy2to1):
            btn.setEnabled(enabled)
        # Zamkni i tlačítka nad grafy — pouze pokud již existují
        for graph in (getattr(self, 'graph_out1', None),
                      getattr(self, 'graph_out2', None)):
            if graph is None:
                continue
            graph.btn_save_graph.setEnabled(enabled)
            graph.btn_clear_graph.setEnabled(enabled)

    def _on_prog_line_changed(self, channel: int, line_num: int):
        """Zobrazí zelenou tečku u aktuálně vykonávaného řádku."""
        self._last_line[channel] = line_num
        editor = self.prog_out1 if channel == 0 else self.prog_out2
        editor.editor._finished_flag = False   # reset — program běží
        editor.highlight_line(line_num)

    def _sample_graphs(self):
        """Periodicky vzorkuje aktuální RAW hodnoty výstupů a předává je grafům."""
        if getattr(self, '_dialog_open', False):
            return   # dialog je otevřen — přeskoč vzorkování
        import time
        if not self.chk_prog_unlock.isChecked():
            return
        now = time.monotonic()
        for ch in (0, 1):
            if not self._prog_running.get(ch, False):
                continue
            if not hasattr(self, "_runners"):
                continue
            runner = self._runners.get(ch)
            if runner is not None:
                raw = runner.current_raw
            else:
                raw = self.ch_widgets[ch].current_raw
            # Rozsah čti z runneru pokud běží přes TRIGGER, jinak z widgetu
            runner_rng = getattr(runner, "current_range", None) if runner else None
            rng = runner_rng if runner_rng else self.ch_widgets[ch].cmb_range.currentText()
            graph = self.graph_out1 if ch == 0 else self.graph_out2
            if graph._start_time is None:
                graph._start_time = now
            t = now - graph._start_time
            graph.add_sample(raw, rng, t)
    
    def _force_sample(self, channel: int):
        """Vynutí okamžité vzorkování grafu pro daný kanál — používá se po SET příkazu."""
        import time
        if not hasattr(self, "_runners"):
            return
        runner = self._runners.get(channel)
        if runner is None:
            return
        raw = runner.current_raw
        runner_rng = getattr(runner, "current_range", None)
        rng = runner_rng if runner_rng else self.ch_widgets[channel].cmb_range.currentText()
        graph = self.graph_out1 if channel == 0 else self.graph_out2
        now = time.monotonic()
        if graph._start_time is None:
            graph._start_time = now
        t = now - graph._start_time
        # Přidej vzorek se starou hodnotou těsně před skokem
        graph.add_sample(runner.current_raw, rng, t - 0.001)
        # Přidej vzorek s novou hodnotou
        graph.add_sample(runner.current_raw, rng, t)

    def _prog_save(self, channel: int):
        """Uloží program zadaného kanálu do textového souboru."""
        from PyQt6.QtWidgets import QFileDialog
        editor = self.prog_out1 if channel == 0 else self.prog_out2
        self._dialog_open = True
        import os
        default = os.path.join(self._save_dir, f"program_out{channel+1}.txt")
        path, _ = QFileDialog.getSaveFileName(
            self, f"Uložit program OUT{channel+1}",
            default,
            "Textové soubory (*.txt)"
        )
        self._dialog_open = False   # vždy resetuj — i při zrušení dialogu
        if not path:
            return
        try:
            with open(path, "w", encoding="utf-8") as f:
                f.write(editor.editor.toPlainText())
            self._log(f"💾 Program OUT{channel+1} uložen: {path}")
        except Exception as e:
            self._log(f"✗ Chyba při ukládání OUT{channel+1}: {e}")

    def _prog_load(self, channel: int):
        """Načte program ze souboru do editoru zadaného kanálu."""
        from PyQt6.QtWidgets import QFileDialog
        editor = self.prog_out1 if channel == 0 else self.prog_out2
        self._dialog_open = True
        import os
        path, _ = QFileDialog.getOpenFileName(
            self, f"Načíst program OUT{channel+1}",
            self._save_dir, "Textové soubory (*.txt)"
        )
        self._dialog_open = False   # vždy resetuj — i při zrušení dialogu
        if not path:
            return
        try:
            with open(path, "r", encoding="utf-8") as f:
                content = f.read()
            # Validace — zkontroluj zda soubor obsahuje alespoň jeden platný příkaz
            # a žádný řádek není podezřele dlouhý (ochrana před binárními soubory)
            valid_lines   = 0
            invalid_lines = []
            for i, ln in enumerate(content.splitlines(), 1):
                ln_stripped = ln.strip()
                if not ln_stripped or ln_stripped.startswith("#"):
                    continue   # prázdný řádek nebo komentář — OK
                if len(ln_stripped) > 200:
                    self._log(f"✗ Soubor odmítnut ({path}) — řádek {i} je příliš dlouhý "
                             f"(možný binární soubor)")
                    return
                first = ln_stripped.split()[0].upper()
                if first in VALID_COMMANDS:
                    valid_lines += 1
                else:
                    invalid_lines.append(i)
            if valid_lines == 0:
                self._log(f"✗ Soubor odmítnut ({path}) — neobsahuje žádný platný příkaz")
                return
            if invalid_lines:
                # Soubor obsahuje neplatné řádky — zeptej se uživatele
                from PyQt6.QtWidgets import QMessageBox
                reply = QMessageBox.question(
                    self,
                    "Neplatné řádky v souboru",
                    f"Soubor obsahuje {len(invalid_lines)} neplatných řádků "
                    f"(řádky: {', '.join(map(str, invalid_lines[:5]))}{'...' if len(invalid_lines) > 5 else ''}).\n"
                    f"Tyto řádky budou považovány za komentáře.\n\n"
                    f"Chceš soubor přesto načíst?",
                    QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
                )
                if reply != QMessageBox.StandardButton.Yes:
                    return
            editor.editor.setPlainText(content)
            self._log(f"📂 Program OUT{channel+1} načten: {path} "
                     f"({valid_lines} platných příkazů)")
        except UnicodeDecodeError:
            self._log(f"✗ Soubor odmítnut ({path}) — není textový soubor (binární formát)")
        except Exception as e:
            self._log(f"✗ Chyba při načítání OUT{channel+1}: {e}")

    def _prog_copy(self, src: int, dst: int):
        """Zkopíruje obsah editoru zdrojového kanálu do cílového.
        src = zdrojový kanál (0=OUT1, 1=OUT2)
        dst = cílový kanál (0=OUT1, 1=OUT2)"""
        src_editor = self.prog_out1 if src == 0 else self.prog_out2
        dst_editor = self.prog_out1 if dst == 0 else self.prog_out2
        text = src_editor.editor.toPlainText()
        if not text.strip():
            self._log(f"⚠ OUT{src+1}: program je prázdný — nic ke kopírování")
            return
        dst_editor.editor.setPlainText(text)
        self._log(f"⇒ Program OUT{src+1} zkopírován do OUT{dst+1}")

    # ── Záložka Oba výstupy ────────────────────────────────────────────────

    def _on_both_unit_changed(self):
        """Přepne rozsah a suffix políčka hodnoty pro záložku Oba výstupy."""
        idx = self.cmb_both_unit.currentIndex()
        if idx == 0:   # %
            self.spin_sync.setRange(0, 100)
            self.spin_sync.setDecimals(2)
            self.lbl_sync_unit.setText("%")
        elif idx == 1:  # RAW
            self.spin_sync.setRange(0, RAW_MAX)
            self.spin_sync.setDecimals(0)
            self.lbl_sync_unit.setText("RAW")
        else:           # fyzikální dle OUT1
            rng = self.ch_widgets[0].cmb_range.currentText()
            lo, hi, unit = OUTPUT_RANGES[rng]
            self.spin_sync.setRange(lo, hi)
            self.spin_sync.setDecimals(3)
            self.lbl_sync_unit.setText(unit)

    def _on_both_range_changed(self, range_name: str):
        """Nastaví stejný rozsah na oba výstupy a přepočítá políčko hodnoty."""
        for ch in (0, 1):
            self.ch_widgets[ch].cmb_range.setCurrentText(range_name)
            self._send_range(ch, range_name)
        self._log(f"Rozsah obou výstupů → {range_name}")
        self._on_both_unit_changed()
        # Explicitně aktualizuj jednotku podle nového rozsahu
        if self.cmb_both_unit.currentIndex() == 2:   # fyzikální
            lo, hi, unit = OUTPUT_RANGES[range_name]
            self.lbl_sync_unit.setText(unit)
            self.spin_sync.setRange(lo, hi)

    def _sync_both(self):
        """Nastaví oba výstupy na hodnotu z políčka záložky Oba výstupy."""
        idx = self.cmb_both_unit.currentIndex()
        val = self.spin_sync.value()
        if idx == 0:   # %
            raw = percent_to_raw(val)
        elif idx == 1:  # RAW
            raw = int(val)
        else:           # fyzikální
            rng = self.ch_widgets[0].cmb_range.currentText()
            raw = phys_to_raw(val, rng)
        self._sync_both_raw(raw)

    def _sync_both_raw(self, raw: int):
        """Nastaví oba výstupy na zadanou RAW hodnotu."""
        for ch in self.ch_widgets:
            ch._set_raw_and_send(raw)

    # ── Komunikace ─────────────────────────────────────────────────────────

    def _reset_device(self):
        """Pošle Reset instrukci do DA2ETH a zaloguje výsledek."""
        if self.worker.is_connected:
            threading.Thread(target=self.worker.reset_device,
                            daemon=True).start()
            self._log("Reset zařízení odeslán.")
        else:
            self._log("[OFFLINE] Reset — není připojeno.")
    
    def _check_busy_watchdog(self):
        """Hlídá jestli komunikace nezamrzla — busy flag True déle než 4 sekundy."""
        if not self.worker.is_connected:
            self._busy_since = None
            return   # není připojeno — watchdog nehlídá
        if self.worker._busy.is_set():
            if self._busy_since is None:
                # Právě začal přenos — zapamatuj si čas začátku
                self._busy_since = time.monotonic()
            elif time.monotonic() - self._busy_since > 4.0:
                # Přenos trvá déle než 4 sekundy — pravděpodobně zamrznutí
                self.lbl_conn_status.setText("🥶 Komunikace zamrzla!")
                self.lbl_conn_status.setStyleSheet(
                    "color: orange; font-weight: bold;")
                self.status_bar.showMessage(
                    "⚠ VAROVÁNÍ: Komunikace se zařízením neodpovídá!", 0)
                self._log("⚠ Watchdog: komunikace zamrzla — doporučuji odpojit a znovu připojit")
        else:
            # Přenos skončil normálně — resetuj časovač a obnov barvu indikátoru
            if self._busy_since is not None:
                self._busy_since = None
                if self.worker.is_connected:
                    self.lbl_conn_status.setText("🔗 Připojeno")
                    self.lbl_conn_status.setStyleSheet(
                        "color: green; font-weight: bold;")
    def _monitor_outputs(self):
        """Periodicky čte hodnoty výstupů a porovnává je s odeslanými."""
        if self.worker.is_connected:
            threading.Thread(target=self.worker.read_outputs,
                             daemon=True).start()

    def _on_read_done(self, values: dict, msg: str):
        """Porovná přečtené hodnoty s odeslanými a zaloguje nesrovnalosti."""
        if not values:
            self._log(f"⚠ Hlídání: {msg}")
            return
        for ch_idx, read_raw in values.items():
            sent_raw = self.worker._last_raw.get(ch_idx)
            if sent_raw is None:
                continue
            if abs(read_raw - sent_raw) > 10:   # tolerance 10 RAW dílků
                self._log(
                    f"⚠ OUT{ch_idx+1}: odesláno {sent_raw}, "
                    f"přečteno {read_raw} — výstup neodpovídá!"
                )
                self.status_bar.showMessage(
                    f"VAROVÁNÍ: OUT{ch_idx+1} neodpovídá!", 5000
                )

    def _toggle_connect(self, checked: bool):
        """Spustí nebo ukončí Spinel TCP spojení se zařízením."""
        if checked:
            self._manual_disconnect = False   # připojujeme — není to ruční odpojení
            self._reconnect_timer.stop()      # zastav případný čekající auto-reconnect
            self._ever_connected = True   # uživatel se alespoň jednou připojil ručně
            self.btn_connect.setText("Odpojit")
            ip, port = self.edit_ip.text().strip(), self.spin_port.value()
            self._log(f"Připojuji se (Spinel TCP) na {ip}:{port}…")
            # Připojení spustíme ve vedlejším vlákně aby neblokoval GUI
            threading.Thread(target=self.worker.connect_device,
                             args=(ip, port), daemon=True).start()
        else:
            self._manual_disconnect = True    # ruční odpojení — auto-reconnect se nespustí
            self._reconnect_timer.stop()      # zastav případný čekající auto-reconnect
            self.btn_connect.setText("Připojit")
            # Před odpojením nastav všechny výstupy na nulu
            if self.worker.is_connected:
                for ch in self.ch_widgets:
                    threading.Thread(target=self.worker.write_output,
                                     args=(ch.ch, 0), daemon=True).start()
                import time
                time.sleep(0.2)   # krátká pauza aby se stihly odeslat
            self.worker.disconnect_device()

    def _on_connected(self, ok: bool, msg: str):
        """Aktualizuje indikátor připojení a zapíše stav do logu."""
        self._busy_since = None   # při změně stavu připojení vždy resetuj watchdog
        if ok:
            self.lbl_conn_status.setText("🔗 Připojeno")
            self.lbl_conn_status.setStyleSheet("color: green; font-weight: bold;")
            # Spusť hlídání pokud je interval nenulový
            if self._monitor_interval > 0:
                self._monitor_timer.start(self._monitor_interval * 1000)
        else:
            self.lbl_conn_status.setText("⛔ Odpojeno")
            self.lbl_conn_status.setStyleSheet("color: red; font-weight: bold;")
            self._monitor_timer.stop()   # zastav hlídání při odpojení
            self.btn_connect.blockSignals(True)
            self.btn_connect.setChecked(False)
            self.btn_connect.setText("Připojit")
            self.btn_connect.blockSignals(False)
        self._log(msg)
        self.status_bar.showMessage(msg)
        # Pokud došlo k neočekávanému odpojení, naplánuj auto-reconnect
        if not ok and not self._manual_disconnect:
            delay = 10   # počet sekund před dalším pokusem
            self._log(f"↻ Automatický pokus o opětovné připojení za {delay} s…")
            self._reconnect_timer.start(delay * 1000)   # QTimer pracuje v milisekundách

    def _auto_reconnect(self):
        """Automaticky se pokusí znovu připojit po neočekávaném odpojení.
        Spouští se časovačem _reconnect_timer — pouze při neočekávaném odpojení."""
        if self._manual_disconnect or self.worker.is_connected or not self._ever_connected:
            return   # ruční odpojení nebo již připojeno — nic nedělej
        ip   = self.edit_ip.text().strip()
        port = self.spin_port.value()
        self._log(f"↻ Pokouším se o opětovné připojení na {ip}:{port}…")
        # Nastavíme tlačítko do stavu "připojuji" aby GUI odpovídalo skutečnosti
        self.btn_connect.blockSignals(True)    # blockSignals zabrání spuštění _toggle_connect
        self.btn_connect.setChecked(True)
        self.btn_connect.setText("Odpojit")
        self.btn_connect.blockSignals(False)
        # Spustíme připojení ve vedlejším vlákně — stejně jako ruční připojení
        import threading
        threading.Thread(target=self.worker.connect_device,
                        args=(ip, port), daemon=True).start()

    def _queue_write(self, channel: int, raw: int, from_program: bool = False):
        """Přidá požadavek na zápis do fronty.
        from_program=True = požadavek z programového enginu — vždy se provede.
        from_program=False = požadavek z GUI — ignoruje se pokud běží program."""
        if not from_program and self._prog_running.get(channel, False):
            return   # GUI nemůže měnit výstup během běhu programu
        self._pending_writes[channel] = raw
        # Okamžitě vzorkuj graf pokud příkaz přišel z programu
        if from_program:
            self._force_sample(channel)
            if from_program:
                QTimer.singleShot(0, lambda ch=channel: self._force_sample(ch))

    def _flush_writes(self):
        """Odešle nahromaděné zápisy na zařízení přes Spinel TCP.
        Pokud není připojeno, zapíše simulační záznam do logu."""
        if not self._pending_writes:
            return
        if self.worker._busy.is_set():
            return   # předchozí zápis ještě probíhá — počkáme na další tik
        writes = dict(self._pending_writes)
        self._pending_writes.clear()
        now = time.monotonic() * 1000

        for ch, raw in writes.items():
            if self.worker.is_connected:
                # Skutečný Spinel zápis ve vedlejším vlákně
                threading.Thread(target=self.worker.write_output,
                                 args=(ch, raw), daemon=True).start()
            else:
                # Simulační mód — pouze zaloguj
                last = self._last_log_time.get(ch, 0.0)
                if self._log_rate_ms == 0 or (now - last) >= self._log_rate_ms:
                    self._on_write_done(ch, True, f"[SIM] RAW={raw}")
                    self._last_log_time[ch] = now

    def _send_range(self, channel: int, range_name: str):
        """Odešle požadavek na změnu hardwarového rozsahu výstupu přes Spinel."""
        if self.worker.is_connected:
            threading.Thread(target=self.worker.set_range,
                             args=(channel, range_name), daemon=True).start()
        else:
            self._log(f"[OFFLINE] Rozsah OUT{channel+1} → {range_name} (nezapojeno)")

    def _on_range_done(self, channel: int, ok: bool, msg: str):
        """Callback po dokončení nastavení rozsahu — zapíše výsledek do logu."""
        self._log(f"{'✓' if ok else '✗'} {msg}")
        if not ok:
            self.status_bar.showMessage(f"Chyba rozsahu OUT{channel+1}: {msg}", 3000)

    def _on_write_done(self, channel: int, ok: bool, msg: str):
        """Zapíše výsledek Spinel zápisu do logu s ohledem na vzorkovací frekvenci."""
        now = time.monotonic() * 1000
        last = self._last_log_time.get(channel, 0.0)
        if self._log_rate_ms == 0 or (now - last) >= self._log_rate_ms or not ok:
            self._log(f"{'✓' if ok else '✗'} OUT{channel+1}: {msg}")
            self._last_log_time[channel] = now
        if not ok:
            self.status_bar.showMessage(f"Chyba OUT{channel+1}: {msg}", 3000)

    def _set_log_rate(self):
        """Dialog pro nastavení vzorkovací frekvence logu (z menu Možnosti)."""
        from PyQt6.QtWidgets import QInputDialog
        current = self._log_rate_ms
        val, ok = QInputDialog.getInt(
            self,
            "Vzorkovací frekvence logu",
            "Minimální interval mezi záznamy v logu [ms]:\n"
            "(0 = loguj každou změnu, 500 = max 2× za sekundu, 1000 = max 1× za sekundu)",
            current, 0, 60000, 100
        )
        if ok:
            self._log_rate_ms = val
            self.settings.setValue("log_rate_ms", val)
            self._log(f"Vzorkovací frekvence logu nastavena na {val} ms "
                      f"({'bez omezení' if val == 0 else f'max {1000//val if val else 0}×/s'})")
    
    def _show_stop_config(self):
        """Zobrazí dialogové okno pro nastavení chování tlačítka Zastavit."""
        dlg = QDialog(self)
        dlg.setWindowTitle("Chování tlačítka Zastavit")
        dlg.setModal(True)
        lay = QVBoxLayout(dlg)
        lay.setSpacing(8)

        lay.addWidget(QLabel("Co se stane s výstupem po zastavení programu:"))

        # OUT1
        grp1 = QGroupBox("OUT1")
        grp1_lay = QVBoxLayout(grp1)
        self._rb_zero1 = QRadioButton("Nastavit na minimum rozsahu")
        self._rb_keep1 = QRadioButton("Ponechat stávající hodnotu")
        self._rb_zero1.setChecked(self._stop_to_zero[0])
        self._rb_keep1.setChecked(not self._stop_to_zero[0])
        grp1_lay.addWidget(self._rb_zero1)
        grp1_lay.addWidget(self._rb_keep1)
        lay.addWidget(grp1)

        # OUT2
        grp2 = QGroupBox("OUT2")
        grp2_lay = QVBoxLayout(grp2)
        self._rb_zero2 = QRadioButton("Nastavit na minimum rozsahu")
        self._rb_keep2 = QRadioButton("Ponechat stávající hodnotu")
        self._rb_zero2.setChecked(self._stop_to_zero[1])
        self._rb_keep2.setChecked(not self._stop_to_zero[1])
        grp2_lay.addWidget(self._rb_zero2)
        grp2_lay.addWidget(self._rb_keep2)
        lay.addWidget(grp2)

        # Tlačítka OK/Zrušit
        btn_row = QHBoxLayout()
        btn_ok = QPushButton("OK")
        btn_ok.setDefault(True)
        btn_ok.clicked.connect(dlg.accept)
        btn_cancel = QPushButton("Zrušit")
        btn_cancel.clicked.connect(dlg.reject)
        btn_row.addStretch()
        btn_row.addWidget(btn_ok)
        btn_row.addWidget(btn_cancel)
        lay.addLayout(btn_row)

        if dlg.exec() == QDialog.DialogCode.Accepted:
            self._stop_to_zero[0] = self._rb_zero1.isChecked()
            self._stop_to_zero[1] = self._rb_zero2.isChecked()
            self._settings.setValue("stop_to_zero_0", self._stop_to_zero[0])
            self._settings.setValue("stop_to_zero_1", self._stop_to_zero[1])
            self._log(
                f"Nastavení Zastavit: "
                f"OUT1={'minimum' if self._stop_to_zero[0] else 'ponechat'}, "
                f"OUT2={'minimum' if self._stop_to_zero[1] else 'ponechat'}"
            )

    def _set_save_dir(self):
        """Nastaví výchozí složku pro ukládání souborů."""
        from PyQt6.QtWidgets import QFileDialog
        folder = QFileDialog.getExistingDirectory(
            self, "Vyber složku pro ukládání souborů", self._save_dir)
        if folder:
            self._save_dir = folder
            self._settings.setValue("save_dir", folder)   # ulož trvale
            self._log(f"📁 Složka pro ukládání: {folder}")
            self.graph_out1.save_dir = folder
            self.graph_out2.save_dir = folder

    # ── Log ────────────────────────────────────────────────────────────────

    def _log(self, msg: str):
        """Zapíše zprávu s časovou značkou do textového pole logu.
        Automaticky scrolluje na konec pouze pokud uživatel není v historii."""
        self.log_edit.append(f"[{time.strftime('%H:%M:%S')}] {msg}")
        logger.debug(msg)
        sb = self.log_edit.verticalScrollBar()
        # Scrolluj na konec pouze pokud je posuvník již na konci (nebo blízko)
        # Pokud uživatel scrolluje v historii, nechej ho číst v klidu
        if sb.value() >= sb.maximum() - 10:
            sb.setValue(sb.maximum())

    def _save_log(self):
        """Uloží obsah logu do textového souboru."""
        default = os.path.join(self.log_save_dir,
                               f"da2eth_log_{time.strftime('%Y%m%d_%H%M%S')}.txt")
        path, _ = QFileDialog.getSaveFileName(
            self, "Uložit log", default,
            "Textové soubory (*.txt);;Všechny soubory (*)"
        )
        if path:
            try:
                with open(path, "w", encoding="utf-8") as f:
                    f.write(self.log_edit.toPlainText())
                self._log(f"Log uložen: {path}")
                self.log_save_dir = os.path.dirname(path)
                self.settings.setValue("log_save_dir", self.log_save_dir)
            except Exception as e:
                QMessageBox.warning(self, "Chyba ukládání", str(e))

    def _set_monitor_interval(self):
        """Dialog pro nastavení intervalu hlídání výstupů."""
        from PyQt6.QtWidgets import QInputDialog
        val, ok = QInputDialog.getInt(
            self, "Hlídání výstupů",
            "Interval kontroly výstupů [s]:\n(0 = vypnuto)",
            self._monitor_interval, 0, 3600, 1
        )
        if ok:
            self._monitor_interval = val
            self.settings.setValue("monitor_interval", val)
            if self.worker.is_connected and val > 0:
                self._monitor_timer.start(val * 1000)
            else:
                self._monitor_timer.stop()
            self._log(f"Interval hlídání nastaven na {val} s "
                      f"({'vypnuto' if val == 0 else f'každých {val} s'})")            

    def _choose_log_dir(self):
        """Dialog pro výběr složky pro ukládání logů (z menu Možnosti)."""
        folder = QFileDialog.getExistingDirectory(
            self, "Vybrat složku pro logy", self.log_save_dir)
        if folder:
            self.log_save_dir = folder
            self.settings.setValue("log_save_dir", folder)
            self._log(f"Složka pro logy: {folder}")

    # ── Nastavení ──────────────────────────────────────────────────────────

    def _load_settings(self):
        """Načte uložená nastavení z minulého spuštění."""
        self.edit_ip.setText(self.settings.value("ip", "192.168.1.254"))
        self.spin_port.setValue(int(self.settings.value("port", 10001)))
        for i, ch in enumerate(self.ch_widgets):
            rng = self.settings.value(f"ch{i}_range", "0–10 V")
            idx = ch.cmb_range.findText(rng)
            if idx >= 0:
                ch.cmb_range.setCurrentIndex(idx)
            ch.spin_step.setValue(float(self.settings.value(f"ch{i}_step", 100.0)))
            ch.spin_origin.setValue(float(self.settings.value(f"ch{i}_origin", 0.0)))

    def closeEvent(self, event):
        """Při zavření uloží nastavení a odpojí zařízení."""
        self.settings.setValue("ip", self.edit_ip.text())
        self.settings.setValue("port", self.spin_port.value())
        for i, ch in enumerate(self.ch_widgets):
            self.settings.setValue(f"ch{i}_range", ch.cmb_range.currentText())
            self.settings.setValue(f"ch{i}_step", ch.spin_step.value())
            self.settings.setValue(f"ch{i}_origin", ch.spin_origin.value())
        self.worker.disconnect_device()
        super().closeEvent(event)

# ── Spuštění ────────────────────────────────────────────────────────────────

def main():
    app = QApplication(sys.argv)
    app.setApplicationName("DA2ETH Controller")
    app.setOrganizationName("Papouch")
    app.setStyleSheet(
        "QToolTip { color: #222; background-color: #fffde7; "
        "border: 1px solid #aaa; padding: 4px; font-size: 10pt; }"
        "QScrollBar:vertical { background: #6d6d75; width: 12px; border-radius: 6px; }"
        "QScrollBar::handle:vertical { background: #7eb8e8; border-radius: 6px; min-height: 20px; }"
        "QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0px; }"
    )
    app.setStyle("Fusion")
    pal = QPalette()
    pal.setColor(QPalette.ColorRole.Window,          QColor(45, 45, 48))
    pal.setColor(QPalette.ColorRole.WindowText,      QColor(230, 230, 230))
    pal.setColor(QPalette.ColorRole.Base,            QColor(30, 30, 30))
    pal.setColor(QPalette.ColorRole.AlternateBase,   QColor(53, 53, 53))
    pal.setColor(QPalette.ColorRole.ToolTipBase,     QColor(255, 255, 220))
    pal.setColor(QPalette.ColorRole.ToolTipText,     QColor(0, 0, 0))
    pal.setColor(QPalette.ColorRole.Text,            QColor(230, 230, 230))
    pal.setColor(QPalette.ColorRole.Button,          QColor(60, 60, 65))
    pal.setColor(QPalette.ColorRole.ButtonText,      QColor(230, 230, 230))
    pal.setColor(QPalette.ColorRole.BrightText,      QColor(255, 80, 80))
    pal.setColor(QPalette.ColorRole.Link,            QColor(42, 130, 218))
    pal.setColor(QPalette.ColorRole.Highlight,       QColor(42, 130, 218))
    pal.setColor(QPalette.ColorRole.HighlightedText, QColor(0, 0, 0))
    app.setPalette(pal)
    window = DA2ETHController()
    window.show()
    sys.exit(app.exec())

if __name__ == "__main__":
    main()