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

Compare commits

base: SergeyRevyakin:new_read_pipe
Branches Tags
SergeyRevyakin:main_2
SergeyRevyakin:new_read_pipe
SergeyRevyakin:fft
SergeyRevyakin:main
..
compare: SergeyRevyakin:main
Branches Tags
SergeyRevyakin:main_2
SergeyRevyakin:new_read_pipe
SergeyRevyakin:fft
SergeyRevyakin:main

No commits in common. 'new_read_pipe' and 'main' have entirely different histories.
new_read_p ... main

49 changed files with 1936 additions and 6408 deletions
Show Stats

1
.gitignore vendored
Unescape Escape View File

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

34
README.md
Unescape Escape View File

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

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

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'

18
deploy/docker/Dockerfile.telemetry_server
Unescape Escape View File

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

25
deploy/docker/docker-compose.yml
Unescape Escape View File

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

3
deploy/requirements/telemetry_server.txt
Unescape Escape View File

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

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]
Description=DroneDetector SDR Scanner 868 MHz
After=network-online.target dronedetector-sdr-868-915.service
After=network-online.target
Wants=network-online.target
Requires=dronedetector-sdr-868-915.service
[Service]
Type=simple

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

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

2
install_all.sh
Unescape Escape View File

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

100
orange_scripts/compose_send_data_915.py
Unescape Escape View File

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

1
orange_scripts/main_1200.py
Unescape Escape View File

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

1
orange_scripts/main_2400.py
Unescape Escape View File

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

173
orange_scripts/main_915.py
Unescape Escape View File

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

BIN
out.iq
View File

Binary file not shown.

2
restart_all.sh
Unescape Escape View File

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

686
scripts_nn/band_scanner.grc
Unescape Escape View File

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

642
scripts_nn/data_saver.grc
Unescape Escape View File

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

683
scripts_nn/fft_detector.grc
Unescape Escape View File

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

1063
scripts_nn/transmitter.grc
View File

File diff suppressed because it is too large Load Diff

210
src/core/data_buffer.py
Unescape Escape View File

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

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

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

82
src/core/sig_n_medi_collect.py
Unescape Escape View File

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

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

96
src/embedded_3300.py
Unescape Escape View File

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

96
src/embedded_433.py
Unescape Escape View File

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

96
src/embedded_4500.py
Unescape Escape View File

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

96
src/embedded_5200.py
Unescape Escape View File

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

96
src/embedded_5800.py
Unescape Escape View File

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

99
src/embedded_750.py
Unescape Escape View File

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

96
src/embedded_868.py
Unescape Escape View File

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

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()

48
src/main_3300.py
Unescape Escape View File

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

7
src/main_433.py
Unescape Escape View File

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

48
src/main_4500.py
Unescape Escape View File

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

47
src/main_5200.py
Unescape Escape View File

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

46
src/main_5800.py
Unescape Escape View File

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

7
src/main_750.py
Unescape Escape View File

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

205
src/main_868.py
Unescape Escape View File

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

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()

5
src/server_to_master.py
Unescape Escape View File

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

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

36
src/utils/datas_processing.py
Unescape Escape View File

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

47
src/utils/jammer_state_flag.py
Unescape Escape View File

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

1
telemetry/__init__.py
Unescape Escape View File

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

465
telemetry/telemetry_server.py
Unescape Escape View File

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