A GPU-based radar electronic countermeasure intermediate frequency data pulse batch recognition and edge detection method

Abstract

The application discloses a GPU-based radar electronic countermeasure intermediate frequency data pulse batch identification and edge detection method, which rapidly searches pulse segmentation flag bits in batch intermediate frequency data through a GPU, and generates a pulse segmentation index list; a hash mapping table of intermediate frequency data to the pulse segmentation index list is established, so that subsequent pulse envelope extraction and edge detection are facilitated; in the pulse envelope extraction process, envelope data is extracted according to pulse separation information by using GPU parallel calculation; a one-dimensional edge detection method is used for up and down edge detection of the pulse, so as to determine the starting and ending positions of the pulse. The application fully utilizes the parallel calculation capacity of the GPU, improves the efficiency and real-time performance of radar electronic countermeasure intermediate frequency data processing, realizes efficient identification and edge detection of the pulse, is suitable for processing large-scale data, and can meet the combat requirements of a high-performance radar electronic countermeasure system.

Description

Technical Field

[0001] This invention relates to the field of radar electronic countermeasures signal processing, and in particular to a GPU-based method for batch identification and edge detection of intermediate frequency data pulses in radar electronic countermeasures. Background Technology

[0002] In radar electronic countermeasures systems, pulse detection and identification of intermediate frequency (IF) data is a crucial step. IF data is a digital signal obtained by sampling radar target signals received by the radar electronic countermeasures system at an intermediate frequency. It contains the individual characteristics and radiation parameters of the target radar radiation source. By performing pulse detection and identification on the IF data, the presence of the target radar can be determined and its attributes analyzed. Traditional CPU processing methods suffer from slow processing speed and poor real-time performance, making it difficult to meet the operational requirements of high-performance radar electronic countermeasures systems. Summary of the Invention

[0003] The purpose of this invention is to propose a GPU-based method for batch identification and edge detection of intermediate frequency data pulses in radar electronic countermeasures, so as to improve the efficiency and real-time performance of radar electronic countermeasures signal processing.

[0004] The technical solution to achieve the objective of this invention is: a GPU-based method for batch identification and edge detection of intermediate frequency data pulses in radar electronic countermeasures, comprising the following steps:

[0005] Step 1, Generate Pulse Segmentation Index List: Use the GPU to quickly find the pulse segmentation flag bits in the batch intermediate frequency data and generate a pulse segmentation index list in sequence;

[0006] Step 2, establish a hash mapping table from intermediate frequency data to the pulse segmentation index list: establish an equal-length hash mapping table for the input intermediate frequency data, where each position in the table represents the position of the pulse data at that point in the pulse segmentation index list;

[0007] Step 3, Pulse envelope extraction: Based on the pulse separation information and pulse width, the pulse is dynamically divided into multiple sub-intervals. A GPU thread is started for each sub-interval to calculate its maximum value as the envelope value.

[0008] Step 4, Pulse rising and falling edge detection: After the pulse envelope is extracted, the rising and falling edges of the pulse are detected using a one-dimensional edge detection method to determine the start and end positions of the pulse.

[0009] Further, in step 1, generating a pulse segmentation index list: The GPU is used to quickly locate the pulse segmentation flags in the batch of intermediate frequency data and generate a pulse segmentation index list in sequence. The specific method is as follows:

[0010] Step 1-1: Copy the real-time received batch intermediate frequency data from CPU memory to GPU memory, with a data length of if_lens;

[0011] Step 1-2: Generate the initial pulse segmentation index list if_seg_idx according to the minimum pulse width limit pw_min, with the following formula:

[0012] if_seg_idx=zeros(if_lens / / pw_min)

[0013] In the formula, if_seg_idx is an array of all zeros with a length of if_lens / / pw_min;

[0014] Steps 1-3: Start a GPU thread for each intermediate frequency data point in the GPU;

[0015] Steps 1-4: In each thread, check if the point is a pulse segmentation flag;

[0016] Steps 1-5: If so, record its index in the pulse segmentation index list;

[0017] if_seg_idx[thread_idx / / pw_min]=thread_idx

[0018] Steps 1-6: Only keep the non-zero values ​​in if_seg_idx.

[0019] Further, in step 2, a hash mapping table is established from the intermediate frequency data to the pulse segmentation index list: An equal-length hash mapping table for pulse segmentation points is established for the input intermediate frequency data. Each position in the table represents the position of that pulse data point in the pulse segmentation index list. The specific method is as follows:

