Demodulation and Code Rate Estimation Methods for OQPSK Signals under Non-cooperative Conditions

Abstract

This invention discloses a method for demodulation and code rate estimation of OQPSK signals under non-cooperative conditions: Frequency offset estimation is performed on the IQ sampled data sequence corresponding to the OQPSK signal, residual frequency components are eliminated, and the frequency offset estimation result is output. Based on the frequency offset estimation result, phase adjustment and alignment are performed on the IQ sampled data. The Fourier transform length and filter length are set to coarsely estimate the signal code rate, and the coarse code rate estimation result is output. Based on the output coarse code rate estimation result, data is selected from the starting position of the IQ sampled data as the demodulation starting sequence. The starting sequence is adjusted according to the minimum entropy characteristic criterion, and the starting demodulation result and the corresponding fine code rate estimation result are output. The remaining IQ sampled data is segmented, and each segment is demodulated sequentially, outputting the demodulation result of each segment and the corresponding fine code rate estimation result. This method tracks and eliminates frequency offset and symbol rate estimation errors, reduces demodulation loss, and achieves integrated demodulation and estimation design.

Description

Technical Field

[0001] This application relates to the technical field of non-cooperative signal processing, and in particular to a method for demodulating OQPSK signals and estimating code rate under non-cooperative conditions. Background Technology

[0002] In traditional cooperative communication systems, both parties know the system's modulation parameters and frame structure before transmitting information. Non-cooperative communication, on the other hand, refers to the unauthorized interception and demodulation of transmitted signals by a third party. Non-cooperative communication generally lacks the sender's prior information and relies heavily on modern signal processing techniques, using blind demodulation to analyze and process the intercepted signal in an attempt to obtain the transmitted information. Non-cooperative signal processing has wide applications in many communication scenarios: for example, government departments monitor civilian communication systems to prevent illegal use of spectrum resources and wireless interference to ensure the rational use of these resources; in the field of military electronic warfare, non-cooperative signal processing is widely used for threat identification, interception of enemy intelligence, and electronic countermeasures. Therefore, blind demodulation and parameter estimation of non-cooperative communication signals are crucial steps in the reception and processing of non-cooperative communication signals.

[0003] Offset Quadrature Phase Shift Keying (OQPSK) modulation is an improvement upon Quadrature Phase Shift Keying (QPSK) modulation. Compared to QPSK signals, OQPSK delays the quadrature components, separating them from the in-phase components by half a symbol period. Therefore, the phase of an OQPSK signal only fluctuates by ±π / 2 within one symbol period. The envelope ripple of a band-limited OQPSK signal is smaller than that of QPSK modulation, and it does not cause power spectrum sidelobe growth when passed through a nonlinear power amplifier. Due to its superior spectral characteristics compared to QPSK, OQPSK modulation is widely used in satellite and mobile communication systems, making its detection and demodulation research of significant practical importance. Currently, commonly used demodulation methods are divided into coherent demodulation and incoherent demodulation. Coherent demodulation requires precise knowledge of the carrier frequency and initial phase, making it unsuitable for non-cooperative scenarios. Traditional noncoherent demodulation algorithms first require estimating various signal parameters, including carrier frequency, symbol rate, timing, and decimation parameters. Based on these estimates, they then perform timing decimation and frequency determination of the sequence. A drawback of this traditional approach is that the accuracy of the back-end sequence decimation is significantly affected by errors in the preceding parameter estimation stages. For example, noise or errors in symbol rate estimation can significantly impact sequence extraction and timing; or the presence of time-varying Doppler shifts can cause the algorithm to fail due to the influence of the remaining carrier frequency. These issues limit the effectiveness of traditional noncoherent demodulation in practical adversarial scenarios. Summary of the Invention

[0004] This application provides a method for demodulation and code rate estimation of OQPSK signals under non-cooperative conditions. The invention first adjusts the initial frequency offset and phase of the signal, then performs a coarse estimation of the code rate based on the signal bandwidth distribution. Based on the coarse estimation result, the signal is jointly processed for demodulation and fine code rate estimation, achieving accurate code rate estimation while obtaining the demodulated sequence. This method combines demodulation and parameter estimation, tracking and eliminating errors in frequency offset and symbol rate estimation, avoiding demodulation losses caused by error accumulation in traditional noncoherent demodulation, and achieving an integrated design of demodulation and parameter estimation.

[0005] Firstly, a method for demodulating OQPSK signals and estimating code rate under non-cooperative conditions is provided, including:

[0006] Receive the OQPSK signal to be processed, perform digital sampling and IQ conversion to baseband, and select the baseband data IQ. 1*N The first M data points are used, and the frequency measurement range is set. Frequency estimation is completed by frequency search, and the frequency offset estimation result FreErr is output.

[0007] Based on the frequency offset estimation result FreErr, a frequency search vector is generated, and the IQ sampled data is phase-adjusted and aligned according to the vector.

[0008] Set the Fourier transform length FFT_M and the filter length Filt_M, take the first FFT_M data of the phase-adjusted and aligned IQ data, perform Fourier transform on the taken data, and calculate the code rate based on the transformed spectrum to roughly estimate SamN_Rough.

[0009] Set the number of initial module symbols AccSymN, and based on the coarse code rate estimate SamN_Rough, select elements of a set length from the IQ sampled data as the demodulation start sequence; adjust the start sequence according to the minimum entropy feature criterion, and output the initial demodulation result and the corresponding fine code rate estimate result SamN_Good;

[0010] The remaining IQ sampled data is segmented, and each segment is demodulated sequentially. The data to be demodulated is adjusted near the SamN_Good result of the previous segment's code rate fine estimation. The demodulation result and the corresponding code rate fine estimation result are output based on the criterion of minimizing the demodulated sequence entropy. After all segments are demodulated, the code rate fine estimation results of each segment are averaged and the final code rate estimation result is output.

[0011] In conjunction with the first aspect, in some implementations of the first aspect, the calculation steps for the frequency offset estimation result FreErr are as follows:

[0012] S1.1: The OQPSK baseband data after digital sampling and IQ conversion is recorded as IQ. 1*N The data sampling rate is Fs;

[0013] S1.2: Take the first M data points of IQ as the data header. Set the search threshold maxEntro, the minimum frequency search value minFreErr, the maximum frequency search value maxFreErr, and the frequency search step size FreErrStep. Initialize k=1, and set the histogram statistical point vector HistR=[h0,h1,...,h R ];

[0014] S1.3: Let FreErr_k = minFreErr + (k-1)*FreErrStep. If FreErr_k is not greater than maxFreErr, then for IQ Init Perform the following operations to generate a vector. Otherwise, proceed to step S1.8; where i is the imaginary part flag;

[0015] A = IQ Init (m)*exp(i*2π*FreErr_k / Fs*m)

[0016] Φ Init (m) = arctan(Im(A) / Re(A))

[0017] m = 0, 1, 2, ..., M-1

[0018] S1.4: Based on HistR, Φ Init Perform histogram statistics to obtain the statistical distribution Ba. 1*R The counting method is as follows, where num(·) represents the number of elements:

[0019] Ba(r)=num(HistR(r)≤Φ Init <HistR(r+1)), where r = 0, 1, 2, ..., R-1

