sync

.gitignore

@@ -183,4 +183,5 @@ cython_debug/
 #.idea/
 
 *.png
-/logs/*.log
+/logs/*.log
+runtime/

deploy/docker/docker-compose.yml

@@ -9,6 +9,7 @@ services:
       - ../../.env
     environment:
       - PYTHONPATH=/app
+      - JAMMER_STATE_FILE=/app/runtime/jammer_active.flag
     working_dir: /app
     command: ["python3", "-m", "src.server_to_master"]
     restart: unless-stopped
@@ -16,6 +17,7 @@ services:
       - "5010:5010"
     volumes:
       - ../../.env:/app/.env:ro
+      - ../../runtime:/app/runtime
     networks:
       - dronedetector-net
 

restart_all.sh

@@ -7,14 +7,14 @@ 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.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/data_buffer.py

@@ -1,6 +1,6 @@
 import os
-import math
 import statistics
+from datetime import datetime
 
 # Более лучшая версия кода есть в FRScanner
 
@@ -12,28 +12,20 @@ class DataBuffer:
     Атрибуты:
             current_column: Указатель на текущий столбец буфера, который обновляем.
             thinning_counter: Прореживающий множитель на текующей итерации.
-            current_counter:  Указатель на количество чтений между последним обновлением столбца и предыдущим атрибутом.
+            current_counter: Указатель на количество чтений между последним обновлением столбца и предыдущим атрибутом.
-            num_of_thinning_iter: Прореживающий множитель. Раз в это количечество раз будет обнволяться столбец буфера.
+            num_of_thinning_iter: Прореживающий множитель. Раз в это количество раз будет обновляться столбец буфера.
             line_size: Количество строк буфера = количеству каналов.
             columns_size: Количество столбцов = фиксированное число.
-            multiply_factor: Процентный показатель превышения сигналом уровня шума.
+            multiply_factor: Процентный показатель превышения сигналом уровня шума (legacy).
             num_for_alarm: Количество раз, превышающих шум, при которых триггеримся.
-            is_init: Флаг инициализации буфера. = True, если инициализирован.
+            is_init: Флаг инициализации буфера.
             buffer: Массив для буфера.
-            buffer_medians: Массив для медиан столбцов букера.
+            buffer_medians: Массив медиан по каналам.
-            buffer_alarms: Массив для количества тревог по столбца буфера.
+            buffer_mads: Массив MAD по каналам.
+            buffer_alarms: Массив для количества тревог по каналам.
     """
 
-    def __init__(self, columns_size, num_of_thinning_iter, num_of_channels, multiply_factor, num_for_alarm):
+    def __init__(self, columns_size, num_of_thinning_iter, num_of_channels, multiply_factor, num_for_alarm, freq_tag=None):
-        """
-        Инициализируем класс.
-
-        :param columns_size:
-        :param num_of_thinning_iter:
-        :param num_of_channels:
-        :param multiply_factor:
-        :param num_for_alarm:
-        """
         self.current_column = 0
         self.thinning_counter = 1
         self.current_counter = 1
@@ -43,29 +35,46 @@ class DataBuffer:
         self.multiply_factor = multiply_factor
         self.num_for_alarm = num_for_alarm
         self.is_init = False
+
         self.buffer = [[0 for _ in range(self.columns_size)] for _ in range(self.line_size)]
-        self.buffer_medians = [0] * self.line_size
+        self.buffer_timestamps = [[None for _ in range(self.columns_size)] for _ in range(self.line_size)]
+        self.buffer_medians = [0.0] * self.line_size
+        self.buffer_mads = [0.0] * self.line_size
         self.buffer_alarms = [0] * self.line_size
+        self.last_alarm_channels = []
+        self.episode_history = [[0.0 for _ in range(self.num_of_thinning_iter)] for _ in range(self.line_size)]
+        self.episode_history_timestamps = [[None for _ in range(self.num_of_thinning_iter)] for _ in range(self.line_size)]
 
-        self.prev_values = [None] * self.line_size
+        self.freq_tag = '' if freq_tag is None else str(freq_tag)
-        self.trend_streak = [0] * self.line_size
+        suffix = f'_{self.freq_tag}' if self.freq_tag else ''
 
-        # Рост в 15% по линейной мощности относительно фоновой медианы в dBFS.
+        self.mad_k_on = float(os.getenv('mad_k_on' + suffix, os.getenv('mad_k_on', 5.0)))
-        self.dbfs_delta_ratio = float(os.getenv('dbfs_delta_percent', 15)) / 100.0
+        self.mad_eps = float(os.getenv('mad_eps' + suffix, os.getenv('mad_eps', 0.05)))
-        # Допускаем небольшой обратный ход, чтобы не сбрасываться от микрошума.
+        self.dbfs_linear_offset_db = float(
-        self.dbfs_max_backstep_db = float(os.getenv('dbfs_max_backstep_db', 0.25))
+            os.getenv('dbfs_linear_offset_db' + suffix, os.getenv('dbfs_linear_offset_db', 0.0))
-        # Минимум подряд "плавных" шагов перед учетом как устойчивого роста.
+        )
-        self.dbfs_min_trend_steps = int(os.getenv('dbfs_min_trend_steps', max(1, self.num_for_alarm)))
+        self.dbfs_linear_abs_median_scale = float(
+            os.getenv('dbfs_linear_abs_median_scale' + suffix, os.getenv('dbfs_linear_abs_median_scale', 0.0))
+        )
 
     def get_buffer(self):
         return self.buffer
 
+    def get_timestamps(self):
+        return self.buffer_timestamps
+
     def get_medians(self):
         return self.buffer_medians
 
+    def get_mads(self):
+        return self.buffer_mads
+
     def get_alarms(self):
         return self.buffer_alarms
 
+    def get_last_alarm_channels(self):
+        return list(self.last_alarm_channels)
+
     def check_init(self):
         return self.is_init
 
@@ -75,25 +84,89 @@ class DataBuffer:
             print(self.buffer[i], end=' ')
             print()
 
+    @staticmethod
+    def _calc_mad(values, median):
+        deviations = [abs(v - median) for v in values]
+        return statistics.median(deviations)
+
+    @staticmethod
+    def _format_ts(timestamp):
+        if timestamp is None:
+            return 'None'
+        try:
+            return datetime.fromtimestamp(float(timestamp)).isoformat(sep=' ', timespec='milliseconds')
+        except Exception:
+            return str(timestamp)
+
+    @staticmethod
+    def _mean_timestamp(timestamps):
+        filtered = [float(ts) for ts in timestamps if ts is not None]
+        if not filtered:
+            return None
+        return sum(filtered) / len(filtered)
+
     def medians(self):
         """
-        Вычислить медиану по строке буфера.
+        Вычислить медиану и MAD по строкам буфера.
         :return: None
         """
         if self.check_init():
             for i in range(self.line_size):
-                self.buffer_medians[i] = statistics.median(self.buffer[i])
+                med = float(statistics.median(self.buffer[i]))
+                self.buffer_medians[i] = med
+                self.buffer_mads[i] = float(self._calc_mad(self.buffer[i], med))
+
+    def get_linear_term(self, median_value):
+        median_value = float(median_value)
+        return self.dbfs_linear_offset_db + self.dbfs_linear_abs_median_scale * abs(median_value)
+
+    def get_threshold(self, channel_idx):
+        """
+        Получить динамический порог в dB для канала:
+        threshold = median + linear_term(median) + mad_k_on * MAD.
+        До завершения инициализации возвращает None.
+        """
+        if not self.check_init():
+            return None
+
+        baseline = float(self.buffer_medians[channel_idx])
+        mad_eff = max(float(self.buffer_mads[channel_idx]), self.mad_eps)
+        linear_term = self.get_linear_term(baseline)
+        return baseline + linear_term + self.mad_k_on * mad_eff
+
+    def get_thresholds(self):
+        if not self.check_init():
+            return [None] * self.line_size
+        return [self.get_threshold(i) for i in range(self.line_size)]
+
+    def log_threshold_update(self, updated_column):
+        if not self.check_init():
+            return
+
+        now_str = datetime.now().isoformat(sep=' ', timespec='milliseconds')
+        freq_tag = self.freq_tag or 'unknown'
+        print(f'[threshold-update][{freq_tag}] now={now_str} updated_column={updated_column}')
+        for i in range(self.line_size):
+            baseline = float(self.buffer_medians[i])
+            mad = float(self.buffer_mads[i])
+            mad_eff = max(mad, self.mad_eps)
+            linear_term = self.get_linear_term(baseline)
+            threshold = self.get_threshold(i)
+            packet_times = [self._format_ts(ts) for ts in self.buffer_timestamps[i]]
+            print(
+                f'  ch={i} median={baseline:.6f} '
+                f'linear_term={linear_term:.6f} '
+                f'mad={mad:.6f} mad_eff={mad_eff:.6f} '
+                f'mad_term={self.mad_k_on * mad_eff:.6f} '
+                f'threshold={threshold:.6f} '
+                f'packet_times={packet_times}'
+            )
 
     def alarms_fill_zeros(self):
         self.buffer_alarms = [0] * self.line_size
-        self.trend_streak = [0] * self.line_size
+        self.last_alarm_channels = []
-        self.prev_values = [None] * self.line_size
 
-    @staticmethod
+    def update(self, data, packet_timestamps=None):
-    def _dbfs_growth_ratio(current_db, baseline_db):
-        return math.pow(10.0, (current_db - baseline_db) / 10.0) - 1.0
-
-    def update(self, data):
         """
         Обновление буфера.
         Если номер текущего чтения совпадает с количеством прореживающего множителя на текущем обновлении буфера, то
@@ -106,77 +179,80 @@ class DataBuffer:
                 До тех пор, пока множитель на итерации меньше фиксированного, увеличиваем в два раза.
         В противном случае - увеличиваем номер чтения.
         :param data: Массив с метриками сигнала по каналам.
+        :param packet_timestamps: Времена пакетов SDR для каждой метрики канала.
         :return: None
         """
+        if packet_timestamps is None:
+            packet_timestamps = [None] * self.line_size
+        if len(packet_timestamps) != self.line_size:
+            raise ValueError('packet_timestamps length must match number of channels')
+
+        sample_idx = self.current_counter - 1
+        for i in range(self.line_size):
+            self.episode_history[i][sample_idx] = float(data[i])
+            self.episode_history_timestamps[i][sample_idx] = packet_timestamps[i]
 
         if self.current_counter == self.thinning_counter:
+            updated_column = self.current_column
             for i in range(self.line_size):
-                self.buffer[i][self.current_column] = data[i]
+                samples = self.episode_history[i][:self.thinning_counter]
+                timestamps = self.episode_history_timestamps[i][:self.thinning_counter]
+                self.buffer[i][self.current_column] = float(sum(samples) / len(samples))
+                self.buffer_timestamps[i][self.current_column] = self._mean_timestamp(timestamps)
             self.current_column = (self.current_column + 1) % self.columns_size
             self.medians()
+            if self.check_init():
+                self.log_threshold_update(updated_column)
+            for i in range(self.line_size):
+                for j in range(self.thinning_counter):
+                    self.episode_history[i][j] = 0.0
+                    self.episode_history_timestamps[i][j] = None
             self.current_counter = 1
             if self.current_column == 0:
                 if self.thinning_counter == 1:
                     self.is_init = True
                     self.medians()
                     print('Начальная калибровка завершена.')
+                    self.log_threshold_update(updated_column)
                 if self.thinning_counter < self.num_of_thinning_iter:
                     self.thinning_counter *= 2
         else:
             self.current_counter += 1
 
+
     def check_alarm(self, data):
         """
         Проверка триггера системы по dBFS во времени.
-        Триггер: устойчивый рост относительно фоновой медианы не меньше dbfs_delta_percent,
+        Один порог на канал, набор тревоги и сброс счетчиков как в main.
-        подтвержденный несколькими последовательными чтениями.
         """
         if self.check_init():
+            self.last_alarm_channels = []
             for i in range(len(data)):
-                baseline = self.buffer_medians[i]
                 current = data[i]
-
+                threshold = self.get_threshold(i)
-                growth_ratio = self._dbfs_growth_ratio(current, baseline)
+                exceeding = current >= threshold
-
-                prev = self.prev_values[i]
-                delta_db = 0.0 if prev is None else current - prev
-                monotonic_or_stable = (prev is None) or (delta_db >= -self.dbfs_max_backstep_db)
-
-                if monotonic_or_stable:
-                    self.trend_streak[i] += 1
-                else:
-                    self.trend_streak[i] = 0
-
-                exceeding = (
-                    growth_ratio >= self.dbfs_delta_ratio
-                    and self.trend_streak[i] >= self.dbfs_min_trend_steps
-                )
 
                 if exceeding:
                     self.buffer_alarms[i] += 1
                 else:
                     self.buffer_alarms[i] = 0
 
-                self.prev_values[i] = current
-
                 if self.buffer_alarms[i] >= self.num_for_alarm:
+                    self.last_alarm_channels = [i]
                     self.buffer_alarms = [0] * self.line_size
-                    self.trend_streak = [0] * self.line_size
                     return True
 
         return False
 
     def check_single_alarm(self, median, cur_channel):
         """
-        Проверка, является ли текущая метрика по каналу превышающей порог роста.
+        Проверка, является ли текущая метрика по каналу превышающей порог.
         :param median: текущая метрика в dBFS.
         :param cur_channel: индекс канала внутри частоты.
         :return: Да/нет.
         """
         if self.check_init():
-            baseline = self.buffer_medians[cur_channel]
+            threshold = self.get_threshold(cur_channel)
-            exceeding = self._dbfs_growth_ratio(median, baseline) >= self.dbfs_delta_ratio
+            return median >= threshold
-            if exceeding:
+
-                return True
+        return False
-            else:
-                return False

src/core/multichannelswitcher.py

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

src/core/sig_n_medi_collect.py

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

src/embedded_3300.py

@@ -1,8 +1,10 @@
 import os
 import datetime
+import time
 from common.runtime import load_root_env, validate_env, as_bool, as_str
 from smb.SMBConnection import SMBConnection
-from utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
+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.multichannelswitcher import MultiChannel, get_centre_freq
 
@@ -46,6 +48,11 @@ 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(',')
@@ -69,11 +76,12 @@ def work(lvl):
     freq = get_centre_freq(f)
     signal_length = get_signal_length(freq)
     median = tmp_signal.fill_signal(lvl, signal_length)
+    packet_ts = tmp_signal.get_last_packet_ts()
 
     if median:
         try:
             num_chs, circle_buffer = multi_channel.check_f(f)
-            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
+            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))
@@ -83,8 +91,40 @@ def work(lvl):
                 if alarm:
                     print('----ALARM---- ', freq)
                     multi_channel.db_alarms_zeros(circle_buffer)
-                else:
+                elif not is_jammer_active():
-                    circle_buffer.update(sigs_array)
+                    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)

src/embedded_433.py

@@ -1,11 +1,13 @@
-import os
+import os
-import datetime
+import datetime
-from common.runtime import load_root_env, validate_env, as_bool, as_str
+import time
+from common.runtime import load_root_env, validate_env, as_bool, as_str
 from smb.SMBConnection import SMBConnection
-from utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
+from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
-from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
+from utils.jammer_state_flag import is_jammer_active
-from core.multichannelswitcher import MultiChannel, get_centre_freq
+from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
-
+from core.multichannelswitcher import MultiChannel, get_centre_freq
+
 load_root_env(__file__)
 freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
 validate_env(__file__, {
@@ -23,98 +25,136 @@ validate_env(__file__, {
     f"f_bases_{freq_suffix}": as_str,
     f"f_roofs_{freq_suffix}": as_str,
 })
-
+
-debug_flag = as_bool(os.getenv('debug_flag', '0'))
+debug_flag = as_bool(os.getenv('debug_flag', '0'))
-send_to_module_flag = as_bool(os.getenv('send_to_module_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'))
+save_data_flag = as_bool(os.getenv('save_data_flag', '0'))
-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_433').split())]
+f_step = [*map(float, os.getenv('f_step_433').split())]
-f_bases = [*map(float, os.getenv('f_bases_433').split())]
+f_bases = [*map(float, os.getenv('f_bases_433').split())]
-f_roofs = [*map(float, os.getenv('f_roofs_433').split())]
+f_roofs = [*map(float, os.getenv('f_roofs_433').split())]
-path_to_save_medians = os.getenv('path_to_save_medians')
+path_to_save_medians = os.getenv('path_to_save_medians')
-path_to_save_alarms = os.getenv('path_to_save_alarms')
+path_to_save_alarms = os.getenv('path_to_save_alarms')
-smb_host = os.getenv('smb_host')
+smb_host = os.getenv('smb_host')
-smb_port = os.getenv('smb_port')
+smb_port = os.getenv('smb_port')
-smb_user = os.getenv('smb_user')
+smb_user = os.getenv('smb_user')
-smb_pass = os.getenv('smb_pass')
+smb_pass = os.getenv('smb_pass')
-shared_folder = os.getenv('shared_folder')
+shared_folder = os.getenv('shared_folder')
-the_pc_name = os.getenv('the_pc_name')
+the_pc_name = os.getenv('the_pc_name')
-remote_pc_name = os.getenv('remote_pc_name')
+remote_pc_name = os.getenv('remote_pc_name')
-smb_domain = os.getenv('smb_domain')
+smb_domain = os.getenv('smb_domain')
-freq_endpoint = os.getenv('freq_endpoint')
+freq_endpoint = os.getenv('freq_endpoint')
-
+telemetry_enabled = as_bool(os.getenv('telemetry_enabled', '1'))
-elems_to_save = elems_to_save.split(',')
+telemetry_host = os.getenv('telemetry_host', '127.0.0.1')
-file_types_to_save = file_types_to_save.split(',')
+telemetry_port = os.getenv('telemetry_port', '5020')
-
+telemetry_endpoint = os.getenv('telemetry_endpoint', 'telemetry')
-tmp_signal = Signal()
+telemetry_timeout_sec = float(os.getenv('telemetry_timeout_sec', '0.30'))
-tmp_sigs_array = SignalsArray()
+
-multi_channel = MultiChannel(f_step, f_bases, f_roofs)
+elems_to_save = elems_to_save.split(',')
-f = multi_channel.init_f()
+file_types_to_save = file_types_to_save.split(',')
-multi_channel.fill_DB()
+
-
+tmp_signal = Signal()
-if debug_flag:
+tmp_sigs_array = SignalsArray()
-    conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
+multi_channel = MultiChannel(f_step, f_bases, f_roofs)
-    conn.connect(smb_host, 139)
+f = multi_channel.init_f()
-    filelist = conn.listPath(shared_folder, '/')
+multi_channel.fill_DB()
-    print(filelist)
+
-
+if debug_flag:
-
+    conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
-def work(lvl):
+    conn.connect(smb_host, 139)
-
+    filelist = conn.listPath(shared_folder, '/')
-    f = multi_channel.get_cur_channel()
+    print(filelist)
-    freq = get_centre_freq(f)
+
-    signal_length = get_signal_length(freq)
+
-    median = tmp_signal.fill_signal(lvl, signal_length)
+def work(lvl):
-
+
-    if median:
+    f = multi_channel.get_cur_channel()
-        try:
+    freq = get_centre_freq(f)
-            num_chs, circle_buffer = multi_channel.check_f(f)
+    signal_length = get_signal_length(freq)
-            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
+    median = tmp_signal.fill_signal(lvl, signal_length)
-
+    packet_ts = tmp_signal.get_last_packet_ts()
-            if sigs_array:
+
-                print('Значения на {0}: {1}'.format(freq, sigs_array))
+    if median:
-                print('Пороги: ', circle_buffer.get_medians())
+        try:
-                alarm = circle_buffer.check_alarm(sigs_array)
+            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 alarm:
+
-                    print('----ALARM---- ', freq)
+            if sigs_array:
-                    multi_channel.db_alarms_zeros(circle_buffer)
+                print('Значения на {0}: {1}'.format(freq, sigs_array))
-                else:
+                print('Пороги: ', circle_buffer.get_medians())
-                    circle_buffer.update(sigs_array)
+                alarm = circle_buffer.check_alarm(sigs_array)
-
+
-                if send_to_module_flag:
+                if alarm:
-                    send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
+                    print('----ALARM---- ', freq)
-
+                    multi_channel.db_alarms_zeros(circle_buffer)
-                if save_data_flag:
+                elif not is_jammer_active():
-                    if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
+                    circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
-                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
+
-                                  list(range(num_chs)))
+
-                    if circle_buffer.check_init():
+                if telemetry_enabled:
-                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
+                    try:
-                                  circle_buffer.get_medians())
+                        max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
-
+                        dbfs_current = float(sigs_array[max_idx])
-            if debug_flag:
+
-                single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
+                        dbfs_threshold = circle_buffer.get_threshold(max_idx)
-                print(cur_channel, single_alarm)
+                        channel_thresholds = circle_buffer.get_thresholds()
-                if single_alarm:
+                        alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
-                    data = pack_elems(elems_to_save, file_types_to_save, tmp_signal.get_signal())
+
-                    print('SAVE CURRENT SIGNAL SROCHNO TI MENYA SLISHISH?!?!?!?')
+                        send_telemetry(
-                    try:
+                            data={
-                        remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
+                                "freq": str(freq),
-                    except Exception as e:
+                                "ts": time.time(),
-                        print(f"Ошибка: {e}")
+                                "dbfs_current": dbfs_current,
-                else:
+                                "dbfs_threshold": dbfs_threshold,
-                    print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
+                                "alarm": bool(alarm),
-
+                                "channel_idx": int(max_idx),
-            f = multi_channel.change_channel()
+                                "channels_total": int(len(sigs_array)),
-        except Exception as e:
+                                "channel_values": [float(v) for v in sigs_array],
-            print(str(e))
+                                "channel_thresholds": channel_thresholds,
-            print(".", end='')
+                                "alarm_channels": alarm_channels,
-
+                            },
-        tmp_signal.clear()
+                            host=telemetry_host,
-
+                            port=telemetry_port,
-    return f
+                            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_4500.py

@@ -1,8 +1,10 @@
 import os
 import datetime
+import time
 from common.runtime import load_root_env, validate_env, as_bool, as_str
 from smb.SMBConnection import SMBConnection
-from utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
+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.multichannelswitcher import MultiChannel, get_centre_freq
 
@@ -46,6 +48,11 @@ 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(',')
@@ -69,11 +76,12 @@ def work(lvl):
     freq = get_centre_freq(f)
     signal_length = get_signal_length(freq)
     median = tmp_signal.fill_signal(lvl, signal_length)
+    packet_ts = tmp_signal.get_last_packet_ts()
 
     if median:
         try:
             num_chs, circle_buffer = multi_channel.check_f(f)
-            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
+            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))
@@ -83,8 +91,40 @@ def work(lvl):
                 if alarm:
                     print('----ALARM---- ', freq)
                     multi_channel.db_alarms_zeros(circle_buffer)
-                else:
+                elif not is_jammer_active():
-                    circle_buffer.update(sigs_array)
+                    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)

src/embedded_5200.py

@@ -1,11 +1,13 @@
-import os
+import os
-import datetime
+import datetime
-from common.runtime import load_root_env, validate_env, as_bool, as_str
+import time
+from common.runtime import load_root_env, validate_env, as_bool, as_str
 from smb.SMBConnection import SMBConnection
-from utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
+from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
-from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
+from utils.jammer_state_flag import is_jammer_active
-from core.multichannelswitcher import MultiChannel, get_centre_freq
+from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
-
+from core.multichannelswitcher import MultiChannel, get_centre_freq
+
 load_root_env(__file__)
 freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
 validate_env(__file__, {
@@ -23,98 +25,136 @@ validate_env(__file__, {
     f"f_bases_{freq_suffix}": as_str,
     f"f_roofs_{freq_suffix}": as_str,
 })
-
+
-debug_flag = as_bool(os.getenv('debug_flag', '0'))
+debug_flag = as_bool(os.getenv('debug_flag', '0'))
-send_to_module_flag = as_bool(os.getenv('send_to_module_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'))
+save_data_flag = as_bool(os.getenv('save_data_flag', '0'))
-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_5200').split())]
+f_step = [*map(float, os.getenv('f_step_5200').split())]
-f_bases = [*map(float, os.getenv('f_bases_5200').split())]
+f_bases = [*map(float, os.getenv('f_bases_5200').split())]
-f_roofs = [*map(float, os.getenv('f_roofs_5200').split())]
+f_roofs = [*map(float, os.getenv('f_roofs_5200').split())]
-path_to_save_medians = os.getenv('path_to_save_medians')
+path_to_save_medians = os.getenv('path_to_save_medians')
-path_to_save_alarms = os.getenv('path_to_save_alarms')
+path_to_save_alarms = os.getenv('path_to_save_alarms')
-smb_host = os.getenv('smb_host')
+smb_host = os.getenv('smb_host')
-smb_port = os.getenv('smb_port')
+smb_port = os.getenv('smb_port')
-smb_user = os.getenv('smb_user')
+smb_user = os.getenv('smb_user')
-smb_pass = os.getenv('smb_pass')
+smb_pass = os.getenv('smb_pass')
-shared_folder = os.getenv('shared_folder')
+shared_folder = os.getenv('shared_folder')
-the_pc_name = os.getenv('the_pc_name')
+the_pc_name = os.getenv('the_pc_name')
-remote_pc_name = os.getenv('remote_pc_name')
+remote_pc_name = os.getenv('remote_pc_name')
-smb_domain = os.getenv('smb_domain')
+smb_domain = os.getenv('smb_domain')
-freq_endpoint = os.getenv('freq_endpoint')
+freq_endpoint = os.getenv('freq_endpoint')
-
+telemetry_enabled = as_bool(os.getenv('telemetry_enabled', '1'))
-elems_to_save = elems_to_save.split(',')
+telemetry_host = os.getenv('telemetry_host', '127.0.0.1')
-file_types_to_save = file_types_to_save.split(',')
+telemetry_port = os.getenv('telemetry_port', '5020')
-
+telemetry_endpoint = os.getenv('telemetry_endpoint', 'telemetry')
-tmp_signal = Signal()
+telemetry_timeout_sec = float(os.getenv('telemetry_timeout_sec', '0.30'))
-tmp_sigs_array = SignalsArray()
+
-multi_channel = MultiChannel(f_step, f_bases, f_roofs)
+elems_to_save = elems_to_save.split(',')
-f = multi_channel.init_f()
+file_types_to_save = file_types_to_save.split(',')
-multi_channel.fill_DB()
+
-
+tmp_signal = Signal()
-if debug_flag:
+tmp_sigs_array = SignalsArray()
-    conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
+multi_channel = MultiChannel(f_step, f_bases, f_roofs)
-    conn.connect(smb_host, 139)
+f = multi_channel.init_f()
-    filelist = conn.listPath(shared_folder, '/')
+multi_channel.fill_DB()
-    print(filelist)
+
-
+if debug_flag:
-
+    conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
-def work(lvl):
+    conn.connect(smb_host, 139)
-
+    filelist = conn.listPath(shared_folder, '/')
-    f = multi_channel.get_cur_channel()
+    print(filelist)
-    freq = get_centre_freq(f)
+
-    signal_length = get_signal_length(freq)
+
-    median = tmp_signal.fill_signal(lvl, signal_length)
+def work(lvl):
-
+
-    if median:
+    f = multi_channel.get_cur_channel()
-        try:
+    freq = get_centre_freq(f)
-            num_chs, circle_buffer = multi_channel.check_f(f)
+    signal_length = get_signal_length(freq)
-            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
+    median = tmp_signal.fill_signal(lvl, signal_length)
-
+    packet_ts = tmp_signal.get_last_packet_ts()
-            if sigs_array:
+
-                print('Значения на {0}: {1}'.format(freq, sigs_array))
+    if median:
-                print('Пороги: ', circle_buffer.get_medians())
+        try:
-                alarm = circle_buffer.check_alarm(sigs_array)
+            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 alarm:
+
-                    print('----ALARM---- ', freq)
+            if sigs_array:
-                    multi_channel.db_alarms_zeros(circle_buffer)
+                print('Значения на {0}: {1}'.format(freq, sigs_array))
-                else:
+                print('Пороги: ', circle_buffer.get_medians())
-                    circle_buffer.update(sigs_array)
+                alarm = circle_buffer.check_alarm(sigs_array)
-
+
-                if send_to_module_flag:
+                if alarm:
-                    send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
+                    print('----ALARM---- ', freq)
-
+                    multi_channel.db_alarms_zeros(circle_buffer)
-                if save_data_flag:
+                elif not is_jammer_active():
-                    if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
+                    circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
-                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
+
-                                  list(range(num_chs)))
+
-                    if circle_buffer.check_init():
+                if telemetry_enabled:
-                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
+                    try:
-                                  circle_buffer.get_medians())
+                        max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
-
+                        dbfs_current = float(sigs_array[max_idx])
-            if debug_flag:
+
-                single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
+                        dbfs_threshold = circle_buffer.get_threshold(max_idx)
-                print(cur_channel, single_alarm)
+                        channel_thresholds = circle_buffer.get_thresholds()
-                if single_alarm:
+                        alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
-                    data = pack_elems(elems_to_save, file_types_to_save, tmp_signal.get_signal())
+
-                    print('SAVE CURRENT SIGNAL SROCHNO TI MENYA SLISHISH?!?!?!?')
+                        send_telemetry(
-                    try:
+                            data={
-                        remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
+                                "freq": str(freq),
-                    except Exception as e:
+                                "ts": time.time(),
-                        print(f"Ошибка: {e}")
+                                "dbfs_current": dbfs_current,
-                else:
+                                "dbfs_threshold": dbfs_threshold,
-                    print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
+                                "alarm": bool(alarm),
-
+                                "channel_idx": int(max_idx),
-            f = multi_channel.change_channel()
+                                "channels_total": int(len(sigs_array)),
-        except Exception as e:
+                                "channel_values": [float(v) for v in sigs_array],
-            print(str(e))
+                                "channel_thresholds": channel_thresholds,
-            print(".", end='')
+                                "alarm_channels": alarm_channels,
-
+                            },
-        tmp_signal.clear()
+                            host=telemetry_host,
-
+                            port=telemetry_port,
-    return f
+                            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_5800.py

@@ -1,11 +1,13 @@
-import os
+import os
-import datetime
+import datetime
-from common.runtime import load_root_env, validate_env, as_bool, as_str
+import time
+from common.runtime import load_root_env, validate_env, as_bool, as_str
 from smb.SMBConnection import SMBConnection
-from utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
+from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
-from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
+from utils.jammer_state_flag import is_jammer_active
-from core.multichannelswitcher import MultiChannel, get_centre_freq
+from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
-
+from core.multichannelswitcher import MultiChannel, get_centre_freq
+
 load_root_env(__file__)
 freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
 validate_env(__file__, {
@@ -23,98 +25,136 @@ validate_env(__file__, {
     f"f_bases_{freq_suffix}": as_str,
     f"f_roofs_{freq_suffix}": as_str,
 })
-
+
-debug_flag = as_bool(os.getenv('debug_flag', '0'))
+debug_flag = as_bool(os.getenv('debug_flag', '0'))
-send_to_module_flag = as_bool(os.getenv('send_to_module_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'))
+save_data_flag = as_bool(os.getenv('save_data_flag', '0'))
-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_5800').split())]
+f_step = [*map(float, os.getenv('f_step_5800').split())]
-f_bases = [*map(float, os.getenv('f_bases_5800').split())]
+f_bases = [*map(float, os.getenv('f_bases_5800').split())]
-f_roofs = [*map(float, os.getenv('f_roofs_5800').split())]
+f_roofs = [*map(float, os.getenv('f_roofs_5800').split())]
-path_to_save_medians = os.getenv('path_to_save_medians')
+path_to_save_medians = os.getenv('path_to_save_medians')
-path_to_save_alarms = os.getenv('path_to_save_alarms')
+path_to_save_alarms = os.getenv('path_to_save_alarms')
-smb_host = os.getenv('smb_host')
+smb_host = os.getenv('smb_host')
-smb_port = os.getenv('smb_port')
+smb_port = os.getenv('smb_port')
-smb_user = os.getenv('smb_user')
+smb_user = os.getenv('smb_user')
-smb_pass = os.getenv('smb_pass')
+smb_pass = os.getenv('smb_pass')
-shared_folder = os.getenv('shared_folder')
+shared_folder = os.getenv('shared_folder')
-the_pc_name = os.getenv('the_pc_name')
+the_pc_name = os.getenv('the_pc_name')
-remote_pc_name = os.getenv('remote_pc_name')
+remote_pc_name = os.getenv('remote_pc_name')
-smb_domain = os.getenv('smb_domain')
+smb_domain = os.getenv('smb_domain')
-freq_endpoint = os.getenv('freq_endpoint')
+freq_endpoint = os.getenv('freq_endpoint')
-
+telemetry_enabled = as_bool(os.getenv('telemetry_enabled', '1'))
-elems_to_save = elems_to_save.split(',')
+telemetry_host = os.getenv('telemetry_host', '127.0.0.1')
-file_types_to_save = file_types_to_save.split(',')
+telemetry_port = os.getenv('telemetry_port', '5020')
-
+telemetry_endpoint = os.getenv('telemetry_endpoint', 'telemetry')
-tmp_signal = Signal()
+telemetry_timeout_sec = float(os.getenv('telemetry_timeout_sec', '0.30'))
-tmp_sigs_array = SignalsArray()
+
-multi_channel = MultiChannel(f_step, f_bases, f_roofs)
+elems_to_save = elems_to_save.split(',')
-f = multi_channel.init_f()
+file_types_to_save = file_types_to_save.split(',')
-multi_channel.fill_DB()
+
-
+tmp_signal = Signal()
-if debug_flag:
+tmp_sigs_array = SignalsArray()
-    conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
+multi_channel = MultiChannel(f_step, f_bases, f_roofs)
-    conn.connect(smb_host, 139)
+f = multi_channel.init_f()
-    filelist = conn.listPath(shared_folder, '/')
+multi_channel.fill_DB()
-    print(filelist)
+
-
+if debug_flag:
-
+    conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
-def work(lvl):
+    conn.connect(smb_host, 139)
-
+    filelist = conn.listPath(shared_folder, '/')
-    f = multi_channel.get_cur_channel()
+    print(filelist)
-    freq = get_centre_freq(f)
+
-    signal_length = get_signal_length(freq)
+
-    median = tmp_signal.fill_signal(lvl, signal_length)
+def work(lvl):
-
+
-    if median:
+    f = multi_channel.get_cur_channel()
-        try:
+    freq = get_centre_freq(f)
-            num_chs, circle_buffer = multi_channel.check_f(f)
+    signal_length = get_signal_length(freq)
-            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
+    median = tmp_signal.fill_signal(lvl, signal_length)
-
+    packet_ts = tmp_signal.get_last_packet_ts()
-            if sigs_array:
+
-                print('Значения на {0}: {1}'.format(freq, sigs_array))
+    if median:
-                print('Пороги: ', circle_buffer.get_medians())
+        try:
-                alarm = circle_buffer.check_alarm(sigs_array)
+            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 alarm:
+
-                    print('----ALARM---- ', freq)
+            if sigs_array:
-                    multi_channel.db_alarms_zeros(circle_buffer)
+                print('Значения на {0}: {1}'.format(freq, sigs_array))
-                else:
+                print('Пороги: ', circle_buffer.get_medians())
-                    circle_buffer.update(sigs_array)
+                alarm = circle_buffer.check_alarm(sigs_array)
-
+
-                if send_to_module_flag:
+                if alarm:
-                    send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
+                    print('----ALARM---- ', freq)
-
+                    multi_channel.db_alarms_zeros(circle_buffer)
-                if save_data_flag:
+                elif not is_jammer_active():
-                    if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
+                    circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
-                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
+
-                                  list(range(num_chs)))
+
-                    if circle_buffer.check_init():
+                if telemetry_enabled:
-                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
+                    try:
-                                  circle_buffer.get_medians())
+                        max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
-
+                        dbfs_current = float(sigs_array[max_idx])
-            if debug_flag:
+
-                single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
+                        dbfs_threshold = circle_buffer.get_threshold(max_idx)
-                print(cur_channel, single_alarm)
+                        channel_thresholds = circle_buffer.get_thresholds()
-                if single_alarm:
+                        alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
-                    data = pack_elems(elems_to_save, file_types_to_save, tmp_signal.get_signal())
+
-                    print('SAVE CURRENT SIGNAL SROCHNO TI MENYA SLISHISH?!?!?!?')
+                        send_telemetry(
-                    try:
+                            data={
-                        remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
+                                "freq": str(freq),
-                    except Exception as e:
+                                "ts": time.time(),
-                        print(f"Ошибка: {e}")
+                                "dbfs_current": dbfs_current,
-                else:
+                                "dbfs_threshold": dbfs_threshold,
-                    print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
+                                "alarm": bool(alarm),
-
+                                "channel_idx": int(max_idx),
-            f = multi_channel.change_channel()
+                                "channels_total": int(len(sigs_array)),
-        except Exception as e:
+                                "channel_values": [float(v) for v in sigs_array],
-            print(str(e))
+                                "channel_thresholds": channel_thresholds,
-            print(".", end='')
+                                "alarm_channels": alarm_channels,
-
+                            },
-        tmp_signal.clear()
+                            host=telemetry_host,
-
+                            port=telemetry_port,
-    return f
+                            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_750.py

@@ -1,11 +1,13 @@
-import os
+import os
-import datetime
+import datetime
-from common.runtime import load_root_env, validate_env, as_bool, as_str
+import time
+from common.runtime import load_root_env, validate_env, as_bool, as_str
 from smb.SMBConnection import SMBConnection
-from utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
+from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
-from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
+from utils.jammer_state_flag import is_jammer_active
-from core.multichannelswitcher import MultiChannel, get_centre_freq
+from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
-
+from core.multichannelswitcher import MultiChannel, get_centre_freq
+
 load_root_env(__file__)
 freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
 validate_env(__file__, {
@@ -23,101 +25,139 @@ validate_env(__file__, {
     f"f_bases_{freq_suffix}": as_str,
     f"f_roofs_{freq_suffix}": as_str,
 })
-
+
-debug_flag = as_bool(os.getenv('debug_flag', '0'))
+debug_flag = as_bool(os.getenv('debug_flag', '0'))
-send_to_module_flag = as_bool(os.getenv('send_to_module_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'))
+save_data_flag = as_bool(os.getenv('save_data_flag', '0'))
-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_750').split())]
+f_step = [*map(float, os.getenv('f_step_750').split())]
-f_bases = [*map(float, os.getenv('f_bases_750').split())]
+f_bases = [*map(float, os.getenv('f_bases_750').split())]
-f_roofs = [*map(float, os.getenv('f_roofs_750').split())]
+f_roofs = [*map(float, os.getenv('f_roofs_750').split())]
-path_to_save_medians = os.getenv('path_to_save_medians')
+path_to_save_medians = os.getenv('path_to_save_medians')
-path_to_save_alarms = os.getenv('path_to_save_alarms')
+path_to_save_alarms = os.getenv('path_to_save_alarms')
-smb_host = os.getenv('smb_host')
+smb_host = os.getenv('smb_host')
-smb_port = os.getenv('smb_port')
+smb_port = os.getenv('smb_port')
-smb_user = os.getenv('smb_user')
+smb_user = os.getenv('smb_user')
-smb_pass = os.getenv('smb_pass')
+smb_pass = os.getenv('smb_pass')
-shared_folder = os.getenv('shared_folder')
+shared_folder = os.getenv('shared_folder')
-the_pc_name = os.getenv('the_pc_name')
+the_pc_name = os.getenv('the_pc_name')
-remote_pc_name = os.getenv('remote_pc_name')
+remote_pc_name = os.getenv('remote_pc_name')
-smb_domain = os.getenv('smb_domain')
+smb_domain = os.getenv('smb_domain')
-freq_endpoint = os.getenv('freq_endpoint')
+freq_endpoint = os.getenv('freq_endpoint')
-
+telemetry_enabled = as_bool(os.getenv('telemetry_enabled', '1'))
-elems_to_save = elems_to_save.split(',')
+telemetry_host = os.getenv('telemetry_host', '127.0.0.1')
-file_types_to_save = file_types_to_save.split(',')
+telemetry_port = os.getenv('telemetry_port', '5020')
-
+telemetry_endpoint = os.getenv('telemetry_endpoint', 'telemetry')
-tmp_signal = Signal()
+telemetry_timeout_sec = float(os.getenv('telemetry_timeout_sec', '0.30'))
-tmp_sigs_array = SignalsArray()
+
-multi_channel = MultiChannel(f_step, f_bases, f_roofs)
+elems_to_save = elems_to_save.split(',')
-f = multi_channel.init_f()
+file_types_to_save = file_types_to_save.split(',')
-multi_channel.fill_DB()
+
-
+tmp_signal = Signal()
-if debug_flag:
+tmp_sigs_array = SignalsArray()
-    conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
+multi_channel = MultiChannel(f_step, f_bases, f_roofs)
-    conn.connect(smb_host, 139)
+f = multi_channel.init_f()
-    filelist = conn.listPath(shared_folder, '/')
+multi_channel.fill_DB()
-    print(filelist)
+
-
+if debug_flag:
-
+    conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
-def work(lvl):
+    conn.connect(smb_host, 139)
-
+    filelist = conn.listPath(shared_folder, '/')
-    f = multi_channel.get_cur_channel()
+    print(filelist)
-    freq = get_centre_freq(f)
+
-    signal_length = get_signal_length(freq)
+
-    median = tmp_signal.fill_signal(lvl, signal_length)
+def work(lvl):
-
+
-    if median:
+    f = multi_channel.get_cur_channel()
-        print(1)
+    freq = get_centre_freq(f)
-        try:
+    signal_length = get_signal_length(freq)
-            num_chs, circle_buffer = multi_channel.check_f(f)
+    median = tmp_signal.fill_signal(lvl, signal_length)
-            print(num_chs, circle_buffer)
+    packet_ts = tmp_signal.get_last_packet_ts()
-            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
+
-            print(3)
+    if median:
-
+        print(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())
+            print(num_chs, circle_buffer)
-                alarm = circle_buffer.check_alarm(sigs_array)
+            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 alarm:
+
-                    print('----ALARM---- ', freq)
+            if sigs_array:
-                    multi_channel.db_alarms_zeros(circle_buffer)
+                print('Значения на {0}: {1}'.format(freq, sigs_array))
-                else:
+                print('Пороги: ', circle_buffer.get_medians())
-                    circle_buffer.update(sigs_array)
+                alarm = circle_buffer.check_alarm(sigs_array)
-
+
-                if send_to_module_flag:
+                if alarm:
-                    send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
+                    print('----ALARM---- ', freq)
-
+                    multi_channel.db_alarms_zeros(circle_buffer)
-                if save_data_flag:
+                elif not is_jammer_active():
-                    if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
+                    circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
-                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
+
-                                  list(range(num_chs)))
+
-                    if circle_buffer.check_init():
+                if telemetry_enabled:
-                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
+                    try:
-                                  circle_buffer.get_medians())
+                        max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
-
+                        dbfs_current = float(sigs_array[max_idx])
-            if debug_flag:
+
-                single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
+                        dbfs_threshold = circle_buffer.get_threshold(max_idx)
-                print(cur_channel, single_alarm)
+                        channel_thresholds = circle_buffer.get_thresholds()
-                if single_alarm:
+                        alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
-                    data = pack_elems(elems_to_save, file_types_to_save, tmp_signal.get_signal())
+
-                    print('SAVE CURRENT SIGNAL SROCHNO TI MENYA SLISHISH?!?!?!?')
+                        send_telemetry(
-                    try:
+                            data={
-                        remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
+                                "freq": str(freq),
-                    except Exception as e:
+                                "ts": time.time(),
-                        print(f"Ошибка: {e}")
+                                "dbfs_current": dbfs_current,
-                else:
+                                "dbfs_threshold": dbfs_threshold,
-                    print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
+                                "alarm": bool(alarm),
-
+                                "channel_idx": int(max_idx),
-            f = multi_channel.change_channel()
+                                "channels_total": int(len(sigs_array)),
-        except Exception as e:
+                                "channel_values": [float(v) for v in sigs_array],
-            print(str(e))
+                                "channel_thresholds": channel_thresholds,
-            print(".", end='')
+                                "alarm_channels": alarm_channels,
-
+                            },
-        tmp_signal.clear()
+                            host=telemetry_host,
-
+                            port=telemetry_port,
-    return f
+                            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_868.py

@@ -1,11 +1,13 @@
-import os
+import os
-import datetime
+import datetime
-from common.runtime import load_root_env, validate_env, as_bool, as_str
+import time
+from common.runtime import load_root_env, validate_env, as_bool, as_str
 from smb.SMBConnection import SMBConnection
-from utils.datas_processing import pack_elems, agregator, send_data, save_data, remote_save_data
+from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
-from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
+from utils.jammer_state_flag import is_jammer_active
-from core.multichannelswitcher import MultiChannel, get_centre_freq
+from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
-
+from core.multichannelswitcher import MultiChannel, get_centre_freq
+
 load_root_env(__file__)
 freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
 validate_env(__file__, {
@@ -23,98 +25,136 @@ validate_env(__file__, {
     f"f_bases_{freq_suffix}": as_str,
     f"f_roofs_{freq_suffix}": as_str,
 })
-
+
-debug_flag = as_bool(os.getenv('debug_flag', '0'))
+debug_flag = as_bool(os.getenv('debug_flag', '0'))
-send_to_module_flag = as_bool(os.getenv('send_to_module_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'))
+save_data_flag = as_bool(os.getenv('save_data_flag', '0'))
-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_868').split())]
+f_step = [*map(float, os.getenv('f_step_868').split())]
-f_bases = [*map(float, os.getenv('f_bases_868').split())]
+f_bases = [*map(float, os.getenv('f_bases_868').split())]
-f_roofs = [*map(float, os.getenv('f_roofs_868').split())]
+f_roofs = [*map(float, os.getenv('f_roofs_868').split())]
-path_to_save_medians = os.getenv('path_to_save_medians')
+path_to_save_medians = os.getenv('path_to_save_medians')
-path_to_save_alarms = os.getenv('path_to_save_alarms')
+path_to_save_alarms = os.getenv('path_to_save_alarms')
-smb_host = os.getenv('smb_host')
+smb_host = os.getenv('smb_host')
-smb_port = os.getenv('smb_port')
+smb_port = os.getenv('smb_port')
-smb_user = os.getenv('smb_user')
+smb_user = os.getenv('smb_user')
-smb_pass = os.getenv('smb_pass')
+smb_pass = os.getenv('smb_pass')
-shared_folder = os.getenv('shared_folder')
+shared_folder = os.getenv('shared_folder')
-the_pc_name = os.getenv('the_pc_name')
+the_pc_name = os.getenv('the_pc_name')
-remote_pc_name = os.getenv('remote_pc_name')
+remote_pc_name = os.getenv('remote_pc_name')
-smb_domain = os.getenv('smb_domain')
+smb_domain = os.getenv('smb_domain')
-freq_endpoint = os.getenv('freq_endpoint')
+freq_endpoint = os.getenv('freq_endpoint')
-
+telemetry_enabled = as_bool(os.getenv('telemetry_enabled', '1'))
-elems_to_save = elems_to_save.split(',')
+telemetry_host = os.getenv('telemetry_host', '127.0.0.1')
-file_types_to_save = file_types_to_save.split(',')
+telemetry_port = os.getenv('telemetry_port', '5020')
-
+telemetry_endpoint = os.getenv('telemetry_endpoint', 'telemetry')
-tmp_signal = Signal()
+telemetry_timeout_sec = float(os.getenv('telemetry_timeout_sec', '0.30'))
-tmp_sigs_array = SignalsArray()
+
-multi_channel = MultiChannel(f_step, f_bases, f_roofs)
+elems_to_save = elems_to_save.split(',')
-f = multi_channel.init_f()
+file_types_to_save = file_types_to_save.split(',')
-multi_channel.fill_DB()
+
-
+tmp_signal = Signal()
-if debug_flag:
+tmp_sigs_array = SignalsArray()
-    conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
+multi_channel = MultiChannel(f_step, f_bases, f_roofs)
-    conn.connect(smb_host, 139)
+f = multi_channel.init_f()
-    filelist = conn.listPath(shared_folder, '/')
+multi_channel.fill_DB()
-    print(filelist)
+
-
+if debug_flag:
-
+    conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
-def work(lvl):
+    conn.connect(smb_host, 139)
-
+    filelist = conn.listPath(shared_folder, '/')
-    f = multi_channel.get_cur_channel()
+    print(filelist)
-    freq = get_centre_freq(f)
+
-    signal_length = get_signal_length(freq)
+
-    median = tmp_signal.fill_signal(lvl, signal_length)
+def work(lvl):
-
+
-    if median:
+    f = multi_channel.get_cur_channel()
-        try:
+    freq = get_centre_freq(f)
-            num_chs, circle_buffer = multi_channel.check_f(f)
+    signal_length = get_signal_length(freq)
-            cur_channel, sigs_array = tmp_sigs_array.fill_sig_arr(median, num_chs)
+    median = tmp_signal.fill_signal(lvl, signal_length)
-
+    packet_ts = tmp_signal.get_last_packet_ts()
-            if sigs_array:
+
-                print('Значения на {0}: {1}'.format(freq, sigs_array))
+    if median:
-                print('Пороги: ', circle_buffer.get_medians())
+        try:
-                alarm = circle_buffer.check_alarm(sigs_array)
+            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 alarm:
+
-                    print('----ALARM---- ', freq)
+            if sigs_array:
-                    multi_channel.db_alarms_zeros(circle_buffer)
+                print('Значения на {0}: {1}'.format(freq, sigs_array))
-                else:
+                print('Пороги: ', circle_buffer.get_medians())
-                    circle_buffer.update(sigs_array)
+                alarm = circle_buffer.check_alarm(sigs_array)
-
+
-                if send_to_module_flag:
+                if alarm:
-                    send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
+                    print('----ALARM---- ', freq)
-
+                    multi_channel.db_alarms_zeros(circle_buffer)
-                if save_data_flag:
+                elif not is_jammer_active():
-                    if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
+                    circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
-                        save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
+
-                                  list(range(num_chs)))
+
-                    if circle_buffer.check_init():
+                if telemetry_enabled:
-                        save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
+                    try:
-                                  circle_buffer.get_medians())
+                        max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
-
+                        dbfs_current = float(sigs_array[max_idx])
-            if debug_flag:
+
-                single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
+                        dbfs_threshold = circle_buffer.get_threshold(max_idx)
-                print(cur_channel, single_alarm)
+                        channel_thresholds = circle_buffer.get_thresholds()
-                if single_alarm:
+                        alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
-                    data = pack_elems(elems_to_save, file_types_to_save, tmp_signal.get_signal())
+
-                    print('SAVE CURRENT SIGNAL SROCHNO TI MENYA SLISHISH?!?!?!?')
+                        send_telemetry(
-                    try:
+                            data={
-                        remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
+                                "freq": str(freq),
-                    except Exception as e:
+                                "ts": time.time(),
-                        print(f"Ошибка: {e}")
+                                "dbfs_current": dbfs_current,
-                else:
+                                "dbfs_threshold": dbfs_threshold,
-                    print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
+                                "alarm": bool(alarm),
-
+                                "channel_idx": int(max_idx),
-            f = multi_channel.change_channel()
+                                "channels_total": int(len(sigs_array)),
-        except Exception as e:
+                                "channel_values": [float(v) for v in sigs_array],
-            print(str(e))
+                                "channel_thresholds": channel_thresholds,
-            print(".", end='')
+                                "alarm_channels": alarm_channels,
-
+                            },
-        tmp_signal.clear()
+                            host=telemetry_host,
-
+                            port=telemetry_port,
-    return f
+                            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/server_to_master.py

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

src/utils/datas_processing.py

@@ -1,149 +1,183 @@
-import os
+import os
-import io
+import io
-import csv
+import csv
-import itertools
+import time
-import requests
+import itertools
-import numpy as np
+import requests
-from datetime import datetime
+import numpy as np
-
+from datetime import datetime
-
+
-def pack_elems(names, file_types, *elems):
+
-    if len(names) != len(file_types) or len(names) != len(elems):
+_telemetry_error_last_ts = 0.0
-        raise ValueError('Длин массивов имен и типов файлов и не совпадает с количество элементов для сохранения')
+
-    return {name: {'file_type': file_type, 'elem': elem} for name, file_type, elem in zip(names, file_types, elems)}
+
-
+def pack_elems(names, file_types, *elems):
-
+    if len(names) != len(file_types) or len(names) != len(elems):
-def agregator(freq, alarm):
+        raise ValueError('Длин массивов имен и типов файлов и не совпадает с количество элементов для сохранения')
-    if alarm:
+    return {name: {'file_type': file_type, 'elem': elem} for name, file_type, elem in zip(names, file_types, elems)}
-        amplitude = 9
+
-    else:
+
-        amplitude = 0
+def agregator(freq, alarm):
-
+    if alarm:
-    data = {"freq": freq,
+        amplitude = 9
-            "amplitude": amplitude
+    else:
-            }
+        amplitude = 0
-    return data
+
-
+    data = {"freq": freq,
-
+            "amplitude": amplitude
-def send_data(data, localhost, localport, endpoint):
+            }
-    """
+    return data
-    Отправка данных по POST на модуль сервер.
+
-    :param data: Данные для отправки.
+
-    :param localhost: Хост модуль сервера.
+def send_data(data, localhost, localport, endpoint):
-    :param localport: Порт модуль сервера.
+    """
-    """
+    Отправка данных по POST на модуль сервер.
-
+    :param data: Данные для отправки.
-    def _post(port):
+    :param localhost: Хост модуль сервера.
-        url = "http://{0}:{1}/{2}".format(localhost, port, endpoint)
+    :param localport: Порт модуль сервера.
-        return requests.post(url, json=data), url
+    """
-
+
-    try:
+    def _post(port):
-        response, url = _post(localport)
+        url = "http://{0}:{1}/{2}".format(localhost, port, endpoint)
-        if response.status_code == 200:
+        return requests.post(url, json=data), url
-            print("Данные успешно отправлены и приняты!", url)
+
-            return
+    try:
-
+        response, url = _post(localport)
-        # Частый кейс: порт 5000 занят локальным registry (DroneDetectPCSoft).
+        if response.status_code == 200:
-        # Пробуем порт модуля сервера из env (например, 5010).
+            print("Данные успешно отправлены и приняты!", url)
-        fallback_port = os.getenv('GENERAL_SERVER_PORT')
+            return
-        if response.status_code == 404 and fallback_port and str(localport) != str(fallback_port):
+
-            response_fb, url_fb = _post(fallback_port)
+        # Частый кейс: порт 5000 занят локальным registry (DroneDetectPCSoft).
-            if response_fb.status_code == 200:
+        # Пробуем порт модуля сервера из env (например, 5010).
-                #print("Данные успешно отправлены и приняты!", url_fb)
+        fallback_port = os.getenv('GENERAL_SERVER_PORT')
-                return
+        if response.status_code == 404 and fallback_port and str(localport) != str(fallback_port):
-            print("Ошибка при отправке данных:", response_fb.status_code, url_fb)
+            response_fb, url_fb = _post(fallback_port)
-            return
+            if response_fb.status_code == 200:
-
+                return
-        print("Ошибка при отправке данных:", response.status_code, url)
+            print("Ошибка при отправке данных:", response_fb.status_code, url_fb)
-    except Exception as e:
+            return
-        print(str(e))
+
-
+        print("Ошибка при отправке данных:", response.status_code, url)
-
+    except Exception as e:
-def save_data(path_to_save, freq, *args):
+        print(str(e))
-    """
+
-    Сохранение данных в csv файл. Используется для сохранения метрик и медиан сигнала на каналах с датой и временем
+
-    - для анализа.
+def send_telemetry(data, host, port, endpoint='telemetry', timeout_sec=0.30):
-    :param path_to_save: Путь для сохранения.
+    """
-    :param freq: Обрабатываемая частота.
+    Best-effort отправка телеметрии на отдельный telemetry-server.
-    :param args: Что сохраняем в файл.
+    Ошибки намеренно не пробрасываются, чтобы не влиять на основной детект/аларм поток.
-    """
+    """
-
+    global _telemetry_error_last_ts
-    try:
+
-        if not os.path.exists(path_to_save):
+    host = '' if host is None else str(host).strip()
-            print('Folder was created.')
+    port = '' if port is None else str(port).strip()
-            os.makedirs(path_to_save)
+    endpoint = str(endpoint or 'telemetry').strip().lstrip('/')
-
+
-        with open(path_to_save + 'data_' + str(freq) + '.csv', 'a', newline='') as f:
+    if not host or not port:
-            writer = csv.writer(f)
+        return
-            args2 = itertools.chain(*(arg if isinstance(arg, list) else [arg] for arg in args))
+
-            writer.writerow(args2)
+    try:
-            print('Write csv.')
+        url = f"http://{host}:{port}/{endpoint}"
-
+        response = requests.post(url, json=data, timeout=float(timeout_sec))
-    except Exception as e:
+        if response.status_code == 200:
-        print(str(e))
+            return
-
+
-
+        now = time.time()
-def prepare_folders_paths(path):
+        if now - _telemetry_error_last_ts >= 10.0:
-    folders = path.split('/')
+            print(f"telemetry http error: {response.status_code} {url}")
-    folders.pop()
+            _telemetry_error_last_ts = now
-    folders = [elem + '/' for elem in folders]
+    except Exception as exc:
-    print(folders)
+        now = time.time()
-    cur_path = ''
+        if now - _telemetry_error_last_ts >= 10.0:
-    print(cur_path)
+            print(f"telemetry send failed: {exc}")
-    return folders, cur_path
+            _telemetry_error_last_ts = now
-
+
-
+
-def remote_save_data(conn, data, module_name, freq, share_folder, path_to_save):
+def save_data(path_to_save, freq, *args):
-    """
+    """
-    Сохранение данных (сигнала) в файл на удаленный диск.
+    Сохранение данных в csv файл. Используется для сохранения метрик и медиан сигнала на каналах с датой и временем
-    :param conn:
+    - для анализа.
-    :param data:
+    :param path_to_save: Путь для сохранения.
-    :param module_name:
+    :param freq: Обрабатываемая частота.
-    :param freq:
+    :param args: Что сохраняем в файл.
-    :param share_folder:
+    """
-    :param path_to_save:
+
-    :return:
+    try:
-    """
+        if not os.path.exists(path_to_save):
-    # cur_datetime = datetime.now().strftime('%d_%m_%Y_%H_%M_%S')
+            print('Folder was created.')
-    # file_name = f'alarm_{module_name}_{freq}_{cur_datetime}.npy'
+            os.makedirs(path_to_save)
-    # path = f"{path_to_save_medians}{module_name}/{str(freq)}/"
+
-    # path_to_file = f"{path}{file_name}"
+        with open(path_to_save + 'data_' + str(freq) + '.csv', 'a', newline='') as f:
-    # print(path_to_file)
+            writer = csv.writer(f)
-    #
+            args2 = itertools.chain(*(arg if isinstance(arg, list) else [arg] for arg in args))
-    # folders, cur_path = prepare_folders_paths(path)
+            writer.writerow(args2)
-    #
+            print('Write csv.')
-    # buffer = io.BytesIO()
+
-    # np.save(buffer, data)
+    except Exception as e:
-    # buffer.seek(0)
+        print(str(e))
-    #
+
-    # for i in range(len(folders)):
+
-    #     cur_path = cur_path + folders[i]
+def prepare_folders_paths(path):
-    #     try:
+    folders = path.split('/')
-    #         conn.listPath(share_folder, cur_path)
+    folders.pop()
-    #     except Exception:
+    folders = [elem + '/' for elem in folders]
-    #         conn.createDirectory(share_folder, cur_path)
+    print(folders)
-    #
+    cur_path = ''
-    # conn.storeFile(share_folder, path_to_file, buffer)
+    print(cur_path)
-    for name, values in data.items():
+    return folders, cur_path
-        elem_name = name
+
-        file_type = values['file_type']
+
-        elem_data = values['elem']
+def remote_save_data(conn, data, module_name, freq, share_folder, path_to_save):
-        print(elem_data.shape)
+    """
-        buffer = io.BytesIO()
+    Сохранение данных (сигнала) в файл на удаленный диск.
-        np.save(buffer, elem_data)
+    :param conn:
-        buffer.seek(0)
+    :param data:
-
+    :param module_name:
-        cur_datetime = datetime.now().strftime('%d_%m_%Y_%H_%M_%S')
+    :param freq:
-        file_name = f'alarm_{elem_name}_{module_name}_{freq}_{cur_datetime}.{file_type}'
+    :param share_folder:
-        path = f"{path_to_save}{module_name}/{str(freq)}/{elem_name}/"
+    :param path_to_save:
-        path_to_file = f"{path}{file_name}"
+    :return:
-        folders, cur_path = prepare_folders_paths(path)
+    """
-
+    # cur_datetime = datetime.now().strftime('%d_%m_%Y_%H_%M_%S')
-        for i in range(len(folders)):
+    # file_name = f'alarm_{module_name}_{freq}_{cur_datetime}.npy'
-            cur_path = cur_path + folders[i]
+    # path = f"{path_to_save_medians}{module_name}/{str(freq)}/"
-            try:
+    # path_to_file = f"{path}{file_name}"
-                conn.listPath(share_folder, cur_path)
+    # print(path_to_file)
-            except Exception:
+    #
-                conn.createDirectory(share_folder, cur_path)
+    # folders, cur_path = prepare_folders_paths(path)
-
+    #
-        conn.storeFile(share_folder, path_to_file, buffer)
+    # buffer = io.BytesIO()
+    # np.save(buffer, data)
+    # buffer.seek(0)
+    #
+    # for i in range(len(folders)):
+    #     cur_path = cur_path + folders[i]
+    #     try:
+    #         conn.listPath(share_folder, cur_path)
+    #     except Exception:
+    #         conn.createDirectory(share_folder, cur_path)
+    #
+    # conn.storeFile(share_folder, path_to_file, buffer)
+    for name, values in data.items():
+        elem_name = name
+        file_type = values['file_type']
+        elem_data = values['elem']
+        print(elem_data.shape)
+        buffer = io.BytesIO()
+        np.save(buffer, elem_data)
+        buffer.seek(0)
+
+        cur_datetime = datetime.now().strftime('%d_%m_%Y_%H_%M_%S')
+        file_name = f'alarm_{elem_name}_{module_name}_{freq}_{cur_datetime}.{file_type}'
+        path = f"{path_to_save}{module_name}/{str(freq)}/{elem_name}/"
+        path_to_file = f"{path}{file_name}"
+        folders, cur_path = prepare_folders_paths(path)
+
+        for i in range(len(folders)):
+            cur_path = cur_path + folders[i]
+            try:
+                conn.listPath(share_folder, cur_path)
+            except Exception:
+                conn.createDirectory(share_folder, cur_path)
+
+        conn.storeFile(share_folder, path_to_file, buffer)

src/utils/jammer_state_flag.py

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

telemetry/telemetry_server.py

@@ -36,6 +36,9 @@ class TelemetryPoint(BaseModel):
     alarm: bool = False
     channel_idx: int = 0
     channels_total: int = 1
+    channel_values: Optional[List[float]] = None
+    channel_thresholds: Optional[List[Optional[float]]] = None
+    alarm_channels: Optional[List[int]] = None
 
 
 def _prune_freq_locked(freq: str, now_ts: float) -> None:
@@ -136,15 +139,25 @@ MONITOR_HTML = """
       --text: #1c232e;
       --green: #12b76a;
       --red: #ef4444;
+      --muted: #5b6574;
     }
     body { margin: 0; background: var(--bg); color: var(--text); font-family: system-ui, -apple-system, Segoe UI, sans-serif; }
-    .wrap { max-width: 1400px; margin: 0 auto; padding: 16px; }
+    .wrap { max-width: 1800px; margin: 0 auto; padding: 14px; }
-    .head { display: flex; justify-content: space-between; align-items: center; margin-bottom: 12px; }
+    .head { display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px; }
-    .meta { font-size: 13px; color: #5b6574; }
+    .meta { font-size: 13px; color: var(--muted); }
-    .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(420px, 1fr)); gap: 12px; }
+    .grid { display: flex; flex-direction: column; gap: 10px; }
-    .card { background: var(--card); border: 1px solid var(--line); border-radius: 10px; padding: 8px 8px 2px; }
+    .card { width: 100%; background: var(--card); border: 1px solid var(--line); border-radius: 10px; padding: 8px 8px 8px; }
-    .title { font-size: 14px; font-weight: 600; margin: 6px 8px; }
+    .title-row { display: flex; justify-content: space-between; align-items: center; margin: 4px 8px; }
-    .plot { height: 280px; }
+    .title { font-size: 20px; font-weight: 700; }
+    .ctrl { display: flex; align-items: center; gap: 6px; }
+    .ctrl label { font-size: 12px; color: var(--muted); }
+    .ctrl select { border: 1px solid var(--line); border-radius: 6px; padding: 2px 6px; }
+    .plot { height: 260px; width: 100%; }
+    .events-title { font-size: 12px; color: var(--muted); margin: 2px 8px 4px; }
+    .events { max-height: 110px; overflow-y: auto; border-top: 1px dashed var(--line); margin: 0 8px; padding-top: 4px; }
+    .ev { display: flex; justify-content: space-between; font-size: 12px; line-height: 1.4; color: var(--text); }
+    .ev-t { color: var(--muted); }
+    .ev-empty { color: var(--muted); font-size: 12px; }
   </style>
 </head>
 <body>
@@ -152,7 +165,7 @@ MONITOR_HTML = """
     <div class=\"head\">
       <div>
         <h2 style=\"margin:0;\">DroneDetector Telemetry Monitor</h2>
-        <div class=\"meta\">Green: dBFS current, Red: dynamic alarm threshold</div>
+        <div class=\"meta\">Green: dBFS current, Red: channel threshold, Red dots: alarm points</div>
       </div>
       <div class=\"meta\" id=\"status\">connecting...</div>
     </div>
@@ -162,17 +175,77 @@ MONITOR_HTML = """
 <script>
 const windowSec = 300;
 const state = {}; // freq -> points[]
+const selectedChannel = {}; // freq -> 'max' | channel index as string
 
 function numericSortFreq(a, b) {
   return Number(a) - Number(b);
 }
 
+function formatTime(ts) {
+  return new Date(Number(ts) * 1000).toLocaleTimeString('ru-RU', {hour12: false});
+}
+
+function getChannelCount(freq) {
+  const pts = state[freq] || [];
+  let maxCount = 1;
+  for (const p of pts) {
+    if (Number.isFinite(Number(p.channels_total))) {
+      maxCount = Math.max(maxCount, Number(p.channels_total));
+    }
+    if (Array.isArray(p.channel_values)) {
+      maxCount = Math.max(maxCount, p.channel_values.length);
+    }
+  }
+  return maxCount;
+}
+
 function ensurePlot(freq) {
   if (document.getElementById(`plot-${freq}`)) return;
+
   const card = document.createElement('div');
   card.className = 'card';
-  card.innerHTML = `<div class=\"title\">${freq} MHz</div><div class=\"plot\" id=\"plot-${freq}\"></div>`;
+  card.innerHTML = `
+    <div class=\"title-row\">
+      <div class=\"title\">${freq} MHz</div>
+      <div class=\"ctrl\">
+        <label for=\"chan-${freq}\">channel</label>
+        <select id=\"chan-${freq}\"></select>
+      </div>
+    </div>
+    <div class=\"plot\" id=\"plot-${freq}\"></div>
+    <div class=\"events-title\">Alarms (time -> channel)</div>
+    <div class=\"events\" id=\"events-${freq}\"></div>
+  `;
   document.getElementById('plots').appendChild(card);
+
+  selectedChannel[freq] = 'max';
+  const sel = document.getElementById(`chan-${freq}`);
+  sel.addEventListener('change', () => {
+    selectedChannel[freq] = sel.value;
+    render(freq);
+  });
+}
+
+function updateChannelSelector(freq) {
+  const sel = document.getElementById(`chan-${freq}`);
+  if (!sel) return;
+
+  const prev = selectedChannel[freq] ?? 'max';
+  const count = getChannelCount(freq);
+
+  const opts = ['max'];
+  for (let i = 0; i < count; i += 1) opts.push(String(i));
+
+  sel.innerHTML = '';
+  for (const v of opts) {
+    const option = document.createElement('option');
+    option.value = v;
+    option.textContent = v === 'max' ? 'max' : `ch ${v}`;
+    sel.appendChild(option);
+  }
+
+  selectedChannel[freq] = opts.includes(prev) ? prev : 'max';
+  sel.value = selectedChannel[freq];
 }
 
 function trimPoints(freq) {
@@ -181,47 +254,134 @@ function trimPoints(freq) {
   state[freq] = arr.filter(p => Number(p.ts) >= cutoff);
 }
 
+function getPointValueForSelection(point, selection) {
+  if (selection === 'max') {
+    return {
+      y: point.dbfs_current ?? null,
+      threshold: point.dbfs_threshold ?? null,
+    };
+  }
+
+  const idx = Number(selection);
+  if (!Number.isInteger(idx)) {
+    return {y: null, threshold: null};
+  }
+
+  const y = Array.isArray(point.channel_values) && idx < point.channel_values.length
+    ? point.channel_values[idx]
+    : null;
+  const threshold = Array.isArray(point.channel_thresholds) && idx < point.channel_thresholds.length
+    ? point.channel_thresholds[idx]
+    : null;
+
+  return {y, threshold};
+}
+
+function isAlarmForSelection(point, selection) {
+  if (point.alarm !== true) return false;
+  if (selection === 'max') return true;
+
+  const idx = Number(selection);
+  if (!Number.isInteger(idx)) return false;
+
+  if (Array.isArray(point.alarm_channels) && point.alarm_channels.length > 0) {
+    return point.alarm_channels.includes(idx);
+  }
+
+  return Number(point.channel_idx) === idx;
+}
+
+function renderAlarmEvents(freq, pts) {
+  const el = document.getElementById(`events-${freq}`);
+  if (!el) return;
+
+  const alarmPts = pts.filter(p => p.alarm === true);
+  if (alarmPts.length === 0) {
+    el.innerHTML = '<div class=\"ev-empty\">no alarms</div>';
+    return;
+  }
+
+  const rows = alarmPts.slice(-20).reverse().map((p) => {
+    const channels = Array.isArray(p.alarm_channels) && p.alarm_channels.length > 0
+      ? p.alarm_channels.join(',')
+      : String(p.channel_idx ?? '-');
+    return `<div class=\"ev\"><span class=\"ev-t\">${formatTime(p.ts)}</span><span>ch ${channels}</span></div>`;
+  });
+
+  el.innerHTML = rows.join('');
+}
+
 function render(freq) {
   ensurePlot(freq);
   trimPoints(freq);
+  updateChannelSelector(freq);
+
   const pts = state[freq] || [];
+  const sel = selectedChannel[freq] ?? 'max';
+
+  const x = [];
+  const y = [];
+  const thr = [];
+  const alarmX = [];
+  const alarmY = [];
+
+  for (const p of pts) {
+    const metric = getPointValueForSelection(p, sel);
+    if (metric.y === null || metric.y === undefined) {
+      continue;
+    }
 
-  const x = pts.map(p => new Date(Number(p.ts) * 1000));
+    const ts = new Date(Number(p.ts) * 1000);
-  const y = pts.map(p => p.dbfs_current);
+    x.push(ts);
-  const thr = pts.map(p => p.dbfs_threshold);
+    y.push(metric.y);
-  const alarmPts = pts.filter(p => p.alarm === true);
+    thr.push(metric.threshold);
+
+    if (isAlarmForSelection(p, sel)) {
+      alarmX.push(ts);
+      alarmY.push(metric.y);
+    }
+  }
+
+  const labelSuffix = sel === 'max' ? 'max' : `ch ${sel}`;
 
   const traces = [
     {
       x,
       y,
       mode: 'lines',
-      name: 'dBFS',
+      name: `dBFS (${labelSuffix})`,
-      line: {color: '#12b76a', width: 2}
+      line: {color: '#12b76a', width: 2},
     },
     {
       x,
       y: thr,
       mode: 'lines',
-      name: 'Threshold',
+      name: `Threshold (${labelSuffix})`,
-      line: {color: '#ef4444', width: 2, dash: 'dash'}
+      line: {color: '#ef4444', width: 2, dash: 'dash'},
     },
     {
-      x: alarmPts.map(p => new Date(Number(p.ts) * 1000)),
+      x: alarmX,
-      y: alarmPts.map(p => p.dbfs_current),
+      y: alarmY,
       mode: 'markers',
       name: 'Alarm',
-      marker: {color: '#ef4444', size: 6, symbol: 'circle'}
+      marker: {color: '#ef4444', size: 6, symbol: 'circle'},
-    }
+    },
   ];
 
   Plotly.react(`plot-${freq}`, traces, {
     margin: {l: 40, r: 12, t: 12, b: 32},
     showlegend: true,
     legend: {orientation: 'h', y: 1.16},
-    xaxis: {title: 'time'},
+    xaxis: {
-    yaxis: {title: 'dBFS'}
+      title: 'time',
+      tickformat: '%H:%M:%S',
+      hoverformat: '%H:%M:%S',
+      range: [new Date(Date.now() - windowSec * 1000), new Date()],
+    },
+    yaxis: {title: 'dBFS'},
   }, {displayModeBar: false, responsive: true});
+
+  renderAlarmEvents(freq, pts);
 }
 
 function renderAll() {
@@ -259,7 +419,9 @@ function connectWs() {
       renderAll();
       return;
     }
+
     if (msg.type !== 'point') return;
+
     const p = msg.data;
     const freq = String(p.freq);
     if (!state[freq]) state[freq] = [];
@@ -277,6 +439,10 @@ function connectWs() {
   };
 }
 
+setInterval(() => {
+  renderAll();
+}, 1000);
+
 loadInitial().then(connectWs).catch((e) => {
   document.getElementById('status').textContent = `init error: ${e}`;
   connectWs();