import serial
import matplotlib.pyplot as plt
import numpy as np
import time

def send_command(ser, command, wait_time=0.5):
    print(f"Отправка команды: {command}")
    ser.write((command + '\r\n').encode())
    time.sleep(wait_time)
    
    response = b''
    start_time = time.time()
    while time.time() - start_time < wait_time:
        if ser.in_waiting > 0:
            response += ser.read(ser.in_waiting)
        time.sleep(0.01)
    
    return response.decode('ascii', errors='ignore')

def setup_nanovna(ser, cal_slot=0):
    print("Настройка NanoVNA...")
    
    commands = [
        f"cal load {cal_slot}",
        "sweep 30000000 250000000 101",
        "pause",
    ]
    
    for cmd in commands:
        response = send_command(ser, cmd, 0.5)
        if response:
            response_clean = response.replace('ch>', '').strip()
            if response_clean:
                print(f"Ответ на {cmd}: {response_clean}")
    
    cal_status = send_command(ser, "cal", 0.5)
    if cal_status:
        print(f"Статус калибровки: {cal_status}")
    
    time.sleep(1)

def get_nanovna_data(ser):
    print("Получение данных S21...")
    send_command(ser, "resume", 2)
    freq_data = send_command(ser, "frequencies", 1)
    print(f"Получено данных частот: {len(freq_data)} байт")
    s21_data = send_command(ser, "data 1", 1) 
    print(f"Получено данных S21: {len(s21_data)} байт")
    return freq_data, s21_data

def parse_frequency_data(data):
    frequencies = []
    lines = data.strip().split('\n')
    
    for line in lines:
        line = line.strip()
        if line and not line.startswith('ch>'):
            try:
                parts = line.split()
                for part in parts:
                    freq = float(part)
                    frequencies.append(freq)
            except ValueError:
                continue
    
    return frequencies

def parse_s21_data(data):
    """Парсинг данных S21 (комплексные числа)"""
    s21_points = []
    lines = data.strip().split('\n')
    
    for line in lines:
        line = line.strip()
        if line and not line.startswith('ch>'):
            try:
                # Данные S21 в формате: real imag
                parts = line.split()
                if len(parts) >= 2:
                    real = float(parts[0])
                    imag = float(parts[1])
                    s21_points.append((real, imag))
            except ValueError:
                continue
    
    return s21_points

def calculate_s21_db(s21_points):
    s21_db = []
    for real, imag in s21_points:
        magnitude = np.sqrt(real**2 + imag**2)
        if magnitude > 0:
            db = 20 * np.log10(magnitude)
        else:
            db = -120  # Минимальное значение
        s21_db.append(db)
    return s21_db

