--logscale enabled by default

RFG_ADC_dataplotter.py

@@ -33,13 +33,18 @@ import numpy as np
 
 WF_WIDTH = 1000  # максимальное число точек в ряду водопада
 FFT_LEN = 1024   # длина БПФ для спектра/водопада спектров
+LOG_BASE = 10.0
+LOG_SCALER = 0.001  # int32 значения приходят в fixed-point лог-шкале с шагом 1e-3
+LOG_POSTSCALER = 1000
+LOG_EXP_LIMIT = 300.0  # запас до переполнения float64 при возведении LOG_BASE в степень
 # Порог для инверсии сырых данных: если среднее значение свипа ниже порога —
 # считаем, что сигнал «меньше нуля» и домножаем свип на -1
 DATA_INVERSION_THRASHOLD = 10.0
 
 Number = Union[int, float]
 SweepInfo = Dict[str, Any]
-SweepPacket = Tuple[np.ndarray, SweepInfo]
+SweepAuxCurves = Optional[Tuple[np.ndarray, np.ndarray]]
+SweepPacket = Tuple[np.ndarray, SweepInfo, SweepAuxCurves]
 
 
 def _format_status_kv(data: Mapping[str, Any]) -> str:
@@ -85,6 +90,154 @@ def _parse_spec_clip(spec: Optional[str]) -> Optional[Tuple[float, float]]:
         return None
 
 
+def _log_value_to_linear(value: int) -> float:
+    """Преобразовать fixed-point логарифмическое значение в линейную шкалу."""
+    exponent = max(-LOG_EXP_LIMIT, min(LOG_EXP_LIMIT, float(value) * LOG_SCALER))
+    return float(LOG_BASE ** exponent)
+
+
+def _log_pair_to_sweep(avg_1: int, avg_2: int) -> float:
+    """Разность двух логарифмических усреднений в линейной шкале."""
+    return (_log_value_to_linear(avg_1) - _log_value_to_linear(avg_2))*LOG_POSTSCALER
+
+
+def _compute_auto_ylim(*series_list: Optional[np.ndarray]) -> Optional[Tuple[float, float]]:
+    """Общий Y-диапазон по всем переданным кривым с небольшим запасом."""
+    y_min: Optional[float] = None
+    y_max: Optional[float] = None
+    for series in series_list:
+        if series is None:
+            continue
+        arr = np.asarray(series)
+        if arr.size == 0:
+            continue
+        finite = arr[np.isfinite(arr)]
+        if finite.size == 0:
+            continue
+        cur_min = float(np.min(finite))
+        cur_max = float(np.max(finite))
+        y_min = cur_min if y_min is None else min(y_min, cur_min)
+        y_max = cur_max if y_max is None else max(y_max, cur_max)
+
+    if y_min is None or y_max is None:
+        return None
+    if y_min == y_max:
+        pad = max(1.0, abs(y_min) * 0.05)
+    else:
+        pad = 0.05 * (y_max - y_min)
+    return (y_min - pad, y_max + pad)
+
+
+def _normalize_sweep_simple(raw: np.ndarray, calib: np.ndarray) -> np.ndarray:
+    """Простая нормировка: поэлементное деление raw/calib."""
+    w = min(raw.size, calib.size)
+    if w <= 0:
+        return raw
+    out = np.full_like(raw, np.nan, dtype=np.float32)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        out[:w] = raw[:w] / calib[:w]
+    out = np.nan_to_num(out, nan=np.nan, posinf=np.nan, neginf=np.nan)
+    return out
+
+
+def _build_calib_envelopes(calib: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    """Оценить нижнюю/верхнюю огибающие калибровочной кривой."""
+    n = int(calib.size)
+    if n <= 0:
+        empty = np.zeros((0,), dtype=np.float32)
+        return empty, empty
+
+    y = np.asarray(calib, dtype=np.float32)
+    finite = np.isfinite(y)
+    if not np.any(finite):
+        zeros = np.zeros_like(y, dtype=np.float32)
+        return zeros, zeros
+
+    if not np.all(finite):
+        x = np.arange(n, dtype=np.float32)
+        y = y.copy()
+        y[~finite] = np.interp(x[~finite], x[finite], y[finite]).astype(np.float32)
+
+    if n < 3:
+        return y.copy(), y.copy()
+
+    dy = np.diff(y)
+    s = np.sign(dy).astype(np.int8, copy=False)
+
+    if np.any(s == 0):
+        for i in range(1, s.size):
+            if s[i] == 0:
+                s[i] = s[i - 1]
+        for i in range(s.size - 2, -1, -1):
+            if s[i] == 0:
+                s[i] = s[i + 1]
+        s[s == 0] = 1
+
+    max_idx = np.where((s[:-1] > 0) & (s[1:] < 0))[0] + 1
+    min_idx = np.where((s[:-1] < 0) & (s[1:] > 0))[0] + 1
+
+    x = np.arange(n, dtype=np.float32)
+
+    def _interp_nodes(nodes: np.ndarray) -> np.ndarray:
+        if nodes.size == 0:
+            idx = np.array([0, n - 1], dtype=np.int64)
+        else:
+            idx = np.unique(np.concatenate(([0], nodes, [n - 1]))).astype(np.int64)
+        return np.interp(x, idx.astype(np.float32), y[idx]).astype(np.float32)
+
+    upper = _interp_nodes(max_idx)
+    lower = _interp_nodes(min_idx)
+
+    swap = lower > upper
+    if np.any(swap):
+        tmp = upper[swap].copy()
+        upper[swap] = lower[swap]
+        lower[swap] = tmp
+
+    return lower, upper
+
+
+def _normalize_sweep_projector(raw: np.ndarray, calib: np.ndarray) -> np.ndarray:
+    """Нормировка через проекцию между огибающими калибровки в диапазон [-1, +1]."""
+    w = min(raw.size, calib.size)
+    if w <= 0:
+        return raw
+
+    out = np.full_like(raw, np.nan, dtype=np.float32)
+    raw_seg = np.asarray(raw[:w], dtype=np.float32)
+    lower, upper = _build_calib_envelopes(np.asarray(calib[:w], dtype=np.float32))
+    span = upper - lower
+
+    finite_span = span[np.isfinite(span) & (span > 0)]
+    if finite_span.size > 0:
+        eps = max(float(np.median(finite_span)) * 1e-6, 1e-9)
+    else:
+        eps = 1e-9
+
+    valid = (
+        np.isfinite(raw_seg)
+        & np.isfinite(lower)
+        & np.isfinite(upper)
+        & (span > eps)
+    )
+    if np.any(valid):
+        proj = np.empty_like(raw_seg, dtype=np.float32)
+        proj[valid] = ((2.0 * (raw_seg[valid] - lower[valid]) / span[valid]) - 1.0) * 1000.0
+        proj[valid] = np.clip(proj[valid], -1000.0, 1000.0)
+        proj[~valid] = np.nan
+        out[:w] = proj
+
+    return out
+
+
+def _normalize_by_calib(raw: np.ndarray, calib: np.ndarray, norm_type: str) -> np.ndarray:
+    """Нормировка свипа по выбранному алгоритму."""
+    nt = str(norm_type).strip().lower()
+    if nt == "simple":
+        return _normalize_sweep_simple(raw, calib)
+    return _normalize_sweep_projector(raw, calib)
+
+
 def try_open_pyserial(path: str, baud: int, timeout: float):
     try:
         import serial  # type: ignore
@@ -274,6 +427,8 @@ class SweepReader(threading.Thread):
         out_queue: Queue[SweepPacket],
         stop_event: threading.Event,
         fancy: bool = False,
+        bin_mode: bool = False,
+        logscale: bool = False,
     ):
         super().__init__(daemon=True)
         self._port_path = port_path