[0020] S1.5: Normalize the sum of the elements in Ba and calculate the entropy value Entro of Ba;

[0021] S1.6: If Entro<maxEntro, then let maxEntro=Entro, FreErr=FreErr_k;

[0022] S1.7: k = k + 1, proceed to step S1.3;

[0023] S1.8: Complete frequency offset estimation and output FreErr.

[0024] In conjunction with the first aspect, in some implementations of the first aspect, the entropy value in step S1.5 is calculated as follows:

[0025]

[0026] In conjunction with the first aspect, in some implementations of the first aspect, the phase adjustment and alignment steps are as follows:

[0027] S2.1: Regarding IQ Init The elements in the sequence are adjusted, and a corresponding phase sequence Φ is generated based on the adjusted elements. Init The adjustment and calculation methods are as follows:

[0028] IQ Init (m)=IQ Init (m)*exp(i*2π*FreErr / Fs*m)

[0029] Φ Init (m)=arctan(Im(IQ Init (m)) / Re(IQ Init (m)))

[0030] m = 0, 1, 2, ..., M-1

[0031] S2.2: Calculate Φ Init The mean of all elements in the array is recorded as mean_phi, and the phase adjustment value Phi_Accmu is set to 0;

[0032] S2.3: Set the frequency search range FreErrRange and the frequency search step size FreErrStep, and initialize k=1;

[0033] S2.4: If the total number of data to be demodulated, N, is greater than or equal to (k+1)*M, then take the k*M+1 to (k+1)*M elements from IQ and record them as follows. If N is less than (k+1)*M, then proceed to step S2.10;

[0034] S2.5: Generate the frequency offset search vector FE based on FreErr, FreErrRange, and FreErrStep. 1*K1 The k1-th element in FE is FreErr - FreErrRange + k1 * FreErrStep, where This represents rounding up and initializing a vector of all zeros. make

[0035] Phi_Accmu=Phi_Accmu+2π*FreErr / Fs*M;

[0036] S2.6: Based on the elements in FE, pair IQ k Adjust and calculate the phase vector Φ k The adjustment method for the k1th element is as follows:

[0037] A m =IQ k (m)*exp(i*2π*FE(k1) / Fs*m)

[0038] Φ k (m)=arctan(Im(A m ) / Re(A m ))

[0039] m = 0, 1, 2, ..., M-1

[0040] According to HistR on Φ k Perform histogram statistics to obtain the statistical distribution Ba. 1*R The counting method is as follows, where num(·) represents the number of elements:

[0041] Ba(r)=num(HistR(r)≤Φ k <HistR(r+1)), where r = 0, 1, 2, ..., R-1

[0042] Calculate the entropy of Ba and assign it to Entro(k1);

[0043] S2.7: Repeat step S2.6 until all K1 elements in FE have been used, find the position of the minimum value in Entro, denoted as k. 1min Update FreErr = FE(k) 1min According to FreErr and Phi_Accmu, IQ k Make adjustments and calculate the phase vector Φ. k :

[0044] IQ k (m)=IQ k (m)*exp(i*2π*FreErr / Fs*m)*exp(i*Phi_Accmu)

[0045] Φ k (m)=arctan(Im(IQ k (m)) / Re(IQ k (m)))

[0046] m = 0, 1, 2, ..., M-1

[0047] S2.8: Calculate the mean phase vector, mean_phi_k, and apply mean_phi_k to IQ.k The following adjustments will be made:

[0048] IQ k (m)=IQ k (m)*exp(i*2π*(mean_phi-mean_phi_k))

[0049] m = 0, 1, 2, ..., M-1

[0050] S2.9: Let k = k + 1, then return to S2.4;

[0051] S2.10: The phase adjustment operation of the first to the k*Mth elements in IQ has been completed. If N>k*M, then discard the k*M+1 to the k*Mth elements in IQ and let N=k*M.

[0052] In conjunction with the first aspect, in some implementations of the first aspect, the steps for coarse code rate estimation are as follows:

[0053] S3.1: Set the Fourier transform length FFT_M and the filter length Filt_M, and take the first FFT_M data points of IQ as the code rate estimation sequence. For IQ FFT Perform a Fourier transform to obtain its spectrum IQf FFT :

[0054] IQf FFT =|fft(IQ FFT )|

[0055] S3.2: Generate a smoothing filter SFilt 1*Filt_M Each element in SFilt is 1 / Filt_M;

[0056] S3.3: IQ FFT Perform a convolution operation with SFilt, and take the Filt_M-th to FFT_M-th elements of the convolutioned sequence as the updated IQf. FFT At this time, IQf FFT The length becomes FFT_M - Filt_M + 1, for IQf FFT Take the logarithm:

[0057] IQf FFT =20*log10(IQf) FFT )

[0058] S3.4: Search IQf FFT The maximum value in the range is denoted as max_IQf, and IQf is searched using max_IQf-3 as the threshold. FFTFor all elements that exceed the threshold, record the position of the first element that exceeds the threshold as ind1 and the position of the last element that exceeds the threshold as ind2;

[0059] S3.5: Coarse estimation results of code rate SamN_Rough:

[0060] SamN_Rough=(FFT_M-Filt_M+1) / (ind2-ind1+1).

[0061] In conjunction with the first aspect, in some implementations of the first aspect, the calculation steps for the initial demodulation result are as follows:

[0062] S4.1: Set the number of initial module symbols to AccSymN, let AccN = AccSymN * SamN_Rough, and round AccN to ensure it is an integer. Select the first AccN elements of IQ as the frequency starting sequence. Set the maximum number of iterations k max ;

[0063] S4.2: Define the frequency histogram statistical point vector HistAm, HistAm = [hA0, hA1, ..., hA...]. M1 ];

[0064] S4.3: Set the variable sampling point range ±AccR, the variable sampling point number AccR_n1, and the variable synchronization number AccR_n2, and let k1 = 0;

[0065] S4.4: Define an all-zero two-dimensional matrix Entro AccR_n1*AccR_n2 Let i1 = 0;

[0066] S4.5: Let SamN_Rough_i1=SamN_Rough-AccR+2*AccR / (AccR_n1-1)*i1, let j1=0;

[0067] S4.6: Let SamN_Move_j1=j1 / (AccR_n2)*SamN_Rough_i1;

[0068] S4.7: Generate the selection sequence SampT_I based on SamN_Rough_i1 and SamN_Move_j1. 1*AccSymN and SampT_Q 1*AccSymN ;

[0069] S4.8: Using elements in SampT_I as indices from IQ Init Select the real part of the corresponding element from IQ, using the element in SampT_Q as the subscript. InitThe imaginary part of the corresponding element is selected from SampT_I and SampT_Q. Since the elements in SampT_I and SampT_Q are not integers, the selection rule is to start from I and Q. Init Select the element closest to the subscript index. For example, if the subscript index is -0.1, then select the element with index IQ. Init If the 0th element has an index of 1.9, then the 2nd element is selected, and so on. The final selected sequence is denoted as I_K. 1*AccSymN and Q_K 1*AccSymN And calculate the modulus sequence IQ_K based on I_K and Q_K. 1*AccSymN :

