OQPSK signal demodulation and code rate estimation method under non-cooperative condition

Abstract

The invention discloses an OQPSK (Orthogonal Quadrature Phase Shift Keying) signal demodulation and code rate estimation method under a non-cooperative condition, which comprises the following steps of: performing frequency offset estimation on an IQ (In-phase Quadrature Phase Shift Keying) sampling data sequence corresponding to an OQPSK signal, eliminating a residual frequency component, and outputting a frequency offset estimation result; performing phase adjustment and alignment on the IQ sampling data based on a frequency offset estimation result; the Fourier transform length and the filter length are set, the signal code rate is roughly estimated, and a code rate rough estimation result is output; based on the output code rate coarse estimation result, selecting data from the initial position of the IQ sampling data as a demodulation initial sequence, adjusting the initial sequence according to an entropy feature minimum criterion, and outputting an initial demodulation result and a corresponding code rate fine estimation result; and segmenting the residual IQ sampling data, demodulating each segment in sequence, and outputting a demodulation result of each segment and a corresponding code rate precise estimation result. According to the method, frequency offset and symbol rate estimation errors are tracked and eliminated, demodulation loss is reduced, and demodulation and parameter estimation integrated design is realized.

Description

Technical Field

[0001] The present application relates to the technical field of non-cooperative signal processing, and in particular to an OQPSK signal demodulation and code rate estimation method under non-cooperative conditions. Background Art

[0002] In traditional cooperative communication systems, both communicating parties know the system's modulation parameters and frame structure and other prior information, and transmit information between the sending and receiving ends. Non-cooperative communication refers to the act of a third party intercepting and demodulating its transmission signal without authorization. Non-cooperative communication generally does not know the prior information of the sender of the signal. It mostly relies on modern signal processing technology to analyze and process the intercepted signal through blind demodulation, aiming to obtain its transmission information. Non-cooperative signal processing is widely used in many communication scenarios: for example, in order to ensure the rational use of wireless spectrum resources, government departments will monitor civil communication systems to prevent illegal use of spectrum resources and wireless interference; in the field of military electronic countermeasures, non-cooperative signal processing is widely used in threat identification, enemy intelligence information interception and electronic countermeasures interference strategies. It can be seen that blind demodulation and parameter estimation of non-cooperative communication signals are key links in the reception and processing of non-cooperative communication signals.

[0003] Offset Quadrature Phase Shift Keying (OQPSK) modulation is an improvement on the Quadrature Phase Shift Keying (QPSK) modulation. Compared with the QPSK signal, the OQPSK modulation delays the quadrature component and separates it from the in-phase component by half a symbol period. Therefore, the phase of the OQPSK signal will only jump ±π / 2 within a symbol period. The envelope fluctuation of the band-limited OQPSK signal is smaller than that of the QPSK modulation. When passing through a nonlinear power amplifier, it will not cause the growth of power spectrum sidelobes. Since the OQPSK modulation method has better spectral characteristics than the QPSK modulation method, it is widely used in satellite communication and mobile communication systems. It is of great practical significance to study its detection and demodulation. Currently, the commonly used demodulation methods are divided into coherent demodulation and incoherent demodulation. Among them, coherent demodulation requires precise knowledge of the carrier frequency and initial phase, and cannot be applied to non-cooperative scenarios. The traditional non-coherent demodulation algorithm needs to first estimate various signal parameters including carrier frequency, symbol rate, timing and extraction parameters, and complete the timing extraction and frequency determination of the sequence based on the estimated parameters. The defect of the traditional process is that the extraction accuracy of the back-end sequence is greatly affected by the error of the previous stage parameter estimation. For example, if the symbol rate estimation is affected by noise, it will have a significant impact on the extraction and timing of the sequence; or when there is a time-varying Doppler frequency shift, the influence of the residual carrier frequency will cause the algorithm to fail. The above problems limit the application effect of traditional non-coherent demodulation in actual confrontation scenarios. Summary of the invention

[0004] The present application provides a method for OQPSK signal demodulation and code rate estimation under non-cooperative conditions. The invention first adjusts the initial frequency offset and phase of the signal, then performs a rough estimate of the code rate based on the signal bandwidth distribution, and performs a joint process of demodulation and precise code rate estimation on the signal based on the result of the rough estimate, thereby completing an accurate estimate of the signal code rate while obtaining the demodulation sequence. The method combines demodulation with parameter estimation, tracks and eliminates frequency offset and symbol rate estimation errors, avoids demodulation losses caused by error accumulation in traditional incoherent demodulation, and realizes an integrated design of demodulation and parameter estimation.

[0005] In a first aspect, a method for OQPSK signal demodulation and code rate estimation under non-cooperative conditions is provided, comprising:

[0006] Receive the OQPSK signal to be processed, digitally sample and IQ transform it to baseband, select the baseband data IQ 1*N The first M data of , and set the frequency measurement range, complete the frequency estimation by frequency search, and output the frequency deviation estimation result FreErr;

[0007] Based on the frequency offset estimation result FreErr, a frequency search vector is generated, and the phase of the IQ sample data is 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 rough code rate estimate SamN_Rough based on the transformed spectrum;

[0009] Set the number of starting module symbols AccSymN, and based on the rough code rate estimate SamN_Rough, select elements of a certain length from the IQ sampling data as the demodulation starting sequence; adjust the starting sequence according to the minimum entropy feature criterion, and output the starting demodulation result and the corresponding code rate accurate estimation result SamN_Good;

[0010] The remaining IQ sampling data is segmented, and each segment is demodulated in turn. The data to be demodulated is adjusted near the precise estimated value SamN_Good of the previous data segment code rate. Based on the minimum entropy of the demodulation sequence, the demodulation result of each segment and the corresponding precise estimated code rate result are output. After all segments are demodulated, the precise estimated code rates of each segment are averaged and the final code rate estimation result is output.

[0011] In combination with the first aspect, in some implementations of the first aspect, the steps of calculating 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 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 FreErrStep, initialize k = 1, 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 IQ Init Perform the following operations to generate a vector Otherwise, go to step S1.8; where i is the imaginary part sign;

[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: According to HistR Init Perform histogram statistics to obtain the statistical number distribution Ba 1*R , the statistical method is as follows, where num(·) represents the number of elements:

[0019] Ba(r)=num(HistR(r)≤Φ Init <HistR(r+1))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, go to step S1.3;

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

[0024] In combination with the first aspect, in some implementations of the first aspect, the entropy value calculation method of step S1.5 is:

[0025]

[0026] In combination with the first aspect, in some implementations of the first aspect, the phase adjustment and alignment step is:

[0027] S2.1: IQ Init The elements in are adjusted, and the corresponding phase sequence Φ is generated according to 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(Q Init (m)) / Re(Q Init (m)))

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

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

[0032] S2.3: Set the frequency search range FreErrRange and the frequency search step 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, take the k*M+1th to (k+1)*Mth elements in IQ and record them as If N is less than (k+1)*M, go to step S2.10;

[0034] S2.5: Generate frequency deviation search vector based on FreErr, FreErrRange and FreErrStep The k1th element in FE is FreErr-FreErrRange+k1*FreErrStep, where Represents rounding up, initializing the vector to all 0s make

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

[0036] S2.6: IQ based on the elements in FE k Adjust and calculate the phase vector Φ k , where the k1th element is adjusted 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 k Perform histogram statistics to obtain the statistical number distribution Ba 1*R , the statistical method is as follows,

[0041] Where num(·) represents the number of elements:

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

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

[0044] S2.7: Repeat step S2.6 until all K1 elements in FE are used, and 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 Adjust and calculate the phase vector Φ k :

[0045] IQ k (m)=IQ k (m)*exp(i*2π*FreErrFs*m)*exp(i*Phi_Accmu)

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

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

[0048] S2.8: Calculate the phase vector mean_phi_k, and calculate IQ k Make the following adjustments:

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

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

[0051] S2.9: Set k=k+1, and return to S2.4;

[0052] S2.10: The phase adjustment operation on the 1st to k*Mth elements in IQ has been completed. If N>k*M, the k*M+1th to k*Mth elements in IQ are discarded, and N=k*M.

[0053] In combination with the first aspect, in some implementations of the first aspect, the step of roughly estimating the code rate is:

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

[0055] QUR FFT =|fft(IQ FFT )|

[0056] S3.2: Generate smoothing filter SFilt 1*Filt_M , each element in SFilt is 1 / Filt_M;

[0057] S3.3: IQ FFT Perform convolution operation with SFilt, and take the Filt_Mth to FFT_Mth elements of the convolved 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:

[0058] QUR FFT =20*log10(IQf FFT )

[0059] S3.4: Search IQf FFT The maximum value in is recorded as max_IQf, and max_IQf-3 is used as the threshold to find IQf FFTFor all elements that cross the threshold, record the position of the first element that crosses the threshold as ind1, and the position of the last element that crosses the threshold as ind2;

[0060] S3.5: Calculate the rough estimate of the code rate SamN_Rough:

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

[0062] In combination with the first aspect, in some implementations of the first aspect, the step of calculating the initial demodulation result is:

[0063] S4.1: Set the number of starting module symbols AccSymN, set 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 ;

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

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

[0066] S4.4: Set the all-zero two-dimensional matrix Entro AccR_n1*AccR_n2 , let i1=0;

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

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

[0069] S4.7: Generate the selection sequence SampT_I according to SamN_Rough_i1 and SamN_Move_j1 1*AccSymN and SampT_Q 1*AccSymN ;

[0070] S4.8: Use the elements in SampT_I as subscripts from IQ Init Select the real part of the corresponding element from SampT_Q and use the element in SampT_Q as the subscript from IQ InitSelect the imaginary part of the corresponding element. Since the elements in SampT_I and SampT_Q are non-integers, the selection rule is to select from IQ Init Select the element with the integer closest to the subscript. For example, if the subscript is -0.1, then take the 0th element in SampT_Q. If the subscript is 1.9, then take the 2nd element. And so on. The final selected sequence is recorded as I_K. 1*AccSymN and Q_K 1*AccSymN , and calculate the module value sequence IQ_K based on I_K and Q_K 1*AccSymN :

[0071]

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

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

[0074] Eliminate all the element values ​​of 0 in BaAm. After the elimination, the length of BaAm becomes M1′;

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

[0076] S4.11: Let j1=j1+1. If j1=AccR_n2, go to S4.12. Otherwise, go to S4.6.

[0077] S4.12: Let i1 = i1 + 1. If i1 = AccR_n1, go to S4.13. Otherwise, go to S4.5.

[0078] S4.13: Find the minimum value in Entro and record its subscripts as i 1min and j 1min , calculate SamN_Move, update SamN_Rough and AccR:

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

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

[0081] AccR=AccR*0.5

[0082] S4.14: Let k1 = k1 + 1, if k1 = k max , then go to S4.15, otherwise go to S4.4;

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

[0084] Generate the selection sequence SampT_I according to 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 module value sequence IQ_K based on I_K and Q_K:

[0085]

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

[0087] In combination with the first aspect, in some implementations of the first aspect, in step S4.7, the sequence SampT_I is selected. 1 *AccSymN and SampT_Q 1*AccSymN The generation method is:

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

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

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

[0091] In combination with the first aspect, in some implementations of the first aspect, the steps of demodulating all segments are as follows:

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

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

[0094] S5.3: If the total number of elements in IQ is less than End_Idx+AccN, the data demodulation process is completed, and go to S5.15; otherwise, select the elements from End_Idx to End_Idx+AccN-1 in IQ as the demodulation process sequence for this time, recorded as

[0095] S5.4: Set the all-zero two-dimensional matrix Entro (2*AccR_n1+1)*(2*AccR_n2+1) , let i1=0;

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

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

[0098] S5.7: Generate the selection sequence SampT_I according to SamN_Rough_i1 and SamN_Move_j1 1*AccSymN and SampT_Q 1*AccSymN ;

[0099] S5.8: Use the elements in SampT_I as subscripts from IQ Init Select the real part of the corresponding element from SampT_Q and use the element in SampT_Q as the subscript from IQ Init Select the imaginary part of the corresponding element from IQ Init Select the element with the integer closest to the subscript, and the final selected sequence is recorded as I_K 1*AccSymN and Q_K 1*AccSymN , and calculate the module value sequence IQ_K based on I_K and Q_K 1 *AccSymN :

[0100]

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

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

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

[0104] Eliminate all the element values ​​of 0 in BaAm. After the elimination, the length of BaAm becomes M1′;

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

[0106] S5.11: Let j1=j1+1. If j1=2*AccR_n2+1, go to S5.12. Otherwise, go to S5.6.

[0107] S5.12: Let i1=i1+1. If i1=2*AccR_n1+1, go to S5.13. Otherwise, go to S5.5.

[0108] S5.13: Find the minimum value in Entro and record its subscripts as i 1min and j 1min , update SamN_Good and SamN_Move_Good:

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

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

[0111] Generate the selection sequence SampT_I using the updated value 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 module value sequence IQ_K based on I_K and Q_K:

