SergeyRevyakin
/
DroneDetector
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Revert "добавил новые сервисы"

Browse Source 
This reverts commit 74bb2d9ce2.
main_2
Sergey Revyakin 3 days ago
parent 3952aa9e69
commit 7546db9fce
29 changed files with 1047 additions and 1444 deletions
Show Stats Download Patch File Download Diff File

5
README.md
Unescape Escape View File

@ -165,15 +165,14 @@ sudo systemctl status dronedetector-sdr-2400.service
```bash ```bash
sudo systemctl stop dronedetector-sdr-433.service sudo systemctl stop dronedetector-sdr-433.service
sudo systemctl stop dronedetector-sdr-750.service sudo systemctl stop dronedetector-sdr-750.service
sudo systemctl stop dronedetector-sdr-868.service
sudo systemctl stop dronedetector-sdr-3300.service sudo systemctl stop dronedetector-sdr-3300.service
sudo systemctl stop dronedetector-sdr-4500.service sudo systemctl stop dronedetector-sdr-4500.service
sudo systemctl stop dronedetector-sdr-5200.service sudo systemctl stop dronedetector-sdr-5200.service
sudo systemctl stop dronedetector-sdr-5800.service sudo systemctl stop dronedetector-sdr-5800.service
sudo systemctl stop dronedetector-sdr-915.service
sudo systemctl stop dronedetector-sdr-1200.service sudo systemctl stop dronedetector-sdr-1200.service
sudo systemctl stop dronedetector-sdr-2400.service sudo systemctl stop dronedetector-sdr-2400.service
sudo systemctl stop dronedetector-sdr-1500.service
sudo systemctl stop dronedetector-sdr-868.service
sudo systemctl stop dronedetector-sdr-868-915.service
``` ```

4
common/runtime.py
Unescape Escape View File

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

3
common/shared_stream_addrs.py
Unescape Escape View File

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

19
deploy/systemd/dronedetector-sdr-1500.service
Unescape Escape View File

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

19
deploy/systemd/dronedetector-sdr-868-915.service
Unescape Escape View File

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

3
deploy/systemd/dronedetector-sdr-868.service
Unescape Escape View File

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

3
deploy/systemd/dronedetector-sdr-915.service
Unescape Escape View File

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

98
orange_scripts/compose_send_data_915.py
Unescape Escape View File

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

174
orange_scripts/main_915.py
Unescape Escape View File

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

145
src/core/multichannelswitcher.py
Unescape Escape View File

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

150
src/embedded_1500.py
Unescape Escape View File

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

74
src/embedded_3300.py
Unescape Escape View File

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

74
src/embedded_433.py
Unescape Escape View File

