FMCW linear chirp signal implementation. More...

#include "radar_signal.h"

Inheritance diagram for fers_signal::FmcwChirpSignal:

Collaboration diagram for fers_signal::FmcwChirpSignal:

Public Member Functions
	FmcwChirpSignal (RealType chirp_bandwidth, RealType chirp_duration, RealType chirp_period, RealType start_frequency_offset=0.0, std::optional< std::size_t > chirp_count=std::nullopt, FmcwChirpDirection direction=FmcwChirpDirection::Up)
	Constructs an FMCW chirp signal with timing and sweep parameters.

	~FmcwChirpSignal () override=default

	FmcwChirpSignal (const FmcwChirpSignal &) noexcept=delete

FmcwChirpSignal &	operator= (const FmcwChirpSignal &) noexcept=delete

	FmcwChirpSignal (FmcwChirpSignal &&) noexcept=delete

FmcwChirpSignal &	operator= (FmcwChirpSignal &&) noexcept=delete

RealType	getChirpBandwidth () const noexcept
	Gets the chirp bandwidth in hertz.

RealType	getChirpDuration () const noexcept
	Gets the chirp duration in seconds.

RealType	getChirpPeriod () const noexcept
	Gets the chirp period in seconds.

RealType	getStartFrequencyOffset () const noexcept
	Gets the start frequency offset relative to carrier in hertz.

const std::optional< std::size_t > &	getChirpCount () const noexcept
	Gets the optional finite chirp count.

RealType	getChirpRate () const noexcept
	Gets the chirp rate in hertz per second.

RealType	getSignedChirpRate () const noexcept
	Gets the signed chirp rate in hertz per second.

FmcwChirpDirection	getDirection () const noexcept
	Gets the FMCW sweep direction.

bool	isDownChirp () const noexcept
	Returns true when this chirp sweeps downward.

bool	isTriangle () const noexcept
	Returns false for linear chirps; triangles override this shape predicate.

std::optional< std::size_t >	activeChirpIndexAt (RealType time_since_segment_start) const noexcept
	Returns the active chirp index for a time since the segment start.

bool	isActiveAt (RealType time_since_segment_start) const noexcept
	Returns true when the signal is inside an active chirp at the specified time.

RealType	basebandPhaseForChirpTime (RealType chirp_time) const noexcept
	Computes baseband phase for a time inside a chirp.

std::optional< RealType >	instantaneousBasebandPhase (RealType time_since_segment_start) const noexcept
	Computes instantaneous baseband phase at a time since segment start.

std::vector< ComplexType >	render (const std::vector< interp::InterpPoint > &points, unsigned &size, RealType fracWinDelay) const override
	Renders an FMCW waveform from interpolation points.

bool	isFmcwFamily () const noexcept override
	Returns true when this signal belongs to the FMCW waveform family.

void	clear () noexcept
	Clears the internal signal data.

void	load (std::span< const ComplexType > inData, unsigned samples, RealType sampleRate)
	Loads complex radar waveform data.

RealType	getRate () const noexcept
	Gets the sample rate of the signal.

unsigned	getSampleCount () const noexcept
	Gets the number of native samples held by this signal.

virtual std::vector< ComplexType >	renderSlice (const std::vector< interp::InterpPoint > &points, RealType outputStartTime, RealType outputSampleRate, std::size_t sampleCount, RealType fracWinDelay) const
	Renders a bounded absolute-time slice on the requested output grid.

ComplexType	sampleAt (RealType time_since_start) const noexcept
	Samples the finite stored complex envelope using the render interpolation filter.

Detailed Description

FMCW linear chirp signal implementation.

Definition at line 434 of file radar_signal.h.

Constructor & Destructor Documentation

◆ FmcwChirpSignal() [1/3]

fers_signal::FmcwChirpSignal::FmcwChirpSignal	(	RealType	chirp_bandwidth,
		RealType	chirp_duration,
		RealType	chirp_period,
		RealType	start_frequency_offset = `0.0`,
		std::optional< std::size_t >	chirp_count = `std::nullopt`,
		FmcwChirpDirection	direction = `FmcwChirpDirection::Up`
	)

Constructs an FMCW chirp signal with timing and sweep parameters.

Definition at line 147 of file radar_signal.cpp.

                                                                                                             :
        _chirp_bandwidth(chirp_bandwidth), _chirp_duration(chirp_duration), _chirp_period(chirp_period),
        _start_frequency_offset(start_frequency_offset), _chirp_count(chirp_count),
        _chirp_rate(chirp_bandwidth / chirp_duration), _direction(direction)
    {
    }

◆ ~FmcwChirpSignal()