def plot_filter_response(frequencies, s21_db):
    if not frequencies or not s21_db:
        print("Недостаточно данных для построения графика")
        return
    
    min_len = min(len(frequencies), len(s21_db))
    frequencies = frequencies[:min_len]
    s21_db = s21_db[:min_len]
    
    frequencies_mhz = [f / 1e6 for f in frequencies]
    
    plt.figure(figsize=(12, 8))
    plt.plot(frequencies_mhz, s21_db, 'b-', linewidth=2, label='S21 (Transmission)')
    
    plt.title('АЧХ режекторного FM фильтра\nNanoVNA-H4 (с калибровкой)', fontsize=14, fontweight='bold')
    plt.xlabel('Частота (МГц)', fontsize=12)
    plt.ylabel('S21 (дБ)', fontsize=12)
    plt.grid(True, alpha=0.3)
    
    fm_start, fm_end = 87.5, 108
    plt.axvspan(fm_start, fm_end, alpha=0.2, color='red', label='FM диапазон')
    plt.axvline(fm_start, color='red', linestyle='--', alpha=0.7)
    plt.axvline(fm_end, color='red', linestyle='--', alpha=0.7)
    
    min_db_index = np.argmin(s21_db)
    min_freq = frequencies_mhz[min_db_index]
    min_db = s21_db[min_db_index]
    
    plt.plot(min_freq, min_db, 'ro', markersize=8, 
             label=f'Подавление: {min_freq:.1f} МГц, {min_db:.1f} дБ')
    
    plt.xlim(min(frequencies_mhz), max(frequencies_mhz))
    plt.ylim(min(s21_db) - 5, max(s21_db) + 5)
    
    plt.xticks(rotation=45)
    
    from matplotlib.ticker import FuncFormatter
    def format_freq(x, pos):
        if x >= 1000:
            return f'{x/1000:.0f}00'
        else:
            return f'{x:.0f}'
    
    plt.gca().xaxis.set_major_formatter(FuncFormatter(format_freq))
    
    plt.legend(fontsize=10)
    plt.tight_layout()
    plt.show()
    
    print(f"\n=== РЕЗУЛЬТАТЫ ИЗМЕРЕНИЯ ===")
    print(f"Диапазон: {min(frequencies_mhz):.1f} - {max(frequencies_mhz):.1f} МГц")
    print(f"Точка подавления: {min_freq:.2f} МГц")
    print(f"Глубина подавления: {min_db:.1f} дБ")
    print(f"FM диапазон: {fm_start} - {fm_end} МГц")
    
    # Проверяем эффективность подавления в FM диапазоне
    fm_indices = [i for i, f in enumerate(frequencies_mhz) if fm_start <= f <= fm_end]
    if fm_indices:
        fm_attenuation = [s21_db[i] for i in fm_indices]
        avg_fm_attenuation = np.mean(fm_attenuation)
        print(f"Среднее подавление в FM диапазоне: {avg_fm_attenuation:.1f} дБ")

def main():
    ser = None
    try:
        print("Подключение к NanoVNA-H4 на COM3...")
        
        ser = serial.Serial(
            port='COM3',
            baudrate=115200,
            timeout=2,
            write_timeout=2,
        )
        time.sleep(2)
        
        setup_nanovna(ser, cal_slot=0)
        freq_data, s21_data = get_nanovna_data(ser)
        
        frequencies = parse_frequency_data(freq_data)
        s21_points = parse_s21_data(s21_data)
        s21_db = calculate_s21_db(s21_points)
        
        print(f"\nОбработано {len(frequencies)} частот и {len(s21_points)} точек S21")
        
        if frequencies and s21_db:
            plot_filter_response(frequencies, s21_db)
        else:
            print("Не удалось получить данные для построения графика")
            
    except Exception as e:
        print(f"Ошибка: {e}")
        import traceback
        traceback.print_exc()
        
    finally:
        if ser and ser.is_open:
            ser.close()
            print("\nСоединение закрыто")

if __name__ == "__main__":
    main()

import serial
import matplotlib
matplotlib.use('Agg')  # Используем бэкенд без GUI
import matplotlib.pyplot as plt
import numpy as np
import time
import os
from datetime import datetime

def send_command(ser, command, wait_time=0.5):
    print(f"Отправка команды: {command}")
    ser.write((command + '\r\n').encode())
    time.sleep(wait_time)
    response = b''
    start_time = time.time()
    while time.time() - start_time < wait_time:
        if ser.in_waiting > 0:
            response += ser.read(ser.in_waiting)
        time.sleep(0.01)
    return response.decode('ascii', errors='ignore')

def setup_nanovna(ser, cal_slot=0):
    print("Настройка NanoVNA...")
    commands = [
        f"cal load {cal_slot}",
        "sweep 30000000 250000000 101",
        "pause",
    ]
    for cmd in commands:
        response = send_command(ser, cmd, 0.5)
        if response:
            response_clean = response.replace('ch>', '').strip()
            if response_clean:
                print(f"Ответ на {cmd}: {response_clean}")
    
    cal_status = send_command(ser, "cal", 0.5)
    if cal_status:
        print(f"Статус калибровки: {cal_status}")
    time.sleep(1)

