ChTheo/RFG_Receiver_GUI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
Theodor Chikin
2025-11-13 14:09:17 +03:00
commit 385fda93f9
3 changed files with 1603 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

294
datagen.py Normal file
View File

@ -0,0 +1,294 @@
import os
import time
import numpy as np
from datetime import datetime, timedelta
# ================================================================================
# ПАРАМЕТРЫ ЭМУЛЯЦИИ
# ================================================================================
DATA_DIR = r"D:\data"
# ✓ ИСПРАВЛЕНИЕ: Выбор типа данных и количество
NUM_FILES = 1000 # Количесйтво файлов для генерации
# Размеры данных
RAW_SIZE = 64000
SYNC_DET_SIZE = 1000
FOURIER_SIZE = SYNC_DET_SIZE // 2 # 500 (положительные частоты)
# Интервал между файлами (в миллисекундах)
FILE_INTERVAL_MS = 300 # 300 мс между файлами
# ================================================================================
# ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ
# ================================================================================
def create_raw_data(size=RAW_SIZE, index=0):
"""Генерирует RAW данные."""
# Синусоида + шум, зависит от индекса для разнообразия
t = np.linspace(0, 10 * np.pi, size)
freq_mult = 1.0 + 0.1 * np.sin(index / 100)
signal = np.sin(freq_mult * t) + 0.1 * np.random.randn(size)
return signal
def create_sync_det_data(size=SYNC_DET_SIZE, index=0):
"""Генерирует SYNC_DET данные."""
# Модулированная синусоида, зависит от индекса
t = np.linspace(0, 20 * np.pi, size)
damping = np.exp(-t / (20 * np.pi)) * (1 + 0.2 * np.sin(index / 50))
signal = np.sin(t) * damping
return signal
def create_fourier_data(sync_det_data=None, fft_size=SYNC_DET_SIZE, output_size=FOURIER_SIZE, index=0):
"""✓ Генерирует FOURIER = |FFT(SYNC_DET)|[:N/2].
FFT от сигнала размером N имеет только N/2 независимых значений.
Args:
sync_det_data: вектор SYNC_DET размером ~1000
fft_size: размер FFT (1000)
output_size: размер выходного спектра (500)
index: индекс файла для вариативности
Returns:
fourier_data: амплитудный спектр размером output_size (500)
"""
if sync_det_data is None:
sync_det_data = create_sync_det_data(index=index)
# ✓ Вычисляем FFT от SYNC_DET
fft_result = np.fft.fft(sync_det_data[:fft_size])
# ✓ Берём амплитудный спектр
amplitude_spectrum = np.abs(fft_result)
# ✓ Центрируем спектр
fft_shift = np.fft.fftshift(amplitude_spectrum)
# ✓ Берём только положительные частоты (N/2 = 500)
fft_positive = fft_shift[len(fft_shift) // 2:]
assert len(fft_positive) == output_size, \
f"FFT positive frequencies size {len(fft_positive)} != expected {output_size}"
fourier_data = fft_positive.astype(float)
# Нормализуем
if fourier_data.max() > 0:
fourier_data = fourier_data / fourier_data.max() * 100
return fourier_data
# ================================================================================
# ГЕНЕРАЦИЯ ФАЙЛОВ
# ================================================================================
def emit_raw_files(count=NUM_FILES, start_time=None):
"""Генерирует RAW файлы количеством count."""
if start_time is None:
start_time = datetime.now()
print(f"\n{'=' * 80}")
print(f"📝 ГЕНЕРИРОВАНИЕ {count} RAW ФАЙЛОВ")
print(f"{'=' * 80}")
print(f"Размер: {RAW_SIZE} точек")
print(f"Интервал: {FILE_INTERVAL_MS}мс\n")
for i in range(count):
# Вычисляем время файла
file_time = start_time + timedelta(milliseconds=i * FILE_INTERVAL_MS)
# Форматируем имя с миллисекундами
time_str = file_time.strftime("%H_%M_%S")
ms = file_time.microsecond // 1000
filename = f"RAW_{time_str}_{ms:03d}.txt"
# Генерируем данные
data = create_raw_data(index=i)
# Добавляем заголовок
filepath = os.path.join(DATA_DIR, filename)
with open(filepath, 'w') as f:
f.write("RAW\n")
np.savetxt(f, data, fmt='%.6f')
# Устанавливаем время модификации
timestamp = file_time.timestamp()
os.utime(filepath, (timestamp, timestamp))
# Прогресс
if (i + 1) % 100 == 0 or (i + 1) == count:
print(f" ✓ {i + 1}/{count} файлов созданы", end='\r')
print(f"\n✅ Готово: {count} RAW файлов")
return start_time + timedelta(milliseconds=count * FILE_INTERVAL_MS)
def emit_sync_det_files(count=NUM_FILES, start_time=None):
"""Генерирует SYNC_DET файлы количеством count."""
if start_time is None:
start_time = datetime.now()
print(f"\n{'=' * 80}")
print(f"📝 ГЕНЕРИРОВАНИЕ {count} SYNC_DET ФАЙЛОВ")
print(f"{'=' * 80}")
print(f"Размер: {SYNC_DET_SIZE} точек")
print(f"Интервал: {FILE_INTERVAL_MS}мс\n")
for i in range(count):
# Вычисляем время файла
file_time = start_time + timedelta(milliseconds=i * FILE_INTERVAL_MS)
# Форматируем имя с миллисекундами
time_str = file_time.strftime("%H_%M_%S")
ms = file_time.microsecond // 1000
filename = f"SYNC_DET_{time_str}_{ms:03d}.txt"
# Генерируем данные
data = create_sync_det_data(index=i)
# Добавляем заголовок
filepath = os.path.join(DATA_DIR, filename)
with open(filepath, 'w') as f:
f.write("SYNC_DET\n")
np.savetxt(f, data, fmt='%.6f')
# Устанавливаем время модификации
timestamp = file_time.timestamp()
os.utime(filepath, (timestamp, timestamp))
# Прогресс
if (i + 1) % 100 == 0 or (i + 1) == count:
print(f" ✓ {i + 1}/{count} файлов созданы", end='\r')
print(f"\n✅ Готово: {count} SYNC_DET файлов")
return start_time + timedelta(milliseconds=count * FILE_INTERVAL_MS)
def emit_fourier_files(count=NUM_FILES, start_time=None):
"""✓ Генерирует FOURIER файлы количеством count.
Каждый файл содержит амплитудный спектр размером 500.
"""
if start_time is None:
start_time = datetime.now()
print(f"\n{'=' * 80}")
print(f"📝 ГЕНЕРИРОВАНИЕ {count} FOURIER ФАЙЛОВ")
print(f"{'=' * 80}")
print(f"Размер: {FOURIER_SIZE} точек (|FFT|[:N/2])")
print(f"Интервал: {FILE_INTERVAL_MS}мс\n")
for i in range(count):
# Вычисляем время файла
file_time = start_time + timedelta(milliseconds=i * FILE_INTERVAL_MS)
# Форматируем имя с миллисекундами
time_str = file_time.strftime("%H_%M_%S")
ms = file_time.microsecond // 1000
filename = f"FOURIER_{time_str}_{ms:03d}.txt"
# Генерируем SYNC_DET
sync_det = create_sync_det_data(index=i)
# Вычисляем FOURIER как |FFT(SYNC_DET)|[:N/2]
data = create_fourier_data(
sync_det_data=sync_det,
fft_size=SYNC_DET_SIZE,
output_size=FOURIER_SIZE,
index=i
)
assert len(data) == FOURIER_SIZE, \
f"FOURIER size {len(data)} != expected {FOURIER_SIZE}"
# Добавляем заголовок
filepath = os.path.join(DATA_DIR, filename)
with open(filepath, 'w') as f:
f.write("FOURIER\n")
np.savetxt(f, data, fmt='%.6f')
# Устанавливаем время модификации
timestamp = file_time.timestamp()
os.utime(filepath, (timestamp, timestamp))
# Прогресс
if (i + 1) % 100 == 0 or (i + 1) == count:
print(f" ✓ {i + 1}/{count} файлов созданы", end='\r')
print(f"\n✅ Готово: {count} FOURIER файлов")
return start_time + timedelta(milliseconds=count * FILE_INTERVAL_MS)
# ================================================================================
# ОСНОВНАЯ ПРОГРАММА
# ================================================================================
def show_menu():
"""Показывает меню выбора типа данных."""
print("\n" + "=" * 80)
print(" РАДАР ЭМУЛЯТОР - ВЫБОР ТИПА ДАННЫХ")
print("=" * 80)
print()
print(" Выберите тип данных для генерирования:")
print()
print(" 1. RAW - Сырые данные с АЦП ({} точек)".format(RAW_SIZE))
print(" 2. SYNC_DET - Обработанные данные ({} точек)".format(SYNC_DET_SIZE))
print(" 3. FOURIER - Амплитудный спектр ({} точек)".format(FOURIER_SIZE))
print()
print("=" * 80)
print()
if __name__ == "__main__":
# Создаём директорию если её нет
os.makedirs(DATA_DIR, exist_ok=True)
print("\n" + "=" * 80)
print(" РАДАР ЭМУЛЯТОР - ГЕНЕРИРОВАНИЕ ТЕСТОВЫХ ДАННЫХ")
print("=" * 80)
print(f" Директория: {DATA_DIR}")
print(f" Количество файлов: {NUM_FILES}")
print(f" Интервал между файлами: {FILE_INTERVAL_MS}мс")
print(f" Формат времени: HH:MM:SS.mmm")
print("=" * 80)
show_menu()
while True:
try:
choice = input(" Введите номер (1/2/3) или 'q' для выхода: ").strip().lower()
if choice == 'q':
print("\n Выход.")
break
elif choice == '1':
start_time = datetime.now().replace(microsecond=0)
emit_raw_files(NUM_FILES, start_time)
break
elif choice == '2':
start_time = datetime.now().replace(microsecond=0)
emit_sync_det_files(NUM_FILES, start_time)
break
elif choice == '3':
start_time = datetime.now().replace(microsecond=0)
emit_fourier_files(NUM_FILES, start_time)
break
else:
print(" ❌ Неверный выбор. Введите 1, 2, 3 или q")
except KeyboardInterrupt:
print("\n\n Прервано пользователем.")
break
except Exception as e:
print(f" ❌ Ошибка: {e}")
continue
print(f"\n📂 Файлы сохранены в: {DATA_DIR}")
print(f"\n💡 Запустите main_analyzer.py и откройте директорию {DATA_DIR}")
print(f" Анализатор автоматически подхватит новые файлы\n")

1079
main.py Normal file
View File

File diff suppressed because it is too large Load Diff

230
testLadArrayGround.m Normal file
View File

@ -0,0 +1,230 @@
close all
clear
cd D:\data\
files = dir("*.txt*");
%%t = datetime(Y,M,D,H,MI,S,MS);
% figure(1);
time = 1:1:64000;
PeriodIntegrate = 2;
%pontInOneFqChange = 86;
pontInOneFqChange = 86;
global startPointTime;
global height;
height = 60;
global timePoint;
timePoint = 100;
global update ;
update =0;
FQend = 512;
%
% for i=1:1:size(files,1)
% A = readmatrix(files(i).name);
%time = 1:1:size(A);
% plot(time,A(time)), hold on;
% end
% hold off;
old_size = size(files,1);
SizeFirst = size (readmatrix(files(1).name),1);
time = 1:1:size(readmatrix(files(1).name));
%figure (2);
k = 1;
oldA = 0;
SUM =0;
g =0;
B = 0;
meandr=0;
S.f =figure('WindowState', 'maximized');
%
% %b = uibutton(fig2, ...
% "Text","Play", ...
% "Icon","play.png", ...
% "IconAlignment","top", ...
% "Position",[100 100 50 50]);
S.pb = uicontrol('style','push',...
'units','pix',...
'position',[10 10 180 40],...
'fontsize',14,...
'string','Обновить',...
'callback',{@pb_call,S});
distance(1:50) = 0;
timearray(1:50) = 0;
timestart = tic;
B_scan = zeros(height, timePoint);
startPointTime = 0;
FFT0_delta = 5;
while(1)
files = dir("*.txt*");
new_siz = size(files,1);
if new_siz> old_size
pause(0.1);
A = readmatrix(files(new_siz).name);
if (SizeFirst== size(A,1))
if k<PeriodIntegrate
SUM = SUM + A;
if k==1
B=A;
%meandr = (square(double(time)*double(3.141592)).*-1)';
meandr = (square(double(time)*double(3.141592)).*1)';
timestart2 = tic;
else
B(:,k) =A(:,1);
end
oldA= A;
MEAN = SUM./k;
k=k+1;
%plot(time,MEAN(time));
else
%%%%%%%%%%%%%%%%%%%%%проверка нажатия кнопки
if (update == 0)
else
R = updateData();
startPointTime = R.startPointTime ;
height = R.height;
timePoint = R.timePoint;
B_scan = R.B_scan;
update = 0;
end
%%%%%
x = linspace(0, 0.65*timePoint, timePoint);
y = linspace(10, 1.5*height, height);
B(:,PeriodIntegrate+1) = A(:,1) ;
B = circshift(B,1,2);
meanB = sum(B(:,1:PeriodIntegrate-1),2)./PeriodIntegrate;
mwanBmeandr = meanB.*meandr;
%mwanBmeandr = meanB;
startPointTime = startPointTime+1;
start = 1;
numberOfFreqChangeStart = 1;
pos = 1;
for numberOfFreqChange = 1:1:SizeFirst
if ((numberOfFreqChange-start)>pontInOneFqChange)
signal(pos) = sum(mwanBmeandr(numberOfFreqChangeStart:numberOfFreqChange));
signalView(pos) = mean(mwanBmeandr(numberOfFreqChangeStart:numberOfFreqChange));
timeSignal(pos) = numberOfFreqChange;
start = numberOfFreqChange;
numberOfFreqChangeStart = numberOfFreqChange;
pos = pos+1;
end
end
%fig2 =figure(2);
subplot(2,2,1);
plot(time,abs(meanB(time)), time, meandr.*0.001, timeSignal, abs(signalView) );
xlabel('Такты (шт)')
ylabel('Сигнал (мВ)')
title('Данные с АЦП')
%figure(3);
ssS = size(signal,2);
perpointFq = 10.67/ssS;
XSignal = 3+ (1:1:ssS).*perpointFq;
subplot(2,2,3);
plot(XSignal, (abs(signal)) );
xlabel('Частота генератора(ГГц)')
ylabel('Принятый сигнал (мВ)')
title('Обработанные данные')
%figure(4);
subplot(2,2,2);
F = fft(sqrt(abs(signal(1:FQend))));
Fshift = (abs(fftshift(F)));
Fshift(ceil(FQend/2)-0:ceil(FQend/2)+0) = 0;
FshiftS = smoothdata(Fshift,'gaussian',5);
plot(FshiftS);
xlim([0 FQend]);
title('Фурье образ')
% [pks,locs] = findpeaks(FshiftS,'MinPeakDistance',5,'Annotate','extents','SortStr','descend');
% text(locs+.02,pks,num2str((1:numel(pks))'))
% ylim([-4 3]);
% ylim([0 1.5]);
%figure(5);
subplot(2,2,4);
if (timearray(1) == 0)
timeend = toc(timestart2);
timearray(1:50) = abs( timeend).*(1:50);
else
timeend = toc(timestart);
timearray(1) = abs( timeend);
end
if startPointTime>timePoint
startPointTime = 1 ;
B_scan(:,startPointTime) = FshiftS(1 , ceil(FQend/2)+FFT0_delta: (ceil(FQend/2)+FFT0_delta+60-1) )';
B_scan(:,startPointTime+1) = zeros(1,height);
imagesc(x,y,B_scan);
% B_scan = circshift(B_scan,[0 1]);
% B_scan(:,timePoint) = FshiftS(1, ceil(735/2): (ceil(735/2)+150-1) )';
%imagesc(B_scan);
else
B_scan(:,startPointTime) = FshiftS(1, ceil(FQend/2)+FFT0_delta: (ceil(FQend/2)+FFT0_delta+60-1) )';
B_scan(:,startPointTime+1) = zeros(1,height);
imagesc(x,y,B_scan);
end
% for ooo =1:size(pks,2)
% transparance = pks(ooo)/pks(1);
% distance(1) = abs((ceil(735/2) - locs(ooo)) * 8/5);
% xlim([1 100]);
% plot(timearray(1),distance(1),'or','MarkerSize', transparance*12,"MarkerFaceColor",'r' ),hold on;
% ylim([0 80]);
% if timearray(1)>=100
% xlim([timearray(1)-100 timearray(1)]);
% ylim([0 80]);
% end
% % distance = circshift(distance,1);,
% % timearray = circshift(timearray,1);
% end
title('Дистанция до объекта')
xlabel('Время (С)')
ylabel('Дистанция (см)')
end
old_size = new_siz;
end
pause(0.01);
end
end
function pb_call(varargin)
%S = varargin{3}; % Get the structure.
%set(S.h,'LineStyle','+')
global update ;
update = 1;
end
function R = updateData()
R.startPointTime = 0 ;
R.height = 60;
R.timePoint = 100;
R.B_scan = zeros(R.height, R.timePoint);
end