@@ -282,12 +437,26 @@ class SweepReader(threading.Thread):
         self._stop = stop_event
         self._src: Optional[SerialLineSource] = None
         self._fancy = bool(fancy)
+        self._bin_mode = bool(bin_mode)
+        self._logscale = bool(logscale)
         self._max_width: int = 0
         self._sweep_idx: int = 0
         self._last_sweep_ts: Optional[float] = None
         self._n_valid_hist = deque()
 
-    def _finalize_current(self, xs, ys, channels: Optional[set[int]]):
+    @staticmethod
+    def _u32_to_i32(v: int) -> int:
+        """Преобразование 32-bit слова в знаковое значение."""
+        return v - 0x1_0000_0000 if (v & 0x8000_0000) else v
+
+    def _finalize_current(
+        self,
+        xs,
+        ys,
+        channels: Optional[set[int]],
+        raw_curves: Optional[Tuple[list[int], list[int]]] = None,
+        apply_inversion: bool = True,
+    ):
         if not xs:
             return
         ch_list = sorted(channels) if channels else [0]
@@ -296,17 +465,43 @@ class SweepReader(threading.Thread):
         width = max_x + 1
         self._max_width = max(self._max_width, width)
         target_width = self._max_width if self._fancy else width
-        # Быстрый векторизованный путь
-        sweep = np.full((target_width,), np.nan, dtype=np.float32)
+
+        def _scatter(values, dtype) -> np.ndarray:
+            series = np.full((target_width,), np.nan, dtype=dtype)
             try:
                 idx = np.asarray(xs, dtype=np.int64)
-            vals = np.asarray(ys, dtype=np.float32)
-            sweep[idx] = vals
+                vals = np.asarray(values, dtype=dtype)
+                series[idx] = vals
             except Exception:
-            # Запасной путь
-            for x, y in zip(xs, ys):
+                for x, y in zip(xs, values):
                     if 0 <= x < target_width:
-                    sweep[x] = float(y)
+                        series[x] = y
+            return series
+
+        def _fill_missing(series: np.ndarray):
+            known = ~np.isnan(series)
+            if not np.any(known):
+                return
+            known_idx = np.nonzero(known)[0]
+            for i0, i1 in zip(known_idx[:-1], known_idx[1:]):
+                if i1 - i0 > 1:
+                    avg = (series[i0] + series[i1]) * 0.5
+                    series[i0 + 1 : i1] = avg
+            first_idx = int(known_idx[0])
+            last_idx = int(known_idx[-1])
+            if first_idx > 0:
+                series[:first_idx] = series[first_idx]
+            if last_idx < series.size - 1:
+                series[last_idx + 1 :] = series[last_idx]
+
+        # Быстрый векторизованный путь
+        sweep = _scatter(ys, np.float32)
+        aux_curves: SweepAuxCurves = None
+        if raw_curves is not None:
+            aux_curves = (
+                _scatter(raw_curves[0], np.float32),
+                _scatter(raw_curves[1], np.float32),
+            )
         # Метрики валидных точек до заполнения пропусков
         finite_pre = np.isfinite(sweep)
         n_valid_cur = int(np.count_nonzero(finite_pre))