[0020] Step 2-1: Create an array of the same length as the input intermediate frequency data, called the hash map table if_seg_idx_hash_map of intermediate frequency data to pulse segmentation index list;

[0021] Step 2-2: Initialize if_seg_idx_hash_map to 0;

[0022] Steps 2-3: Traverse the pulse segmentation index list if_seg_idx and set the data at the corresponding position in the hash mapping table if_seg_idx_hash_map of the pulse segmentation index list to 1;

[0023] Steps 2-4: Using GPU parallel computing, the hash mapping table if_seg_idx_hash_map from the intermediate frequency data to the pulse segmentation index list is summed to calculate the actual index of each pulse segmentation point.

[0024] Further, in step 3, pulse envelope extraction: based on the pulse segmentation information and pulse width, the pulse is dynamically divided into multiple sub-intervals. A GPU thread is started for each sub-interval, and its maximum value is calculated as the envelope value. The specific method is as follows:

[0025] Step 3-1: Determine the start and end positions of each pulse based on the pulse segmentation index list;

[0026] Step 3-2: For each pulse, divide it into 512 sub-intervals;

[0027] Step 3-3: Start a GPU thread for each sub-interval, calculate the maximum value of the intermediate frequency data within the interval in parallel, and use it as the envelope value of that interval.

[0028] Further, in step 4, pulse rising and falling edge detection: After the pulse envelope is extracted, a one-dimensional edge detection method is used to detect the rising and falling edges of the pulse to determine the start and end positions of the pulse. The specific method is as follows:

[0029] Step 4-1: For each segmented pulse envelope one-dimensional signal, establish a GPU sub-thread;

[0030] Step 4-2: In each sub-thread, perform edge detection on the one-dimensional pulse envelope signal;

[0031] Step 4-3: Using a differential algorithm, when a signal transition from low to high or from high to low is detected, the position is recorded as the rising and falling edges of the pulse, thereby determining the start and end positions of the pulse.

[0032] Step 4-4: Post-process the positions of the top and bottom edges.

[0033] Furthermore, before the data is copied to GPU memory, the batch of intermediate frequency data received in real time is preprocessed, including noise removal, filtering, or signal enhancement.

[0034] Furthermore, pulse envelope extraction is performed using Fourier transform or wavelet transform to extract the signal envelope, and a sliding window function is used to smooth the signal.

[0035] Furthermore, one-dimensional edge detection uses first- or second-order difference methods to detect signal changes, or uses convolution algorithms to find the rising and falling edges of the signal.

[0036] Furthermore, post-processing is performed on the upper and lower edge positions, including removing duplicate edges, using filters to remove noise or smooth edge positions, and using pattern recognition or machine learning algorithms to further optimize the pulse detection results.

[0037] A GPU-based radar electronic countermeasures intermediate frequency data pulse batch identification and edge detection system is provided, which implements the GPU-based radar electronic countermeasures intermediate frequency data pulse batch identification and edge detection method to achieve GPU-based radar electronic countermeasures intermediate frequency data pulse batch identification and edge detection.

[0038] Compared with existing technologies, the significant advantages of this invention are: by fully utilizing the parallel computing power of GPUs, it improves the efficiency and real-time performance of intermediate frequency data processing in radar electronic countermeasures, achieving efficient pulse identification and edge detection. This method exhibits significant performance advantages when processing large-scale data, meeting the requirements of high-performance radar electronic countermeasures systems. Attached Figure Description

[0039] Figure 1 This is the overall flowchart. Implementation

[0040] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0041] This invention relates to a GPU-based method and system for batch identification and edge detection of intermediate frequency data pulses in radar electronic countermeasures. The specific steps are as follows:

[0042] Step 1: Generate a pulse segmentation index list:

[0043] Step 1-1: Copy the real-time received batch intermediate frequency data from CPU memory to GPU memory, with a data length of if_lens;

[0044] Step 1-2: Generate the initial pulse segmentation index list if_seg_idx according to the minimum pulse width limit pw_min.

[0045] if_seg_idx=zeros(if_lens / / pw_min)

[0046] Steps 1-3: Start a GPU thread for each intermediate frequency data point in the GPU;

[0047] Steps 1-4: In each thread, check if the point is a pulse segmentation flag;

[0048] Steps 1-5: If so, record its index in the pulse segmentation index list;

[0049] if_seg_idx[thread_idx / / pw_min]=thread_idx

[0050] Steps 1-6: Only keep the non-zero values ​​in if_seg_idx.

[0051] Step 2: Establish a hash mapping table from intermediate frequency data to the pulse segmentation index list:

[0052] Step 2-1: Create an array of the same length as the input intermediate frequency data, called the hash map table if_seg_idx_hash_map of intermediate frequency data to pulse segmentation index list;

[0053] Step 2-2: Initialize if_seg_idx_hash_map to 0;

[0054] Steps 2-3: Traverse the pulse segmentation index list if_seg_idx and set the data at the corresponding position in the hash mapping table if_seg_idx_hash_map of the pulse segmentation index list to 1;

[0055] Steps 2-4: The hash map table if_seg_idx_hash_map from the intermediate frequency data to the pulse segmentation index list is summed using GPU parallel computing, and then the actual index of each pulse segmentation point is calculated.

[0056] Step 3: Pulse envelope extraction;

[0057] Step 3-1: Determine the start and end positions of each pulse based on the pulse segmentation index list;

[0058] Step 3-2: For each pulse, divide it into 512 sub-intervals;

[0059] Step 3-3: A GPU thread is launched for each sub-interval to calculate the maximum value of the intermediate frequency data within that interval and use it as the envelope value for that interval. This step, through parallel processing, significantly improves the efficiency of envelope extraction. This step extracts the intensity variation characteristics of each pulse, providing crucial signal features for pulse rising and falling edge detection.

[0060] Step 4: Pulse rising and falling edge detection:

[0061] Step 4-1: For each segmented pulse envelope one-dimensional signal, establish a GPU sub-thread;

[0062] Step 4-2: In each sub-thread, perform edge detection on the one-dimensional pulse envelope signal;

[0063] Step 4-3: Using differential algorithms or other one-dimensional signal processing methods, when a signal transition from low to high or from high to low is detected, record the position as the upper and lower edges of the pulse. By using one-dimensional edge detection, the upper and lower edge positions of the pulse can be effectively detected, thereby determining its start and end positions.

[0064] Step 4-4: Perform post-processing on the upper and lower edge positions as needed, such as removing duplicate edges or performing filtering, to improve the accuracy and stability of detection.

[0065] Preferably, preprocessing of the intermediate frequency (IF) data: In step 1, preprocessing of the batch of IF data received in real time can be considered, such as noise removal, filtering, or signal enhancement, to improve the accuracy and efficiency of subsequent processing steps. This can be completed before the data is copied to GPU memory to ensure the quality and stability of the processed data.

[0066] Preferably, step 3 mentions the extraction of the pulse envelope. Fourier transform or wavelet transform can be used to extract the signal envelope. Alternatively, a sliding window or other window function can be used to smooth the signal to reduce noise interference.

[0067] Preferably, step 4 mentions a one-dimensional edge detection method to determine the start and end positions of the pulse. First-order or second-order difference methods can be used to detect signal changes, or convolution algorithms or other digital signal processing techniques can be considered to find the rising and falling edges of the signal.

[0068] Preferably, as mentioned in step 4-4, post-processing of the upper and lower edge positions can be performed. Filters can be used to remove noise or smooth the edge positions. Alternatively, pattern recognition or machine learning algorithms can be used to further optimize the pulse detection results.

[0069] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0070] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are specific and detailed, they should not be construed as limiting the scope of this application. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these modifications and improvements all fall within the protection scope of this application. Therefore, the protection scope of this application should be determined by the appended claims.

Claims

