from serdes_validation_framework import get_instrument_controller # Auto-detects available hardware controller = get_instrument_controller() # For development/testing without hardware: os.environ['SVF_MOCK_MODE'] = '1' # For specific hardware testing: os.environ['SVF_MOCK_MODE'] = '0' # Example usage (works in both modes): controller.connect_instrument('GPIB::1::INSTR') response = controller.query_instrument('GPIB::1::INSTR', '*IDN?') print(f"Operating in {controller.get_mode()} mode") # 'mock' or 'real'

from serdes_validation_framework.protocols.ethernet_224g import ( Ethernet224GTestSequence, ComplianceSpecification ) # Initialize test sequence sequence = Ethernet224GTestSequence() # Run link training training_results = sequence.run_link_training_test( scope_resource="GPIB0::7::INSTR", pattern_gen_resource="GPIB0::10::INSTR" ) # Run compliance tests compliance_results = sequence.run_compliance_test_suite( scope_resource="GPIB0::7::INSTR", pattern_gen_resource="GPIB0::10::INSTR" ) print(f"Training status: {training_results.convergence_status}") print(f"Compliance status: {compliance_results.test_status}")

from serdes_validation_framework import ( create_validation_framework, auto_validate_signal, create_usb4_test_sequence ) from serdes_validation_framework.protocols.usb4 import ( USB4SignalMode, USB4TunnelingMode, USB4LinkState ) # Quick USB4 validation with automatic protocol detection results = auto_validate_signal( signal_data=usb4_signal_data, # Dual-lane signal data sample_rate=200e9, voltage_range=0.8, protocol_hint="usb4" ) print(f"Protocol detected: {results['protocol_type']}") print(f"Validation status: {results['validation_results'].overall_status.name}") # Advanced USB4 test sequence test_sequence = create_usb4_test_sequence(enable_thunderbolt=True) comprehensive_results = test_sequence.run_complete_sequence(usb4_signal_data) # Check tunneling validation for phase_result in comprehensive_results.phase_results: if phase_result.phase.name == 'TUNNELING': print(f"PCIe tunneling: {phase_result.metrics.get('pcie_tunnel_integrity', 'N/A')}") print(f"DisplayPort tunneling: {phase_result.metrics.get('displayport_tunnel_quality', 'N/A')}")

from serdes_validation_framework.protocols.pcie.constants import SignalMode from serdes_validation_framework.test_sequence.pcie_sequence import ( PCIeTestSequence, PCIeTestPhase, PCIeTestResult, PCIeTestSequenceConfig, LaneConfig, create_single_lane_nrz_test, create_multi_lane_pam4_test ) # Create a PCIe 6.0 test configuration for multi-lane PAM4 config = create_multi_lane_pam4_test( num_lanes=4, sample_rate=200e9, # 200 GSa/s bandwidth=100e9, # 100 GHz voltage_range=1.2, target_ber=1e-12 ) # Create a PCIe test sequence sequence = PCIeTestSequence(config) # Run complete test sequence with all phases result = sequence.run_complete_sequence(signal_data) # Check results if result.overall_status == PCIeTestResult.PASS: print("✅ PCIe 6.0 validation passed!") print(f"Total duration: {result.total_duration:.2f} seconds") # Check individual phase results for phase_result in result.phase_results: phase_name = phase_result.phase.name status = phase_result.status.name print(f"Phase {phase_name}: {status} ({phase_result.duration:.2f}s)") # Print key metrics for metric, value in phase_result.metrics.items(): print(f" - {metric}: {value}") else: print(f"❌ PCIe 6.0 validation failed: {result.overall_status.name}") # Access lane-specific results for lane_id, lane_results in result.lane_results.items(): print(f"Lane {lane_id} SNR: {lane_results.get('snr_db', 'N/A')} dB")

from serdes_validation_framework.data_analysis import PAM4Analyzer # Initialize analyzer analyzer = PAM4Analyzer({ 'time': time_data, 'voltage': voltage_data }) # Analyze signal levels = analyzer.analyze_level_separation() evm = analyzer.calculate_evm() eye = analyzer.analyze_eye_diagram() print(f"RMS EVM: {evm.rms_evm_percent:.2f}%") print(f"Worst Eye Height: {eye.worst_eye_height:.3f}")

# Mock mode provides realistic data simulation: def generate_pam4_waveform(): """Generate synthetic PAM4 data""" levels = np.array([-3.0, -1.0, 1.0, 3.0]) symbols = np.random.choice(levels, size=num_points) noise = np.random.normal(0, 0.05, num_points) return symbols + noise # Auto-switching between real/mock: def capture_waveform(scope): """Capture waveform data""" if scope.controller.get_mode() == 'mock': return generate_pam4_waveform() else: return scope.query_waveform()

from serdes_validation_framework import auto_validate_signal import numpy as np # Generate or load your signal data signal_data = { 0: {'voltage': np.random.randn(1000), 'time': np.linspace(0, 1e-6, 1000)}, 1: {'voltage': np.random.randn(1000), 'time': np.linspace(0, 1e-6, 1000)} } # Automatic protocol detection and validation results = auto_validate_signal( signal_data=signal_data, sample_rate=200e9, voltage_range=0.8, protocol_hint="usb4" # Optional hint ) print(f"Detected Protocol: {results['protocol_type']}") print(f"Validation Status: {results['status']}")

from serdes_validation_framework.visualization import USB4Visualizer # Create visualizer viz = USB4Visualizer() # Generate professional eye diagram with measurements eye_result = viz.plot_eye_diagram( signal_data, show_measurements=True, filename='usb4_eye_diagram.png' ) # Create interactive dashboard dashboard_result = viz.create_interactive_dashboard( test_results, filename='usb4_dashboard.html' ) # Analyze tunnel bandwidth bandwidth_result = viz.plot_tunnel_bandwidth( bandwidth_data, filename='tunnel_analysis.png' )

from serdes_validation_framework.stress_testing import LoopbackStressTest, create_stress_test_config # Create stress test configuration config = create_stress_test_config( protocol="USB4", num_cycles=1000, output_dir="usb4_stress_results" ) # Run stress test stress_test = LoopbackStressTest(config) results = stress_test.run_stress_test() # Analyze results print(f"Success Rate: {results.success_rate:.1%}") print(f"Max Degradation: {results.max_degradation:.1f}%") print(f"Final Eye Height: {results.final_eye_height:.4f}V") # Results automatically saved to CSV and plots generated

from serdes_validation_framework.test_sequence import PCIeTestSequencer from serdes_validation_framework.protocols.pcie import SignalMode # Initialize PCIe test sequencer (auto-detects mock/real mode) sequencer = PCIeTestSequencer() # Connect to instruments sequencer.setup_instruments([ 'GPIB::1::INSTR', # Oscilloscope 'GPIB::2::INSTR' # Pattern generator ]) # Run a simple test sequence results = sequencer.run_sequence([ {'command': 'configure_scope', 'params': {'bandwidth': 100e9}}, {'command': 'capture_data', 'params': {'duration': 1.0}}, {'command': 'analyze_signal', 'params': {'mode': SignalMode.PAM4}} ]) print(f"Test completed: {results['status']}")

# Start the API server from serdes_validation_framework.api import create_app import uvicorn app = create_app() uvicorn.run(app, host="0.0.0.0", port=8000) # Or use the CLI # python -m serdes_validation_framework.api.cli server --host 0.0.0.0 --port 8000

# Use the API client import requests import numpy as np # Analyze eye diagram via API signal_data = np.random.randn(1000) * 0.4 response = requests.post("http://localhost:8000/api/v1/eye-diagram/analyze", json={ "signal_data": signal_data.tolist(), "sample_rate": 40e9, "protocol": "USB4", "show_mask": True }) result = response.json() print(f"Eye Height: {result['eye_height']:.4f}V") print(f"Q-Factor: {result['q_factor']:.2f}") print(f"Mask Compliance: {result['mask_analysis']['compliance_level']}") # Start stress test asynchronously stress_response = requests.post("http://localhost:8000/api/v1/stress-test/start", json={ "protocol": "USB4", "num_cycles": 100, "cycle_duration": 1.0 }) test_id = stress_response.json()["test_id"] # Monitor test progress status_response = requests.get(f"http://localhost:8000/api/v1/test/{test_id}/status") print(f"Test Status: {status_response.json()['status']}")