@@ -314,30 +509,22 @@ class SweepReader(threading.Thread):
         # Дополнительная обработка пропусков: при --fancy заполняем внутренние разрывы, края и дотягиваем до максимальной длины
         if self._fancy:
             try:
-                known = ~np.isnan(sweep)
-                if np.any(known):
-                    known_idx = np.nonzero(known)[0]
-                    # Для каждой пары соседних известных индексов заполним промежуток средним значением
-                    for i0, i1 in zip(known_idx[:-1], known_idx[1:]):
-                        if i1 - i0 > 1:
-                            avg = (sweep[i0] + sweep[i1]) * 0.5
-                            sweep[i0 + 1 : i1] = avg
-                    first_idx = int(known_idx[0])
-                    last_idx = int(known_idx[-1])
-                    if first_idx > 0:
-                        sweep[:first_idx] = sweep[first_idx]
-                    if last_idx < sweep.size - 1:
-                        sweep[last_idx + 1 :] = sweep[last_idx]
+                _fill_missing(sweep)
+                if aux_curves is not None:
+                    _fill_missing(aux_curves[0])
+                    _fill_missing(aux_curves[1])
             except Exception:
                 # В случае ошибки просто оставляем как есть
                 pass
         # Инверсия данных при «отрицательном» уровне (среднее ниже порога)
+        if apply_inversion:
             try:
                 m = float(np.nanmean(sweep))
                 if np.isfinite(m) and m < DATA_INVERSION_THRASHOLD:
                     sweep *= -1.0
             except Exception:
                 pass
+        #sweep = np.abs(sweep)
         #sweep -= float(np.nanmean(sweep))
 
         # Метрики для статусной строки (вид словаря: переменная -> значение)
@@ -381,45 +568,31 @@ class SweepReader(threading.Thread):
 
         # Кладём готовый свип (если очередь полна — выбрасываем самый старый)
         try:
-            self._q.put_nowait((sweep, info))
+            self._q.put_nowait((sweep, info, aux_curves))
         except Full:
             try:
                 _ = self._q.get_nowait()
             except Exception:
                 pass
             try:
-                self._q.put_nowait((sweep, info))
+                self._q.put_nowait((sweep, info, aux_curves))
             except Exception:
                 pass
 
-    def run(self):
-        # Состояние текущего свипа
+    def _run_ascii_stream(self, chunk_reader: SerialChunkReader):
         xs: list[int] = []
         ys: list[int] = []
         cur_channel: Optional[int] = None
         cur_channels: set[int] = set()
-
-        try:
-            self._src = SerialLineSource(self._port_path, self._baud, timeout=1.0)
-            sys.stderr.write(f"[info] Открыл порт {self._port_path} ({self._src._using})\n")
-        except Exception as e:
-            sys.stderr.write(f"[error] {e}\n")
-            return
-
-        try:
-            # Быстрый неблокирующий дренаж порта с разбором по байтам
-            chunk_reader = SerialChunkReader(self._src)
         buf = bytearray()
         while not self._stop.is_set():
             data = chunk_reader.read_available()
             if data:
                 buf += data
             else:
-                    # Короткая уступка CPU, если нет новых данных
                 time.sleep(0.0005)
                 continue
 
-                # Обрабатываем все полные строки
             while True:
                 nl = buf.find(b"\n")
                 if nl == -1:
@@ -466,15 +639,198 @@ class SweepReader(threading.Thread):
                         xs.append(x)
                         ys.append(y)
 
-                # Защита от переполнения буфера при отсутствии переводов строки
             if len(buf) > 1_000_000:
                 del buf[:-262144]
-        finally:
-            try:
-                # Завершаем оставшийся свип
+
         self._finalize_current(xs, ys, cur_channels)