[0070]

[0071] S4.9: Calculate the mean of all elements in IQ_K, divide all elements in IQ_K by this mean, and perform histogram statistics on the adjusted IQ_K according to HistAm to obtain the statistical distribution BaAm. 1*M1 ,

[0072] BaAm(m1)=num(HistAm(m1)≤IQ_K<HistAm(m1+1)), m1=0,1,2,...,M1-1

[0073] Remove all elements with a value of 0 from BaAm. After the removal, the length of BaAm becomes M1′.

[0074] S4.10: Calculate the entropy value of BaAm and fill it into Entro(i1,j1);

[0075] S4.11: Let j1 = j1 + 1. If j1 = AccR_n2, then go to S4.12; otherwise go to S4.6.

[0076] S4.12: Let i1 = i1 + 1. If i1 = AccR_n1, then go to S4.13; otherwise, go to S4.5.

[0077] S4.13: Find the position of the minimum value in Entro and record its index as i. 1min and j 1min Calculate SamN_Move, and update SamN_Rough and AccR:

[0078] SamN_Rough=SamN_Rough-AccR+2*AccR / (AccR_n1-1)*i 1min

[0079] SamN_Move=j 1min / (AccR_n2)*SamN_Rough

[0080] AccR = AccR * 0.5

[0081] S4.14: Let k1 = k1 + 1, if k1 = k max If yes, then proceed to S4.15; otherwise, proceed to S4.4.

[0082] S4.15: Let SamN_Good=SamN_Rough, SamN_Move_Good=SamN_Move,

[0083] Generate the selection sequence SampT_I according to the method in S4.7. 1*AccSymN and SampT_Q 1*AccSymN And generate I_K according to the processing method in S4.8. 1*AccSymN and Q_K 1*AccSymN And calculate the modulus sequence IQ_K based on I_K and Q_K:

[0084]

[0085] S4.16: Calculate the mean of all elements in IQ_K, and divide I_K and Q_K by this mean. The I_K and Q_K after dividing by the mean are the initial demodulation results. SamN_Good is the accurate code rate estimate output by the demodulation start module. At the same time, SamN_Move_Good is output as the input variable of the subsequent modules.

[0086] In conjunction with the first aspect, in some implementations of the first aspect, step S4.7 selects the sequence SampT_I. 1 *AccSymN and SampT_Q 1*AccSymN The generation method is as follows:

[0087] SampT_I(n2)=SamN_Move_j1+n2*SamN_Rough_i1

[0088] SampT_Q(n2)=SamN_Move_j1+n2*SamN_Rough_i1+SamN_Rough_i1 / 2

[0089] n2 = 0, 1, 2, ..., AccSymN-1.

[0090] In conjunction with the first aspect, in some implementations of the first aspect, the steps of segment demodulation are as follows:

[0091] S5.1: Reset the variable sampling point range ±AccR, the variable sampling point number AccR_n1, and the variable synchronization number AccR_n2, setting Last_TT_end=0, K=0, and SamN_Good_All=0;

[0092] S5.2: SamN_Good_All = SamN_Good_All + SamN_Good, K = K + 1, update the value of Last_TT_end, and calculate the variables End_Idx and tt_mod;

[0093] S5.3: If the total number of elements in IQ is less than End_Idx + AccN, then the data demodulation process is complete, and proceed to S5.15; otherwise, select the elements from End_Idx to End_Idx + AccN-1 in IQ as the demodulation sequence for this current process, denoted as...

[0094] S5.4: Define an all-zero two-dimensional matrix Entro (2*AccR_n1+1)*(2*AccR_n2+1) Let i1 = 0;

[0095] S5.5: Let SamN_Rough_i1 = SamN_Good + (i1 - AccR_n1) / AccR_n1 * AccR, and let j1 = 0;

[0096] S5.6: Let SamN_Move_j1=(j1-AccR_n2) / AccR_n2*SamN_Rough_i1;

[0097] S5.7: Generate the selection sequence SampT_I based on SamN_Rough_i1 and SamN_Move_j1. 1*AccSymN and SampT_Q 1*AccSymN ;

[0098] S5.8: Using elements in SampT_I as indices from IQ Init Select the real part of the corresponding element from IQ, using the element in SampT_Q as the subscript. Init The imaginary part of the corresponding element is selected from the IQ values. Init The element closest to the subscript index is selected from the sequence, and the final selected sequence is denoted as I_K. 1*AccSymN and Q_K 1*AccSymN And calculate the modulus sequence IQ_K based on I_K and Q_K. 1 *AccSymN :

[0099]

[0100] S5.9: Calculate the mean of all elements in IQ_K, divide all elements in IQ_K by this mean, and perform histogram statistics on the adjusted IQ_K according to HistAm to obtain the statistical distribution BaAm. 1*M1 ,

[0101] BaAm(m1)=num(HistAm(m1)≤IQ_K<HistAm(m1+1))

[0102] m1 = 0, 1, 2, ..., M1-1

[0103] Remove all elements with a value of 0 from BaAm. After the removal, the length of BaAm becomes M1′.

[0104] S5.10: Calculate the entropy value of BaAm and fill it into Entro(i1,j1);

[0105] S5.11: Let j1 = j1 + 1. If j1 = 2 * AccR_n2 + 1, then go to S5.12; otherwise go to S5.6.

[0106] S5.12: Let i1 = i1 + 1. If i1 = 2 * AccR_n1 + 1, then go to S5.13; otherwise go to S5.5.

[0107] S5.13: Find the position of the minimum value in Entro and record its index as i. 1min and j 1min Update SamN_Good and SamN_Move_Good:

[0108] SamN_Good=SamN_Good+(i 1min -AccR_n1) / AccR_n1*AccR

[0109] SamN_Move_Good=(j 1min -AccR_n2) / AccR_n2*SamN_Good

[0110] Generate the selected sequence SampT_I using the updated values. 1*AccSymN and SampT_Q 1*AccSymN And generate I_K according to the processing method in S5.8. 1*AccSymN and Q_K 1*AccSymN And calculate the modulus sequence IQ_K based on I_K and Q_K:

[0111]

[0112] Calculate the mean of all elements in IQ_K, and divide I_K and Q_K by the mean. The I_K and Q_K after dividing by the mean are used as the output of the demodulation.

[0113] S5.14: Return to S5.2 and continue with the next demodulation;

[0114] S5.15: Calculate the code rate SamN = Fs * K / SamN_Good_All, and output the code rate SamN;

[0115] The generation methods for Last_TT_end, End_Idx, and tt_mod in step S5.2 are as follows:

[0116] Last_TT_end=Last_TT_end+SamN_Move_Good+SamN_Good*(AccSymN1-1)

[0117] End_Idx=floor(Last_TT_end)+1

[0118] tt_mod = End_Idx - Last_TT_end

[0119] `floor` is a function that rounds down to the nearest integer.

[0120] Compared with the prior art, the solution provided in this application has at least the following beneficial technical effects:

[0121] (1) The present invention integrates code rate estimation and demodulation, avoiding the error accumulation problem caused by the traditional noncoherent demodulation method of first estimating parameters and then demodulating based on the estimated parameters, thus reducing demodulation loss.