@ -1,14 +1,30 @@
import os import os
import datetime import datetime
import time import time
from common.runtime import load_root_env, as_bool from common.runtime import load_root_env, validate_env, as_bool, as_str
from smb.SMBConnection import SMBConnection from smb.SMBConnection import SMBConnection
from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
from utils.jammer_state_flag import is_jammer_active from utils.jammer_state_flag import is_jammer_active
from core.sig_n_medi_collect import Signal, SignalsArray from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
from core.multichannelswitcher import MultiChannel from core.multichannelswitcher import MultiChannel, get_centre_freq
load_root_env(__file__) load_root_env(__file__)
freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
validate_env(__file__, {
"send_to_module_flag": as_bool,
"save_data_flag": as_bool,
"elems_to_save": as_str,
"file_types_to_save": as_str,
"lochost": as_str,
"locport": as_str,
"freq_endpoint": as_str,
"path_to_save_medians": as_str,
"path_to_save_alarms": as_str,
"module_name": as_str,
f"f_step_{freq_suffix}": as_str,
f"f_bases_{freq_suffix}": as_str,
f"f_roofs_{freq_suffix}": as_str,
})
debug_flag = as_bool(os.getenv('debug_flag', '0')) 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'))
@ -21,12 +37,6 @@ 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())]
signal_length = int(os.getenv('signal_length_433'))
buffer_columns_size = int(os.getenv('buffer_columns_size_433'))
num_of_thinning_iter = int(os.getenv('num_of_thinning_iter_433'))
multiply_factor = float(os.getenv('multiply_factor_433'))
num_for_alarm = int(os.getenv('num_for_alarm_433'))
c_freq = os.getenv('c_freq_433', '433')
path_to_save_medians = os.getenv('path_to_save_medians') path_to_save_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')
@ -51,13 +61,7 @@ tmp_signal = Signal()
tmp_sigs_array = SignalsArray() tmp_sigs_array = SignalsArray()
multi_channel = MultiChannel(f_step, f_bases, f_roofs) multi_channel = MultiChannel(f_step, f_bases, f_roofs)
f = multi_channel.init_f() f = multi_channel.init_f()
multi_channel.fill_DB( multi_channel.fill_DB()
buffer_columns_size,
num_of_thinning_iter,
multiply_factor,
num_for_alarm,
c_freq,
)
if debug_flag: if debug_flag:
conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True) conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
@ -67,8 +71,10 @@ if debug_flag:
def work(lvl): def work(lvl):
f = multi_channel.get_cur_channel() f = multi_channel.get_cur_channel()
freq = c_freq freq = get_centre_freq(f)
signal_length = get_signal_length(freq)
median = tmp_signal.fill_signal(lvl, signal_length) median = tmp_signal.fill_signal(lvl, signal_length)
packet_ts = tmp_signal.get_last_packet_ts() packet_ts = tmp_signal.get_last_packet_ts()
@ -88,26 +94,28 @@ def work(lvl):
elif not is_jammer_active(): elif not is_jammer_active():
circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array) circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
if telemetry_enabled: if telemetry_enabled:
try: try:
max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx]) max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
dbfs_current = float(sigs_array[max_idx]) dbfs_current = float(sigs_array[max_idx])
dbfs_threshold = circle_buffer.get_threshold(max_idx) dbfs_threshold = circle_buffer.get_threshold(max_idx)
channel_thresholds = circle_buffer.get_thresholds() channel_thresholds = circle_buffer.get_thresholds()
alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else [] alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
send_telemetry( send_telemetry(
data={ data={
'freq': str(freq), "freq": str(freq),
'ts': time.time(), "ts": time.time(),
'dbfs_current': dbfs_current, "dbfs_current": dbfs_current,
'dbfs_threshold': dbfs_threshold, "dbfs_threshold": dbfs_threshold,
'alarm': bool(alarm), "alarm": bool(alarm),
'channel_idx': int(max_idx), "channel_idx": int(max_idx),
'channels_total': int(len(sigs_array)), "channels_total": int(len(sigs_array)),
'channel_values': [float(v) for v in sigs_array], "channel_values": [float(v) for v in sigs_array],
'channel_thresholds': channel_thresholds, "channel_thresholds": channel_thresholds,
'alarm_channels': alarm_channels, "alarm_channels": alarm_channels,
}, },
host=telemetry_host, host=telemetry_host,
port=telemetry_port, port=telemetry_port,
@ -116,16 +124,18 @@ def work(lvl):
) )
except Exception as exc: except Exception as exc:
if debug_flag: if debug_flag:
print(f'telemetry send failed: {exc}') print(f"telemetry send failed: {exc}")
if send_to_module_flag: if send_to_module_flag:
send_data(agregator(freq, alarm), localhost, localport, freq_endpoint) send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
if save_data_flag: if save_data_flag:
if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0: if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), list(range(num_chs))) save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
list(range(num_chs)))
if circle_buffer.check_init(): if circle_buffer.check_init():
save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians()) save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
circle_buffer.get_medians())
if debug_flag: if debug_flag:
single_alarm = circle_buffer.check_single_alarm(median, cur_channel) single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@ -136,14 +146,14 @@ def work(lvl):
try: try:
remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms) remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
except Exception as e: except Exception as e:
print(f'Ошибка: {e}') print(f"Ошибка: {e}")
else: else:
print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!') print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
f = multi_channel.change_channel() f = multi_channel.change_channel()
except Exception as e: except Exception as e:
print(str(e)) print(str(e))
print('.', end='') print(".", end='')
tmp_signal.clear() tmp_signal.clear()

74
src/embedded_4500.py
Unescape Escape View File

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

74
src/embedded_5200.py
Unescape Escape View File