fers_signal::FmcwChirpSignal::~FmcwChirpSignal ( )

overridedefault

◆ FmcwChirpSignal() [2/3]

fers_signal::FmcwChirpSignal::FmcwChirpSignal ( const FmcwChirpSignal & )

deletenoexcept

◆ FmcwChirpSignal() [3/3]

fers_signal::FmcwChirpSignal::FmcwChirpSignal ( FmcwChirpSignal && )

deletenoexcept

Member Function Documentation

◆ activeChirpIndexAt()

std::optional< std::size_t > fers_signal::FmcwChirpSignal::activeChirpIndexAt ( RealType time_since_segment_start ) const

noexcept

Returns the active chirp index for a time since the segment start.

Definition at line 157 of file radar_signal.cpp.

    {
        if (time_since_segment_start < 0.0)
        {
            return std::nullopt;
        }
 
        const auto chirp_index = static_cast<std::size_t>(std::floor(time_since_segment_start / _chirp_period));
        if (_chirp_count.has_value() && chirp_index >= *_chirp_count)
        {
            return std::nullopt;
        }
 
        const RealType chirp_time = time_since_segment_start - static_cast<RealType>(chirp_index) * _chirp_period;
        // Exact arithmetic cannot make this negative, but floating-point boundary rounding can.
        if (chirp_time < 0.0 || chirp_time >= _chirp_duration)
        {
            return std::nullopt;
        }
 
        return chirp_index;
    }

References max.

◆ basebandPhaseForChirpTime()

RealType fers_signal::FmcwChirpSignal::basebandPhaseForChirpTime ( RealType chirp_time ) const

noexcept

Computes baseband phase for a time inside a chirp.

Definition at line 193 of file radar_signal.cpp.

    {
        return 2.0 * PI * _start_frequency_offset * chirp_time + PI * getSignedChirpRate() * chirp_time * chirp_time;
    }

References max, and PI.

◆ clear()

void fers_signal::Signal::clear ( )

noexceptinherited

Clears the internal signal data.

Definition at line 347 of file radar_signal.cpp.

    {
        _size = 0;
        _rate = 0;
    }

Referenced by fers_signal::Signal::load().

Here is the caller graph for this function:

◆ getChirpBandwidth()

RealType fers_signal::FmcwChirpSignal::getChirpBandwidth ( ) const

noexcept

Gets the chirp bandwidth in hertz.

Definition at line 453 of file radar_signal.h.

453{ return _chirp_bandwidth; }

◆ getChirpCount()

const std::optional< std::size_t > & fers_signal::FmcwChirpSignal::getChirpCount ( ) const

noexcept

Gets the optional finite chirp count.

Definition at line 465 of file radar_signal.h.

465{ return _chirp_count; }

◆ getChirpDuration()

RealType fers_signal::FmcwChirpSignal::getChirpDuration ( ) const

noexcept

Gets the chirp duration in seconds.

Definition at line 456 of file radar_signal.h.

456{ return _chirp_duration; }

Referenced by serial::fmcw_validation::validateSchedule().

Here is the caller graph for this function:

◆ getChirpPeriod()

RealType fers_signal::FmcwChirpSignal::getChirpPeriod ( ) const

noexcept

Gets the chirp period in seconds.

Definition at line 459 of file radar_signal.h.

459{ return _chirp_period; }

Referenced by serial::fmcw_validation::validateSchedule().

Here is the caller graph for this function:

◆ getChirpRate()

RealType fers_signal::FmcwChirpSignal::getChirpRate ( ) const

noexcept

Gets the chirp rate in hertz per second.

Definition at line 468 of file radar_signal.h.

468{ return _chirp_rate; }

◆ getDirection()

FmcwChirpDirection fers_signal::FmcwChirpSignal::getDirection ( ) const

noexcept

Gets the FMCW sweep direction.

Definition at line 477 of file radar_signal.h.

477{ return _direction; }

◆ getRate()

RealType fers_signal::Signal::getRate ( ) const

noexceptinherited

Gets the sample rate of the signal.

Returns: The sample rate of the signal.

Definition at line 94 of file radar_signal.h.

94{ return _rate; }

◆ getSampleCount()

unsigned fers_signal::Signal::getSampleCount ( ) const

noexceptinherited

Gets the number of native samples held by this signal.

Definition at line 97 of file radar_signal.h.

97{ return _size; }

◆ getSignedChirpRate()

RealType fers_signal::FmcwChirpSignal::getSignedChirpRate ( ) const

noexcept

Gets the signed chirp rate in hertz per second.