def get_nanovna_data(ser):
    send_command(ser, "resume", 2)
    freq_data = send_command(ser, "frequencies", 1)
    print(f"Получено данных частот: {len(freq_data)} байт")
    s21_data = send_command(ser, "data 1", 1) 
    print(f"Получено данных S21: {len(s21_data)} байт")
    return freq_data, s21_data

def parse_frequency_data(data):
    frequencies = []
    lines = data.strip().split('\n')
    for line in lines:
        line = line.strip()
        if line and not line.startswith('ch>'):
            try:
                parts = line.split()
                for part in parts:
                    freq = float(part)
                    frequencies.append(freq)
            except ValueError:
                continue
    return frequencies

def parse_s21_data(data):
    s21_points = []
    lines = data.strip().split('\n')
    for line in lines:
        line = line.strip()
        if line and not line.startswith('ch>'):
            try:
                # Данные S21 в формате: real imag
                parts = line.split()
                if len(parts) >= 2:
                    real = float(parts[0])
                    imag = float(parts[1])
                    s21_points.append((real, imag))
            except ValueError:
                continue
    return s21_points

def calculate_s21_db(s21_points):
    s21_db = []
    for real, imag in s21_points:
        magnitude = np.sqrt(real**2 + imag**2)
        if magnitude > 0:
            db = 20 * np.log10(magnitude)
        else:
            db = -120  # Минимальное значение
        s21_db.append(db)
    return s21_db

def save_filter_response(frequencies, s21_db, filename=None):
    if not frequencies or not s21_db:
        print("Недостаточно данных для построения графика")
        return None
    
    min_len = min(len(frequencies), len(s21_db))
    frequencies = frequencies[:min_len]
    s21_db = s21_db[:min_len]
    
    frequencies_mhz = [f / 1e6 for f in frequencies]
    
    # Создаем папку для результатов если её нет
    results_dir = "/home/frolov"
    if not os.path.exists(results_dir):
        os.makedirs(results_dir)
    
    # Генерируем имя файла с временной меткой
    if filename is None:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"filter_response_{timestamp}.png"
    
    filepath = os.path.join(results_dir, filename)
    
    plt.figure(figsize=(12, 8))
    plt.plot(frequencies_mhz, s21_db, 'b-', linewidth=2, label='S21 (Transmission)')
    
    plt.title('АЧХ режекторного FM фильтра\nNanoVNA-H4 (с калибровкой)', fontsize=14, fontweight='bold')
    plt.xlabel('Частота (МГц)', fontsize=12)
    plt.ylabel('S21 (дБ)', fontsize=12)
    plt.grid(True, alpha=0.3)
    
    fm_start, fm_end = 87.5, 108
    plt.axvspan(fm_start, fm_end, alpha=0.2, color='red', label='FM диапазон')
    plt.axvline(fm_start, color='red', linestyle='--', alpha=0.7)
    plt.axvline(fm_end, color='red', linestyle='--', alpha=0.7)
    
    min_db_index = np.argmin(s21_db)
    min_freq = frequencies_mhz[min_db_index]
    min_db = s21_db[min_db_index]
    
    plt.plot(min_freq, min_db, 'ro', markersize=8, 
             label=f'Подавление: {min_freq:.1f} МГц, {min_db:.1f} дБ')
    
    plt.xlim(min(frequencies_mhz), max(frequencies_mhz))
    plt.ylim(min(s21_db) - 5, max(s21_db) + 5)
    
    plt.xticks(rotation=45)
    
    from matplotlib.ticker import FuncFormatter
    def format_freq(x, pos):
        if x >= 1000:
            return f'{x/1000:.0f}00'
        else:
            return f'{x:.0f}'
    
    plt.gca().xaxis.set_major_formatter(FuncFormatter(format_freq))
    
    plt.legend(fontsize=10)
    plt.tight_layout()
    
    # Сохраняем график
    plt.savefig(filepath, dpi=150, bbox_inches='tight')
    plt.close()
    
    print(f"График сохранен как: {filepath}")
    
    # Сохраняем данные в текстовый файл
    data_filename = filename.replace('.png', '.txt')
    data_filepath = os.path.join(results_dir, data_filename)
    
    with open(data_filepath, 'w') as f:
        f.write("Частота (МГц)\tS21 (дБ)\n")
        for freq, db in zip(frequencies_mhz, s21_db):
            f.write(f"{freq:.3f}\t{db:.3f}\n")
    
    print(f"Данные сохранены как: {data_filepath}")
    
    print(f"\n=== РЕЗУЛЬТАТЫ ИЗМЕРЕНИЯ ===")
    print(f"Диапазон: {min(frequencies_mhz):.1f} - {max(frequencies_mhz):.1f} МГц")
    print(f"Точка подавления: {min_freq:.2f} МГц")
    print(f"Глубина подавления: {min_db:.1f} дБ")
    print(f"FM диапазон: {fm_start} - {fm_end} МГц")
    
    # Проверяем эффективность подавления в FM диапазоне
    fm_indices = [i for i, f in enumerate(frequencies_mhz) if fm_start <= f <= fm_end]
    if fm_indices:
        fm_attenuation = [s21_db[i] for i in fm_indices]
        avg_fm_attenuation = np.mean(fm_attenuation)
        print(f"Среднее подавление в FM диапазоне: {avg_fm_attenuation:.1f} дБ")
    
    return filepath

