mirror of
https://github.com/portapack-mayhem/mayhem-firmware.git
synced 2026-08-12 19:03:40 +00:00
stafur
85eaa9d800
* Updated harckrf_gpio methods to more closely reflect hackrf_usb. Added some ui debug updates to RFFC5072 Status View. * Updated tuning tables for tuning.cpp. Remnoved 15MHz lower limit in max2831.cpp since lower bandwidths don't seem to be causing lower band issues. Added more opportunities for clocks to stabalize at startup in board.cpp. Added/amended UI to help with addresssing low band tuning issues. Cleaned up stale comments in radio.cpp. * Ran format-code.sh * Updated to remove commented lines as part of clean up addressing review comments.
221 lines
8.2 KiB
C++
221 lines
8.2 KiB
C++
/*
|
||
* Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
|
||
*
|
||
* This file is part of PortaPack.
|
||
*
|
||
* This program is free software; you can redistribute it and/or modify
|
||
* it under the terms of the GNU General Public License as published by
|
||
* the Free Software Foundation; either version 2, or (at your option)
|
||
* any later version.
|
||
*
|
||
* This program is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
* GNU General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU General Public License
|
||
* along with this program; see the file COPYING. If not, write to
|
||
* the Free Software Foundation, Inc., 51 Franklin Street,
|
||
* Boston, MA 02110-1301, USA.
|
||
*/
|
||
|
||
#include "tuning.hpp"
|
||
|
||
#include "utility.hpp"
|
||
|
||
namespace tuning {
|
||
namespace config {
|
||
|
||
// Forward declarations
|
||
Config low_band(const rf::Frequency target_frequency);
|
||
Config mid_band(const rf::Frequency target_frequency);
|
||
Config high_band(const rf::Frequency target_frequency);
|
||
|
||
#ifdef PRALINE
|
||
/*
|
||
* PRALINE Tuning Configuration
|
||
* ============================
|
||
*
|
||
* Reference: hackrf_usb/common/tune_config.h praline_tune_config_rx[]
|
||
*
|
||
* The hackrf_usb firmware uses a table-driven approach where each entry
|
||
* specifies:
|
||
* - rf_range_end_mhz: Upper frequency limit for this config
|
||
* - if_mhz: IF frequency (what MAX2831 tunes to)
|
||
* - high_lo: true = high-side injection, false = low-side
|
||
* - shift: FPGA quarter-shift mode (not implemented in Mayhem yet)
|
||
*
|
||
* Key insight: The IF frequency varies to keep the RFFC5072 VCO in a
|
||
* safe operating range (ideally 3500-5000 MHz, avoiding extremes).
|
||
*
|
||
* RFFC5072 VCO calculation:
|
||
* High-side injection: LO = IF + RF, VCO = LO × lodiv
|
||
* Low-side injection: LO = IF - RF, VCO = LO × lodiv
|
||
* Where lodiv = 2 for frequencies where VCO > 2700 MHz
|
||
*
|
||
* From hackrf_usb tune_config_rx (simplified):
|
||
* 0-2100 MHz: IF=2375, high_lo=true → VCO = (2375+RF)×2
|
||
* 2105-2115: IF=2375, high_lo=false → VCO = (2375-RF)×2
|
||
* 2115-2130: IF=2425, high_lo=false → VCO = (2425-RF)×2
|
||
* ... (more entries for fine-grained control)
|
||
* 2320-2580: IF=0 (bypass mode, no mixer)
|
||
* 2580+: High-pass mode
|
||
*/
|
||
|
||
// Simplified tune_config lookup for Mayhem
|
||
// Returns the IF frequency in Hz for a given target frequency
|
||
constexpr rf::Frequency praline_get_if_frequency(const rf::Frequency target_frequency) {
|
||
const uint32_t freq_mhz = target_frequency / 1'000'000;
|
||
|
||
// Based on hackrf_usb tune_config_rx table
|
||
if (freq_mhz < 2100) {
|
||
// Most low-band frequencies: use 2375 MHz IF
|
||
// This keeps VCO around 4750-4950 MHz for FM band
|
||
return 2375'000'000;
|
||
} else if (freq_mhz < 2320) {
|
||
// Transition zone: use varying IF to avoid VCO edges
|
||
// These frequencies are tricky - near MAX2831 minimum
|
||
// Use 2425 MHz to give some margin
|
||
return 2425'000'000;
|
||
} else {
|
||
// Bypass mode or high-band - IF not used for mixer
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
// Returns true for high-side injection, false for low-side
|
||
constexpr bool praline_use_high_side_injection(const rf::Frequency target_frequency) {
|
||
const uint32_t freq_mhz = target_frequency / 1'000'000;
|
||
|
||
// Based on hackrf_usb tune_config_rx table
|
||
if (freq_mhz < 2100) {
|
||
// Standard low-band: high-side injection
|
||
// LO = IF + RF, mixer inverts spectrum
|
||
return true;
|
||
} else if (freq_mhz < 2105) {
|
||
// Narrow transition: still high-side
|
||
return true;
|
||
} else if (freq_mhz < 2320) {
|
||
// Near MAX2831 minimum: use low-side injection
|
||
// LO = IF - RF, no spectrum inversion
|
||
return false;
|
||
} else {
|
||
// Bypass/high-band - doesn't matter, mixer bypassed
|
||
return false;
|
||
}
|
||
}
|
||
#endif // PRALINE
|
||
|
||
// Low band <2170 Mhz (HackRF One) or <2320 MHz (PRALINE):
|
||
constexpr rf::Frequency low_band_second_lo_frequency(const rf::Frequency target_frequency) {
|
||
#ifdef PRALINE
|
||
// Use the tune_config lookup for PRALINE
|
||
return praline_get_if_frequency(target_frequency);
|
||
#else
|
||
return 2650'000'000 - (target_frequency / 7);
|
||
#endif
|
||
}
|
||
|
||
Config low_band(const rf::Frequency target_frequency) {
|
||
const rf::Frequency second_lo_frequency = low_band_second_lo_frequency(target_frequency);
|
||
|
||
#ifdef PRALINE
|
||
rf::Frequency first_lo_frequency;
|
||
bool mixer_invert;
|
||
|
||
if (praline_use_high_side_injection(target_frequency)) {
|
||
// High-side injection: LO = IF + RF
|
||
first_lo_frequency = second_lo_frequency + target_frequency;
|
||
mixer_invert = true;
|
||
} else {
|
||
// Low-side injection: LO = IF - RF
|
||
first_lo_frequency = second_lo_frequency - target_frequency;
|
||
mixer_invert = false;
|
||
}
|
||
|
||
return {first_lo_frequency, second_lo_frequency, rf::path::Band::Low, mixer_invert};
|
||
#else
|
||
const rf::Frequency first_lo_frequency = target_frequency + second_lo_frequency;
|
||
const bool mixer_invert = true;
|
||
return {first_lo_frequency, second_lo_frequency, rf::path::Band::Low, mixer_invert};
|
||
#endif
|
||
}
|
||
|
||
// Mid band 2170-2740 Mhz (HackRF One) or 2320-2580 MHz (PRALINE):
|
||
Config mid_band(const rf::Frequency target_frequency) {
|
||
#ifdef PRALINE
|
||
// For Praline with MAX2831 (2.3-2.6 GHz range)
|
||
// Frequencies 2170-2300 MHz need upconversion since they're below MAX2831 minimum
|
||
if (target_frequency < 2300'000'000) {
|
||
// Treat as low band - need mixer
|
||
return low_band(target_frequency);
|
||
}
|
||
// Frequencies 2300-2600 MHz can go direct (no RFFC5072)
|
||
else if (target_frequency <= 2600'000'000) {
|
||
const rf::Frequency second_lo_frequency = target_frequency;
|
||
const rf::Frequency first_lo_frequency = 0;
|
||
const bool mixer_invert = false;
|
||
return {first_lo_frequency, second_lo_frequency, rf::path::Band::Mid, mixer_invert};
|
||
}
|
||
// Frequencies 2600-2740 MHz need downconversion since they're above MAX2831 maximum
|
||
else {
|
||
// Treat as high band
|
||
return high_band(target_frequency);
|
||
}
|
||
#else
|
||
const rf::Frequency second_lo_frequency = target_frequency;
|
||
const rf::Frequency first_lo_frequency = 0;
|
||
const bool mixer_invert = false;
|
||
return {first_lo_frequency, second_lo_frequency, rf::path::Band::Mid, mixer_invert};
|
||
#endif
|
||
}
|
||
|
||
// High band >2740 Mhz (HackRF One) or >2580 MHz (PRALINE):
|
||
constexpr rf::Frequency high_band_second_lo_frequency(const rf::Frequency target_frequency) {
|
||
#ifdef PRALINE
|
||
// Praline formula tuned for MAX2831 (2.3-2.6 GHz range)
|
||
// Keep second_lo in MAX2831's range while allowing RFFC5072 to work
|
||
//
|
||
// For high-band, we use LOW-side injection: LO = RF - IF
|
||
// So IF should be chosen to keep LO (and thus VCO) in a good range
|
||
//
|
||
// Based on hackrf_usb tune_config_tx patterns:
|
||
if (target_frequency < 3600'000'000)
|
||
return 2400'000'000 + ((target_frequency - 2740'000'000) / 4);
|
||
else if (target_frequency < 5100'000'000)
|
||
return 2500'000'000 + ((target_frequency - 3600'000'000) / 6);
|
||
else
|
||
return 2550'000'000 + ((target_frequency - 5100'000'000) / 10);
|
||
#else
|
||
if (target_frequency < 3600'000'000)
|
||
return (2170'000'000 + (((target_frequency - 2740'000'000) * 57) / 86));
|
||
else if (target_frequency < 5100'000'000)
|
||
return (2350'000'000 + ((target_frequency - 3600'000'000) / 5));
|
||
else
|
||
return (2500'000'000 + ((target_frequency - 5100'000'000) / 9));
|
||
#endif
|
||
}
|
||
|
||
Config high_band(const rf::Frequency target_frequency) {
|
||
const rf::Frequency second_lo_frequency = high_band_second_lo_frequency(target_frequency);
|
||
const rf::Frequency first_lo_frequency = target_frequency - second_lo_frequency;
|
||
const bool mixer_invert = false;
|
||
return {first_lo_frequency, second_lo_frequency, rf::path::Band::High, mixer_invert};
|
||
}
|
||
|
||
Config create(const rf::Frequency target_frequency) {
|
||
/* TODO: This is some lame code. */
|
||
if (rf::path::band_low.contains(target_frequency)) {
|
||
return low_band(target_frequency);
|
||
} else if (rf::path::band_mid.contains(target_frequency)) {
|
||
return mid_band(target_frequency);
|
||
} else if (rf::path::band_high.contains(target_frequency)) {
|
||
return high_band(target_frequency);
|
||
} else {
|
||
return {};
|
||
}
|
||
}
|
||
|
||
} /* namespace config */
|
||
} /* namespace tuning */
|