Update UI opportunistically in sweep mode

mossmann · mossmann · commit 3d8ac18cc10d · 2026-04-09T13:52:03.000-04:00
diff --git a/firmware/common/radio.c b/firmware/common/radio.c
@@ -270,6 +270,11 @@ static bool radio_update_frequency(radio_t* const radio, uint64_t* bank)
 	bool set_lo = (requested_lo != RADIO_UNSET);
 	bool set_img_reject = (requested_img_reject != RADIO_UNSET);
 
+	uint64_t opmode = bank[RADIO_OPMODE];
+	if (opmode == RADIO_UNSET) {
+		opmode = radio->config[RADIO_BANK_APPLIED][RADIO_OPMODE];
+	}
+
 	if (set_if && set_lo && set_img_reject) {
 		bool new_if =
 			(requested_if !=
@@ -284,7 +289,8 @@ static bool radio_update_frequency(radio_t* const radio, uint64_t* bank)
 			set_freq_explicit(
 				requested_if / FP_ONE_HZ,
 				requested_lo / FP_ONE_HZ,
-				requested_img_reject);
+				requested_img_reject,
+				opmode);
 			radio->config[RADIO_BANK_APPLIED][RADIO_FREQUENCY_IF] =
 				requested_if;
 			radio->config[RADIO_BANK_APPLIED][RADIO_FREQUENCY_LO] =
@@ -323,10 +329,6 @@ static bool radio_update_frequency(radio_t* const radio, uint64_t* bank)
 	if (applied_afe_rate == RADIO_UNSET) {
 		return false;
 	}
-	uint64_t opmode = bank[RADIO_OPMODE];
-	if (opmode == RADIO_UNSET) {
-		opmode = radio->config[RADIO_BANK_APPLIED][RADIO_OPMODE];
-	}
 	const tune_config_t* tune_config = select_tune_config(opmode);
 	const tune_config_t* applied_tune_config =
 		select_tune_config(radio->config[RADIO_BANK_APPLIED][RADIO_OPMODE]);
@@ -349,12 +351,16 @@ static bool radio_update_frequency(radio_t* const radio, uint64_t* bank)
 	fp_40_24_t offset = applied_afe_rate / 4;
 	bool new_offset = (applied_offset != offset);
 	if (new_rotation || new_offset || new_config || new_rf) {
-		tuning_set_frequency(tune_config, requested_rf_hz, offset / FP_ONE_HZ);
+		tuning_set_frequency(
+			tune_config,
+			requested_rf_hz,
+			offset / FP_ONE_HZ,
+			opmode);
 		applied_offset = offset;
 	}
 #else
 	if (new_rf) {
-		set_freq(requested_rf_hz);
+		set_freq(requested_rf_hz, opmode);
 	}
 #endif
 	radio->config[RADIO_BANK_APPLIED][RADIO_FREQUENCY_RF] = requested_rf;
diff --git a/firmware/common/rf_path.c b/firmware/common/rf_path.c
@@ -34,6 +34,7 @@
 #include "mixer.h"
 #include "platform_detect.h"
 #include "sgpio.h"
+#include "transceiver_mode.h"
 #if defined(HACKRF_ONE) || defined(RAD1O) || defined(PRALINE)
 	#include "platform_scu.h"
 #endif
@@ -537,7 +538,10 @@ void rf_path_set_direction(rf_path_t* const rf_path, const rf_path_direction_t d
 	hackrf_ui()->set_direction(direction);
 }
 
-void rf_path_set_filter(rf_path_t* const rf_path, const rf_path_filter_t filter)
+void rf_path_set_filter(
+	rf_path_t* const rf_path,
+	const rf_path_filter_t filter,
+	const transceiver_mode_t opmode)
 {
 	switch (filter) {
 	default:
@@ -560,7 +564,9 @@ void rf_path_set_filter(rf_path_t* const rf_path, const rf_path_filter_t filter)
 
 	switchctrl_set(rf_path, rf_path->switchctrl);
 
-	hackrf_ui()->set_filter(filter);
+	if (opmode != TRANSCEIVER_MODE_RX_SWEEP) {
+		hackrf_ui()->set_filter(filter);
+	}
 }
 
 void rf_path_set_lna(rf_path_t* const rf_path, const uint_fast8_t enable)
diff --git a/firmware/common/rf_path.h b/firmware/common/rf_path.h
@@ -25,6 +25,7 @@
 
 #include <stdint.h>
 
+#include "transceiver_mode.h"
 #if defined(HACKRF_ONE) || defined(RAD1O) || defined(PRALINE)
 	#include "gpio.h"
 #endif
@@ -91,7 +92,10 @@ void rf_path_init(rf_path_t* const rf_path);
 
 void rf_path_set_direction(rf_path_t* const rf_path, const rf_path_direction_t direction);
 
-void rf_path_set_filter(rf_path_t* const rf_path, const rf_path_filter_t filter);
+void rf_path_set_filter(
+	rf_path_t* const rf_path,
+	const rf_path_filter_t filter,
+	const transceiver_mode_t opmode);
 
 void rf_path_set_lna(rf_path_t* const rf_path, const uint_fast8_t enable);
 void rf_path_set_antenna(rf_path_t* const rf_path, const uint_fast8_t enable);
diff --git a/firmware/common/tuning.c b/firmware/common/tuning.c
@@ -28,6 +28,7 @@
 #include "max283x.h"
 #include "mixer.h"
 #include "sgpio.h"
+#include "transceiver_mode.h"
 #if defined(PRALINE) || defined(HACKRF_ONE)
 	#include "operacake.h"
 #endif
@@ -79,7 +80,7 @@ static uint32_t max2837_freq_nominal_hz = 2560000000;
  * hz between 0 to 999999 Hz (not checked)
  * return false on error or true if success.
  */
-bool set_freq(const uint64_t freq)
+bool set_freq(const uint64_t freq, const transceiver_mode_t opmode)
 {
 	bool success;
 	uint64_t mixer_freq_hz;
@@ -92,7 +93,7 @@ bool set_freq(const uint64_t freq)
 	max283x_mode_t prior_max283x_mode = max283x_mode(&max283x);
 	max283x_set_mode(&max283x, MAX283x_MODE_STANDBY);
 	if (freq_mhz < MAX_LP_FREQ_MHZ) {
-		rf_path_set_filter(&rf_path, RF_PATH_FILTER_LOW_PASS);
+		rf_path_set_filter(&rf_path, RF_PATH_FILTER_LOW_PASS, opmode);
 	#ifdef RAD1O
 		max2837_freq_nominal_hz = 2300 * FREQ_ONE_MHZ;
 	#else
@@ -105,7 +106,7 @@ bool set_freq(const uint64_t freq)
 		max283x_set_frequency(&max283x, real_mixer_freq_hz - freq);
 		sgpio_cpld_set_mixer_invert(&sgpio_config, 1);
 	} else if ((freq_mhz >= MIN_BYPASS_FREQ_MHZ) && (freq_mhz < MAX_BYPASS_FREQ_MHZ)) {
-		rf_path_set_filter(&rf_path, RF_PATH_FILTER_BYPASS);
+		rf_path_set_filter(&rf_path, RF_PATH_FILTER_BYPASS, opmode);
 		/* mixer_freq_mhz <= not used in Bypass mode */
 		max283x_set_frequency(&max283x, freq);
 		sgpio_cpld_set_mixer_invert(&sgpio_config, 0);
@@ -124,7 +125,7 @@ bool set_freq(const uint64_t freq)
 			max2837_freq_nominal_hz = (2500 * FREQ_ONE_MHZ) +
 				((freq - (MID2_HP_FREQ_MHZ * FREQ_ONE_MHZ)) / 9);
 		}
-		rf_path_set_filter(&rf_path, RF_PATH_FILTER_HIGH_PASS);
+		rf_path_set_filter(&rf_path, RF_PATH_FILTER_HIGH_PASS, opmode);
 		mixer_freq_hz = freq - max2837_freq_nominal_hz;
 		/* Set Freq and read real freq */
 		real_mixer_freq_hz = mixer_set_frequency(&mixer, mixer_freq_hz);
@@ -136,7 +137,9 @@ bool set_freq(const uint64_t freq)
 	}
 	max283x_set_mode(&max283x, prior_max283x_mode);
 	if (success) {
-		hackrf_ui()->set_frequency(freq);
+		if (opmode != TRANSCEIVER_MODE_RX_SWEEP) {
+			hackrf_ui()->set_frequency(freq);
+		}
 	#ifdef HACKRF_ONE
 		operacake_set_range(freq_mhz);
 	#endif
@@ -149,7 +152,8 @@ bool set_freq(const uint64_t freq)
 bool tuning_set_frequency(
 	const tune_config_t* cfg,
 	const uint64_t freq,
-	const uint32_t offset)
+	const uint32_t offset,
+	const transceiver_mode_t opmode)
 {
 	uint64_t mixer_freq_hz;
 	uint64_t real_mixer_freq_hz;
@@ -175,11 +179,11 @@ bool tuning_set_frequency(
 	max283x_set_mode(&max283x, MAX283x_MODE_STANDBY);
 
 	if (cfg->if_mhz == 0) {
-		rf_path_set_filter(&rf_path, RF_PATH_FILTER_BYPASS);
+		rf_path_set_filter(&rf_path, RF_PATH_FILTER_BYPASS, opmode);
 		max283x_set_frequency(&max283x, rf);
 		sgpio_cpld_set_mixer_invert(&sgpio_config, 0);
 	} else if (cfg->if_mhz > freq_mhz) {
-		rf_path_set_filter(&rf_path, RF_PATH_FILTER_LOW_PASS);
+		rf_path_set_filter(&rf_path, RF_PATH_FILTER_LOW_PASS, opmode);
 		if (cfg->high_lo) {
 			mixer_freq_hz = FREQ_ONE_MHZ * cfg->if_mhz + rf;
 			real_mixer_freq_hz = mixer_set_frequency(&mixer, mixer_freq_hz);
@@ -192,15 +196,17 @@ bool tuning_set_frequency(
 			sgpio_cpld_set_mixer_invert(&sgpio_config, 0);
 		}
 	} else {
-		rf_path_set_filter(&rf_path, RF_PATH_FILTER_HIGH_PASS);
+		rf_path_set_filter(&rf_path, RF_PATH_FILTER_HIGH_PASS, opmode);
 		mixer_freq_hz = rf - FREQ_ONE_MHZ * cfg->if_mhz;
 		real_mixer_freq_hz = mixer_set_frequency(&mixer, mixer_freq_hz);
 		max283x_set_frequency(&max283x, rf - real_mixer_freq_hz);
 		sgpio_cpld_set_mixer_invert(&sgpio_config, 0);
 	}
 
 	max283x_set_mode(&max283x, prior_max283x_mode);
-	hackrf_ui()->set_frequency(freq);
+	if (opmode != TRANSCEIVER_MODE_RX_SWEEP) {
+		hackrf_ui()->set_frequency(freq);
+	}
 	operacake_set_range(freq_mhz);
 	return true;
 }
@@ -209,7 +215,8 @@ bool tuning_set_frequency(
 bool set_freq_explicit(
 	const uint64_t if_freq_hz,
 	const uint64_t lo_freq_hz,
-	const rf_path_filter_t path)
+	const rf_path_filter_t path,
+	const transceiver_mode_t opmode)
 {
 	if ((if_freq_hz < ((uint64_t) ABS_MIN_BYPASS_FREQ_MHZ * FREQ_ONE_MHZ)) ||
 	    (if_freq_hz > ((uint64_t) ABS_MAX_BYPASS_FREQ_MHZ * FREQ_ONE_MHZ))) {
@@ -225,7 +232,7 @@ bool set_freq_explicit(
 		return false;
 	}
 
-	rf_path_set_filter(&rf_path, path);
+	rf_path_set_filter(&rf_path, path, opmode);
 	max283x_set_frequency(&max283x, if_freq_hz);
 
 	if (lo_freq_hz > if_freq_hz) {
diff --git a/firmware/common/tuning.h b/firmware/common/tuning.h
@@ -27,21 +27,24 @@
 #include <stdint.h>
 
 #include "rf_path.h"
+#include "transceiver_mode.h"
 #if defined(PRALINE)
 	#include "tune_config.h"
 #endif
 
 #define FREQ_ONE_MHZ (1000ULL * 1000)
 
-bool set_freq(const uint64_t freq);
+bool set_freq(const uint64_t freq, const transceiver_mode_t opmode);
 bool set_freq_explicit(
 	const uint64_t if_freq_hz,
 	const uint64_t lo_freq_hz,
-	const rf_path_filter_t path);
+	const rf_path_filter_t path,
+	const transceiver_mode_t opmode);
 
 #ifdef PRALINE
 bool tuning_set_frequency(
 	const tune_config_t* cfg,
 	const uint64_t freq,
-	const uint32_t offset);
+	const uint32_t offset,
+	const transceiver_mode_t opmode);
 #endif
diff --git a/firmware/hackrf_usb/usb_api_sweep.c b/firmware/hackrf_usb/usb_api_sweep.c
@@ -27,8 +27,10 @@
 
 #include <fixed_point.h>
 #include <hackrf_core.h>
+#include <hackrf_ui.h>
 #include <m0_state.h>
 #include <radio.h>
+#include <rf_path.h>
 #include <streaming.h>
 #include <transceiver_mode.h>
 #include <usb_queue.h>
@@ -58,6 +60,31 @@ static uint32_t dwell_blocks = 0;
 static uint32_t step_width = 0;
 static uint32_t offset = 0;
 static enum sweep_style style = LINEAR;
+static bool freq_ui_dirty = false;
+static bool img_reject_ui_dirty = false;
+static rf_path_filter_t img_reject;
+
+/*
+ * Opportunistic UI updates are made when time is available. Updates are
+ * prioritized to prevent a single update from taking too long. Lower priority
+ * changes to the image reject filter path display are done only if there is
+ * time remaining after the higher priority update to the frequency display.
+ */
+void update_ui(void)
+{
+	if (freq_ui_dirty) {
+		hackrf_ui()->set_frequency(sweep_freq + offset);
+		freq_ui_dirty = false;
+	} else if (img_reject_ui_dirty) {
+		const uint64_t new_img_reject =
+			radio_reg_read(&radio, RADIO_BANK_APPLIED, RADIO_IMAGE_REJECT);
+		if (new_img_reject != img_reject) {
+			img_reject = new_img_reject;
+			hackrf_ui()->set_filter(img_reject);
+		}
+		img_reject_ui_dirty = false;
+	}
+}
 
 /* Do this before starting sweep mode with request_transceiver_mode(). */
 usb_request_status_t usb_vendor_request_init_sweep(
@@ -153,6 +180,9 @@ void sweep_mode(uint32_t seq)
 	uint8_t* buffer;
 
 	transceiver_startup(TRANSCEIVER_MODE_RX_SWEEP);
+	hackrf_ui()->set_frequency(sweep_freq + offset);
+	img_reject = radio_reg_read(&radio, RADIO_BANK_APPLIED, RADIO_IMAGE_REJECT);
+	hackrf_ui()->set_filter(img_reject);
 
 	// Set M0 to RX first buffer, then wait.
 	m0_state.threshold = 0x4000;
@@ -235,6 +265,8 @@ void sweep_mode(uint32_t seq)
 				(sweep_freq + offset) * FP_ONE_HZ);
 			nvic_enable_irq(NVIC_USB0_IRQ);
 			radio_update(&radio);
+			freq_ui_dirty = true;
+			img_reject_ui_dirty = true;
 			blocks_queued = 0;
 		}
 
@@ -243,6 +275,7 @@ void sweep_mode(uint32_t seq)
 			if (transceiver_request.seq != seq) {
 				goto end;
 			}
+			update_ui();
 		}
 
 		// Set M0 to switch back to WAIT after filling next buffer.
