GNU Radio Radar Toolbox
gr::radar::static_target_simulator_cc Class Referenceabstract

#include <static_target_simulator_cc.h>

Inheritance diagram for gr::radar::static_target_simulator_cc:
gr::radar::static_target_simulator_cc_impl

Public Types

typedef std::shared_ptr< static_target_simulator_ccsptr
 

Public Member Functions

virtual void setup_targets (std::vector< float > range, std::vector< float > velocity, std::vector< float > rcs, std::vector< float > azimuth, std::vector< float > position_rx, int samp_rate, float center_freq, float self_coupling_db, bool rndm_phaseshift, bool self_coupling)=0
 

Static Public Member Functions

static sptr make (std::vector< float > range, std::vector< float > velocity, std::vector< float > rcs, std::vector< float > azimuth, std::vector< float > position_rx, int samp_rate, float center_freq, float self_coupling_db, bool rndm_phaseshift=true, bool self_coupling=true, const std::string &len_key="packet_len")
 

Detailed Description

Simulates the backscattering of a given signal on point targets.

Implements the point scatter model. The input signal is the transmitted signal. The output signal is the received, backscattered signal, and contains one output signal per receive antenna.

Target modeling

The targets are modeled by the vectors range, velocity, rcs, and azimuth. All these vectors need to be of length H, where H describes the number of reflecting targets. The backscattered signal can either have a zero phase, or a random phase (controlled by rndm_phaseshift). The received signal will be the linear superposition of H signals, each of which are derived from the input signal by the following equation:

\[
    r_h(t) = b_h s(t - \tau_h) e^{j2\pi f_{D,h}}
\]

The attenuation depends on the center frequency $f_C$, the radar cross section $\sigma_{\text{RCS},h}$, the distance of the target $d_h$ and the speed of light $c_0$:

\[
    b_h = \sqrt{\frac{c_0^2 \sigma_{\text{RCS},h}}{(4\pi)^3 d_h^4 f_C^2}}
\]

The delay $\tau_h$ depends on the distance of the target:

\[
    \tau_h = 2\frac{d_h}{c_0}
\]

The Doppler shift $f_{D,h}$ depends on the relative velocity and the center frequency:

\[
    f_{D,h} = 2\frac{v_{\text{rel},h}{c_0} f_C
\]

The signals are added up to produce the total sum signal:

\[
    r(t) = \sum_{h=0}^{H-1} r_h(t)
\]

MIMO processing simulation

This block has a limited capability of simulating multi-antenna reception. The position_rx vector determines the distance of every RX antenna from the origin (Note: The TX antenna is always in the origin). The length of the position_rx vector is thus also the number of output signals this block produces. For a simple, mono-static SISO radar, simply set position_rx to [0]. The RX antennas are always laid out in a straight line. When multiple antennas are given, the target azimuth plays a role; an azimuth of zero is perpendicular to the line in which the RX antennas are placed.

Self-coupling

Self-coupling describes the amount of the TX signal that is directly coupled into the RX path. When self_coupling is set to true, effectively, a target with zero velocity and range is added. The parameter self_coupling_db describes the attenuation of the self-coupling, a value of -10 means that the transmit signal is attenuated by 10 dB on the receive signal.

Member Typedef Documentation

◆ sptr

Member Function Documentation

◆ make()

static sptr gr::radar::static_target_simulator_cc::make ( std::vector< float >  range,
std::vector< float >  velocity,
std::vector< float >  rcs,
std::vector< float >  azimuth,
std::vector< float >  position_rx,
int  samp_rate,
float  center_freq,
float  self_coupling_db,
bool  rndm_phaseshift = true,
bool  self_coupling = true,
const std::string &  len_key = "packet_len" 
)
static
Parameters
rangeTarget ranges as vector (length H)
velocityTarget velocities as vector (length H)
rcsTarget RCS as vector (length H)
azimuthTarget azimuth as vector (length H)
position_rxPosition RX antennas. A value of [0] means there is one antenna, located in the origin (simple monostatic case).
samp_rateSample rate (samples per second)
center_freqCenter frequency (Hz)
self_coupling_dbSelf coupling attenuation (dB)
rndm_phaseshiftToggle random phaseshift on targets
self_couplingToggle self coupling
packet_lenPacket length key for tagged stream

◆ setup_targets()

virtual void gr::radar::static_target_simulator_cc::setup_targets ( std::vector< float >  range,
std::vector< float >  velocity,
std::vector< float >  rcs,
std::vector< float >  azimuth,
std::vector< float >  position_rx,
int  samp_rate,
float  center_freq,
float  self_coupling_db,
bool  rndm_phaseshift,
bool  self_coupling 
)
pure virtual

The documentation for this class was generated from the following file: