serial::fmcw_validation Namespace Reference

Typedefs
using	Thrower = std::function< void(const std::string &)>
	Callback used by validators to report an error through the caller's mechanism.

Functions
void	validateWaveform (const fers_signal::RadarSignal &wave, const std::string &owner, const Thrower &throw_error)
	Validates that a waveform is compatible with FMCW streaming constraints.
void	validateWaveformModeMatch (const fers_signal::RadarSignal &wave, radar::OperationMode mode, const std::string &owner, const Thrower &throw_error)
	Validates that a waveform and radar operation mode are compatible.
void	validateSchedule (const std::vector< radar::SchedulePeriod > &schedule, const fers_signal::FmcwChirpSignal &fmcw, const std::string &owner, const Thrower &throw_error)
	Validates that an FMCW waveform schedule can emit complete chirps.
void	validateSchedule (const std::vector< radar::SchedulePeriod > &schedule, const fers_signal::RadarSignal &wave, const std::string &owner, const Thrower &throw_error)
	Validates that an FMCW waveform schedule can emit complete waveform periods.

Typedef Documentation

Thrower

using serial::fmcw_validation::Thrower = typedef std::function<void(const std::string&)>

Callback used by validators to report an error through the caller's mechanism.

Definition at line 28 of file fmcw_validation.h.

Function Documentation

validateSchedule() [1/2]

void serial::fmcw_validation::validateSchedule	(	const std::vector< radar::SchedulePeriod > &	schedule,
		const fers_signal::FmcwChirpSignal &	fmcw,
		const std::string &	owner,
		const Thrower &	throw_error
	)

Validates that an FMCW waveform schedule can emit complete chirps.

Definition at line 182 of file fmcw_validation.cpp.

    {
        for (const auto& period : effectiveSchedule(schedule))
        {
            const RealType duration = period.end - period.start;
            if (duration < fmcw.getChirpDuration())
            {
                throw_error(std::format(
                    "{} has schedule period [{}, {}] duration {} s shorter than FMCW chirp_duration T_c={} s.", owner,
                    period.start, period.end, duration, fmcw.getChirpDuration()));
            }
            if (duration < fmcw.getChirpPeriod())
            {
                LOG(logging::Level::WARNING, "{} has a schedule period [{}, {}] shorter than FMCW chirp_period ({}s).",
                    owner, period.start, period.end, fmcw.getChirpPeriod());
            }
        }
    }

References fers_signal::FmcwChirpSignal::getChirpDuration(), fers_signal::FmcwChirpSignal::getChirpPeriod(), LOG, max, and logging::WARNING.

Referenced by validateSchedule().

Here is the call graph for this function:

Here is the caller graph for this function:

validateSchedule() [2/2]

void serial::fmcw_validation::validateSchedule	(	const std::vector< radar::SchedulePeriod > &	schedule,
		const fers_signal::RadarSignal &	wave,
		const std::string &	owner,
		const Thrower &	throw_error
	)

Validates that an FMCW waveform schedule can emit complete waveform periods.

Definition at line 202 of file fmcw_validation.cpp.

    {
        if (const auto* fmcw = wave.getFmcwChirpSignal(); fmcw != nullptr)
        {
            validateSchedule(schedule, *fmcw, owner, throw_error);
            return;
        }
 
        if (const auto* sfcw = wave.getSteppedFrequencySignal(); sfcw != nullptr)
        {
            for (const auto& period : effectiveSchedule(schedule))
            {
                const RealType duration = period.end - period.start;
                if (duration < sfcw->getDwellTime())
                {
                    LOG(logging::Level::WARNING, "{} has schedule period [{}, {}] shorter than one SFCW dwell ({}s).",
                        owner, period.start, period.end, sfcw->getDwellTime());
                }
                if (duration < sfcw->getSweepPeriod())
                {
                    LOG(logging::Level::WARNING, "{} has schedule period [{}, {}] shorter than one SFCW sweep ({}s).",
                        owner, period.start, period.end, sfcw->getSweepPeriod());
                }
            }
            return;
        }
 
        const auto* triangle = wave.getFmcwTriangleSignal();
        if (triangle == nullptr)
        {
            return;
        }
 
        const RealType T_tri = triangle->getTrianglePeriod();
        for (const auto& period : effectiveSchedule(schedule))
        {
            const RealType duration = period.end - period.start;
            if (duration < T_tri)
            {
                throw_error(std::format(
                    "{} has schedule period [{}, {}] duration {} s shorter than FMCW triangle_period T_tri={} s.",
                    owner, period.start, period.end, duration, T_tri));
            }
            const RealType full_triangles = std::floor(duration / T_tri);
            const RealType used = full_triangles * T_tri;
            const RealType leftover = duration - used;
            if (leftover > 1.0e-12)
            {
                LOG(logging::Level::WARNING,
                    "{} has schedule period [{}, {}] that is not an integer multiple of FMCW triangle_period ({}s); "
                    "{}s will be silent after the last complete triangle.",
                    owner, period.start, period.end, T_tri, leftover);
            }
        }
    }