[0112]

[0113] 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 the mean are used as the output results of the demodulation.

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

[0115] In combination with the first aspect, in some implementations of the first aspect, the method further includes:

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

[0117] In combination with the first aspect, in some implementations of the first aspect, the method for generating Last_TT_end, End_Idx and tt_mod in step S5.2 is as follows:

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

[0119] End_Idx=floor(Last_TT_end)+1

[0120] tt_mod=End_Idx-Last_TT_end

[0121] Floor is a downward positive function.

[0122] Compared with the prior art, the solution provided by this application includes at least the following beneficial technical effects:

[0123] (1) The present invention integrates code rate estimation and demodulation, thereby avoiding the error accumulation problem caused by the traditional incoherent demodulation method of first estimating parameters and then demodulating according to the estimated parameters, thereby reducing demodulation loss.

[0124] (2) Traditional methods estimate the carrier frequency only once at the beginning of demodulation and cannot handle the situation where there is time-varying Doppler frequency shift in the data. This method can effectively handle the above problem by aligning frequency offset estimation and phase adjustment, and is more suitable for application in actual confrontation scenarios. BRIEF DESCRIPTION OF THE DRAWINGS

[0125] Figure 1 It is a flowchart of the overall process of the present invention.

[0126] Figure 2 The IQ and spectrum distribution of the obtained signal.

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

[0128] Figure 4 is the demodulation result of all remaining data in step S5.

[0129] Figure 5 It is the distribution of code rate of each data segment in the whole demodulation process. DETAILED DESCRIPTION

[0130] The present application is further described in detail below with reference to the accompanying drawings and specific embodiments.

[0131] like Figure 1 As shown, the present invention provides an OQPSK signal demodulation and code rate estimation method under non-cooperative conditions. The method first adjusts the initial frequency offset and phase of the signal, then performs a rough estimation of the code rate based on the signal bandwidth distribution, and performs a joint process of demodulation and code rate precision estimation on the signal based on the rough estimation result, thereby completing an accurate estimation of the signal code rate while obtaining a demodulation sequence. The present invention is further described below in conjunction with specific steps.

[0132] Step S1: Receive the OQPSK signal to be processed, convert it to baseband through digital sampling and IQ conversion, and select the baseband data IQ 1 *N The first M data of , and the frequency measurement range is set, the frequency estimation is completed by frequency search, and the frequency offset estimation result FreErr is output.

[0133] S1.1: The OQPSK baseband data after digital sampling and IQ conversion is recorded as IQ (such as Figure 2 As shown), the data sampling rate is Fs.

[0134] In Example 1, in a certain task, the sampling rate is 0.039063 MHz, the IQ conversion center frequency is set to 1930097.6265 Hz, the total sampling time is 29.422 s, and the number of IQ sampling data recorded is 1149312, N=1149312.

[0135] S1.2: Take the first M data 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 FreErrStep. Initialize k = 1, set the histogram statistical point vector HistR = [h0,h1,...,h R ]

[0136] In Example 1, the M=3906 data before IQ are taken as the data header IQ Init Set the search threshold maxEntro value to 1000, the minimum frequency search value minFreErr value to -1, the maximum frequency search value maxFreEr value to 1, and the frequency search step FreErrStep to 0.002, initialize k = 1, and set the histogram statistical point vector HistR = [-π, -π + π / 25,-π+2*π / 25, ... ,π].

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

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

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

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

[0141] S1.4: According to HistR Init Perform histogram statistics to obtain the statistical number distribution Ba 1*R In Example 1, R=51.

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

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

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

[0145] The entropy value Entro is calculated as follows.

[0146]

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

[0148] S1.7: k=k+1, go to step S1.3.

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

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

[0151] Step S2: Generate a frequency search vector based on the frequency offset estimation result FreErr, and perform phase adjustment and alignment on the IQ sampling data according to the vector.

[0152] S2.1: IQ Init The elements in are adjusted, and the corresponding phase sequence Φ is generated according to the adjusted elements Init , the adjustment and calculation methods are as follows.

[0153] IQ Init (m)=IQ Init (m)*exp(i*2π*FreErr, Fs*m)

[0154] Φ Init (m) = arctan(Im(Q Init (m)) / Re(Q Init (m)))

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

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

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

[0158] In the first embodiment, the frequency search interval FreErrRange is set to 0.5 and the frequency search step FreErrStep is set to 0.01, and k is initialized to 1.

