.gitignore

@@ -184,4 +184,3 @@ cython_debug/
 
 *.png
 /logs/*.log
-runtime/

README.md

@@ -148,7 +148,19 @@ docker compose -f deploy/docker/docker-compose.yml down
 ```
 
 ### Все SDR-сервисы (systemd)
-
+Запуск всех SDR unitов:
+```bash
+sudo systemctl start dronedetector-sdr-433.service
+sudo systemctl start dronedetector-sdr-750.service
+sudo systemctl start dronedetector-sdr-868.service
+sudo systemctl start dronedetector-sdr-3300.service
+sudo systemctl start dronedetector-sdr-4500.service
+sudo systemctl start dronedetector-sdr-5200.service
+sudo systemctl start dronedetector-sdr-5800.service
+sudo systemctl start dronedetector-sdr-915.service
+sudo systemctl start dronedetector-sdr-1200.service
+sudo systemctl start dronedetector-sdr-2400.service
+```
 ```bash
 sudo systemctl status dronedetector-sdr-433.service 
 sudo systemctl status dronedetector-sdr-750.service  
@@ -165,25 +177,37 @@ sudo systemctl status dronedetector-sdr-2400.service
 ```bash
 sudo systemctl stop dronedetector-sdr-433.service 
 sudo systemctl stop dronedetector-sdr-750.service  
+sudo systemctl stop dronedetector-sdr-868.service 
 sudo systemctl stop dronedetector-sdr-3300.service 
 sudo systemctl stop dronedetector-sdr-4500.service
 sudo systemctl stop dronedetector-sdr-5200.service  
 sudo systemctl stop dronedetector-sdr-5800.service 
+sudo systemctl stop dronedetector-sdr-915.service
 sudo systemctl stop dronedetector-sdr-1200.service
 sudo systemctl stop dronedetector-sdr-2400.service
-sudo systemctl stop dronedetector-sdr-1500.service
-sudo systemctl stop dronedetector-sdr-868.service
-sudo systemctl stop dronedetector-sdr-868-915.service
 ```
 
 
-
+Альтернатива одной командой:
+```bash
+for u in dronedetector-sdr-{433,750,868,3300,4500,5200,5800,915,1200,2400}.service; do
+  sudo systemctl start "$u"
+done
+```
 
 Проверка статуса всех SDR unitов:
 ```bash
 sudo systemctl status dronedetector-sdr-*.service --no-pager
 ```
 
+### Полный ручной старт всего контура
+```bash
+docker compose -f deploy/docker/docker-compose.yml up -d
+for u in dronedetector-sdr-{433,750,868,3300,4500,5200,5800,915,1200,2400}.service; do
+  sudo systemctl start "$u"
+done
+```
+
 ### Просмотр логов SDR
 ``` bash
 # 50 последних 

common/runtime.py

@@ -70,7 +70,7 @@ def validate_env(source: str, schema: Dict[str, Callable[[str], Any]]) -> Dict[s
 
 
 def resolve_hackrf_index(serial_env_key: str, source: str) -> str:
-    """Resolve HackRF osmosdr selector from expected serial in env."""
+    """Resolve HackRF index from expected serial in env."""
     serial = validate_env(source, {serial_env_key: as_str})[serial_env_key]
 
     try:
@@ -96,4 +96,4 @@ def resolve_hackrf_index(serial_env_key: str, source: str) -> str:
             f"[{source}] serial {serial!r} not found among connected HackRF devices: {serials}"
         )
 
-    return serial
+    return str(serials.index(serial))

common/shared_stream_addrs.py

@@ -1,3 +0,0 @@
-SHARED_VECTOR_LEN = 4096
-SHARED_868_ADDR = 'tcp://127.0.0.1:35068'
-SHARED_915_ADDR = 'tcp://127.0.0.1:35069'

deploy/docker/Dockerfile.telemetry_server

@@ -1,18 +0,0 @@
-# syntax=docker/dockerfile:1.7
-FROM python:3.11-slim
-
-ENV PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1 \
-    PYTHONPATH=/app
-
-WORKDIR /app
-
-COPY deploy/requirements/telemetry_server.txt /tmp/requirements.txt
-RUN --mount=type=cache,target=/root/.cache/pip \
-    pip install --upgrade pip && \
-    pip install -r /tmp/requirements.txt
-
-COPY . /app
-
-EXPOSE 5020
-CMD ["python3", "-m", "telemetry.telemetry_server"]

deploy/docker/docker-compose.yml

@@ -9,7 +9,6 @@ services:
       - ../../.env
     environment:
       - PYTHONPATH=/app
-      - JAMMER_STATE_FILE=/app/runtime/jammer_active.flag
     working_dir: /app
     command: ["python3", "-m", "src.server_to_master"]
     restart: unless-stopped
@@ -17,7 +16,6 @@ services:
       - "5010:5010"
     volumes:
       - ../../.env:/app/.env:ro
-      - ../../runtime:/app/runtime
     networks:
       - dronedetector-net
 
@@ -50,29 +48,6 @@ services:
     networks:
       - dronedetector-net
 
-
-  dronedetector-telemetry-server:
-    container_name: dronedetector-telemetry-server
-    image: dronedetector-telemetry-server:latest
-    build:
-      context: ../..
-      dockerfile: deploy/docker/Dockerfile.telemetry_server
-    env_file:
-      - ../../.env
-    environment:
-      - PYTHONPATH=/app
-    working_dir: /app
-    command: ["python3", "-m", "telemetry.telemetry_server"]
-    restart: unless-stopped
-    ports:
-      - "5020:5020"
-    volumes:
-      - ../../.env:/app/.env:ro
-      - ../../telemetry:/app/telemetry
-      - ../../common:/app/common
-    networks:
-      - dronedetector-net
-
 networks:
   dronedetector-net:
     name: dronedetector-net

deploy/requirements/telemetry_server.txt

@@ -1,3 +0,0 @@
-fastapi==0.115.6
-uvicorn[standard]==0.32.1
-python-dotenv==1.0.1

deploy/systemd/dronedetector-sdr-1500.service

@@ -1,19 +0,0 @@
-[Unit]
-Description=DroneDetector SDR Scanner 1500 MHz
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-User=__RUN_USER__
-Group=__RUN_GROUP__
-WorkingDirectory=__PROJECT_ROOT__
-EnvironmentFile=__PROJECT_ROOT__/.env
-Environment=PYTHONPATH=__PROJECT_ROOT__
-ExecStartPre=/usr/local/bin/dronedetector-precheck-sdr.sh
-ExecStart=__PROJECT_ROOT__/.venv-sdr/bin/python src/main_1500.py
-Restart=always
-RestartSec=3
-
-[Install]
-WantedBy=multi-user.target

deploy/systemd/dronedetector-sdr-868-915.service

@@ -1,19 +0,0 @@
-[Unit]
-Description=DroneDetector SDR Router 868/915 Shared HackRF
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-User=__RUN_USER__
-Group=__RUN_GROUP__
-WorkingDirectory=__PROJECT_ROOT__
-EnvironmentFile=__PROJECT_ROOT__/.env
-Environment=PYTHONPATH=__PROJECT_ROOT__
-ExecStartPre=/usr/local/bin/dronedetector-precheck-sdr.sh
-ExecStart=__PROJECT_ROOT__/.venv-sdr/bin/python src/main_868_915_router.py
-Restart=always
-RestartSec=3
-
-[Install]
-WantedBy=multi-user.target

deploy/systemd/dronedetector-sdr-868.service

@@ -1,8 +1,7 @@
 [Unit]
 Description=DroneDetector SDR Scanner 868 MHz
-After=network-online.target dronedetector-sdr-868-915.service
+After=network-online.target
 Wants=network-online.target
-Requires=dronedetector-sdr-868-915.service
 
 [Service]
 Type=simple

deploy/systemd/dronedetector-sdr-915.service

@@ -1,8 +1,7 @@
 [Unit]
 Description=DroneDetector SDR Scanner 915 MHz
-After=network-online.target dronedetector-sdr-868-915.service
+After=network-online.target
 Wants=network-online.target
-Requires=dronedetector-sdr-868-915.service
 
 [Service]
 Type=simple

install_all.sh

@@ -10,9 +10,7 @@ RUN_GROUP="$(id -gn "${RUN_USER}")"
 SDR_UNITS=(
   dronedetector-sdr-433.service
   dronedetector-sdr-750.service
-  dronedetector-sdr-868-915.service
   dronedetector-sdr-868.service
-  dronedetector-sdr-1500.service
   dronedetector-sdr-3300.service
   dronedetector-sdr-4500.service
   dronedetector-sdr-5200.service

orange_scripts/compose_send_data_915.py

@@ -1,70 +1,74 @@
-from common.runtime import load_root_env, validate_env, as_float, as_int, as_str
-import json
-import os
 
+from common.runtime import load_root_env, validate_env, as_float, as_int, as_str
 import numpy as np
 import requests
+import os
+import sys
+import json
+import time
 
 
 load_root_env(__file__)
-validate_env('orange_scripts/compose_send_data_915.py', {
+validate_env("orange_scripts/compose_send_data_915.py", {
-    'POROG_915': as_float,
+    "POROG_915": as_float,
-    'SERVER_IP_1': as_str,
+    "SERVER_IP_1": as_str,
-    'SERVER_PORT_1': as_int,
+    "SERVER_PORT_1": as_int,
 })
-
 porog = float(os.getenv('POROG_915'))
 server_ip_1 = os.getenv('SERVER_IP_1')
 server_port_1 = os.getenv('SERVER_PORT_1')
 server_ip_2 = os.getenv('SERVER_IP_2')
 server_port_2 = os.getenv('SERVER_PORT_2')
 PARAMS = {'split_size': 400_000, 'point_amount': 100_000}
-PARAMS['show_amount'] = int(0.8 * PARAMS['point_amount'])
+PARAMS['show_amount'] = 0.8 * PARAMS['point_amount']
 token = 0
 channel = 1
 flag = 0
 
+##############################
+# HYPERPARAMETERS
+##############################
 f_base = 0.91e9
 f_step = 20e6
 f_roof = 0.98e9
-
+##############################
+# Variables
+##############################
 f = f_base
 EOCF = 0
-signal_arr = np.array([], dtype=np.complex64)
+signal_arr = []
 
 
 class NumpyArrayEncoder(json.JSONEncoder):
     def default(self, obj):
         if isinstance(obj, np.integer):
             return int(obj)
-        if isinstance(obj, np.ndarray):
+        elif isinstance(obj, np.ndarray):
             return obj.tolist()
-        return super().default(obj)
+        else:
+            return super(NumpyArrayEncoder, self).default(obj)
 
 
 def send_data(sig):
     try:
         global token
         print('#' * 10)
-        print('\nОтправка пакета ' + str(token + 1))
+        print('\nОтправка пакета ' + str(token+1))
         data_to_send = {
-            'freq': 915,
+            "freq": 915,
-            'channel': int(channel),
+            "channel": int(channel),
-            'token': int(token + 1),
+            "token": int(token+1),
-            'data_real': np.asarray(np.array(sig, dtype=np.complex64).real, dtype=np.float32),
+            "data_real": np.asarray(np.array(sig, dtype=np.complex64).real, dtype=np.float32),
-            'data_imag': np.asarray(np.array(sig, dtype=np.complex64).imag, dtype=np.float32),
+            "data_imag": np.asarray(np.array(sig, dtype=np.complex64).imag, dtype=np.float32)
         }
         mod_data_to_send = json.dumps(data_to_send, cls=NumpyArrayEncoder)
-        response = requests.post(
+        response = requests.post("http://{0}:{1}/receive_data".format(server_ip_1, server_port_1), json=mod_data_to_send)
-            'http://{0}:{1}/receive_data'.format(server_ip_1, server_port_1),
-            json=mod_data_to_send,
-        )
         if response.status_code == 200:
             token += 1
             print(response.text)
             print('#' * 10)       
         else:
-            print('Ошибка при отправке данных: ', response.status_code)
+            print("Ошибка при отправке данных: ", response.status_code)
             print('#' * 10)
     except Exception as exc:
         print(str(exc))
@@ -72,48 +76,40 @@ def send_data(sig):
 
 def median(sig):
     global flag
-    samples = np.asarray(np.abs(np.array(sig, dtype=np.complex64)), dtype=np.float32)
+    median = abs(float(np.median(sorted(np.asarray(np.abs(np.array(sig, dtype=np.complex64)), dtype=np.float32))[int(PARAMS['show_amount']):])))
-    med = abs(float(np.median(sorted(samples)[int(PARAMS['show_amount']):])))
+    flag = 0 if porog > median else 1
-    flag = 0 if porog > med else 1
+    print(channel, median, flag)
-    print(channel, med, flag)
-
-
-def advance_freq():
-    global channel
-    global f
-
-    next_freq = f + f_step
-    if next_freq >= f_roof:
-        f = f_base
-        channel = 1
-        return f, True
-
-    f = next_freq
-    channel += 1
-    return f, False
 
 
 def work(lvl):
     global flag
+    global channel
+    global f_base
+    global f_step
+    global f_roof
     global f
     global EOCF
     global signal_arr
 
-    y = np.asarray(lvl, dtype=np.complex64).ravel()
+    y = np.array(lvl).ravel()
     signal_arr = np.concatenate((signal_arr, y), axis=None)
 
-    if flag == 0 and len(signal_arr) >= PARAMS['point_amount']:
+    if f >= f_roof:
-        median(signal_arr[:PARAMS['point_amount']])
+        f = f_base
-        signal_arr = np.array([], dtype=np.complex64)
+        signal_arr = []
-        if flag == 0:
+        channel = 1
-            f, _ = advance_freq()
+        return f, EOCF
-            return f, EOCF
+    else:
-
+        if flag == 0 and len(signal_arr) >= PARAMS['point_amount']:
-    if len(signal_arr) >= PARAMS['split_size']:
+            median(signal_arr[:PARAMS['point_amount']])
-        send_data(signal_arr[:PARAMS['split_size']])
+            signal_arr = []
-        flag = 0
+            if flag == 0:
-        signal_arr = np.array([], dtype=np.complex64)
+                f += f_step
-        f, _ = advance_freq()
+                channel += 1
+        if len(signal_arr) >= PARAMS['split_size']:
+            send_data(signal_arr[:PARAMS['split_size']])
+            flag = 0
+            signal_arr = []
+            channel += 1
+            f += f_step
         return f, EOCF
-
-    return f, EOCF

orange_scripts/main_1200.py

@@ -12,6 +12,7 @@ from common.runtime import load_root_env, resolve_hackrf_index
 
 load_root_env(__file__)
 
+
 def get_hack_id():
     return resolve_hackrf_index('HACKID_1200', 'orange_scripts/main_1200.py')
     serial_number = os.getenv('HACKID_1200')

orange_scripts/main_2400.py

@@ -12,6 +12,7 @@ from common.runtime import load_root_env, resolve_hackrf_index
 
 load_root_env(__file__)
 
+
 def get_hack_id():
     return resolve_hackrf_index('HACKID_2400', 'orange_scripts/main_2400.py')
     serial_number = os.getenv('HACKID_2400')

orange_scripts/main_915.py

@@ -1,88 +1,169 @@
-from gnuradio import blocks, gr, zeromq
+from gnuradio import blocks, gr
-import signal
 import sys
-import threading
+import signal
+import compose_send_data_915 as my_freq
+import osmosdr
 import time
+import threading
+import subprocess
+import os
+from common.runtime import load_root_env, resolve_hackrf_index
 
-import compose_send_data_915 as my_freq
 
-from common.runtime import load_root_env
+load_root_env(__file__)
-from common.shared_stream_addrs import SHARED_915_ADDR, SHARED_VECTOR_LEN
 
 
-load_root_env(__file__)
+def get_hack_id():
+    return resolve_hackrf_index('HACKID_915', 'orange_scripts/main_915.py')
+    serial_number = os.getenv('HACKID_915')
+    pos = None
+    output = []
+    try:
+        command = 'lsusb -v -d 1d50:6089 | grep iSerial'
+        output.append(subprocess.check_output(command, shell=True, text=True))
+    except subprocess.CalledProcessError as e:
+        print(f"Команда завершилась с кодом возврата {e.returncode}")
+        print(e)
+    print(output)
+    output_lines = output[0].strip().split('\n')
+    print(output_lines)
+    serial_numbers = [line.split()[-1] for line in output_lines]
+    print(serial_numbers)
+    for i, number in enumerate(serial_numbers):
+        if number == serial_number:
+            id = i
+            break
+    if id is not None:
+        print('HackId is: {0}'.format(id))
+        return str(id)
+    else:
+        print('Такого хака нет!')
 
 
 class get_center_freq(gr.top_block):
+
     def __init__(self):
-        gr.top_block.__init__(self, 'get_center_freq')
+        gr.top_block.__init__(self, "get_center_freq")
-
+
-        self.prob_freq = 0
+        ##################################################
-        self.poll_rate = 10000
+        # Variables
-        self.vector_len = SHARED_VECTOR_LEN
+        ##################################################
-        self.center_freq = 0
+        self.prob_freq = prob_freq = 0
-        self.shared_addr = SHARED_915_ADDR
+        self.top_peaks_amount = top_peaks_amount = 20
-        self._stop_polling = threading.Event()
+        self.samp_rate = samp_rate = 20e6
-        self._prob_freq_thread = None
+        self.poll_rate = poll_rate = 10000
-
+        self.num_points = num_points = 8192
-        self.probSigVec = blocks.probe_signal_vc(self.vector_len)
+        self.flag = flag = 1
-        self.shared_source_0 = zeromq.pull_source(
+        self.decimation = decimation = 1
-            gr.sizeof_gr_complex,
+        self.center_freq = center_freq = my_freq.work(prob_freq)[0]
-            self.vector_len,
+
-            self.shared_addr,
+        ##################################################
-            100,
+        # Blocks
-            False,
+        ##################################################
-            -1,
+        self.probSigVec = blocks.probe_signal_vc(4096)
-            False,
+        self.rtlsdr_source_0 = osmosdr.source(
+            args="numchan=" + str(1) + " " + 'hackrf=' + get_hack_id()
         )
-        self.connect((self.shared_source_0, 0), (self.probSigVec, 0))
+        self.rtlsdr_source_0.set_time_unknown_pps(osmosdr.time_spec_t())
-
+        self.rtlsdr_source_0.set_sample_rate(samp_rate)
-    def start_polling(self):
+        self.rtlsdr_source_0.set_center_freq(center_freq, 0)
-        if self._prob_freq_thread is not None:
+        self.rtlsdr_source_0.set_freq_corr(0, 0)
-            return
+        self.rtlsdr_source_0.set_gain(16, 0)
+        self.rtlsdr_source_0.set_if_gain(16, 0)
+        self.rtlsdr_source_0.set_bb_gain(0, 0)
+        self.rtlsdr_source_0.set_antenna('', 0)
+        self.rtlsdr_source_0.set_bandwidth(0, 0)
+        self.rtlsdr_source_0.set_min_output_buffer(4096)
 
         def _prob_freq_probe():
-            while not self._stop_polling.is_set():
+            while True:
-                self.set_prob_freq(self.probSigVec.level())
+
-                time.sleep(1.0 / self.poll_rate)
+                val = self.probSigVec.level()
+                try:
+                    self.set_prob_freq(val)
+                except AttributeError:
+                    pass
+                time.sleep(1.0 / (poll_rate))
+        _prob_freq_thread = threading.Thread(target=_prob_freq_probe)
+        _prob_freq_thread.daemon = True
+        _prob_freq_thread.start()
+
+        self.blocks_stream_to_vector_1 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, 4096)
+
+
 
-        self._prob_freq_thread = threading.Thread(target=_prob_freq_probe, daemon=True)
+        ##################################################
-        self._prob_freq_thread.start()
+        # Connections
+        ##################################################
+        self.connect((self.blocks_stream_to_vector_1, 0), (self.probSigVec, 0))
+        self.connect((self.rtlsdr_source_0, 0), (self.blocks_stream_to_vector_1, 0))
 
     def get_prob_freq(self):
         return self.prob_freq
 
     def set_prob_freq(self, prob_freq):
         self.prob_freq = prob_freq
-        self.center_freq = my_freq.work(self.prob_freq)[0]
+        self.set_center_freq(my_freq.work(self.prob_freq)[0])
+
+    def get_top_peaks_amount(self):
+        return self.top_peaks_amount
+
+    def set_top_peaks_amount(self, top_peaks_amount):
+        self.top_peaks_amount = top_peaks_amount
+
+    def get_samp_rate(self):
+        return self.samp_rate
+
+    def set_samp_rate(self, samp_rate):
+        self.samp_rate = samp_rate
+        self.rtlsdr_source_0.set_sample_rate(self.samp_rate)
+
+    def get_poll_rate(self):
+        return self.poll_rate
+
+    def set_poll_rate(self, poll_rate):
+        self.poll_rate = poll_rate
+
+    def get_num_points(self):
+        return self.num_points
+
+    def set_num_points(self, num_points):
+        self.num_points = num_points
+
+    def get_flag(self):
+        return self.flag
+
+    def set_flag(self, flag):
+        self.flag = flag
+
+    def get_decimation(self):
+        return self.decimation
+
+    def set_decimation(self, decimation):
+        self.decimation = decimation
 
     def get_center_freq(self):
         return self.center_freq
 
     def set_center_freq(self, center_freq):
         self.center_freq = center_freq
-
+        self.rtlsdr_source_0.set_center_freq(self.center_freq, 0)
-    def close(self):
-        self._stop_polling.set()
-        self.stop()
-        self.wait()
 
 
 def main(top_block_cls=get_center_freq, options=None):
     time.sleep(3)
     tb = top_block_cls()
-
     def sig_handler(sig=None, frame=None):
-        tb.close()
+        tb.stop()
+        tb.wait()
         sys.exit(0)
 
     signal.signal(signal.SIGINT, sig_handler)
     signal.signal(signal.SIGTERM, sig_handler)
 
     tb.start()
-    tb.start_polling()
     try:
-        print('shared_pull_addr:', SHARED_915_ADDR)
+        input('Press Enter to quit: ')
     except EOFError:
         pass
     tb.wait()

restart_all.sh

@@ -7,9 +7,7 @@ COMPOSE_FILE="${PROJECT_ROOT}/deploy/docker/docker-compose.yml"
 SDR_UNITS=(
   dronedetector-sdr-433.service
   dronedetector-sdr-750.service
-  dronedetector-sdr-868-915.service
   dronedetector-sdr-868.service
-  dronedetector-sdr-1500.service
   dronedetector-sdr-3300.service
   dronedetector-sdr-4500.service
   dronedetector-sdr-5200.service

scripts_nn/band_scanner.grc

@@ -1,686 +0,0 @@
-options:
-  parameters:
-    author: ''
-    catch_exceptions: 'True'
-    category: '[GRC Hier Blocks]'
-    cmake_opt: ''
-    comment: ''
-    copyright: ''
-    description: ''
-    gen_cmake: 'On'
-    gen_linking: dynamic
-    generate_options: qt_gui
-    hier_block_src_path: '.:'
-    id: band_scanner
-    max_nouts: '0'
-    output_language: python
-    placement: (0,0)
-    qt_qss_theme: ''
-    realtime_scheduling: ''
-    run: 'True'
-    run_command: '{python} -u {filename}'
-    run_options: prompt
-    sizing_mode: fixed
-    thread_safe_setters: ''
-    title: band_scanner
-    window_size: (1000,1000)
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [8, 8]
-    rotation: 0
-    state: enabled
-
-blocks:
-- name: freq
-  id: variable
-  parameters:
-    comment: ''
-    value: py_module.work(func_probe, min_f, max_f, step_f)
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [368, 16.0]
-    rotation: 0
-    state: true
-- name: func_probe
-  id: variable_function_probe
-  parameters:
-    block_id: vec_probe
-    comment: ''
-    function_args: ''
-    function_name: level
-    poll_rate: '0.05'
-    value: '0'
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [1120, 272.0]
-    rotation: 0
-    state: true
-- name: max_f
-  id: variable
-  parameters:
-    comment: ''
-    value: 3.0e9
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [536, 16.0]
-    rotation: 0
-    state: true
-- name: min_f
-  id: variable
-  parameters:
-    comment: ''
-    value: 0.4e9
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [448, 16.0]
-    rotation: 0
-    state: true
-- name: samp_rate
-  id: variable
-  parameters:
-    comment: ''
-    value: 20e6
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [184, 12]
-    rotation: 0
-    state: enabled
-- name: step_f
-  id: variable
-  parameters:
-    comment: ''
-    value: 5e6
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [616, 16.0]
-    rotation: 0
-    state: true
-- name: analog_const_source_x_0
-  id: analog_const_source_x
-  parameters:
-    affinity: ''
-    alias: ''
-    comment: ''
-    const: freq
-    maxoutbuf: '0'
-    minoutbuf: '0'
-    type: float
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [792, 48.0]
-    rotation: 0
-    state: disabled
-- name: osmosdr_source_0
-  id: osmosdr_source
-  parameters:
-    affinity: ''
-    alias: ''
-    ant0: ''
-    ant1: ''
-    ant10: ''
-    ant11: ''
-    ant12: ''
-    ant13: ''
-    ant14: ''
-    ant15: ''
-    ant16: ''
-    ant17: ''
-    ant18: ''
-    ant19: ''
-    ant2: ''
-    ant20: ''
-    ant21: ''
-    ant22: ''
-    ant23: ''
-    ant24: ''
-    ant25: ''
-    ant26: ''
-    ant27: ''
-    ant28: ''
-    ant29: ''
-    ant3: ''
-    ant30: ''
-    ant31: ''
-    ant4: ''
-    ant5: ''
-    ant6: ''
-    ant7: ''
-    ant8: ''
-    ant9: ''
-    args: hackrf=0
-    bb_gain0: '0'
-    bb_gain1: '20'
-    bb_gain10: '20'
-    bb_gain11: '20'
-    bb_gain12: '20'
-    bb_gain13: '20'
-    bb_gain14: '20'
-    bb_gain15: '20'
-    bb_gain16: '20'
-    bb_gain17: '20'
-    bb_gain18: '20'
-    bb_gain19: '20'
-    bb_gain2: '20'
-    bb_gain20: '20'
-    bb_gain21: '20'
-    bb_gain22: '20'
-    bb_gain23: '20'
-    bb_gain24: '20'
-    bb_gain25: '20'
-    bb_gain26: '20'
-    bb_gain27: '20'
-    bb_gain28: '20'
-    bb_gain29: '20'
-    bb_gain3: '20'
-    bb_gain30: '20'
-    bb_gain31: '20'
-    bb_gain4: '20'
-    bb_gain5: '20'
-    bb_gain6: '20'
-    bb_gain7: '20'
-    bb_gain8: '20'
-    bb_gain9: '20'
-    bw0: '0'
-    bw1: '0'
-    bw10: '0'
-    bw11: '0'
-    bw12: '0'
-    bw13: '0'
-    bw14: '0'
-    bw15: '0'
-    bw16: '0'
-    bw17: '0'
-    bw18: '0'
-    bw19: '0'
-    bw2: '0'
-    bw20: '0'
-    bw21: '0'
-    bw22: '0'
-    bw23: '0'
-    bw24: '0'
-    bw25: '0'
-    bw26: '0'
-    bw27: '0'
-    bw28: '0'
-    bw29: '0'
-    bw3: '0'
-    bw30: '0'
-    bw31: '0'
-    bw4: '0'
-    bw5: '0'
-    bw6: '0'
-    bw7: '0'
-    bw8: '0'
-    bw9: '0'
-    clock_source0: ''
-    clock_source1: ''
-    clock_source2: ''
-    clock_source3: ''
-    clock_source4: ''
-    clock_source5: ''
-    clock_source6: ''
-    clock_source7: ''
-    comment: ''
-    corr0: '0'
-    corr1: '0'
-    corr10: '0'
-    corr11: '0'
-    corr12: '0'
-    corr13: '0'
-    corr14: '0'
-    corr15: '0'
-    corr16: '0'
-    corr17: '0'
-    corr18: '0'
-    corr19: '0'
-    corr2: '0'
-    corr20: '0'
-    corr21: '0'
-    corr22: '0'
-    corr23: '0'
-    corr24: '0'
-    corr25: '0'
-    corr26: '0'
-    corr27: '0'
-    corr28: '0'
-    corr29: '0'
-    corr3: '0'
-    corr30: '0'
-    corr31: '0'
-    corr4: '0'
-    corr5: '0'
-    corr6: '0'
-    corr7: '0'
-    corr8: '0'
-    corr9: '0'
-    dc_offset_mode0: '0'
-    dc_offset_mode1: '0'
-    dc_offset_mode10: '0'
-    dc_offset_mode11: '0'
-    dc_offset_mode12: '0'
-    dc_offset_mode13: '0'
-    dc_offset_mode14: '0'
-    dc_offset_mode15: '0'
-    dc_offset_mode16: '0'
-    dc_offset_mode17: '0'
-    dc_offset_mode18: '0'
-    dc_offset_mode19: '0'
-    dc_offset_mode2: '0'
-    dc_offset_mode20: '0'
-    dc_offset_mode21: '0'
-    dc_offset_mode22: '0'
-    dc_offset_mode23: '0'
-    dc_offset_mode24: '0'
-    dc_offset_mode25: '0'
-    dc_offset_mode26: '0'
-    dc_offset_mode27: '0'
-    dc_offset_mode28: '0'
-    dc_offset_mode29: '0'
-    dc_offset_mode3: '0'
-    dc_offset_mode30: '0'
-    dc_offset_mode31: '0'
-    dc_offset_mode4: '0'
-    dc_offset_mode5: '0'
-    dc_offset_mode6: '0'
-    dc_offset_mode7: '0'
-    dc_offset_mode8: '0'
-    dc_offset_mode9: '0'
-    freq0: freq
-    freq1: 100e6
-    freq10: 100e6
-    freq11: 100e6
-    freq12: 100e6
-    freq13: 100e6
-    freq14: 100e6
-    freq15: 100e6
-    freq16: 100e6
-    freq17: 100e6
-    freq18: 100e6
-    freq19: 100e6
-    freq2: 100e6
-    freq20: 100e6
-    freq21: 100e6
-    freq22: 100e6
-    freq23: 100e6
-    freq24: 100e6
-    freq25: 100e6
-    freq26: 100e6
-    freq27: 100e6
-    freq28: 100e6
-    freq29: 100e6
-    freq3: 100e6
-    freq30: 100e6
-    freq31: 100e6
-    freq4: 100e6
-    freq5: 100e6
-    freq6: 100e6
-    freq7: 100e6
-    freq8: 100e6
-    freq9: 100e6
-    gain0: '100'
-    gain1: '10'
-    gain10: '10'
-    gain11: '10'
-    gain12: '10'
-    gain13: '10'
-    gain14: '10'
-    gain15: '10'
-    gain16: '10'
-    gain17: '10'
-    gain18: '10'
-    gain19: '10'
-    gain2: '10'
-    gain20: '10'
-    gain21: '10'
-    gain22: '10'
-    gain23: '10'
-    gain24: '10'
-    gain25: '10'
-    gain26: '10'
-    gain27: '10'
-    gain28: '10'
-    gain29: '10'
-    gain3: '10'
-    gain30: '10'
-    gain31: '10'
-    gain4: '10'
-    gain5: '10'
-    gain6: '10'
-    gain7: '10'
-    gain8: '10'
-    gain9: '10'
-    gain_mode0: 'False'
-    gain_mode1: 'False'
-    gain_mode10: 'False'
-    gain_mode11: 'False'
-    gain_mode12: 'False'
-    gain_mode13: 'False'
-    gain_mode14: 'False'
-    gain_mode15: 'False'
-    gain_mode16: 'False'
-    gain_mode17: 'False'
-    gain_mode18: 'False'
-    gain_mode19: 'False'
-    gain_mode2: 'False'
-    gain_mode20: 'False'
-    gain_mode21: 'False'
-    gain_mode22: 'False'
-    gain_mode23: 'False'
-    gain_mode24: 'False'
-    gain_mode25: 'False'
-    gain_mode26: 'False'
-    gain_mode27: 'False'
-    gain_mode28: 'False'
-    gain_mode29: 'False'
-    gain_mode3: 'False'
-    gain_mode30: 'False'
-    gain_mode31: 'False'
-    gain_mode4: 'False'
-    gain_mode5: 'False'
-    gain_mode6: 'False'
-    gain_mode7: 'False'
-    gain_mode8: 'False'
-    gain_mode9: 'False'
-    if_gain0: '100'
-    if_gain1: '20'
-    if_gain10: '20'
-    if_gain11: '20'
-    if_gain12: '20'
-    if_gain13: '20'
-    if_gain14: '20'
-    if_gain15: '20'
-    if_gain16: '20'
-    if_gain17: '20'
-    if_gain18: '20'
-    if_gain19: '20'
-    if_gain2: '20'
-    if_gain20: '20'
-    if_gain21: '20'
-    if_gain22: '20'
-    if_gain23: '20'
-    if_gain24: '20'
-    if_gain25: '20'
-    if_gain26: '20'
-    if_gain27: '20'
-    if_gain28: '20'
-    if_gain29: '20'
-    if_gain3: '20'
-    if_gain30: '20'
-    if_gain31: '20'
-    if_gain4: '20'
-    if_gain5: '20'
-    if_gain6: '20'
-    if_gain7: '20'
-    if_gain8: '20'
-    if_gain9: '20'
-    iq_balance_mode0: '0'
-    iq_balance_mode1: '0'
-    iq_balance_mode10: '0'
-    iq_balance_mode11: '0'
-    iq_balance_mode12: '0'
-    iq_balance_mode13: '0'
-    iq_balance_mode14: '0'
-    iq_balance_mode15: '0'
-    iq_balance_mode16: '0'
-    iq_balance_mode17: '0'
-    iq_balance_mode18: '0'
-    iq_balance_mode19: '0'
-    iq_balance_mode2: '0'
-    iq_balance_mode20: '0'
-    iq_balance_mode21: '0'
-    iq_balance_mode22: '0'
-    iq_balance_mode23: '0'
-    iq_balance_mode24: '0'
-    iq_balance_mode25: '0'
-    iq_balance_mode26: '0'
-    iq_balance_mode27: '0'
-    iq_balance_mode28: '0'
-    iq_balance_mode29: '0'
-    iq_balance_mode3: '0'
-    iq_balance_mode30: '0'
-    iq_balance_mode31: '0'
-    iq_balance_mode4: '0'
-    iq_balance_mode5: '0'
-    iq_balance_mode6: '0'
-    iq_balance_mode7: '0'
-    iq_balance_mode8: '0'
-    iq_balance_mode9: '0'
-    maxoutbuf: '0'
-    minoutbuf: '0'
-    nchan: '1'
-    num_mboards: '1'
-    sample_rate: samp_rate
-    sync: sync
-    time_source0: ''
-    time_source1: ''
-    time_source2: ''
-    time_source3: ''
-    time_source4: ''
-    time_source5: ''
-    time_source6: ''
-    time_source7: ''
-    type: fc32
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [448, 220.0]
-    rotation: 0
-    state: true
-- name: py_module
-  id: epy_module
-  parameters:
-    alias: ''
-    comment: ''
-    source_code: "# this module will be imported in the into your flowgraph\r\n\r\n\
-      import numpy\r\nimport os\r\nimport time \r\n\r\nf = 0\r\n\r\ndef work(lvl,\
-      \ min_f, max_f, step_f):\r\n    global f\r\n    if f < min_f:\r\n        f =\
-      \ min_f\r\n    f += step_f\r\n    if f > max_f:\r\n        f = min_f\r\n   \
-      \ print('ffffffffffffffffff: {0}'.format(f))    \r\n    return f\r\n        "
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [1128, 392.0]
-    rotation: 0
-    state: true
-- name: qtgui_number_sink_0
-  id: qtgui_number_sink
-  parameters:
-    affinity: ''
-    alias: ''
-    autoscale: 'False'
-    avg: '0'
-    color1: ("black", "black")
-    color10: ("black", "black")
-    color2: ("black", "black")
-    color3: ("black", "black")
-    color4: ("black", "black")
-    color5: ("black", "black")
-    color6: ("black", "black")
-    color7: ("black", "black")
-    color8: ("black", "black")
-    color9: ("black", "black")
-    comment: ''
-    factor1: '1'
-    factor10: '1'
-    factor2: '1'
-    factor3: '1'
-    factor4: '1'
-    factor5: '1'
-    factor6: '1'
-    factor7: '1'
-    factor8: '1'
-    factor9: '1'
-    graph_type: qtgui.NUM_GRAPH_NONE
-    gui_hint: ''
-    label1: ''
-    label10: ''
-    label2: ''
-    label3: ''
-    label4: ''
-    label5: ''
-    label6: ''
-    label7: ''
-    label8: ''
-    label9: ''
-    max: 0.95e9
-    min: 0.85e9
-    name: '""'
-    nconnections: '1'
-    type: float
-    unit1: ''
-    unit10: ''
-    unit2: ''
-    unit3: ''
-    unit4: ''
-    unit5: ''
-    unit6: ''
-    unit7: ''
-    unit8: ''
-    unit9: ''
-    update_time: '0.01'
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [992, 24.0]
-    rotation: 0
-    state: disabled
-- name: qtgui_time_sink_x_0
-  id: qtgui_time_sink_x
-  parameters:
-    affinity: ''
-    alias: ''
-    alpha1: '1.0'
-    alpha10: '1.0'
-    alpha2: '1.0'
-    alpha3: '1.0'
-    alpha4: '1.0'
-    alpha5: '1.0'
-    alpha6: '1.0'
-    alpha7: '1.0'
-    alpha8: '1.0'
-    alpha9: '1.0'
-    autoscale: 'False'
-    axislabels: 'True'
-    color1: blue
-    color10: dark blue
-    color2: red
-    color3: green
-    color4: black
-    color5: cyan
-    color6: magenta
-    color7: yellow
-    color8: dark red
-    color9: dark green
-    comment: ''
-    ctrlpanel: 'False'
-    entags: 'True'
-    grid: 'False'
-    gui_hint: ''
-    label1: Signal 1
-    label10: Signal 10
-    label2: Signal 2
-    label3: Signal 3
-    label4: Signal 4
-    label5: Signal 5
-    label6: Signal 6
-    label7: Signal 7
-    label8: Signal 8
-    label9: Signal 9
-    legend: 'True'
-    marker1: '-1'
-    marker10: '-1'
-    marker2: '-1'
-    marker3: '-1'
-    marker4: '-1'
-    marker5: '-1'
-    marker6: '-1'
-    marker7: '-1'
-    marker8: '-1'
-    marker9: '-1'
-    name: freq
-    nconnections: '1'
-    size: '1000000'
-    srate: samp_rate
-    stemplot: 'False'
-    style1: '1'
-    style10: '1'
-    style2: '1'
-    style3: '1'
-    style4: '1'
-    style5: '1'
-    style6: '1'
-    style7: '1'
-    style8: '1'
-    style9: '1'
-    tr_chan: '0'
-    tr_delay: '0'
-    tr_level: '0.0'
-    tr_mode: qtgui.TRIG_MODE_FREE
-    tr_slope: qtgui.TRIG_SLOPE_POS
-    tr_tag: '""'
-    type: complex
-    update_time: '0.10'
-    width1: '1'
-    width10: '1'
-    width2: '1'
-    width3: '1'
-    width4: '1'
-    width5: '1'
-    width6: '1'
-    width7: '1'
-    width8: '1'
-    width9: '1'
-    ylabel: Amplitude
-    ymax: '1'
-    ymin: '-1'
-    yunit: '""'
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [928, 272.0]
-    rotation: 0
-    state: enabled
-- name: vec_probe
-  id: blocks_probe_signal_vx
-  parameters:
-    affinity: ''
-    alias: ''
-    comment: ''
-    type: complex
-    vlen: '1'
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [936, 384.0]
-    rotation: 0
-    state: true
-
-connections:
-- [analog_const_source_x_0, '0', qtgui_number_sink_0, '0']
-- [osmosdr_source_0, '0', qtgui_time_sink_x_0, '0']
-- [osmosdr_source_0, '0', vec_probe, '0']
-
-metadata:
-  file_format: 1
-  grc_version: 3.10.7.0

scripts_nn/data_saver.grc

@@ -1,642 +0,0 @@
-options:
-  parameters:
-    author: ''
-    catch_exceptions: 'True'
-    category: '[GRC Hier Blocks]'
-    cmake_opt: ''
-    comment: ''
-    copyright: ''
-    description: ''
-    gen_cmake: 'On'
-    gen_linking: dynamic
-    generate_options: qt_gui
-    hier_block_src_path: '.:'
-    id: data_saver
-    max_nouts: '0'
-    output_language: python
-    placement: (0,0)
-    qt_qss_theme: ''
-    realtime_scheduling: ''
-    run: 'True'
-    run_command: '{python} -u {filename}'
-    run_options: prompt
-    sizing_mode: fixed
-    thread_safe_setters: ''
-    title: data_saver
-    window_size: ''
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [8, 8]
-    rotation: 0
-    state: enabled
-
-blocks:
-- name: freq
-  id: variable
-  parameters:
-    comment: ''
-    value: 1.160e9
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [56, 307]
-    rotation: 0
-    state: true
-- name: samp_rate
-  id: variable
-  parameters:
-    comment: ''
-    value: 20e6
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [56, 212]
-    rotation: 0
-    state: enabled
-- name: epy_block_0
-  id: epy_block
-  parameters:
-    Delay: '0.1'
-    FileTag: '''DJI_3'''
-    SaveDir: '''D:/Dataset/1160'''
-    SplitSize: '400000'
-    _source_code: "\"\"\"\nEmbedded Python Blocks:\n\nEach time this file is saved,\
-      \ GRC will instantiate the first class it finds\nto get ports and parameters\
-      \ of your block. The arguments to __init__  will\nbe the parameters. All of\
-      \ them are required to have default values!\n\"\"\"\n\nimport numpy as np\n\
-      from gnuradio import gr\nimport os\nimport time\nimport matplotlib.pyplot as\
-      \ plt\nimport sys\nimport gc\n\nclass Simsi_Sink(gr.sync_block):  # other base\
-      \ classes are basic_block, decim_block, interp_block\n    \"\"\"Embedded Python\
-      \ Block example - a simple multiply const\"\"\"\n\n    def __init__(self, SaveDir=\"\
-      ./signal\", FileTag=\"fragment_\", SplitSize=1000000, Delay=2):  # only default\
-      \ arguments here\n        \"\"\"arguments to this function show up as parameters\
-      \ in GRC\"\"\"\n        gr.sync_block.__init__(\n            self,\n       \
-      \     name='Simsi_Sink',   # will show up in GRC\n            in_sig=[np.complex64],\n\
-      \            out_sig=None#[np.complex64]\n        )\n        self.Delay = Delay\n\
-      \        self.FileTag = FileTag\n        self.SplitSize = SplitSize\n      \
-      \  \n        self.SaveDir = SaveDir\n        if not os.path.exists(self.SaveDir)\
-      \ and self.SaveDir == \"./signal\":\n            os.mkdir(\"signal\")\n    \
-      \        \n        self.it = 0\n        self.Signal = np.array([], dtype=np.float32)\n\
-      \        self.data_dir = SaveDir\n\n        self.last_file_path = self.data_dir\
-      \ + \"/\" + self.FileTag + str(self.it)\n        self.last_fd = open(self.last_file_path,\
-      \ \"wb\")\n        self.last_file_len = 0\n\n\n        self.reading_in_progress_file_path\
-      \ = self.data_dir + \"/reading_in_progress\"\n        self.reading_in_progress_file_fd\
-      \ = open(self.reading_in_progress_file_path, \"wb\")\n\n        print(self.Signal)\n\
-      \        print(self.data_dir)\n        # if an attribute with the same name\
-      \ as a parameter is found,\n        # a callback is registered (properties work,\
-      \ too).\n\n    def work(self, input_items, output_items):\n        \"\"\"example:\
-      \ multiply with constant\"\"\"\n        length = len(input_items[0])\n     \
-      \   self.last_file_len += length\n\n        if self.last_file_len > self.SplitSize:\n\
-      \            print(\"Saving file: \" + str(self.last_file_path))\n         \
-      \   length = length - (self.last_file_len - self.SplitSize)\n            self.last_fd.write(input_items[0][0:length].copy())\n\
-      \            self.it += 1\n            self.last_file_len = 0\n            self.last_file_path\
-      \ = self.data_dir + '/' + self.FileTag + str(self.it)\n            self.last_fd.close()\n\
-      \            self.reading_in_progress_file_fd.close()\n            os.remove(self.reading_in_progress_file_path)\n\
-      \            time.sleep(self.Delay)\n            self.reading_in_progress_file_fd\
-      \ = open(self.reading_in_progress_file_path, \"wb\")\n            self.last_fd\
-      \ = open(self.last_file_path, \"wb\")\n            \n        else:\n       \
-      \     self.last_fd.write(input_items[0].copy())\n\n\n        return len(input_items[0])\n"
-    affinity: ''
-    alias: ''
-    comment: ''
-    maxoutbuf: '0'
-    minoutbuf: '0'
-  states:
-    _io_cache: ('Simsi_Sink', 'Simsi_Sink', [('SaveDir', "'./signal'"), ('FileTag',
-      "'fragment_'"), ('SplitSize', '1000000'), ('Delay', '2')], [('0', 'complex',
-      1)], [], 'Embedded Python Block example - a simple multiply const', ['Delay',
-      'FileTag', 'SaveDir', 'SplitSize'])
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [728, 336.0]
-    rotation: 0
-    state: enabled
-- name: osmosdr_source_1
-  id: osmosdr_source
-  parameters:
-    affinity: ''
-    alias: ''
-    ant0: ''
-    ant1: ''
-    ant10: ''
-    ant11: ''
-    ant12: ''
-    ant13: ''
-    ant14: ''
-    ant15: ''
-    ant16: ''
-    ant17: ''
-    ant18: ''
-    ant19: ''
-    ant2: ''
-    ant20: ''
-    ant21: ''
-    ant22: ''
-    ant23: ''
-    ant24: ''
-    ant25: ''
-    ant26: ''
-    ant27: ''
-    ant28: ''
-    ant29: ''
-    ant3: ''
-    ant30: ''
-    ant31: ''
-    ant4: ''
-    ant5: ''
-    ant6: ''
-    ant7: ''
-    ant8: ''
-    ant9: ''
-    args: hackrf=0
-    bb_gain0: '36'
-    bb_gain1: '20'
-    bb_gain10: '20'
-    bb_gain11: '20'
-    bb_gain12: '20'
-    bb_gain13: '20'
-    bb_gain14: '20'
-    bb_gain15: '20'
-    bb_gain16: '20'
-    bb_gain17: '20'
-    bb_gain18: '20'
-    bb_gain19: '20'
-    bb_gain2: '20'
-    bb_gain20: '20'
-    bb_gain21: '20'
-    bb_gain22: '20'
-    bb_gain23: '20'
-    bb_gain24: '20'
-    bb_gain25: '20'
-    bb_gain26: '20'
-    bb_gain27: '20'
-    bb_gain28: '20'
-    bb_gain29: '20'
-    bb_gain3: '20'
-    bb_gain30: '20'
-    bb_gain31: '20'
-    bb_gain4: '20'
-    bb_gain5: '20'
-    bb_gain6: '20'
-    bb_gain7: '20'
-    bb_gain8: '20'
-    bb_gain9: '20'
-    bw0: '0'
-    bw1: '0'
-    bw10: '0'
-    bw11: '0'
-    bw12: '0'
-    bw13: '0'
-    bw14: '0'
-    bw15: '0'
-    bw16: '0'
-    bw17: '0'
-    bw18: '0'
-    bw19: '0'
-    bw2: '0'
-    bw20: '0'
-    bw21: '0'
-    bw22: '0'
-    bw23: '0'
-    bw24: '0'
-    bw25: '0'
-    bw26: '0'
-    bw27: '0'
-    bw28: '0'
-    bw29: '0'
-    bw3: '0'
-    bw30: '0'
-    bw31: '0'
-    bw4: '0'
-    bw5: '0'
-    bw6: '0'
-    bw7: '0'
-    bw8: '0'
-    bw9: '0'
-    clock_source0: ''
-    clock_source1: ''
-    clock_source2: ''
-    clock_source3: ''
-    clock_source4: ''
-    clock_source5: ''
-    clock_source6: ''
-    clock_source7: ''
-    comment: ''
-    corr0: '0'
-    corr1: '0'
-    corr10: '0'
-    corr11: '0'
-    corr12: '0'
-    corr13: '0'
-    corr14: '0'
-    corr15: '0'
-    corr16: '0'
-    corr17: '0'
-    corr18: '0'
-    corr19: '0'
-    corr2: '0'
-    corr20: '0'
-    corr21: '0'
-    corr22: '0'
-    corr23: '0'
-    corr24: '0'
-    corr25: '0'
-    corr26: '0'
-    corr27: '0'
-    corr28: '0'
-    corr29: '0'
-    corr3: '0'
-    corr30: '0'
-    corr31: '0'
-    corr4: '0'
-    corr5: '0'
-    corr6: '0'
-    corr7: '0'
-    corr8: '0'
-    corr9: '0'
-    dc_offset_mode0: '0'
-    dc_offset_mode1: '0'
-    dc_offset_mode10: '0'
-    dc_offset_mode11: '0'
-    dc_offset_mode12: '0'
-    dc_offset_mode13: '0'
-    dc_offset_mode14: '0'
-    dc_offset_mode15: '0'
-    dc_offset_mode16: '0'
-    dc_offset_mode17: '0'
-    dc_offset_mode18: '0'
-    dc_offset_mode19: '0'
-    dc_offset_mode2: '0'
-    dc_offset_mode20: '0'
-    dc_offset_mode21: '0'
-    dc_offset_mode22: '0'
-    dc_offset_mode23: '0'
-    dc_offset_mode24: '0'
-    dc_offset_mode25: '0'
-    dc_offset_mode26: '0'
-    dc_offset_mode27: '0'
-    dc_offset_mode28: '0'
-    dc_offset_mode29: '0'
-    dc_offset_mode3: '0'
-    dc_offset_mode30: '0'
-    dc_offset_mode31: '0'
-    dc_offset_mode4: '0'
-    dc_offset_mode5: '0'
-    dc_offset_mode6: '0'
-    dc_offset_mode7: '0'
-    dc_offset_mode8: '0'
-    dc_offset_mode9: '0'
-    freq0: freq
-    freq1: 100e6
-    freq10: 100e6
-    freq11: 100e6
-    freq12: 100e6
-    freq13: 100e6
-    freq14: 100e6
-    freq15: 100e6
-    freq16: 100e6
-    freq17: 100e6
-    freq18: 100e6
-    freq19: 100e6
-    freq2: 100e6
-    freq20: 100e6
-    freq21: 100e6
-    freq22: 100e6
-    freq23: 100e6
-    freq24: 100e6
-    freq25: 100e6
-    freq26: 100e6
-    freq27: 100e6
-    freq28: 100e6
-    freq29: 100e6
-    freq3: 100e6
-    freq30: 100e6
-    freq31: 100e6
-    freq4: 100e6
-    freq5: 100e6
-    freq6: 100e6
-    freq7: 100e6
-    freq8: 100e6
-    freq9: 100e6
-    gain0: '12'
-    gain1: '10'
-    gain10: '10'
-    gain11: '10'
-    gain12: '10'
-    gain13: '10'
-    gain14: '10'
-    gain15: '10'
-    gain16: '10'
-    gain17: '10'
-    gain18: '10'
-    gain19: '10'
-    gain2: '10'
-    gain20: '10'
-    gain21: '10'
-    gain22: '10'
-    gain23: '10'
-    gain24: '10'
-    gain25: '10'
-    gain26: '10'
-    gain27: '10'
-    gain28: '10'
-    gain29: '10'
-    gain3: '10'
-    gain30: '10'
-    gain31: '10'
-    gain4: '10'
-    gain5: '10'
-    gain6: '10'
-    gain7: '10'
-    gain8: '10'
-    gain9: '10'
-    gain_mode0: 'False'
-    gain_mode1: 'False'
-    gain_mode10: 'False'
-    gain_mode11: 'False'
-    gain_mode12: 'False'
-    gain_mode13: 'False'
-    gain_mode14: 'False'
-    gain_mode15: 'False'
-    gain_mode16: 'False'
-    gain_mode17: 'False'
-    gain_mode18: 'False'
-    gain_mode19: 'False'
-    gain_mode2: 'False'
-    gain_mode20: 'False'
-    gain_mode21: 'False'
-    gain_mode22: 'False'
-    gain_mode23: 'False'
-    gain_mode24: 'False'
-    gain_mode25: 'False'
-    gain_mode26: 'False'
-    gain_mode27: 'False'
-    gain_mode28: 'False'
-    gain_mode29: 'False'
-    gain_mode3: 'False'
-    gain_mode30: 'False'
-    gain_mode31: 'False'
-    gain_mode4: 'False'
-    gain_mode5: 'False'
-    gain_mode6: 'False'
-    gain_mode7: 'False'
-    gain_mode8: 'False'
-    gain_mode9: 'False'
-    if_gain0: '30'
-    if_gain1: '20'
-    if_gain10: '20'
-    if_gain11: '20'
-    if_gain12: '20'
-    if_gain13: '20'
-    if_gain14: '20'
-    if_gain15: '20'
-    if_gain16: '20'
-    if_gain17: '20'
-    if_gain18: '20'
-    if_gain19: '20'
-    if_gain2: '20'
-    if_gain20: '20'
-    if_gain21: '20'
-    if_gain22: '20'
-    if_gain23: '20'
-    if_gain24: '20'
-    if_gain25: '20'
-    if_gain26: '20'
-    if_gain27: '20'
-    if_gain28: '20'
-    if_gain29: '20'
-    if_gain3: '20'
-    if_gain30: '20'
-    if_gain31: '20'
-    if_gain4: '20'
-    if_gain5: '20'
-    if_gain6: '20'
-    if_gain7: '20'
-    if_gain8: '20'
-    if_gain9: '20'
-    iq_balance_mode0: '0'
-    iq_balance_mode1: '0'
-    iq_balance_mode10: '0'
-    iq_balance_mode11: '0'
-    iq_balance_mode12: '0'
-    iq_balance_mode13: '0'
-    iq_balance_mode14: '0'
-    iq_balance_mode15: '0'
-    iq_balance_mode16: '0'
-    iq_balance_mode17: '0'
-    iq_balance_mode18: '0'
-    iq_balance_mode19: '0'
-    iq_balance_mode2: '0'
-    iq_balance_mode20: '0'
-    iq_balance_mode21: '0'
-    iq_balance_mode22: '0'
-    iq_balance_mode23: '0'
-    iq_balance_mode24: '0'
-    iq_balance_mode25: '0'
-    iq_balance_mode26: '0'
-    iq_balance_mode27: '0'
-    iq_balance_mode28: '0'
-    iq_balance_mode29: '0'
-    iq_balance_mode3: '0'
-    iq_balance_mode30: '0'
-    iq_balance_mode31: '0'
-    iq_balance_mode4: '0'
-    iq_balance_mode5: '0'
-    iq_balance_mode6: '0'
-    iq_balance_mode7: '0'
-    iq_balance_mode8: '0'
-    iq_balance_mode9: '0'
-    maxoutbuf: '0'
-    minoutbuf: '0'
-    nchan: '1'
-    num_mboards: '1'
-    sample_rate: samp_rate
-    sync: sync
-    time_source0: ''
-    time_source1: ''
-    time_source2: ''
-    time_source3: ''
-    time_source4: ''
-    time_source5: ''
-    time_source6: ''
-    time_source7: ''
-    type: fc32
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [244, 164]
-    rotation: 0
-    state: true
-- name: qtgui_time_sink_x_0_1
-  id: qtgui_time_sink_x
-  parameters:
-    affinity: ''
-    alias: ''
-    alpha1: '1.0'
-    alpha10: '1.0'
-    alpha2: '1.0'
-    alpha3: '1.0'
-    alpha4: '1.0'
-    alpha5: '1.0'
-    alpha6: '1.0'
-    alpha7: '1.0'
-    alpha8: '1.0'
-    alpha9: '1.0'
-    autoscale: 'False'
-    axislabels: 'True'
-    color1: blue
-    color10: dark blue
-    color2: red
-    color3: green
-    color4: black
-    color5: cyan
-    color6: magenta
-    color7: yellow
-    color8: dark red
-    color9: dark green
-    comment: ''
-    ctrlpanel: 'False'
-    entags: 'True'
-    grid: 'False'
-    gui_hint: ''
-    label1: ''
-    label10: ''
-    label2: ''
-    label3: ''
-    label4: ''
-    label5: ''
-    label6: ''
-    label7: ''
-    label8: ''
-    label9: ''
-    legend: 'True'
-    marker1: '-1'
-    marker10: '-1'
-    marker2: '-1'
-    marker3: '-1'
-    marker4: '-1'
-    marker5: '-1'
-    marker6: '-1'
-    marker7: '-1'
-    marker8: '-1'
-    marker9: '-1'
-    name: '""'
-    nconnections: '1'
-    size: '1000000'
-    srate: samp_rate
-    stemplot: 'False'
-    style1: '1'
-    style10: '1'
-    style2: '1'
-    style3: '1'
-    style4: '1'
-    style5: '1'
-    style6: '1'
-    style7: '1'
-    style8: '1'
-    style9: '1'
-    tr_chan: '0'
-    tr_delay: '0'
-    tr_level: '0.0'
-    tr_mode: qtgui.TRIG_MODE_FREE
-    tr_slope: qtgui.TRIG_SLOPE_POS
-    tr_tag: '""'
-    type: complex
-    update_time: '0.01'
-    width1: '1'
-    width10: '1'
-    width2: '1'
-    width3: '1'
-    width4: '1'
-    width5: '1'
-    width6: '1'
-    width7: '1'
-    width8: '1'
-    width9: '1'
-    ylabel: Amplitude
-    ymax: '2'
-    ymin: '-2'
-    yunit: '""'
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [720, 92.0]
-    rotation: 0
-    state: enabled
-- name: qtgui_waterfall_sink_x_0
-  id: qtgui_waterfall_sink_x
-  parameters:
-    affinity: ''
-    alias: ''
-    alpha1: '1.0'
-    alpha10: '1.0'
-    alpha2: '1.0'
-    alpha3: '1.0'
-    alpha4: '1.0'
-    alpha5: '1.0'
-    alpha6: '1.0'
-    alpha7: '1.0'
-    alpha8: '1.0'
-    alpha9: '1.0'
-    axislabels: 'True'
-    bw: samp_rate
-    color1: '0'
-    color10: '0'
-    color2: '0'
-    color3: '0'
-    color4: '0'
-    color5: '0'
-    color6: '0'
-    color7: '0'
-    color8: '0'
-    color9: '0'
-    comment: ''
-    fc: freq
-    fftsize: '32768'
-    freqhalf: 'True'
-    grid: 'False'
-    gui_hint: ''
-    int_max: '10'
-    int_min: '-140'
-    label1: ''
-    label10: ''
-    label2: ''
-    label3: ''
-    label4: ''
-    label5: ''
-    label6: ''
-    label7: ''
-    label8: ''
-    label9: ''
-    legend: 'True'
-    maxoutbuf: '0'
-    minoutbuf: '0'
-    name: '""'
-    nconnections: '1'
-    showports: 'False'
-    type: complex
-    update_time: '0.10'
-    wintype: window.WIN_HAMMING
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [1040, 172.0]
-    rotation: 0
-    state: enabled
-
-connections:
-- [osmosdr_source_1, '0', epy_block_0, '0']
-- [osmosdr_source_1, '0', qtgui_time_sink_x_0_1, '0']
-- [osmosdr_source_1, '0', qtgui_waterfall_sink_x_0, '0']
-
-metadata:
-  file_format: 1
-  grc_version: 3.10.9.2

scripts_nn/fft_detector.grc

@@ -1,683 +0,0 @@
-options:
-  parameters:
-    author: ''
-    catch_exceptions: 'True'
-    category: '[GRC Hier Blocks]'
-    cmake_opt: ''
-    comment: ''
-    copyright: ''
-    description: ''
-    gen_cmake: 'On'
-    gen_linking: dynamic
-    generate_options: no_gui
-    hier_block_src_path: '.:'
-    id: fft_detector
-    max_nouts: '0'
-    output_language: python
-    placement: (0,0)
-    qt_qss_theme: ''
-    realtime_scheduling: ''
-    run: 'True'
-    run_command: '{python} -u {filename}'
-    run_options: prompt
-    sizing_mode: fixed
-    thread_safe_setters: ''
-    title: fft_detector
-    window_size: (1000,1000)
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [8, 8]
-    rotation: 0
-    state: enabled
-
-blocks:
-- name: filter1
-  id: variable
-  parameters:
-    comment: ''
-    value: firdes.low_pass (1, samp_rate, 500e3, 300e3, window.WIN_BLACKMAN_HARRIS)
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [464, 16.0]
-    rotation: 0
-    state: true
-- name: filter2
-  id: variable
-  parameters:
-    comment: ''
-    value: firdes.low_pass(1,samp_rate, 5e3, 3e3, window.WIN_HANN)
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [696, 16.0]
-    rotation: 0
-    state: true
-- name: freq
-  id: variable
-  parameters:
-    comment: ''
-    value: py_module.work(func_probe)
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [368, 16.0]
-    rotation: 0
-    state: true
-- name: func_probe
-  id: variable_function_probe
-  parameters:
-    block_id: vec_probe
-    comment: ''
-    function_args: ''
-    function_name: level
-    poll_rate: '100'
-    value: '0'
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [1312, 128.0]
-    rotation: 0
-    state: enabled
-- name: max_f
-  id: variable
-  parameters:
-    comment: ''
-    value: 2.46e9
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [536, 16.0]
-    rotation: 0
-    state: disabled
-- name: min_f
-  id: variable
-  parameters:
-    comment: ''
-    value: 2.4e9
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [456, 16.0]
-    rotation: 0
-    state: disabled
-- name: samp_rate
-  id: variable
-  parameters:
-    comment: ''
-    value: 20e6
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [184, 12]
-    rotation: 0
-    state: enabled
-- name: blocks_complex_to_mag_squared_0
-  id: blocks_complex_to_mag_squared
-  parameters:
-    affinity: ''
-    alias: ''
-    comment: ''
-    maxoutbuf: '0'
-    minoutbuf: '0'
-    vlen: '2048'
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [840, 120.0]
-    rotation: 0
-    state: true
-- name: blocks_integrate_xx_0
-  id: blocks_integrate_xx
-  parameters:
-    affinity: ''
-    alias: ''
-    comment: ''
-    decim: '10'
-    maxoutbuf: '0'
-    minoutbuf: '0'
-    type: float
-    vlen: '2048'
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [840, 192.0]
-    rotation: 0
-    state: true
-- name: blocks_keep_one_in_n_0
-  id: blocks_keep_one_in_n
-  parameters:
-    affinity: ''
-    alias: ''
-    comment: ''
-    maxoutbuf: '0'
-    minoutbuf: '0'
-    n: '1'
-    type: complex
-    vlen: '2048'
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [368, 272.0]
-    rotation: 0
-    state: true
-- name: blocks_nlog10_ff_0
-  id: blocks_nlog10_ff
-  parameters:
-    affinity: ''
-    alias: ''
-    comment: ''
-    k: '-100'
-    maxoutbuf: '0'
-    minoutbuf: '0'
-    n: '10'
-    vlen: '2048'
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [840, 280.0]
-    rotation: 0
-    state: true
-- name: blocks_stream_to_vector_0_0
-  id: blocks_stream_to_vector
-  parameters:
-    affinity: ''
-    alias: ''
-    comment: ''
-    maxoutbuf: '0'
-    minoutbuf: '0'
-    num_items: '2048'
-    type: complex
-    vlen: '1'
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [368, 216.0]
-    rotation: 0
-    state: true
-- name: dc_blocker_xx_0
-  id: dc_blocker_xx
-  parameters:
-    affinity: ''
-    alias: ''
-    comment: ''
-    length: '1024'
-    long_form: 'True'
-    maxoutbuf: '0'
-    minoutbuf: '0'
-    type: cc
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [368, 136.0]
-    rotation: 0
-    state: true
-- name: fft_vxx_0
-  id: fft_vxx
-  parameters:
-    affinity: ''
-    alias: ''
-    comment: ''
-    fft_size: '2048'
-    forward: 'True'
-    maxoutbuf: '0'
-    minoutbuf: '0'
-    nthreads: '1'
-    shift: 'True'
-    type: complex
-    window: window.blackmanharris(2048)
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [576, 192.0]
-    rotation: 0
-    state: true
-- name: osmosdr_source_0
-  id: osmosdr_source
-  parameters:
-    affinity: ''
-    alias: ''
-    ant0: ''
-    ant1: ''
-    ant10: ''
-    ant11: ''
-    ant12: ''
-    ant13: ''
-    ant14: ''
-    ant15: ''
-    ant16: ''
-    ant17: ''
-    ant18: ''
-    ant19: ''
-    ant2: ''
-    ant20: ''
-    ant21: ''
-    ant22: ''
-    ant23: ''
-    ant24: ''
-    ant25: ''
-    ant26: ''
-    ant27: ''
-    ant28: ''
-    ant29: ''
-    ant3: ''
-    ant30: ''
-    ant31: ''
-    ant4: ''
-    ant5: ''
-    ant6: ''
-    ant7: ''
-    ant8: ''
-    ant9: ''
-    args: hackrf=0
-    bb_gain0: '0'
-    bb_gain1: '20'
-    bb_gain10: '20'
-    bb_gain11: '20'
-    bb_gain12: '20'
-    bb_gain13: '20'
-    bb_gain14: '20'
-    bb_gain15: '20'
-    bb_gain16: '20'
-    bb_gain17: '20'
-    bb_gain18: '20'
-    bb_gain19: '20'
-    bb_gain2: '20'
-    bb_gain20: '20'
-    bb_gain21: '20'
-    bb_gain22: '20'
-    bb_gain23: '20'
-    bb_gain24: '20'
-    bb_gain25: '20'
-    bb_gain26: '20'
-    bb_gain27: '20'
-    bb_gain28: '20'
-    bb_gain29: '20'
-    bb_gain3: '20'
-    bb_gain30: '20'
-    bb_gain31: '20'
-    bb_gain4: '20'
-    bb_gain5: '20'
-    bb_gain6: '20'
-    bb_gain7: '20'
-    bb_gain8: '20'
-    bb_gain9: '20'
-    bw0: 20e6
-    bw1: '0'
-    bw10: '0'
-    bw11: '0'
-    bw12: '0'
-    bw13: '0'
-    bw14: '0'
-    bw15: '0'
-    bw16: '0'
-    bw17: '0'
-    bw18: '0'
-    bw19: '0'
-    bw2: '0'
-    bw20: '0'
-    bw21: '0'
-    bw22: '0'
-    bw23: '0'
-    bw24: '0'
-    bw25: '0'
-    bw26: '0'
-    bw27: '0'
-    bw28: '0'
-    bw29: '0'
-    bw3: '0'
-    bw30: '0'
-    bw31: '0'
-    bw4: '0'
-    bw5: '0'
-    bw6: '0'
-    bw7: '0'
-    bw8: '0'
-    bw9: '0'
-    clock_source0: ''
-    clock_source1: ''
-    clock_source2: ''
-    clock_source3: ''
-    clock_source4: ''
-    clock_source5: ''
-    clock_source6: ''
-    clock_source7: ''
-    comment: ''
-    corr0: '0'
-    corr1: '0'
-    corr10: '0'
-    corr11: '0'
-    corr12: '0'
-    corr13: '0'
-    corr14: '0'
-    corr15: '0'
-    corr16: '0'
-    corr17: '0'
-    corr18: '0'
-    corr19: '0'
-    corr2: '0'
-    corr20: '0'
-    corr21: '0'
-    corr22: '0'
-    corr23: '0'
-    corr24: '0'
-    corr25: '0'
-    corr26: '0'
-    corr27: '0'
-    corr28: '0'
-    corr29: '0'
-    corr3: '0'
-    corr30: '0'
-    corr31: '0'
-    corr4: '0'
-    corr5: '0'
-    corr6: '0'
-    corr7: '0'
-    corr8: '0'
-    corr9: '0'
-    dc_offset_mode0: '0'
-    dc_offset_mode1: '0'
-    dc_offset_mode10: '0'
-    dc_offset_mode11: '0'
-    dc_offset_mode12: '0'
-    dc_offset_mode13: '0'
-    dc_offset_mode14: '0'
-    dc_offset_mode15: '0'
-    dc_offset_mode16: '0'
-    dc_offset_mode17: '0'
-    dc_offset_mode18: '0'
-    dc_offset_mode19: '0'
-    dc_offset_mode2: '0'
-    dc_offset_mode20: '0'
-    dc_offset_mode21: '0'
-    dc_offset_mode22: '0'
-    dc_offset_mode23: '0'
-    dc_offset_mode24: '0'
-    dc_offset_mode25: '0'
-    dc_offset_mode26: '0'
-    dc_offset_mode27: '0'
-    dc_offset_mode28: '0'
-    dc_offset_mode29: '0'
-    dc_offset_mode3: '0'
-    dc_offset_mode30: '0'
-    dc_offset_mode31: '0'
-    dc_offset_mode4: '0'
-    dc_offset_mode5: '0'
-    dc_offset_mode6: '0'
-    dc_offset_mode7: '0'
-    dc_offset_mode8: '0'
-    dc_offset_mode9: '0'
-    freq0: freq
-    freq1: 100e6
-    freq10: 100e6
-    freq11: 100e6
-    freq12: 100e6
-    freq13: 100e6
-    freq14: 100e6
-    freq15: 100e6
-    freq16: 100e6
-    freq17: 100e6
-    freq18: 100e6
-    freq19: 100e6
-    freq2: 100e6
-    freq20: 100e6
-    freq21: 100e6
-    freq22: 100e6
-    freq23: 100e6
-    freq24: 100e6
-    freq25: 100e6
-    freq26: 100e6
-    freq27: 100e6
-    freq28: 100e6
-    freq29: 100e6
-    freq3: 100e6
-    freq30: 100e6
-    freq31: 100e6
-    freq4: 100e6
-    freq5: 100e6
-    freq6: 100e6
-    freq7: 100e6
-    freq8: 100e6
-    freq9: 100e6
-    gain0: '100'
-    gain1: '10'
-    gain10: '10'
-    gain11: '10'
-    gain12: '10'
-    gain13: '10'
-    gain14: '10'
-    gain15: '10'
-    gain16: '10'
-    gain17: '10'
-    gain18: '10'
-    gain19: '10'
-    gain2: '10'
-    gain20: '10'
-    gain21: '10'
-    gain22: '10'
-    gain23: '10'
-    gain24: '10'
-    gain25: '10'
-    gain26: '10'
-    gain27: '10'
-    gain28: '10'
-    gain29: '10'
-    gain3: '10'
-    gain30: '10'
-    gain31: '10'
-    gain4: '10'
-    gain5: '10'
-    gain6: '10'
-    gain7: '10'
-    gain8: '10'
-    gain9: '10'
-    gain_mode0: 'False'
-    gain_mode1: 'False'
-    gain_mode10: 'False'
-    gain_mode11: 'False'
-    gain_mode12: 'False'
-    gain_mode13: 'False'
-    gain_mode14: 'False'
-    gain_mode15: 'False'
-    gain_mode16: 'False'
-    gain_mode17: 'False'
-    gain_mode18: 'False'
-    gain_mode19: 'False'
-    gain_mode2: 'False'
-    gain_mode20: 'False'
-    gain_mode21: 'False'
-    gain_mode22: 'False'
-    gain_mode23: 'False'
-    gain_mode24: 'False'
-    gain_mode25: 'False'
-    gain_mode26: 'False'
-    gain_mode27: 'False'
-    gain_mode28: 'False'
-    gain_mode29: 'False'
-    gain_mode3: 'False'
-    gain_mode30: 'False'
-    gain_mode31: 'False'
-    gain_mode4: 'False'
-    gain_mode5: 'False'
-    gain_mode6: 'False'
-    gain_mode7: 'False'
-    gain_mode8: 'False'
-    gain_mode9: 'False'
-    if_gain0: '100'
-    if_gain1: '20'
-    if_gain10: '20'
-    if_gain11: '20'
-    if_gain12: '20'
-    if_gain13: '20'
-    if_gain14: '20'
-    if_gain15: '20'
-    if_gain16: '20'
-    if_gain17: '20'
-    if_gain18: '20'
-    if_gain19: '20'
-    if_gain2: '20'
-    if_gain20: '20'
-    if_gain21: '20'
-    if_gain22: '20'
-    if_gain23: '20'
-    if_gain24: '20'
-    if_gain25: '20'
-    if_gain26: '20'
-    if_gain27: '20'
-    if_gain28: '20'
-    if_gain29: '20'
-    if_gain3: '20'
-    if_gain30: '20'
-    if_gain31: '20'
-    if_gain4: '20'
-    if_gain5: '20'
-    if_gain6: '20'
-    if_gain7: '20'
-    if_gain8: '20'
-    if_gain9: '20'
-    iq_balance_mode0: '0'
-    iq_balance_mode1: '0'
-    iq_balance_mode10: '0'
-    iq_balance_mode11: '0'
-    iq_balance_mode12: '0'
-    iq_balance_mode13: '0'
-    iq_balance_mode14: '0'
-    iq_balance_mode15: '0'
-    iq_balance_mode16: '0'
-    iq_balance_mode17: '0'
-    iq_balance_mode18: '0'
-    iq_balance_mode19: '0'
-    iq_balance_mode2: '0'
-    iq_balance_mode20: '0'
-    iq_balance_mode21: '0'
-    iq_balance_mode22: '0'
-    iq_balance_mode23: '0'
-    iq_balance_mode24: '0'
-    iq_balance_mode25: '0'
-    iq_balance_mode26: '0'
-    iq_balance_mode27: '0'
-    iq_balance_mode28: '0'
-    iq_balance_mode29: '0'
-    iq_balance_mode3: '0'
-    iq_balance_mode30: '0'
-    iq_balance_mode31: '0'
-    iq_balance_mode4: '0'
-    iq_balance_mode5: '0'
-    iq_balance_mode6: '0'
-    iq_balance_mode7: '0'
-    iq_balance_mode8: '0'
-    iq_balance_mode9: '0'
-    maxoutbuf: '2048'
-    minoutbuf: '2048'
-    nchan: '1'
-    num_mboards: '1'
-    sample_rate: samp_rate
-    sync: sync
-    time_source0: ''
-    time_source1: ''
-    time_source2: ''
-    time_source3: ''
-    time_source4: ''
-    time_source5: ''
-    time_source6: ''
-    time_source7: ''
-    type: fc32
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [80, 132.0]
-    rotation: 0
-    state: true
-- name: py_module
-  id: epy_module
-  parameters:
-    alias: ''
-    comment: ''
-    source_code: "# this module will be imported in the into your flowgraph\r\n\r\n\
-      import numpy as np\r\nimport os\r\nimport time \r\n\r\nimport matplotlib.pyplot\
-      \ as plt\r\nimport math\r\n\r\n\r\n##################################\r\n# frequency\
-      \ change params\r\n##################################\r\n\r\nmin_f = 0.400e9\
-      \ # 2.38e9\r\nmax_f = 0.500e9 # 2.52e9\r\nstep_f = 1e6 # 10e6\r\nf = min_f +\
-      \ step_f / 2\r\n\r\n\r\n##################################\r\n# spectrum\r\n\
-      ##################################\r\n\r\nbins = 2048\r\nsavepath = 'C:/Users/ftlen/Work/GNU\
-      \ Radio/fft_detector/pics/433/'\r\n#savepath = 'C:/Users/ftlen/\u0420\u0430\u0431\
-      \u043E\u0447\u0438\u0439 \u0441\u0442\u043E\u043B/\u043D\u0438\u043A\u0438\u0442\
-      \u0430/'\r\n#filetag = '433_transmitter_denis_teleskop_'\r\nfiletag = '433_noise_office_teleskop_'\r\
-      \n\r\nfileit = 1\r\nsplit_size = 1_000_000\r\nmax_its = 10\r\nmax_iter = 0\r\
-      \n\r\nlast_spectrum_arr = np.array([])\r\nsignal_arr = np.array([])\r\n\r\n\
-      def set_spec_arr_zero(): \r\n    global bins, min_f, max_f, step_f\r\n    arr\
-      \ = np.array([-100] * int(((max_f - min_f) / step_f - 1) * bins), dtype=np.float32)\r\
-      \n    return arr\r\n\r\nlast_spectrum_arr = set_spec_arr_zero()\r\n\r\n\r\n\
-      def moving_average(x, w=50):\r\n    return np.convolve(x, np.ones(w), 'valid')\
-      \ / w\r\n##################################\r\n# main\r\n##################################\r\
-      \n\r\ndef work(lvl):\r\n    global f, min_f, max_f, step_f\r\n    global last_spectrum_arr,\
-      \ bins\r\n    global savepath, filetag, fileit\r\n    global signal_arr, split_size\r\
-      \n    global max_its, max_iter\r\n    #print('wrk')\r\n    if f >= max_f - step_f:\r\
-      \n        f = min_f + step_f / 2\r\n        #print('!', last_spectrum_arr.shape)\r\
-      \n        last_spectrum_arr = moving_average(last_spectrum_arr)\r\n        plt.ylim(-100,\
-      \ -50)\r\n        plt.xlim(min_f, max_f)\r\n        x = np.linspace(min_f, max_f,\
-      \ len(last_spectrum_arr))\r\n        plt.plot(x, last_spectrum_arr)\r\n    \
-      \    plt.savefig(savepath + filetag + str(fileit))\r\n        fileit += 1\r\n\
-      \        plt.close()\r\n        last_spectrum_arr = set_spec_arr_zero()\r\n\
-      \        return f\r\n\r\n    y = np.array(lvl).ravel()\r\n    if len(y) == 2048:\r\
-      \n        arr = y # / np.linalg.norm(y)\r\n\r\n        x1 = int((f-min_f)/step_f\
-      \ * bins - bins/2)\r\n        x2 = int((f-min_f)/step_f * bins + bins/2)\r\n\
-      \r\n        override_arr = last_spectrum_arr[x1:x2]\r\n\r\n        #override_arr\
-      \ = np.maximum(arr, override_arr)\r\n        override_arr = np.mean( np.array([\
-      \ arr, override_arr ]), axis=0 )\r\n\r\n        last_spectrum_arr[x1:x2] = override_arr\r\
-      \n\r\n        if max_iter == max_its:\r\n            f += step_f\r\n       \
-      \     max_iter = 0\r\n        else:\r\n            max_iter += 1\r\n    return\
-      \ f\r\n        "
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [1312, 232.0]
-    rotation: 0
-    state: enabled
-- name: vec_probe
-  id: blocks_probe_signal_vx
-  parameters:
-    affinity: ''
-    alias: ''
-    comment: ''
-    type: float
-    vlen: '2048'
-  states:
-    bus_sink: false
-    bus_source: false
-    bus_structure: null
-    coordinate: [1096, 192.0]
-    rotation: 0
-    state: enabled
-
-connections:
-- [blocks_complex_to_mag_squared_0, '0', blocks_integrate_xx_0, '0']
-- [blocks_integrate_xx_0, '0', blocks_nlog10_ff_0, '0']
-- [blocks_keep_one_in_n_0, '0', fft_vxx_0, '0']
-- [blocks_nlog10_ff_0, '0', vec_probe, '0']
-- [blocks_stream_to_vector_0_0, '0', blocks_keep_one_in_n_0, '0']
-- [dc_blocker_xx_0, '0', blocks_stream_to_vector_0_0, '0']
-- [fft_vxx_0, '0', blocks_complex_to_mag_squared_0, '0']
-- [osmosdr_source_0, '0', dc_blocker_xx_0, '0']
-
-metadata:
-  file_format: 1
-  grc_version: 3.10.7.0

src/core/data_buffer.py

@@ -1,10 +1,7 @@
-import os
 import statistics
-from datetime import datetime
 
 # Более лучшая версия кода есть в FRScanner
 
-
 class DataBuffer:
     """
     Класс с реализацией циклического буффера.
@@ -12,20 +9,29 @@ class DataBuffer:
     Атрибуты:
             current_column: Указатель на текущий столбец буфера, который обновляем.
             thinning_counter: Прореживающий множитель на текующей итерации.
-            current_counter: Указатель на количество чтений между последним обновлением столбца и предыдущим атрибутом.
+            current_counter:  Указатель на количество чтений между последним обновлением столбца и предыдущим атрибутом.
-            num_of_thinning_iter: Прореживающий множитель. Раз в это количество раз будет обновляться столбец буфера.
+            num_of_thinning_iter: Прореживающий множитель. Раз в это количечество раз будет обнволяться столбец буфера.
             line_size: Количество строк буфера = количеству каналов.
             columns_size: Количество столбцов = фиксированное число.
-            multiply_factor: Процентный показатель превышения сигналом уровня шума (legacy).
+            multiply_factor: Процентный показатель превышения сигналом уровня шума. ex m_p = 1.1 => триггер, если
-            num_for_alarm: Количество раз, превышающих шум, при которых триггеримся.
+                                сигнал превышает шум на 10%.
-            is_init: Флаг инициализации буфера.
+            num_for_alarm: Количество раз, превышающих шум, при которых триггеримся = фиксированное число.
+            is_init: Флаг инициализации буфера. = True, если инициализирован.
             buffer: Массив для буфера.
-            buffer_medians: Массив медиан по каналам.
+            buffer_medians: Массив для медиан столбцов букера.
-            buffer_mads: Массив MAD по каналам.
+            buffer_alarms: Массив для количества тревог по столбца буфера.
-            buffer_alarms: Массив для количества тревог по каналам.
     """
 
-    def __init__(self, columns_size, num_of_thinning_iter, num_of_channels, multiply_factor, num_for_alarm, freq_tag=None):
+    def __init__(self, columns_size, num_of_thinning_iter, num_of_channels, multiply_factor, num_for_alarm):
+        """
+        Инициализируем класс.
+
+        :param columns_size:
+        :param num_of_thinning_iter:
+        :param num_of_channels:
+        :param multiply_factor:
+        :param num_for_alarm:
+        """
         self.current_column = 0
         self.thinning_counter = 1
         self.current_counter = 1
@@ -35,46 +41,19 @@ class DataBuffer:
         self.multiply_factor = multiply_factor
         self.num_for_alarm = num_for_alarm
         self.is_init = False
-
         self.buffer = [[0 for _ in range(self.columns_size)] for _ in range(self.line_size)]
-        self.buffer_timestamps = [[None for _ in range(self.columns_size)] for _ in range(self.line_size)]
+        self.buffer_medians = [0] * self.line_size
-        self.buffer_medians = [0.0] * self.line_size
-        self.buffer_mads = [0.0] * self.line_size
         self.buffer_alarms = [0] * self.line_size
-        self.last_alarm_channels = []
-        self.episode_history = [[0.0 for _ in range(self.num_of_thinning_iter)] for _ in range(self.line_size)]
-        self.episode_history_timestamps = [[None for _ in range(self.num_of_thinning_iter)] for _ in range(self.line_size)]
-
-        self.freq_tag = '' if freq_tag is None else str(freq_tag)
-        suffix = f'_{self.freq_tag}' if self.freq_tag else ''
-
-        self.mad_k_on = float(os.getenv('mad_k_on' + suffix, os.getenv('mad_k_on', 5.0)))
-        self.mad_eps = float(os.getenv('mad_eps' + suffix, os.getenv('mad_eps', 0.05)))
-        self.dbfs_linear_offset_db = float(
-            os.getenv('dbfs_linear_offset_db' + suffix, os.getenv('dbfs_linear_offset_db', 0.0))
-        )
-        self.dbfs_linear_abs_median_scale = float(
-            os.getenv('dbfs_linear_abs_median_scale' + suffix, os.getenv('dbfs_linear_abs_median_scale', 0.0))
-        )
 
     def get_buffer(self):
         return self.buffer
 
-    def get_timestamps(self):
-        return self.buffer_timestamps
-
     def get_medians(self):
         return self.buffer_medians
 
-    def get_mads(self):
-        return self.buffer_mads
-
     def get_alarms(self):
         return self.buffer_alarms
 
-    def get_last_alarm_channels(self):
-        return list(self.last_alarm_channels)
-
     def check_init(self):
         return self.is_init
 
@@ -84,89 +63,20 @@ class DataBuffer:
             print(self.buffer[i], end=' ')
             print()
 
-    @staticmethod
-    def _calc_mad(values, median):
-        deviations = [abs(v - median) for v in values]
-        return statistics.median(deviations)
-
-    @staticmethod
-    def _format_ts(timestamp):
-        if timestamp is None:
-            return 'None'
-        try:
-            return datetime.fromtimestamp(float(timestamp)).isoformat(sep=' ', timespec='milliseconds')
-        except Exception:
-            return str(timestamp)
-
-    @staticmethod
-    def _mean_timestamp(timestamps):
-        filtered = [float(ts) for ts in timestamps if ts is not None]
-        if not filtered:
-            return None
-        return sum(filtered) / len(filtered)
-
     def medians(self):
         """
-        Вычислить медиану и MAD по строкам буфера.
+        Вычислить медиану по строке буфера.
         :return: None
         """
         if self.check_init():
             for i in range(self.line_size):
-                med = float(statistics.median(self.buffer[i]))
+                self.buffer_medians[i] = statistics.median(self.buffer[i])
-                self.buffer_medians[i] = med
+            # print('medians is: ', self.buffer_medians)
-                self.buffer_mads[i] = float(self._calc_mad(self.buffer[i], med))
+        # return self.buffer_medians
-
-    def get_linear_term(self, median_value):
-        median_value = float(median_value)
-        return self.dbfs_linear_offset_db + self.dbfs_linear_abs_median_scale * abs(median_value)
-
-    def get_threshold(self, channel_idx):
-        """
-        Получить динамический порог в dB для канала:
-        threshold = median + linear_term(median) + mad_k_on * MAD.
-        До завершения инициализации возвращает None.
-        """
-        if not self.check_init():
-            return None
-
-        baseline = float(self.buffer_medians[channel_idx])
-        mad_eff = max(float(self.buffer_mads[channel_idx]), self.mad_eps)
-        linear_term = self.get_linear_term(baseline)
-        return baseline + linear_term + self.mad_k_on * mad_eff
-
-    def get_thresholds(self):
-        if not self.check_init():
-            return [None] * self.line_size
-        return [self.get_threshold(i) for i in range(self.line_size)]
-
-    def log_threshold_update(self, updated_column):
-        if not self.check_init():
-            return
-
-        now_str = datetime.now().isoformat(sep=' ', timespec='milliseconds')
-        freq_tag = self.freq_tag or 'unknown'
-        print(f'[threshold-update][{freq_tag}] now={now_str} updated_column={updated_column}')
-        for i in range(self.line_size):
-            baseline = float(self.buffer_medians[i])
-            mad = float(self.buffer_mads[i])
-            mad_eff = max(mad, self.mad_eps)
-            linear_term = self.get_linear_term(baseline)
-            threshold = self.get_threshold(i)
-            packet_times = [self._format_ts(ts) for ts in self.buffer_timestamps[i]]
-            print(
-                f'  ch={i} median={baseline:.6f} '
-                f'linear_term={linear_term:.6f} '
-                f'mad={mad:.6f} mad_eff={mad_eff:.6f} '
-                f'mad_term={self.mad_k_on * mad_eff:.6f} '
-                f'threshold={threshold:.6f} '
-                f'packet_times={packet_times}'
-            )
 
     def alarms_fill_zeros(self):
         self.buffer_alarms = [0] * self.line_size
-        self.last_alarm_channels = []
+    def update(self, data):
-
-    def update(self, data, packet_timestamps=None):
         """
         Обновление буфера.
         Если номер текущего чтения совпадает с количеством прореживающего множителя на текущем обновлении буфера, то
@@ -175,84 +85,86 @@ class DataBuffer:
         3. Берем медианы по буферу, если он уже проиницализирован.
         4. Сбрасываем счетчик текущих чтений.
         5. Если был последний столбец (и мы уже переключились на первый), то
-                Если прореживающий множитель на текующей итерации был единица, то мы иницилизировались.
+                Если прореживающий множитель на текующей итерации был единица, то мы иницилизировались
                 До тех пор, пока множитель на итерации меньше фиксированного, увеличиваем в два раза.
         В противном случае - увеличиваем номер чтения.
         :param data: Массив с метриками сигнала по каналам.
-        :param packet_timestamps: Времена пакетов SDR для каждой метрики канала.
         :return: None
         """
-        if packet_timestamps is None:
-            packet_timestamps = [None] * self.line_size
-        if len(packet_timestamps) != self.line_size:
-            raise ValueError('packet_timestamps length must match number of channels')
 
-        sample_idx = self.current_counter - 1
+        # TODO: Добавить время релаксации - если система затриггерилась, то  перестать обновлять буфер на N чтений,
-        for i in range(self.line_size):
+        # где N задается в .env-template. Сейчас есть бага, что буфер перестает обновляться только когда система
-            self.episode_history[i][sample_idx] = float(data[i])
+        # триггерится. Между тем, когда приходит аларм и num_for_alarm, когда сигнал алармовский, но система еще не
-            self.episode_history_timestamps[i][sample_idx] = packet_timestamps[i]
+        # триггерится, буфер продолжает обновляться. В таких условиях буфер может набрать в себя алармовских сигналов
+        # и повысить пороги. Пример такой ситуации: дрон висит на 1км, система его видит, но сигнал превышает порог раз
+        # через раз и аларм срабатывает не всегда. В таких условиях наберется высокий сигнал, повысятся пороги и когда
+        # дрон начнет движение вперед, он будет заметен на более низкой дистанции, чем обычно, так как пороги повышены.
 
         if self.current_counter == self.thinning_counter:
-            updated_column = self.current_column
             for i in range(self.line_size):
-                samples = self.episode_history[i][:self.thinning_counter]
+                self.buffer[i][self.current_column] = data[i]
-                timestamps = self.episode_history_timestamps[i][:self.thinning_counter]
-                self.buffer[i][self.current_column] = float(sum(samples) / len(samples))
-                self.buffer_timestamps[i][self.current_column] = self._mean_timestamp(timestamps)
             self.current_column = (self.current_column + 1) % self.columns_size
+            #print('Столбец {0} обновлен. Перешли к столбцу {1}: '.format(self.current_column - 1, self.current_column))
             self.medians()
-            if self.check_init():
-                self.log_threshold_update(updated_column)
-            for i in range(self.line_size):
-                for j in range(self.thinning_counter):
-                    self.episode_history[i][j] = 0.0
-                    self.episode_history_timestamps[i][j] = None
             self.current_counter = 1
             if self.current_column == 0:
                 if self.thinning_counter == 1:
                     self.is_init = True
                     self.medians()
                     print('Начальная калибровка завершена.')
-                    self.log_threshold_update(updated_column)
                 if self.thinning_counter < self.num_of_thinning_iter:
                     self.thinning_counter *= 2
+                    # print('thinning counter обновлен: ', self.thinning_counter)
+
         else:
             self.current_counter += 1
-
+            # print('curr counter обновлен: ', self.current_counter)
 
     def check_alarm(self, data):
         """
-        Проверка триггера системы по dBFS во времени.
+        Проверка триггера системы.
-        Один порог на канал, набор тревоги и сброс счетчиков как в main.
+        Если значение по каналу превышает медиану (порог) шума на какой-то процент, то инкремент буфер аларма по каналу.
+        Превышение num_for_alarm подряд - триггер. Если после n превышений, где n<num_for_alarm приходит сигнал не
+        первышающий порог, то сбрасываем буфер алармов.
+        :param data:
+        :return: Да/нет.
         """
         if self.check_init():
-            self.last_alarm_channels = []
+            ratios=[]
+            print("="*50)
             for i in range(len(data)):
-                current = data[i]
+                exceeding = data[i] > self.multiply_factor * self.buffer_medians[i]
-                threshold = self.get_threshold(i)
+                ratios.append(data[i]/self.buffer_medians[i])
-                exceeding = current >= threshold
-
                 if exceeding:
                     self.buffer_alarms[i] += 1
+                    # print('Инкремент буффер алармов по каналу {0}, текущее число по этому каналу: {1}'.format(i,self.buffer_alarms[i]))
                 else:
                     self.buffer_alarms[i] = 0
+                    # print('Обнулили буффер алармов по каналу {0}, текущее число по этому каналу: {1}'.format(i,self.buffer_alarms[i]))
 
                 if self.buffer_alarms[i] >= self.num_for_alarm:
-                    self.last_alarm_channels = [i]
+                    # print('Сработала тревога по каналу {0}, текущее число по этому каналу: {1}'.format(i,self.buffer_alarms[i]))
                     self.buffer_alarms = [0] * self.line_size
+                    print("Отношения:", [f"{r:.3f}" for r in ratios])
+                    print("!"*50)
                     return True
+            print("Отношения:", [f"{r:.3f}" for r in ratios])
+            print("="*50)
+            
 
         return False
 
     def check_single_alarm(self, median, cur_channel):
         """
-        Проверка, является ли текущая метрика по каналу превышающей порог.
+        Проверка, является ли текущая медиана по каналу превышающей порог.
-        :param median: текущая метрика в dBFS.
+        :param median: меди (хар-ка) по каналу.
         :param cur_channel: индекс канала внутри частоты.
         :return: Да/нет.
         """
         if self.check_init():
-            threshold = self.get_threshold(cur_channel)
+            exceeding = median > self.multiply_factor * self.buffer_medians[cur_channel]
-            return median >= threshold
+            print(median/self.buffer_medians[cur_channel])
-
+            if exceeding:
-        return False
+                return True
+            else:
+                return False

src/core/multichannelswitcher.py

@@ -1,8 +1,63 @@
+import os
 from core.data_buffer import DataBuffer
 
 
+def get_centre_freq(freq):
+    """
+    Получить название частоты по ее диапазону.
+    :param freq: Частота, которую обрабатываем.
+    :return: Название частоты.
+    """
+    c_freq = 0
+    if 5.46e9 <= freq <= 6.0e9:
+        c_freq = 5800
+    if 5.0e9 <= freq <= 5.4e9:
+        c_freq = 5200
+    if 4.5e9 <= freq <= 4.7e9:
+        c_freq = 4500
+    if 3.3e9 <= freq <= 3.5e9:
+        c_freq = 3300
+    if 2.4e9 <= freq <= 2.5e9:
+        c_freq = 2400
+    if 1e9 <= freq <= 1.36e9:
+        c_freq = 1200
+    if 0.9e9 <= freq <= 0.960e9:
+        c_freq = 915
+    if 0.830e9 <= freq <= 0.890e9:
+        c_freq = 868
+    if 0.700e9 <= freq <= 0.780e9:
+        c_freq = 750
+    if 0.380e9 <= freq <= 0.500e9:
+        c_freq = 433
+    return str(c_freq)
+
+
 class MultiChannel:
+    """
+    Класс с реализацией переключателя каналов. Присутствует поддержка нескольких частот, а поэтому
+    Атрибуты:
+            steps: Массив шагов для разных частот. Ex. steps = [-20e6, -5e6, -3e6],  i-ый элемент соответствует i-ой
+            частоте для обработке, типа 1.2, 915 и 868.
+            bases: Массив верхних границ диапазонов рассматриваемых частот. Ex bases = [1.36e9, 0.93e9, 0.87e9] для
+            1.2, 915 и 868.
+            roofs: То же самое, только нижних границ. Ex roofs = [1e9, 0.9e9, 0.85e9]
+            cur_channel: Указатель на текущий канал, который обрабатываем.
+            cur_roof: Указатель на нижнюю границу текущей обрабатываемой частоты.
+            cur_step: Указатель на шаг текущей обрабатываемой частоты.
+            num_chs: Массив из каналов по обрабатываемым частотам. Вычисляется автоматически исходя из границ и шага.
+            init_freq: Чекер на инициализацию частоты перед началом работы скрипта. Нужен из-за особенности
+            работы графов GNURadio и функции work в embedded Python блоке.
+            DB: Список из циклических буферов для соответствующих чатсот.
+    """
+
     def __init__(self, steps, bases, roofs):
+        """
+        Инициализация класса.
+        :param steps: Список с шагами для соответствующих частот.
+        :param bases: Список верхних границ диапазонов частот, с которыми работаем.
+        :param roofs: Список нижних границ --//--.
+        """
+
         self.steps = steps
         self.bases = bases
         self.roofs = roofs
@@ -14,76 +69,100 @@ class MultiChannel:
         self.DB = []
 
     def init_f(self):
+        """
+        Инициализация начальной частоты, с которой начинаем обработку.
+        :return: Верхняя граница первой частоты из набора частот.
+        """
         self.init_freq = True
         return self.bases[0]
 
     def get_cur_channel(self):
+        """
+        Получить текущий обрабатываемый канал.
+        :return: Канал обработки.
+        """
         return self.cur_channel
 
-    @staticmethod
-    def _range_finished(channel, roof, step):
-        if step < 0:
-            return channel <= roof
-        return channel >= roof
-
     def change_channel(self):
+        """
+        Функция смены канала. Идет от верхней границы диапазона частоты к нижней с шагом step. Если дошли до нижней
+        границы, то переключаемся на следующую частоту посредством переноса курсора текущего канала на верхнюю границу
+        новой частоты и указатель нижней границы также двигаем на следующую позицию. Если частота для обработки одна, то
+        указатель текущего канала возвращается в начало - верхней границы этой же частоты. Указатель нижней границы не
+        изменяется.
+
+        :return: Канал после смены.
+        """
         if not self.init_freq:
             return self.init_f()
 
-        current_idx = self.roofs.index(self.cur_roof)
+        if self.cur_channel <= self.cur_roof:
-        if self._range_finished(self.cur_channel, self.cur_roof, self.cur_step):
+            if self.cur_roof == self.roofs[-1]:
-            next_idx = (current_idx + 1) % len(self.bases)
+                self.cur_channel = self.bases[0]
-            self.cur_channel = self.bases[next_idx]
+                self.cur_roof = self.roofs[0]
-            self.cur_roof = self.roofs[next_idx]
+                self.cur_step = self.steps[0]
-            self.cur_step = self.steps[next_idx]
+            else:
+                next_roofs = self.roofs.index(self.cur_roof) + 1
+                self.cur_channel = self.bases[next_roofs]
+                self.cur_roof = self.roofs[next_roofs]
+                self.cur_step = self.steps[next_roofs]
         else:
             self.cur_channel += self.cur_step
+        # print('Канал частоты изменен на ', self.cur_channel / 1000000)
         return self.get_cur_channel()
 
     def get_num_chs(self, idx_freq):
+        """
+        Вычисляет количество каналов на частоте исходя из верхнего, нижнего диапазонов и шага.
+        :param idx_freq: id частоты внутри класса. Т.е. в данный момент обрабатывается несколько частот, то id =
+        индексу верхней границы в bases для данной частоты, или нижней границы в roofs или шагу в steps.
+        В примерах из описания атрибутов индекс частоты 915 будет равен единице (т.к. идет вторым элементом в списках).
+        :return: Количество каналов.
+        """
         if (idx_freq + 1) > len(self.num_chs):
             tmp = self.bases[idx_freq]
-            roof = self.roofs[idx_freq]
-            step = self.steps[idx_freq]
             counter = 0
-            if step == 0:
+            while tmp >= self.roofs[idx_freq]:
-                raise ValueError('step must not be zero')
+                counter += 1
-            if step < 0:
+                tmp += self.steps[idx_freq]
-                while tmp >= roof:
-                    counter += 1
-                    tmp += step
-            else:
-                while tmp <= roof:
-                    counter += 1
-                    tmp += step
             self.num_chs.append(counter)
             return counter
-        return self.num_chs[idx_freq]
+        else:
+            return self.num_chs[idx_freq]
 
     def check_f(self, freq):
+        """
+        Проверить наличие частоты в классе. Если да, то вернуть количество каналов и циклический буфер этой частоты.
+        :param freq: Частота.
+        :return: Количество каналов, циклический буфер выбранной частоты ИЛИ none.
+        """
         for i in range(len(self.bases)):
-            low = min(self.roofs[i], self.bases[i])
+            if self.roofs[i] <= freq <= self.bases[i]:
-            high = max(self.roofs[i], self.bases[i])
-            if low <= freq <= high:
                 return self.get_num_chs(i), self.DB[i]
-        return None, None
+            else:
+                return None, None
 
-    def fill_DB(self, buffer_columns_size, num_of_thinning_iter, multiply_factor, num_for_alarm, freq_tag=None):
+    def fill_DB(self):
-        self.DB = []
+        """
+        Инициализировать циклические буферы для всех частот в отдельный список.
+        :return: N0nE.
+        """
         for i in range(len(self.bases)):
+            freq = get_centre_freq(self.bases[i])
+            buffer_columns_size = int(os.getenv('buffer_columns_size_' + str(freq)))
+            num_of_thinning_iter = int(os.getenv('num_of_thinning_iter_' + str(freq)))
+            multiply_factor = float(os.getenv('multiply_factor_' + str(freq)))
+            num_for_alarm = int(os.getenv('num_for_alarm_' + str(freq)))
             num_chs = self.get_num_chs(i)
             self.DB.append(
-                DataBuffer(
+                DataBuffer(buffer_columns_size, num_of_thinning_iter, num_chs, multiply_factor, num_for_alarm))
-                    buffer_columns_size,
-                    num_of_thinning_iter,
-                    num_chs,
-                    multiply_factor,
-                    num_for_alarm,
-                    freq_tag=freq_tag,
-                )
-            )
 
     def db_alarms_zeros(self, circle_buffer):
+        """
+        При отработке системы зануляет алармы во всех буферах, кроме текущего, т.к. в текущем уже занулилось.
+        :param circle_buffer: Циклический буфер текущей обрабатываемой частоты.
+        :return: None.
+        """
         for i in range(len(self.DB)):
             if self.DB[i] != circle_buffer:
                 self.DB[i].alarms_fill_zeros()

src/core/sig_n_medi_collect.py

@@ -1,6 +1,4 @@
 import os
-import math
-import time
 import numpy as np
 from typing import Union
 from common.runtime import load_root_env
@@ -26,10 +24,6 @@ class Signal:
         self.conv_method = conv_method
         self.signal = []
         self.signal_abs = []
-        self.last_packet_ts = None
-        self.metric_mode = os.getenv('signal_metric_mode', 'fft_top_bins').strip().lower()
-        self.fft_top_bins = max(1, int(os.getenv('signal_fft_top_bins', '2048')))
-        self.fft_window = os.getenv('signal_fft_window', 'hann').strip().lower()
 
     def get_signal(self):
         """
@@ -38,9 +32,6 @@ class Signal:
         """
         return self.signal, self.signal_abs
 
-    def get_last_packet_ts(self):
-        return self.last_packet_ts
-
     def clear(self) -> None:
         """
         Очистить массив с сигналом после предобработки?
@@ -48,31 +39,6 @@ class Signal:
         """
         self.signal = []
         self.signal_abs = []
-        self.last_packet_ts = None
-
-    def _build_window(self, size: int) -> np.ndarray:
-        if self.fft_window in {'', 'none', 'rect', 'rectangular'}:
-            return np.ones(size, dtype=np.float32)
-        if self.fft_window == 'hann':
-            return np.hanning(size).astype(np.float32, copy=False)
-        raise ValueError(f'unsupported fft window: {self.fft_window}')
-
-    def _compute_iq_power(self, samples: np.ndarray, signal_abs: np.ndarray) -> float:
-        if self.conv_method == 'max':
-            return float(np.max(signal_abs * signal_abs))
-
-        if self.metric_mode in {'fft', 'fft_top_bins', 'top_bins'}:
-            window = self._build_window(samples.size)
-            windowed = samples.astype(np.complex64, copy=False) * window
-            spectrum = np.fft.fft(windowed)
-            power_bins = (np.abs(spectrum) ** 2).astype(np.float32, copy=False)
-            power_bins /= max(float(np.sum(window * window)), 1.0)
-
-            bins_to_keep = min(self.fft_top_bins, power_bins.size)
-            top_bins = np.partition(power_bins, power_bins.size - bins_to_keep)[-bins_to_keep:]
-            return float(np.mean(top_bins))
-
-        return float(np.mean(signal_abs * signal_abs))
 
     def signal_preprocessing(self, length) -> float:
         """
@@ -80,33 +46,15 @@ class Signal:
 
         :return: Число типа float - "характеристика сигнала".
         """
-        samples = np.asarray(self.signal).ravel()[0:length]
+        signal = np.array([self.signal.real[0:length], self.signal.imag[0:length]], dtype=np.float32)
-        if samples.size == 0:
+        signal_abs = np.linalg.norm(signal, axis=0)  # Поэлементный модуль комплексного числа. shape.result
-            return 0.0
+        # (1, self.length)
-
-        # Основной режим: считаем dBFS из IQ-вектора.
-        if np.iscomplexobj(samples):
-            i = samples.real.astype(np.float32, copy=False)
-            q = samples.imag.astype(np.float32, copy=False)
-            signal = np.array([i, q], dtype=np.float32)
-            signal_abs = np.sqrt(i * i + q * q).astype(np.float32, copy=False)
-
-            power = self._compute_iq_power(samples, signal_abs)
-
-            result = 10.0 * math.log10(max(power, 1e-20))
-            self.signal = signal
-            self.signal_abs = signal_abs
-            return result
-
-        # Fallback: если на вход уже подали скалярную метрику, агрегируем как есть.
-        scalar_samples = samples.astype(np.float32, copy=False)
         if self.conv_method == 'max':
-            result = float(np.max(scalar_samples))
+            result = np.max(signal_abs)
         else:
-            result = float(np.median(scalar_samples))
+            result = np.median(signal_abs)
-
+        self.signal = signal
-        self.signal = scalar_samples
+        self.signal_abs = signal_abs
-        self.signal_abs = np.abs(scalar_samples)
         return result
 
     def fill_signal(self, lvl, length) -> Union[int, float]:
@@ -121,8 +69,8 @@ class Signal:
             self.signal = np.concatenate((self.signal, y), axis=None)
             return 0
         else:
-            self.last_packet_ts = time.time()
             preproc_signal = self.signal_preprocessing(length)
+            #self.clear()
             return preproc_signal
 
 
@@ -133,33 +81,27 @@ class SignalsArray:
             sig_array: Список для сохранения медиан.
             counter: Индикатор наполненности массива.
     """
-
     def __init__(self):
         self.sig_array = []
-        self.sig_ts_array = []
         self.counter = 0
 
-    def fill_sig_arr(self, metrica, packet_ts=None, num_chs=3):
+    def fill_sig_arr(self, metrica, num_chs=3):
         """
         Аппендим характеристику сигнала (метрику) в массив длиной num_chs.
         :param metrica: Характеристика сигнала (метрика).
-        :param packet_ts: Время завершения набора пакета с SDR для текущей метрики.
         :param num_chs: Количество каналов на частоте.
         :return: Индекс канала внутри частоты и массив с характеристиками, если заполнен, иначе - пустой.
         """
         if num_chs:
             if self.counter < num_chs:
                 self.sig_array.append(metrica)
-                self.sig_ts_array.append(packet_ts)
                 self.counter += 1
             if self.counter == num_chs:
                 arr = self.sig_array
-                arr_ts = self.sig_ts_array
                 self.sig_array = []
-                self.sig_ts_array = []
                 self.counter = 0
-                return num_chs - 1, arr, arr_ts
+                return num_chs - 1, arr
             else:
-                return self.counter - 1, [], []
+                return self.counter - 1, []
         else:
-            return 0, [], []
+            return 0, []

src/embedded_1500.py

@@ -1,150 +0,0 @@
-import os
-import datetime
-import time
-from common.runtime import load_root_env, as_bool
-from smb.SMBConnection import SMBConnection
-from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
-from utils.jammer_state_flag import is_jammer_active
-from core.sig_n_medi_collect import Signal, SignalsArray
-from core.multichannelswitcher import MultiChannel
-
-load_root_env(__file__)
-
-debug_flag = as_bool(os.getenv('debug_flag', '0'))
-send_to_module_flag = as_bool(os.getenv('send_to_module_flag', '0'))
-save_data_flag = as_bool(os.getenv('save_data_flag', '0'))
-module_name = os.getenv('module_name')
-elems_to_save = os.getenv('elems_to_save')
-file_types_to_save = os.getenv('file_types_to_save')
-localhost = os.getenv('lochost')
-localport = os.getenv('locport')
-f_step = [*map(float, os.getenv('f_step_1500').split())]
-f_bases = [*map(float, os.getenv('f_bases_1500').split())]
-f_roofs = [*map(float, os.getenv('f_roofs_1500').split())]
-signal_length = int(os.getenv('signal_length_1500'))
-buffer_columns_size = int(os.getenv('buffer_columns_size_1500'))
-num_of_thinning_iter = int(os.getenv('num_of_thinning_iter_1500'))
-multiply_factor = float(os.getenv('multiply_factor_1500'))
-num_for_alarm = int(os.getenv('num_for_alarm_1500'))
-c_freq = os.getenv('c_freq_1500', '1500')
-path_to_save_medians = os.getenv('path_to_save_medians')
-path_to_save_alarms = os.getenv('path_to_save_alarms')
-smb_host = os.getenv('smb_host')
-smb_port = os.getenv('smb_port')
-smb_user = os.getenv('smb_user')
-smb_pass = os.getenv('smb_pass')
-shared_folder = os.getenv('shared_folder')
-the_pc_name = os.getenv('the_pc_name')
-remote_pc_name = os.getenv('remote_pc_name')
-smb_domain = os.getenv('smb_domain')
-freq_endpoint = os.getenv('freq_endpoint')
-telemetry_enabled = as_bool(os.getenv('telemetry_enabled', '1'))
-telemetry_host = os.getenv('telemetry_host', '127.0.0.1')
-telemetry_port = os.getenv('telemetry_port', '5020')
-telemetry_endpoint = os.getenv('telemetry_endpoint', 'telemetry')
-telemetry_timeout_sec = float(os.getenv('telemetry_timeout_sec', '0.30'))
-
-elems_to_save = elems_to_save.split(',')
-file_types_to_save = file_types_to_save.split(',')
-
-tmp_signal = Signal()
-tmp_sigs_array = SignalsArray()
-multi_channel = MultiChannel(f_step, f_bases, f_roofs)
-f = multi_channel.init_f()
-multi_channel.fill_DB(
-    buffer_columns_size,
-    num_of_thinning_iter,
-    multiply_factor,
-    num_for_alarm,
-    c_freq,
-)
-
-if debug_flag:
-    conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
-    conn.connect(smb_host, 139)
-    filelist = conn.listPath(shared_folder, '/')
-    print(filelist)
-
-
-def work(lvl):
-    f = multi_channel.get_cur_channel()
-    freq = c_freq
-    median = tmp_signal.fill_signal(lvl, signal_length)
-    packet_ts = tmp_signal.get_last_packet_ts()
-
-    if median:
-        try:
-            num_chs, circle_buffer = multi_channel.check_f(f)
-            cur_channel, sigs_array, sigs_ts_array = tmp_sigs_array.fill_sig_arr(median, packet_ts=packet_ts, num_chs=num_chs)
-
-            if sigs_array:
-                print('Значения на {0}: {1}'.format(freq, sigs_array))
-                print('Пороги: ', circle_buffer.get_medians())
-                alarm = circle_buffer.check_alarm(sigs_array)
-
-                if alarm:
-                    print('----ALARM---- ', freq)
-                    multi_channel.db_alarms_zeros(circle_buffer)
-                elif not is_jammer_active():
-                    circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
-
-                if telemetry_enabled:
-                    try:
-                        max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
-                        dbfs_current = float(sigs_array[max_idx])
-                        dbfs_threshold = circle_buffer.get_threshold(max_idx)
-                        channel_thresholds = circle_buffer.get_thresholds()
-                        alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
-
-                        send_telemetry(
-                            data={
-                                'freq': str(freq),
-                                'ts': time.time(),
-                                'dbfs_current': dbfs_current,
-                                'dbfs_threshold': dbfs_threshold,
-                                'alarm': bool(alarm),
-                                'channel_idx': int(max_idx),
-                                'channels_total': int(len(sigs_array)),
-                                'channel_values': [float(v) for v in sigs_array],
-                                'channel_thresholds': channel_thresholds,
-                                'alarm_channels': alarm_channels,
-                            },
-                            host=telemetry_host,
-                            port=telemetry_port,
-                            endpoint=telemetry_endpoint,
-                            timeout_sec=telemetry_timeout_sec,
-                        )
-                    except Exception as exc:
-                        if debug_flag:
-                            print(f'telemetry send failed: {exc}')
-
-                if send_to_module_flag:
-                    send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
-
-                if save_data_flag:
-                    if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
-                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), list(range(num_chs)))
-                    if circle_buffer.check_init():
-                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians())
-
-            if debug_flag:
-                single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
-                print(cur_channel, single_alarm)
-                if single_alarm:
-                    data = pack_elems(elems_to_save, file_types_to_save, tmp_signal.get_signal())
-                    print('SAVE CURRENT SIGNAL SROCHNO TI MENYA SLISHISH?!?!?!?')
-                    try:
-                        remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
-                    except Exception as e:
-                        print(f'Ошибка: {e}')
-                else:
-                    print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
-
-            f = multi_channel.change_channel()
-        except Exception as e:
-            print(str(e))
-            print('.', end='')
-
-        tmp_signal.clear()
-
-    return f

src/embedded_3300.py

@@ -1,14 +1,28 @@
 import os
 import datetime
-import time
+from common.runtime import load_root_env, validate_env, as_bool, as_str
-from common.runtime import load_root_env, as_bool
 from smb.SMBConnection import SMBConnection
-from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
+from utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
-from utils.jammer_state_flag import is_jammer_active
+from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
-from core.sig_n_medi_collect import Signal, SignalsArray
+from core.multichannelswitcher import MultiChannel, get_centre_freq
-from core.multichannelswitcher import MultiChannel
 
 load_root_env(__file__)
+freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
+validate_env(__file__, {
+    "send_to_module_flag": as_bool,
+    "save_data_flag": as_bool,
+    "elems_to_save": as_str,
+    "file_types_to_save": as_str,
+    "lochost": as_str,
+    "locport": as_str,
+    "freq_endpoint": as_str,
+    "path_to_save_medians": as_str,
+    "path_to_save_alarms": as_str,
+    "module_name": as_str,
+    f"f_step_{freq_suffix}": as_str,
+    f"f_bases_{freq_suffix}": as_str,
+    f"f_roofs_{freq_suffix}": as_str,
+})
 
 debug_flag = as_bool(os.getenv('debug_flag', '0'))
 send_to_module_flag = as_bool(os.getenv('send_to_module_flag', '0'))
@@ -21,12 +35,6 @@ localport = os.getenv('locport')
 f_step = [*map(float, os.getenv('f_step_3300').split())]
 f_bases = [*map(float, os.getenv('f_bases_3300').split())]
 f_roofs = [*map(float, os.getenv('f_roofs_3300').split())]
-signal_length = int(os.getenv('signal_length_3300'))
-buffer_columns_size = int(os.getenv('buffer_columns_size_3300'))
-num_of_thinning_iter = int(os.getenv('num_of_thinning_iter_3300'))
-multiply_factor = float(os.getenv('multiply_factor_3300'))
-num_for_alarm = int(os.getenv('num_for_alarm_3300'))
-c_freq = os.getenv('c_freq_3300', '3300')
 path_to_save_medians = os.getenv('path_to_save_medians')
 path_to_save_alarms = os.getenv('path_to_save_alarms')
 smb_host = os.getenv('smb_host')
@@ -38,11 +46,6 @@ the_pc_name = os.getenv('the_pc_name')
 remote_pc_name = os.getenv('remote_pc_name')
 smb_domain = os.getenv('smb_domain')
 freq_endpoint = os.getenv('freq_endpoint')
-telemetry_enabled = as_bool(os.getenv('telemetry_enabled', '1'))
-telemetry_host = os.getenv('telemetry_host', '127.0.0.1')
-telemetry_port = os.getenv('telemetry_port', '5020')
-telemetry_endpoint = os.getenv('telemetry_endpoint', 'telemetry')
-telemetry_timeout_sec = float(os.getenv('telemetry_timeout_sec', '0.30'))
 
 elems_to_save = elems_to_save.split(',')
 file_types_to_save = file_types_to_save.split(',')
@@ -51,13 +54,7 @@ tmp_signal = Signal()
 tmp_sigs_array = SignalsArray()
 multi_channel = MultiChannel(f_step, f_bases, f_roofs)
 f = multi_channel.init_f()
-multi_channel.fill_DB(
+multi_channel.fill_DB()
-    buffer_columns_size,
-    num_of_thinning_iter,
-    multiply_factor,
-    num_for_alarm,
-    c_freq,
-)
 
 if debug_flag:
     conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
@@ -67,15 +64,16 @@ if debug_flag:
 
 
 def work(lvl):
+
     f = multi_channel.get_cur_channel()
-    freq = c_freq
+    freq = get_centre_freq(f)
+    signal_length = get_signal_length(freq)
     median = tmp_signal.fill_signal(lvl, signal_length)
-    packet_ts = tmp_signal.get_last_packet_ts()
 
     if median:
         try:
             num_chs, circle_buffer = multi_channel.check_f(f)
-            cur_channel, sigs_array, sigs_ts_array = tmp_sigs_array.fill_sig_arr(median, packet_ts=packet_ts, num_chs=num_chs)
+            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
 
             if sigs_array:
                 print('Значения на {0}: {1}'.format(freq, sigs_array))
@@ -85,47 +83,19 @@ def work(lvl):
                 if alarm:
                     print('----ALARM---- ', freq)
                     multi_channel.db_alarms_zeros(circle_buffer)
-                elif not is_jammer_active():
+                else:
-                    circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
+                    circle_buffer.update(sigs_array)
-
-                if telemetry_enabled:
-                    try:
-                        max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
-                        dbfs_current = float(sigs_array[max_idx])
-                        dbfs_threshold = circle_buffer.get_threshold(max_idx)
-                        channel_thresholds = circle_buffer.get_thresholds()
-                        alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
-
-                        send_telemetry(
-                            data={
-                                'freq': str(freq),
-                                'ts': time.time(),
-                                'dbfs_current': dbfs_current,
-                                'dbfs_threshold': dbfs_threshold,
-                                'alarm': bool(alarm),
-                                'channel_idx': int(max_idx),
-                                'channels_total': int(len(sigs_array)),
-                                'channel_values': [float(v) for v in sigs_array],
-                                'channel_thresholds': channel_thresholds,
-                                'alarm_channels': alarm_channels,
-                            },
-                            host=telemetry_host,
-                            port=telemetry_port,
-                            endpoint=telemetry_endpoint,
-                            timeout_sec=telemetry_timeout_sec,
-                        )
-                    except Exception as exc:
-                        if debug_flag:
-                            print(f'telemetry send failed: {exc}')
 
                 if send_to_module_flag:
                     send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
 
                 if save_data_flag:
                     if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
-                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), list(range(num_chs)))
+                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
+                                  list(range(num_chs)))
                     if circle_buffer.check_init():
-                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians())
+                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
+                                  circle_buffer.get_medians())
 
             if debug_flag:
                 single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@@ -136,14 +106,14 @@ def work(lvl):
                     try:
                         remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
                     except Exception as e:
-                        print(f'Ошибка: {e}')
+                        print(f"Ошибка: {e}")
                 else:
                     print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
 
             f = multi_channel.change_channel()
         except Exception as e:
             print(str(e))
-            print('.', end='')
+            print(".", end='')
 
         tmp_signal.clear()
 

src/embedded_433.py

@@ -1,14 +1,28 @@
 import os
 import datetime
-import time
+from common.runtime import load_root_env, validate_env, as_bool, as_str
-from common.runtime import load_root_env, as_bool
 from smb.SMBConnection import SMBConnection
-from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
+from utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
-from utils.jammer_state_flag import is_jammer_active
+from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
-from core.sig_n_medi_collect import Signal, SignalsArray
+from core.multichannelswitcher import MultiChannel, get_centre_freq
-from core.multichannelswitcher import MultiChannel
 
 load_root_env(__file__)
+freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
+validate_env(__file__, {
+    "send_to_module_flag": as_bool,
+    "save_data_flag": as_bool,
+    "elems_to_save": as_str,
+    "file_types_to_save": as_str,
+    "lochost": as_str,
+    "locport": as_str,
+    "freq_endpoint": as_str,
+    "path_to_save_medians": as_str,
+    "path_to_save_alarms": as_str,
+    "module_name": as_str,
+    f"f_step_{freq_suffix}": as_str,
+    f"f_bases_{freq_suffix}": as_str,
+    f"f_roofs_{freq_suffix}": as_str,
+})
 
 debug_flag = as_bool(os.getenv('debug_flag', '0'))
 send_to_module_flag = as_bool(os.getenv('send_to_module_flag', '0'))
@@ -21,12 +35,6 @@ localport = os.getenv('locport')
 f_step = [*map(float, os.getenv('f_step_433').split())]
 f_bases = [*map(float, os.getenv('f_bases_433').split())]
 f_roofs = [*map(float, os.getenv('f_roofs_433').split())]
-signal_length = int(os.getenv('signal_length_433'))
-buffer_columns_size = int(os.getenv('buffer_columns_size_433'))
-num_of_thinning_iter = int(os.getenv('num_of_thinning_iter_433'))
-multiply_factor = float(os.getenv('multiply_factor_433'))
-num_for_alarm = int(os.getenv('num_for_alarm_433'))
-c_freq = os.getenv('c_freq_433', '433')
 path_to_save_medians = os.getenv('path_to_save_medians')
 path_to_save_alarms = os.getenv('path_to_save_alarms')
 smb_host = os.getenv('smb_host')
@@ -38,11 +46,6 @@ the_pc_name = os.getenv('the_pc_name')
 remote_pc_name = os.getenv('remote_pc_name')
 smb_domain = os.getenv('smb_domain')
 freq_endpoint = os.getenv('freq_endpoint')
-telemetry_enabled = as_bool(os.getenv('telemetry_enabled', '1'))
-telemetry_host = os.getenv('telemetry_host', '127.0.0.1')
-telemetry_port = os.getenv('telemetry_port', '5020')
-telemetry_endpoint = os.getenv('telemetry_endpoint', 'telemetry')
-telemetry_timeout_sec = float(os.getenv('telemetry_timeout_sec', '0.30'))
 
 elems_to_save = elems_to_save.split(',')
 file_types_to_save = file_types_to_save.split(',')
@@ -51,13 +54,7 @@ tmp_signal = Signal()
 tmp_sigs_array = SignalsArray()
 multi_channel = MultiChannel(f_step, f_bases, f_roofs)
 f = multi_channel.init_f()
-multi_channel.fill_DB(
+multi_channel.fill_DB()
-    buffer_columns_size,
-    num_of_thinning_iter,
-    multiply_factor,
-    num_for_alarm,
-    c_freq,
-)
 
 if debug_flag:
     conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
@@ -67,15 +64,16 @@ if debug_flag:
 
 
 def work(lvl):
+
     f = multi_channel.get_cur_channel()
-    freq = c_freq
+    freq = get_centre_freq(f)
+    signal_length = get_signal_length(freq)
     median = tmp_signal.fill_signal(lvl, signal_length)
-    packet_ts = tmp_signal.get_last_packet_ts()
 
     if median:
         try:
             num_chs, circle_buffer = multi_channel.check_f(f)
-            cur_channel, sigs_array, sigs_ts_array = tmp_sigs_array.fill_sig_arr(median, packet_ts=packet_ts, num_chs=num_chs)
+            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
 
             if sigs_array:
                 print('Значения на {0}: {1}'.format(freq, sigs_array))
@@ -85,47 +83,19 @@ def work(lvl):
                 if alarm:
                     print('----ALARM---- ', freq)
                     multi_channel.db_alarms_zeros(circle_buffer)
-                elif not is_jammer_active():
+                else:
-                    circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
+                    circle_buffer.update(sigs_array)
-
-                if telemetry_enabled:
-                    try:
-                        max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
-                        dbfs_current = float(sigs_array[max_idx])
-                        dbfs_threshold = circle_buffer.get_threshold(max_idx)
-                        channel_thresholds = circle_buffer.get_thresholds()
-                        alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
-
-                        send_telemetry(
-                            data={
-                                'freq': str(freq),
-                                'ts': time.time(),
-                                'dbfs_current': dbfs_current,
-                                'dbfs_threshold': dbfs_threshold,
-                                'alarm': bool(alarm),
-                                'channel_idx': int(max_idx),
-                                'channels_total': int(len(sigs_array)),
-                                'channel_values': [float(v) for v in sigs_array],
-                                'channel_thresholds': channel_thresholds,
-                                'alarm_channels': alarm_channels,
-                            },
-                            host=telemetry_host,
-                            port=telemetry_port,
-                            endpoint=telemetry_endpoint,
-                            timeout_sec=telemetry_timeout_sec,
-                        )
-                    except Exception as exc:
-                        if debug_flag:
-                            print(f'telemetry send failed: {exc}')
 
                 if send_to_module_flag:
                     send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
 
                 if save_data_flag:
                     if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
-                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), list(range(num_chs)))
+                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
+                                  list(range(num_chs)))
                     if circle_buffer.check_init():
-                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians())
+                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
+                                  circle_buffer.get_medians())
 
             if debug_flag:
                 single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@@ -136,14 +106,14 @@ def work(lvl):
                     try:
                         remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
                     except Exception as e:
-                        print(f'Ошибка: {e}')
+                        print(f"Ошибка: {e}")
                 else:
                     print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
 
             f = multi_channel.change_channel()
         except Exception as e:
             print(str(e))
-            print('.', end='')
+            print(".", end='')
 
         tmp_signal.clear()
 

src/embedded_4500.py

@@ -1,14 +1,28 @@
 import os
 import datetime
-import time
+from common.runtime import load_root_env, validate_env, as_bool, as_str
-from common.runtime import load_root_env, as_bool
 from smb.SMBConnection import SMBConnection
-from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
+from utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
-from utils.jammer_state_flag import is_jammer_active
+from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
-from core.sig_n_medi_collect import Signal, SignalsArray
+from core.multichannelswitcher import MultiChannel, get_centre_freq
-from core.multichannelswitcher import MultiChannel
 
 load_root_env(__file__)
+freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
+validate_env(__file__, {
+    "send_to_module_flag": as_bool,
+    "save_data_flag": as_bool,
+    "elems_to_save": as_str,
+    "file_types_to_save": as_str,
+    "lochost": as_str,
+    "locport": as_str,
+    "freq_endpoint": as_str,
+    "path_to_save_medians": as_str,
+    "path_to_save_alarms": as_str,
+    "module_name": as_str,
+    f"f_step_{freq_suffix}": as_str,
+    f"f_bases_{freq_suffix}": as_str,
+    f"f_roofs_{freq_suffix}": as_str,
+})
 
 debug_flag = as_bool(os.getenv('debug_flag', '0'))
 send_to_module_flag = as_bool(os.getenv('send_to_module_flag', '0'))
@@ -21,12 +35,6 @@ localport = os.getenv('locport')
 f_step = [*map(float, os.getenv('f_step_4500').split())]
 f_bases = [*map(float, os.getenv('f_bases_4500').split())]
 f_roofs = [*map(float, os.getenv('f_roofs_4500').split())]
-signal_length = int(os.getenv('signal_length_4500'))
-buffer_columns_size = int(os.getenv('buffer_columns_size_4500'))
-num_of_thinning_iter = int(os.getenv('num_of_thinning_iter_4500'))
-multiply_factor = float(os.getenv('multiply_factor_4500'))
-num_for_alarm = int(os.getenv('num_for_alarm_4500'))
-c_freq = os.getenv('c_freq_4500', '4500')
 path_to_save_medians = os.getenv('path_to_save_medians')
 path_to_save_alarms = os.getenv('path_to_save_alarms')
 smb_host = os.getenv('smb_host')
@@ -38,11 +46,6 @@ the_pc_name = os.getenv('the_pc_name')
 remote_pc_name = os.getenv('remote_pc_name')
 smb_domain = os.getenv('smb_domain')
 freq_endpoint = os.getenv('freq_endpoint')
-telemetry_enabled = as_bool(os.getenv('telemetry_enabled', '1'))
-telemetry_host = os.getenv('telemetry_host', '127.0.0.1')
-telemetry_port = os.getenv('telemetry_port', '5020')
-telemetry_endpoint = os.getenv('telemetry_endpoint', 'telemetry')
-telemetry_timeout_sec = float(os.getenv('telemetry_timeout_sec', '0.30'))
 
 elems_to_save = elems_to_save.split(',')
 file_types_to_save = file_types_to_save.split(',')
@@ -51,13 +54,7 @@ tmp_signal = Signal()
 tmp_sigs_array = SignalsArray()
 multi_channel = MultiChannel(f_step, f_bases, f_roofs)
 f = multi_channel.init_f()
-multi_channel.fill_DB(
+multi_channel.fill_DB()
-    buffer_columns_size,
-    num_of_thinning_iter,
-    multiply_factor,
-    num_for_alarm,
-    c_freq,
-)
 
 if debug_flag:
     conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
@@ -67,15 +64,16 @@ if debug_flag:
 
 
 def work(lvl):
+
     f = multi_channel.get_cur_channel()
-    freq = c_freq
+    freq = get_centre_freq(f)
+    signal_length = get_signal_length(freq)
     median = tmp_signal.fill_signal(lvl, signal_length)
-    packet_ts = tmp_signal.get_last_packet_ts()
 
     if median:
         try:
             num_chs, circle_buffer = multi_channel.check_f(f)
-            cur_channel, sigs_array, sigs_ts_array = tmp_sigs_array.fill_sig_arr(median, packet_ts=packet_ts, num_chs=num_chs)
+            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
 
             if sigs_array:
                 print('Значения на {0}: {1}'.format(freq, sigs_array))
@@ -85,47 +83,19 @@ def work(lvl):
                 if alarm:
                     print('----ALARM---- ', freq)
                     multi_channel.db_alarms_zeros(circle_buffer)
-                elif not is_jammer_active():
+                else:
-                    circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
+                    circle_buffer.update(sigs_array)
-
-                if telemetry_enabled:
-                    try:
-                        max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
-                        dbfs_current = float(sigs_array[max_idx])
-                        dbfs_threshold = circle_buffer.get_threshold(max_idx)
-                        channel_thresholds = circle_buffer.get_thresholds()
-                        alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
-
-                        send_telemetry(
-                            data={
-                                'freq': str(freq),
-                                'ts': time.time(),
-                                'dbfs_current': dbfs_current,
-                                'dbfs_threshold': dbfs_threshold,
-                                'alarm': bool(alarm),
-                                'channel_idx': int(max_idx),
-                                'channels_total': int(len(sigs_array)),
-                                'channel_values': [float(v) for v in sigs_array],
-                                'channel_thresholds': channel_thresholds,
-                                'alarm_channels': alarm_channels,
-                            },
-                            host=telemetry_host,
-                            port=telemetry_port,
-                            endpoint=telemetry_endpoint,
-                            timeout_sec=telemetry_timeout_sec,
-                        )
-                    except Exception as exc:
-                        if debug_flag:
-                            print(f'telemetry send failed: {exc}')
 
                 if send_to_module_flag:
                     send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
 
                 if save_data_flag:
                     if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
-                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), list(range(num_chs)))
+                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
+                                  list(range(num_chs)))
                     if circle_buffer.check_init():
-                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians())
+                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
+                                  circle_buffer.get_medians())
 
             if debug_flag:
                 single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@@ -136,14 +106,14 @@ def work(lvl):
                     try:
                         remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
                     except Exception as e:
-                        print(f'Ошибка: {e}')
+                        print(f"Ошибка: {e}")
                 else:
                     print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
 
             f = multi_channel.change_channel()
         except Exception as e:
             print(str(e))
-            print('.', end='')
+            print(".", end='')
 
         tmp_signal.clear()
 

src/embedded_5200.py

@@ -1,14 +1,28 @@
 import os
 import datetime
-import time
+from common.runtime import load_root_env, validate_env, as_bool, as_str
-from common.runtime import load_root_env, as_bool
 from smb.SMBConnection import SMBConnection
-from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
+from utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
-from utils.jammer_state_flag import is_jammer_active
+from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
-from core.sig_n_medi_collect import Signal, SignalsArray
+from core.multichannelswitcher import MultiChannel, get_centre_freq
-from core.multichannelswitcher import MultiChannel
 
 load_root_env(__file__)
+freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
+validate_env(__file__, {
+    "send_to_module_flag": as_bool,
+    "save_data_flag": as_bool,
+    "elems_to_save": as_str,
+    "file_types_to_save": as_str,
+    "lochost": as_str,
+    "locport": as_str,
+    "freq_endpoint": as_str,
+    "path_to_save_medians": as_str,
+    "path_to_save_alarms": as_str,
+    "module_name": as_str,
+    f"f_step_{freq_suffix}": as_str,
+    f"f_bases_{freq_suffix}": as_str,
+    f"f_roofs_{freq_suffix}": as_str,
+})
 
 debug_flag = as_bool(os.getenv('debug_flag', '0'))
 send_to_module_flag = as_bool(os.getenv('send_to_module_flag', '0'))
@@ -21,12 +35,6 @@ localport = os.getenv('locport')
 f_step = [*map(float, os.getenv('f_step_5200').split())]
 f_bases = [*map(float, os.getenv('f_bases_5200').split())]
 f_roofs = [*map(float, os.getenv('f_roofs_5200').split())]
-signal_length = int(os.getenv('signal_length_5200'))
-buffer_columns_size = int(os.getenv('buffer_columns_size_5200'))
-num_of_thinning_iter = int(os.getenv('num_of_thinning_iter_5200'))
-multiply_factor = float(os.getenv('multiply_factor_5200'))
-num_for_alarm = int(os.getenv('num_for_alarm_5200'))
-c_freq = os.getenv('c_freq_5200', '5200')
 path_to_save_medians = os.getenv('path_to_save_medians')
 path_to_save_alarms = os.getenv('path_to_save_alarms')
 smb_host = os.getenv('smb_host')
@@ -38,11 +46,6 @@ the_pc_name = os.getenv('the_pc_name')
 remote_pc_name = os.getenv('remote_pc_name')
 smb_domain = os.getenv('smb_domain')
 freq_endpoint = os.getenv('freq_endpoint')
-telemetry_enabled = as_bool(os.getenv('telemetry_enabled', '1'))
-telemetry_host = os.getenv('telemetry_host', '127.0.0.1')
-telemetry_port = os.getenv('telemetry_port', '5020')
-telemetry_endpoint = os.getenv('telemetry_endpoint', 'telemetry')
-telemetry_timeout_sec = float(os.getenv('telemetry_timeout_sec', '0.30'))
 
 elems_to_save = elems_to_save.split(',')
 file_types_to_save = file_types_to_save.split(',')
@@ -51,13 +54,7 @@ tmp_signal = Signal()
 tmp_sigs_array = SignalsArray()
 multi_channel = MultiChannel(f_step, f_bases, f_roofs)
 f = multi_channel.init_f()
-multi_channel.fill_DB(
+multi_channel.fill_DB()
-    buffer_columns_size,
-    num_of_thinning_iter,
-    multiply_factor,
-    num_for_alarm,
-    c_freq,
-)
 
 if debug_flag:
     conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
@@ -67,15 +64,16 @@ if debug_flag:
 
 
 def work(lvl):
+
     f = multi_channel.get_cur_channel()
-    freq = c_freq
+    freq = get_centre_freq(f)
+    signal_length = get_signal_length(freq)
     median = tmp_signal.fill_signal(lvl, signal_length)
-    packet_ts = tmp_signal.get_last_packet_ts()
 
     if median:
         try:
             num_chs, circle_buffer = multi_channel.check_f(f)
-            cur_channel, sigs_array, sigs_ts_array = tmp_sigs_array.fill_sig_arr(median, packet_ts=packet_ts, num_chs=num_chs)
+            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
 
             if sigs_array:
                 print('Значения на {0}: {1}'.format(freq, sigs_array))
@@ -85,47 +83,19 @@ def work(lvl):
                 if alarm:
                     print('----ALARM---- ', freq)
                     multi_channel.db_alarms_zeros(circle_buffer)
-                elif not is_jammer_active():
+                else:
-                    circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
+                    circle_buffer.update(sigs_array)
-
-                if telemetry_enabled:
-                    try:
-                        max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
-                        dbfs_current = float(sigs_array[max_idx])
-                        dbfs_threshold = circle_buffer.get_threshold(max_idx)
-                        channel_thresholds = circle_buffer.get_thresholds()
-                        alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
-
-                        send_telemetry(
-                            data={
-                                'freq': str(freq),
-                                'ts': time.time(),
-                                'dbfs_current': dbfs_current,
-                                'dbfs_threshold': dbfs_threshold,
-                                'alarm': bool(alarm),
-                                'channel_idx': int(max_idx),
-                                'channels_total': int(len(sigs_array)),
-                                'channel_values': [float(v) for v in sigs_array],
-                                'channel_thresholds': channel_thresholds,
-                                'alarm_channels': alarm_channels,
-                            },
-                            host=telemetry_host,
-                            port=telemetry_port,
-                            endpoint=telemetry_endpoint,
-                            timeout_sec=telemetry_timeout_sec,
-                        )
-                    except Exception as exc:
-                        if debug_flag:
-                            print(f'telemetry send failed: {exc}')
 
                 if send_to_module_flag:
                     send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
 
                 if save_data_flag:
                     if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
-                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), list(range(num_chs)))
+                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
+                                  list(range(num_chs)))
                     if circle_buffer.check_init():
-                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians())
+                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
+                                  circle_buffer.get_medians())
 
             if debug_flag:
                 single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@@ -136,14 +106,14 @@ def work(lvl):
                     try:
                         remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
                     except Exception as e:
-                        print(f'Ошибка: {e}')
+                        print(f"Ошибка: {e}")
                 else:
                     print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
 
             f = multi_channel.change_channel()
         except Exception as e:
             print(str(e))
-            print('.', end='')
+            print(".", end='')
 
         tmp_signal.clear()
 

src/embedded_5800.py

@@ -1,14 +1,28 @@
 import os
 import datetime
-import time
+from common.runtime import load_root_env, validate_env, as_bool, as_str
-from common.runtime import load_root_env, as_bool
 from smb.SMBConnection import SMBConnection
-from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
+from utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
-from utils.jammer_state_flag import is_jammer_active
+from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
-from core.sig_n_medi_collect import Signal, SignalsArray
+from core.multichannelswitcher import MultiChannel, get_centre_freq
-from core.multichannelswitcher import MultiChannel
 
 load_root_env(__file__)
+freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
+validate_env(__file__, {
+    "send_to_module_flag": as_bool,
+    "save_data_flag": as_bool,
+    "elems_to_save": as_str,
+    "file_types_to_save": as_str,
+    "lochost": as_str,
+    "locport": as_str,
+    "freq_endpoint": as_str,
+    "path_to_save_medians": as_str,
+    "path_to_save_alarms": as_str,
+    "module_name": as_str,
+    f"f_step_{freq_suffix}": as_str,
+    f"f_bases_{freq_suffix}": as_str,
+    f"f_roofs_{freq_suffix}": as_str,
+})
 
 debug_flag = as_bool(os.getenv('debug_flag', '0'))
 send_to_module_flag = as_bool(os.getenv('send_to_module_flag', '0'))
@@ -21,12 +35,6 @@ localport = os.getenv('locport')
 f_step = [*map(float, os.getenv('f_step_5800').split())]
 f_bases = [*map(float, os.getenv('f_bases_5800').split())]
 f_roofs = [*map(float, os.getenv('f_roofs_5800').split())]
-signal_length = int(os.getenv('signal_length_5800'))
-buffer_columns_size = int(os.getenv('buffer_columns_size_5800'))
-num_of_thinning_iter = int(os.getenv('num_of_thinning_iter_5800'))
-multiply_factor = float(os.getenv('multiply_factor_5800'))
-num_for_alarm = int(os.getenv('num_for_alarm_5800'))
-c_freq = os.getenv('c_freq_5800', '5800')
 path_to_save_medians = os.getenv('path_to_save_medians')
 path_to_save_alarms = os.getenv('path_to_save_alarms')
 smb_host = os.getenv('smb_host')
@@ -38,11 +46,6 @@ the_pc_name = os.getenv('the_pc_name')
 remote_pc_name = os.getenv('remote_pc_name')
 smb_domain = os.getenv('smb_domain')
 freq_endpoint = os.getenv('freq_endpoint')
-telemetry_enabled = as_bool(os.getenv('telemetry_enabled', '1'))
-telemetry_host = os.getenv('telemetry_host', '127.0.0.1')
-telemetry_port = os.getenv('telemetry_port', '5020')
-telemetry_endpoint = os.getenv('telemetry_endpoint', 'telemetry')
-telemetry_timeout_sec = float(os.getenv('telemetry_timeout_sec', '0.30'))
 
 elems_to_save = elems_to_save.split(',')
 file_types_to_save = file_types_to_save.split(',')
@@ -51,13 +54,7 @@ tmp_signal = Signal()
 tmp_sigs_array = SignalsArray()
 multi_channel = MultiChannel(f_step, f_bases, f_roofs)
 f = multi_channel.init_f()
-multi_channel.fill_DB(
+multi_channel.fill_DB()
-    buffer_columns_size,
-    num_of_thinning_iter,
-    multiply_factor,
-    num_for_alarm,
-    c_freq,
-)
 
 if debug_flag:
     conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
@@ -67,15 +64,16 @@ if debug_flag:
 
 
 def work(lvl):
+
     f = multi_channel.get_cur_channel()
-    freq = c_freq
+    freq = get_centre_freq(f)
+    signal_length = get_signal_length(freq)
     median = tmp_signal.fill_signal(lvl, signal_length)
-    packet_ts = tmp_signal.get_last_packet_ts()
 
     if median:
         try:
             num_chs, circle_buffer = multi_channel.check_f(f)
-            cur_channel, sigs_array, sigs_ts_array = tmp_sigs_array.fill_sig_arr(median, packet_ts=packet_ts, num_chs=num_chs)
+            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
 
             if sigs_array:
                 print('Значения на {0}: {1}'.format(freq, sigs_array))
@@ -85,47 +83,19 @@ def work(lvl):
                 if alarm:
                     print('----ALARM---- ', freq)
                     multi_channel.db_alarms_zeros(circle_buffer)
-                elif not is_jammer_active():
+                else:
-                    circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
+                    circle_buffer.update(sigs_array)
-
-                if telemetry_enabled:
-                    try:
-                        max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
-                        dbfs_current = float(sigs_array[max_idx])
-                        dbfs_threshold = circle_buffer.get_threshold(max_idx)
-                        channel_thresholds = circle_buffer.get_thresholds()
-                        alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
-
-                        send_telemetry(
-                            data={
-                                'freq': str(freq),
-                                'ts': time.time(),
-                                'dbfs_current': dbfs_current,
-                                'dbfs_threshold': dbfs_threshold,
-                                'alarm': bool(alarm),
-                                'channel_idx': int(max_idx),
-                                'channels_total': int(len(sigs_array)),
-                                'channel_values': [float(v) for v in sigs_array],
-                                'channel_thresholds': channel_thresholds,
-                                'alarm_channels': alarm_channels,
-                            },
-                            host=telemetry_host,
-                            port=telemetry_port,
-                            endpoint=telemetry_endpoint,
-                            timeout_sec=telemetry_timeout_sec,
-                        )
-                    except Exception as exc:
-                        if debug_flag:
-                            print(f'telemetry send failed: {exc}')
 
                 if send_to_module_flag:
                     send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
 
                 if save_data_flag:
                     if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
-                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), list(range(num_chs)))
+                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
+                                  list(range(num_chs)))
                     if circle_buffer.check_init():
-                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians())
+                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
+                                  circle_buffer.get_medians())
 
             if debug_flag:
                 single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@@ -136,14 +106,14 @@ def work(lvl):
                     try:
                         remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
                     except Exception as e:
-                        print(f'Ошибка: {e}')
+                        print(f"Ошибка: {e}")
                 else:
                     print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
 
             f = multi_channel.change_channel()
         except Exception as e:
             print(str(e))
-            print('.', end='')
+            print(".", end='')
 
         tmp_signal.clear()
 

src/embedded_750.py

@@ -1,14 +1,28 @@
 import os
 import datetime
-import time
+from common.runtime import load_root_env, validate_env, as_bool, as_str
-from common.runtime import load_root_env, as_bool
 from smb.SMBConnection import SMBConnection
-from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
+from utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
-from utils.jammer_state_flag import is_jammer_active
+from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
-from core.sig_n_medi_collect import Signal, SignalsArray
+from core.multichannelswitcher import MultiChannel, get_centre_freq
-from core.multichannelswitcher import MultiChannel
 
 load_root_env(__file__)
+freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
+validate_env(__file__, {
+    "send_to_module_flag": as_bool,
+    "save_data_flag": as_bool,
+    "elems_to_save": as_str,
+    "file_types_to_save": as_str,
+    "lochost": as_str,
+    "locport": as_str,
+    "freq_endpoint": as_str,
+    "path_to_save_medians": as_str,
+    "path_to_save_alarms": as_str,
+    "module_name": as_str,
+    f"f_step_{freq_suffix}": as_str,
+    f"f_bases_{freq_suffix}": as_str,
+    f"f_roofs_{freq_suffix}": as_str,
+})
 
 debug_flag = as_bool(os.getenv('debug_flag', '0'))
 send_to_module_flag = as_bool(os.getenv('send_to_module_flag', '0'))
@@ -21,12 +35,6 @@ localport = os.getenv('locport')
 f_step = [*map(float, os.getenv('f_step_750').split())]
 f_bases = [*map(float, os.getenv('f_bases_750').split())]
 f_roofs = [*map(float, os.getenv('f_roofs_750').split())]
-signal_length = int(os.getenv('signal_length_750'))
-buffer_columns_size = int(os.getenv('buffer_columns_size_750'))
-num_of_thinning_iter = int(os.getenv('num_of_thinning_iter_750'))
-multiply_factor = float(os.getenv('multiply_factor_750'))
-num_for_alarm = int(os.getenv('num_for_alarm_750'))
-c_freq = os.getenv('c_freq_750', '750')
 path_to_save_medians = os.getenv('path_to_save_medians')
 path_to_save_alarms = os.getenv('path_to_save_alarms')
 smb_host = os.getenv('smb_host')
@@ -38,11 +46,6 @@ the_pc_name = os.getenv('the_pc_name')
 remote_pc_name = os.getenv('remote_pc_name')
 smb_domain = os.getenv('smb_domain')
 freq_endpoint = os.getenv('freq_endpoint')
-telemetry_enabled = as_bool(os.getenv('telemetry_enabled', '1'))
-telemetry_host = os.getenv('telemetry_host', '127.0.0.1')
-telemetry_port = os.getenv('telemetry_port', '5020')
-telemetry_endpoint = os.getenv('telemetry_endpoint', 'telemetry')
-telemetry_timeout_sec = float(os.getenv('telemetry_timeout_sec', '0.30'))
 
 elems_to_save = elems_to_save.split(',')
 file_types_to_save = file_types_to_save.split(',')
@@ -51,13 +54,7 @@ tmp_signal = Signal()
 tmp_sigs_array = SignalsArray()
 multi_channel = MultiChannel(f_step, f_bases, f_roofs)
 f = multi_channel.init_f()
-multi_channel.fill_DB(
+multi_channel.fill_DB()
-    buffer_columns_size,
-    num_of_thinning_iter,
-    multiply_factor,
-    num_for_alarm,
-    c_freq,
-)
 
 if debug_flag:
     conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
@@ -67,15 +64,19 @@ if debug_flag:
 
 
 def work(lvl):
+
     f = multi_channel.get_cur_channel()
-    freq = c_freq
+    freq = get_centre_freq(f)
+    signal_length = get_signal_length(freq)
     median = tmp_signal.fill_signal(lvl, signal_length)
-    packet_ts = tmp_signal.get_last_packet_ts()
 
     if median:
+        print(1)
         try:
             num_chs, circle_buffer = multi_channel.check_f(f)
-            cur_channel, sigs_array, sigs_ts_array = tmp_sigs_array.fill_sig_arr(median, packet_ts=packet_ts, num_chs=num_chs)
+            print(num_chs, circle_buffer)
+            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
+            print(3)
 
             if sigs_array:
                 print('Значения на {0}: {1}'.format(freq, sigs_array))
@@ -85,47 +86,19 @@ def work(lvl):
                 if alarm:
                     print('----ALARM---- ', freq)
                     multi_channel.db_alarms_zeros(circle_buffer)
-                elif not is_jammer_active():
+                else:
-                    circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
+                    circle_buffer.update(sigs_array)
-
-                if telemetry_enabled:
-                    try:
-                        max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
-                        dbfs_current = float(sigs_array[max_idx])
-                        dbfs_threshold = circle_buffer.get_threshold(max_idx)
-                        channel_thresholds = circle_buffer.get_thresholds()
-                        alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
-
-                        send_telemetry(
-                            data={
-                                'freq': str(freq),
-                                'ts': time.time(),
-                                'dbfs_current': dbfs_current,
-                                'dbfs_threshold': dbfs_threshold,
-                                'alarm': bool(alarm),
-                                'channel_idx': int(max_idx),
-                                'channels_total': int(len(sigs_array)),
-                                'channel_values': [float(v) for v in sigs_array],
-                                'channel_thresholds': channel_thresholds,
-                                'alarm_channels': alarm_channels,
-                            },
-                            host=telemetry_host,
-                            port=telemetry_port,
-                            endpoint=telemetry_endpoint,
-                            timeout_sec=telemetry_timeout_sec,
-                        )
-                    except Exception as exc:
-                        if debug_flag:
-                            print(f'telemetry send failed: {exc}')
 
                 if send_to_module_flag:
                     send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
 
                 if save_data_flag:
                     if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
-                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), list(range(num_chs)))
+                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
+                                  list(range(num_chs)))
                     if circle_buffer.check_init():
-                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians())
+                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
+                                  circle_buffer.get_medians())
 
             if debug_flag:
                 single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@@ -136,14 +109,14 @@ def work(lvl):
                     try:
                         remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
                     except Exception as e:
-                        print(f'Ошибка: {e}')
+                        print(f"Ошибка: {e}")
                 else:
                     print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
 
             f = multi_channel.change_channel()
         except Exception as e:
             print(str(e))
-            print('.', end='')
+            print(".", end='')
 
         tmp_signal.clear()
 

src/embedded_868.py

@@ -1,14 +1,28 @@
 import os
 import datetime
-import time
+from common.runtime import load_root_env, validate_env, as_bool, as_str
-from common.runtime import load_root_env, as_bool
 from smb.SMBConnection import SMBConnection
-from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
+from utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
-from utils.jammer_state_flag import is_jammer_active
+from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
-from core.sig_n_medi_collect import Signal, SignalsArray
+from core.multichannelswitcher import MultiChannel, get_centre_freq
-from core.multichannelswitcher import MultiChannel
 
 load_root_env(__file__)
+freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
+validate_env(__file__, {
+    "send_to_module_flag": as_bool,
+    "save_data_flag": as_bool,
+    "elems_to_save": as_str,
+    "file_types_to_save": as_str,
+    "lochost": as_str,
+    "locport": as_str,
+    "freq_endpoint": as_str,
+    "path_to_save_medians": as_str,
+    "path_to_save_alarms": as_str,
+    "module_name": as_str,
+    f"f_step_{freq_suffix}": as_str,
+    f"f_bases_{freq_suffix}": as_str,
+    f"f_roofs_{freq_suffix}": as_str,
+})
 
 debug_flag = as_bool(os.getenv('debug_flag', '0'))
 send_to_module_flag = as_bool(os.getenv('send_to_module_flag', '0'))
@@ -21,12 +35,6 @@ localport = os.getenv('locport')
 f_step = [*map(float, os.getenv('f_step_868').split())]
 f_bases = [*map(float, os.getenv('f_bases_868').split())]
 f_roofs = [*map(float, os.getenv('f_roofs_868').split())]
-signal_length = int(os.getenv('signal_length_868'))
-buffer_columns_size = int(os.getenv('buffer_columns_size_868'))
-num_of_thinning_iter = int(os.getenv('num_of_thinning_iter_868'))
-multiply_factor = float(os.getenv('multiply_factor_868'))
-num_for_alarm = int(os.getenv('num_for_alarm_868'))
-c_freq = os.getenv('c_freq_868', '868')
 path_to_save_medians = os.getenv('path_to_save_medians')
 path_to_save_alarms = os.getenv('path_to_save_alarms')
 smb_host = os.getenv('smb_host')
@@ -38,11 +46,6 @@ the_pc_name = os.getenv('the_pc_name')
 remote_pc_name = os.getenv('remote_pc_name')
 smb_domain = os.getenv('smb_domain')
 freq_endpoint = os.getenv('freq_endpoint')
-telemetry_enabled = as_bool(os.getenv('telemetry_enabled', '1'))
-telemetry_host = os.getenv('telemetry_host', '127.0.0.1')
-telemetry_port = os.getenv('telemetry_port', '5020')
-telemetry_endpoint = os.getenv('telemetry_endpoint', 'telemetry')
-telemetry_timeout_sec = float(os.getenv('telemetry_timeout_sec', '0.30'))
 
 elems_to_save = elems_to_save.split(',')
 file_types_to_save = file_types_to_save.split(',')
@@ -51,13 +54,7 @@ tmp_signal = Signal()
 tmp_sigs_array = SignalsArray()
 multi_channel = MultiChannel(f_step, f_bases, f_roofs)
 f = multi_channel.init_f()
-multi_channel.fill_DB(
+multi_channel.fill_DB()
-    buffer_columns_size,
-    num_of_thinning_iter,
-    multiply_factor,
-    num_for_alarm,
-    c_freq,
-)
 
 if debug_flag:
     conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
@@ -67,15 +64,16 @@ if debug_flag:
 
 
 def work(lvl):
+
     f = multi_channel.get_cur_channel()
-    freq = c_freq
+    freq = get_centre_freq(f)
+    signal_length = get_signal_length(freq)
     median = tmp_signal.fill_signal(lvl, signal_length)
-    packet_ts = tmp_signal.get_last_packet_ts()
 
     if median:
         try:
             num_chs, circle_buffer = multi_channel.check_f(f)
-            cur_channel, sigs_array, sigs_ts_array = tmp_sigs_array.fill_sig_arr(median, packet_ts=packet_ts, num_chs=num_chs)
+            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
 
             if sigs_array:
                 print('Значения на {0}: {1}'.format(freq, sigs_array))
@@ -85,47 +83,19 @@ def work(lvl):
                 if alarm:
                     print('----ALARM---- ', freq)
                     multi_channel.db_alarms_zeros(circle_buffer)
-                elif not is_jammer_active():
+                else:
-                    circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
+                    circle_buffer.update(sigs_array)
-
-                if telemetry_enabled:
-                    try:
-                        max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
-                        dbfs_current = float(sigs_array[max_idx])
-                        dbfs_threshold = circle_buffer.get_threshold(max_idx)
-                        channel_thresholds = circle_buffer.get_thresholds()
-                        alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
-
-                        send_telemetry(
-                            data={
-                                'freq': str(freq),
-                                'ts': time.time(),
-                                'dbfs_current': dbfs_current,
-                                'dbfs_threshold': dbfs_threshold,
-                                'alarm': bool(alarm),
-                                'channel_idx': int(max_idx),
-                                'channels_total': int(len(sigs_array)),
-                                'channel_values': [float(v) for v in sigs_array],
-                                'channel_thresholds': channel_thresholds,
-                                'alarm_channels': alarm_channels,
-                            },
-                            host=telemetry_host,
-                            port=telemetry_port,
-                            endpoint=telemetry_endpoint,
-                            timeout_sec=telemetry_timeout_sec,
-                        )
-                    except Exception as exc:
-                        if debug_flag:
-                            print(f'telemetry send failed: {exc}')
 
                 if send_to_module_flag:
                     send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
 
                 if save_data_flag:
                     if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
-                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), list(range(num_chs)))
+                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
+                                  list(range(num_chs)))
                     if circle_buffer.check_init():
-                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians())
+                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
+                                  circle_buffer.get_medians())
 
             if debug_flag:
                 single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@@ -136,14 +106,14 @@ def work(lvl):
                     try:
                         remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
                     except Exception as e:
-                        print(f'Ошибка: {e}')
+                        print(f"Ошибка: {e}")
                 else:
                     print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
 
             f = multi_channel.change_channel()
         except Exception as e:
             print(str(e))
-            print('.', end='')
+            print(".", end='')
 
         tmp_signal.clear()
 

src/main_1500.py

@@ -1,104 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-from gnuradio import blocks
-from gnuradio import gr
-import signal
-import sys
-import threading
-import time
-
-import osmosdr
-import embedded_1500 as my_freq
-
-from common.runtime import load_root_env, resolve_hackrf_index
-
-
-load_root_env(__file__)
-
-
-def get_hack_id():
-    return resolve_hackrf_index('hack_1500', 'src/main_1500.py')
-
-
-class get_center_freq(gr.top_block):
-    def __init__(self):
-        gr.top_block.__init__(self, 'get_center_freq')
-
-        self.prob_freq = 0
-        self.samp_rate = 20e6
-        self.poll_rate = 10000
-        self.vector_len = 4096
-        self.center_freq = my_freq.work(self.prob_freq)
-        self._prob_freq_thread = None
-
-        self.probSigVec = blocks.probe_signal_vc(self.vector_len)
-        self.rtlsdr_source_0 = osmosdr.source(
-            args='numchan=' + str(1) + ' ' + 'hackrf=' + get_hack_id()
-        )
-        self.rtlsdr_source_0.set_time_unknown_pps(osmosdr.time_spec_t())
-        self.rtlsdr_source_0.set_sample_rate(self.samp_rate)
-        self.rtlsdr_source_0.set_center_freq(self.center_freq, 0)
-        self.rtlsdr_source_0.set_freq_corr(0, 0)
-        self.rtlsdr_source_0.set_gain(24, 0)
-        self.rtlsdr_source_0.set_if_gain(24, 0)
-        self.rtlsdr_source_0.set_bb_gain(100, 0)
-        self.rtlsdr_source_0.set_antenna('', 0)
-        self.rtlsdr_source_0.set_bandwidth(0, 0)
-        self.rtlsdr_source_0.set_min_output_buffer(self.vector_len)
-
-        self.blocks_stream_to_vector_1 = blocks.stream_to_vector(gr.sizeof_gr_complex * 1, self.vector_len)
-        self.connect((self.blocks_stream_to_vector_1, 0), (self.probSigVec, 0))
-        self.connect((self.rtlsdr_source_0, 0), (self.blocks_stream_to_vector_1, 0))
-
-        def _prob_freq_probe():
-            while True:
-                val = self.probSigVec.level()
-                try:
-                    self.set_prob_freq(val)
-                except AttributeError:
-                    pass
-                time.sleep(1.0 / self.poll_rate)
-
-        self._prob_freq_thread = threading.Thread(target=_prob_freq_probe, daemon=True)
-        self._prob_freq_thread.start()
-
-    def get_prob_freq(self):
-        return self.prob_freq
-
-    def set_prob_freq(self, prob_freq):
-        self.prob_freq = prob_freq
-        self.set_center_freq(my_freq.work(self.prob_freq))
-
-    def get_center_freq(self):
-        return self.center_freq
-
-    def set_center_freq(self, center_freq):
-        self.center_freq = center_freq
-        self.rtlsdr_source_0.set_center_freq(self.center_freq, 0)
-
-
-def main(top_block_cls=get_center_freq, options=None):
-    tb = top_block_cls()
-
-    def sig_handler(sig=None, frame=None):
-        tb.stop()
-        tb.wait()
-        sys.exit(0)
-
-    signal.signal(signal.SIGINT, sig_handler)
-    signal.signal(signal.SIGTERM, sig_handler)
-
-    tb.start()
-    try:
-        print('СЕРВИСНАЯ ИНФОРМАЦИЯ: ')
-        print('debug_flag: ', my_freq.debug_flag)
-        print('save_data_flag: ', my_freq.save_data_flag)
-        print('send_to_module_flag: ', my_freq.send_to_module_flag)
-    except EOFError:
-        pass
-    tb.wait()
-
-
-if __name__ == '__main__':
-    main()

src/main_3300.py

@@ -18,12 +18,12 @@ import time
 import threading
 import subprocess
 import os
-import numpy as np
 
 from common.runtime import load_root_env, resolve_hackrf_index
 
 load_root_env(__file__)
 
+
 def get_hack_id():
     return resolve_hackrf_index('hack_3300', 'src/main_3300.py')
     serial_number = os.getenv('hack_3300')
@@ -83,14 +83,6 @@ class get_center_freq(gr.top_block):
         self.flag = flag = 1
         self.decimation = decimation = 1
         self.center_freq = center_freq = my_freq.work(prob_freq)
-        self.read_pipe_settle_sec = float(os.getenv('read_pipe_settle_sec_hf', '0.003'))
-        self.read_pipe_windows_per_update = max(1, int(os.getenv('read_pipe_windows_per_update_hf', '3')) )
-        self.read_pipe_vec_len = 4096
-        self.read_pipe_window_sec = self.read_pipe_vec_len / self.samp_rate
-        self.read_pipe_poll_sec = float(os.getenv('read_pipe_poll_sec_hf', str(self.read_pipe_window_sec)))
-        self.read_pipe_poll_sec = max(self.read_pipe_window_sec, self.read_pipe_poll_sec)
-        self.read_pipe_next_at = time.monotonic()
-        self.read_pipe_settle_until = 0.0
 
         ##################################################
         # Blocks
@@ -103,42 +95,21 @@ class get_center_freq(gr.top_block):
         self.rtlsdr_source_0.set_sample_rate(samp_rate)
         self.rtlsdr_source_0.set_center_freq(center_freq, 0)
         self.rtlsdr_source_0.set_freq_corr(0, 0)
-        self.rtlsdr_source_0.set_gain(24, 0)
+        self.rtlsdr_source_0.set_gain(100, 0)
-        self.rtlsdr_source_0.set_if_gain(24, 0)
+        self.rtlsdr_source_0.set_if_gain(100, 0)
-        self.rtlsdr_source_0.set_bb_gain(100, 0)
+        self.rtlsdr_source_0.set_bb_gain(0, 0)
         self.rtlsdr_source_0.set_antenna('', 0)
         self.rtlsdr_source_0.set_bandwidth(0, 0)
         self.rtlsdr_source_0.set_min_output_buffer(4096)
         def _prob_freq_probe():
             while True:
-                now = time.monotonic()
-                if now < self.read_pipe_settle_until:
-                    time.sleep(min(self.read_pipe_poll_sec, self.read_pipe_settle_until - now))
-                    continue
-
-                windows = []
-                for i in range(self.read_pipe_windows_per_update):
-                    windows.append(np.array(self.probSigVec.level()).ravel())
-                    if i + 1 < self.read_pipe_windows_per_update:
-                        time.sleep(self.read_pipe_window_sec)
-
-                if len(windows) == 1:
-                    val = windows[0]
-                else:
-                    val = np.concatenate(windows, axis=None)
 
+                val = self.probSigVec.level()
                 try:
                     self.set_prob_freq(val)
                 except AttributeError:
                     pass
-
+                time.sleep(1.0 / (poll_rate))
-                self.read_pipe_next_at += self.read_pipe_poll_sec
-                sleep_for = self.read_pipe_next_at - time.monotonic()
-                if sleep_for > 0:
-                    time.sleep(sleep_for)
-                else:
-                    self.read_pipe_next_at = time.monotonic()
-
         _prob_freq_thread = threading.Thread(target=_prob_freq_probe)
         _prob_freq_thread.daemon = True
         _prob_freq_thread.start()
@@ -158,12 +129,7 @@ class get_center_freq(gr.top_block):
 
     def set_prob_freq(self, prob_freq):
         self.prob_freq = prob_freq
-        next_center = my_freq.work(self.prob_freq)
+        self.set_center_freq(my_freq.work(self.prob_freq))
-        if next_center is None:
-            return
-        if next_center != self.center_freq:
-            self.set_center_freq(next_center)
-            self.read_pipe_settle_until = time.monotonic() + self.read_pipe_settle_sec
 
     def get_top_peaks_amount(self):
         return self.top_peaks_amount

src/main_433.py

@@ -23,6 +23,7 @@ from common.runtime import load_root_env, resolve_hackrf_index
 
 load_root_env(__file__)
 
+
 def get_hack_id():
     return resolve_hackrf_index('hack_433', 'src/main_433.py')
     serial_number = os.getenv('hack_433')
@@ -94,9 +95,9 @@ class get_center_freq(gr.top_block):
         self.rtlsdr_source_0.set_sample_rate(samp_rate)
         self.rtlsdr_source_0.set_center_freq(center_freq, 0)
         self.rtlsdr_source_0.set_freq_corr(0, 0)
-        self.rtlsdr_source_0.set_gain(24, 0)
+        self.rtlsdr_source_0.set_gain(10, 0)
-        self.rtlsdr_source_0.set_if_gain(24, 0)
+        self.rtlsdr_source_0.set_if_gain(100, 0)
-        self.rtlsdr_source_0.set_bb_gain(100, 0)
+        self.rtlsdr_source_0.set_bb_gain(0, 0)
         self.rtlsdr_source_0.set_antenna('', 0)
         self.rtlsdr_source_0.set_bandwidth(0, 0)
         self.rtlsdr_source_0.set_min_output_buffer(4096)

src/main_4500.py

@@ -18,12 +18,12 @@ import time
 import threading
 import subprocess
 import os
-import numpy as np
 
 from common.runtime import load_root_env, resolve_hackrf_index
 
 load_root_env(__file__)
 
+
 def get_hack_id():
     return resolve_hackrf_index('hack_4500', 'src/main_4500.py')
     serial_number = os.getenv('hack_4500')
@@ -83,14 +83,6 @@ class get_center_freq(gr.top_block):
         self.flag = flag = 1
         self.decimation = decimation = 1
         self.center_freq = center_freq = my_freq.work(prob_freq)
-        self.read_pipe_settle_sec = float(os.getenv('read_pipe_settle_sec_hf', '0.003'))
-        self.read_pipe_windows_per_update = max(1, int(os.getenv('read_pipe_windows_per_update_hf', '3')) )
-        self.read_pipe_vec_len = 4096
-        self.read_pipe_window_sec = self.read_pipe_vec_len / self.samp_rate
-        self.read_pipe_poll_sec = float(os.getenv('read_pipe_poll_sec_hf', str(self.read_pipe_window_sec)))
-        self.read_pipe_poll_sec = max(self.read_pipe_window_sec, self.read_pipe_poll_sec)
-        self.read_pipe_next_at = time.monotonic()
-        self.read_pipe_settle_until = 0.0
 
         ##################################################
         # Blocks
@@ -103,42 +95,21 @@ class get_center_freq(gr.top_block):
         self.rtlsdr_source_0.set_sample_rate(samp_rate)
         self.rtlsdr_source_0.set_center_freq(center_freq, 0)
         self.rtlsdr_source_0.set_freq_corr(0, 0)
-        self.rtlsdr_source_0.set_gain(24, 0)
+        self.rtlsdr_source_0.set_gain(100, 0)
-        self.rtlsdr_source_0.set_if_gain(24, 0)
+        self.rtlsdr_source_0.set_if_gain(100, 0)
-        self.rtlsdr_source_0.set_bb_gain(100, 0)
+        self.rtlsdr_source_0.set_bb_gain(0, 0)
         self.rtlsdr_source_0.set_antenna('', 0)
         self.rtlsdr_source_0.set_bandwidth(0, 0)
         self.rtlsdr_source_0.set_min_output_buffer(4096)
         def _prob_freq_probe():
             while True:
-                now = time.monotonic()
-                if now < self.read_pipe_settle_until:
-                    time.sleep(min(self.read_pipe_poll_sec, self.read_pipe_settle_until - now))
-                    continue
-
-                windows = []
-                for i in range(self.read_pipe_windows_per_update):
-                    windows.append(np.array(self.probSigVec.level()).ravel())
-                    if i + 1 < self.read_pipe_windows_per_update:
-                        time.sleep(self.read_pipe_window_sec)
-
-                if len(windows) == 1:
-                    val = windows[0]
-                else:
-                    val = np.concatenate(windows, axis=None)
 
+                val = self.probSigVec.level()
                 try:
                     self.set_prob_freq(val)
                 except AttributeError:
                     pass
-
+                time.sleep(1.0 / (poll_rate))
-                self.read_pipe_next_at += self.read_pipe_poll_sec
-                sleep_for = self.read_pipe_next_at - time.monotonic()
-                if sleep_for > 0:
-                    time.sleep(sleep_for)
-                else:
-                    self.read_pipe_next_at = time.monotonic()
-
         _prob_freq_thread = threading.Thread(target=_prob_freq_probe)
         _prob_freq_thread.daemon = True
         _prob_freq_thread.start()
@@ -158,12 +129,7 @@ class get_center_freq(gr.top_block):
 
     def set_prob_freq(self, prob_freq):
         self.prob_freq = prob_freq
-        next_center = my_freq.work(self.prob_freq)
+        self.set_center_freq(my_freq.work(self.prob_freq))
-        if next_center is None:
-            return
-        if next_center != self.center_freq:
-            self.set_center_freq(next_center)
-            self.read_pipe_settle_until = time.monotonic() + self.read_pipe_settle_sec
 
     def get_top_peaks_amount(self):
         return self.top_peaks_amount

src/main_5200.py

@@ -18,11 +18,12 @@ import time
 import threading
 import subprocess
 import os
-import numpy as np
+
 from common.runtime import load_root_env, resolve_hackrf_index
 
 load_root_env(__file__)
 
+
 def get_hack_id():
     return resolve_hackrf_index('hack_5200', 'src/main_5200.py')
     serial_number = os.getenv('hack_5200')
@@ -82,14 +83,6 @@ class get_center_freq(gr.top_block):
         self.flag = flag = 1
         self.decimation = decimation = 1
         self.center_freq = center_freq = my_freq.work(prob_freq)
-        self.read_pipe_settle_sec = float(os.getenv('read_pipe_settle_sec_hf', '0.003'))
-        self.read_pipe_windows_per_update = max(1, int(os.getenv('read_pipe_windows_per_update_hf', '3')) )
-        self.read_pipe_vec_len = 4096
-        self.read_pipe_window_sec = self.read_pipe_vec_len / self.samp_rate
-        self.read_pipe_poll_sec = float(os.getenv('read_pipe_poll_sec_hf', str(self.read_pipe_window_sec)))
-        self.read_pipe_poll_sec = max(self.read_pipe_window_sec, self.read_pipe_poll_sec)
-        self.read_pipe_next_at = time.monotonic()
-        self.read_pipe_settle_until = 0.0
 
         ##################################################
         # Blocks
@@ -103,41 +96,20 @@ class get_center_freq(gr.top_block):
         self.rtlsdr_source_0.set_center_freq(center_freq, 0)
         self.rtlsdr_source_0.set_freq_corr(0, 0)
         self.rtlsdr_source_0.set_gain(100, 0)
-        self.rtlsdr_source_0.set_if_gain(24, 0)
+        self.rtlsdr_source_0.set_if_gain(100, 0)
-        self.rtlsdr_source_0.set_bb_gain(24, 0)
+        self.rtlsdr_source_0.set_bb_gain(0, 0)
         self.rtlsdr_source_0.set_antenna('', 0)
         self.rtlsdr_source_0.set_bandwidth(0, 0)
         self.rtlsdr_source_0.set_min_output_buffer(4096)
         def _prob_freq_probe():
             while True:
-                now = time.monotonic()
-                if now < self.read_pipe_settle_until:
-                    time.sleep(min(self.read_pipe_poll_sec, self.read_pipe_settle_until - now))
-                    continue
-
-                windows = []
-                for i in range(self.read_pipe_windows_per_update):
-                    windows.append(np.array(self.probSigVec.level()).ravel())
-                    if i + 1 < self.read_pipe_windows_per_update:
-                        time.sleep(self.read_pipe_window_sec)
-
-                if len(windows) == 1:
-                    val = windows[0]
-                else:
-                    val = np.concatenate(windows, axis=None)
 
+                val = self.probSigVec.level()
                 try:
                     self.set_prob_freq(val)
                 except AttributeError:
                     pass
-
+                time.sleep(1.0 / (poll_rate))
-                self.read_pipe_next_at += self.read_pipe_poll_sec
-                sleep_for = self.read_pipe_next_at - time.monotonic()
-                if sleep_for > 0:
-                    time.sleep(sleep_for)
-                else:
-                    self.read_pipe_next_at = time.monotonic()
-
         _prob_freq_thread = threading.Thread(target=_prob_freq_probe)
         _prob_freq_thread.daemon = True
         _prob_freq_thread.start()
@@ -157,12 +129,7 @@ class get_center_freq(gr.top_block):
 
     def set_prob_freq(self, prob_freq):
         self.prob_freq = prob_freq
-        next_center = my_freq.work(self.prob_freq)
+        self.set_center_freq(my_freq.work(self.prob_freq))
-        if next_center is None:
-            return
-        if next_center != self.center_freq:
-            self.set_center_freq(next_center)
-            self.read_pipe_settle_until = time.monotonic() + self.read_pipe_settle_sec
 
     def get_top_peaks_amount(self):
         return self.top_peaks_amount

src/main_5800.py

@@ -18,12 +18,12 @@ import time
 import threading
 import subprocess
 import os
-import numpy as np
 
 from common.runtime import load_root_env, resolve_hackrf_index
 
 load_root_env(__file__)
 
+
 def get_hack_id():
     return resolve_hackrf_index('hack_5800', 'src/main_5800.py')
     serial_number = os.getenv('hack_5800')
@@ -83,14 +83,6 @@ class get_center_freq(gr.top_block):
         self.flag = flag = 1
         self.decimation = decimation = 1
         self.center_freq = center_freq = my_freq.work(prob_freq)
-        self.read_pipe_settle_sec = float(os.getenv('read_pipe_settle_sec_hf', '0.003'))
-        self.read_pipe_windows_per_update = max(1, int(os.getenv('read_pipe_windows_per_update_hf', '3')) )
-        self.read_pipe_vec_len = 4096
-        self.read_pipe_window_sec = self.read_pipe_vec_len / self.samp_rate
-        self.read_pipe_poll_sec = float(os.getenv('read_pipe_poll_sec_hf', str(self.read_pipe_window_sec)))
-        self.read_pipe_poll_sec = max(self.read_pipe_window_sec, self.read_pipe_poll_sec)
-        self.read_pipe_next_at = time.monotonic()
-        self.read_pipe_settle_until = 0.0
 
         ##################################################
         # Blocks
@@ -103,42 +95,21 @@ class get_center_freq(gr.top_block):
         self.rtlsdr_source_0.set_sample_rate(samp_rate)
         self.rtlsdr_source_0.set_center_freq(center_freq, 0)
         self.rtlsdr_source_0.set_freq_corr(0, 0)
-        self.rtlsdr_source_0.set_gain(24, 0)
+        self.rtlsdr_source_0.set_gain(5, 0)
-        self.rtlsdr_source_0.set_if_gain(24, 0)
+        self.rtlsdr_source_0.set_if_gain(100, 0)
         self.rtlsdr_source_0.set_bb_gain(100, 0)
         self.rtlsdr_source_0.set_antenna('', 0)
         self.rtlsdr_source_0.set_bandwidth(0, 0)
         self.rtlsdr_source_0.set_min_output_buffer(4096)
         def _prob_freq_probe():
             while True:
-                now = time.monotonic()
-                if now < self.read_pipe_settle_until:
-                    time.sleep(min(self.read_pipe_poll_sec, self.read_pipe_settle_until - now))
-                    continue
-
-                windows = []
-                for i in range(self.read_pipe_windows_per_update):
-                    windows.append(np.array(self.probSigVec.level()).ravel())
-                    if i + 1 < self.read_pipe_windows_per_update:
-                        time.sleep(self.read_pipe_window_sec)
-
-                if len(windows) == 1:
-                    val = windows[0]
-                else:
-                    val = np.concatenate(windows, axis=None)
 
+                val = self.probSigVec.level()
                 try:
                     self.set_prob_freq(val)
                 except AttributeError:
                     pass
-
+                time.sleep(1.0 / (poll_rate))
-                self.read_pipe_next_at += self.read_pipe_poll_sec
-                sleep_for = self.read_pipe_next_at - time.monotonic()
-                if sleep_for > 0:
-                    time.sleep(sleep_for)
-                else:
-                    self.read_pipe_next_at = time.monotonic()
-
         _prob_freq_thread = threading.Thread(target=_prob_freq_probe)
         _prob_freq_thread.daemon = True
         _prob_freq_thread.start()
@@ -158,12 +129,7 @@ class get_center_freq(gr.top_block):
 
     def set_prob_freq(self, prob_freq):
         self.prob_freq = prob_freq
-        next_center = my_freq.work(self.prob_freq)
+        self.set_center_freq(my_freq.work(self.prob_freq))
-        if next_center is None:
-            return
-        if next_center != self.center_freq:
-            self.set_center_freq(next_center)
-            self.read_pipe_settle_until = time.monotonic() + self.read_pipe_settle_sec
 
     def get_top_peaks_amount(self):
         return self.top_peaks_amount

src/main_750.py

@@ -23,6 +23,7 @@ from common.runtime import load_root_env, resolve_hackrf_index
 
 load_root_env(__file__)
 
+
 def get_hack_id():
     return resolve_hackrf_index('hack_750', 'src/main_750.py')
     serial_number = os.getenv('hack_750')
@@ -94,9 +95,9 @@ class get_center_freq(gr.top_block):
         self.rtlsdr_source_0.set_sample_rate(samp_rate)
         self.rtlsdr_source_0.set_center_freq(center_freq, 0)
         self.rtlsdr_source_0.set_freq_corr(0, 0)
-        self.rtlsdr_source_0.set_gain(24, 0)
+        self.rtlsdr_source_0.set_gain(100, 0)
-        self.rtlsdr_source_0.set_if_gain(24, 0)
+        self.rtlsdr_source_0.set_if_gain(100, 0)
-        self.rtlsdr_source_0.set_bb_gain(100, 0)
+        self.rtlsdr_source_0.set_bb_gain(0, 0)
         self.rtlsdr_source_0.set_antenna('', 0)
         self.rtlsdr_source_0.set_bandwidth(0, 0)
         self.rtlsdr_source_0.set_min_output_buffer(4096)

src/main_868.py

@@ -1,97 +1,206 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
+#
+# SPDX-License-Identifier: GPL-3.0
+#
+# GNU Radio Python Flow Graph
+# Title: get_center_freq
+# GNU Radio version: 3.8.1.0
+
 from gnuradio import blocks
 from gnuradio import gr
-from gnuradio import zeromq
-import signal
 import sys
-import threading
+import signal
+import embedded_868 as my_freq  # embedded python module
+import osmosdr
 import time
+import threading
+import subprocess
+import os
 
-import embedded_868 as my_freq
+from common.runtime import load_root_env, resolve_hackrf_index
 
-from common.runtime import load_root_env
+load_root_env(__file__)
-from common.shared_stream_addrs import SHARED_868_ADDR, SHARED_VECTOR_LEN
+
+
+def get_hack_id():
+    return resolve_hackrf_index('hack_868', 'src/main_868.py')
+    serial_number = os.getenv('hack_868')
+    pos = None
+    output = []
+    try:
+        # command = '/home/orangepi/hackrf/host/build/hackrf-tools/src/hackrf_info'
+        command = 'lsusb -v -d 1d50:6089 | grep iSerial'
+        output.append(subprocess.check_output(command, shell=True, text=True))
+
+    # indexes = [line.split(":")[1].strip() for line in output_lines if "Index" in line]
+    # serial_numbers = [line.split(":")[1].strip() for line in output_lines if "Serial number" in line]
+    # print(indexes)
+    # print(serial_numbers)
+    # for i, number in enumerate(serial_numbers):
+    #     if number == serial_number:
+    #         pos = i
+    #         break
+    # if pos is not None:
+    #     id = indexes[pos]
+    # else:
+    #     print('Такого хака нет!')
+    except subprocess.CalledProcessError as e:
+        print(f"Команда завершилась с кодом возврата {e.returncode}")
+        print(e)
+    print(output)
+    output_lines = output[0].strip().split('\n')
+    print(output_lines)
+    serial_numbers = [line.split()[-1] for line in output_lines]
+    print(serial_numbers)
+    for i, number in enumerate(serial_numbers):
+        if number == serial_number:
+            id = i
+            break
+    if id is not None:
+        print('HackId is: {0}'.format(id))
+        return str(id)
+    else:
+        print('Такого хака нет!')
 
 
-load_root_env(__file__)
 
 
 class get_center_freq(gr.top_block):
+
     def __init__(self):
-        gr.top_block.__init__(self, 'get_center_freq')
+        gr.top_block.__init__(self, "get_center_freq")
-
+
-        self.prob_freq = 0
+        ##################################################
-        self.poll_rate = 10000
+        # Variables
-        self.vector_len = SHARED_VECTOR_LEN
+        ##################################################
-        self.center_freq = 0
+        self.prob_freq = prob_freq = 0
-        self.shared_addr = SHARED_868_ADDR
+        self.top_peaks_amount = top_peaks_amount = 20
-        self._stop_polling = threading.Event()
+        self.samp_rate = samp_rate = 20e6
-        self._prob_freq_thread = None
+        self.poll_rate = poll_rate = 10000
-
+        self.num_points = num_points = 8192
-        self.probSigVec = blocks.probe_signal_vc(self.vector_len)
+        self.flag = flag = 1
-        self.shared_source_0 = zeromq.pull_source(
+        self.decimation = decimation = 1
-            gr.sizeof_gr_complex,
+        self.center_freq = center_freq = my_freq.work(prob_freq)
-            self.vector_len,
+
-            self.shared_addr,
+        ##################################################
-            100,
+        # Blocks
-            False,
+        ##################################################
-            -1,
+        self.probSigVec = blocks.probe_signal_vc(4096)
-            False,
+        self.rtlsdr_source_0 = osmosdr.source(
+            args="numchan=" + str(1) + " " + 'hackrf=' + get_hack_id()
         )
-        self.connect((self.shared_source_0, 0), (self.probSigVec, 0))
+        self.rtlsdr_source_0.set_time_unknown_pps(osmosdr.time_spec_t())
+        self.rtlsdr_source_0.set_sample_rate(samp_rate)
+        self.rtlsdr_source_0.set_center_freq(center_freq, 0)
+        self.rtlsdr_source_0.set_freq_corr(0, 0)
+        self.rtlsdr_source_0.set_gain(100, 0)
+        self.rtlsdr_source_0.set_if_gain(100, 0)
+        self.rtlsdr_source_0.set_bb_gain(0, 0)
+        self.rtlsdr_source_0.set_antenna('', 0)
+        self.rtlsdr_source_0.set_bandwidth(0, 0)
+        self.rtlsdr_source_0.set_min_output_buffer(4096)
+        def _prob_freq_probe():
+            while True:
+
+                val = self.probSigVec.level()
+                try:
+                    self.set_prob_freq(val)
+                except AttributeError:
+                    pass
+                time.sleep(1.0 / (poll_rate))
+        _prob_freq_thread = threading.Thread(target=_prob_freq_probe)
+        _prob_freq_thread.daemon = True
+        _prob_freq_thread.start()
+
+        self.blocks_stream_to_vector_1 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, 4096)
 
-    def start_polling(self):
-        if self._prob_freq_thread is not None:
-            return
 
-        def _prob_freq_probe():
-            while not self._stop_polling.is_set():
-                self.set_prob_freq(self.probSigVec.level())
-                time.sleep(1.0 / self.poll_rate)
 
-        self._prob_freq_thread = threading.Thread(target=_prob_freq_probe, daemon=True)
+        ##################################################
-        self._prob_freq_thread.start()
+        # Connections
+        ##################################################
+        self.connect((self.blocks_stream_to_vector_1, 0), (self.probSigVec, 0))
+        self.connect((self.rtlsdr_source_0, 0), (self.blocks_stream_to_vector_1, 0))
 
     def get_prob_freq(self):
         return self.prob_freq
 
     def set_prob_freq(self, prob_freq):
         self.prob_freq = prob_freq
-        self.center_freq = my_freq.work(self.prob_freq)
+        self.set_center_freq(my_freq.work(self.prob_freq))
+
+    def get_top_peaks_amount(self):
+        return self.top_peaks_amount
+
+    def set_top_peaks_amount(self, top_peaks_amount):
+        self.top_peaks_amount = top_peaks_amount
+
+    def get_samp_rate(self):
+        return self.samp_rate
+
+    def set_samp_rate(self, samp_rate):
+        self.samp_rate = samp_rate
+        self.rtlsdr_source_0.set_sample_rate(self.samp_rate)
+
+    def get_poll_rate(self):
+        return self.poll_rate
+
+    def set_poll_rate(self, poll_rate):
+        self.poll_rate = poll_rate
+
+    def get_num_points(self):
+        return self.num_points
+
+    def set_num_points(self, num_points):
+        self.num_points = num_points
+
+    def get_flag(self):
+        return self.flag
+
+    def set_flag(self, flag):
+        self.flag = flag
+
+    def get_decimation(self):
+        return self.decimation
+
+    def set_decimation(self, decimation):
+        self.decimation = decimation
 
     def get_center_freq(self):
         return self.center_freq
 
     def set_center_freq(self, center_freq):
         self.center_freq = center_freq
+        self.rtlsdr_source_0.set_center_freq(self.center_freq, 0)
 
-    def close(self):
-        self._stop_polling.set()
-        self.stop()
-        self.wait()
 
 
 def main(top_block_cls=get_center_freq, options=None):
-    tb = top_block_cls()
+    #for k in range(0, 3):
+    #    light_diods_on_boot()
 
+    tb = top_block_cls()
     def sig_handler(sig=None, frame=None):
-        tb.close()
+        tb.stop()
+        tb.wait()
         sys.exit(0)
 
     signal.signal(signal.SIGINT, sig_handler)
     signal.signal(signal.SIGTERM, sig_handler)
 
     tb.start()
-    tb.start_polling()
     try:
-        print('shared_pull_addr:', SHARED_868_ADDR)
+        print('СЕРВИСНАЯ ИНФОРМАЦИЯ: ')
-        print('debug_flag:', my_freq.debug_flag)
+        print('debug_flag: ', my_freq.debug_flag)
-        print('save_data_flag:', my_freq.save_data_flag)
+        print('save_data_flag: ', my_freq.save_data_flag)
-        print('send_to_module_flag:', my_freq.send_to_module_flag)
+        print('send_to_module_flag: ', my_freq.send_to_module_flag)
+        #print('multiply_factor: ', float(os.getenv('multiply_factor_' + '1200')))
+        #print('multiply_factor: ', float(os.getenv('multiply_factor_' + '715')))
     except EOFError:
         pass
+    #tb.stop()
     tb.wait()
 
 

src/main_868_915_router.py

@@ -1,122 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-from gnuradio import blocks
-from gnuradio import gr
-import signal
-import sys
-import threading
-import time
-
-import osmosdr
-
-from common.runtime import load_root_env, resolve_hackrf_index
-from common.shared_stream_addrs import SHARED_VECTOR_LEN
-from shared_router_868_915 import SharedRouter868915
-
-
-load_root_env(__file__)
-
-
-def get_hack_id():
-    return resolve_hackrf_index('hack_868', 'src/main_868_915_router.py')
-
-
-class get_center_freq(gr.top_block):
-    def __init__(self):
-        gr.top_block.__init__(self, 'get_center_freq')
-
-        self.prob_freq = 0
-        self.poll_rate = 10000
-        self.vector_len = SHARED_VECTOR_LEN
-        self.router = SharedRouter868915()
-        self.active_lane = self.router.get_active_name()
-        self.center_freq = self.router.get_start_freq()
-        self._stop_polling = threading.Event()
-        self._prob_freq_thread = None
-
-        self.probSigVec = blocks.probe_signal_vc(self.vector_len)
-        self.rtlsdr_source_0 = osmosdr.source(
-            args='numchan=' + str(1) + ' ' + 'hackrf=' + get_hack_id()
-        )
-        self.rtlsdr_source_0.set_time_unknown_pps(osmosdr.time_spec_t())
-        self.rtlsdr_source_0.set_freq_corr(0, 0)
-        self.rtlsdr_source_0.set_antenna('', 0)
-        self.rtlsdr_source_0.set_min_output_buffer(self.vector_len)
-        self.apply_active_frontend()
-        self.rtlsdr_source_0.set_center_freq(self.center_freq, 0)
-
-        self.blocks_stream_to_vector_1 = blocks.stream_to_vector(gr.sizeof_gr_complex * 1, self.vector_len)
-        self.connect((self.rtlsdr_source_0, 0), (self.blocks_stream_to_vector_1, 0))
-        self.connect((self.blocks_stream_to_vector_1, 0), (self.probSigVec, 0))
-
-    def start_polling(self):
-        if self._prob_freq_thread is not None:
-            return
-
-        def _prob_freq_probe():
-            while not self._stop_polling.is_set():
-                self.set_prob_freq(self.probSigVec.level())
-                time.sleep(1.0 / self.poll_rate)
-
-        self._prob_freq_thread = threading.Thread(target=_prob_freq_probe, daemon=True)
-        self._prob_freq_thread.start()
-
-    def apply_active_frontend(self):
-        frontend = self.router.get_active_frontend()
-        self.rtlsdr_source_0.set_sample_rate(frontend['sample_rate'])
-        self.rtlsdr_source_0.set_gain(frontend['gain'], 0)
-        self.rtlsdr_source_0.set_if_gain(frontend['if_gain'], 0)
-        self.rtlsdr_source_0.set_bb_gain(frontend['bb_gain'], 0)
-        self.rtlsdr_source_0.set_bandwidth(frontend['bandwidth'], 0)
-
-    def get_prob_freq(self):
-        return self.prob_freq
-
-    def set_prob_freq(self, prob_freq):
-        self.prob_freq = prob_freq
-        next_center, lane_switched = self.router.route_vector(self.prob_freq)
-        if lane_switched:
-            self.active_lane = self.router.get_active_name()
-            self.apply_active_frontend()
-        if next_center != self.center_freq:
-            self.set_center_freq(next_center)
-
-    def get_center_freq(self):
-        return self.center_freq
-
-    def set_center_freq(self, center_freq):
-        self.center_freq = center_freq
-        self.rtlsdr_source_0.set_center_freq(self.center_freq, 0)
-
-    def close(self):
-        self._stop_polling.set()
-        try:
-            self.router.close()
-        finally:
-            self.stop()
-            self.wait()
-
-
-def main(top_block_cls=get_center_freq, options=None):
-    tb = top_block_cls()
-
-    def sig_handler(sig=None, frame=None):
-        tb.close()
-        sys.exit(0)
-
-    signal.signal(signal.SIGINT, sig_handler)
-    signal.signal(signal.SIGTERM, sig_handler)
-
-    tb.start()
-    tb.start_polling()
-    try:
-        print('shared_router_active_lane:', tb.router.get_active_name())
-        print('shared_router_start_freq:', tb.get_center_freq())
-    except EOFError:
-        pass
-    tb.wait()
-
-
-if __name__ == '__main__':
-    main()

src/server_to_master.py

@@ -14,7 +14,6 @@ from fastapi import FastAPI
 from common.runtime import load_root_env, validate_env, as_bool, as_float, as_int, as_str
 from datetime import datetime, timedelta
 import logging 
-from src.utils.jammer_state_flag import set_jammer_active
 
 logging.basicConfig(level=logging.INFO)
 
@@ -417,7 +416,6 @@ async def jammer_active():
 
     freqs_alarm = {freq: 0 for freq in freqs}
     jammer_event = True
-    set_jammer_active(True)
 
     print('АКТИВИРУЕМ ПОДАВИТЕЛЬ ААААААААААААААААААААААААААААААААААААААААААААААА!!!!')
     print('-' * 20)
@@ -440,7 +438,6 @@ async def jammer_deactive():
     global sending_data_task
     alarm = False
     jammer_event = False
-    set_jammer_active(False)
     sending_data_task = asyncio.create_task(sending_data())
 
     print('ОТКЛЮАЕМ ПОДАВИТЕЛЬ ААААААААААААААААААААААААААААААААААААААААААААААААА!!!!')
@@ -499,7 +496,6 @@ async def jam_server():
                         await jammer_deactive()
         except Exception as e:
             jam_server_connect = None
-            set_jammer_active(False)
             if jammer_event:
                 await jammer_deactive()
 
@@ -512,7 +508,6 @@ async def startup_event():
     """
 
     global sending_data_task
-    set_jammer_active(False)
     asyncio.create_task(jam_server())
     sending_data_task = asyncio.create_task(sending_data())
 

src/shared_router_868_915.py

@@ -1,173 +0,0 @@
-import os
-
-import numpy as np
-import zmq
-
-from common.runtime import load_root_env
-from common.shared_stream_addrs import SHARED_868_ADDR, SHARED_915_ADDR
-from core.multichannelswitcher import MultiChannel
-from core.sig_n_medi_collect import Signal
-
-
-load_root_env(__file__)
-
-
-class Scheduler868:
-    def __init__(self):
-        self.signal_length = int(os.getenv('signal_length_868'))
-        self.multi_channel = MultiChannel(
-            [*map(float, os.getenv('f_step_868').split())],
-            [*map(float, os.getenv('f_bases_868').split())],
-            [*map(float, os.getenv('f_roofs_868').split())],
-        )
-        self.base_freq = float(self.multi_channel.init_f())
-        self.signal = Signal()
-
-    def get_current_freq(self):
-        return float(self.multi_channel.get_cur_channel())
-
-    def process(self, lvl):
-        current_before = self.get_current_freq()
-        metric = self.signal.fill_signal(lvl, self.signal_length)
-        if metric == 0:
-            return current_before, False
-
-        next_freq = float(self.multi_channel.change_channel())
-        self.signal.clear()
-        lane_complete = next_freq == self.base_freq and current_before != self.base_freq
-        return next_freq, lane_complete
-
-
-class Scheduler915:
-    def __init__(self):
-        self.porog = float(os.getenv('POROG_915'))
-        self.point_amount = 100_000
-        self.split_size = 400_000
-        self.show_amount = int(0.8 * self.point_amount)
-        self.f_base = 0.91e9
-        self.f_step = 20e6
-        self.f_roof = 0.98e9
-        self.f = self.f_base
-        self.channel = 1
-        self.flag = 0
-        self.signal_arr = np.array([], dtype=np.complex64)
-
-    def get_current_freq(self):
-        return float(self.f)
-
-    def _median(self, sig):
-        samples = np.asarray(np.abs(np.array(sig, dtype=np.complex64)), dtype=np.float32)
-        sorted_samples = sorted(samples)
-        median = abs(float(np.median(sorted_samples[self.show_amount:])))
-        self.flag = 0 if self.porog > median else 1
-
-    def _advance(self):
-        next_freq = self.f + self.f_step
-        if next_freq >= self.f_roof:
-            self.f = self.f_base
-            self.channel = 1
-            return float(self.f), True
-
-        self.f = next_freq
-        self.channel += 1
-        return float(self.f), False
-
-    def process(self, lvl):
-        y = np.asarray(lvl, dtype=np.complex64).ravel()
-        self.signal_arr = np.concatenate((self.signal_arr, y), axis=None)
-
-        if self.flag == 0 and len(self.signal_arr) >= self.point_amount:
-            self._median(self.signal_arr[:self.point_amount])
-            self.signal_arr = np.array([], dtype=np.complex64)
-            if self.flag == 0:
-                return self._advance()
-
-        if len(self.signal_arr) >= self.split_size:
-            self.flag = 0
-            self.signal_arr = np.array([], dtype=np.complex64)
-            return self._advance()
-
-        return float(self.f), False
-
-
-class SharedRouter868915:
-    def __init__(self):
-        self.frontends = {
-            '868': {
-                'sample_rate': 20e6,
-                'gain': 24,
-                'if_gain': 24,
-                'bb_gain': 100,
-                'bandwidth': 0,
-            },
-            '915': {
-                'sample_rate': 20e6,
-                'gain': 16,
-                'if_gain': 16,
-                'bb_gain': 0,
-                'bandwidth': 0,
-            },
-        }
-        self.schedulers = {
-            '868': Scheduler868(),
-            '915': Scheduler915(),
-        }
-        self.context = zmq.Context.instance()
-        self.sockets = {
-            '868': self._make_socket(SHARED_868_ADDR),
-            '915': self._make_socket(SHARED_915_ADDR),
-        }
-        self.active_name = '868'
-        self.switch_counter = 0
-
-    def _make_socket(self, addr):
-        sock = self.context.socket(zmq.PUSH)
-        sock.setsockopt(zmq.SNDHWM, 64)
-        sock.setsockopt(zmq.LINGER, 0)
-        sock.setsockopt(zmq.IMMEDIATE, 1)
-        sock.bind(addr)
-        return sock
-
-    def close(self):
-        for sock in self.sockets.values():
-            try:
-                sock.close(0)
-            except Exception:
-                pass
-
-    def get_active_name(self):
-        return self.active_name
-
-    def get_active_freq(self):
-        return self.schedulers[self.active_name].get_current_freq()
-
-    def get_active_frontend(self):
-        return dict(self.frontends[self.active_name])
-
-    def get_start_freq(self):
-        return self.get_active_freq()
-
-    def route_vector(self, lvl):
-        vector = np.asarray(lvl, dtype=np.complex64).ravel()
-        active_name = self.active_name
-
-        try:
-            self.sockets[active_name].send(vector.tobytes(), zmq.NOBLOCK)
-        except zmq.Again:
-            pass
-
-        next_freq, lane_complete = self.schedulers[active_name].process(vector)
-        lane_switched = False
-
-        if lane_complete:
-            previous = self.active_name
-            self.active_name = '915' if self.active_name == '868' else '868'
-            next_freq = self.get_active_freq()
-            self.switch_counter += 1
-            lane_switched = True
-            print(
-                f'[shared-router-868-915] switch#{self.switch_counter}: '
-                f'{previous} -> {self.active_name}, tune={next_freq}'
-            )
-
-        return float(next_freq), lane_switched

src/unused/embedded_1200.py

@@ -21,8 +21,7 @@ localport = os.getenv('locport')
 f_step = [*map(float, os.getenv('f_step_1200').split())]
 f_bases = [*map(float, os.getenv('f_bases_1200').split())]
 f_roofs = [*map(float, os.getenv('f_roofs_1200').split())]
-
+path_to_save_medians = os.getenv('path_to_save_medians')
-c_freq = as_str(os.getenv(f'c_freq_{freq_suffix}', freq_suffix))path_to_save_medians = os.getenv('path_to_save_medians')
 path_to_save_alarms = os.getenv('path_to_save_alarms')
 smb_host = os.getenv('smb_host')
 smb_port = os.getenv('smb_port')
@@ -38,13 +37,7 @@ file_types_to_save = file_types_to_save.split(',')
 
 tmp_signal = Signal()
 tmp_sigs_array = SignalsArray()
-multi_channel = MultiChannel(
+multi_channel = MultiChannel(f_step, f_bases, f_roofs)
-    f_step,
-    f_bases,
-    f_roofs,
-    config_tags=[freq_suffix] * len(f_step),
-    report_freqs=[c_freq] * len(f_step),
-)
 f = multi_channel.init_f()
 multi_channel.fill_DB()
 
@@ -58,9 +51,8 @@ if debug_flag:
 def work(lvl):
 
     f = multi_channel.get_cur_channel()
-    config_tag = multi_channel.get_config_tag(f)
+    freq = get_centre_freq(f)
-    freq = multi_channel.get_report_freq(f)
+    signal_length = get_signal_length(freq)
-    signal_length = get_signal_length(config_tag)
     median, signal, abs_signal = tmp_signal.fill_sig(lvl, signal_length)
 
     if median != -1:

src/utils/datas_processing.py

@@ -1,16 +1,12 @@
 import os
 import io
 import csv
-import time
 import itertools
 import requests
 import numpy as np
 from datetime import datetime
 
 
-_telemetry_error_last_ts = 0.0
-
-
 def pack_elems(names, file_types, *elems):
     if len(names) != len(file_types) or len(names) != len(elems):
         raise ValueError('Длин массивов имен и типов файлов и не совпадает с количество элементов для сохранения')
@@ -53,6 +49,7 @@ def send_data(data, localhost, localport, endpoint):
         if response.status_code == 404 and fallback_port and str(localport) != str(fallback_port):
             response_fb, url_fb = _post(fallback_port)
             if response_fb.status_code == 200:
+                #print("Данные успешно отправлены и приняты!", url_fb)
                 return
             print("Ошибка при отправке данных:", response_fb.status_code, url_fb)
             return
@@ -62,37 +59,6 @@ def send_data(data, localhost, localport, endpoint):
         print(str(e))
 
 
-def send_telemetry(data, host, port, endpoint='telemetry', timeout_sec=0.30):
-    """
-    Best-effort отправка телеметрии на отдельный telemetry-server.
-    Ошибки намеренно не пробрасываются, чтобы не влиять на основной детект/аларм поток.
-    """
-    global _telemetry_error_last_ts
-
-    host = '' if host is None else str(host).strip()
-    port = '' if port is None else str(port).strip()
-    endpoint = str(endpoint or 'telemetry').strip().lstrip('/')
-
-    if not host or not port:
-        return
-
-    try:
-        url = f"http://{host}:{port}/{endpoint}"
-        response = requests.post(url, json=data, timeout=float(timeout_sec))
-        if response.status_code == 200:
-            return
-
-        now = time.time()
-        if now - _telemetry_error_last_ts >= 10.0:
-            print(f"telemetry http error: {response.status_code} {url}")
-            _telemetry_error_last_ts = now
-    except Exception as exc:
-        now = time.time()
-        if now - _telemetry_error_last_ts >= 10.0:
-            print(f"telemetry send failed: {exc}")
-            _telemetry_error_last_ts = now
-
-
 def save_data(path_to_save, freq, *args):
     """
     Сохранение данных в csv файл. Используется для сохранения метрик и медиан сигнала на каналах с датой и временем

src/utils/jammer_state_flag.py

@@ -1,47 +0,0 @@
-import os
-import time
-from pathlib import Path
-
-_DEFAULT_FLAG_PATH = Path(__file__).resolve().parents[2] / "runtime" / "jammer_active.flag"
-_FLAG_PATH = Path(os.getenv("JAMMER_STATE_FILE", str(_DEFAULT_FLAG_PATH)))
-_CACHE_TTL_SEC = float(os.getenv("JAMMER_STATE_CACHE_TTL_SEC", "0.25"))
-_STALE_SEC = float(os.getenv("JAMMER_STATE_STALE_SEC", "5.0"))
-
-_cached_value = False
-_cached_checked_monotonic = 0.0
-
-
-def _read_uncached() -> bool:
-    try:
-        stat = _FLAG_PATH.stat()
-        if time.time() - stat.st_mtime > _STALE_SEC:
-            return False
-        return _FLAG_PATH.read_text(encoding="ascii").strip() == "1"
-    except OSError:
-        return False
-
-
-def is_jammer_active() -> bool:
-    global _cached_value
-    global _cached_checked_monotonic
-
-    now = time.monotonic()
-    if now - _cached_checked_monotonic < _CACHE_TTL_SEC:
-        return _cached_value
-
-    _cached_value = _read_uncached()
-    _cached_checked_monotonic = now
-    return _cached_value
-
-
-def set_jammer_active(active: bool) -> None:
-    global _cached_value
-    global _cached_checked_monotonic
-
-    _FLAG_PATH.parent.mkdir(parents=True, exist_ok=True)
-    tmp_path = _FLAG_PATH.with_name(f"{_FLAG_PATH.name}.{os.getpid()}.tmp")
-    tmp_path.write_text("1" if active else "0", encoding="ascii")
-    os.replace(tmp_path, _FLAG_PATH)
-
-    _cached_value = bool(active)
-    _cached_checked_monotonic = time.monotonic()

telemetry/__init__.py

@@ -1 +0,0 @@
-# telemetry package

telemetry/telemetry_server.py

@@ -1,465 +0,0 @@
-import asyncio
-import os
-import time
-from collections import defaultdict, deque
-from typing import Any, Deque, Dict, List, Optional
-
-from fastapi import FastAPI, Query, WebSocket, WebSocketDisconnect
-from fastapi.responses import HTMLResponse
-from pydantic import BaseModel, Field
-
-from common.runtime import load_root_env
-
-load_root_env(__file__)
-
-TELEMETRY_BIND_HOST = os.getenv('telemetry_bind_host', os.getenv('lochost', '0.0.0.0'))
-TELEMETRY_BIND_PORT = int(os.getenv('telemetry_bind_port', os.getenv('telemetry_port', '5020')))
-TELEMETRY_HISTORY_SEC = int(float(os.getenv('telemetry_history_sec', '900')))
-TELEMETRY_MAX_POINTS_PER_FREQ = int(os.getenv('telemetry_max_points_per_freq', '5000'))
-
-
-def _new_buffer() -> Deque[Dict[str, Any]]:
-    return deque(maxlen=TELEMETRY_MAX_POINTS_PER_FREQ)
-
-
-app = FastAPI(title='DroneDetector Telemetry Server')
-_buffers: Dict[str, Deque[Dict[str, Any]]] = defaultdict(_new_buffer)
-_ws_clients: List[WebSocket] = []
-_state_lock = asyncio.Lock()
-
-
-class TelemetryPoint(BaseModel):
-    freq: str
-    ts: float = Field(default_factory=lambda: time.time())
-    dbfs_current: float
-    dbfs_threshold: Optional[float] = None
-    alarm: bool = False
-    channel_idx: int = 0
-    channels_total: int = 1
-    channel_values: Optional[List[float]] = None
-    channel_thresholds: Optional[List[Optional[float]]] = None
-    alarm_channels: Optional[List[int]] = None
-
-
-def _prune_freq_locked(freq: str, now_ts: float) -> None:
-    cutoff = now_ts - TELEMETRY_HISTORY_SEC
-    buf = _buffers[freq]
-    while buf and float(buf[0].get('ts', 0.0)) < cutoff:
-        buf.popleft()
-
-
-def _copy_series_locked(seconds: int, freq: Optional[str] = None) -> Dict[str, List[Dict[str, Any]]]:
-    now_ts = time.time()
-    cutoff = now_ts - seconds
-
-    if freq is not None:
-        data = [point for point in _buffers.get(freq, []) if float(point.get('ts', 0.0)) >= cutoff]
-        return {freq: data}
-
-    series: Dict[str, List[Dict[str, Any]]] = {}
-    for key, buf in _buffers.items():
-        series[key] = [point for point in buf if float(point.get('ts', 0.0)) >= cutoff]
-    return series
-
-
-async def _broadcast(message: Dict[str, Any]) -> None:
-    dead: List[WebSocket] = []
-    for ws in list(_ws_clients):
-        try:
-            await ws.send_json(message)
-        except Exception:
-            dead.append(ws)
-
-    if dead:
-        async with _state_lock:
-            for ws in dead:
-                if ws in _ws_clients:
-                    _ws_clients.remove(ws)
-
-
-@app.post('/telemetry')
-async def ingest_telemetry(point: TelemetryPoint):
-    payload = point.model_dump()
-    freq = str(payload['freq'])
-    now_ts = time.time()
-
-    async with _state_lock:
-        _buffers[freq].append(payload)
-        _prune_freq_locked(freq, now_ts)
-
-    await _broadcast({'type': 'point', 'data': payload})
-    return {'ok': True}
-
-
-@app.get('/telemetry/history')
-async def telemetry_history(
-    freq: Optional[str] = Query(default=None),
-    seconds: int = Query(default=300, ge=10, le=86400),
-):
-    seconds = min(seconds, TELEMETRY_HISTORY_SEC)
-    async with _state_lock:
-        series = _copy_series_locked(seconds=seconds, freq=freq)
-    return {'seconds': seconds, 'series': series}
-
-
-@app.websocket('/telemetry/ws')
-async def telemetry_ws(websocket: WebSocket):
-    await websocket.accept()
-    async with _state_lock:
-        _ws_clients.append(websocket)
-        snapshot = _copy_series_locked(seconds=min(300, TELEMETRY_HISTORY_SEC), freq=None)
-
-    await websocket.send_json({'type': 'snapshot', 'data': snapshot})
-
-    try:
-        while True:
-            # Keepalive channel from browser; content is ignored.
-            await websocket.receive_text()
-    except WebSocketDisconnect:
-        pass
-    finally:
-        async with _state_lock:
-            if websocket in _ws_clients:
-                _ws_clients.remove(websocket)
-
-
-MONITOR_HTML = """
-<!doctype html>
-<html>
-<head>
-  <meta charset=\"utf-8\" />
-  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />
-  <title>DroneDetector Telemetry</title>
-  <script src=\"https://cdn.plot.ly/plotly-2.35.2.min.js\"></script>
-  <style>
-    :root {
-      --bg: #f6f8fb;
-      --card: #ffffff;
-      --line: #d9dde5;
-      --text: #1c232e;
-      --green: #12b76a;
-      --red: #ef4444;
-      --muted: #5b6574;
-    }
-    body { margin: 0; background: var(--bg); color: var(--text); font-family: system-ui, -apple-system, Segoe UI, sans-serif; }
-    .wrap { max-width: 1800px; margin: 0 auto; padding: 14px; }
-    .head { display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px; }
-    .meta { font-size: 13px; color: var(--muted); }
-    .grid { display: flex; flex-direction: column; gap: 10px; }
-    .card { width: 100%; background: var(--card); border: 1px solid var(--line); border-radius: 10px; padding: 8px 8px 8px; }
-    .title-row { display: flex; justify-content: space-between; align-items: center; margin: 4px 8px; }
-    .title { font-size: 20px; font-weight: 700; }
-    .ctrl { display: flex; align-items: center; gap: 6px; }
-    .ctrl label { font-size: 12px; color: var(--muted); }
-    .ctrl select { border: 1px solid var(--line); border-radius: 6px; padding: 2px 6px; }
-    .plot { height: 260px; width: 100%; }
-    .events-title { font-size: 12px; color: var(--muted); margin: 2px 8px 4px; }
-    .events { max-height: 110px; overflow-y: auto; border-top: 1px dashed var(--line); margin: 0 8px; padding-top: 4px; }
-    .ev { display: flex; justify-content: space-between; font-size: 12px; line-height: 1.4; color: var(--text); }
-    .ev-t { color: var(--muted); }
-    .ev-empty { color: var(--muted); font-size: 12px; }
-  </style>
-</head>
-<body>
-  <div class=\"wrap\">
-    <div class=\"head\">
-      <div>
-        <h2 style=\"margin:0;\">DroneDetector Telemetry Monitor</h2>
-        <div class=\"meta\">Green: dBFS current, Red: channel threshold, Red dots: alarm points</div>
-      </div>
-      <div class=\"meta\" id=\"status\">connecting...</div>
-    </div>
-    <div class=\"grid\" id=\"plots\"></div>
-  </div>
-
-<script>
-const windowSec = 300;
-const state = {}; // freq -> points[]
-const selectedChannel = {}; // freq -> 'max' | channel index as string
-
-function numericSortFreq(a, b) {
-  return Number(a) - Number(b);
-}
-
-function formatTime(ts) {
-  return new Date(Number(ts) * 1000).toLocaleTimeString('ru-RU', {hour12: false});
-}
-
-function getChannelCount(freq) {
-  const pts = state[freq] || [];
-  let maxCount = 1;
-  for (const p of pts) {
-    if (Number.isFinite(Number(p.channels_total))) {
-      maxCount = Math.max(maxCount, Number(p.channels_total));
-    }
-    if (Array.isArray(p.channel_values)) {
-      maxCount = Math.max(maxCount, p.channel_values.length);
-    }
-  }
-  return maxCount;
-}
-
-function ensurePlot(freq) {
-  if (document.getElementById(`plot-${freq}`)) return;
-
-  const card = document.createElement('div');
-  card.className = 'card';
-  card.innerHTML = `
-    <div class=\"title-row\">
-      <div class=\"title\">${freq} MHz</div>
-      <div class=\"ctrl\">
-        <label for=\"chan-${freq}\">channel</label>
-        <select id=\"chan-${freq}\"></select>
-      </div>
-    </div>
-    <div class=\"plot\" id=\"plot-${freq}\"></div>
-    <div class=\"events-title\">Alarms (time -> channel)</div>
-    <div class=\"events\" id=\"events-${freq}\"></div>
-  `;
-  document.getElementById('plots').appendChild(card);
-
-  selectedChannel[freq] = 'max';
-  const sel = document.getElementById(`chan-${freq}`);
-  sel.addEventListener('change', () => {
-    selectedChannel[freq] = sel.value;
-    render(freq);
-  });
-}
-
-function updateChannelSelector(freq) {
-  const sel = document.getElementById(`chan-${freq}`);
-  if (!sel) return;
-
-  const prev = selectedChannel[freq] ?? 'max';
-  const count = getChannelCount(freq);
-
-  const opts = ['max'];
-  for (let i = 0; i < count; i += 1) opts.push(String(i));
-
-  sel.innerHTML = '';
-  for (const v of opts) {
-    const option = document.createElement('option');
-    option.value = v;
-    option.textContent = v === 'max' ? 'max' : `ch ${v}`;
-    sel.appendChild(option);
-  }
-
-  selectedChannel[freq] = opts.includes(prev) ? prev : 'max';
-  sel.value = selectedChannel[freq];
-}
-
-function trimPoints(freq) {
-  const arr = state[freq] || [];
-  const cutoff = Date.now() / 1000 - windowSec;
-  state[freq] = arr.filter(p => Number(p.ts) >= cutoff);
-}
-
-function getPointValueForSelection(point, selection) {
-  if (selection === 'max') {
-    return {
-      y: point.dbfs_current ?? null,
-      threshold: point.dbfs_threshold ?? null,
-    };
-  }
-
-  const idx = Number(selection);
-  if (!Number.isInteger(idx)) {
-    return {y: null, threshold: null};
-  }
-
-  const y = Array.isArray(point.channel_values) && idx < point.channel_values.length
-    ? point.channel_values[idx]
-    : null;
-  const threshold = Array.isArray(point.channel_thresholds) && idx < point.channel_thresholds.length
-    ? point.channel_thresholds[idx]
-    : null;
-
-  return {y, threshold};
-}
-
-function isAlarmForSelection(point, selection) {
-  if (point.alarm !== true) return false;
-  if (selection === 'max') return true;
-
-  const idx = Number(selection);
-  if (!Number.isInteger(idx)) return false;
-
-  if (Array.isArray(point.alarm_channels) && point.alarm_channels.length > 0) {
-    return point.alarm_channels.includes(idx);
-  }
-
-  return Number(point.channel_idx) === idx;
-}
-
-function renderAlarmEvents(freq, pts) {
-  const el = document.getElementById(`events-${freq}`);
-  if (!el) return;
-
-  const alarmPts = pts.filter(p => p.alarm === true);
-  if (alarmPts.length === 0) {
-    el.innerHTML = '<div class=\"ev-empty\">no alarms</div>';
-    return;
-  }
-
-  const rows = alarmPts.slice(-20).reverse().map((p) => {
-    const channels = Array.isArray(p.alarm_channels) && p.alarm_channels.length > 0
-      ? p.alarm_channels.join(',')
-      : String(p.channel_idx ?? '-');
-    return `<div class=\"ev\"><span class=\"ev-t\">${formatTime(p.ts)}</span><span>ch ${channels}</span></div>`;
-  });
-
-  el.innerHTML = rows.join('');
-}
-
-function render(freq) {
-  ensurePlot(freq);
-  trimPoints(freq);
-  updateChannelSelector(freq);
-
-  const pts = state[freq] || [];
-  const sel = selectedChannel[freq] ?? 'max';
-
-  const x = [];
-  const y = [];
-  const thr = [];
-  const alarmX = [];
-  const alarmY = [];
-
-  for (const p of pts) {
-    const metric = getPointValueForSelection(p, sel);
-    if (metric.y === null || metric.y === undefined) {
-      continue;
-    }
-
-    const ts = new Date(Number(p.ts) * 1000);
-    x.push(ts);
-    y.push(metric.y);
-    thr.push(metric.threshold);
-
-    if (isAlarmForSelection(p, sel)) {
-      alarmX.push(ts);
-      alarmY.push(metric.y);
-    }
-  }
-
-  const labelSuffix = sel === 'max' ? 'max' : `ch ${sel}`;
-
-  const traces = [
-    {
-      x,
-      y,
-      mode: 'lines',
-      name: `dBFS (${labelSuffix})`,
-      line: {color: '#12b76a', width: 2},
-    },
-    {
-      x,
-      y: thr,
-      mode: 'lines',
-      name: `Threshold (${labelSuffix})`,
-      line: {color: '#ef4444', width: 2, dash: 'dash'},
-    },
-    {
-      x: alarmX,
-      y: alarmY,
-      mode: 'markers',
-      name: 'Alarm',
-      marker: {color: '#ef4444', size: 6, symbol: 'circle'},
-    },
-  ];
-
-  Plotly.react(`plot-${freq}`, traces, {
-    margin: {l: 40, r: 12, t: 12, b: 32},
-    showlegend: true,
-    legend: {orientation: 'h', y: 1.16},
-    xaxis: {
-      title: 'time',
-      tickformat: '%H:%M:%S',
-      hoverformat: '%H:%M:%S',
-      range: [new Date(Date.now() - windowSec * 1000), new Date()],
-    },
-    yaxis: {title: 'dBFS'},
-  }, {displayModeBar: false, responsive: true});
-
-  renderAlarmEvents(freq, pts);
-}
-
-function renderAll() {
-  const freqs = Object.keys(state).sort(numericSortFreq);
-  freqs.forEach(render);
-}
-
-async function loadInitial() {
-  const res = await fetch(`/telemetry/history?seconds=${windowSec}`);
-  const payload = await res.json();
-  const series = payload.series || {};
-  for (const [freq, points] of Object.entries(series)) {
-    state[freq] = points;
-  }
-  renderAll();
-}
-
-function connectWs() {
-  const proto = location.protocol === 'https:' ? 'wss' : 'ws';
-  const ws = new WebSocket(`${proto}://${location.host}/telemetry/ws`);
-
-  ws.onopen = () => {
-    document.getElementById('status').textContent = 'ws connected';
-    setInterval(() => {
-      if (ws.readyState === 1) ws.send('ping');
-    }, 20000);
-  };
-
-  ws.onmessage = (event) => {
-    const msg = JSON.parse(event.data);
-    if (msg.type === 'snapshot' && msg.data) {
-      for (const [freq, points] of Object.entries(msg.data)) {
-        state[freq] = points;
-      }
-      renderAll();
-      return;
-    }
-
-    if (msg.type !== 'point') return;
-
-    const p = msg.data;
-    const freq = String(p.freq);
-    if (!state[freq]) state[freq] = [];
-    state[freq].push(p);
-    render(freq);
-  };
-
-  ws.onclose = () => {
-    document.getElementById('status').textContent = 'ws disconnected, retrying...';
-    setTimeout(connectWs, 1500);
-  };
-
-  ws.onerror = () => {
-    document.getElementById('status').textContent = 'ws error';
-  };
-}
-
-setInterval(() => {
-  renderAll();
-}, 1000);
-
-loadInitial().then(connectWs).catch((e) => {
-  document.getElementById('status').textContent = `init error: ${e}`;
-  connectWs();
-});
-</script>
-</body>
-</html>
-"""
-
-
-@app.get('/', response_class=HTMLResponse)
-@app.get('/monitor', response_class=HTMLResponse)
-async def monitor_page():
-    return HTMLResponse(content=MONITOR_HTML)
-
-
-if __name__ == '__main__':
-    import uvicorn
-
-    uvicorn.run(app, host=TELEMETRY_BIND_HOST, port=TELEMETRY_BIND_PORT)