-            except Exception:
-                pass
+
+    def _run_binary_stream(self, chunk_reader: SerialChunkReader):
+        xs: list[int] = []
+        ys: list[int] = []
+        cur_channel: Optional[int] = None
+        cur_channels: set[int] = set()
+        words = deque()
+
+        buf = bytearray()
+        while not self._stop.is_set():
+            data = chunk_reader.read_available()
+            if data:
+                buf += data
+            else:
+                time.sleep(0.0005)
+                continue
+
+            usable = len(buf) & ~1
+            if usable == 0:
+                continue
+
+            i = 0
+            while i < usable:
+                w = int(buf[i]) | (int(buf[i + 1]) << 8)
+                words.append(w)
+                i += 2
+
+            # Бинарный протокол:
+            #   старт свипа (актуальный): 0xFFFF, 0xFFFF, 0xFFFF, (ch<<8)|0x0A
+            #   старт свипа (legacy):     0xFFFF, 0xFFFF, channel, 0x0A0A
+            #   точка: step, value_hi, value_lo, 0x000A
+            while len(words) >= 4:
+                w0 = int(words[0])
+                w1 = int(words[1])
+                w2 = int(words[2])
+                w3 = int(words[3])
+
+                if w0 == 0xFFFF and w1 == 0xFFFF and w2 == 0xFFFF and (w3 & 0x00FF) == 0x000A:
+                    self._finalize_current(xs, ys, cur_channels)
+                    xs.clear()
+                    ys.clear()
+                    cur_channels.clear()
+                    cur_channel = (w3 >> 8) & 0x00FF
+                    cur_channels.add(cur_channel)
+                    for _ in range(4):
+                        words.popleft()
+                    continue
+
+                if w0 == 0xFFFF and w1 == 0xFFFF and w3 == 0x0A0A:
+                    self._finalize_current(xs, ys, cur_channels)
+                    xs.clear()
+                    ys.clear()
+                    cur_channels.clear()
+                    cur_channel = w2
+                    cur_channels.add(cur_channel)
+                    for _ in range(4):
+                        words.popleft()
+                    continue
+
+                if w3 == 0x000A:
+                    if cur_channel is not None:
+                        cur_channels.add(cur_channel)
+                    xs.append(w0)
+                    value_u32 = (w1 << 16) | w2
+                    ys.append(self._u32_to_i32(value_u32))
+                    for _ in range(4):
+                        words.popleft()
+                    continue
+
+                # Поток может начаться с середины пакета; сдвигаемся по слову до ресинхронизации.
+                words.popleft()
+
+            del buf[:usable]
+            if len(buf) > 1_000_000:
+                del buf[:-262144]
+
+        self._finalize_current(xs, ys, cur_channels)
+
+    def _run_logscale_binary_stream(self, chunk_reader: SerialChunkReader):
+        xs: list[int] = []
+        ys: list[float] = []
+        avg_1_vals: list[int] = []
+        avg_2_vals: list[int] = []
+        cur_channel: Optional[int] = None
+        cur_channels: set[int] = set()
+        words = deque()
+
+        buf = bytearray()
+        while not self._stop.is_set():
+            data = chunk_reader.read_available()
+            if data:
+                buf += data
+            else:
+                time.sleep(0.0005)
+                continue
+
+            usable = len(buf) & ~1
+            if usable == 0:
+                continue
+
+            i = 0
+            while i < usable:
+                w = int(buf[i]) | (int(buf[i + 1]) << 8)
+                words.append(w)
+                i += 2
+
+            # Бинарный logscale-протокол:
+            #   старт свипа: 0xFFFF x5, затем (ch<<8)|0x0A
+            #   точка: step, avg1_hi, avg1_lo, avg2_hi, avg2_lo, 0x000A
+            while len(words) >= 6:
+                w0 = int(words[0])
+                w1 = int(words[1])
+                w2 = int(words[2])
+                w3 = int(words[3])
+                w4 = int(words[4])
+                w5 = int(words[5])
+
+                if (
+                    w0 == 0xFFFF
+                    and w1 == 0xFFFF
+                    and w2 == 0xFFFF
+                    and w3 == 0xFFFF
+                    and w4 == 0xFFFF
+                    and (w5 & 0x00FF) == 0x000A
+                ):
+                    self._finalize_current(
+                        xs,
+                        ys,
+                        cur_channels,
+                        raw_curves=(avg_1_vals, avg_2_vals),
+                        apply_inversion=False,
+                    )
+                    xs.clear()
+                    ys.clear()
+                    avg_1_vals.clear()
+                    avg_2_vals.clear()
+                    cur_channels.clear()
+                    cur_channel = (w5 >> 8) & 0x00FF
+                    cur_channels.add(cur_channel)
+                    for _ in range(6):
+                        words.popleft()
+                    continue
+
+                if w5 == 0x000A:
+                    if cur_channel is not None:
+                        cur_channels.add(cur_channel)
+                    avg_1 = self._u32_to_i32((w1 << 16) | w2)
+                    avg_2 = self._u32_to_i32((w3 << 16) | w4)
+                    xs.append(w0)
+                    avg_1_vals.append(avg_1)
+                    avg_2_vals.append(avg_2)
+                    ys.append(_log_pair_to_sweep(avg_1, avg_2))
+                    #ys.append(LOG_BASE**(avg_1/LOG_SCALER) - LOG_BASE**(avg_2/LOG_SCALER))
+                    for _ in range(6):
+                        words.popleft()
+                    continue
+
+                words.popleft()
+
+            del buf[:usable]
+            if len(buf) > 1_000_000:
+                del buf[:-262144]
+
+        self._finalize_current(
+            xs,
+            ys,
+            cur_channels,
+            raw_curves=(avg_1_vals, avg_2_vals),
+            apply_inversion=False,
+        )
+
+    def run(self):
+        try:
+            self._src = SerialLineSource(self._port_path, self._baud, timeout=1.0)
+            sys.stderr.write(f"[info] Открыл порт {self._port_path} ({self._src._using})\n")
+        except Exception as e:
+            sys.stderr.write(f"[error] {e}\n")
+            return
+
+        try:
+            chunk_reader = SerialChunkReader(self._src)
+            if self._logscale:
+                self._run_logscale_binary_stream(chunk_reader)
+            elif self._bin_mode:
+                self._run_binary_stream(chunk_reader)
+            else:
+                self._run_ascii_stream(chunk_reader)
+        finally:
             try:
                 if self._src is not None:
                     self._src.close()
@@ -532,6 +888,30 @@ def main():
         default="auto",
         help="Графический бэкенд: pyqtgraph (pg) — быстрее; matplotlib (mpl) — совместимый. По умолчанию auto",
     )
+    parser.add_argument(
+        "--norm-type",
+        choices=["projector", "simple"],
+        default="projector",
+        help="Тип нормировки: projector (по огибающим в [-1,+1]) или simple (raw/calib)",
+    )
+    parser.add_argument(
+        "--bin",
+        dest="bin_mode",
+        action="store_true",
+        help=(
+            "Бинарный протокол: старт свипа 0xFFFF,0xFFFF,0xFFFF,(CH<<8)|0x0A; "
+            "точки step,uint32(hi16,lo16),0x000A"
+        ),
+    )
+    parser.add_argument(
+        "--logscale",
+        action="store_true",
+        default=True,
+        help=(
+            "Новый бинарный протокол: точка несёт пару int32 (avg_1, avg_2), "
+            "а свип считается как 10**(avg_1*0.001) - 10**(avg_2*0.001)"
+        ),
+    )
 
     args = parser.parse_args()
 