[0122] (2) Traditional methods only estimate the carrier frequency once at the start of demodulation, which cannot handle the case of time-varying Doppler frequency shift in the data. This method can effectively handle the above problems by frequency offset estimation and phase adjustment alignment, and is more suitable for application in actual combat scenarios. Attached Figure Description

[0123] Figure 1 This is a flowchart illustrating the overall process of the present invention.

[0124] Figure 2 This describes the IQ and spectral distribution of the acquired signal.

[0125] Figure 3 This is the initial demodulation result in step S4.

[0126] Figure 4 This represents the demodulation results of all remaining data from step S5.

[0127] Figure 5 This shows the data code rate distribution of each segment during the full demodulation process. Detailed Implementation

[0128] The present application will now be described in further detail with reference to the accompanying drawings and specific embodiments.

[0129] like Figure 1 As shown, this invention provides a method for demodulating and estimating the code rate of an OQPSK signal under non-cooperative conditions. This method first adjusts the initial frequency offset and phase of the signal, then performs a coarse estimation of the code rate based on the signal bandwidth distribution. Based on the coarse estimation result, the signal undergoes joint processing of demodulation and fine code rate estimation, achieving accurate estimation of the signal code rate while obtaining the demodulated sequence. The specific steps of this invention are further elaborated below.

[0130] Step S1: Receive the OQPSK signal to be processed, perform digital sampling and IQ conversion to baseband, and select the baseband data IQ. 1 *N The first M data points are used, and the frequency measurement range is set. Frequency estimation is completed by frequency search, and the frequency offset estimation result FreErr is output.

[0131] S1.1: The OQPSK baseband data after digital sampling and IQ conversion is recorded as IQ (e.g., Figure 2 As shown in the figure, the data sampling rate is Fs.

[0132] In Example 1, the sampling rate was 0.039063MHz, the IQ conversion center frequency was set to 1930097.6265Hz, the total sampling time was 29.422s, and a total of 1,149,312 IQ sampling data were recorded, N = 1,149,312.

[0133] S1.2: Take the first M data points of IQ as the data header. Set the search threshold `maxEntro`, the minimum frequency search value `minFreErr`, the maximum frequency search value `maxFreErr`, and the frequency search step size `FreErrStep`. Initialize k = 1, and set the histogram statistical point vector `HistR = [h0, h1, ..., h...]`. R ]

[0134] In Example 1, the first M = 3906 data points of IQ are taken as the data header IQ. Init Set the search threshold maxEntro to 1000, the frequency search minimum minFreErr to -1, the frequency search maximum maxFreErr to 1, and the frequency search step size FreErrStep to 0.002. Initialize k = 1, and set the histogram statistical point vector HistR = [-π, -π + π / 25, -π + 2*π / 25, ..., π].

[0135] S1.3: Let FreErr_k = minFreErr + (k-1)*FreErrStep. If FreErr_k is not greater than maxFreErr, then for IQ InitPerform the following operations to generate a vector. Otherwise, proceed to step S1.8; where i is the imaginary part flag, Im(A) is the imaginary part of the complex number A, and Re(A) is the real part of the complex number A.

[0136] A = IQ Init (m)*exp(i*2π*FreErr_k / Fs*m)

[0137] Φ Init (m) = arctan(Im(A) / Re(A))

[0138] m = 0, 1, 2, ..., M-1

[0139] S1.4: Based on HistR, Φ Init Perform histogram statistics to obtain the statistical distribution Ba. 1*R In Example 1, R = 51.

[0140] The statistical method for Ba is as follows, where num(·) represents the number of elements.

[0141] Ba(r)=num(HistR(r)≤Φ Init <HistR(r+1)), where r = 0, 1, 2, ..., R-1

[0142] S1.5: Normalize the sum of the elements in Ba and calculate the entropy value Entro of Ba.

[0143] The entropy value Entropy is calculated as follows.

[0144]

[0145]

[0146] S1.6: If Entro<maxEntro, let maxEntro=Entro and FreErr=FreErr_k.

[0147] S1.7: k = k + 1, proceed to step S1.3.

[0148] S1.8: Complete frequency offset estimation and output FreErr.

[0149] In Example 1, the value of FreErr is -377.

[0150] Step S2: Based on the frequency offset estimation result FreErr, generate a frequency search vector, and perform phase adjustment and alignment on the IQ sampled data according to the vector.

[0151] S2.1: Regarding IQ InitThe elements in the sequence are adjusted, and a corresponding phase sequence Φ is generated based on the adjusted elements. Init The adjustment and calculation methods are as follows.

[0152] IQ Init (m)=IQ Init (m)*exp(i*2π*FreErr / Fs*m)

[0153] Φ Init (m)=arctan(Im(IQ Init (m)) / Re(IQ Init (m)))

[0154] m = 0, 1, 2, ..., M-1

[0155] S2.2: Calculate Φ Init The mean of all elements is recorded as mean_phi, and the phase adjustment value Phi_Accmu is set to 0.

[0156] S2.3: Set the frequency search range FreErrRange and the frequency search step size FreErrStep, and initialize k=1.

[0157] In Example 1, the FreErrRange value is set to 0.5 and the FreErrStep value is set to 0.01, and k is initialized to 1.

[0158] S2.4: If the total number of data to be demodulated, N, is greater than or equal to (k+1)*M, then take the k*M+1 to (k+1)*M elements from IQ and record them as follows. If N is less than (k+1)*M, then proceed to step S2.10.

[0159] S2.5: Generate the frequency offset search vector FE based on FreErr, FreErrRange, and FreErrStep. 1*K1 The k1-th element in FE is FreErr - FreErrRange + k1 * FreErrStep, where This represents rounding up, initializing the vector Entro to all zeros. 1*K1 Let Phi_Accmu = Phi_Accmu + 2π*FreErr / Fs*M.

[0160] In Example 1, the vector length of FE is 101 (K1 = 101).

[0161] S2.6: Based on the elements in FE, pair IQ k Adjust and calculate the phase vector Φ k The adjustment method for the k1th element is as follows.

[0162] A m =IQ k (m)*exp(i*2π*FE(k1) / Fs*m)

[0163] Φ k (m)=arctan(Im(A m ) / Re(A m ))

[0164] m = 0, 1, 2, ..., M-1

[0165] Referring to step S1.4, based on HistR, Φ k Perform histogram statistics to obtain the statistical distribution Ba. 1*R The counting method is as follows, where num(·) represents the number of elements:

[0166] Ba(r)=num(HistR(r)≤Φ k <HistR(r+1)), where r = 0, 1, 2, ..., R-1

[0167] Calculate the entropy of Ba according to the entropy calculation method in step S1.5 and assign it to Entro(k1).

[0168] S2.7: Repeat step S2.6 until all K1 elements in FE have been used, find the position of the minimum value in Entro, denoted as k. 1min Update FreErr = FE(k) 1min According to FreErr and Phi_Accmu, IQ k Make adjustments and calculate the phase vector Φ. k :

[0169] IQ k (m)=IQ k (m)*exp(i*2π*FreErr / Fs*m)*exp(i*Phi_Accmu)

[0170] Φ k (m)=arctan(Im(IQ k (m)) / Re(IQ k (m)))