@ -1,14 +1,30 @@
import os import os
import datetime import datetime
import time import time
from common.runtime import load_root_env, as_bool from common.runtime import load_root_env, validate_env, as_bool, as_str
from smb.SMBConnection import SMBConnection from smb.SMBConnection import SMBConnection
from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
from utils.jammer_state_flag import is_jammer_active from utils.jammer_state_flag import is_jammer_active
from core.sig_n_medi_collect import Signal, SignalsArray from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
from core.multichannelswitcher import MultiChannel from core.multichannelswitcher import MultiChannel, get_centre_freq
load_root_env(__file__) load_root_env(__file__)
freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
validate_env(__file__, {
"send_to_module_flag": as_bool,
"save_data_flag": as_bool,
"elems_to_save": as_str,
"file_types_to_save": as_str,
"lochost": as_str,
"locport": as_str,
"freq_endpoint": as_str,
"path_to_save_medians": as_str,
"path_to_save_alarms": as_str,
"module_name": as_str,
f"f_step_{freq_suffix}": as_str,
f"f_bases_{freq_suffix}": as_str,
f"f_roofs_{freq_suffix}": as_str,
})
debug_flag = as_bool(os.getenv('debug_flag', '0')) 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'))
@ -21,12 +37,6 @@ 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())]
signal_length = int(os.getenv('signal_length_5200'))
buffer_columns_size = int(os.getenv('buffer_columns_size_5200'))
num_of_thinning_iter = int(os.getenv('num_of_thinning_iter_5200'))
multiply_factor = float(os.getenv('multiply_factor_5200'))
num_for_alarm = int(os.getenv('num_for_alarm_5200'))
c_freq = os.getenv('c_freq_5200', '5200')
path_to_save_medians = os.getenv('path_to_save_medians') path_to_save_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')
@ -51,13 +61,7 @@ tmp_signal = Signal()
tmp_sigs_array = SignalsArray() tmp_sigs_array = SignalsArray()
multi_channel = MultiChannel(f_step, f_bases, f_roofs) multi_channel = MultiChannel(f_step, f_bases, f_roofs)
f = multi_channel.init_f() f = multi_channel.init_f()
multi_channel.fill_DB( multi_channel.fill_DB()
buffer_columns_size,
num_of_thinning_iter,
multiply_factor,
num_for_alarm,
c_freq,
)
if debug_flag: if debug_flag:
conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True) conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
@ -67,8 +71,10 @@ if debug_flag:
def work(lvl): def work(lvl):
f = multi_channel.get_cur_channel() f = multi_channel.get_cur_channel()
freq = c_freq freq = get_centre_freq(f)
signal_length = get_signal_length(freq)
median = tmp_signal.fill_signal(lvl, signal_length) median = tmp_signal.fill_signal(lvl, signal_length)
packet_ts = tmp_signal.get_last_packet_ts() packet_ts = tmp_signal.get_last_packet_ts()
@ -88,26 +94,28 @@ def work(lvl):
elif not is_jammer_active(): elif not is_jammer_active():
circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array) circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
if telemetry_enabled: if telemetry_enabled:
try: try:
max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx]) max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
dbfs_current = float(sigs_array[max_idx]) dbfs_current = float(sigs_array[max_idx])
dbfs_threshold = circle_buffer.get_threshold(max_idx) dbfs_threshold = circle_buffer.get_threshold(max_idx)
channel_thresholds = circle_buffer.get_thresholds() channel_thresholds = circle_buffer.get_thresholds()
alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else [] alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
send_telemetry( send_telemetry(
data={ data={
'freq': str(freq), "freq": str(freq),
'ts': time.time(), "ts": time.time(),
'dbfs_current': dbfs_current, "dbfs_current": dbfs_current,
'dbfs_threshold': dbfs_threshold, "dbfs_threshold": dbfs_threshold,
'alarm': bool(alarm), "alarm": bool(alarm),
'channel_idx': int(max_idx), "channel_idx": int(max_idx),
'channels_total': int(len(sigs_array)), "channels_total": int(len(sigs_array)),
'channel_values': [float(v) for v in sigs_array], "channel_values": [float(v) for v in sigs_array],
'channel_thresholds': channel_thresholds, "channel_thresholds": channel_thresholds,
'alarm_channels': alarm_channels, "alarm_channels": alarm_channels,
}, },
host=telemetry_host, host=telemetry_host,
port=telemetry_port, port=telemetry_port,
@ -116,16 +124,18 @@ def work(lvl):
) )
except Exception as exc: except Exception as exc:
if debug_flag: if debug_flag:
print(f'telemetry send failed: {exc}') print(f"telemetry send failed: {exc}")
if send_to_module_flag: if send_to_module_flag:
send_data(agregator(freq, alarm), localhost, localport, freq_endpoint) send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
if save_data_flag: if save_data_flag:
if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0: if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), list(range(num_chs))) save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
list(range(num_chs)))
if circle_buffer.check_init(): if circle_buffer.check_init():
save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians()) save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
circle_buffer.get_medians())
if debug_flag: if debug_flag:
single_alarm = circle_buffer.check_single_alarm(median, cur_channel) single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@ -136,14 +146,14 @@ def work(lvl):
try: try:
remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms) remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
except Exception as e: except Exception as e:
print(f'Ошибка: {e}') print(f"Ошибка: {e}")
else: else:
print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!') print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
f = multi_channel.change_channel() f = multi_channel.change_channel()
except Exception as e: except Exception as e:
print(str(e)) print(str(e))
print('.', end='') print(".", end='')
tmp_signal.clear() tmp_signal.clear()

74
src/embedded_5800.py
Unescape Escape View File

@ -1,14 +1,30 @@
import os import os
import datetime import datetime
import time import time
from common.runtime import load_root_env, as_bool from common.runtime import load_root_env, validate_env, as_bool, as_str
from smb.SMBConnection import SMBConnection from smb.SMBConnection import SMBConnection
from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
from utils.jammer_state_flag import is_jammer_active from utils.jammer_state_flag import is_jammer_active
from core.sig_n_medi_collect import Signal, SignalsArray from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
from core.multichannelswitcher import MultiChannel from core.multichannelswitcher import MultiChannel, get_centre_freq
load_root_env(__file__) load_root_env(__file__)
freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
validate_env(__file__, {
"send_to_module_flag": as_bool,
"save_data_flag": as_bool,
"elems_to_save": as_str,
"file_types_to_save": as_str,
"lochost": as_str,
"locport": as_str,
"freq_endpoint": as_str,
"path_to_save_medians": as_str,
"path_to_save_alarms": as_str,
"module_name": as_str,
f"f_step_{freq_suffix}": as_str,
f"f_bases_{freq_suffix}": as_str,
f"f_roofs_{freq_suffix}": as_str,
})
debug_flag = as_bool(os.getenv('debug_flag', '0')) 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'))
@ -21,12 +37,6 @@ 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())]
signal_length = int(os.getenv('signal_length_5800'))
buffer_columns_size = int(os.getenv('buffer_columns_size_5800'))
num_of_thinning_iter = int(os.getenv('num_of_thinning_iter_5800'))
multiply_factor = float(os.getenv('multiply_factor_5800'))
num_for_alarm = int(os.getenv('num_for_alarm_5800'))
c_freq = os.getenv('c_freq_5800', '5800')
path_to_save_medians = os.getenv('path_to_save_medians') path_to_save_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')
@ -51,13 +61,7 @@ tmp_signal = Signal()
tmp_sigs_array = SignalsArray() tmp_sigs_array = SignalsArray()
multi_channel = MultiChannel(f_step, f_bases, f_roofs) multi_channel = MultiChannel(f_step, f_bases, f_roofs)
f = multi_channel.init_f() f = multi_channel.init_f()
multi_channel.fill_DB( multi_channel.fill_DB()
buffer_columns_size,
num_of_thinning_iter,
multiply_factor,
num_for_alarm,
c_freq,
)
if debug_flag: if debug_flag:
conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True) conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
@ -67,8 +71,10 @@ if debug_flag:
def work(lvl): def work(lvl):
f = multi_channel.get_cur_channel() f = multi_channel.get_cur_channel()
freq = c_freq freq = get_centre_freq(f)
signal_length = get_signal_length(freq)
median = tmp_signal.fill_signal(lvl, signal_length) median = tmp_signal.fill_signal(lvl, signal_length)
packet_ts = tmp_signal.get_last_packet_ts() packet_ts = tmp_signal.get_last_packet_ts()
@ -88,26 +94,28 @@ def work(lvl):
elif not is_jammer_active(): elif not is_jammer_active():
circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array) circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
if telemetry_enabled: if telemetry_enabled:
try: try:
max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx]) max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
dbfs_current = float(sigs_array[max_idx]) dbfs_current = float(sigs_array[max_idx])
dbfs_threshold = circle_buffer.get_threshold(max_idx) dbfs_threshold = circle_buffer.get_threshold(max_idx)
channel_thresholds = circle_buffer.get_thresholds() channel_thresholds = circle_buffer.get_thresholds()
alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else [] alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
send_telemetry( send_telemetry(
data={ data={
'freq': str(freq), "freq": str(freq),
'ts': time.time(), "ts": time.time(),
'dbfs_current': dbfs_current, "dbfs_current": dbfs_current,
'dbfs_threshold': dbfs_threshold, "dbfs_threshold": dbfs_threshold,
'alarm': bool(alarm), "alarm": bool(alarm),
'channel_idx': int(max_idx), "channel_idx": int(max_idx),
'channels_total': int(len(sigs_array)), "channels_total": int(len(sigs_array)),
'channel_values': [float(v) for v in sigs_array], "channel_values": [float(v) for v in sigs_array],
'channel_thresholds': channel_thresholds, "channel_thresholds": channel_thresholds,
'alarm_channels': alarm_channels, "alarm_channels": alarm_channels,
}, },
host=telemetry_host, host=telemetry_host,
port=telemetry_port, port=telemetry_port,
@ -116,16 +124,18 @@ def work(lvl):
) )
except Exception as exc: except Exception as exc:
if debug_flag: if debug_flag:
print(f'telemetry send failed: {exc}') print(f"telemetry send failed: {exc}")
if send_to_module_flag: if send_to_module_flag:
send_data(agregator(freq, alarm), localhost, localport, freq_endpoint) send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
if save_data_flag: if save_data_flag:
if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0: if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), list(range(num_chs))) save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
list(range(num_chs)))
if circle_buffer.check_init(): if circle_buffer.check_init():
save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians()) save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
circle_buffer.get_medians())
if debug_flag: if debug_flag:
single_alarm = circle_buffer.check_single_alarm(median, cur_channel) single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@ -136,14 +146,14 @@ def work(lvl):
try: try:
remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms) remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
except Exception as e: except Exception as e:
print(f'Ошибка: {e}') print(f"Ошибка: {e}")
else: else:
print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!') print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
f = multi_channel.change_channel() f = multi_channel.change_channel()
except Exception as e: except Exception as e:
print(str(e)) print(str(e))
print('.', end='') print(".", end='')
tmp_signal.clear() tmp_signal.clear()