1. A GPU-based method for batch identification and edge detection of intermediate frequency data pulses in radar electronic countermeasures, characterized in that, Includes the following steps: Step 1, Generate Pulse Segmentation Index List: Use the GPU to quickly find the pulse segmentation flag bits in the batch intermediate frequency data and generate a pulse segmentation index list in sequence; Step 2, establish a hash mapping table from intermediate frequency data to the pulse segmentation index list: establish an equal-length hash mapping table for the input intermediate frequency data, where each position in the table represents the position of the pulse data at that segmentation point in the pulse segmentation index list; Step 3, Pulse envelope extraction: Based on the pulse separation information and pulse width, the pulse is dynamically divided into multiple sub-intervals. A GPU thread is started for each sub-interval to calculate its maximum value as the envelope value. Step 4, Pulse rising and falling edge detection: After the pulse envelope is extracted, the rising and falling edges of the pulse are detected using a one-dimensional edge detection method to determine the start and end positions of the pulse. in: Step 1, Generate Pulse Segmentation Index List: Use the GPU to quickly find the pulse segmentation flags in the batch of intermediate frequency data and generate a pulse segmentation index list in sequence. The specific method is as follows: Step 1-1: Copy the real-time received batch intermediate frequency data from CPU memory to GPU memory, with a data length of if_lens; Step 1-2: Generate the initial pulse segmentation index list if_seg_idx according to the minimum pulse width limit pw_min, with the following formula: ； In the formula, if_seg_idx is an array of all zeros with a length of if_lens / / pw_min; Steps 1-3: Start a GPU thread for each intermediate frequency data point in the GPU; Steps 1-4: In each thread, check if the point is a pulse segmentation flag; Steps 1-5: If so, record its index in the pulse segmentation index list; ； Steps 1-6: Only keep the non-zero values ​​in if_seg_idx; Step 2, establish a hash mapping table from intermediate frequency (IF) data to the pulse segmentation index list: For the input IF data, establish an equal-length hash mapping table for pulse segmentation points. Each position in the table represents the position of the pulse data at that segmentation point in the pulse segmentation index list. The specific method is as follows: Step 2-1: Create an array of the same length as the input intermediate frequency data, called the hash map table if_seg_idx_hash_map of intermediate frequency data to pulse segmentation index list; Step 2-2: Initialize if_seg_idx_hash_map to 0; Steps 2-3: Traverse the pulse segmentation index list if_seg_idx and set the data at the corresponding position in the hash mapping table if_seg_idx_hash_map of the pulse segmentation index list to 1; Steps 2-4: Using GPU parallel computing, the hash mapping table if_seg_idx_hash_map from the intermediate frequency data to the pulse segmentation index list is summed to calculate the actual index of each pulse segmentation point; Step 3, Pulse Envelope Extraction: Based on the pulse segmentation information and pulse width, the pulse is dynamically divided into multiple sub-intervals. A GPU thread is started for each sub-interval, and its maximum value is calculated as the envelope value. The specific method is as follows: Step 3-1: Determine the start and end positions of each pulse based on the pulse segmentation index list; Step 3-2: For each pulse, divide it into 512 sub-intervals; Step 3-3: Start a GPU thread for each sub-interval, calculate the maximum value of the intermediate frequency data within the interval in parallel, and use it as the envelope value of that interval; Step 4, Pulse Rising and Falling Edge Detection: After the pulse envelope is extracted, the rising and falling edges of the pulse are detected using a one-dimensional edge detection method to determine the start and end positions of the pulse. The specific method is as follows: Step 4-1: For each segmented pulse envelope one-dimensional signal, establish a GPU sub-thread; Step 4-2: In each sub-thread, perform edge detection on the one-dimensional pulse envelope signal; Step 4-3: Using a differential algorithm, when a signal transition from low to high or from high to low is detected, the position is recorded as the rising and falling edges of the pulse, thereby determining the start and end positions of the pulse. Step 4-4: Post-process the positions of the top and bottom edges.

2. The GPU-based method for batch identification and edge detection of intermediate frequency data pulses in radar electronic countermeasures according to claim 1, characterized in that, Before the data is copied to GPU memory, the batch of intermediate frequency data received in real time is preprocessed, including noise removal, filtering, or signal enhancement.

3. The GPU-based method for batch identification and edge detection of intermediate frequency data pulses in radar electronic countermeasures according to claim 1, characterized in that, Pulse envelope extraction uses Fourier transform or wavelet transform to extract the signal envelope and a sliding window function to smooth the signal.

4. The GPU-based method for batch identification and edge detection of intermediate frequency data pulses in radar electronic countermeasures according to claim 1, characterized in that, One-dimensional edge detection uses first- or second-order difference methods to detect signal changes, or uses convolution algorithms to find the rising and falling edges of the signal.

5. The GPU-based method for batch identification and edge detection of intermediate frequency data pulses in radar electronic countermeasures according to claim 1, characterized in that, Post-processing is performed on the top and bottom edges. This includes removing repetitive edges, using filters to remove noise or smooth edge locations, and using pattern recognition or machine learning algorithms to further optimize pulse detection results.

6. A GPU-based radar electronic countermeasures intermediate frequency data pulse batch identification and edge detection system, characterized in that, Implement the GPU-based radar electronic countermeasures intermediate frequency data pulse batch identification and edge detection method according to any one of claims 1-5, and realize GPU-based radar electronic countermeasures intermediate frequency data pulse batch identification and edge detection.

Images