Radar

class Radar(waveform=None, receive_beamformer=None, detector=None, selected_transmit_ports=None, selected_receive_ports=None, carrier_frequency=None, seed=None)

Bases: RadarBase[RadarTransmission, RadarReception], Serializable

Signal processing pipeline of a monostatic radar sensing its environment.

The radar can be configured by assigning four composite objects to respective property attributes:

Property	Type
waveform	RadarWaveform
receive_beamformer	ReceiveBeamformer
detector	RadarDetector

Of those, only a RadarWaveform is mandatory. Beamformers, i.e. a TransmitBeamformer and a ReceiveBeamformer, are only required when the radar is assigned to a Device configured to multiple antennas. A RadarDetector is optional, if not configured the radar’s generated RadarReception will not contain a RadarPointCloud.

When assigned to a Device, device transmission will trigger the radar to generate a RadarTransmission by executing the following sequence of calls:

        sequenceDiagram

participant Device
participant Radar
participant RadarWaveform
participant TransmitBeamformer

Device ->> Radar: _transmit()
Radar ->> RadarWaveform: ping()
RadarWaveform -->> Radar: Signal
Radar ->>  TransmitBeamformer: transmit(Signal)
TransmitBeamformer -->> Radar: Signal
Radar -->> Device: RadarTransmission
    

Initially, the ping method of the RadarWaveform is called to generate the model of a single-antenna radar frame. For Devices configured to multiple antennas, the configured TransmitBeamformer is called to encode the signal for each antenna. The resulting multi-antenna frame, contained within the return RadarTransmission, is cached at the assigned Device.

When assigned to a Device, device reception will trigger the radar to generate a RadarReception by executing the following sequence of calls:

        sequenceDiagram

    participant Device
    participant Radar
    participant ReceiveBeamformer
    participant RadarWaveform
    participant RadarDetector

    Device ->> Radar: _receive(Signal)
    Radar ->> ReceiveBeamformer: probe(Signal)
    ReceiveBeamformer -->> Radar: line_signals
    loop
        Radar ->> RadarWaveform: estimate(line_signal)
        RadarWaveform -->> Radar: line_estimate
    end
    Radar ->> RadarDetector: detect(line_estimates)
    RadarDetector -->> Radar: RadarPointCloud
    Radar -->> Device: RadarReception
    

Initially, the probe method of the ReceiveBeamformer is called to generate a sequence of line signals from each direction of interest. We refer to them as line signals as they are the result of an antenna arrays beamforing towards a single direction of interest, so the signal can be though of as having propagated along a single line pointing towards the direction of interest. This step is only executed for Devices configured to multiple antennas. The sequence of line signals are then indiviually processed by the estimate method of the RadarWaveform, resulting in a line estimate representing a range-doppler map for each direction of interest. This sequence line estimates is combined to a single RadarCube. If a RadarDetector is configured, the detect method is called to generate a RadarPointCloud from the RadarCube. The resulting information is cached as a RadarReception at the assigned Device.

Parameters:

• waveform (RadarWaveform | None) – Description of the waveform to be transmitted and received by this radar. None if no waveform is configured.

• receive_beamformer (ReceiveBeamformer | None) – Beamforming applied during signal reception. If not specified, no beamforming will be applied during reception.

• detector (RadarDetector | None) – Detector routine configured to generate point clouds from radar cubes. If not specified, no point cloud will be generated during reception.

• selected_transmit_ports (Optional[Sequence[int]]) – Indices of antenna ports selected for transmission from the operated Device's antenna array. If not specified, all available ports will be considered.

• selected_receive_ports (Optional[Sequence[int]]) – Indices of antenna ports selected for reception from the operated Device's antenna array. If not specified, all available antenna ports will be considered.

• carrier_frequency (float | None) – Central frequency of the mixed signal in radio-frequency transmission band. If not specified, the operated device’s default carrier frequency will be assumed during signal processing.

• seed (int | None) – Random seed used to initialize the pseudo-random number generator.

_receive(signal, device)

Process a received signal by the receiver.

Subroutine of the public receive method that performs the pipeline-specific receive processing and consolidates the inferred information into a single Reception object.

Parameters:

• signal (Signal) – Multi-stream signal model to be processed.

• state – Device state to be considered during reception.

Return type:

RadarReception

Returns:

Information inferred from the received signal.

_transmit(device, duration)

Generate information to be transmitted.