77
src/embedded_750.py
Unescape Escape View File

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

74
src/embedded_868.py
Unescape Escape View File

@ -1,14 +1,30 @@
import os import os
import datetime import datetime
import time import time
from common.runtime import load_root_env, as_bool from common.runtime import load_root_env, validate_env, as_bool, as_str
from smb.SMBConnection import SMBConnection from smb.SMBConnection import SMBConnection
from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data from utils.datas_processing import pack_elems, agregator, send_data, send_telemetry, save_data, remote_save_data
from utils.jammer_state_flag import is_jammer_active from utils.jammer_state_flag import is_jammer_active
from core.sig_n_medi_collect import Signal, SignalsArray from core.sig_n_medi_collect import Signal, SignalsArray, get_signal_length
from core.multichannelswitcher import MultiChannel from core.multichannelswitcher import MultiChannel, get_centre_freq
load_root_env(__file__) load_root_env(__file__)
freq_suffix = os.path.splitext(os.path.basename(__file__))[0].split("_")[-1]
validate_env(__file__, {
"send_to_module_flag": as_bool,
"save_data_flag": as_bool,
"elems_to_save": as_str,
"file_types_to_save": as_str,
"lochost": as_str,
"locport": as_str,
"freq_endpoint": as_str,
"path_to_save_medians": as_str,
"path_to_save_alarms": as_str,
"module_name": as_str,
f"f_step_{freq_suffix}": as_str,
f"f_bases_{freq_suffix}": as_str,
f"f_roofs_{freq_suffix}": as_str,
})
debug_flag = as_bool(os.getenv('debug_flag', '0')) 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'))
@ -21,12 +37,6 @@ 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())]
signal_length = int(os.getenv('signal_length_868'))
buffer_columns_size = int(os.getenv('buffer_columns_size_868'))
num_of_thinning_iter = int(os.getenv('num_of_thinning_iter_868'))
multiply_factor = float(os.getenv('multiply_factor_868'))
num_for_alarm = int(os.getenv('num_for_alarm_868'))
c_freq = os.getenv('c_freq_868', '868')
path_to_save_medians = os.getenv('path_to_save_medians') path_to_save_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')
@ -51,13 +61,7 @@ tmp_signal = Signal()
tmp_sigs_array = SignalsArray() tmp_sigs_array = SignalsArray()
multi_channel = MultiChannel(f_step, f_bases, f_roofs) multi_channel = MultiChannel(f_step, f_bases, f_roofs)
f = multi_channel.init_f() f = multi_channel.init_f()
multi_channel.fill_DB( multi_channel.fill_DB()
buffer_columns_size,
num_of_thinning_iter,
multiply_factor,
num_for_alarm,
c_freq,
)
if debug_flag: if debug_flag:
conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True) conn = SMBConnection(smb_user, smb_pass, the_pc_name, remote_pc_name, use_ntlm_v2=True)
@ -67,8 +71,10 @@ if debug_flag:
def work(lvl): def work(lvl):
f = multi_channel.get_cur_channel() f = multi_channel.get_cur_channel()
freq = c_freq freq = get_centre_freq(f)
signal_length = get_signal_length(freq)
median = tmp_signal.fill_signal(lvl, signal_length) median = tmp_signal.fill_signal(lvl, signal_length)
packet_ts = tmp_signal.get_last_packet_ts() packet_ts = tmp_signal.get_last_packet_ts()
@ -88,26 +94,28 @@ def work(lvl):
elif not is_jammer_active(): elif not is_jammer_active():
circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array) circle_buffer.update(sigs_array, packet_timestamps=sigs_ts_array)
if telemetry_enabled: if telemetry_enabled:
try: try:
max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx]) max_idx = max(range(len(sigs_array)), key=lambda idx: sigs_array[idx])
dbfs_current = float(sigs_array[max_idx]) dbfs_current = float(sigs_array[max_idx])
dbfs_threshold = circle_buffer.get_threshold(max_idx) dbfs_threshold = circle_buffer.get_threshold(max_idx)
channel_thresholds = circle_buffer.get_thresholds() channel_thresholds = circle_buffer.get_thresholds()
alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else [] alarm_channels = circle_buffer.get_last_alarm_channels() if alarm else []
send_telemetry( send_telemetry(
data={ data={
'freq': str(freq), "freq": str(freq),
'ts': time.time(), "ts": time.time(),
'dbfs_current': dbfs_current, "dbfs_current": dbfs_current,
'dbfs_threshold': dbfs_threshold, "dbfs_threshold": dbfs_threshold,
'alarm': bool(alarm), "alarm": bool(alarm),
'channel_idx': int(max_idx), "channel_idx": int(max_idx),
'channels_total': int(len(sigs_array)), "channels_total": int(len(sigs_array)),
'channel_values': [float(v) for v in sigs_array], "channel_values": [float(v) for v in sigs_array],
'channel_thresholds': channel_thresholds, "channel_thresholds": channel_thresholds,
'alarm_channels': alarm_channels, "alarm_channels": alarm_channels,
}, },
host=telemetry_host, host=telemetry_host,
port=telemetry_port, port=telemetry_port,
@ -116,16 +124,18 @@ def work(lvl):
) )
except Exception as exc: except Exception as exc:
if debug_flag: if debug_flag:
print(f'telemetry send failed: {exc}') print(f"telemetry send failed: {exc}")
if send_to_module_flag: if send_to_module_flag:
send_data(agregator(freq, alarm), localhost, localport, freq_endpoint) send_data(agregator(freq, alarm), localhost, localport, freq_endpoint)
if save_data_flag: if save_data_flag:
if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0: if not circle_buffer.check_init() and circle_buffer.current_column - 1 == 0:
save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)), list(range(num_chs))) save_data(path_to_save_medians, freq, 'DateTime', 'ALARM', 'max signal', list(range(num_chs)),
list(range(num_chs)))
if circle_buffer.check_init(): if circle_buffer.check_init():
save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array, circle_buffer.get_medians()) save_data(path_to_save_medians, freq, datetime.datetime.now(), alarm, max(sigs_array), sigs_array,
circle_buffer.get_medians())
if debug_flag: if debug_flag:
single_alarm = circle_buffer.check_single_alarm(median, cur_channel) single_alarm = circle_buffer.check_single_alarm(median, cur_channel)
@ -136,14 +146,14 @@ def work(lvl):
try: try:
remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms) remote_save_data(conn, data, module_name, freq, shared_folder, path_to_save_alarms)
except Exception as e: except Exception as e:
print(f'Ошибка: {e}') print(f"Ошибка: {e}")
else: else:
print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!') print('VSE OKI DOKI SIGNAL SOKHRANYAT NE NUZHNO!!!')
f = multi_channel.change_channel() f = multi_channel.change_channel()
except Exception as e: except Exception as e:
print(str(e)) print(str(e))
print('.', end='') print(".", end='')
tmp_signal.clear() tmp_signal.clear()

