удалил лишний дамп

README.md

@@ -164,15 +164,16 @@ 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-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
 ```
 
 

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 index from expected serial in env."""
+    """Resolve HackRF osmosdr selector 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 str(serials.index(serial))
+    return serial

common/shared_stream_addrs.py

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

deploy/systemd/dronedetector-sdr-1500.service

@@ -0,0 +1,19 @@
+[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

@@ -0,0 +1,19 @@
+[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,7 +1,8 @@
 [Unit]
 Description=DroneDetector SDR Scanner 868 MHz
-After=network-online.target
+After=network-online.target dronedetector-sdr-868-915.service
 Wants=network-online.target
+Requires=dronedetector-sdr-868-915.service
 
 [Service]
 Type=simple

deploy/systemd/dronedetector-sdr-915.service

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

install_all.sh

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

orange_scripts/main_915.py

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

restart_all.sh

@@ -7,14 +7,16 @@ COMPOSE_FILE="${PROJECT_ROOT}/deploy/docker/docker-compose.yml"
 SDR_UNITS=(
   dronedetector-sdr-433.service
   dronedetector-sdr-750.service
-  #dronedetector-sdr-868.service
+  dronedetector-sdr-868-915.service
+  dronedetector-sdr-868.service
+  dronedetector-sdr-1500.service
   dronedetector-sdr-3300.service
-  #dronedetector-sdr-4500.service
+  dronedetector-sdr-4500.service
   dronedetector-sdr-5200.service
   dronedetector-sdr-5800.service
-  #dronedetector-sdr-915.service
+  dronedetector-sdr-915.service
-  #dronedetector-sdr-1200.service
+  dronedetector-sdr-1200.service
-  #dronedetector-sdr-2400.service
+  dronedetector-sdr-2400.service
 )
 
 log() {

src/core/multichannelswitcher.py

@@ -1,63 +1,8 @@
-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
@@ -69,90 +14,63 @@ 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
 
-    def change_channel(self):
+    @staticmethod
-        """
+    def _range_finished(channel, roof, step):
-        Функция смены канала. Идет от верхней границы диапазона частоты к нижней с шагом step. Если дошли до нижней
+        if step < 0:
-        границы, то переключаемся на следующую частоту посредством переноса курсора текущего канала на верхнюю границу
+            return channel <= roof
-        новой частоты и указатель нижней границы также двигаем на следующую позицию. Если частота для обработки одна, то
+        return channel >= roof
-        указатель текущего канала возвращается в начало - верхней границы этой же частоты. Указатель нижней границы не
-        изменяется.
 
-        :return: Канал после смены.
+    def change_channel(self):
-        """
         if not self.init_freq:
             return self.init_f()
 
-        if self.cur_channel <= self.cur_roof:
+        current_idx = self.roofs.index(self.cur_roof)
-            if self.cur_roof == self.roofs[-1]:
+        if self._range_finished(self.cur_channel, self.cur_roof, self.cur_step):
-                self.cur_channel = self.bases[0]
+            next_idx = (current_idx + 1) % len(self.bases)
-                self.cur_roof = self.roofs[0]
+            self.cur_channel = self.bases[next_idx]
-                self.cur_step = self.steps[0]
+            self.cur_roof = self.roofs[next_idx]
-            else:
+            self.cur_step = self.steps[next_idx]
-                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
-            while tmp >= self.roofs[idx_freq]:
+            if step == 0:
-                counter += 1
+                raise ValueError('step must not be zero')
-                tmp += self.steps[idx_freq]
+            if step < 0:
+                while tmp >= roof:
+                    counter += 1
+                    tmp += step
+            else:
+                while tmp <= roof:
+                    counter += 1
+                    tmp += step
             self.num_chs.append(counter)
             return counter
-        else:
+        return self.num_chs[idx_freq]
-            return self.num_chs[idx_freq]
 
     def check_f(self, freq):
-        """
-        Проверить наличие частоты в классе. Если да, то вернуть количество каналов и циклический буфер этой частоты.
-        :param freq: Частота.
-        :return: Количество каналов, циклический буфер выбранной частоты ИЛИ none.
-        """
         for i in range(len(self.bases)):
-            if self.roofs[i] <= freq <= self.bases[i]:
+            low = min(self.roofs[i], self.bases[i])
+            high = max(self.roofs[i], self.bases[i])
+            if low <= freq <= high:
                 return self.get_num_chs(i), self.DB[i]
-            else:
+        return None, None
-                return None, None
 
-    def fill_DB(self):
+    def fill_DB(self, buffer_columns_size, num_of_thinning_iter, multiply_factor, num_for_alarm, freq_tag=None):
-        """
+        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(
@@ -161,16 +79,11 @@ class MultiChannel:
                     num_chs,
                     multiply_factor,
                     num_for_alarm,
-                    freq_tag=str(freq),
+                    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/embedded_1500.py

@@ -0,0 +1,150 @@
+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,30 +1,14 @@
 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.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'))
@@ -37,6 +21,12 @@ 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')
@@ -61,7 +51,13 @@ 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)
@@ -71,10 +67,8 @@ if debug_flag:
 
 
 def work(lvl):
-
     f = multi_channel.get_cur_channel()
-    freq = get_centre_freq(f)
+    freq = c_freq
-    signal_length = get_signal_length(freq)
     median = tmp_signal.fill_signal(lvl, signal_length)
     packet_ts = tmp_signal.get_last_packet_ts()
 
@@ -94,28 +88,26 @@ def work(lvl):
                 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),
+                                'freq': str(freq),
-                                "ts": time.time(),
+                                'ts': time.time(),
-                                "dbfs_current": dbfs_current,
+                                'dbfs_current': dbfs_current,
-                                "dbfs_threshold": dbfs_threshold,
+                                'dbfs_threshold': dbfs_threshold,
-                                "alarm": bool(alarm),
+                                'alarm': bool(alarm),
-                                "channel_idx": int(max_idx),
+                                'channel_idx': int(max_idx),
-                                "channels_total": int(len(sigs_array)),
+                                'channels_total': int(len(sigs_array)),
-                                "channel_values": [float(v) for v in sigs_array],
+                                'channel_values': [float(v) for v in sigs_array],
-                                "channel_thresholds": channel_thresholds,
+                                'channel_thresholds': channel_thresholds,
-                                "alarm_channels": alarm_channels,
+                                'alarm_channels': alarm_channels,
                             },
                             host=telemetry_host,
                             port=telemetry_port,
@@ -124,18 +116,16 @@ def work(lvl):
                         )
                     except Exception as exc:
                         if debug_flag:
-                            print(f"telemetry send failed: {exc}")
+                            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)),
+                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), 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,
+                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians())
-                                  circle_buffer.get_medians())
 
             if debug_flag:
                 single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@@ -146,14 +136,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,30 +1,14 @@
 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.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'))
@@ -37,6 +21,12 @@ 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')
@@ -61,7 +51,13 @@ 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)
@@ -71,10 +67,8 @@ if debug_flag:
 
 
 def work(lvl):
-
     f = multi_channel.get_cur_channel()
-    freq = get_centre_freq(f)
+    freq = c_freq
-    signal_length = get_signal_length(freq)
     median = tmp_signal.fill_signal(lvl, signal_length)
     packet_ts = tmp_signal.get_last_packet_ts()
 
@@ -94,28 +88,26 @@ def work(lvl):
                 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),
+                                'freq': str(freq),
-                                "ts": time.time(),
+                                'ts': time.time(),
-                                "dbfs_current": dbfs_current,
+                                'dbfs_current': dbfs_current,
-                                "dbfs_threshold": dbfs_threshold,
+                                'dbfs_threshold': dbfs_threshold,
-                                "alarm": bool(alarm),
+                                'alarm': bool(alarm),
-                                "channel_idx": int(max_idx),
+                                'channel_idx': int(max_idx),
-                                "channels_total": int(len(sigs_array)),
+                                'channels_total': int(len(sigs_array)),
-                                "channel_values": [float(v) for v in sigs_array],
+                                'channel_values': [float(v) for v in sigs_array],
-                                "channel_thresholds": channel_thresholds,
+                                'channel_thresholds': channel_thresholds,
-                                "alarm_channels": alarm_channels,
+                                'alarm_channels': alarm_channels,
                             },
                             host=telemetry_host,
                             port=telemetry_port,
@@ -124,18 +116,16 @@ def work(lvl):
                         )
                     except Exception as exc:
                         if debug_flag:
-                            print(f"telemetry send failed: {exc}")
+                            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)),
+                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), 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,
+                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians())
-                                  circle_buffer.get_medians())
 
             if debug_flag:
                 single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@@ -146,14 +136,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,30 +1,14 @@
 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.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'))
@@ -37,6 +21,12 @@ 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')
@@ -61,7 +51,13 @@ 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)
@@ -71,10 +67,8 @@ if debug_flag:
 
 
 def work(lvl):
-
     f = multi_channel.get_cur_channel()
-    freq = get_centre_freq(f)
+    freq = c_freq
-    signal_length = get_signal_length(freq)
     median = tmp_signal.fill_signal(lvl, signal_length)
     packet_ts = tmp_signal.get_last_packet_ts()
 
@@ -94,28 +88,26 @@ def work(lvl):
                 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),
+                                'freq': str(freq),
-                                "ts": time.time(),
+                                'ts': time.time(),
-                                "dbfs_current": dbfs_current,
+                                'dbfs_current': dbfs_current,
-                                "dbfs_threshold": dbfs_threshold,
+                                'dbfs_threshold': dbfs_threshold,
-                                "alarm": bool(alarm),
+                                'alarm': bool(alarm),
-                                "channel_idx": int(max_idx),
+                                'channel_idx': int(max_idx),
-                                "channels_total": int(len(sigs_array)),
+                                'channels_total': int(len(sigs_array)),
-                                "channel_values": [float(v) for v in sigs_array],
+                                'channel_values': [float(v) for v in sigs_array],
-                                "channel_thresholds": channel_thresholds,
+                                'channel_thresholds': channel_thresholds,
-                                "alarm_channels": alarm_channels,
+                                'alarm_channels': alarm_channels,
                             },
                             host=telemetry_host,
                             port=telemetry_port,
@@ -124,18 +116,16 @@ def work(lvl):
                         )
                     except Exception as exc:
                         if debug_flag:
-                            print(f"telemetry send failed: {exc}")
+                            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)),
+                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), 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,
+                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians())
-                                  circle_buffer.get_medians())
 
             if debug_flag:
                 single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@@ -146,14 +136,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,30 +1,14 @@
 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.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'))
@@ -37,6 +21,12 @@ 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')
@@ -61,7 +51,13 @@ 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)
@@ -71,10 +67,8 @@ if debug_flag:
 
 
 def work(lvl):
-
     f = multi_channel.get_cur_channel()
-    freq = get_centre_freq(f)
+    freq = c_freq
-    signal_length = get_signal_length(freq)
     median = tmp_signal.fill_signal(lvl, signal_length)
     packet_ts = tmp_signal.get_last_packet_ts()
 
@@ -94,28 +88,26 @@ def work(lvl):
                 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),
+                                'freq': str(freq),
-                                "ts": time.time(),
+                                'ts': time.time(),
-                                "dbfs_current": dbfs_current,
+                                'dbfs_current': dbfs_current,
-                                "dbfs_threshold": dbfs_threshold,
+                                'dbfs_threshold': dbfs_threshold,
-                                "alarm": bool(alarm),
+                                'alarm': bool(alarm),
-                                "channel_idx": int(max_idx),
+                                'channel_idx': int(max_idx),
-                                "channels_total": int(len(sigs_array)),
+                                'channels_total': int(len(sigs_array)),
-                                "channel_values": [float(v) for v in sigs_array],
+                                'channel_values': [float(v) for v in sigs_array],
-                                "channel_thresholds": channel_thresholds,
+                                'channel_thresholds': channel_thresholds,
-                                "alarm_channels": alarm_channels,
+                                'alarm_channels': alarm_channels,
                             },
                             host=telemetry_host,
                             port=telemetry_port,
@@ -124,18 +116,16 @@ def work(lvl):
                         )
                     except Exception as exc:
                         if debug_flag:
-                            print(f"telemetry send failed: {exc}")
+                            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)),
+                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), 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,
+                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians())
-                                  circle_buffer.get_medians())
 
             if debug_flag:
                 single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@@ -146,14 +136,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,30 +1,14 @@
 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.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'))
@@ -37,6 +21,12 @@ 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')
@@ -61,7 +51,13 @@ 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)
@@ -71,10 +67,8 @@ if debug_flag:
 
 
 def work(lvl):
-
     f = multi_channel.get_cur_channel()
-    freq = get_centre_freq(f)
+    freq = c_freq
-    signal_length = get_signal_length(freq)
     median = tmp_signal.fill_signal(lvl, signal_length)
     packet_ts = tmp_signal.get_last_packet_ts()
 
@@ -94,28 +88,26 @@ def work(lvl):
                 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),
+                                'freq': str(freq),
-                                "ts": time.time(),
+                                'ts': time.time(),
-                                "dbfs_current": dbfs_current,
+                                'dbfs_current': dbfs_current,
-                                "dbfs_threshold": dbfs_threshold,
+                                'dbfs_threshold': dbfs_threshold,
-                                "alarm": bool(alarm),
+                                'alarm': bool(alarm),
-                                "channel_idx": int(max_idx),
+                                'channel_idx': int(max_idx),
-                                "channels_total": int(len(sigs_array)),
+                                'channels_total': int(len(sigs_array)),
-                                "channel_values": [float(v) for v in sigs_array],
+                                'channel_values': [float(v) for v in sigs_array],
-                                "channel_thresholds": channel_thresholds,
+                                'channel_thresholds': channel_thresholds,
-                                "alarm_channels": alarm_channels,
+                                'alarm_channels': alarm_channels,
                             },
                             host=telemetry_host,
                             port=telemetry_port,
@@ -124,18 +116,16 @@ def work(lvl):
                         )
                     except Exception as exc:
                         if debug_flag:
-                            print(f"telemetry send failed: {exc}")
+                            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)),
+                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), 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,
+                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians())
-                                  circle_buffer.get_medians())
 
             if debug_flag:
                 single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@@ -146,14 +136,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,30 +1,14 @@
 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.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'))
@@ -37,6 +21,12 @@ 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')
@@ -61,7 +51,13 @@ 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)
@@ -71,20 +67,15 @@ if debug_flag:
 
 
 def work(lvl):
-
     f = multi_channel.get_cur_channel()
-    freq = get_centre_freq(f)
+    freq = c_freq
-    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)
-            print(num_chs, circle_buffer)
             cur_channel, sigs_array, sigs_ts_array = tmp_sigs_array.fill_sig_arr(median, packet_ts=packet_ts, num_chs=num_chs)
-            print(3)
 
             if sigs_array:
                 print('Значения на {0}: {1}'.format(freq, sigs_array))
@@ -97,28 +88,26 @@ def work(lvl):
                 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),
+                                'freq': str(freq),
-                                "ts": time.time(),
+                                'ts': time.time(),
-                                "dbfs_current": dbfs_current,
+                                'dbfs_current': dbfs_current,
-                                "dbfs_threshold": dbfs_threshold,
+                                'dbfs_threshold': dbfs_threshold,
-                                "alarm": bool(alarm),
+                                'alarm': bool(alarm),
-                                "channel_idx": int(max_idx),
+                                'channel_idx': int(max_idx),
-                                "channels_total": int(len(sigs_array)),
+                                'channels_total': int(len(sigs_array)),
-                                "channel_values": [float(v) for v in sigs_array],
+                                'channel_values': [float(v) for v in sigs_array],
-                                "channel_thresholds": channel_thresholds,
+                                'channel_thresholds': channel_thresholds,
-                                "alarm_channels": alarm_channels,
+                                'alarm_channels': alarm_channels,
                             },
                             host=telemetry_host,
                             port=telemetry_port,
@@ -127,18 +116,16 @@ def work(lvl):
                         )
                     except Exception as exc:
                         if debug_flag:
-                            print(f"telemetry send failed: {exc}")
+                            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)),
+                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), 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,
+                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians())
-                                  circle_buffer.get_medians())
 
             if debug_flag:
                 single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@@ -149,14 +136,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,30 +1,14 @@
 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.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'))
@@ -37,6 +21,12 @@ 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')
@@ -61,7 +51,13 @@ 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)
@@ -71,10 +67,8 @@ if debug_flag:
 
 
 def work(lvl):
-
     f = multi_channel.get_cur_channel()
-    freq = get_centre_freq(f)
+    freq = c_freq
-    signal_length = get_signal_length(freq)
     median = tmp_signal.fill_signal(lvl, signal_length)
     packet_ts = tmp_signal.get_last_packet_ts()
 
@@ -94,28 +88,26 @@ def work(lvl):
                 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),
+                                'freq': str(freq),
-                                "ts": time.time(),
+                                'ts': time.time(),
-                                "dbfs_current": dbfs_current,
+                                'dbfs_current': dbfs_current,
-                                "dbfs_threshold": dbfs_threshold,
+                                'dbfs_threshold': dbfs_threshold,
-                                "alarm": bool(alarm),
+                                'alarm': bool(alarm),
-                                "channel_idx": int(max_idx),
+                                'channel_idx': int(max_idx),
-                                "channels_total": int(len(sigs_array)),
+                                'channels_total': int(len(sigs_array)),
-                                "channel_values": [float(v) for v in sigs_array],
+                                'channel_values': [float(v) for v in sigs_array],
-                                "channel_thresholds": channel_thresholds,
+                                'channel_thresholds': channel_thresholds,
-                                "alarm_channels": alarm_channels,
+                                'alarm_channels': alarm_channels,
                             },
                             host=telemetry_host,
                             port=telemetry_port,
@@ -124,18 +116,16 @@ def work(lvl):
                         )
                     except Exception as exc:
                         if debug_flag:
-                            print(f"telemetry send failed: {exc}")
+                            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)),
+                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), 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,
+                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians())
-                                  circle_buffer.get_medians())
 
             if debug_flag:
                 single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@@ -146,14 +136,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

@@ -0,0 +1,104 @@
+#!/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,6 +18,7 @@ import time
 import threading
 import subprocess
 import os
+import numpy as np
 
 from common.runtime import load_root_env, resolve_hackrf_index
 
@@ -82,6 +83,14 @@ 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
@@ -94,21 +103,42 @@ 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(100, 0)
+        self.rtlsdr_source_0.set_gain(24, 0)
-        self.rtlsdr_source_0.set_if_gain(100, 0)
+        self.rtlsdr_source_0.set_if_gain(24, 0)
-        self.rtlsdr_source_0.set_bb_gain(0, 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()
@@ -128,7 +158,12 @@ class get_center_freq(gr.top_block):
 
     def set_prob_freq(self, prob_freq):
         self.prob_freq = prob_freq
-        self.set_center_freq(my_freq.work(self.prob_freq))
+        next_center = 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

@@ -94,9 +94,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(10, 0)
+        self.rtlsdr_source_0.set_gain(24, 0)
-        self.rtlsdr_source_0.set_if_gain(100, 0)
+        self.rtlsdr_source_0.set_if_gain(24, 0)
-        self.rtlsdr_source_0.set_bb_gain(0, 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)

src/main_4500.py

@@ -18,6 +18,7 @@ import time
 import threading
 import subprocess
 import os
+import numpy as np
 
 from common.runtime import load_root_env, resolve_hackrf_index
 
@@ -82,6 +83,14 @@ 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
@@ -94,21 +103,42 @@ 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(100, 0)
+        self.rtlsdr_source_0.set_gain(24, 0)
-        self.rtlsdr_source_0.set_if_gain(100, 0)
+        self.rtlsdr_source_0.set_if_gain(24, 0)
-        self.rtlsdr_source_0.set_bb_gain(0, 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()
@@ -128,7 +158,12 @@ class get_center_freq(gr.top_block):
 
     def set_prob_freq(self, prob_freq):
         self.prob_freq = prob_freq
-        self.set_center_freq(my_freq.work(self.prob_freq))
+        next_center = 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,6 +18,7 @@ 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__)
@@ -81,6 +82,14 @@ 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
@@ -94,20 +103,41 @@ 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(100, 0)
+        self.rtlsdr_source_0.set_if_gain(24, 0)
-        self.rtlsdr_source_0.set_bb_gain(0, 0)
+        self.rtlsdr_source_0.set_bb_gain(24, 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()
@@ -127,7 +157,12 @@ class get_center_freq(gr.top_block):
 
     def set_prob_freq(self, prob_freq):
         self.prob_freq = prob_freq
-        self.set_center_freq(my_freq.work(self.prob_freq))
+        next_center = 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,6 +18,7 @@ import time
 import threading
 import subprocess
 import os
+import numpy as np
 
 from common.runtime import load_root_env, resolve_hackrf_index
 
@@ -82,6 +83,14 @@ 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
@@ -94,21 +103,42 @@ 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(5, 0)
+        self.rtlsdr_source_0.set_gain(24, 0)
-        self.rtlsdr_source_0.set_if_gain(100, 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(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()
@@ -128,7 +158,12 @@ class get_center_freq(gr.top_block):
 
     def set_prob_freq(self, prob_freq):
         self.prob_freq = prob_freq
-        self.set_center_freq(my_freq.work(self.prob_freq))
+        next_center = 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

@@ -94,9 +94,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(100, 0)
+        self.rtlsdr_source_0.set_gain(24, 0)
-        self.rtlsdr_source_0.set_if_gain(100, 0)
+        self.rtlsdr_source_0.set_if_gain(24, 0)
-        self.rtlsdr_source_0.set_bb_gain(0, 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)

src/main_868.py

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

src/main_868_915_router.py

@@ -0,0 +1,122 @@
+#!/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/shared_router_868_915.py

@@ -0,0 +1,173 @@
+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

@@ -1,108 +1,116 @@
-import os
+import os
-import datetime
+import datetime
-from smb.SMBConnection import SMBConnection
+from smb.SMBConnection import SMBConnection
-from dotenv import load_dotenv
+from dotenv import load_dotenv
-from DroneScanner.utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
+from DroneScanner.utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
-from DroneScanner.core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
+from DroneScanner.core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
-from DroneScanner.core.multichannelswitcher import MultiChannel, get_centre_freq
+from DroneScanner.core.multichannelswitcher import MultiChannel, get_centre_freq
-
+
-dotenv_path = os.path.join(os.path.dirname(__file__), '../../.env')
+dotenv_path = os.path.join(os.path.dirname(__file__), '../../.env')
-if os.path.exists(dotenv_path):
+if os.path.exists(dotenv_path):
-    load_dotenv(dotenv_path)
+    load_dotenv(dotenv_path)
-
+
-debug_flag = bool(os.getenv('debug_flag'))
+debug_flag = bool(os.getenv('debug_flag'))
-send_to_module_flag = bool(os.getenv('send_to_module_flag'))
+send_to_module_flag = bool(os.getenv('send_to_module_flag'))
-save_data_flag = bool(os.getenv('save_data_flag'))
+save_data_flag = bool(os.getenv('save_data_flag'))
-module_name = os.getenv('module_name')
+module_name = os.getenv('module_name')
-elems_to_save = os.getenv('elems_to_save')
+elems_to_save = os.getenv('elems_to_save')
-file_types_to_save = os.getenv('file_types_to_save')
+file_types_to_save = os.getenv('file_types_to_save')
-localhost = os.getenv('lochost')
+localhost = os.getenv('lochost')
-localport = os.getenv('locport')
+localport = os.getenv('locport')
-f_step = [*map(float, os.getenv('f_step_1200').split())]
+f_step = [*map(float, os.getenv('f_step_1200').split())]
-f_bases = [*map(float, os.getenv('f_bases_1200').split())]
+f_bases = [*map(float, os.getenv('f_bases_1200').split())]
-f_roofs = [*map(float, os.getenv('f_roofs_1200').split())]
+f_roofs = [*map(float, os.getenv('f_roofs_1200').split())]
-path_to_save_medians = os.getenv('path_to_save_medians')
+
-path_to_save_alarms = os.getenv('path_to_save_alarms')
+c_freq = as_str(os.getenv(f'c_freq_{freq_suffix}', freq_suffix))path_to_save_medians = os.getenv('path_to_save_medians')
-smb_host = os.getenv('smb_host')
+path_to_save_alarms = os.getenv('path_to_save_alarms')
-smb_port = os.getenv('smb_port')
+smb_host = os.getenv('smb_host')
-smb_user = os.getenv('smb_user')
+smb_port = os.getenv('smb_port')
-smb_pass = os.getenv('smb_pass')
+smb_user = os.getenv('smb_user')
-shared_folder = os.getenv('shared_folder')
+smb_pass = os.getenv('smb_pass')
-the_pc_name = os.getenv('the_pc_name')
+shared_folder = os.getenv('shared_folder')
-remote_pc_name = os.getenv('remote_pc_name')
+the_pc_name = os.getenv('the_pc_name')
-smb_domain = os.getenv('smb_domain')
+remote_pc_name = os.getenv('remote_pc_name')
-
+smb_domain = os.getenv('smb_domain')
-elems_to_save = elems_to_save.split(',')
+
-file_types_to_save = file_types_to_save.split(',')
+elems_to_save = elems_to_save.split(',')
-
+file_types_to_save = file_types_to_save.split(',')
-tmp_signal = Signal()
+
-tmp_sigs_array = SignalsArray()
+tmp_signal = Signal()
-multi_channel = MultiChannel(f_step, f_bases, f_roofs)
+tmp_sigs_array = SignalsArray()
-f = multi_channel.init_f()
+multi_channel = MultiChannel(
-multi_channel.fill_DB()
+    f_step,
-
+    f_bases,
-if debug_flag:
+    f_roofs,
-    conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
+    config_tags=[freq_suffix] * len(f_step),
-    conn.connect(smb_host, 139)
+    report_freqs=[c_freq] * len(f_step),
-    filelist = conn.listPath(shared_folder, '/')
+)
-    print(filelist)
+f = multi_channel.init_f()
-
+multi_channel.fill_DB()
-
+
-def work(lvl):
+if debug_flag:
-
+    conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
-    f = multi_channel.get_cur_channel()
+    conn.connect(smb_host, 139)
-    freq = get_centre_freq(f)
+    filelist = conn.listPath(shared_folder, '/')
-    signal_length = get_signal_length(freq)
+    print(filelist)
-    median, signal, abs_signal = tmp_signal.fill_sig(lvl, signal_length)
+
-
+
-    if median != -1:
+def work(lvl):
-        try:
+
-            num_chs, circle_buffer = multi_channel.check_f(f)
+    f = multi_channel.get_cur_channel()
-
+    config_tag = multi_channel.get_config_tag(f)
-            #print(f, freq, num_chs, signal_length)
+    freq = multi_channel.get_report_freq(f)
-            #print(median)
+    signal_length = get_signal_length(config_tag)
-
+    median, signal, abs_signal = tmp_signal.fill_sig(lvl, signal_length)
-            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
+
-
+    if median != -1:
-            if sigs_array:
+        try:
-                print('Значения на {0}: {1}'.format(freq, sigs_array))
+            num_chs, circle_buffer = multi_channel.check_f(f)
-                print('Пороги: ', circle_buffer.get_medians())
+
-                alarm = circle_buffer.check_alarm(sigs_array)
+            #print(f, freq, num_chs, signal_length)
-
+            #print(median)
-                if alarm:
+
-                    print('----ALARM---- ', freq)
+            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
-                    multi_channel.db_alarms_zeros(circle_buffer)
+
-                else:
+            if sigs_array:
-                    circle_buffer.update(sigs_array)
+                print('Значения на {0}: {1}'.format(freq, sigs_array))
-
+                print('Пороги: ', circle_buffer.get_medians())
-                if send_to_module_flag:
+                alarm = circle_buffer.check_alarm(sigs_array)
-                    send_data(agregator(freq, alarm), localhost, localport)
+
-
+                if alarm:
-                if save_data_flag:
+                    print('----ALARM---- ', freq)
-                    if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
+                    multi_channel.db_alarms_zeros(circle_buffer)
-                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
+                else:
-                                  list(range(num_chs)))
+                    circle_buffer.update(sigs_array)
-                    if circle_buffer.check_init():
+
-                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
+                if send_to_module_flag:
-                                  circle_buffer.get_medians())
+                    send_data(agregator(freq, alarm), localhost, localport)
-                # print(circle_buffer.get_buffer())
+
-                # print(circle_buffer.get_medians())
+                if save_data_flag:
-                # print(circle_buffer.get_alarms())
+                    if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
-            if debug_flag:
+                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
-                single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
+                                  list(range(num_chs)))
-                print(cur_channel, single_alarm)
+                    if circle_buffer.check_init():
-                if single_alarm:
+                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
-                    data = pack_elems(elems_to_save, file_types_to_save, signal, abs_signal)
+                                  circle_buffer.get_medians())
-                    #print('SAVE CURRENT SIGNAL SROCHNO TI MENYA SLISHISH?!?!?!?')
+                # print(circle_buffer.get_buffer())
-                    try:
+                # print(circle_buffer.get_medians())
-                        remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
+                # print(circle_buffer.get_alarms())
-                    except Exception as e:
+            if debug_flag:
-                        print(f"Ошибка: {e}")
+                single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
-                #else:
+                print(cur_channel, single_alarm)
-                    #print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
+                if single_alarm:
-
+                    data = pack_elems(elems_to_save, file_types_to_save, signal, abs_signal)
-            f = multi_channel.change_channel()
+                    #print('SAVE CURRENT SIGNAL SROCHNO TI MENYA SLISHISH?!?!?!?')
-        except Exception as e:
+                    try:
-            print(str(e))
+                        remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
-            print(".", end='')
+                    except Exception as e:
-    return f
+                        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='')
+    return f