Subroutine of the public transmit method that performs the pipeline-specific transmit-processing and consolidates the generated information into a single hermespy.core.device.Transmission object.

Parameters:

• state – State of the device at the time of transmission.

• duration (float) – Duration of the transmitted signal in seconds. If not specified, the duration of a single frame will be assumed.

Return type:

RadarTransmission

Returns: Information to be transmitted.

serialize(process)

Serialize this object’s state.

Objects cannot be serialized directly, instead a Factory must be instructed to carry out the serialization process.

Parameters:

process (SerializationProcess) – The current stage of the serialization process. This object is generated by the Factory and provides an interface to serialization methods supporting multiple backends.

Return type:

None

velocity_resolution(carrier_frequency)

The radar’s velocity resolution in meters per second.

Denoted by \(\Delta v\) of unit \(\left[ \Delta v \right] = \frac{\mathrm{m}}{\mathrm{s}}\) in literature. Computed as :rtype: float

\[\Delta v = \frac{c_0}{f_{\mathrm{c}}} \Delta f_{\mathrm{Res}}\]

querying the configured RadarWaveform’s relative_doppler_resolution property \(\Delta f_{\mathrm{Res}}\).

property frame_duration: float

Duration of a single sample frame in seconds.

Denoted as \(T_{\mathrm{F}}\) of unit \(\left[ T_{\mathrm{F}} \right] = \mathrm{s}\) in literature.

property max_range: float

The radar’s maximum detectable range in meters.

Denoted by \(R_{\mathrm{Max}}\) of unit \(\left[ R_{\mathrm{Max}} \right] = \mathrm{m}\) in literature. Convenience property that resolves to the configured RadarWaveform’s max_range property. Returns \(R_{\mathrm{Max}} = 0\) if no waveform is configured.

property power: float

Expected power of the transmitted signal in Watts.

Note

Applies only to the signal-carrying parts of the transmission, silent parts shuch as guard intervals should not be considered.

property sampling_rate: float

The operator’s preferred sampling rate in Hz.

Denoted as \(f_{\mathrm{S}}\) of unit \(\left[ f_{\mathrm{S}} \right] = \mathrm{Hz} = \tfrac{1}{\mathrm{s}}\) in literature.

property waveform: RadarWaveform | None

Description of the waveform to be transmitted and received by this radar.

None if no waveform is configured.

During _transmit, the RadarWaveform’s ping() method is called to generate a signal to be transmitted by the radar.

During _receive, the RadarWaveform’s estimate() method is called multiple times to generate range-doppler line estimates for each direction of interest.

class RadarBase(receive_beamformer=None, detector=None, selected_transmit_ports=None, selected_receive_ports=None, carrier_frequency=None, seed=None)

Bases: Generic[RTT, RRT], Transmitter[RTT], Receiver[RRT]

Base class class for radar sensing signal processing pipelines.

Parameters:

• receive_beamformer (ReceiveBeamformer | None) – Beamforming applied during signal reception. If not specified, no beamforming will be applied during reception.

• detector (RadarDetector | None) – Detector routine configured to generate point clouds from radar cubes. If not specified, no point cloud will be generated during reception.

• selected_transmit_ports (Optional[Sequence[int]]) – Indices of antenna ports selected for transmission from the operated Device's antenna array. If not specified, all available ports will be considered.

• selected_receive_ports (Optional[Sequence[int]]) – Indices of antenna ports selected for reception from the operated Device's antenna array. If not specified, all available antenna ports will be considered.

• carrier_frequency (float | None) – Central frequency of the mixed signal in radio-frequency transmission band. If not specified, the operated device’s default carrier frequency will be assumed during signal processing.

• seed (int | None) – Random seed used to initialize the pseudo-random number generator.

serialize(process)

Serialize this object’s state.

Objects cannot be serialized directly, instead a Factory must be instructed to carry out the serialization process.

Parameters:

process (SerializationProcess) – The current stage of the serialization process. This object is generated by the Factory and provides an interface to serialization methods supporting multiple backends.

Return type:

None

property detector: RadarDetector | None

Detector routine configured to generate point clouds from radar cubes.

If configured, during _receive, the detector’s detect method is called to generate a RadarPointCloud. If not configured, i.e. None, the generated RadarReception’s cloud property will be None.

property receive_beamformer: ReceiveBeamformer | None

Beamforming applied during signal reception.

The TransmitBeamformer’s probe method is called as a subroutine of Receiver.receive().

Configuration is required if the assigned Device features multiple antennas.