104
src/main_1500.py
Unescape Escape View File

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

45
src/main_3300.py
Unescape Escape View File

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

4
src/main_433.py
Unescape Escape View File

@ -94,8 +94,8 @@ class get_center_freq(gr.top_block):
self.rtlsdr_source_0.set_sample_rate(samp_rate) self.rtlsdr_source_0.set_sample_rate(samp_rate)
self.rtlsdr_source_0.set_center_freq(center_freq, 0) self.rtlsdr_source_0.set_center_freq(center_freq, 0)
self.rtlsdr_source_0.set_freq_corr(0, 0) self.rtlsdr_source_0.set_freq_corr(0, 0)
self.rtlsdr_source_0.set_gain(24, 0) self.rtlsdr_source_0.set_gain(100, 0)
self.rtlsdr_source_0.set_if_gain(24, 0) self.rtlsdr_source_0.set_if_gain(100, 0)
self.rtlsdr_source_0.set_bb_gain(100, 0) self.rtlsdr_source_0.set_bb_gain(100, 0)
self.rtlsdr_source_0.set_antenna('', 0) self.rtlsdr_source_0.set_antenna('', 0)
self.rtlsdr_source_0.set_bandwidth(0, 0) self.rtlsdr_source_0.set_bandwidth(0, 0)