@@ -557,7 +937,15 @@ def main():
     # Очередь завершённых свипов и поток чтения
     q: Queue[SweepPacket] = Queue(maxsize=1000)
     stop_event = threading.Event()
-    reader = SweepReader(args.port, args.baud, q, stop_event, fancy=bool(args.fancy))
+    reader = SweepReader(
+        args.port,
+        args.baud,
+        q,
+        stop_event,
+        fancy=bool(args.fancy),
+        bin_mode=bool(args.bin_mode),
+        logscale=bool(args.logscale),
+    )
     reader.start()
 
     # Графика
@@ -569,6 +957,7 @@ def main():
 
     # Состояние для отображения
     current_sweep_raw: Optional[np.ndarray] = None
+    current_aux_curves: SweepAuxCurves = None
     current_sweep_norm: Optional[np.ndarray] = None
     last_calib_sweep: Optional[np.ndarray] = None
     current_info: Optional[SweepInfo] = None
@@ -592,6 +981,7 @@ def main():
     ymax_slider = None
     contrast_slider = None
     calib_enabled = False
+    norm_type = str(getattr(args, "norm_type", "projector")).strip().lower()
     cb = None
 
     # Статусная строка (внизу окна)
@@ -606,11 +996,13 @@ def main():
     )
 
     # Линейный график последнего свипа
+    line_avg1_obj, = ax_line.plot([], [], lw=1, color="0.65")
+    line_avg2_obj, = ax_line.plot([], [], lw=1, color="0.45")
     line_obj, = ax_line.plot([], [], lw=1, color="tab:blue")
     line_calib_obj, = ax_line.plot([], [], lw=1, color="tab:red")
     line_norm_obj, = ax_line.plot([], [], lw=1, color="tab:green")
     ax_line.set_title("Сырые данные", pad=1)
-    ax_line.set_xlabel("F")
+    ax_line.set_xlabel("ГГц")
     ax_line.set_ylabel("")
     channel_text = ax_line.text(
         0.98,
@@ -626,8 +1018,8 @@ def main():
     # Линейный график спектра текущего свипа
     fft_line_obj, = ax_fft.plot([], [], lw=1)
     ax_fft.set_title("FFT", pad=1)
-    ax_fft.set_xlabel("X")
-    ax_fft.set_ylabel("Амплитуда, дБ")
+    ax_fft.set_xlabel("Время")
+    ax_fft.set_ylabel("дБ")
 
     # Диапазон по Y для последнего свипа: авто по умолчанию (поддерживает отрицательные значения)
     fixed_ylim: Optional[Tuple[float, float]] = None
@@ -651,7 +1043,7 @@ def main():
     )
     ax_img.set_title("Сырые данные", pad=12)
     ax_img.set_xlabel("")
-    ax_img.set_ylabel("частота")
+    ax_img.set_ylabel("ГГц")
     # Не показываем численные значения по времени на водопаде сырых данных
     try:
         ax_img.tick_params(axis="x", labelbottom=False)
@@ -674,15 +1066,9 @@ def main():
         ax_spec.tick_params(axis="x", labelbottom=False)
     except Exception:
         pass
+
     def _normalize_sweep(raw: np.ndarray, calib: np.ndarray) -> np.ndarray:
-        w = min(raw.size, calib.size)
-        if w <= 0:
-            return raw
-        out = np.full_like(raw, np.nan, dtype=np.float32)
-        with np.errstate(divide="ignore", invalid="ignore"):
-            out[:w] = raw[:w] / calib[:w]
-        out = np.nan_to_num(out, nan=np.nan, posinf=np.nan, neginf=np.nan)
-        return out
+        return _normalize_by_calib(raw, calib, norm_type=norm_type)
 
     def _set_calib_enabled():
         nonlocal calib_enabled, current_sweep_norm
@@ -734,15 +1120,15 @@ def main():
         if ring is not None:
             return
         width = WF_WIDTH
-        x_shared = np.arange(width, dtype=np.int32)
+        x_shared = np.linspace(3.3, 14.3, width, dtype=np.float32)
         ring = np.full((max_sweeps, width), np.nan, dtype=np.float32)
         ring_time = np.full((max_sweeps,), np.nan, dtype=np.float64)
         head = 0
         # Обновляем изображение под новые размеры: время по X (горизонталь), X по Y
         img_obj.set_data(np.zeros((width, max_sweeps), dtype=np.float32))
-        img_obj.set_extent((0, max_sweeps - 1, 0, width - 1 if width > 0 else 1))
+        img_obj.set_extent((0, max_sweeps - 1, 3.3, 14.3))
         ax_img.set_xlim(0, max_sweeps - 1)
-        ax_img.set_ylim(0, max(1, width - 1))
+        ax_img.set_ylim(3.3, 14.3)
         # FFT буферы: время по X, бин по Y
         ring_fft = np.full((max_sweeps, fft_bins), np.nan, dtype=np.float32)
         img_fft_obj.set_data(np.zeros((fft_bins, max_sweeps), dtype=np.float32))
@@ -752,7 +1138,7 @@ def main():
         freq_shared = np.arange(fft_bins, dtype=np.int32)
 
     def _visible_levels_matplotlib(data: np.ndarray, axis) -> Optional[Tuple[float, float]]:
