python 通信调制方式_Python产生不同PRI调制方式的雷达脉冲序列信号,python,串

雷达脉冲串信号

脉内信号

脉冲内的信号有两种：

常规连续波信号

s

(

t

)

=

c

o

s

(

2

π

f

0

t

)

s(t)=cos(2\pi f_0 t)

s

(

t

)

=

c

o

s

(

2

π

f

0

​

t

)

线性调频信号

s

(

t

)

=

c

o

s

(

2

π

f

0

t

+

π

k

t

2

)

s(t) = cos(2\pi f_0 t + \pi k t^2)

s

(

t

)

=

c

o

s

(

2

π

f

0

​

t

+

π

k

t

2

)

,

k

k

k

是调频率

PRI序列

p

(

n

)

p(n)

p

(

n

)

就是PRI序列，它的变换反映了PRI调制方式的变化规律。

ref：基于多特征量的雷达辐射源脉间PRI调制识别。

这里仿真5种PRI调制：

固定PRI

PRI抖动

PRI滑变

PRI参差

仿真时候没有加

ω

(

n

)

\omega(n)

ω

(

n

)

PRI组变

python代码

Rad_Sig(PRI_index,sig_index)实现不同脉内信号和PRI调制方式选择：

PRI_index:0–fixed PRI; 1–jitter mode; 2–slide mode; 3–group change mode; 4–jagged mode

sig_index:0–fixed frequency; 1–LFM signal

import numpy as np

import matplotlib.pyplot as plt

import math

fc = 1e9 # center frequency

fs = 40e6 # sample frequency

Num = 15 # PRI num

Tp = 0.001 # pulse width

BW = 20e6# bandwidth

k = BW/Tp# chirp rate

# PRI jitter

PRI_ave = 0.01

PRI_per = 0.3

PRI_jitter = PRI_ave + PRI_ave*(PRI_per - 2*PRI_per*np.random.rand(Num))

#print(PRI_jitter)

# PRI slide

PRI_min = 0.005

PRI_max = 0.015

PRI_offset = 0.001

PRI_slide = [PRI_min]

for i in range(Num):

PRI_s = PRI_slide[i] + PRI_offset

if (PRI_s > PRI_max):

PRI_s = PRI_min

PRI_slide = np.append(PRI_slide,PRI_s)

#print(PRI_slide)

# PRI fixed

PRI_fix = [PRI_ave]*Num

#print(PRI_fix)

# PRI group change

N_group = 3

Num_group = [3,5,7]

PRI_group = [0.01,0.05,0.07]

PRI_group_change = []

for i in range(N_group):

PRI_group_change = np.append(PRI_group_change,[PRI_group[i]]*Num_group[i])

#print(PRI_group_change)

# PRI jagged

N_jag = 5

PRI_jag_set = [0.01,0.02,0.05,0.09,0.1]

PRI_jagged = []

for i in range(Num):

ind = np.mod(i,N_jag)

PRI_jagged = np.append(PRI_jagged,PRI_jag_set[ind])

#print(PRI_jagged)

def LFM_signal():

N0 = math.ceil(Tp*fs)

t = np.linspace(0,Tp,N0)

st_LFM = np.cos(2*np.pi*fc*t + np.pi * k * np.power(t,2))

return st_LFM

def cos_signal():

N0 = math.ceil(Tp*fs)

t = np.linspace(0,Tp,N0)

st_cos = np.cos(2*np.pi*fc*t)

return st_cos

def Rad_Sig(PRI_index,sig_index):

Num_local = Num

#global all_PRI

if PRI_index == 0:

all_PRI = PRI_fix

elif PRI_index == 1:

all_PRI = PRI_jitter

elif PRI_index == 2:

all_PRI = PRI_slide

elif PRI_index == 3:

all_PRI = PRI_group_change

Num_local = np.sum(Num_group)

elif PRI_index == 4:

all_PRI = PRI_jagged

else:

print('error')

#print(all_PRI)

#print(Num_local)

zero0 = np.zeros(int(fs*(all_PRI[0]-Tp)))

if sig_index == 1:

signal = LFM_signal()

elif sig_index == 0:

signal = cos_signal()

else:

print('error')

signal0 = np.hstack((signal,zero0))

Rad_sig = signal0

for i in range(1,Num_local):

zeroi = np.zeros(int(fs*(all_PRI[i]-Tp)))

signali = np.hstack((signal,zeroi))

Rad_sig = np.hstack((Rad_sig,signali))

return Rad_sig

if __name__=="__main__":

s = Rad_Sig(1,1)

'''

Rad_Sig(PRI_index,sig_index):

PRI_index:0--fixed PRI; 1--jitter mode; 2--slide mode; 3--group change mode; 4--jagged mode

sig_index:0--fixed frequency; 1--LFM signal

'''

plt.figure

plt.subplot(2,1,1)

plt.plot(s,color='red',linewidth=2)

plt.xlabel('t')

plt.subplot(2,1,2)

plt.plot(s[0:3000],color='blue')

plt.show()