TheArchive/mayhem-firmware
1
0
Fork 0
mirror of https://github.com/portapack-mayhem/mayhem-firmware.git synced 2024-12-14 04:04:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

better roundings/per pixel marker

Browse Source
This commit is contained in:
GullCode 2023-04-30 14:56:17 +02:00
parent 98e7116230
commit 1135a42932
2 changed files with 44 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
firmware/application/apps/ui_looking_glass_app.cpp
View File

@ -43,11 +43,6 @@ namespace ui
return ((num / multiplier) + 1) * multiplier; return ((num / multiplier) + 1) * multiplier;
} }
// Returns the previous multiple of num that is a multiple of multiplier
//int64_t GlassView::prev_mult_of(int64_t num, int64_t multiplier) {
// return (num / multiplier) * multiplier;
//}
void GlassView::adjust_range(int64_t* f_min, int64_t* f_max, int64_t width) { void GlassView::adjust_range(int64_t* f_min, int64_t* f_max, int64_t width) {
int64_t span = *f_max - *f_min; int64_t span = *f_max - *f_min;
int64_t num_intervals = span / width; int64_t num_intervals = span / width;
@ -144,6 +139,8 @@ namespace ui
// Each having the radio signal power for it's corresponding frequency slot // Each having the radio signal power for it's corresponding frequency slot
void GlassView::on_channel_spectrum(const ChannelSpectrum &spectrum) void GlassView::on_channel_spectrum(const ChannelSpectrum &spectrum)
{ {
// default fast scan offset
uint8_t offset = 2 ;
baseband::spectrum_streaming_stop(); baseband::spectrum_streaming_stop();
if( fast_scan || ( LOOKING_GLASS_SLICE_WIDTH < LOOKING_GLASS_SLICE_WIDTH_MAX ) ) if( fast_scan || ( LOOKING_GLASS_SLICE_WIDTH < LOOKING_GLASS_SLICE_WIDTH_MAX ) )
{ {
@ -182,7 +179,14 @@ namespace ui
} }
} }
if( bin == 120 )
{
bins_Hz_size += 12 * each_bin_size; // add DC bin Hz count into the "pixel fulfilled bag of Hz"
}
else
{
bins_Hz_size += each_bin_size; // add this bin Hz count into the "pixel fulfilled bag of Hz" bins_Hz_size += each_bin_size; // add this bin Hz count into the "pixel fulfilled bag of Hz"
}
if (bins_Hz_size >= marker_pixel_step) // new pixel fullfilled if (bins_Hz_size >= marker_pixel_step) // new pixel fullfilled
{ {
@ -196,7 +200,7 @@ namespace ui
if (!pixel_index) // Received indication that a waterfall line has been completed if (!pixel_index) // Received indication that a waterfall line has been completed
{ {
bins_Hz_size = 0; // Since this is an entire pixel line, we don't carry "Pixels into next bin" bins_Hz_size = 0; // Since this is an entire pixel line, we don't carry "Pixels into next bin"
f_center = f_center_ini - 2 * each_bin_size ; // Start a new sweep f_center = f_center_ini - offset * each_bin_size ; // Start a new sweep
radio::set_tuning_frequency(f_center); // tune rx for this new slice directly, faster than using persistent memory saving radio::set_tuning_frequency(f_center); // tune rx for this new slice directly, faster than using persistent memory saving
chThdSleepMilliseconds(10); chThdSleepMilliseconds(10);
baseband::spectrum_streaming_start(); // Do the RX baseband::spectrum_streaming_start(); // Do the RX
@ -205,14 +209,25 @@ namespace ui
bins_Hz_size -= marker_pixel_step; // reset bins size, but carrying the eventual excess Hz into next pixel bins_Hz_size -= marker_pixel_step; // reset bins size, but carrying the eventual excess Hz into next pixel
} }
} }
f_center += 238 * each_bin_size ; // Move into the next bandwidth slice NOTE: spectrum.sampling_rate = LOOKING_GLASS_SLICE_WIDTH f_center += ( 256 - ( 2 * offset ) ) * each_bin_size ; // Move into the next bandwidth slice NOTE: spectrum.sampling_rate = LOOKING_GLASS_SLICE_WIDTH
// lost bins are taken in account so next slice first ignored bins overlap previous kept ones
} }
else //slow scan else //slow scan
{ {
for (uint8_t bin = 0 ; bin < 80 ; bin++) offset = 32 ;
uint8_t bin_length = 80 ;
for (uint8_t bin = offset ; bin < bin_length + offset ; bin++)
{
if (bin < 120)
{ {
if (spectrum.db[134 + bin] > max_power) // 134 if (spectrum.db[134 + bin] > max_power) // 134
max_power = spectrum.db[134 + bin]; max_power = spectrum.db[134 + bin];
}
else
{
if (spectrum.db[bin - 118] > max_power) // 118
max_power = spectrum.db[bin - 118];
}
bins_Hz_size += each_bin_size; // add this bin Hz count into the "pixel fulfilled bag of Hz" bins_Hz_size += each_bin_size; // add this bin Hz count into the "pixel fulfilled bag of Hz"
@ -228,7 +243,7 @@ namespace ui
if (!pixel_index) // Received indication that a waterfall line has been completed if (!pixel_index) // Received indication that a waterfall line has been completed
{ {
bins_Hz_size = 0; // Since this is an entire pixel line, we don't carry "Pixels into next bin" bins_Hz_size = 0; // Since this is an entire pixel line, we don't carry "Pixels into next bin"
f_center = f_center_ini - 2 * each_bin_size ; // Start a new sweep f_center = f_center_ini - offset * each_bin_size ; // Start a new sweep
radio::set_tuning_frequency(f_center); // tune rx for this new slice directly, faster than using persistent memory saving radio::set_tuning_frequency(f_center); // tune rx for this new slice directly, faster than using persistent memory saving
chThdSleepMilliseconds(10); chThdSleepMilliseconds(10);
baseband::spectrum_streaming_start(); // Do the RX baseband::spectrum_streaming_start(); // Do the RX
@ -237,7 +252,7 @@ namespace ui
bins_Hz_size -= marker_pixel_step; // reset bins size, but carrying the eventual excess Hz into next pixel bins_Hz_size -= marker_pixel_step; // reset bins size, but carrying the eventual excess Hz into next pixel
} }
} }
f_center += 80 * each_bin_size ; f_center += bin_length * each_bin_size ;
} }
radio::set_tuning_frequency(f_center); // tune rx for this new slice directly, faster than using persistent memory saving radio::set_tuning_frequency(f_center); // tune rx for this new slice directly, faster than using persistent memory saving
chThdSleepMilliseconds(5); chThdSleepMilliseconds(5);
@ -277,19 +292,16 @@ namespace ui
adjust_range( &f_min , &f_max , 240 ); adjust_range( &f_min , &f_max , 240 );
marker_pixel_step = (f_max - f_min) / 240; // Each pixel value in Hz marker_pixel_step = (f_max - f_min) / 240; // Each pixel value in Hz
f_center_ini = f_min + (LOOKING_GLASS_SLICE_WIDTH / 2); // Initial center frequency for sweep
marker = f_min + (f_max - f_min) / 2 ; marker = f_min + (f_max - f_min) / 2 ;
button_marker.set_text( to_string_short_freq( marker ) ); button_marker.set_text( to_string_short_freq( marker ) );
PlotMarker( marker ); // Refresh marker on screen PlotMarker( marker ); // Refresh marker on screen
pixel_index = 0; // reset pixel counter pixel_index = 0; // reset pixel counter
max_power = 0; max_power = 0;
bins_Hz_size = 0; // reset amount of Hz filled up by pixels bins_Hz_size = 0; // reset amount of Hz filled up by pixels
if( next_mult_of( (f_max - f_min) , 240 ) <= LOOKING_GLASS_SLICE_WIDTH_MAX ) if( (f_max - f_min) <= LOOKING_GLASS_SLICE_WIDTH_MAX )
{ {
LOOKING_GLASS_SLICE_WIDTH = next_mult_of( (f_max - f_min) , 240 ); LOOKING_GLASS_SLICE_WIDTH = (f_max - f_min) ;
receiver_model.set_sampling_rate(LOOKING_GLASS_SLICE_WIDTH); receiver_model.set_sampling_rate(LOOKING_GLASS_SLICE_WIDTH);
receiver_model.set_baseband_bandwidth(LOOKING_GLASS_SLICE_WIDTH/2); receiver_model.set_baseband_bandwidth(LOOKING_GLASS_SLICE_WIDTH/2);
} }
@ -299,9 +311,15 @@ namespace ui
receiver_model.set_sampling_rate(LOOKING_GLASS_SLICE_WIDTH); receiver_model.set_sampling_rate(LOOKING_GLASS_SLICE_WIDTH);
receiver_model.set_baseband_bandwidth(LOOKING_GLASS_SLICE_WIDTH); receiver_model.set_baseband_bandwidth(LOOKING_GLASS_SLICE_WIDTH);
} }
if( next_mult_of( LOOKING_GLASS_SLICE_WIDTH , 256 ) > LOOKING_GLASS_SLICE_WIDTH_MAX )
LOOKING_GLASS_SLICE_WIDTH = LOOKING_GLASS_SLICE_WIDTH_MAX ;
else
LOOKING_GLASS_SLICE_WIDTH = next_mult_of( LOOKING_GLASS_SLICE_WIDTH , 256 );
receiver_model.set_squelch_level(0); receiver_model.set_squelch_level(0);
each_bin_size = LOOKING_GLASS_SLICE_WIDTH / 240 ; each_bin_size = LOOKING_GLASS_SLICE_WIDTH / 256 ;
f_center = f_center_ini - 2 * each_bin_size ; // Reset sweep into first slice f_center_ini = f_min + (LOOKING_GLASS_SLICE_WIDTH / 2) ; // Initial center frequency for sweep
f_center = f_center_ini ; // Reset sweep into first slice
baseband::set_spectrum(LOOKING_GLASS_SLICE_WIDTH, field_trigger.value()); baseband::set_spectrum(LOOKING_GLASS_SLICE_WIDTH, field_trigger.value());
receiver_model.set_tuning_frequency(f_center_ini); // tune rx for this slice receiver_model.set_tuning_frequency(f_center_ini); // tune rx for this slice
} }