[0171] m = 0, 1, 2, ..., M-1

[0172] S2.8: Calculate the mean phase vector, mean_phi_k, and apply mean_phi_k to IQ. k The following adjustments will be made:

[0173] IQk (m)=IQ k (m)*exp(i*2π*(mean_phi-mean_phi_k))

[0174] m = 0, 1, 2, ..., M-1

[0175] S2.9: Let k = k + 1, then return to S2.4.

[0176] S2.10: The phase adjustment operation of the first to the k*Mth elements in IQ has been completed. If N>k*M, then discard the k*M+1 to the k*Mth elements in IQ and let N=k*M.

[0177] In Example 1, all elements have been adjusted, and the adjusted N = 1148364.

[0178] Step S3: Set the Fourier transform length FFT_M and the filter length Filt_M, take the first FFT_M data of the adjusted IQ data, perform Fourier transform on the taken data, and calculate the code rate based on the transformed spectrum to roughly estimate SamN_Rough.

[0179] S3.1: Set the Fourier transform length FFT_M and the filter length Filt_M, and take the first FFT_M data points of IQ as the code rate estimation sequence. For IQ FFT Perform a Fourier transform to obtain its spectrum IQf FFT :

[0180] IQf FFT =|fft(IQ FFT )|

[0181] In Example 1, the Fourier transform length FFT_M is set to 32768 (FFT_M is, for example, 1024 to 65536) and the filter length Filt_M is set to 1000 (Filt_M is, for example, 100 to 2000).

[0182] S3.2: Generate a smoothing filter SFilt 1*Filt_M Each element in SFilt is 1 / Filt_M.

[0183] S3.3: IQ FFT Perform a convolution operation with SFilt, and take the Filt_M-th to FFT_M-th elements of the convolutioned sequence as the updated IQf. FFT At this time, IQf FFT The length becomes FFT_M - Filt_M + 1, for IQf FFT Take the logarithm (i.e., with respect to IQf) FFT(Take the logarithms of the FFT_M-Filt_M+1 numbers and then assign them back):

[0184] IQf FFT =20*log10(IQf) FFT )

[0185] S3.4: Search IQf FFT The maximum value in the range is denoted as max_IQf, and IQf is searched using max_IQf-3 as the threshold. FFT For all elements that exceed the threshold, record the position of the first element that exceeds the threshold as ind1 and the position of the last element that exceeds the threshold as ind2.

[0186] S3.5: The calculation method for the coarse code rate estimation result SamN_Rough is as follows:

[0187] SamN_Rough=(FFT_M-Filt_M+1) / (ind2-ind1+1)

[0188] In Example 1, the calculated SamN_Rough value was 7.8773.

[0189] Step S4: Set the number of initial module symbols AccSymN, and select elements of a certain length from the IQ sampled data as the demodulation start sequence based on the coarse estimation result SamN_Rough obtained in step S3; adjust the start sequence according to the minimum entropy feature criterion, and output the initial demodulation result and the corresponding code rate fine estimation result SamN_Good.

[0190] S4.1: Set the number of initial module symbols to AccSymN, let AccN = AccSymN * SamN_Rough, and round AccN to ensure it is an integer. Select the first AccN elements of IQ as the frequency starting sequence. Set the maximum number of iterations k max .

[0191] In Example 1, the initial module code element count AccSymN is set to 2000, and the calculated AccN value is 15755. The maximum number of iterations k is set. max The value is 4.

[0192] S4.2: Define the frequency histogram statistical point vector HistAm, HistAm = [hA0, hA1, ..., hA...]. M1 ].

[0193] In Example 1, the value of hA0 is 0, hA M1 The value is 2, and HistAm has a total of 201 elements (M1 = 200).

[0194] S4.3: Set the variable sampling point range ±AccR (i.e. [-AccR,+AccR]), the variable sampling point number AccR_n1, and the variable synchronization number AccR_n2, and let k1 = 0.

[0195] In Example 1, the variable sampling point range ±AccR is set to ±0.3, the variable sampling point number AccR_n1 is set to 300, and the variable synchronization number AccR_n2 is set to 20, and k1 = 0.

[0196] S4.4: Define an all-zero two-dimensional matrix Entro AccR_n1*AccR_n2 Let i1 = 0.

[0197] S4.5: Let SamN_Rough_i1=SamN_Rough-AccR+2*AccR / (AccR_n1-1)*i1, let j1=0.

[0198] S4.6: Let SamN_Move_j1=j1 / (AccR_n2)*SamN_Rough_i1.

[0199] S4.7: Generate the selection sequence SampT_I based on SamN_Rough_i1 and SamN_Move_j1. 1*AccSymN and SampT_Q 1*AccSymN Select sequence SampT_I 1*AccSymN and SampT_Q 1*AccSymN The generation method is as follows:

[0200] SampT_I(n2)=SamN_Move_j1+n2*SamN_Rough_i1

[0201] SampT_Q(n2)=SamN_Move_j1+n2*SamN_Rough_i1+SamN_Rough_i1 / 2

[0202] n2 = 0, 1, 2, ..., AccSymN-1

[0203] S4.8: Using elements in SampT_I as indices from IQ Init Select the real part of the corresponding element from IQ, using the element in SampT_Q as the subscript. Init The imaginary part of the corresponding element is selected from SampT_I and SampT_Q. Since the elements in SampT_I and SampT_Q are not integers, the selection rule is to start from I and Q. Init Select the element closest to the subscript index. For example, if the subscript index is -0.1, then select the element with index IQ. InitIf the 0th element has an index of 1.9, then the 2nd element is selected, and so on. The final selected sequence is denoted as I_K. 1*AccSymN and Q_K 1*AccSymN And calculate the modulus sequence IQ_K based on I_K and Q_K. 1*AccSymN :

[0204]

[0205] S4.9: Calculate the mean of all elements in IQ_K, divide all elements in IQ_K by this mean, and perform histogram statistics on the adjusted IQ_K according to HistAm to obtain the statistical distribution BaAm. 1*M1 ,

[0206] BaAm(m1)=num(HistAm(m1)≤IQ_K<HistAm(m1+1))

[0207] m1 = 0, 1, 2, ..., M1-1

[0208] Remove all elements with a value of 0 from BaAm. After the removal, the length of BaAm becomes M1′.

[0209] S4.10: Calculate the entropy value of BaAm according to the entropy value calculation method in step S1.5, and fill it into Entro(i1,j1).

[0210] S4.11: Let j1 = j1 + 1. If j1 = AccR_n2, then go to S4.12; otherwise, go to S4.6.

[0211] S4.12: Let i1 = i1 + 1. If i1 = AccR_n1, then go to S4.13; otherwise, go to S4.5.

[0212] S4.13: Find the position of the minimum value in Entro and record its index as i. 1min and j 1min Calculate SamN_Move, and update SamN_Rough and AccR:

[0213] SamN_Rough=SamN_Rough-AccR+2*AccR / (AccR_n1-1)*i 1min

[0214] SamN_Move=j 1min / (AccR_n2)*SamN_Rough

[0215] AccR = AccR * 0.5

[0216] S4.14: Let k1 = k1 + 1, if k1 = kmax If yes, proceed to S4.15; otherwise, proceed to S4.4.

[0217] S4.15: Let SamN_Good=SamN_Rough, SamN_Move_Good=SamN_Move,

[0218] Generate the selection sequence SampT_I according to the method in S4.7. 1*AccSymN and SampT_Q 1*AccSymN And generate I_K according to the processing method in S4.8. 1*AccSymN and Q_K 1*AccSymN And calculate the modulus sequence IQ_K based on I_K and Q_K:

[0219]

[0220] S4.16: Calculate the mean of all elements in IQ_K, and divide I_K and Q_K by this mean. The I_K and Q_K after dividing by the mean are the initial demodulation results (e.g., ...). Figure 3 As shown in the figure, SamN_Good is the accurate code rate estimation result output by the demodulation start module, and SamN_Move_Good is also output as the input variable of the subsequent modules.

[0221] In Example 1, the output value of SamN_Good is 7.8126.

[0222] Step S5: Based on the output of step S4, the remaining IQ sampled data is segmented, and each segment is demodulated sequentially. The data to be demodulated is adjusted near the precise code rate estimate SamN_Good of the previous segment, and the demodulation result and the corresponding precise code rate estimate result are output based on the minimum demodulated sequence entropy. After all segments are demodulated, the precise code rate estimate results of each segment are averaged and the final code rate estimate result is output.

[0223] S5.1: Reset the variable sampling point range ±AccR, the variable sampling point number AccR_n1, and the variable synchronization number AccR_n2, setting Last_TT_end=0, K=0, and SamN_Good_All=0.

[0224] In Example 1, the AccR value is 0.001, the AccR_n1 value is 10, and the AccR_n2 value is 20.

[0225] S5.2: SamN_Good_All = SamN_Good_All + SamN_Good, K = K + 1. Update the value of Last_TT_end and calculate the variables End_Idx and tt_mod. The methods for generating Last_TT_end, End_Idx, and tt_mod are as follows, where floor is the floor function:

[0226] Last_TT_end=Last_TT_end+SamN_Move_Good+SamN_Good*(AccSymN1-1)

[0227] End_Idx=floor(Last_TT_end)+1

[0228] tt_mod = End_Idx - Last_TT_end

[0229] S5.3: If the total number of elements in IQ is less than End_Idx + AccN, then the data demodulation process is complete, and proceed to S5.15; otherwise, select the elements from End_Idx to End_Idx + AccN-1 in IQ as the demodulation sequence for this current process, denoted as...

[0230] S5.4: Define an all-zero two-dimensional matrix Entro (2*AccR_n1+1)*(2*AccR_n2+1) Let i1 = 0.

[0231] S5.5: Let SamN_Rough_i1 = SamN_Good + (i1 - AccR_n1) / AccR_n1 * AccR, and let j1 = 0.

[0232] S5.6: Let SamN_Move_j1=(j1-AccR_n2) / AccR_n2*SamN_Rough_i1.

[0233] S5.7: Generate the selection sequence SampT_I based on SamN_Rough_i1 and SamN_Move_j1. 1*AccSymN and SampT_Q 1*AccSymN The elements in both sequences are generated in the same way as in step S4.7.

[0234] S5.8: Using elements in SampT_I as indices from IQ Init Select the real part of the corresponding element from IQ, using the element in SampT_Q as the subscript. Init The imaginary part of the corresponding element is selected from the IQ values. Init The element closest to the subscript index is selected from the sequence, and the final selected sequence is denoted as I_K. 1*AccSymN and Q_K1*AccSymN And calculate the modulus sequence IQ_K based on I_K and Q_K. 1 *AccSymN :

[0235]

[0236] S5.9: Calculate the mean of all elements in IQ_K, divide all elements in IQ_K by this mean, and perform histogram statistics on the adjusted IQ_K according to HistAm to obtain the statistical distribution BaAm. 1*M1 ,

[0237] BaAm(m1)=num(HistAm(m1)≤IQ_K<HistAm(m1+1))

[0238] m1 = 0, 1, 2, ..., M1-1

[0239] Remove all elements with a value of 0 from BaAm. After the removal, the length of BaAm becomes M1′.

[0240] S5.10: Calculate the entropy value of BaAm according to the calculation method in step S1.5 and fill it into Entro(i1,j1).

[0241] S5.11: Let j1 = j1 + 1. If j1 = 2 * AccR_n2 + 1, then go to S5.12; otherwise, go to S5.6.

[0242] S5.12: Let i1 = i1 + 1. If i1 = 2 * AccR_n1 + 1, then go to S5.13; otherwise, go to S5.5.

[0243] S5.13: Find the position of the minimum value in Entro and record its index as i. 1min and j 1min Update SamN_Good and SamN_Move_Good:

[0244] SamN_Good=SamN_Good+(i 1min -AccR_n1) / AccR_n1*AccR

[0245] SamN_Move_Good=(j 1min -AccR_n2) / AccR_n2*SamN_Good

[0246] Using the updated values, generate the selection sequence SampT_I as described in step S4.7. 1*AccSymN and SampT_Q 1 *AccSymNAnd generate I_K according to the processing method in S5.8. 1*AccSymN and Q_K 1*AccSymN And calculate the modulus sequence IQ_K based on I_K and Q_K:

[0247]

[0248] Calculate the mean of all elements in IQ_K, and divide I_K and Q_K by this mean. The I_K and Q_K after dividing by the mean are the output results of this demodulation (e.g., ...). Figure 4 (As shown).

[0249] S5.14: Return to S5.2 and continue to the next demodulation.

[0250] S5.15: Calculate the code rate SamN = Fs * K / SamN_Good_All. The overall process ends, and the code rate SamN is output. The demodulation result has been output in the intermediate step.

[0251] like Figure 5 As shown, in Example 1, the output code rate SamN value is 4999.82, the actual result is 5000, and the final demodulation result is output as I_K and Q_K after dividing the mean by step S5.13.

[0252] Although the present invention has been disclosed above with reference to preferred embodiments, it is not intended to limit the present invention. Any person skilled in the art can make possible changes and modifications without departing from the spirit and scope of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope defined in the claims of the present invention.

Claims

1. A method for demodulating and estimating the code rate of OQPSK signals under non-cooperative conditions, characterized in that, include: Receive the OQPSK signal to be processed, perform digital sampling and IQ conversion to baseband, and select the baseband data IQ. 1*N The first M data points are used, and the frequency measurement range is set. Frequency estimation is completed by frequency search, and the frequency offset estimation result FreErr is output. Based on the frequency offset estimation result FreErr, a frequency search vector is generated, and the IQ sampled data is phase-adjusted and aligned according to the vector. Set the Fourier transform length FFT_M and the filter length Filt_M, take the first FFT_M data of the phase-adjusted and aligned IQ data, perform Fourier transform on the taken data, and calculate the code rate based on the transformed spectrum to roughly estimate SamN_Rough. Set the number of initial module symbols AccSymN, and based on the coarse code rate estimate SamN_Rough, select elements of a set length from the IQ sampled data as the demodulation start sequence; adjust the start sequence according to the minimum entropy feature criterion, and output the initial demodulation result and the corresponding fine code rate estimate result SamN_Good; The remaining IQ sampled data is segmented, and each segment is demodulated sequentially. The data to be demodulated is adjusted near the SamN_Good result of the previous segment's code rate fine estimation. The demodulation result and the corresponding code rate fine estimation result are output based on the criterion of minimizing the demodulated sequence entropy. After all segments are demodulated, the code rate fine estimation results of each segment are averaged and the final code rate estimation result is output.

2. The method according to claim 1, characterized in that, The calculation steps for the frequency offset estimation result FreErr are as follows: S1.1: The OQPSK baseband data after digital sampling and IQ conversion is recorded as IQ. 1*N The data sampling rate is Fs; S1.2: Take the first M data points of IQ as the data header. Set the search threshold maxEntro, the minimum frequency search value minFreErr, the maximum frequency search value maxFreErr, and the frequency search step size FreErrStep. Initialize k=1, and set the histogram statistical point vector HistR=[h0,h1,...,h R ]; S1.3: Let FreErr_k = minFreErr + (k-1)*FreErrStep. If FreErr_k is not greater than maxFreErr, then for IQ Init Perform the following operations to generate a vector. Otherwise, proceed to step S1.8; where i is the imaginary part flag; A=IQ Init (m)*exp(i*2π*FreErr_k / Fs*m) Φ Init (m)=arctan(Im(A) / Re(A)) m = 0, 1, 2, ..., M-1 S1.4: Based on HistR, Φ Init Perform histogram statistics to obtain the statistical distribution Ba. 1*R The counting method is as follows, where num(·) represents the number of elements: Ba(r)=num(HistR(r)≤Φ Init <HistR(r+1)), where r = 0, 1, 2, ..., R-1 S1.5: Normalize the sum of the elements in Ba and calculate the entropy value Entro of Ba; S1.6: If Entro<maxEntro, then let maxEntro=Entro, FreErr=FreErr_k; S1.7: k = k + 1, proceed to step S1.3; S1.8: Complete frequency offset estimation and output FreErr.

3. The method according to claim 2, characterized in that, The entropy value in step S1.5 is calculated as follows:

4. The method according to claim 2, characterized in that, The phase adjustment and alignment steps are as follows: S2.1: Regarding IQ Init The elements in the sequence are adjusted, and a corresponding phase sequence Φ is generated based on the adjusted elements. Init The adjustment and calculation methods are as follows: IQ Init (m)=IQ Init (m)*exp(i*2π*FreErr / Fs*m) Φ Init (m)=arctan(Im(IQ Init (m)) / Re(IQ Init (m))) m = 0, 1, 2, ..., M-1 S2.2: Calculate Φ Init The mean of all elements in the array is recorded as mean_phi, and the phase adjustment value Phi_Accmu is set to 0; S2.3: Set the frequency search range FreErrRange and the frequency search step size FreErrStep, and initialize k=1; S2.4: If the total number of data to be demodulated, N, is greater than or equal to (k+1)*M, then take the k*M+1 to (k+1)*M elements from IQ and record them as follows. If N is less than (k+1)*M, then proceed to step S2.10; S2.5: Generate the frequency offset search vector based on FreErr, FreErrRange, and FreErrStep. The k1-th element in FE is FreErr - FreErrRange + k1 * FreErrStep, where This represents rounding up and initializing a vector of all zeros. make Phi_Accmu=Phi_Accmu+2π*FreErrFs*M; S2.6: Based on the elements in FE, pair IQ k Adjust and calculate the phase vector Φ k The adjustment method for the k1th element is as follows: A m =IQ k (m)*exp(i*2π*FE(k1) / Fs*m) Φ k (m)=arctan(Im(A m ) / Re(A m )) m = 0, 1, 2, ..., M-1 According to HistR on Φ k Perform histogram statistics to obtain the statistical distribution Ba. 1*R The counting method is as follows, where num(·) represents the number of elements: Ba(r)=num(HistR(r)≤Φ k <HistR(r+1)), where r = 0, 1, 2, ..., R-1 Calculate the entropy of Ba and assign it to Entro(k1); S2.7: Repeat step S2.6 until all K1 elements in FE have been used, find the position of the minimum value in Entro, denoted as k. 1min Update FreErr = FE(k) 1min According to FreErr and Phi_Accmu, IQ k Make adjustments and calculate the phase vector Φ. k : IQ k (m)=IQ k (m)*exp(i*2π*FreErr / Fs*m)*exp(i*Phi_Accmu) Φ k (m)=arctan(Im(IQ k (m)) / Re(IQ k (m))) m = 0, 1, 2, ..., M-1 S2.8: Calculate the mean phase vector, mean_phi_k, and apply mean_phi_k to IQ. k The following adjustments will be made: IQ k (m)=IQ k (m)*exp(i*2π*(mean_phi-mean_phi_k)) m = 0, 1, 2, ..., M-1 S2.9: Let k = k + 1, then return to S2.4; S2.10: The phase adjustment operation of the first to the k*Mth elements in IQ has been completed. If N>k*M, then discard the k*M+1 to the k*Mth elements in IQ and let N=k*M.

5. The method according to claim 1, characterized in that, The steps for coarsely estimating the code rate are as follows: S3.1: Set the Fourier transform length FFT_M and the filter length Filt_M, and take the first FFT_M data points of IQ as the code rate estimation sequence. For IQ FFT Perform a Fourier transform to obtain its spectrum IQf FFT : IQf FFT =|fft(IQ FFT )| S3.2: Generate a smoothing filter SFilt 1*Filt_M Each element in SFilt is 1 / Filt_M; S3.3: IQ FFT Perform a convolution operation with SFilt, and take the Filt_M-th to FFT_M-th elements of the convolutioned sequence as the updated IQf. FFT At this time, IQf FFT The length becomes FFT_M - Filt_M + 1, for IQf FFT Take the logarithm: IQf FFT =20*log10(IQf FFT ) S3.4: Search IQf FFT The maximum value in the range is denoted as max_IQf, and IQf is searched using max_IQf-3 as the threshold. FFT For all elements that exceed the threshold, record the position of the first element that exceeds the threshold as ind1 and the position of the last element that exceeds the threshold as ind2; S3.5: Coarse estimation results of code rate SamN_Rough: SamN_Rough=(FFT_M-Filt_M+1) / (ind2-ind1+1).