[0159] S2.4: If the total number of data to be demodulated N is greater than or equal to (k+1)*M, take the k*M+1th to (k+1)*Mth elements in IQ and record them as If N is less than (k+1)*M, go to step S2.10.

[0160] S2.5: Generate frequency deviation search vector based on FreErr, FreErrRange and FreErrStep The k1th element in FE is FreErr-FreErrRange+k1*FreErrStep, where Represents rounding up, initializing the vector to all 0s Let Phi_Accmu=Phi_Accmu+2π*FreErr / Fs*M.

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

[0163] S2.6: IQ based on the elements in FE k Adjust and calculate the phase vector Φ k , where the k1th element is adjusted as follows.

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

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

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

[0167] Refer to step S1.4, according to HistR k Perform histogram statistics to obtain the statistical number distribution Ba 1*R , the statistical method is as follows, where num(·) represents the number of elements:

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

[0169] The entropy of Ba is calculated by referring to the entropy value calculation method in step S1.5 and assigned to Entro(k1).

[0170] S2.7: Repeat step S2.6 until all K1 elements in FE are used, and 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 Adjust and calculate the phase vector Φ k :

[0171] IQ k (m)=IQ k (m)*exp(i*2π*FreErrFs*m)*exp(i*Phi_Accmu)

[0172] Φ k (m) = arctan(Im(IQ k (m))、Re(IQ k (m)))

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

[0174] S2.8: Calculate the phase vector mean_phi_k, and calculate IQ k Make the following adjustments:

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

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

[0177] S2.9: Let k=k+1, and return to S2.4.

[0178] S2.10: The phase adjustment operation on the 1st to k*Mth elements in IQ has been completed. If N>k*M, the k*M+1th to k*Mth elements in IQ are discarded, and N=k*M.

[0179] In Example 1, the adjustment of all elements is completed at this time, and the adjusted N=1148364.

[0180] Step S3, setting the Fourier transform length FFT_M and the filter length Filt_M, taking the first FFT_M data of the adjusted IQ data, performing Fourier transform on the taken data, and calculating a rough code rate estimate SamN_Rough according to the transformed spectrum.

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

[0182] QUR FFT =|fft(IQ FFT )|

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

[0184] S3.2: Generate smoothing filter SFilt 1*Filt_M , each element in SFilt is 1 / Filt_M.

[0185] S3.3: IQ FFTPerform convolution operation with SFilt, and take the Filt_Mth to FFT_Mth elements of the convolved 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., IQf FFT Take the logarithm of the FFT_M-Filt_M+1 numbers in the image and assign them back):

[0186] QUR FFT =20*log10(IQf FFT )

[0187] S3.4: Search IQf FFT The maximum value in is recorded as max_IQf, and max_IQf-3 is used as the threshold to find IQf FFT For all elements that cross the threshold, record the position of the first element that crosses the threshold as ind1 and the position of the last element that crosses the threshold as ind2.

[0188] S3.5: The rough code rate estimation result SamN_Rough is calculated as follows:

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

[0190] In Example 1, the SamN_Rough value is calculated to be 7.8773.

[0191] Step S4, set the number of starting module code elements AccSymN, and select elements of a certain length from the IQ sampling data as the demodulation starting sequence based on the rough estimation result SamN_Rough obtained in step S3; adjust the starting sequence according to the minimum entropy feature criterion, and output the starting demodulation result and the corresponding code rate accurate estimation result SamN_Good.

[0192] S4.1: Set the number of starting module symbols AccSymN, set 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 .

[0193] In Example 1, the value of the number of symbols in the starting module AccSymN is set to 2000, the calculated value of AccN is 15755, and the maximum number of iterations k is set to max The value is 4.

[0194] S4.2: Set the frequency histogram statistical point vector HistAm, HistAm = [hA0,hA1,…,hA M1 ].

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

[0196] S4.3: Set the variable sampling point range ±AccR (ie [-AccR, +AccR]), the variable sampling point number AccR_n1 and the variable synchronization number AccR_n2, and set k1=0.

[0197] In the first embodiment, 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.

[0198] S4.4: Set the all-zero two-dimensional matrix Entro AccR_n1*AccR_n2 , let i1=0.

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

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

[0201] S4.7: Generate the selection sequence SampT_I according to SamN_Rough_i1 and SamN_Move_j1 1*AccSymN and SampT_Q 1*AccSymN . Select the sequence SampT_I 1*AccSymN and SampT_Q 1*AccSymN The generation method is:

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

[0203] SampT_Q(n2)=SamN_Move_ j1+n2*SamN_Rough_i1+SamN_Rough_i1 / 2

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

[0205] S4.8: Use the elements in SampT_I as subscripts from IQ InitSelect the real part of the corresponding element from SampT_Q and use the element in SampT_Q as the subscript from IQ Init Select the imaginary part of the corresponding element. Since the elements in SampT_I and SampT_Q are non-integers, the selection rule is to select from IQ Init Select the element with the integer closest to the subscript. For example, if the subscript is -0.1, then take the 0th element in SampT_Q. If the subscript is 1.9, then take the 2nd element. And so on. The final selected sequence is recorded as I_K. 1*AccSymN and Q_K 1*AccSymN , and calculate the module value sequence IQ_K based on I_K and Q_K 1*AccSymN :

[0206]

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

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

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

[0210] All element values ​​of 0 in BaAm are removed, and after the removal is completed, the length of BaAm becomes M1′.

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

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

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

[0214] S4.13: Find the minimum value in Entro and record its subscripts as i 1min and j 1min , calculate SamN_Move, update SamN_Rough and AccR:

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

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

[0217] AccR=AccR*0.5

[0218] S4.14: Let k1 = k1 + 1, if k1 = k max , then go to S4.15, otherwise go to S4.4.

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

[0220] Generate the selection sequence SampT_I according to 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 module value sequence IQ_K based on I_K and Q_K:

[0221]

[0222] S4.16: 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 the mean are the initial demodulation results (such as Figure 3 As shown), SamN_Good is the accurate estimation result of the code rate output by the demodulation starting module, and SamN_Move_Good is output as the input variable of the subsequent module.

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

[0224] Step S5, according to the output result of step S4, the remaining IQ sampling data is segmented, and each segment is demodulated in turn, and the data to be demodulated is adjusted near the precise estimated value SamN_Good of the code rate of the previous segment data, and the demodulation result of each segment and the corresponding precise estimated result of the code rate are output based on the minimum entropy of the demodulation sequence. After completing the demodulation of all segments, the precise estimated results of the code rates corresponding to each segment are averaged and the final code rate estimation result is output.

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

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

[0227] S5.2: SamN_Good_All=SamN_Good_All+SamN_Good, K=K+1, update the value of Last_TT_end, and calculate variables End_Idx and tt_mod. The generation method of Last_TT_end, End_Idx and tt_mod is as follows, floor is a downward positive function:

[0228] Last_TT_end=Last_TT_end+SamN_Move_Good

[0229] +SamN_Good*(AccSymN1-1)

[0230] End_Idx=floor(Last_TT_end)+1

[0231] tt_mod=End_Idx-Last_TT_end

[0232] S5.3: If the total number of elements in IQ is less than End_Idx+AccN, the data demodulation process is completed, and go to S5.15; otherwise, select the elements from End_Idx to End_Idx+AccN-1 in IQ as the demodulation process sequence for this time, recorded as

[0233] S5.4: Set the all-zero two-dimensional matrix Entro (2*AccR_n1+1)*(2*AccR_n2+1) , let i1=0.

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

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

[0236] S5.7: Generate the selection sequence SampT_I according to SamN_Rough_i1 and SamN_Move_j1 1*AccSymN and SampT_Q 1*AccSymN , the elements in the two sequences are generated in the same way as step S4.7.

[0237] S5.8: Use the elements in SampT_I as subscripts from IQ Init Select the real part of the corresponding element from SampT_Q and use the element in SampT_Q as the subscript from IQ Init Select the imaginary part of the corresponding element from IQ InitSelect the element with the integer closest to the subscript, and the final selected sequence is recorded as I_K 1*AccSymN and Q_K 1*AccSymN , and calculate the module value sequence IQ_K based on I_K and Q_K 1 *AccSymN :

[0238]

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

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

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

[0242] All element values ​​of 0 in BaAm are removed, and after the removal is completed, the length of BaAm becomes M1′.

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

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

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

[0246] S5.13: Find the minimum value in Entro and record its subscripts as i 1min and j 1min , update SamN_Good and SamN_Move_Good:

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

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

[0249] Use the updated value to generate the selection sequence SampT_I in the manner of step S4.7 1*AccSymNand 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 module value sequence IQ_K based on I_K and Q_K:

[0250]

[0251] 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 the mean are the output results of the demodulation (such as Figure 4 shown).

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

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

[0254] 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 through step S5.13, which is I_K and Q_K after the mean value is divided as the output result of the demodulation.

[0255] Although the present invention is disclosed as above in terms of preferred embodiments, it is not intended to limit the present invention. Any person skilled in the art may 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 shall be based on the scope defined by the claims of the present invention.

Claims

1. A method for OQPSK signal demodulation and code rate estimation under non-cooperative conditions, characterized in that: include: Receive the OQPSK signal to be processed, digitally sample and IQ transform it to baseband, select the baseband data IQ 1*N The first M data of , and set the frequency measurement range, complete the frequency estimation by frequency search, and output the frequency deviation estimation result FreErr; Based on the frequency offset estimation result FreErr, a frequency search vector is generated, and the phase of the IQ sample data is 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 rough code rate estimate SamN_Rough based on the transformed spectrum; Set the number of starting module symbols AccSymN, and based on the rough code rate estimate SamN_Rough, select elements of a certain length from the IQ sampling data as the demodulation starting sequence; adjust the starting sequence according to the minimum entropy feature criterion, and output the starting demodulation result and the corresponding code rate accurate estimation result SamN_Good; The remaining IQ sampling data is segmented, and each segment is demodulated in turn. The data to be demodulated is adjusted near the precise estimated value SamN_Good of the previous data segment code rate. Based on the minimum entropy of the demodulation sequence, the demodulation result of each segment and the corresponding precise estimated code rate result are output. After all segments are demodulated, the precise estimated code rates 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 of 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 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 FreErrStep, initialize k = 1, 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 IQ Init Perform the following operations to generate a vector Otherwise, go to step S1.8; where i is the imaginary part sign; 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: According to HistR Init Perform histogram statistics to obtain the statistical number distribution Ba 1*R , the statistical method is as follows, where num(·) represents the number of elements: Ba(r)=num(HistR(r)≤Φ Init <HistR(r+1))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, go 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 of step S1.5 is calculated as follows:

4. The method according to claim 1, characterized in that The steps of phase adjustment and alignment are: S2.1: IQ Init The elements in are adjusted, and the corresponding phase sequence Φ is generated according to 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(Q Init (m)) / Re(Q Init (m))) m=0,1,2,…,M-1 S2.2: Calculate Φ Init The mean of all elements in is recorded as mean_phi, and the phase adjustment value Phi_Accmu=0; S2.3: Set the frequency search range FreErrRange and the frequency search step 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, take the k*M+1th to (k+1)*Mth elements in IQ and record them as If N is less than (k+1)*M, go to step S2.10; S2.5: Generate frequency deviation search vector based on FreErr, FreErrRange and FreErrStep The k1th element in FE is FreErr-FreErrRange+k1*FreErrStep, where Represents rounding up, initializing the vector to all 0s make Phi_Accmu=Phi_Accmu+2π*FreErr / Fs*M; S2.6: IQ based on the elements in FE k Adjust and calculate the phase vector Φ k , where the k1th element is adjusted 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 k Perform histogram statistics to obtain the statistical number distribution Ba 1*R , the statistical method is as follows, where num(·) represents the number of elements: Ba(r)=num(HistR(r)≤Φ Init <HistR(r+1))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 are used, and 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 Adjust 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 phase vector mean_phi_k, and calculate IQ k Make the following adjustments: IQ k (m)=IQ k (m)*exp(i*2π*(mean_phi-mean_phi_k)) m=0,1,2,...,M-1 S2.9: Set k=k+1, and return to S2.4; S2.10: The phase adjustment operation on the 1st to k*Mth elements in IQ has been completed. If N>k*M, the k*M+1th to k*Mth elements in IQ are discarded, and N=k*M.

5. The method according to claim 1, characterized in that The steps for roughly estimating the code rate are: S3.1: Set the Fourier transform length FFT_M and the filter length Filt_M, and take the first FFT_M data of IQ as the code rate estimation sequence IQ FFT Perform Fourier transform to obtain its spectrum IQf FFT : IQf FFT =|fft(IQ FFT )| S3.2: Generate smoothing filter SFilt 1*Filt_M , each element in SFilt is 1 / Filt_M; S3.3: IQ FFT Perform convolution operation with SFilt, and take the Filt_Mth to FFT_Mth elements of the convolved 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 is recorded as max_IQf, and max_IQf-3 is used as the threshold to find IQf FFT For all elements that cross the threshold, record the position of the first element that crosses the threshold as ind1, and the position of the last element that crosses the threshold as ind2; S3.5: Calculate the rough estimate of the code rate SamN_Rough: SamN_Rough=(FFT_M-Filt_M+1) / (ind2-ind1+1).

6. The method according to claim 1, characterized in that The calculation steps of the initial demodulation result are: S4.1: Set the number of starting module symbols AccSymN, set 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: Set 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 set k1 = 0; S4.4: Set the 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 according to SamN_Rough_i1 and SamN_Move_j1 1*AccSymN and SampT_Q 1 *AccSymN ; S4.8: Use the elements in SampT_I as subscripts from IQ Init Select the real part of the corresponding element from SampT_Q and use the element in SampT_Q as the subscript from IQ Init Select the imaginary part of the corresponding element. Since the elements in SampT_I and SampT_Q are non-integers, the selection rule is to select from IQ Init Select the element with the integer closest to the subscript. For example, if the subscript is -0.1, then take the 0th element in SampT_Q. If the subscript is 1.9, then take the 2nd element. And so on. The final selected sequence is recorded as I_K. 1*AccSymN and Q_K 1*AccSymN , and calculate the module value sequence IQ_K based on I_K and Q_K 1*AccSymN : S4.9: Calculate the mean of all elements in IQ_K, and divide all elements in IQ_K by the mean. Perform histogram statistics on the adjusted IQ_K according to HistAm to obtain the statistical number distribution BaAm 1*M1 , BaAm(m1)=num(HistAm(m1)≤IQ_K<HistAm(m1+1)), m1=0,1,2,...,M1-1 Eliminate all the element values ​​of 0 in BaAm. After the elimination, 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, go to S4.

12. Otherwise, go to S4.

6. S4.12: Let i1 = i1 + 1. If i1 = AccR_n1, go to S4.

13. Otherwise, go to S4.

5. S4.13: Find the minimum value in Entro and record its subscripts as i 1min and j 1min , calculate SamN_Move, 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 , then go to S4.15, otherwise go to S4.4; S4.15: Let SamN_Good=SamN_Rough, SamN_Move_Good=SamN_Move, Generate the selection sequence SampT_I according to 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 module value 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 the mean. I_K and Q_K after dividing the mean are the starting demodulation results. SamN_Good is the accurate estimation result of the code rate output by the demodulation starting 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: 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 1, characterized in that The steps for demodulating all segments 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, and set Last_TT_end=0, K=0, 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 variables End_Idx and tt_mod; S5.3: If the total number of elements in IQ is less than End_Idx+AccN, the data demodulation process is completed, and go to S5.15; otherwise, select the elements from End_Idx to End_Idx+AccN-1 in IQ as the demodulation process sequence for this time, recorded as S5.4: Set the 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, 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 according to SamN_Rough_i1 and SamN_Move_j1 1*AccSymN and SampT_Q 1 *AccSymN ; S5.8: Use the elements in SampT_I as subscripts from IQ Init Select the real part of the corresponding element from SampT_Q and use the element in SampT_Q as the subscript from IQ Init Select the imaginary part of the corresponding element from IQ Init Select the element with the integer closest to the subscript, and the final selected sequence is recorded as I_K 1*AccSymN and Q_K 1*AccSymN , and calculate the module value sequence IQ_K based on I_K and Q_K 1*AccSymN : S5.9: Calculate the mean of all elements in IQ_K, and divide all elements in IQ_K by the mean. Perform histogram statistics on the adjusted IQ_K according to HistAm to obtain the statistical number distribution BaAm 1*M1 , BaAm(m1)=num(HistAm(m1)≤IQ_K<HistAm(m1+1)) m1=0,1,2,...,M1-1 Eliminate all the element values ​​of 0 in BaAm. After the elimination, 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, go to S5.

12. Otherwise, go to S5.

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

13. Otherwise, go to S5.

5. S5.13: Find the minimum value in Entro and record its subscripts 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 selection sequence SampT_I using the updated value 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 module value 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 the mean are used as the output results of the demodulation. S5.14: Return to S5.2 and continue the next demodulation.

9. The method according to claim 8, characterized in that The method further comprises: S5.15: Calculate the code rate SamN = Fs*K / SamN_Good_All, and output the code rate SamN.

10. The method according to claim 8, characterized in that The method for generating Last_TT_end, End_Idx and tt_mod in step S5.2 is 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 downward positive function.

Images