def main():
    ser = None
    try:
        ser = serial.Serial('/dev/ttyACM0', 115200, timeout=1)
        print("Подключение установлено")
        
        setup_nanovna(ser, cal_slot=0)
        freq_data, s21_data = get_nanovna_data(ser)
        frequencies = parse_frequency_data(freq_data)
        s21_points = parse_s21_data(s21_data)
        s21_db = calculate_s21_db(s21_points)
        
        print(f"\nОбработано {len(frequencies)} частот и {len(s21_points)} точек S21")
        
        if frequencies and s21_db:
            plot_filename = save_filter_response(frequencies, s21_db)
            print(f"\nИзмерение завершено. Результаты сохранены в: {plot_filename}")
        else:
            print("Не удалось получить данные для построения графика")
    except Exception as e:
        print(f"Ошибка: {e}")
        import traceback
        traceback.print_exc()
    finally:
        if ser and ser.is_open:
            ser.close()

if __name__ == "__main__":
    main()

import serial
import matplotlib.pyplot as plt
import numpy as np
import time
from scipy.signal import find_peaks
import math

def send_command(ser, command, wait_time=0.5):
    print(f"Отправка команды: {command}")
    ser.write((command + '\r\n').encode())
    time.sleep(wait_time)
    
    response = b''
    start_time = time.time()
    while time.time() - start_time < wait_time:
        if ser.in_waiting > 0:
            response += ser.read(ser.in_waiting)
        time.sleep(0.01)
    
    return response.decode('ascii', errors='ignore')

def setup_nanovna_for_cable_measurement(ser, start_freq=1e6, stop_freq=300e6, points=201):
    print("Настройка NanoVNA для измерения кабеля...")
    
    commands = [
        f"sweep {int(start_freq)} {int(stop_freq)} {points}",
        "pause",
    ]
    
    for cmd in commands:
        response = send_command(ser, cmd, 0.5)
        if response:
            print(f"Ответ на {cmd}: {response.strip()}")
    
    time.sleep(1)

def get_s11_data(ser):
    print("Получение данных S11...")
    
    send_command(ser, "resume", 2)
    
    # Получаем данные частот
    freq_data = send_command(ser, "frequencies", 1)
    
    # Получаем данные S11
    s11_data = send_command(ser, "data 0", 1)  # S11 - reflection
    
    return freq_data, s11_data

def parse_frequency_data(data):
    frequencies = []
    lines = data.strip().split('\n')
    
    for line in lines:
        line = line.strip()
        if line and not line.startswith('ch>'):
            try:
                parts = line.split()
                for part in parts:
                    freq = float(part)
                    frequencies.append(freq)
            except ValueError:
                continue
    
    return frequencies

