step

Calculate the amplitude of a signal propagating in free space from a radar at (40000,0,0) to a target at (300,200,50). Assume both the radar and the target are stationary. The sample rate is 8000 Hz while the operating frequency of the radar is 300 MHz. Transmit five samples of a unit amplitude signal. The signal propagation speed takes the default value of the speed of light. Examine the amplitude of the signal at the target.

fs = 8e3;
fop = 3e8;
freesp = phased.FreeSpace(SampleRate=fs, ...
    OperatingFrequency=fop);
pos1 = [40000;0;0];
pos2 = [300;200;50];
vel1 = [0;0;0];
vel2 = [0;0;0];

Create the transmitted signal.

x = ones(5,1);

Find the received signal at the target.

y = freesp(x,pos1,pos2,vel1,vel2);
disp(y)

   1.0e-05 *

   0.0000 + 0.0000i
   0.1870 - 0.0229i
   0.1988 - 0.0243i
   0.1988 - 0.0243i
   0.1988 - 0.0243i

The first sample is zero because the signal has not yet reached the target.

Manually compute the loss using the formula

R = sqrt((pos1-pos2)'*(pos1-pos2));
lambda = physconst('Lightspeed')/fop;
L = (4*pi*R/lambda)^2

L = 
2.4924e+11

Because the transmitted amplitude is unity, the magnitude-squared value of the signal at the target for the third sample equals the inverse of the loss.

disp(1/abs(y(3))^2)

   2.4924e+11

Calculate the result of propagating a signal in free space from a radar at (1000,0,0) to a target at (300,200,50). Assume the radar moves at 10 m/s along the x-axis, while the target moves at 15 m/s along the y-axis. The sample rate is 8000 Hz while the operating frequency of the radar is 300 MHz. The signal propagation speed takes the default value of the speed of light. Transmit five samples of a unit amplitude signal and examine the amplitude of the signal at the target.

fs = 8000;
fop = 3e8;
freesp = phased.FreeSpace(SampleRate=fs, ...
    OperatingFrequency=fop);
pos1 = [1000;0;0];
pos2 = [300;200;50];
vel1 = [10;0;0];
vel2 = [0;15;0];
y = freesp(ones(5,1),pos1,pos2,vel1,vel2);
disp(y)

   1.0e-03 *

   0.0126 - 0.1061i
   0.0117 - 0.1083i
   0.0105 - 0.1085i
   0.0094 - 0.1086i
   0.0082 - 0.1087i

Because the transmitted amplitude is unity, the square of the signal at the target equals the inverse of the loss.

disp(1/abs(y(2))^2)

   8.4206e+07

Create a uniform linear array (ULA) consisting of four short-dipole antenna elements that support polarization. Set the orientation of each dipole to the z-direction. Set the operating frequency to 300 MHz and the element spacing of the array to 0.4 meters. While the antenna element supports polarization, you must explicitly enable polarization in the Radiator System object™.

Create the short-dipole antenna element, ULA array, and radiator System objects. Set the CombineRadiatedSignals property to true to coherently combine the radiated signals from all antennas and the Polarization property to 'Combined' to process polarized waves.

freq = 300e6;
nsensors = 4;
c = physconst('LightSpeed');
antenna = phased.ShortDipoleAntennaElement('FrequencyRange',[100e6 900e6],...
    'AxisDirection','Z');
array = phased.ULA('Element',antenna,...
    'NumElements',nsensors,...
    'ElementSpacing',0.4);
radiator = phased.Radiator('Sensor',array,...
    'PropagationSpeed',c,...
    'OperatingFrequency',freq,...
    'CombineRadiatedSignals',true,...
    'Polarization','Combined',...
    'WeightsInputPort',true);

Create a signal to be radiated. In this case, the signal consists of one cycle of a 4 kHz sinusoid. Set the signal amplitude to unity. Set the sampling frequency to 8 kHz. Choose radiating angles of 0 degrees azimuth and 20 degrees elevation. For polarization, you must set a local axes - in this case chosen to coincide with the global axes. Set uniform weights on the elements of the array.

fsig = 4000;
fs = 8000;
A = 1;
t = [0:0.01:2]/fs;
signal = A*sin(2*pi*fsig*t');
radiatingAngles = [0;20];
laxes = ones(3,3);
y = radiator(signal,radiatingAngles,laxes,[1,1,1,1].');
disp(y)

    X: [201x1 double]
    Y: [201x1 double]
    Z: [201x1 double]

The radiated signal is a struct containing the polarized field.

Use a FreeSpace System object to propagate the field from the origin to the destination.

propagator = phased.FreeSpace('PropagationSpeed',c,...
    'OperatingFrequency',freq,...
    'TwoWayPropagation',false,...
    'SampleRate',fs);

Set the signal origin, signal origin velocity, signal destination, and signal destination velocity.

origin_pos = [0; 0; 0];
dest_pos = [500; 200; 50];
origin_vel = [10; 0; 0];
dest_vel = [0; 15; 0];

Call the FreeSpace object to propagate the signals.

yprop = propagator(y,origin_pos,dest_pos,...
    origin_vel,dest_vel);

Plot the x-component of the propagated signals.

figure
plot(1000*t,real(yprop.X))
xlabel('Time (millisec)')

Create a FreeSpace System object™ to propagate a signal from one point to multiple points in space. Start by defining a signal origin and three destination points, all at different ranges.

Compute the propagation direction angles from the source to the destination locations. The source and destination are stationary.

pos1 = [0,0,0]';
vel1 = [0,0,0]';
pos2 = [[700;700;100],[1400;1400;200],2*[2100;2100;400]];
vel2 = zeros(size(pos2));
[rngs,radiatingAngles] = rangeangle(pos2,pos1);

Create the cosine antenna element, ULA array, and Radiator System objects.

fs = 8000;
freq = 300e6;
nsensors = 4;
sAnt = phased.CosineAntennaElement;
sArray = phased.ULA('Element',sAnt,'NumElements',nsensors);
sRad = phased.Radiator('Sensor',sArray,...
    'OperatingFrequency',freq,...
    'CombineRadiatedSignals',true,'WeightsInputPort',true);

Create a signal to be one cycle of a sinusoid of amplitude one and having a frequency of 4 kHz.

fsig = 4000;
t = [0:0.01:2]'/fs;
signal = sin(2*pi*fsig*t);

Radiate the signals in the destination directions. Apply a uniform weighting to the array.

y = step(sRad,signal,radiatingAngles,[1,1,1,1].');

Propagate the signals to the destination points.

sFSp = phased.FreeSpace('OperatingFrequency',freq,'SampleRate',fs);
yprop = step(sFSp,y,pos1,pos2,vel1,vel2);

Plot the propagated signal magnitudes for each range.

figure
plot(1000*t,abs(yprop(:,1)),1000*t,abs(yprop(:,2)),1000*t,abs(yprop(:,3)))
ylabel('Signal Magnitude')
xlabel('Time (millisec)')