Definition at line 471 of file radar_signal.h.

        {
            return isDownChirp() ? -_chirp_rate : _chirp_rate;
        }

◆ getStartFrequencyOffset()

RealType fers_signal::FmcwChirpSignal::getStartFrequencyOffset ( ) const

noexcept

Gets the start frequency offset relative to carrier in hertz.

Definition at line 462 of file radar_signal.h.

462{ return _start_frequency_offset; }

◆ instantaneousBasebandPhase()

std::optional< RealType > fers_signal::FmcwChirpSignal::instantaneousBasebandPhase ( RealType time_since_segment_start ) const

noexcept

Computes instantaneous baseband phase at a time since segment start.

Definition at line 181 of file radar_signal.cpp.

    {
        const auto chirp_index = activeChirpIndexAt(time_since_segment_start);
        if (!chirp_index.has_value())
        {
            return std::nullopt;
        }
 
        const RealType chirp_time = time_since_segment_start - static_cast<RealType>(*chirp_index) * _chirp_period;
        return basebandPhaseForChirpTime(chirp_time);
    }

References max.

◆ isActiveAt()

bool fers_signal::FmcwChirpSignal::isActiveAt ( RealType time_since_segment_start ) const

noexcept

Returns true when the signal is inside an active chirp at the specified time.

Definition at line 489 of file radar_signal.h.

        {
            return activeChirpIndexAt(time_since_segment_start).has_value();
        }

References max.

◆ isDownChirp()

bool fers_signal::FmcwChirpSignal::isDownChirp ( ) const

noexcept

Returns true when this chirp sweeps downward.

Definition at line 480 of file radar_signal.h.

480{ return _direction == FmcwChirpDirection::Down; }

fers_signal::FmcwChirpDirection::Down

@ Down

Instantaneous baseband frequency decreases over the chirp.

◆ isFmcwFamily()

bool fers_signal::FmcwChirpSignal::isFmcwFamily ( ) const

overridevirtualnoexcept

Returns true when this signal belongs to the FMCW waveform family.

Reimplemented from fers_signal::Signal.

Definition at line 505 of file radar_signal.h.

505{ return true; }

◆ isTriangle()

bool fers_signal::FmcwChirpSignal::isTriangle ( ) const

noexcept

Returns false for linear chirps; triangles override this shape predicate.

Definition at line 483 of file radar_signal.h.

483{ return false; }

◆ load()

void fers_signal::Signal::load	(	std::span< const ComplexType >	inData,
		unsigned	samples,
		RealType	sampleRate
	)

inherited

Loads complex radar waveform data.

Parameters

inData	The input span of complex signal data.
samples	The number of samples in the input data.
sampleRate	The sample rate of the input data.

Definition at line 353 of file radar_signal.cpp.

    {
        clear();
        const unsigned ratio = params::oversampleRatio();
        const auto oversampled_samples = static_cast<std::size_t>(samples) * static_cast<std::size_t>(ratio);
        if (oversampled_samples > std::numeric_limits<unsigned>::max())
        {
            throw std::overflow_error("Oversampled signal sample count exceeds unsigned range");
        }
        _data.resize(oversampled_samples);
        _size = static_cast<unsigned>(oversampled_samples);
        _rate = sampleRate * static_cast<RealType>(ratio);
 
        if (ratio == 1)
        {
            std::ranges::copy(inData, _data.begin());
        }
        else
        {
            upsample(inData, samples, _data);
        }
    }

References fers_signal::Signal::clear(), max, params::oversampleRatio(), and fers_signal::upsample().

Here is the call graph for this function:

◆ operator=() [1/2]

FmcwChirpSignal & fers_signal::FmcwChirpSignal::operator= ( const FmcwChirpSignal & )

deletenoexcept

◆ operator=() [2/2]

FmcwChirpSignal & fers_signal::FmcwChirpSignal::operator= ( FmcwChirpSignal && )

deletenoexcept

◆ render()

std::vector< ComplexType > fers_signal::FmcwChirpSignal::render	(	const std::vector< interp::InterpPoint > &	points,
		unsigned &	size,
		RealType	fracWinDelay
	)		const

overridevirtual

Renders an FMCW waveform from interpolation points.

Reimplemented from fers_signal::Signal.

Definition at line 198 of file radar_signal.cpp.

    {
        size = 0;
        return {};
    }

References max.

◆ renderSlice()

std::vector< ComplexType > fers_signal::Signal::renderSlice	(	const std::vector< interp::InterpPoint > &	points,
		RealType	outputStartTime,
		RealType	outputSampleRate,
		std::size_t	sampleCount,
		RealType	fracWinDelay
	)		const