def parse_s11_data(data):
    s11_points = []
    lines = data.strip().split('\n')
    
    for line in lines:
        line = line.strip()
        if line and not line.startswith('ch>'):
            try:
                parts = line.split()
                if len(parts) >= 2:
                    real = float(parts[0])
                    imag = float(parts[1])
                    s11_points.append((real, imag))
            except ValueError:
                continue
    
    return s11_points

def calculate_phase(s11_points):
    phases = []
    for real, imag in s11_points:
        phase = np.arctan2(imag, real)  # Фаза в радианах
        phases.append(phase)
    return phases

def calculate_vswr(s11_points):
    vswr_values = []
    for real, imag in s11_points:
        magnitude = np.sqrt(real**2 + imag**2)
        if magnitude < 1:
            vswr = (1 + magnitude) / (1 - magnitude)
        else:
            vswr = 100  # Большое значение для плохого КСВ
        vswr_values.append(vswr)
    return vswr_values

def find_cable_length(frequencies, phases, vswr_values, vf=0.66):
    """
    Определение длины кабеля по фазовому сдвигу
    vf - коэффициент укорочения (velocity factor)
    """
    # Находим пики в КСВ (минимумы отражения)
    peaks, _ = find_peaks(-np.array(vswr_values), prominence=0.1)
    
    if len(peaks) < 2:
        print("Не удалось найти достаточное количество резонансов")
        return None, None
    
    # Берем первые два резонансных пика
    peak1_idx = peaks[0]
    peak2_idx = peaks[1]
    
    freq1 = frequencies[peak1_idx]
    freq2 = frequencies[peak2_idx]
    
    # Разность частот между соседними резонансами
    delta_f = abs(freq2 - freq1)
    
    # Длина кабеля: L = c / (2 * delta_f * vf)
    c = 3e8  # Скорость света м/с
    cable_length = c / (2 * delta_f * vf)
    
    # Альтернативный метод: по фазовому сдвигу
    phase_slope = np.polyfit(frequencies, phases, 1)[0]  # Наклон фазы
    electrical_length = -phase_slope * c / (4 * np.pi * vf)
    
    return cable_length, electrical_length, delta_f, freq1, freq2

def plot_cable_measurement(frequencies, phases, vswr_values, cable_length, delta_f):
    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10))
    
    print(f"\n=== РЕЗУЛЬТАТЫ ИЗМЕРЕНИЯ КАБЕЛЯ ===")
    print(f"Разность частот между резонансами: {delta_f/1e6:.2f} МГц")
    print(f"Расчетная длина кабеля: {cable_length:.2f} метров")
    print(f"Длина кабеля в сантиметрах: {cable_length * 100:.1f} см")

    # График 1: КСВ
    frequencies_mhz = [f / 1e6 for f in frequencies]
    ax1.plot(frequencies_mhz, vswr_values, 'b-', linewidth=2, label='КСВ')
    ax1.set_title('КСВ кабеля', fontsize=14, fontweight='bold')
    ax1.set_xlabel('Частота (МГц)', fontsize=12)
    ax1.set_ylabel('КСВ', fontsize=12)
    ax1.grid(True, alpha=0.3)
    ax1.legend()
    
    # График 2: Фаза
    phases_deg = [p * 180 / np.pi for p in phases]
    ax2.plot(frequencies_mhz, phases_deg, 'r-', linewidth=2, label='Фаза S11')
    ax2.set_title('Фаза коэффициента отражения', fontsize=14, fontweight='bold')
    ax2.set_xlabel('Частота (МГц)', fontsize=12)
    ax2.set_ylabel('Фаза (градусы)', fontsize=12)
    ax2.grid(True, alpha=0.3)
    ax2.legend()
    
    plt.tight_layout()
    plt.show()
    