6. The method according to claim 2, characterized in that, The calculation steps for the initial demodulation result are as follows: S4.1: Set the number of initial module symbols to AccSymN, let AccN = AccSymN * SamN_Rough, and round AccN to ensure it is an integer. Select the first AccN elements of IQ as the frequency starting sequence. Set the maximum number of iterations k max ; S4.2: Define the frequency histogram statistical point vector HistAm, HistAm = [hA0, hA1, ..., hA...]. M1 ]; S4.3: Set the variable sampling point range ±AccR, the variable sampling point number AccR_n1, and the variable synchronization number AccR_n2, and let k1 = 0; S4.4: Define an all-zero two-dimensional matrix Entro AccR_n1*AccR_n2 Let i1 = 0; S4.5: Let SamN_Rough_i1=SamN_Rough-AccR+2*AccR / (AccR_n1-1)*i1, let j1=0; S4.6: Let SamN_Move_j1=j1 / (AccR_n2)*SamN_Rough_i1; S4.7: Generate the selection sequence SampT_I based on SamN_Rough_i1 and SamN_Move_j1. 1*AccSymN and SampT_Q 1 *AccSymN ; S4.8: Using elements in SampT_I as indices from IQ Init Select the real part of the corresponding element from IQ, using the element in SampT_Q as the subscript. Init The imaginary part of the corresponding element is selected from SampT_I and SampT_Q. Since the elements in SampT_I and SampT_Q are not integers, the selection rule is to start from I and Q. Init Select the element closest to the subscript index. For example, if the subscript index is -0.1, then select the element with index IQ. Init If the 0th element has an index of 1.9, then the 2nd element is selected, and so on. The final selected sequence is denoted as I_K. 1*AccSymN and Q_K 1*AccSymN And calculate the modulus sequence IQ_K based on I_K and Q_K. 1*AccSymN : S4.9: Calculate the mean of all elements in IQ_K, divide all elements in IQ_K by this mean, and perform histogram statistics on the adjusted IQ_K according to HistAm to obtain the statistical distribution BaAm. 1*M1 , BaAm(m1)=num(HistAm(m1)≤IQ_K<HistAm(m1+1)), m1=0,1,2,...,M1-1 Remove all elements with a value of 0 from BaAm. After the removal, the length of BaAm becomes M1′. S4.10: Calculate the entropy value of BaAm and fill it into Entro(i1,j1); S4.11: Let j1 = j1 + 1. If j1 = AccR_n2, then go to S4.12; otherwise go to S4.

6. S4.12: Let i1 = i1 + 1. If i1 = AccR_n1, then go to S4.13; otherwise, go to S4.

5. S4.13: Find the position of the minimum value in Entro and record its index as i. 1min and j 1min Calculate SamN_Move, and update SamN_Rough and AccR: SamN_Rough=SamN_Rough-AccR+2*AccR / (AccR_n1-1)*i 1min SamN_Move=j 1min / (AccR_n2)*SamN_Rough AccR = AccR * 0.5 S4.14: Let k1 = k1 + 1, if k1 = k max If yes, then proceed to S4.15; otherwise, proceed to S4.

4. S4.15: Let SamN_Good=SamN_Rough, SamN_Move_Good=SamN_Move, Generate the selection sequence SampT_I according to the method in S4.

7. 1*AccSymN and SampT_Q 1*AccSymN And generate I_K according to the processing method in S4.

8. 1*AccSymN and Q_K 1*AccSymN And calculate the modulus sequence IQ_K based on I_K and Q_K: S4.16: Calculate the mean of all elements in IQ_K, and divide I_K and Q_K by this mean. The I_K and Q_K after dividing by the mean are the initial demodulation results. SamN_Good is the accurate code rate estimate output by the demodulation start module. At the same time, SamN_Move_Good is output as the input variable of the subsequent modules.

7. The method according to claim 6, characterized in that, In step S4.7, the sequence SampT_I is selected. 1*AccSymN and SampT_Q 1*AccSymN The generation method is as follows: SampT_I(n2)=SamN_Move_j1+n2*SamN_Rough_i1 SampT_Q(n2)=SamN_Move_j1+n2*SamN_Rough_i1+SamN_Rough_i1 / 2 n2 = 0, 1, 2, ..., AccSymN-1.

8. The method according to claim 6, characterized in that, The demodulation steps for that segment are as follows: S5.1: Reset the variable sampling point range ±AccR, the variable sampling point number AccR_n1, and the variable synchronization number AccR_n2, setting Last_TT_end=0, K=0, and SamN_Good_All=0; S5.2: SamN_Good_All = SamN_Good_All + SamN_Good, K = K + 1, update the value of Last_TT_end, and calculate the variables End_Idx and tt_mod; S5.3: If the total number of elements in IQ is less than End_Idx + AccN, then the data demodulation process is complete, and proceed to S5.15; otherwise, select the elements from End_Idx to End_Idx + AccN-1 in IQ as the demodulation sequence for this current process, denoted as... S5.4: Define an all-zero two-dimensional matrix Entro (2*AccR_n1+1)*(2*AccR_n2+1) Let i1 = 0; S5.5: Let SamN_Rough_i1 = SamN_Good + (i1 - AccR_n1) / AccR_n1 * AccR, and let j1 = 0; S5.6: Let SamN_Move_j1=(j1-AccR_n2) / AccR_n2*SamN_Rough_i1; S5.7: Generate the selection sequence SampT_I based on SamN_Rough_i1 and SamN_Move_j1. 1*AccSymN and SampT_Q 1 *AccSymN ; S5.8: Using elements in SampT_I as indices from IQ Init Select the real part of the corresponding element from IQ, using the element in SampT_Q as the subscript. Init The imaginary part of the corresponding element is selected from the IQ values. Init The element closest to the subscript index is selected from the sequence, and the final selected sequence is denoted as I_K. 1*AccSymN and Q_K 1*AccSymN And calculate the modulus sequence IQ_K based on I_K and Q_K. 1*AccSymN : S5.9: Calculate the mean of all elements in IQ_K, divide all elements in IQ_K by this mean, and perform histogram statistics on the adjusted IQ_K according to HistAm to obtain the statistical distribution BaAm. 1*M1 , BaAm(m1)=num(HistAm(m1)≤IQ_K<HistAm(m1+1)) m1 = 0, 1, 2, ..., M1-1 Remove all elements with a value of 0 from BaAm. After the removal, the length of BaAm becomes M1′. S5.10: Calculate the entropy value of BaAm and fill it into Entro(i1,j1); S5.11: Let j1 = j1 + 1. If j1 = 2 * AccR_n2 + 1, then go to S5.12; otherwise go to S5.

6. S5.12: Let i1 = i1 + 1. If i1 = 2 * AccR_n1 + 1, then go to S5.13; otherwise go to S5.

5. S5.13: Find the position of the minimum value in Entro and record its index as i. 1min and j 1min Update SamN_Good and SamN_Move_Good: SamN_Good=SamN_Good+(i 1min -AccR_n1) / AccR_n1*AccR SamN_Move_Good=(j 1min -AccR_n2) / AccR_n2*SamN_Good Generate the selected sequence SampT_I using the updated values. 1*AccSymN and SampT_Q 1*AccSymN And generate I_K according to the processing method in S5.

8. 1*AccSymN and Q_K 1*AccSymN And calculate the modulus sequence IQ_K based on I_K and Q_K: Calculate the mean of all elements in IQ_K, and divide I_K and Q_K by the mean. The I_K and Q_K after dividing by the mean are used as the output of the demodulation. S5.14: Return to S5.2 and continue with the next demodulation; S5.15: Calculate the code rate SamN = Fs * K / SamN_Good_All, and output the code rate SamN; The generation methods for Last_TT_end, End_Idx, and tt_mod in step S5.2 are as follows: Last_TT_end=Last_TT_end+SamN_Move_Good+SamN_Good*(AccSymN1-1) End_Idx=floor(Last_TT_end)+1 tt_mod = End_Idx - Last_TT_end `floor` is a function that rounds down to the nearest integer.

Images