References LOG, max, validateSchedule(), and logging::WARNING.

Here is the call graph for this function:

validateWaveform()

void serial::fmcw_validation::validateWaveform	(	const fers_signal::RadarSignal &	wave,
		const std::string &	owner,
		const Thrower &	throw_error
	)

Validates that a waveform is compatible with FMCW streaming constraints.

Definition at line 134 of file fmcw_validation.cpp.

    {
        if (const auto* fmcw = wave.getFmcwChirpSignal(); fmcw != nullptr)
        {
            if (fmcw->getChirpPeriod() < fmcw->getChirpDuration())
            {
                throw_error(owner + " has chirp_period shorter than chirp_duration; FMCW requires T_rep >= T_c.");
            }
 
            const RealType sweep_start = fmcw->getStartFrequencyOffset();
            const RealType sweep_end =
                sweep_start + (fmcw->isDownChirp() ? -fmcw->getChirpBandwidth() : fmcw->getChirpBandwidth());
            validateCommonSweep(wave, owner, fmcw->getChirpDuration(), fmcw->getChirpBandwidth(), sweep_start,
                                sweep_end, throw_error);
            warnStreamingMemory(owner, "FMCW");
            return;
        }
 
        if (const auto* triangle = wave.getFmcwTriangleSignal(); triangle != nullptr)
        {
            const RealType sweep_start = triangle->getStartFrequencyOffset();
            const RealType sweep_end = sweep_start + triangle->getChirpBandwidth();
            validateCommonSweep(wave, owner, triangle->getChirpDuration(), triangle->getChirpBandwidth(), sweep_start,
                                sweep_end, throw_error);
            warnStreamingMemory(owner, "FMCW");
            return;
        }
 
        if (const auto* sfcw = wave.getSteppedFrequencySignal(); sfcw != nullptr)
        {
            validateSfcwWaveform(wave, owner, *sfcw, throw_error);
        }
    }

References max.

validateWaveformModeMatch()

void serial::fmcw_validation::validateWaveformModeMatch	(	const fers_signal::RadarSignal &	wave,
		const radar::OperationMode	mode,
		const std::string &	owner,
		const Thrower &	throw_error
	)

Validates that a waveform and radar operation mode are compatible.

Definition at line 168 of file fmcw_validation.cpp.

    {
        const bool is_pulsed = !wave.isCw() && !wave.isFmcwFamily() && !wave.isSteppedFrequency();
        const bool matches = (mode == radar::OperationMode::PULSED_MODE && is_pulsed) ||
            (mode == radar::OperationMode::CW_MODE && wave.isCw()) ||
            (mode == radar::OperationMode::FMCW_MODE && wave.isFmcwFamily()) ||
            (mode == radar::OperationMode::SFCW_MODE && wave.isSteppedFrequency());
        if (!matches)
        {
            throw_error(owner + " mode does not match waveform '" + wave.getName() + "'.");
        }
    }

References radar::CW_MODE, radar::FMCW_MODE, max, radar::PULSED_MODE, and radar::SFCW_MODE.