11
firmware/application/apps/ui_looking_glass_app.hpp
View File

@ -37,7 +37,7 @@
namespace ui namespace ui
{ {
#define LOOKING_GLASS_SLICE_WIDTH_MAX 19999920 #define LOOKING_GLASS_SLICE_WIDTH_MAX 20000000
#define MHZ_DIV 1000000 #define MHZ_DIV 1000000
#define X2_MHZ_DIV 2000000 #define X2_MHZ_DIV 2000000
@ -81,14 +81,13 @@ namespace ui
std::vector<preset_entry> presets_db{}; std::vector<preset_entry> presets_db{};
// Each slice bandwidth 20 MHz and a multiple of 240 // Each slice bandwidth 20 MHz and a multiple of 256
// since we are using LOOKING_GLASS_SLICE_WIDTH/240 as the each_bin_size // since we are using LOOKING_GLASS_SLICE_WIDTH/256 as the each_bin_size
// it should also be a multiple of 2 since we are using LOOKING_GLASS_SLICE_WIDTH / 2 as centering freq // it should also be a multiple of 2 since we are using LOOKING_GLASS_SLICE_WIDTH / 2 as centering freq
int64_t LOOKING_GLASS_SLICE_WIDTH = 19999920; int64_t LOOKING_GLASS_SLICE_WIDTH = 20000000;
// frequency rounding helpers // frequency rounding helpers
int64_t next_mult_of(int64_t num, int64_t multiplier); int64_t next_mult_of(int64_t num, int64_t multiplier);
//int64_t prev_mult_of(int64_t num, int64_t multiplier);
void adjust_range(int64_t* f_min, int64_t* f_max, int64_t width); void adjust_range(int64_t* f_min, int64_t* f_max, int64_t width);
void on_channel_spectrum(const ChannelSpectrum& spectrum); void on_channel_spectrum(const ChannelSpectrum& spectrum);
@ -110,7 +109,7 @@ namespace ui
rf::Frequency f_center_ini { 0 }; rf::Frequency f_center_ini { 0 };
rf::Frequency marker { 0 }; rf::Frequency marker { 0 };
rf::Frequency marker_pixel_step { 0 }; rf::Frequency marker_pixel_step { 0 };
rf::Frequency each_bin_size { LOOKING_GLASS_SLICE_WIDTH / 240 }; rf::Frequency each_bin_size { LOOKING_GLASS_SLICE_WIDTH / 256 };
rf::Frequency bins_Hz_size { 0 }; rf::Frequency bins_Hz_size { 0 };
uint8_t min_color_power { 0 }; uint8_t min_color_power { 0 };
uint32_t pixel_index { 0 }; uint32_t pixel_index { 0 };