beamforming

Does this make sense?

Explaining mathy concepts one step at a time.

POSTED BY

JYYUAN

POSTED ON

DECEMBER 16, 2013

POSTED UNDER

ELECTRICAL ENGINEERING, PROGRAMMING, PYTHON, SIGNAL PROCESSING

We have N phone elements. For simplicity, let’s say they are equally spaced, d distance apart, in a

perfectly straight line. We have something making noise somewhat nearby, and we want to make a

guess at what direction the sound is coming from. Since sound takes time to travel through air (or water,

choose a medium), we can use our N phone elements to detect where the sound is coming from. And

how do we do that? Depending what direction the sound is coming from, it will have a certain time

delay between phones, and if we can correctly guess it, we will know what direction the sound came

from.

For now, we will use a really simple sound model, with basic attenuation and no reverberation. Say we

have a sound source such that the data from each microphone is , where

is additive white Gaussian noise, uncorrelated in time and across phones. In our model with

if the elements are not spaced equally, should be replaced with the actual distance from reference to

n phone). Then, theoretically, we can say for each phone, if we want to look in the direction, we can do

a delay-and-sum technique to get a signal coming from the direction we are looking in.

here is the time shift we apply by setting a beam direction, or a direction where we are looking, and

can be calculated similarly to the time delays of the incoming signal with a negative sign in front. By

summing up these time-shifted versions of our signal, we can get a general idea of the signal coming

from each direction rather than on a phone-by-phone basis. You can see from the equation if our beam

looks in the direction of our signal such that the time delay of the signal in the phone data is canceled

out by the time-shifting for beamforming in a certain direction, we get attain basically perfect signal

reconstruction and weaker noise to boot.

Below I have included plots showing 32 phones reading in a signal with small additive noise, doing

frequency domain beamforming, and plotting received power and signal for phones and beams. I run

the program with the incident angle coming from three different direction. The Python code is included

below, sorry for the sloppiness, my Python isn’t quite up the speed yet.

1

2

3

4

5

6

13

14

15

16

17

18

19

20

21

22

29

30

31

32

33

34

35

36

37

38

45

46

47

48

49

50

51

52

53

54

</pre>

sound_speed, \

spacing, \

noise_pwr,

signal_pwr,

sampling_rate, \

samples, \

signal_hz, \

signal_dir):

'''function to make simulated phone data'''

# generate data matrix, samples x nphones

time_delays = spacing/sound_speed

fft_freqs = np.matrix(np.linspace( 0, sampling_rate, samples, endpoint

time_delays = np.matrix(np.cos(signal_dir)*time_delays)

spacial_filt = np.exp(2j*np.pi*fft_freqs.transpose()*time_delays)

spacial_filt = np.array(spacial_filt).transpose()

replicas = np.fft.irfft( \

np.array(np.fft.fft(signal))*spacial_filt, \

samples, 1 )

# add to data and then return it

data = data + replicas.transpose()

phone_data):

'''function to do conventional beamforming'''

56

57

58

59

60

61

68

69

70

71

72

73

74

75

76

77

84

85

86

87

88

89

90

91

92

93

100

101

102

103

104

105

106

107

108

109

# allocate space to put data

time_delays = np.matrix( (spacing/sound_speed))

fft_freqs = np.matrix(np.linspace( 0, sampling_rate, samples, endpoint

print fft_freqs.shape

print time_delays.shape

for ind, direction in enumerate(look_dirs):

spacial_filt = 1.0/nphones*np.exp(-2j*np.pi*fft_freqs*time_delays*

# fft the data, and let's beamform.

bf_data[:,ind] = np.sum(np.fft.irfft( np.fft.fft(phone_data,samples,