def measure_cable_with_different_vf(ser):
    setup_nanovna_for_cable_measurement(ser, start_freq=1e6, stop_freq=500e6, points=501)
    
    freq_data, s11_data = get_s11_data(ser)
    frequencies = parse_frequency_data(freq_data)
    s11_points = parse_s11_data(s11_data)
    
    if not frequencies or not s11_points:
        print("Не удалось получить данные")
        return
    
    phases = calculate_phase(s11_points)
    vswr_values = calculate_vswr(s11_points)
    
    # Стандартные коэффициенты укорочения для разных кабелей
    cable_types = {
        "RG-58": 0.66,
        "RG-174": 0.66,
        "RG-213": 0.66,
        "LMR-400": 0.85,
        "Коаксиал с полиэтиленом": 0.66,
        "Коаксиал с тефлоном": 0.70,
        "Воздушный коаксиал": 0.80
    }
        
    print("\n=== РЕЗУЛЬТАТЫ ДЛЯ РАЗНЫХ ТИПОВ КАБЕЛЕЙ ===")
    for cable_type, vf in cable_types.items():
        length, _, delta_f, freq1, freq2 = find_cable_length(frequencies, phases, vswr_values, vf)
        if length:
            print(f"{cable_type} (VF={vf}): {length:.2f} м")

    # Используем средний коэффициент для построения графика
    vf = 0.66
    
    # Расчет длины с выбранным коэффициентом
    cable_length, electrical_length, delta_f, freq1, freq2 = find_cable_length(
        frequencies, phases, vswr_values, vf)
    
    if cable_length:
        plot_cable_measurement(frequencies, phases, vswr_values, cable_length, delta_f)
    else:
        print("Не удалось определить длину кабеля")

def main():
    ser = None
    try:
        ser = serial.Serial(
            port='COM3',
            baudrate=115200,
            timeout=2,
            write_timeout=2,
        )
        time.sleep(2)
        measure_cable_with_different_vf(ser)
        
    except Exception as e:
        print(f"Ошибка: {e}")
        import traceback
        traceback.print_exc()
        
    finally:
        if ser and ser.is_open:
            ser.close()

if __name__ == "__main__":
    main()

import serial
import time
import os
import subprocess
import math

try:
    import RPi.GPIO as GPIO
    RASPBERRY_PI = True
except ImportError:
    RASPBERRY_PI = False
    print("Предупреждение: RPi.GPIO не доступен")