45
src/main_4500.py
Unescape Escape View File

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

45
src/main_5200.py
Unescape Escape View File

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

45
src/main_5800.py
Unescape Escape View File

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

4
src/main_750.py
Unescape Escape View File

@ -94,8 +94,8 @@ class get_center_freq(gr.top_block):
self.rtlsdr_source_0.set_sample_rate(samp_rate) self.rtlsdr_source_0.set_sample_rate(samp_rate)
self.rtlsdr_source_0.set_center_freq(center_freq, 0) self.rtlsdr_source_0.set_center_freq(center_freq, 0)
self.rtlsdr_source_0.set_freq_corr(0, 0) self.rtlsdr_source_0.set_freq_corr(0, 0)
self.rtlsdr_source_0.set_gain(24, 0) self.rtlsdr_source_0.set_gain(100, 0)
self.rtlsdr_source_0.set_if_gain(24, 0) self.rtlsdr_source_0.set_if_gain(100, 0)
self.rtlsdr_source_0.set_bb_gain(100, 0) self.rtlsdr_source_0.set_bb_gain(100, 0)
self.rtlsdr_source_0.set_antenna('', 0) self.rtlsdr_source_0.set_antenna('', 0)
self.rtlsdr_source_0.set_bandwidth(0, 0) self.rtlsdr_source_0.set_bandwidth(0, 0)

198
src/main_868.py
Unescape Escape View File

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

122
src/main_868_915_router.py
Unescape Escape View File

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

173
src/shared_router_868_915.py
Unescape Escape View File

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

16
src/unused/embedded_1200.py
Unescape Escape View File

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

Write Preview
Loading…
Cancel
Save