-        """(vmin, vmax) по текущей видимой области imshow (без накопления по времени)."""
+        """(vmin, vmax) по центральным 90% значений в видимой области imshow."""
         if data.size == 0:
             return None
         ny, nx = data.shape[0], data.shape[1]
@@ -777,8 +1163,8 @@ def main():
         if not finite.any():
             return None
         vals = sub[finite]
-        vmin = float(np.min(vals))
-        vmax = float(np.max(vals))
+        vmin = float(np.nanpercentile(vals, 5))
+        vmax = float(np.nanpercentile(vals, 95))
         if not (np.isfinite(vmin) and np.isfinite(vmax)) or vmin == vmax:
             return None
         return (vmin, vmax)
@@ -814,7 +1200,7 @@ def main():
                 # Окно Хэннинга
                 win = np.hanning(take_fft).astype(np.float32)
                 fft_in[:take_fft] = seg * win
-                spec = np.fft.rfft(fft_in)
+                spec = np.fft.ifft(fft_in)
                 mag = np.abs(spec).astype(np.float32)
                 fft_row = 20.0 * np.log10(mag + 1e-9)
                 if fft_row.shape[0] != bins:
@@ -831,15 +1217,16 @@ def main():
                 y_max_fft = float(fr_max)
 
     def drain_queue():
-        nonlocal current_sweep_raw, current_sweep_norm, current_info, last_calib_sweep
+        nonlocal current_sweep_raw, current_aux_curves, current_sweep_norm, current_info, last_calib_sweep
         drained = 0
         while True:
             try:
-                s, info = q.get_nowait()
+                s, info, aux_curves = q.get_nowait()
             except Empty:
                 break
             drained += 1
             current_sweep_raw = s
+            current_aux_curves = aux_curves
             current_info = info
             ch = 0
             try:
@@ -909,6 +1296,13 @@ def main():
             else:
                 xs = np.arange(current_sweep_raw.size, dtype=np.int32)
             line_obj.set_data(xs, current_sweep_raw)
+            if current_aux_curves is not None:
+                avg_1_curve, avg_2_curve = current_aux_curves
+                line_avg1_obj.set_data(xs[: avg_1_curve.size], avg_1_curve)
+                line_avg2_obj.set_data(xs[: avg_2_curve.size], avg_2_curve)
+            else:
+                line_avg1_obj.set_data([], [])
+                line_avg2_obj.set_data([], [])
             if last_calib_sweep is not None:
                 line_calib_obj.set_data(xs[: last_calib_sweep.size], last_calib_sweep)
             else:
@@ -917,22 +1311,16 @@ def main():
                 line_norm_obj.set_data(xs[: current_sweep_norm.size], current_sweep_norm)
             else:
                 line_norm_obj.set_data([], [])
-            # Лимиты по X постоянные под текущую ширину
-            ax_line.set_xlim(0, max(1, current_sweep_raw.size - 1))
+            # Лимиты по X: 3.3 ГГц .. 14.3 ГГц
+            ax_line.set_xlim(3.3, 14.3)
             # Адаптивные Y-лимиты (если не задан --ylim)
             if fixed_ylim is None:
-                y0 = float(np.nanmin(current_sweep_raw))
-                y1 = float(np.nanmax(current_sweep_raw))
-                if np.isfinite(y0) and np.isfinite(y1):
-                    if y0 == y1:
-                        pad = max(1.0, abs(y0) * 0.05)
-                        y0 -= pad
-                        y1 += pad
-                    else:
-                        pad = 0.05 * (y1 - y0)
-                        y0 -= pad
-                        y1 += pad
-                    ax_line.set_ylim(y0, y1)
+                y_series = [current_sweep_raw, last_calib_sweep, current_sweep_norm]
+                if current_aux_curves is not None:
+                    y_series.extend(current_aux_curves)
+                y_limits = _compute_auto_ylim(*y_series)
+                if y_limits is not None:
+                    ax_line.set_ylim(y_limits[0], y_limits[1])
 
             # Обновление спектра текущего свипа
             sweep_for_fft = current_sweep_norm if current_sweep_norm is not None else current_sweep_raw
@@ -942,7 +1330,7 @@ def main():
                 seg = np.nan_to_num(sweep_for_fft[:take_fft], nan=0.0).astype(np.float32, copy=False)
                 win = np.hanning(take_fft).astype(np.float32)
                 fft_in[:take_fft] = seg * win
-                spec = np.fft.rfft(fft_in)
+                spec = np.fft.ifft(fft_in)
                 mag = np.abs(spec).astype(np.float32)
                 fft_vals = 20.0 * np.log10(mag + 1e-9)
                 xs_fft = freq_shared
@@ -951,7 +1339,7 @@ def main():
                 fft_line_obj.set_data(xs_fft[: fft_vals.size], fft_vals)
                 # Авто-диапазон по Y для спектра
                 if np.isfinite(np.nanmin(fft_vals)) and np.isfinite(np.nanmax(fft_vals)):
-                    ax_fft.set_xlim(0, max(1, xs_fft.size - 1))
+                    ax_fft.set_xlim(0, max(1, xs_fft.size - 1) * 1.5)
                     ax_fft.set_ylim(float(np.nanmin(fft_vals)), float(np.nanmax(fft_vals)))
 
         # Обновление водопада
