如何在GRC流图模块间用Python处理64元素向量并实现相位解包？

Got it, let’s walk through exactly how to implement your custom Python processing between those GNU Radio Companion (GRC) modules. Here’s a straightforward, step-by-step breakdown tailored to your requirements:

• Open your existing GRC flowgraph, search for the Python Block in the library panel, and drag it onto the canvas — place it directly between the Complex to Mag Phase module and the QT GUI Time Sink.
• Double-click the Python Block to open its configuration window.

In the block’s settings tab, set these parameters to align with your data stream:

• Input Type: Select vector of float (since Complex to Mag Phase outputs magnitude and phase as float vectors; adjust if your setup uses a different data type).
• Vector Length: Set to 64 to match your chunk size.
• Output Type: Configure two separate vector outputs (one for processed magnitude, one for unwrapped phase) — this lets you feed each signal to a separate channel in the time sink.

Switch to the Code tab in the Python Block config and replace the default template with this code, which handles your required operations:

import numpy as np

class blk(gr.sync_block):
    """Custom block to process 64-element mag/phase vectors:
    - Applies square root to each magnitude sample
    - Performs phase unwrapping on the phase vector
    """
    def __init__(self):
        gr.sync_block.__init__(
            self,
            name='Mag/Phase Custom Processor',  # Name that shows up in GRC
            in_sig=[(np.float32, 64), (np.float32, 64)],  # 2 input vectors: mag, phase
            out_sig=[(np.float32, 64), (np.float32, 64)]  # 2 output vectors: processed mag, unwrapped phase
        )

    def work(self, input_items, output_items):
        # Grab the input vectors
        mag_input = input_items[0]
        phase_input = input_items[1]
        
        # Process magnitude: element-wise square root
        processed_mag = np.sqrt(mag_input)
        
        # Process phase: unwrap each 64-element vector
        unwrapped_phase = np.unwrap(phase_input, axis=1)  # Axis=1 targets each 64-element chunk
        
        # Assign outputs to the block's output buffers
        output_items[0][:] = processed_mag
        output_items[1][:] = unwrapped_phase
        
        # Return the number of items processed (matches input count)
        return len(output_items[0])

Quick notes on the code:

• in_sig matches the two outputs from Complex to Mag Phase (magnitude first, then phase).
• Replace np.sqrt() with any element-wise math operation you need (e.g., np.square() for squaring, np.log10() for log magnitude).
• np.unwrap() handles phase unwrapping automatically — the axis=1 ensures we process each 64-element vector individually.

• Connect the Complex to Mag Phase magnitude output to the first input of your custom Python Block.
• Connect the phase output to the second input of the Python Block.
• Connect the first output (processed magnitude) to one channel of the QT GUI Time Sink.
• Connect the second output (unwrapped phase) to another channel of the time sink.

• Run your flowgraph to confirm the processed magnitude and unwrapped phase display correctly in the time sink.
• If you need to tweak the math operation, just modify the line handling processed_mag.
• If phase unwrapping isn’t behaving as expected, adjust the axis parameter in np.unwrap() (though axis=1 should work for 64-element chunks).

内容的提问来源于stack exchange，提问作者Hassaan Ahmad