class CableAnalyzer:
    def __init__(self):
        self.ser = None

    def send_command(self, command, wait_time=0.5):
        print(f"Отправка команды: {command}")
        try:
            self.ser.reset_input_buffer()
            self.ser.reset_output_buffer()
            
            self.ser.write((command + '\r\n').encode())
            time.sleep(wait_time)
            
            response = b''
            start_time = time.time()
            while time.time() - start_time < wait_time:
                if self.ser.in_waiting > 0:
                    response += self.ser.read(self.ser.in_waiting)
                time.sleep(0.01)
            
            return response.decode('ascii', errors='ignore').strip()
            
        except Exception as e:
            print(f"Ошибка при отправке команды: {e}")
            return ""

    def setup_nanovna(self, start_freq=1e6, stop_freq=300e6, points=201):
        print("Настройка NanoVNA для измерения кабеля...")
        test_response = self.send_command("info", 1)
        if not test_response or "ch>" not in test_response:
            print("Ошибка: NanoVNA не отвечает")
            return False
        commands = [
            f"sweep {int(start_freq)} {int(stop_freq)} {points}",
            "pause",
        ]
        for cmd in commands:
            response = self.send_command(cmd, 0.5)
            if response:
                print(f"Ответ: {response}")
        
        time.sleep(1)
        return True

    def get_s11_data(self):
        print("Получение данных S11...")
        self.send_command("resume", 2)
        freq_data = self.send_command("frequencies", 1)
        s11_data = self.send_command("data 0", 1)
        return freq_data, s11_data

    def parse_frequency_data(self, data):
        frequencies = []
        if not data:
            return frequencies
        lines = data.strip().split('\n')
        for line in lines:
            line = line.strip()
            if line and not line.startswith('ch>'):
                try:
                    parts = line.split()
                    for part in parts:
                        freq = float(part)
                        frequencies.append(freq)
                except ValueError:
                    continue
        return frequencies

    def parse_s11_data(self, data):
        s11_points = []
        if not data:
            return s11_points
        lines = data.strip().split('\n')
        for line in lines:
            line = line.strip()
            if line and not line.startswith('ch>'):
                try:
                    parts = line.split()
                    if len(parts) >= 2:
                        real = float(parts[0])
                        imag = float(parts[1])
                        s11_points.append((real, imag))
                except ValueError:
                    continue
        return s11_points

    def calculate_vswr(self, s11_points):
        vswr_values = []
        for real, imag in s11_points:
            magnitude = math.sqrt(real**2 + imag**2)
            if magnitude < 1:
                vswr = (1 + magnitude) / (1 - magnitude)
            else:
                vswr = 100
            vswr_values.append(vswr)
        return vswr_values

    def calculate_phase(self, s11_points):
        phases = []
        for real, imag in s11_points:
            phase = math.atan2(imag, real)
            phases.append(phase)
        return phases

    def find_peaks_simple(self, data, min_distance=5):
        peaks = []
        for i in range(min_distance, len(data) - min_distance):
            if (data[i] == max(data[i-min_distance:i+min_distance+1])):
                peaks.append(i)
        return peaks

    def find_cable_length(self, frequencies, phases, vswr_values, vf=0.66):
        if len(frequencies) < 10:
            print("Недостаточно данных для анализа")
            return None, None, None, None, None
        
        try:
            # Ищем минимумы в КСВ (используем обратные значения)
            inverse_vswr = [-v for v in vswr_values]
            peaks = self.find_peaks_simple(inverse_vswr, min_distance=10)
            
            if len(peaks) < 2:
                print("Не удалось найти резонансы, использую фазовый метод")
                # Простой фазовый метод
                phase_diff = phases[-1] - phases[0]
                freq_diff = frequencies[-1] - frequencies[0]
                if freq_diff > 0:
                    phase_slope = phase_diff / freq_diff
                    c = 3e8
                    electrical_length = -phase_slope * c / (4 * math.pi * vf)
                    return electrical_length, electrical_length, freq_diff/10, frequencies[0], frequencies[-1]
                return None, None, None, None, None
            
            # Берем первые два пика
            peak1_idx = peaks[0]
            peak2_idx = peaks[1]
            
            freq1 = frequencies[peak1_idx]
            freq2 = frequencies[peak2_idx]
            
            delta_f = abs(freq2 - freq1)
            
            if delta_f == 0:
                print("Нулевая разность частот")
                return None, None, None, None, None
                
            c = 3e8
            cable_length = c / (2 * delta_f * vf)
            
            # Фазовый метод как проверка
            phase_slope = (phases[-1] - phases[0]) / (frequencies[-1] - frequencies[0])
            electrical_length = -phase_slope * c / (4 * math.pi * vf)
            
            return cable_length, electrical_length, delta_f, freq1, freq2
            
        except Exception as e:
            print(f"Ошибка при расчете длины кабеля: {e}")
            return None, None, None, None, None

    def measure_cable(self):
        if not self.setup_nanovna(start_freq=1e6, stop_freq=500e6, points=101):
            return
        
        freq_data, s11_data = self.get_s11_data()
        if not freq_data or not s11_data:
            print("Не удалось получить данные от NanoVNA")
            return
        
        frequencies = self.parse_frequency_data(freq_data)
        s11_points = self.parse_s11_data(s11_data)
        
        if len(frequencies) < 10 or len(s11_points) < 10:
            print("Недостаточно данных для анализа")
            return
        
        phases = self.calculate_phase(s11_points)
        vswr_values = self.calculate_vswr(s11_points)
        
        cable_types = {
            "RG-58": 0.66,
            "RG-174": 0.66,
            "RG-213": 0.66,
            "LMR-400": 0.85,
            "Коаксиал с полиэтиленом": 0.66,
            "Коаксиал с тефлоном": 0.70,
        }
            
        print("\n" + "="*60)
        print("РЕЗУЛЬТАТЫ ИЗМЕРЕНИЯ КАБЕЛЯ")
        print("="*60)
        
        results = {}
        for cable_type, vf in cable_types.items():
            length, _, delta_f, freq1, freq2 = self.find_cable_length(
                frequencies, phases, vswr_values, vf)
            if length:
                results[cable_type] = length
                print(f"{cable_type:30} (VF={vf}): {length:.2f} м")
        
        # Основной результат
        vf = 0.66
        cable_length, electrical_length, delta_f, freq1, freq2 = self.find_cable_length(
            frequencies, phases, vswr_values, vf)
        
        if cable_length:
            self.print_detailed_results(cable_length, delta_f, frequencies, vswr_values)
            self.save_results(frequencies, s11_points, cable_length, results)
        else:
            print("Не удалось определить длину кабеля")

    def print_detailed_results(self, cable_length, delta_f, frequencies, vswr_values):
        print(f"\nОСНОВНЫЕ РЕЗУЛЬТАТЫ:")
        print(f"Разность частот между резонансами: {delta_f/1e6:.2f} МГц")
        print(f"Расчетная длина кабеля: {cable_length:.3f} метров")
        print(f"В сантиметрах: {cable_length * 100:.1f} см")
        
        print(f"\nДИАПАЗОН ИЗМЕРЕНИЙ:")
        print(f"Начальная частота: {frequencies[0]/1e6:.1f} МГц")
        print(f"Конечная частота: {frequencies[-1]/1e6:.1f} МГц")
        print(f"Количество точек: {len(frequencies)}")
        
        print(f"\nКАЧЕСТВО КАБЕЛЯ:")
        avg_vswr = sum(vswr_values) / len(vswr_values)
        min_vswr = min(vswr_values)
        max_vswr = max(vswr_values)
        print(f"Средний КСВ: {avg_vswr:.2f}")
        print(f"Минимальный КСВ: {min_vswr:.2f}")
        print(f"Максимальный КСВ: {max_vswr:.2f}")
        
        if avg_vswr < 1.5:
            print("Оценка: Отличное качество кабеля")
        elif avg_vswr < 2.0:
            print("Оценка: Хорошее качество кабеля")
        else:
            print("Оценка: Проверьте соединения и кабель")

    def save_results(self, frequencies, s11_points, cable_length, results):
        try:
            timestamp = time.strftime("%Y%m%d_%H%M%S")
            filename = f"cable_results_{timestamp}.txt"
            
            with open(filename, 'w', encoding='utf-8') as f:
                f.write("Результаты измерения кабеля NanoVNA\n")
                f.write(f"Время: {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
                f.write(f"Длина кабеля: {cable_length:.3f} м\n\n")
                
                f.write("Результаты для разных кабелей:\n")
                for cable_type, length in results.items():
                    f.write(f"{cable_type}: {length:.3f} м\n")
                
                f.write("\nИзмеренные данные:\n")
                f.write("Частота(МГц)\tReal\tImag\n")
                for i, (freq, point) in enumerate(zip(frequencies, s11_points)):
                    if i < len(s11_points):
                        f.write(f"{freq/1e6:.1f}\t{point[0]:.6f}\t{point[1]:.6f}\n")
            
            print(f"\nРезультаты сохранены в: {filename}")
            
        except Exception as e:
            print(f"Ошибка сохранения: {e}")

    def run(self):
        try:
            self.ser = serial.Serial('/dev/ttyACM0', 115200, timeout=1)
            time.sleep(2)
            self.ser.reset_input_buffer()
            self.ser.reset_output_buffer()
            print("Подключение к NanoVNA установлено")
            self.measure_cable()
            
        except serial.SerialException as e:
            print(f"Ошибка порта: {e}")
        except KeyboardInterrupt:
            print("\nИзмерение прервано")
        except Exception as e:
            print(f"Ошибка: {e}")
        finally:
            if self.ser and self.ser.is_open:
                self.ser.close()
                print("Порт закрыт")

if __name__ == "__main__":
    analyzer = CableAnalyzer()
    analyzer.run()