@@ -1022,6 +1410,8 @@ def main():
         # Возвращаем обновлённые артисты
         return (
             line_obj,
+            line_avg1_obj,
+            line_avg2_obj,
             line_calib_obj,
             line_norm_obj,
             img_obj,
@@ -1057,7 +1447,15 @@ def run_pyqtgraph(args):
     # Очередь завершённых свипов и поток чтения
     q: Queue[SweepPacket] = Queue(maxsize=1000)
     stop_event = threading.Event()
-    reader = SweepReader(args.port, args.baud, q, stop_event, fancy=bool(args.fancy))
+    reader = SweepReader(
+        args.port,
+        args.baud,
+        q,
+        stop_event,
+        fancy=bool(args.fancy),
+        bin_mode=bool(args.bin_mode),
+        logscale=bool(args.logscale),
+    )
     reader.start()
 
     # Настройки скорости
@@ -1074,10 +1472,12 @@ def run_pyqtgraph(args):
     # Плот последнего свипа (слева-сверху)
     p_line = win.addPlot(row=0, col=0, title="Сырые данные")
     p_line.showGrid(x=True, y=True, alpha=0.3)
+    curve_avg1 = p_line.plot(pen=pg.mkPen((170, 170, 170), width=1))
+    curve_avg2 = p_line.plot(pen=pg.mkPen((110, 110, 110), width=1))
     curve = p_line.plot(pen=pg.mkPen((80, 120, 255), width=1))
     curve_calib = p_line.plot(pen=pg.mkPen((220, 60, 60), width=1))
     curve_norm = p_line.plot(pen=pg.mkPen((60, 180, 90), width=1))
-    p_line.setLabel("bottom", "X")
+    p_line.setLabel("bottom", "ГГц")
     p_line.setLabel("left", "Y")
     ch_text = pg.TextItem("", anchor=(1, 1))
     ch_text.setZValue(10)
@@ -1092,7 +1492,7 @@ def run_pyqtgraph(args):
         p_img.getAxis("bottom").setStyle(showValues=False)
     except Exception:
         pass
-    p_img.setLabel("left", "X (0 снизу)")
+    p_img.setLabel("left", "ГГц")
     img = pg.ImageItem()
     p_img.addItem(img)
 
@@ -1100,8 +1500,8 @@ def run_pyqtgraph(args):
     p_fft = win.addPlot(row=1, col=0, title="FFT")
     p_fft.showGrid(x=True, y=True, alpha=0.3)
     curve_fft = p_fft.plot(pen=pg.mkPen((255, 120, 80), width=1))
-    p_fft.setLabel("bottom", "Бин")
-    p_fft.setLabel("left", "Амплитуда, дБ")
+    p_fft.setLabel("bottom", "Время")
+    p_fft.setLabel("left", "дБ")
 
     # Водопад спектров (справа-снизу)
     p_spec = win.addPlot(row=1, col=1, title="B-scan (дБ)")
@@ -1133,6 +1533,7 @@ def run_pyqtgraph(args):
     width: Optional[int] = None
     x_shared: Optional[np.ndarray] = None
     current_sweep_raw: Optional[np.ndarray] = None
+    current_aux_curves: SweepAuxCurves = None
     current_sweep_norm: Optional[np.ndarray] = None
     last_calib_sweep: Optional[np.ndarray] = None
     current_info: Optional[SweepInfo] = None
@@ -1146,6 +1547,7 @@ def run_pyqtgraph(args):
     spec_clip = _parse_spec_clip(getattr(args, "spec_clip", None))
     spec_mean_sec = float(getattr(args, "spec_mean_sec", 0.0))
     calib_enabled = False
+    norm_type = str(getattr(args, "norm_type", "projector")).strip().lower()
     # Диапазон по Y: авто по умолчанию (поддерживает отрицательные значения)
     fixed_ylim: Optional[Tuple[float, float]] = None
     if args.ylim:
@@ -1158,14 +1560,7 @@ def run_pyqtgraph(args):
         p_line.setYRange(fixed_ylim[0], fixed_ylim[1], padding=0)
 
     def _normalize_sweep(raw: np.ndarray, calib: np.ndarray) -> np.ndarray:
-        w = min(raw.size, calib.size)
-        if w <= 0:
-            return raw
-        out = np.full_like(raw, np.nan, dtype=np.float32)
-        with np.errstate(divide="ignore", invalid="ignore"):
-            out[:w] = raw[:w] / calib[:w]
-        out = np.nan_to_num(out, nan=np.nan, posinf=np.nan, neginf=np.nan)
-        return out
+        return _normalize_by_calib(raw, calib, norm_type=norm_type)
 
     def _set_calib_enabled():
         nonlocal calib_enabled, current_sweep_norm
@@ -1188,14 +1583,15 @@ def run_pyqtgraph(args):
         if ring is not None:
             return
         width = WF_WIDTH
-        x_shared = np.arange(width, dtype=np.int32)
+        x_shared = np.linspace(3.3, 14.3, width, dtype=np.float32)
         ring = np.full((max_sweeps, width), np.nan, dtype=np.float32)
         ring_time = np.full((max_sweeps,), np.nan, dtype=np.float64)
         head = 0
-        # Водопад: время по оси X, X по оси Y
+        # Водопад: время по оси X, X по оси Y (ось Y: 3.3..14.3 ГГц)
         img.setImage(ring.T, autoLevels=False)
-        p_img.setRange(xRange=(0, max_sweeps - 1), yRange=(0, max(1, width - 1)), padding=0)
-        p_line.setXRange(0, max(1, width - 1), padding=0)
+        img.setRect(0, 3.3, max_sweeps, 14.3 - 3.3)
+        p_img.setRange(xRange=(0, max_sweeps - 1), yRange=(3.3, 14.3), padding=0)
+        p_line.setXRange(3.3, 14.3, padding=0)
         # FFT: время по оси X, бин по оси Y
         ring_fft = np.full((max_sweeps, fft_bins), np.nan, dtype=np.float32)
         img_fft.setImage(ring_fft.T, autoLevels=False)
@@ -1204,7 +1600,7 @@ def run_pyqtgraph(args):
         freq_shared = np.arange(fft_bins, dtype=np.int32)
 
     def _visible_levels_pyqtgraph(data: np.ndarray) -> Optional[Tuple[float, float]]:
-        """(vmin, vmax) по текущей видимой области ImageItem (без накопления по времени)."""
+        """(vmin, vmax) по центральным 90% значений в видимой области ImageItem."""
         if data.size == 0:
             return None
         ny, nx = data.shape[0], data.shape[1]
@@ -1228,8 +1624,8 @@ def run_pyqtgraph(args):
         if not finite.any():
             return None
         vals = sub[finite]
-        vmin = float(np.min(vals))
-        vmax = float(np.max(vals))
+        vmin = float(np.nanpercentile(vals, 5))
+        vmax = float(np.nanpercentile(vals, 95))
         if not (np.isfinite(vmin) and np.isfinite(vmax)) or vmin == vmax:
             return None
         return (vmin, vmax)
@@ -1255,7 +1651,7 @@ def run_pyqtgraph(args):
                 seg = np.nan_to_num(s[:take_fft], nan=0.0).astype(np.float32, copy=False)
                 win = np.hanning(take_fft).astype(np.float32)
                 fft_in[:take_fft] = seg * win
-                spec = np.fft.rfft(fft_in)
+                spec = np.fft.ifft(fft_in)
                 mag = np.abs(spec).astype(np.float32)
                 fft_row = 20.0 * np.log10(mag + 1e-9)
                 if fft_row.shape[0] != bins:
@@ -1271,15 +1667,16 @@ def run_pyqtgraph(args):
                 y_max_fft = float(fr_max)
 
     def drain_queue():
-        nonlocal current_sweep_raw, current_sweep_norm, current_info, last_calib_sweep
+        nonlocal current_sweep_raw, current_aux_curves, current_sweep_norm, current_info, last_calib_sweep
         drained = 0
         while True:
             try:
-                s, info = q.get_nowait()
+                s, info, aux_curves = q.get_nowait()
             except Empty:
                 break
             drained += 1
             current_sweep_raw = s
+            current_aux_curves = aux_curves
             current_info = info
             ch = 0
             try:
@@ -1318,6 +1715,13 @@ def run_pyqtgraph(args):
             else:
                 xs = np.arange(current_sweep_raw.size)
             curve.setData(xs, current_sweep_raw, autoDownsample=True)
+            if current_aux_curves is not None:
+                avg_1_curve, avg_2_curve = current_aux_curves
+                curve_avg1.setData(xs[: avg_1_curve.size], avg_1_curve, autoDownsample=True)
+                curve_avg2.setData(xs[: avg_2_curve.size], avg_2_curve, autoDownsample=True)
+            else:
+                curve_avg1.setData([], [])
+                curve_avg2.setData([], [])
             if last_calib_sweep is not None:
                 curve_calib.setData(xs[: last_calib_sweep.size], last_calib_sweep, autoDownsample=True)
             else:
@@ -1327,11 +1731,12 @@ def run_pyqtgraph(args):
             else:
                 curve_norm.setData([], [])
             if fixed_ylim is None:
-                y0 = float(np.nanmin(current_sweep_raw))
-                y1 = float(np.nanmax(current_sweep_raw))
-                if np.isfinite(y0) and np.isfinite(y1):
-                    margin = 0.05 * max(1.0, (y1 - y0))
-                    p_line.setYRange(y0 - margin, y1 + margin, padding=0)
+                y_series = [current_sweep_raw, last_calib_sweep, current_sweep_norm]
+                if current_aux_curves is not None:
+                    y_series.extend(current_aux_curves)
+                y_limits = _compute_auto_ylim(*y_series)
+                if y_limits is not None:
+                    p_line.setYRange(y_limits[0], y_limits[1], padding=0)
 
             # Обновим спектр
             sweep_for_fft = current_sweep_norm if current_sweep_norm is not None else current_sweep_raw
@@ -1341,13 +1746,14 @@ def run_pyqtgraph(args):
                 seg = np.nan_to_num(sweep_for_fft[:take_fft], nan=0.0).astype(np.float32, copy=False)
                 win = np.hanning(take_fft).astype(np.float32)
                 fft_in[:take_fft] = seg * win
-                spec = np.fft.rfft(fft_in)
+                spec = np.fft.ifft(fft_in)
                 mag = np.abs(spec).astype(np.float32)
                 fft_vals = 20.0 * np.log10(mag + 1e-9)
                 xs_fft = freq_shared
                 if fft_vals.size > xs_fft.size:
                     fft_vals = fft_vals[: xs_fft.size]
                 curve_fft.setData(xs_fft[: fft_vals.size], fft_vals)
+                p_fft.setXRange(0, max(1, xs_fft.size - 1) * 1.5, padding=0)
                 p_fft.setYRange(float(np.nanmin(fft_vals)), float(np.nanmax(fft_vals)), padding=0)
 
         if changed and ring is not None: