KerberosSDR代码笔记(5) 信号处理（采样时间延迟计算、相位差计算的2种方法、MUSIC算法）
https://github.com/rtlsdrblog/kerberossdr/blob/master/_signalProcessing/hydra_signal_processor.py
这部分是最重要的部分，它里面包含几个重要的算法，采样时间同步，相位同步，以及调用了空间谱估计算法。
# KerberosSDR Signal Processor
#
# Copyright (C) 2018-2019 Carl Laufer, Tamás Pető
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see 接下来看一下最常用的UCA均匀圆阵所涉及的几个函数的具体实现：
de.corr_matrix_estimate，de.gen_scanning_vectors，de.DOA_MUSIC
它们都来自于pyargus库
https://github.com/petotamas/pyArgus
这是一个跟天线阵有关的库，有3个主要的文件，antennaArrayPattern.py，这是用来绘制阵列天线方向图的，beamform.py，用来实现波束成形，directionEstimation.py，计算信号到达角的，除此之外还有一些用来测试的程序以及配套文档。
这几个模块互相之间没有依赖，所以我们可以直接看directionEstimation.py
https://github.com/petotamas/pyArgus/blob/master/pyArgus/directionEstimation.py
以及它的文档：
https://github.com/petotamas/pyArgus/blob/master/docs/nb_direction_of_arrival_estimaton.ipynb
ipynb可以用github直接查看，但是网速不好可能打不开，可以尝试这个网站nbviewer.jupyter.org
测向原理可以参考这篇文章：
https://blog.csdn.net/qq_23947237/article/details/82318222
它解释了为什么经过它提出的步骤就能测出方向。
这个步骤总结一下就是：
1.先求出阵列矩阵(scanning vector)
阵列矩阵跟阵形有关，上面那个博客里用的是线阵，但是我们实际python代码里用的是更一般化的代码，只需要填写x,y的信息，可以生成面阵的阵列矩阵
2.求协方差矩阵(correlation matrix)
可以用接收机通道上收到的大量的采样点来估计出这个协方差矩阵
3.求出噪声子空间
对协方差矩阵做特征值分解，得到这个噪声子空间
4.计算空间谱函数
利用阵列矩阵和噪声子空间计算空间谱函数，就能得到music的波形，最后做谱峰搜索就能得到入射角（程序其它部分做的）。
下面是我从hydra_signal_processing.py里摘录的使用UCA和MUSIC算法时会调用到的代码，基本就是按照上面的步骤做的，只不过把第一步和第二步换了一下顺序，这个没有影响。
iq_samples = self.module_receiver.iq_samples[:, 0:self.DOA_sample_size]
#首先要截取iq_samples，4个通道的数据都要，所以每行都要了，行用了冒号表示
#但是DOA算法只需要计算DOA_sample_size长度的数据，所以列是0:self.DOA_sample_size
R = de.corr_matrix_estimate(iq_samples.T, imp="fast")
#使用大量的采样点来估计协方差矩阵
M = np.size(iq_samples, 0)
#iq_samples的行数，就是接收机通道数，4
self.DOA_theta = np.linspace(0,360,361)
#生成0~360，一共361个数字的等间隔数列，self.DOA_theta=[0 1 2 3 ... 360]
x = self.DOA_inter_elem_space * np.cos(2*np.pi/M * np.arange(M))
y = self.DOA_inter_elem_space * np.sin(-2*np.pi/M * np.arange(M))
#DOA_inter_elem_space里是lamda 天线间距/波长 对于圆阵还要除以sqrt(2)，晚点确认？
#np.arange(4)会生成一个数组[0 1 2 3]
#如果暂时忽略掉self.DOA_inter_elem_space
#只考虑np.cos(2*np.pi/M * np.arange(M))和np.sin(-2*np.pi/M * np.arange(M))
#它们会生成单位圆与横轴右侧交点开始逆时针旋转，均匀分布的4个点，x和y分别是这些点的横坐标和纵坐标
#[x,y] = [1,0] [0,-1] [-1,0] [0,1] 实际x和y还要乘以lamda
scanning_vectors = de.gen_scanning_vectors(M, x, y, self.DOA_theta)
#根据阵列的空间布局（包括阵形和lamda)来计算阵列向量
self.DOA_MUSIC_res = de.DOA_MUSIC(R, scanning_vectors, signal_dimension = 1)
#根据协方差矩阵和阵列向量来做MUSIC计算
#signal_dimension是待测信号数量，这里规定了只有1个待测信号可以看到hydra_signal_processing.py在做music算法时虽然步骤和理论差不多，但是只是调用了几个pyargus里的函数，具体的操作在pyargus中，我摘录了对应的几个函数。
def corr_matrix_estimate(X, imp="mem_eff"):
"""
Estimates the spatial correlation matrix with sample averaging
Implementation notes:
--------------------
Two different implementation exist for this function call. One of them use a for loop to iterate through the
signal samples while the other use a direct matrix product from numpy. The latter consumes more memory
(as all the received coherent multichannel samples must be available at the same time)
but much faster for large arrays. The implementation can be selected using the "imp" function parameter.
Set imp="mem_eff" to use the memory efficient implementation with a for loop or set to "fast" in order to use
the faster direct matrix product implementation.
Parameters:
-----------
:param X : Received multichannel signal matrix from the antenna array.
:param imp: Selects the implementation method. Valid values are "mem_eff" and "fast". The default value is "mem_eff".
:type X: N x M complex numpy array N is the number of samples, M is the number of antenna elements.
:type imp: string
Return values:
-------------
:return R : Estimated spatial correlation matrix
:rtype R: M x M complex numpy array
:return -1 : When unidentified implementation method was specified
"""
#由于调用这个函数的时候，iq_sample做了转置(iq_sample.T)
#因此X变量里现在的列数是4列，对应4个接收机通道，行数是每一个接收机通道的采样点数量
N = np.size(X, 0) #每个通道采样点数量
M = np.size(X, 1) #接收机通道数，4个
R = np.zeros((M, M), dtype=complex)
# --input check--
if N < M:
print("WARNING: Number of antenna elements is greather than the number of time samples") #如果采样点比接收机通道少，那肯定不行
print("WARNING: You may flipped the input matrix")
# --calculation--
if imp == "mem_eff":
for n in range(N):
R += np.outer(X[n, :], np.conjugate(X[n, :]))
elif imp == "fast":
X = X.T #现在X矩阵又做了一次转置，那么X里面现在就是原始的iq_samples了
#根据协方差矩阵的估计公式（参考那篇博客的文章）
#接收机采样点矩阵乘以自己的共轭转置，再累加，再除以采样点数量就行
#矩阵右上角的H就代表共轭转置
#下面这一行做的就是采样点乘以自己的共轭转置并累加了
R = np.dot(X, X.conj().T)
else:
print("ERROR: Unidentified implementation method")
print("ERROR: No output is generated")
return -1
#下面这一行做的是除以采样点数量，做完了就得到协方差矩阵的估计值了
R = np.divide(R, N)
return R
def gen_scanning_vectors(M, x, y, thetas):
"""
Description:
------------
This function prepares scanning vectorors for general antenna array configurations
#这里生成的是广义的阵列天线的阵列矩阵，更接近面阵或者任意平面阵
Parameters:
-----------
:param M : Number of antenna elements on the circle
:param x : x coordinates of the antenna elements on a plane
:param y : y coordinates of the antenna elements on a plane
:param thetas : A vector containing the incident angles e.g.: [0deg, 1deg, 2deg, ..., 180 deg]
:type M: int
:type x: 1D numpy array
:type y: 1D numpy array
:type R: float
:type thetas: 1D numpy array
Return values:
-------------
:return scanning_vectors : Estimated signal dimension
:rtype scanning_vectors: 2D numpy array with size: M x P, where P is the number of incident angles
"""
scanning_vectors = np.zeros((M, np.size(thetas)), dtype=complex)
#np.zeros会生成4行，361列的数组
for i in range(np.size(thetas)):
scanning_vectors[:,i] = np.exp(1j*2*np.pi* (x*np.cos(np.deg2rad(thetas[i])) + y*np.sin(np.deg2rad(thetas[i]))))
#我暂时还没找到面阵的阵列矩阵的公式，但是那篇博客里的线阵公式看着也差不多
#也是e^(-j*(N)*2*pi*d*sin(theta)/lamda)，复数表示差不多，但是公式里lamda在分母
#我这里x,y里包含了lamda，但是它们在分子上
return scanning_vectors
def DOA_MUSIC(R, scanning_vectors, signal_dimension, angle_resolution = 1):
"""
MUSIC - Multiple Signal Classification method
Description:
------------
The function implements the MUSIC method for direction estimation
Calculation method :
1
ADORT(theta) = ---------------------------
H H
S(theta) * En En * S(theta)
#这个公式和那篇博客文章里的空间谱函数一样，现在S(theta)也就是阵列矩阵已经直接传入了
#我们只需要算出En就行，它是噪声子空间
Parameters:
-----------
:param R: spatial correlation matrix
:param scanning_vectors : Generated using the array alignment and the incident angles
:param signal_dimension: Number of signal sources
:type R: 2D numpy array with size of M x M, where M is the number of antennas in the antenna system
:tpye scanning vectors: 2D numpy array with size: M x P, where P is the number of incident angles
:type signal_dimension: int
Return values:
--------------
:return ADORT : Angular dependent orthogonality. Expresses the orthongonality of the current steering vector to the
noise subspace
:rtype : numpy array
:return -1, -1: Input spatial correlation matrix is not quadratic
:return -2, -2: dimension of R not equal with dimension of the antenna array
:return -3, -3: Spatial correlation matrix is singular
"""
# --- Parameters ---
# --> Input check
if np.size(R, 0) != np.size(R, 1): #协方差矩阵应该是一个方阵
print("ERROR: Correlation matrix is not quadratic")
return -1, -1
if np.size(R, 0) != np.size(scanning_vectors, 0):
#阵列矩阵的列数要和协方差矩阵相同，都是通道数4
print("ERROR: Correlation matrix dimension does not match with the antenna array dimension")
return -2, -2
ADORT = np.zeros(np.size(scanning_vectors, 1),dtype=complex)
#这是计算出的谱函数，横坐标就是所有角度0~360，就是阵列矩阵的列数
M = np.size(R, 0) #用协方差矩阵的行数得到通道数
# --- Calculation ---
# Determine eigenvectors and eigenvalues
sigmai, vi = lin.eig(R) #求协方差矩阵R的特征值sigmai和特征向量vi
#sigmai 是一行数组，每一元素是一个特征值
#vi 也是一行，但是是数组套数组，每一个元素都是一个特征向量
#这个特征向量本身也是一行数组
#比如
#矩阵A：
# [[ 3 -1]
# [-1 3]]
#特征值a：
[4. 2.]
#特征向量b：
[[ 0.70710678 0.70710678] [-0.70710678 0.70710678]]
#array里存储的必须是同一类型的数据，list中的元素可以类型不同
# Sorting
#信号子空间是由大的特征值对应的特征向量张成的子空间
#噪声子空间是由小的特征值对应的特征向量张成的子空间
#要找出噪声子空间，就要找小的特征值，要排序
#接下来做的就是按照特征值的绝对值大小对特征向量排序
eig_array = []
for i in range(M):
eig_array.append([np.abs(sigmai[i]),vi[:,i]])
#先把特征值的绝对值和特征向量放到一行里，然后再把它们合并成一个元素放到一个list里
#一共M(4)个接收机，协方差矩阵是4x4的，所以特征值和特征向量有4组
#那么这个list有4个元素，每个元素的第一个子元素是特征值的绝对值eig_array[0]
#第二个子元素是对应的特征向量
#[[特征值1,[特征向量1[0],特征向量1[1],特征向量1[2],特征向量1[3]]],
# [特征值2,[特征向量2[0],特征向量2[1],特征向量2[2],特征向量2[3]]],
# [特征值3,[特征向量3[0],特征向量3[1],特征向量3[2],特征向量3[3]]],
# [特征值4,[特征向量4[0],特征向量4[1],特征向量4[2],特征向量4[3]]]]
eig_array = sorted(eig_array, key=lambda eig_array: eig_array[0], reverse=False)
#sorted对所有可迭代对象进行排序
#key是用来比较的元素，这个参数来自于可迭代的对象中，就是eig_array[0]
#reverse=False，代表是从小到大排序的
# Generate noise subspace matrix
noise_dimension = M - signal_dimension
#M是特征值总数，减去信号子空间的大小（1个信号发射机，信号子空间就对应1个特征值？）
#就得到了噪声子空间的大小
E = np.zeros((M,noise_dimension),dtype=complex)
#E是4行3列的array，现在里面都是0
#根据这个尺寸，应该是把3个噪声子空间对应的特征向量竖着存放，
#每一列对应一个噪声子空间的特征向量
for i in range(noise_dimension):
E[:,i] = eig_array[i][1]
#i的范围是0，1，2，一开头是0
#eig_array[i][1]，就是eig_array[0][1]，就是eig_array的第一个元素的第二个子元素，
#经过排序，第一个元素就是特征值最小的那一对特征值+特征向量
#第二个子元素就是这个特征向量了，所以E[:,0]里存的是特征向量
#只不过E里是把特征向量竖过来存储的，所以是所有行（4行）和第一列是这个特征值向量
#等所有3个噪声特征值对应的特征向量存完以后E就是噪声子空间了
E = np.matrix(E)
theta_index=0
for i in range(np.size(scanning_vectors, 1)):
#scanning_vectors里有4行361列，所以i的范围就是0～360
S_theta_ = scanning_vectors[:, i]
#每行都要（对应4个接收机通道），列对应每个角度，这是阵列矩阵
S_theta_ = np.matrix(S_theta_).getT()
#从4行1列转为1行4列，暂时不知道为什么要转置？可能是为了下面的矩阵乘法？
ADORT[theta_index]= 1/np.abs(S_theta_.getH()*(E*E.getH())*S_theta_)
#这个公式就是空间谱密度的公式
theta_index += 1 #这个theta_index就跟i一样
return ADORT