virtualinherited

Renders a bounded absolute-time slice on the requested output grid.

Definition at line 413 of file radar_signal.cpp.

    {
        auto out = std::vector<ComplexType>(sampleCount);
        if (_size == 0 || _rate <= 0.0 || outputSampleRate <= 0.0 || points.empty())
        {
            return out;
        }
 
        const RealType timestep = 1.0 / outputSampleRate;
        const int filt_length = static_cast<int>(params::renderFilterLength());
        const auto& interp = interp::InterpFilter::getInstance();
 
        auto iter = points.begin();
        auto next = points.size() > 1 ? std::next(iter) : iter;
        const RealType idelay = std::round(_rate * iter->delay);
        RealType sample_time = outputStartTime;
 
        for (std::size_t i = 0; i < sampleCount; ++i)
        {
            while (sample_time > next->time && next != iter)
            {
                iter = next;
                if (std::next(next) != points.end())
                {
                    ++next;
                }
                else
                {
                    break;
                }
            }
 
            auto [amplitude, phase, fdelay, i_sample_unwrap] =
                calculateWeightsAndDelays(iter, next, sample_time, idelay, fracWinDelay);
            const RealType native_position = (sample_time - points.front().time) * _rate;
            const auto source_index = static_cast<int>(std::floor(native_position));
            RealType source_fraction = native_position - static_cast<RealType>(source_index);
            if (source_fraction < 0.0 && source_fraction > -1.0e-12)
            {
                source_fraction = 0.0;
            }
 
            const RealType combined_delay = fdelay + source_fraction;
            const auto delay_unwrap = static_cast<int>(std::floor(combined_delay));
            fdelay = combined_delay - static_cast<RealType>(delay_unwrap);
            i_sample_unwrap += delay_unwrap;
 
            const auto& filt = interp.getFilter(fdelay);
            const ComplexType accum =
                performConvolution(source_index, filt.data(), filt_length, amplitude, i_sample_unwrap);
            out[i] = std::exp(ComplexType(0.0, 1.0) * phase) * accum;
 
            sample_time += timestep;
        }
 
        return out;
    }

References interp::InterpFilter::getInstance(), max, and params::renderFilterLength().

Referenced by fers_signal::Signal::render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sampleAt()

ComplexType fers_signal::Signal::sampleAt ( RealType time_since_start ) const

noexceptinherited

Samples the finite stored complex envelope using the render interpolation filter.

Times outside [0, duration) return zero; file-backed signals never wrap implicitly.

Definition at line 376 of file radar_signal.cpp.

    {
        if (_data.empty() || _rate <= 0.0 || !std::isfinite(time_since_start) || time_since_start < 0.0 ||
            time_since_start >= static_cast<RealType>(_size) / _rate)
        {
            return {0.0, 0.0};
        }
 
        const RealType position = time_since_start * _rate;
        const auto center = static_cast<long long>(std::floor(position));
        const RealType fraction = position - std::floor(position);
        const auto& filter = interp::InterpFilter::getInstance().getFilter(fraction);
        const auto filter_length = static_cast<long long>(filter.size());
        const auto sample_count = static_cast<long long>(_data.size());
        ComplexType value{0.0, 0.0};
        for (long long tap = 0; tap < filter_length; ++tap)
        {
            const long long sample_index = center + tap - filter_length / 2;
            if (sample_index >= 0 && sample_index < sample_count)
            {
                value += _data[static_cast<std::size_t>(sample_index)] * filter[static_cast<std::size_t>(tap)];
            }
        }
        return value;
    }

References interp::InterpFilter::getFilter(), interp::InterpFilter::getInstance(), max, and position.

Here is the call graph for this function:

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

packages/libfers/src/signal/radar_signal.h
packages/libfers/src/signal/radar_signal.cpp

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ FmcwChirpSignal() [1/3]

◆ ~FmcwChirpSignal()

◆ FmcwChirpSignal() [2/3]

◆ FmcwChirpSignal() [3/3]

Member Function Documentation

◆ activeChirpIndexAt()

◆ basebandPhaseForChirpTime()

◆ clear()

◆ getChirpBandwidth()

◆ getChirpCount()

◆ getChirpDuration()

◆ getChirpPeriod()

◆ getChirpRate()

◆ getDirection()

◆ getRate()

◆ getSampleCount()

◆ getSignedChirpRate()

◆ getStartFrequencyOffset()

◆ instantaneousBasebandPhase()

◆ isActiveAt()

◆ isDownChirp()

◆ isFmcwFamily()

◆ isTriangle()

◆ load()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ render()

◆ renderSlice()

◆ sampleAt()