KB8PMY
/
tinySA
mirror of https://github.com/erikkaashoek/tinySA.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add battery status to form and freq_t

Browse Source
master
erikkaashoek 5 years ago
parent 224a96df63
commit 7c7fd57b16
10 changed files with 175 additions and 178 deletions
Show Stats Download Patch File Download Diff File

4
chprintf.c
Unescape View File

@ -329,12 +329,12 @@ int chvprintf(BaseSequentialStream *chp, const char *fmt, va_list ap) {
else else
state|=DEFAULT_PRESCISION; state|=DEFAULT_PRESCISION;
//Get [length] //Get [length]
/*
if (c == 'l' || c == 'L') { if (c == 'l' || c == 'L') {
state|=IS_LONG; // state|=IS_LONG; // Ignore Long
if (*fmt) if (*fmt)
c = *fmt++; c = *fmt++;
} }
/*
else if ((c >= 'A') && (c <= 'Z')) else if ((c >= 'A') && (c <= 'Z'))
state|=IS_LONG; state|=IS_LONG;
*/ */

65
main.c
Unescape View File

@ -36,10 +36,10 @@
#include <string.h> #include <string.h>
#include <math.h> #include <math.h>
extern uint32_t minFreq; extern freq_t minFreq;
extern uint32_t maxFreq; extern freq_t maxFreq;
uint32_t frequencyStart; freq_t frequencyStart;
uint32_t frequencyStop; freq_t frequencyStop;
int32_t frequencyExtra; int32_t frequencyExtra;
#define START_MIN minFreq #define START_MIN minFreq
#define STOP_MAX maxFreq #define STOP_MAX maxFreq
@ -92,7 +92,7 @@ static void apply_edelay_at(int i);
static void cal_interpolate(int s); static void cal_interpolate(int s);
#endif #endif
void update_frequencies(void); void update_frequencies(void);
static void set_frequencies(uint32_t start, uint32_t stop, uint16_t points); static void set_frequencies(freq_t start, freq_t stop, uint16_t points);
static bool sweep(bool break_on_operation); static bool sweep(bool break_on_operation);
#ifdef __VNA__ #ifdef __VNA__
static void transform_domain(void); static void transform_domain(void);
@ -357,6 +357,7 @@ VNA_SHELL_FUNCTION(cmd_pause)
(void)argc; (void)argc;
(void)argv; (void)argv;
pause_sweep(); pause_sweep();
draw_cal_status();
} }
VNA_SHELL_FUNCTION(cmd_resume) VNA_SHELL_FUNCTION(cmd_resume)
@ -424,7 +425,7 @@ adjust_gain(uint32_t newfreq)
} }
#endif #endif
int set_frequency(uint32_t freq) int set_frequency(freq_t freq)
{ {
(void) freq; (void) freq;
#ifdef __VNA__ #ifdef __VNA__
@ -590,7 +591,7 @@ VNA_SHELL_FUNCTION(cmd_freq)
if (argc != 1) { if (argc != 1) {
goto usage; goto usage;
} }
uint32_t freq = my_atoui(argv[0]); freq_t freq = my_atoui(argv[0]);
pause_sweep(); pause_sweep();
set_frequency(freq); set_frequency(freq);
@ -1030,7 +1031,7 @@ void set_sweep_points(uint16_t points){
VNA_SHELL_FUNCTION(cmd_scan) VNA_SHELL_FUNCTION(cmd_scan)
{ {
uint32_t start, stop; freq_t start, stop;
uint32_t points = sweep_points; uint32_t points = sweep_points;
uint32_t i; uint32_t i;
if (argc < 2 || argc > 4) { if (argc < 2 || argc > 4) {
@ -1081,9 +1082,9 @@ update_marker_index(void)
for (m = 0; m < MARKERS_MAX; m++) { for (m = 0; m < MARKERS_MAX; m++) {
if (!markers[m].enabled) if (!markers[m].enabled)
continue; continue;
uint32_t f = markers[m].frequency; freq_t f = markers[m].frequency;
uint32_t fstart = get_sweep_frequency(ST_START); freq_t fstart = get_sweep_frequency(ST_START);
uint32_t fstop = get_sweep_frequency(ST_STOP); freq_t fstop = get_sweep_frequency(ST_STOP);
if (f < fstart) { if (f < fstart) {
markers[m].index = 0; markers[m].index = 0;
markers[m].frequency = fstart; markers[m].frequency = fstart;
@ -1102,13 +1103,13 @@ update_marker_index(void)
} }
} }
void set_marker_frequency(int m, uint32_t f) void set_marker_frequency(int m, freq_t f)
{ {
if (m < 0 || !markers[m].enabled) if (m < 0 || !markers[m].enabled)
return; return;
int i = 1; int i = 1;
markers[m].mtype &= ~M_TRACKING; markers[m].mtype &= ~M_TRACKING;
uint32_t s = (frequencies[1] - frequencies[0])/2; freq_t s = (frequencies[1] - frequencies[0])/2;
while (i< sweep_points - 2){ while (i< sweep_points - 2){
if (frequencies[i]-s <= f && f < frequencies[i+1]-s) { // Avoid rounding error in s!!!!!!! if (frequencies[i]-s <= f && f < frequencies[i+1]-s) { // Avoid rounding error in s!!!!!!!
markers[m].index = i; markers[m].index = i;
@ -1120,14 +1121,14 @@ void set_marker_frequency(int m, uint32_t f)
} }
static void static void
set_frequencies(uint32_t start, uint32_t stop, uint16_t points) set_frequencies(freq_t start, freq_t stop, uint16_t points)
{ {
uint32_t i; uint32_t i;
uint32_t step = (points - 1); freq_t step = (points - 1);
uint32_t span = stop - start; freq_t span = stop - start;
uint32_t delta = span / step; freq_t delta = span / step;
uint32_t error = span % step; freq_t error = span % step;
uint32_t f = start, df = step>>1; freq_t f = start, df = step>>1;
for (i = 0; i <= step; i++, f+=delta) { for (i = 0; i <= step; i++, f+=delta) {
frequencies[i] = f; frequencies[i] = f;
df+=error; df+=error;
@ -1146,7 +1147,7 @@ set_frequencies(uint32_t start, uint32_t stop, uint16_t points)
void void
update_frequencies(void) update_frequencies(void)
{ {
uint32_t start, stop; freq_t start, stop;
start = get_sweep_frequency(ST_START); start = get_sweep_frequency(ST_START);
stop = get_sweep_frequency(ST_STOP); stop = get_sweep_frequency(ST_STOP);
@ -1160,7 +1161,7 @@ update_frequencies(void)
} }
void void
set_sweep_frequency(int type, uint32_t freq) set_sweep_frequency(int type, freq_t freq)
{ {
#ifdef __VNA__ #ifdef __VNA__
int cal_applied = cal_status & CALSTAT_APPLY; int cal_applied = cal_status & CALSTAT_APPLY;
@ -1196,9 +1197,9 @@ set_sweep_frequency(int type, uint32_t freq)
break; break;
case ST_CENTER: case ST_CENTER:
setting.freq_mode |= FREQ_MODE_CENTER_SPAN; setting.freq_mode |= FREQ_MODE_CENTER_SPAN;
uint32_t center = setting.frequency0 / 2 + setting.frequency1 / 2; freq_t center = setting.frequency0 / 2 + setting.frequency1 / 2;
if (center != freq) { if (center != freq) {
uint32_t span = setting.frequency1 - setting.frequency0; freq_t span = setting.frequency1 - setting.frequency0;
if (freq < START_MIN + span / 2) { if (freq < START_MIN + span / 2) {
span = (freq - START_MIN) * 2; span = (freq - START_MIN) * 2;
} }
@ -1212,7 +1213,7 @@ set_sweep_frequency(int type, uint32_t freq)
case ST_SPAN: case ST_SPAN:
setting.freq_mode |= FREQ_MODE_CENTER_SPAN; setting.freq_mode |= FREQ_MODE_CENTER_SPAN;
if (setting.frequency1 - setting.frequency0 != freq) { if (setting.frequency1 - setting.frequency0 != freq) {
uint32_t center = setting.frequency0 / 2 + setting.frequency1 / 2; freq_t center = setting.frequency0 / 2 + setting.frequency1 / 2;
if (center < START_MIN + freq / 2) { if (center < START_MIN + freq / 2) {
center = START_MIN + freq / 2; center = START_MIN + freq / 2;
} }
@ -1239,12 +1240,12 @@ set_sweep_frequency(int type, uint32_t freq)
#endif #endif
} }
uint32_t freq_t
get_sweep_frequency(int type) get_sweep_frequency(int type)
{ {
// Obsolete, ensure correct start/stop, start always must be < stop // Obsolete, ensure correct start/stop, start always must be < stop
if (setting.frequency0 > setting.frequency1) { if (setting.frequency0 > setting.frequency1) {
uint32_t t = setting.frequency0; freq_t t = setting.frequency0;
setting.frequency0 = setting.frequency1; setting.frequency0 = setting.frequency1;
setting.frequency1 = t; setting.frequency1 = t;
} }
@ -1266,9 +1267,9 @@ VNA_SHELL_FUNCTION(cmd_sweep)
} else if (argc > 3) { } else if (argc > 3) {
goto usage; goto usage;
} }
uint32_t value0 = 0; freq_t value0 = 0;
uint32_t value1 = 0; freq_t value1 = 0;
uint32_t value2 = 0; freq_t value2 = 0;
if (argc >= 1) value0 = my_atoui(argv[0]); if (argc >= 1) value0 = my_atoui(argv[0]);
if (argc >= 2) value1 = my_atoui(argv[1]); if (argc >= 2) value1 = my_atoui(argv[1]);
if (argc >= 3) value2 = my_atoui(argv[2]); if (argc >= 3) value2 = my_atoui(argv[2]);
@ -1965,7 +1966,7 @@ VNA_SHELL_FUNCTION(cmd_marker)
default: default:
// select active marker and move to index or frequency // select active marker and move to index or frequency
markers[t].enabled = TRUE; markers[t].enabled = TRUE;
uint32_t value = my_atoui(argv[1]); freq_t value = my_atoui(argv[1]);
markers[t].mtype &= ~M_TRACKING; markers[t].mtype &= ~M_TRACKING;
active_marker = t; active_marker = t;
if (value > sweep_points) if (value > sweep_points)
@ -2889,12 +2890,12 @@ int main(void)
redraw_frame(); redraw_frame();
#ifdef TINYSA3 #ifdef TINYSA3
set_mode(M_HIGH); set_mode(M_HIGH);
set_sweep_frequency(ST_STOP, (uint32_t) 30000000); set_sweep_frequency(ST_STOP, (freq_t) 30000000);
sweep(false); sweep(false);
osalThreadSleepMilliseconds(100); osalThreadSleepMilliseconds(100);
set_mode(M_LOW); set_mode(M_LOW);
set_sweep_frequency(ST_STOP, (uint32_t) 4000000); set_sweep_frequency(ST_STOP, (freq_t) 4000000);
sweep(false); sweep(false);
#endif #endif

51
nanovna.h
Unescape View File

@ -84,6 +84,7 @@
#define actual_t measured[TRACE_ACTUAL] #define actual_t measured[TRACE_ACTUAL]
#define temp_t measured[TRACE_TEMP] #define temp_t measured[TRACE_TEMP]
typedef uint32_t freq_t;
#define CORRECTION_POINTS 10 // Frequency dependent level correction table entries #define CORRECTION_POINTS 10 // Frequency dependent level correction table entries
typedef float measurement_t[TRACES_MAX][POINTS_COUNT]; typedef float measurement_t[TRACES_MAX][POINTS_COUNT];
@ -154,13 +155,13 @@ enum stimulus_type {
void set_sweep_points(uint16_t points); void set_sweep_points(uint16_t points);
void update_frequencies(void); void update_frequencies(void);
void set_sweep_frequency(int type, uint32_t frequency); void set_sweep_frequency(int type, freq_t frequency);
uint32_t get_sweep_frequency(int type); freq_t get_sweep_frequency(int type);
void my_microsecond_delay(int t); void my_microsecond_delay(int t);
float my_atof(const char *p); float my_atof(const char *p);
int shell_printf(const char *fmt, ...); int shell_printf(const char *fmt, ...);
void set_marker_frequency(int m, uint32_t f); void set_marker_frequency(int m, freq_t f);
void toggle_sweep(void); void toggle_sweep(void);
void toggle_mute(void); void toggle_mute(void);
void load_default_properties(void); void load_default_properties(void);
@ -203,8 +204,8 @@ extern const char *info_about[];
extern const char * const unit_string[]; extern const char * const unit_string[];
extern uint8_t signal_is_AM; extern uint8_t signal_is_AM;
extern const int reffer_freq[]; extern const int reffer_freq[];
extern uint32_t minFreq; extern freq_t minFreq;
extern uint32_t maxFreq; extern freq_t maxFreq;
int level_is_calibrated(void); int level_is_calibrated(void);
void reset_settings(int); void reset_settings(int);
void update_min_max_freq(void); void update_min_max_freq(void);
@ -271,7 +272,7 @@ void set_attack(int);
void set_noise(int); void set_noise(int);
void toggle_tracking_output(void); void toggle_tracking_output(void);
extern int32_t frequencyExtra; extern int32_t frequencyExtra;
void set_10mhz(uint32_t); void set_10mhz(freq_t);
void set_modulation(int); void set_modulation(int);
void set_modulation_frequency(int); void set_modulation_frequency(int);
int search_maximum(int m, int center, int span); int search_maximum(int m, int center, int span);
@ -504,29 +505,29 @@ typedef struct config {
int16_t touch_cal[4]; int16_t touch_cal[4];
uint32_t _serial_speed; uint32_t _serial_speed;
#ifdef __VNA__ #ifdef __VNA__
uint32_t harmonic_freq_threshold; freq_t harmonic_freq_threshold;
#endif #endif
uint16_t dac_value; uint16_t dac_value;
uint16_t vbat_offset; uint16_t vbat_offset;
float low_level_offset; float low_level_offset;
float high_level_offset; float high_level_offset;
uint32_t correction_frequency[CORRECTION_POINTS]; freq_t correction_frequency[CORRECTION_POINTS];
float correction_value[CORRECTION_POINTS]; float correction_value[CORRECTION_POINTS];
uint32_t deviceid; uint32_t deviceid;
uint32_t setting_frequency_10mhz; freq_t setting_frequency_10mhz;
uint16_t gridlines; uint16_t gridlines;
uint16_t hambands; uint16_t hambands;
#ifdef TINYSA4 #ifdef TINYSA4
uint32_t frequency_IF2; freq_t frequency_IF2;
#endif #endif
int8_t _mode; int8_t _mode;
int8_t cor_am; int8_t cor_am;
int8_t cor_wfm; int8_t cor_wfm;
int8_t cor_nfm; int8_t cor_nfm;
int8_t dummy; uint32_t dummy;
// uint8_t _reserved[22]; // uint8_t _reserved[22];
uint32_t checksum; freq_t checksum;
} config_t; } config_t;
extern config_t config; extern config_t config;
@ -575,7 +576,7 @@ typedef struct {
int8_t enabled; int8_t enabled;
int8_t mtype; int8_t mtype;
int16_t index; int16_t index;
uint32_t frequency; freq_t frequency;
} marker_t; } marker_t;
#define MARKERS_MAX 4 #define MARKERS_MAX 4
@ -746,8 +747,8 @@ void show_version(void);
typedef struct setting typedef struct setting
{ {
uint32_t magic; uint32_t magic;
// uint32_t _frequency0; // freq_t _frequency0;
// uint32_t _frequency1; // freq_t _frequency1;
int mode; int mode;
uint16_t _sweep_points; uint16_t _sweep_points;
int16_t attenuate_x2; int16_t attenuate_x2;
@ -768,7 +769,7 @@ typedef struct setting
int tracking; int tracking;
int modulation; int modulation;
int step_delay; int step_delay;
uint32_t frequency_step; freq_t frequency_step;
int test; int test;
int harmonic; int harmonic;
int decay; int decay;
@ -777,9 +778,9 @@ typedef struct setting
uint32_t vbw_x10; uint32_t vbw_x10;
int tracking_output; int tracking_output;
int repeat; int repeat;
uint32_t frequency0; freq_t frequency0;
uint32_t frequency1; freq_t frequency1;
uint32_t frequency_IF; freq_t frequency_IF;
int freq_mode; int freq_mode;
int measurement; int measurement;
int refer; int refer;
@ -840,7 +841,7 @@ enum { SD_NORMAL, SD_PRECISE, SD_FAST, SD_MANUAL };
#define REPEAT_TIME 111 // Time per extra repeat in uS #define REPEAT_TIME 111 // Time per extra repeat in uS
#define MEASURE_TIME 127 // Time per single point measurement with vbwstep =1 without step delay in uS #define MEASURE_TIME 127 // Time per single point measurement with vbwstep =1 without step delay in uS
extern uint32_t frequencies[POINTS_COUNT]; extern freq_t frequencies[POINTS_COUNT];
extern const float unit_scale_value[]; extern const float unit_scale_value[];
extern const char * const unit_scale_text[]; extern const char * const unit_scale_text[];
@ -880,17 +881,17 @@ extern const char * const unit_scale_text[];
typedef struct properties { typedef struct properties {
uint32_t magic; uint32_t magic;
preset_t setting; preset_t setting;
// uint32_t _frequency0; // freq_t _frequency0;
// uint32_t _frequency1; // freq_t _frequency1;
uint16_t _sweep_points; uint16_t _sweep_points;
#ifdef __VNA__ #ifdef __VNA__
uint16_t _cal_status; uint16_t _cal_status;
#endif #endif
#ifdef __SA__ #ifdef __SA__
// uint32_t _frequency_IF; //IF frequency // freq_t _frequency_IF; //IF frequency
#endif #endif
// uint32_t _frequencies[POINTS_COUNT]; // freq_t _frequencies[POINTS_COUNT];
#ifdef __VNA__ #ifdef __VNA__
float _cal_data[5][POINTS_COUNT][2]; float _cal_data[5][POINTS_COUNT][2];
float _electrical_delay; // picoseconds float _electrical_delay; // picoseconds
@ -1107,7 +1108,7 @@ void wait_user(void);
void calibrate(void); void calibrate(void);
float to_dBm(float); float to_dBm(float);
uint32_t calc_min_sweep_time_us(void); uint32_t calc_min_sweep_time_us(void);
pureRSSI_t perform(bool b, int i, uint32_t f, int e); pureRSSI_t perform(bool b, int i, freq_t f, int e);
void interpolate_maximum(int m); void interpolate_maximum(int m);
enum { enum {

40
plot.c
Unescape View File

@ -42,7 +42,7 @@ void cell_draw_test_info(int x0, int y0);
static int16_t grid_offset; static int16_t grid_offset;
static int16_t grid_width; static int16_t grid_width;
static int32_t grid_span; static freq_t grid_span;
int16_t area_width = AREA_WIDTH_NORMAL; int16_t area_width = AREA_WIDTH_NORMAL;
int16_t area_height; // initialized in main() = AREA_HEIGHT_NORMAL; int16_t area_height; // initialized in main() = AREA_HEIGHT_NORMAL;
@ -119,10 +119,10 @@ float2int(float v)
void update_grid(void) void update_grid(void)
{ {
uint32_t gdigit = 100000000; freq_t gdigit = 100000000;
uint32_t fstart = get_sweep_frequency(ST_START); freq_t fstart = get_sweep_frequency(ST_START);
uint32_t fspan = get_sweep_frequency(ST_SPAN); freq_t fspan = get_sweep_frequency(ST_SPAN);
uint32_t grid; freq_t grid;
if (fspan == 0) { if (fspan == 0) {
fspan = setting.actual_sweep_time_us; // Time in uS fspan = setting.actual_sweep_time_us; // Time in uS
@ -412,8 +412,8 @@ rectangular_grid(int x, int y)
#ifdef __HAM_BAND__ #ifdef __HAM_BAND__
typedef const struct { typedef const struct {
uint32_t start; freq_t start;
uint32_t stop; freq_t stop;
} ham_bands_t; } ham_bands_t;
const ham_bands_t ham_bands[] = const ham_bands_t ham_bands[] =
@ -439,9 +439,9 @@ int ham_band(int x) // Search which index in the frequency tabled matches w
{ {
if (!config.hambands) if (!config.hambands)
return false; return false;
uint32_t f = frequencies[x]; freq_t f = frequencies[x];
int L = 0; int L = 0;
int R = (sizeof ham_bands)/sizeof(uint32_t) - 1; int R = (sizeof ham_bands)/sizeof(freq_t) - 1;
while (L <= R) { while (L <= R) {
int m = (L + R) / 2; int m = (L + R) / 2;
if (ham_bands[m].stop < f) if (ham_bands[m].stop < f)
@ -909,14 +909,14 @@ void trace_get_value_string( // Only used at one place
int t, char *buf, int len, int t, char *buf, int len,
int i, float coeff[POINTS_COUNT], int i, float coeff[POINTS_COUNT],
int ri, int mtype, int ri, int mtype,
uint32_t i_freq, uint32_t ref_freq) freq_t i_freq, freq_t ref_freq)
{ {
(void) t; (void) t;
float v; float v;
char buf2[16]; char buf2[16];
char buf3[8]; char buf3[8];
char *ptr2 = buf2; char *ptr2 = buf2;
uint32_t dfreq = 0; freq_t dfreq = 0;
float rlevel = 0; float rlevel = 0;
int ii = i; int ii = i;
int unit_index = setting.unit; int unit_index = setting.unit;
@ -961,7 +961,7 @@ void trace_get_value_string( // Only used at one place
#endif #endif
} else { } else {
#if 0 #if 0
uint32_t resolution = get_sweep_frequency(ST_SPAN); freq_t resolution = get_sweep_frequency(ST_SPAN);
if (resolution <= 2000*POINTS_COUNT) if (resolution <= 2000*POINTS_COUNT)
plot_printf(ptr2, sizeof(buf2) - 2, "%3.3f" , (dfreq + 500) / 1000000.0); plot_printf(ptr2, sizeof(buf2) - 2, "%3.3f" , (dfreq + 500) / 1000000.0);
else if (resolution <= 20000*POINTS_COUNT) else if (resolution <= 20000*POINTS_COUNT)
@ -1957,10 +1957,10 @@ cell_draw_marker_info(int x0, int y0)
cell_drawstring(buf, xpos, ypos); cell_drawstring(buf, xpos, ypos);
xpos += 13; xpos += 13;
//trace_get_info(t, buf, sizeof buf); //trace_get_info(t, buf, sizeof buf);
uint32_t freq = frequencies[markers[mk].index]; freq_t freq = frequencies[markers[mk].index];
if (uistat.marker_delta && mk != active_marker) { if (uistat.marker_delta && mk != active_marker) {
uint32_t freq1 = frequencies[markers[active_marker].index]; freq_t freq1 = frequencies[markers[active_marker].index];
uint32_t delta = freq > freq1 ? freq - freq1 : freq1 - freq; freq_t delta = freq > freq1 ? freq - freq1 : freq1 - freq;
plot_printf(buf, sizeof buf, S_DELTA"%.9qHz", delta); plot_printf(buf, sizeof buf, S_DELTA"%.9qHz", delta);
} else { } else {
plot_printf(buf, sizeof buf, "%.10qHz", freq); plot_printf(buf, sizeof buf, "%.10qHz", freq);
@ -1987,9 +1987,9 @@ cell_draw_marker_info(int x0, int y0)
cell_drawstring(buf, xpos, ypos); cell_drawstring(buf, xpos, ypos);
xpos += 27; xpos += 27;
if ((domain_mode & DOMAIN_MODE) == DOMAIN_FREQ) { if ((domain_mode & DOMAIN_MODE) == DOMAIN_FREQ) {
uint32_t freq = frequencies[idx]; freq_t freq = frequencies[idx];
uint32_t freq1 = frequencies[idx0]; freq_t freq1 = frequencies[idx0];
uint32_t delta = freq > freq1 ? freq - freq1 : freq1 - freq; freq_t delta = freq > freq1 ? freq - freq1 : freq1 - freq;
plot_printf(buf, sizeof buf, "%c%.13qHz", freq >= freq1 ? '+' : '-', delta); plot_printf(buf, sizeof buf, "%c%.13qHz", freq >= freq1 ? '+' : '-', delta);
} else { } else {
plot_printf(buf, sizeof buf, "%Fs (%Fm)", time_of_index(idx) - time_of_index(idx0), distance_of_index(idx) - distance_of_index(idx0)); plot_printf(buf, sizeof buf, "%Fs (%Fm)", time_of_index(idx) - time_of_index(idx0), distance_of_index(idx) - distance_of_index(idx0));
@ -2100,7 +2100,7 @@ static void cell_draw_marker_info(int x0, int y0)
for (int i = 0; i < MARKER_COUNT; i++) { for (int i = 0; i < MARKER_COUNT; i++) {
if (i == 3) { if (i == 3) {
if (setting.measurement == M_PASS_BAND) { if (setting.measurement == M_PASS_BAND) {
uint32_t f; freq_t f;
if (markers[2].frequency>markers[1].frequency) if (markers[2].frequency>markers[1].frequency)
f = markers[2].frequency-markers[1].frequency; f = markers[2].frequency-markers[1].frequency;
else else
@ -2141,7 +2141,7 @@ static void cell_draw_marker_info(int x0, int y0)
setting.unit = U_WATT; setting.unit = U_WATT;
float p = index_to_value(markers[0].index); float p = index_to_value(markers[0].index);
int h_i = 2; int h_i = 2;
uint32_t f = markers[0].frequency; freq_t f = markers[0].frequency;
float h = 0.0; float h = 0.0;
while (f * h_i < frequencies[sweep_points-1]) { while (f * h_i < frequencies[sweep_points-1]) {
if (search_maximum(1, f*h_i, 4*h_i) ) // use marker 1 for searching harmonics if (search_maximum(1, f*h_i, 4*h_i) ) // use marker 1 for searching harmonics

34
sa_cmd.c
Unescape View File

@ -272,8 +272,8 @@ VNA_SHELL_FUNCTION(cmd_if)
shell_printf("usage: if {433M..435M}\r\n"); shell_printf("usage: if {433M..435M}\r\n");
return; return;
} else { } else {
uint32_t a = (uint32_t)my_atoi(argv[0]); freq_t a = (freq_t)my_atoi(argv[0]);
if (a!= 0 &&( a < (DEFAULT_IF - (uint32_t)2000000) || a>(DEFAULT_IF + (uint32_t)2000000))) if (a!= 0 &&( a < (DEFAULT_IF - (freq_t)2000000) || a>(DEFAULT_IF + (freq_t)2000000)))
goto usage; goto usage;
setting.auto_IF = false; setting.auto_IF = false;
set_IF(a); set_IF(a);
@ -449,7 +449,7 @@ return; // Don't use!!!!
VNA_SHELL_FUNCTION(cmd_o) VNA_SHELL_FUNCTION(cmd_o)
{ {
(void) argc; (void) argc;
uint32_t value = my_atoi(argv[0]); freq_t value = my_atoi(argv[0]);
if (VFO == 0) if (VFO == 0)
setting.frequency_IF = value; setting.frequency_IF = value;
set_freq(VFO, value); set_freq(VFO, value);
@ -489,7 +489,7 @@ VNA_SHELL_FUNCTION(cmd_a)
shell_printf("a=%u\r\n", frequencyStart); shell_printf("a=%u\r\n", frequencyStart);
return; return;
} }
uint32_t value = my_atoui(argv[0]); freq_t value = my_atoui(argv[0]);
frequencyStart = value; frequencyStart = value;
} }
@ -501,7 +501,7 @@ VNA_SHELL_FUNCTION(cmd_b)
shell_printf("b=%u\r\n", frequencyStop); shell_printf("b=%u\r\n", frequencyStop);
return; return;
} }
uint32_t value = my_atoui(argv[0]); freq_t value = my_atoui(argv[0]);
frequencyStop = value; frequencyStop = value;
} }
@ -542,11 +542,11 @@ void sweep_remote(void)
{ {
uint32_t i; uint32_t i;
uint32_t step = (points - 1); uint32_t step = (points - 1);
uint32_t span = frequencyStop - frequencyStart; freq_t span = frequencyStop - frequencyStart;
uint32_t delta = span / step; freq_t delta = span / step;
uint32_t error = span % step; freq_t error = span % step;
uint32_t f = frequencyStart - setting.frequency_IF, df = step>>1; freq_t f = frequencyStart - setting.frequency_IF, df = step>>1;
uint32_t old_step = setting.frequency_step; freq_t old_step = setting.frequency_step;
setting.frequency_step = delta; setting.frequency_step = delta;
streamPut(shell_stream, '{'); streamPut(shell_stream, '{');
dirty = true; dirty = true;
@ -638,7 +638,7 @@ VNA_SHELL_FUNCTION(cmd_correction)
return; return;
} }
int i = my_atoi(argv[0]); int i = my_atoi(argv[0]);
uint32_t f = my_atoui(argv[1]); freq_t f = my_atoui(argv[1]);
float v = my_atof(argv[2]); float v = my_atof(argv[2]);
config.correction_frequency[i] = f; config.correction_frequency[i] = f;
config.correction_value[i] = v; config.correction_value[i] = v;
@ -648,7 +648,7 @@ VNA_SHELL_FUNCTION(cmd_correction)
VNA_SHELL_FUNCTION(cmd_scanraw) VNA_SHELL_FUNCTION(cmd_scanraw)
{ {
uint32_t start, stop; freq_t start, stop;
uint32_t points = sweep_points; uint32_t points = sweep_points;
if (argc < 2 || argc > 3) { if (argc < 2 || argc > 3) {
shell_printf("usage: scanraw {start(Hz)} {stop(Hz)} [points]\r\n"); shell_printf("usage: scanraw {start(Hz)} {stop(Hz)} [points]\r\n");
@ -668,12 +668,13 @@ VNA_SHELL_FUNCTION(cmd_scanraw)
// if (get_waterfall()) // if (get_waterfall())
// disable_waterfall(); // display dma hangs when waterfall is enabled // disable_waterfall(); // display dma hangs when waterfall is enabled
uint32_t old_step = setting.frequency_step; freq_t old_step = setting.frequency_step;
float f_step = (stop-start)/ points; float f_step = (stop-start)/ points;
setting.frequency_step = (uint32_t)f_step; setting.frequency_step = (freq_t)f_step;
streamPut(shell_stream, '{'); streamPut(shell_stream, '{');
static uint32_t old_start=0, old_stop=0, old_points=0; static freq_t old_start=0, old_stop=0;
static uint32_t old_points=0;
if (old_start != start || old_stop != stop || old_points != points) { // To prevent dirty for every sweep if (old_start != start || old_stop != stop || old_points != points) { // To prevent dirty for every sweep
dirty = true; dirty = true;
old_start = start; old_start = start;
@ -684,7 +685,7 @@ VNA_SHELL_FUNCTION(cmd_scanraw)
dirty = true; dirty = true;
for (uint32_t i = 0; i<points; i++) { for (uint32_t i = 0; i<points; i++) {
int val = perform(false, i, start +(uint32_t)(f_step * i), false) + float_TO_PURE_RSSI(EXT_ZERO_LEVEL); int val = perform(false, i, start +(freq_t)(f_step * i), false) + float_TO_PURE_RSSI(EXT_ZERO_LEVEL);
if (operation_requested) // break on operation in perform if (operation_requested) // break on operation in perform
break; break;
streamPut(shell_stream, 'x'); streamPut(shell_stream, 'x');
@ -693,6 +694,7 @@ VNA_SHELL_FUNCTION(cmd_scanraw)
} }
streamPut(shell_stream, '}'); streamPut(shell_stream, '}');
setting.frequency_step = old_step; setting.frequency_step = old_step;
dirty = true;
redraw_request = 0; // disable screen update in this mode redraw_request = 0; // disable screen update in this mode
} }

87
sa_core.c
Unescape View File

@ -34,13 +34,15 @@
int scandirty = true; int scandirty = true;
setting_t setting; setting_t setting;
uint32_t frequencies[POINTS_COUNT]; freq_t frequencies[POINTS_COUNT];
uint16_t actual_rbw_x10 = 0; uint16_t actual_rbw_x10 = 0;
uint16_t vbwSteps = 1; uint16_t vbwSteps = 1;
uint32_t minFreq = 0; freq_t minFreq = 0;
uint32_t maxFreq = 520000000; freq_t maxFreq = 520000000;
static freq_t old_freq[4] = { 0, 0, 0, 0};
static freq_t real_old_freq[4] = { 0, 0, 0, 0};
//int setting.refer = -1; // Off by default //int setting.refer = -1; // Off by default
const int reffer_freq[] = {30000000, 15000000, 10000000, 4000000, 3000000, 2000000, 1000000}; const int reffer_freq[] = {30000000, 15000000, 10000000, 4000000, 3000000, 2000000, 1000000};
@ -183,16 +185,11 @@ void reset_settings(int m)
} }
markers[0].mtype = M_REFERENCE | M_TRACKING; markers[0].mtype = M_REFERENCE | M_TRACKING;
markers[0].enabled = M_ENABLED; markers[0].enabled = M_ENABLED;
setting._active_marker = 0;
set_sweep_points(POINTS_COUNT);
dirty = true; dirty = true;
} }
//static uint32_t extra_vbw_step_time = 0;
//static uint32_t etra_repeat_time = 0;
//static uint32_t minimum_zero_span_sweep_time = 0;
//static uint32_t minimum_sweep_time = 0;
uint32_t calc_min_sweep_time_us(void) // Estimate minimum sweep time in uS, needed to calculate the initial delays for the RSSI before first sweep uint32_t calc_min_sweep_time_us(void) // Estimate minimum sweep time in uS, needed to calculate the initial delays for the RSSI before first sweep
{ {
uint32_t t; uint32_t t;
@ -266,7 +263,7 @@ void set_gridlines(int d)
//int setting_frequency_10mhz = 10000000; //int setting_frequency_10mhz = 10000000;
void set_10mhz(uint32_t f) void set_10mhz(freq_t f)
{ {
if (f < 9000000 || f > 11000000) if (f < 9000000 || f > 11000000)
return; return;
@ -379,7 +376,7 @@ void set_modulation(int m)
void set_modulation_frequency(int f) void set_modulation_frequency(int f)
{ {
if (100 <= f && f <= 6000) { if (50 <= f && f <= 6000) {
setting.modulation_frequency = f; setting.modulation_frequency = f;
dirty = true; dirty = true;
} }
@ -683,7 +680,7 @@ void set_harmonic(int h)
{ {
setting.harmonic = h; setting.harmonic = h;
minFreq = 684000000.0; minFreq = 684000000.0;
if ((uint32_t)(setting.harmonic * 240000000)+434000000 > minFreq) if ((freq_t)(setting.harmonic * 240000000)+434000000 > minFreq)
minFreq = setting.harmonic * 240000000.0+434000000.0; minFreq = setting.harmonic * 240000000.0+434000000.0;
maxFreq = 4360000000; maxFreq = 4360000000;
if (setting.harmonic != 0 && (960000000.0 * setting.harmonic + 434000000.0 )< 4360000000.0) if (setting.harmonic != 0 && (960000000.0 * setting.harmonic + 434000000.0 )< 4360000000.0)
@ -1051,7 +1048,7 @@ void apply_settings(void) // Ensure all settings in the setting structure
#if 0 #if 0
#define CORRECTION_POINTS 10 #define CORRECTION_POINTS 10
static const uint32_t correction_frequency[CORRECTION_POINTS] = static const freq_t correction_frequency[CORRECTION_POINTS] =
{ 100000, 200000, 400000, 1000000, 2000000, 50000000, 100000000, 200000000, 300000000, 350000000 }; { 100000, 200000, 400000, 1000000, 2000000, 50000000, 100000000, 200000000, 300000000, 350000000 };
static const float correction_value[CORRECTION_POINTS] = static const float correction_value[CORRECTION_POINTS] =
@ -1083,7 +1080,7 @@ void calculate_correction(void)
#pragma GCC push_options #pragma GCC push_options
#pragma GCC optimize ("Og") // "Os" causes problem #pragma GCC optimize ("Og") // "Os" causes problem
pureRSSI_t get_frequency_correction(uint32_t f) // Frequency dependent RSSI correction to compensate for imperfect LPF pureRSSI_t get_frequency_correction(freq_t f) // Frequency dependent RSSI correction to compensate for imperfect LPF
{ {
if (!(setting.mode == M_LOW || setting.mode == M_GENLOW)) if (!(setting.mode == M_LOW || setting.mode == M_GENLOW))
return(0.0); return(0.0);
@ -1096,7 +1093,7 @@ pureRSSI_t get_frequency_correction(uint32_t f) // Frequency dependent RSSI
return(scaled_correction_value[0] >> (SCALE_FACTOR - 5) ); return(scaled_correction_value[0] >> (SCALE_FACTOR - 5) );
f = f - config.correction_frequency[i-1]; f = f - config.correction_frequency[i-1];
#if 0 #if 0
uint32_t m = (config.correction_frequency[i] - config.correction_frequency[i-1]) >> SCALE_FACTOR ; freq_t m = (config.correction_frequency[i] - config.correction_frequency[i-1]) >> SCALE_FACTOR ;
float multi = (config.correction_value[i] - config.correction_value[i-1]) * (1 << (SCALE_FACTOR -1)) / (float)m; float multi = (config.correction_value[i] - config.correction_value[i-1]) * (1 << (SCALE_FACTOR -1)) / (float)m;
float cv = config.correction_value[i-1] + ((f >> SCALE_FACTOR) * multi) / (float)(1 << (SCALE_FACTOR -1)) ; float cv = config.correction_value[i-1] + ((f >> SCALE_FACTOR) * multi) / (float)(1 << (SCALE_FACTOR -1)) ;
#else #else
@ -1111,18 +1108,12 @@ pureRSSI_t get_frequency_correction(uint32_t f) // Frequency dependent RSSI
float peakLevel; float peakLevel;
float min_level; float min_level;
uint32_t peakFreq; freq_t peakFreq;
int peakIndex; int peakIndex;
float temppeakLevel; float temppeakLevel;
int temppeakIndex; int temppeakIndex;
static unsigned long old_freq[4] = { 0, 0, 0, 0};
static unsigned long real_old_freq[4] = { 0, 0, 0, 0};
// volatile int t;
//static uint32_t extra_vbw_step_time = 0; // volatile int t;
//static uint32_t etra_repeat_time = 0;
//static uint32_t minimum_zero_span_sweep_time = 0;
//static uint32_t minimum_sweep_time = 0;
void setupSA(void) void setupSA(void)
{ {
@ -1184,9 +1175,9 @@ void set_freq(int V, unsigned long freq) // translate the requested frequency
if (delta > OFFSET_LOWER_BOUND && delta < 79999) { // and requested frequency can be reached by using the offset registers if (delta > OFFSET_LOWER_BOUND && delta < 79999) { // and requested frequency can be reached by using the offset registers
#if 0 #if 0
if (real_old_freq[V] >= 480000000) if (real_old_freq[V] >= 480000000)
shell_printf("%d: Offs %q HW %d\r\n", SI4432_Sel, (uint32_t)(real_old_freq[V]+delta*2), real_old_freq[V]); shell_printf("%d: Offs %q HW %d\r\n", SI4432_Sel, (freq_t)(real_old_freq[V]+delta*2), real_old_freq[V]);
else else
shell_printf("%d: Offs %q HW %d\r\n", SI4432_Sel, (uint32_t)(real_old_freq[V]+delta*1), real_old_freq[V]); shell_printf("%d: Offs %q HW %d\r\n", SI4432_Sel, (freq_t)(real_old_freq[V]+delta*1), real_old_freq[V]);
#endif #endif
delta = delta * 4 / 625; // = 156.25; // Calculate and set the offset register i.s.o programming a new frequency delta = delta * 4 / 625; // = 156.25; // Calculate and set the offset register i.s.o programming a new frequency
SI4432_Write_2_Byte(SI4432_FREQ_OFFSET1, (uint8_t)(delta & 0xff), (uint8_t)((delta >> 8) & 0x03)); SI4432_Write_2_Byte(SI4432_FREQ_OFFSET1, (uint8_t)(delta & 0xff), (uint8_t)((delta >> 8) & 0x03));
@ -1195,7 +1186,7 @@ void set_freq(int V, unsigned long freq) // translate the requested frequency
old_freq[V] = freq; old_freq[V] = freq;
} else { } else {
#ifdef __WIDE_OFFSET__ #ifdef __WIDE_OFFSET__
uint32_t target_f; // Impossible to use offset so set SI4432 to new frequency freq_t target_f; // Impossible to use offset so set SI4432 to new frequency
if (freq < real_old_freq[V]) { // sweeping down if (freq < real_old_freq[V]) { // sweeping down
if (freq - 80000 >= 480000000) { if (freq - 80000 >= 480000000) {
target_f = freq - 160000; target_f = freq - 160000;
@ -1360,7 +1351,7 @@ void update_rbw(void) // calculate the actual_rbw and the vbwSteps (#
} else { } else {
setting.vbw_x10 = 3000; // trick to get right default rbw in zero span mode setting.vbw_x10 = 3000; // trick to get right default rbw in zero span mode
} }
uint32_t temp_actual_rbw_x10 = setting.rbw_x10; // requested rbw , 32 bit !!!!!! freq_t temp_actual_rbw_x10 = setting.rbw_x10; // requested rbw , 32 bit !!!!!!
if (temp_actual_rbw_x10 == 0) { // if auto rbw if (temp_actual_rbw_x10 == 0) { // if auto rbw
if (setting.step_delay_mode==SD_FAST) { // if in fast scanning if (setting.step_delay_mode==SD_FAST) { // if in fast scanning
if (setting.fast_speedup > 2) if (setting.fast_speedup > 2)
@ -1618,7 +1609,7 @@ static void calculate_static_correction(void) // Calculate the
- setting.offset); - setting.offset);
} }
pureRSSI_t perform(bool break_on_operation, int i, uint32_t f, int tracking) // Measure the RSSI for one frequency, used from sweep and other measurement routines. Must do all HW setup pureRSSI_t perform(bool break_on_operation, int i, freq_t f, int tracking) // Measure the RSSI for one frequency, used from sweep and other measurement routines. Must do all HW setup
{ {
int modulation_delay = 0; int modulation_delay = 0;
int modulation_index = 0; int modulation_index = 0;
@ -1737,8 +1728,8 @@ pureRSSI_t perform(bool break_on_operation, int i, uint32_t f, int tracking)
modulation_delay += config.cor_nfm; // -17 default modulation_delay += config.cor_nfm; // -17 default
// modulation_index = 0; // default value // modulation_index = 0; // default value
} }
if ((setting.mode == M_GENLOW && f > ((uint32_t)480000000) - DEFAULT_IF) || if ((setting.mode == M_GENLOW && f > ((freq_t)480000000) - DEFAULT_IF) ||
(setting.mode == M_GENHIGH && f > ((uint32_t)480000000) ) ) (setting.mode == M_GENHIGH && f > ((freq_t)480000000) ) )
modulation_index += 2; modulation_index += 2;
current_fm_modulation = (int *)fm_modulation[modulation_index]; current_fm_modulation = (int *)fm_modulation[modulation_index];
f -= fm_modulation_offset[modulation_index]; // Shift output frequency f -= fm_modulation_offset[modulation_index]; // Shift output frequency
@ -1780,7 +1771,7 @@ modulation_again:
#endif #endif
int t = 0; int t = 0;
do { do {
uint32_t lf = f; freq_t lf = f;
if (vbwSteps > 1) { // Calculate sub steps if (vbwSteps > 1) { // Calculate sub steps
int offs_div10 = (t - (vbwSteps >> 1)) * 500 / 10; // steps of half the rbw int offs_div10 = (t - (vbwSteps >> 1)) * 500 / 10; // steps of half the rbw
if ((vbwSteps & 1) == 0) // Uneven steps, center if ((vbwSteps & 1) == 0) // Uneven steps, center
@ -1796,7 +1787,7 @@ modulation_again:
if (/* MODE_INPUT(setting.mode) && */ i > 0 && FREQ_IS_CW()) // In input mode in zero span mode after first setting of the LO's if (/* MODE_INPUT(setting.mode) && */ i > 0 && FREQ_IS_CW()) // In input mode in zero span mode after first setting of the LO's
goto skip_LO_setting; // No more LO changes required, save some time and jump over the code goto skip_LO_setting; // No more LO changes required, save some time and jump over the code
uint32_t local_IF; freq_t local_IF;
spur_second_pass = false; spur_second_pass = false;
again: // Spur reduction jumps to here for second measurement again: // Spur reduction jumps to here for second measurement
@ -1881,7 +1872,7 @@ modulation_again:
} else } else
#endif #endif
{ // Else set LO ('s) { // Else set LO ('s)
uint32_t target_f; freq_t target_f;
if (setting.mode == M_LOW && !setting.tracking && S_STATE(setting.below_IF)) // if in low input mode and below IF if (setting.mode == M_LOW && !setting.tracking && S_STATE(setting.below_IF)) // if in low input mode and below IF
target_f = local_IF-lf; // set LO SI4432 to below IF frequency target_f = local_IF-lf; // set LO SI4432 to below IF frequency
else else
@ -2119,7 +2110,7 @@ sweep_again: // stay in sweep loop when output mo
} }
if (RSSI < AGC_RSSI_THRESHOLD) if (RSSI < AGC_RSSI_THRESHOLD)
agc_prev_rssi = -150; agc_prev_rssi = -150;
uint32_t delta_freq = frequencies[i] - agc_peak_freq; freq_t delta_freq = frequencies[i] - agc_peak_freq;
if (agc_peak_freq != 0 && delta_freq < 2000000) { if (agc_peak_freq != 0 && delta_freq < 2000000) {
int max_gain = (-25 - agc_peak_rssi ) / 4; int max_gain = (-25 - agc_peak_rssi ) / 4;
auto_set_AGC_LNA(false, 16 + delta_freq * max_gain / 2000000 ); // enable LNA and stepwise gain auto_set_AGC_LNA(false, 16 + delta_freq * max_gain / 2000000 ); // enable LNA and stepwise gain
@ -2511,7 +2502,7 @@ sweep_again: // stay in sweep loop when output mo
#if 0 #if 0
float v = actual_t[markers[m].index] - 10.0; // -10dB points float v = actual_t[markers[m].index] - 10.0; // -10dB points
int index = markers[m].index; int index = markers[m].index;
uint32_t f = markers[m].frequency; freq_t f = markers[m].frequency;
uint32_t s = actual_rbw_x10 * 200; // twice the selected RBW uint32_t s = actual_rbw_x10 * 200; // twice the selected RBW
int left = index, right = index; int left = index, right = index;
while (t > 0 && actual_t[t+1] > v && markers[t].frequency > f - s) // Find left point while (t > 0 && actual_t[t+1] > v && markers[t].frequency > f - s) // Find left point
@ -2562,8 +2553,8 @@ sweep_again: // stay in sweep loop when output mo
markers[0].index = l; markers[0].index = l;
markers[1].index = r; markers[1].index = r;
} }
uint32_t lf = frequencies[l]; freq_t lf = frequencies[l];
uint32_t rf = frequencies[r]; freq_t rf = frequencies[r];
markers[0].frequency = lf; markers[0].frequency = lf;
markers[1].frequency = rf; markers[1].frequency = rf;
@ -3203,8 +3194,8 @@ common_silent:
} }
trace[TRACE_STORED].enabled = true; trace[TRACE_STORED].enabled = true;
set_reflevel(test_case[i].pass+10); set_reflevel(test_case[i].pass+10);
set_sweep_frequency(ST_CENTER, (uint32_t)(test_case[i].center * 1000000)); set_sweep_frequency(ST_CENTER, (freq_t)(test_case[i].center * 1000000));
set_sweep_frequency(ST_SPAN, (uint32_t)(test_case[i].span * 1000000)); set_sweep_frequency(ST_SPAN, (freq_t)(test_case[i].span * 1000000));
draw_cal_status(); draw_cal_status();
} }
@ -3299,7 +3290,7 @@ void self_test(int test)
setting.frequency_step = 30000; setting.frequency_step = 30000;
if (setting.test_argument > 0) if (setting.test_argument > 0)
setting.frequency_step=setting.test_argument; setting.frequency_step=setting.test_argument;
uint32_t f = 400000; // Start search at 400kHz freq_t f = 400000; // Start search at 400kHz
// int i = 0; // Index in spur table (temp_t) // int i = 0; // Index in spur table (temp_t)
set_RBW(setting.frequency_step/100); set_RBW(setting.frequency_step/100);
last_spur = 0; last_spur = 0;
@ -3383,12 +3374,12 @@ void self_test(int test)
shell_printf("RBW = %f, ",setting.rbw_x10/10.0); shell_printf("RBW = %f, ",setting.rbw_x10/10.0);
#if 0 #if 0
set_sweep_frequency(ST_SPAN, (uint32_t)(setting.rbw_x10 * 1000)); // Wide set_sweep_frequency(ST_SPAN, (freq_t)(setting.rbw_x10 * 1000)); // Wide
#else #else
if (setting.rbw_x10 < 1000) if (setting.rbw_x10 < 1000)
set_sweep_frequency(ST_SPAN, (uint32_t)(setting.rbw_x10 * 5000)); // Narrow set_sweep_frequency(ST_SPAN, (freq_t)(setting.rbw_x10 * 5000)); // Narrow
else else
set_sweep_frequency(ST_SPAN, (uint32_t)(18000000)); set_sweep_frequency(ST_SPAN, (freq_t)(18000000));
#endif #endif
test_acquire(TEST_RBW); // Acquire test test_acquire(TEST_RBW); // Acquire test
test_validate(TEST_RBW); // Validate test test_validate(TEST_RBW); // Validate test
@ -3410,9 +3401,9 @@ void self_test(int test)
setting.step_delay_mode = SD_NORMAL; setting.step_delay_mode = SD_NORMAL;
setting.step_delay = setting.step_delay * 4 / 5; setting.step_delay = setting.step_delay * 4 / 5;
if (setting.rbw_x10 < 1000) if (setting.rbw_x10 < 1000)
set_sweep_frequency(ST_SPAN, (uint32_t)(setting.rbw_x10 * 5000)); set_sweep_frequency(ST_SPAN, (freq_t)(setting.rbw_x10 * 5000));
else else
set_sweep_frequency(ST_SPAN, (uint32_t)(18000000)); set_sweep_frequency(ST_SPAN, (freq_t)(18000000));
// setting.repeat = 10; // setting.repeat = 10;
test_acquire(TEST_RBW); // Acquire test test_acquire(TEST_RBW); // Acquire test
@ -3435,9 +3426,9 @@ void self_test(int test)
setting.offset_delay /= 2; setting.offset_delay /= 2;
setting.spur_removal = S_OFF; setting.spur_removal = S_OFF;
if (setting.rbw_x10 < 1000) if (setting.rbw_x10 < 1000)
set_sweep_frequency(ST_SPAN, (uint32_t)(setting.rbw_x10 * 5000)); // 50 times RBW set_sweep_frequency(ST_SPAN, (freq_t)(setting.rbw_x10 * 5000)); // 50 times RBW
else else
set_sweep_frequency(ST_SPAN, (uint32_t)(18000000)); // Limit to 18MHz set_sweep_frequency(ST_SPAN, (freq_t)(18000000)); // Limit to 18MHz
// setting.repeat = 10; // setting.repeat = 10;
test_acquire(TEST_RBW); // Acquire test test_acquire(TEST_RBW); // Acquire test
test_validate(TEST_RBW); // Validate test test_validate(TEST_RBW); // Validate test

4
si4432.c
Unescape View File

@ -354,7 +354,7 @@ static int old_freq_band[2] = {-1,-1};
static int written[2]= {0,0}; static int written[2]= {0,0};
#endif #endif
void SI4432_Set_Frequency ( uint32_t Freq ) { void SI4432_Set_Frequency ( freq_t Freq ) {
// int mode = SI4432_Read_Byte(0x02) & 0x03; // Disabled as unreliable // int mode = SI4432_Read_Byte(0x02) & 0x03; // Disabled as unreliable
// SI4432_Write_Byte(0x07, 0x02); // Switch to tune mode // SI4432_Write_Byte(0x07, 0x02); // Switch to tune mode
@ -848,7 +848,7 @@ extern int settingAttenuate;
//#define LEVEL(i, f, v) (v * (1-(fabs(f - frequencies[i])/actual_rbw/1000))) //#define LEVEL(i, f, v) (v * (1-(fabs(f - frequencies[i])/actual_rbw/1000)))
float LEVEL(uint32_t i, uint32_t f, int v) float LEVEL(uint32_t i, freq_t f, int v)
{ {
float dv; float dv;
float df = fabs((float)f - (float)i); float df = fabs((float)f - (float)i);

4
si4432.h
Unescape View File

@ -156,8 +156,8 @@ void ADF4351_Setup(void);
void ADF4351_WriteRegister32(int channel, const uint32_t value); void ADF4351_WriteRegister32(int channel, const uint32_t value);
uint32_t ADF4351_set_frequency(int channel, uint32_t freq, int drive_strength); freq_t ADF4351_set_frequency(int channel, freq_t freq, int drive_strength);
uint32_t ADF4351_prep_frequency(int channel, uint32_t freq, int drive_strength); freq_t ADF4351_prep_frequency(int channel, freq_t freq, int drive_strength);
//int ADF4351_set_frequency_with_offset(uint32_t freq, int offset, uint8_t drive_strength); //int ADF4351_set_frequency_with_offset(uint32_t freq, int offset, uint8_t drive_strength);
void ADF4351_Set(int channel); void ADF4351_Set(int channel);
void ADF4351_enable_output(void); void ADF4351_enable_output(void);

48
ui.c
Unescape View File

@ -778,7 +778,7 @@ menu_stimulus_cb(int item, uint8_t data)
} }
#endif #endif
static uint32_t static freq_t
get_marker_frequency(int marker) get_marker_frequency(int marker)
{ {
if (marker < 0 || marker >= MARKERS_MAX) if (marker < 0 || marker >= MARKERS_MAX)
@ -791,7 +791,7 @@ get_marker_frequency(int marker)
static UI_FUNCTION_CALLBACK(menu_marker_op_cb) static UI_FUNCTION_CALLBACK(menu_marker_op_cb)
{ {
(void)item; (void)item;
uint32_t freq = get_marker_frequency(active_marker); freq_t freq = get_marker_frequency(active_marker);
if (freq == 0) if (freq == 0)
return; // no active marker return; // no active marker
@ -809,12 +809,12 @@ static UI_FUNCTION_CALLBACK(menu_marker_op_cb)
{ {
if (previous_marker == -1 || active_marker == previous_marker) { if (previous_marker == -1 || active_marker == previous_marker) {
// if only 1 marker is active, keep center freq and make span the marker comes to the edge // if only 1 marker is active, keep center freq and make span the marker comes to the edge
uint32_t center = get_sweep_frequency(ST_CENTER); freq_t center = get_sweep_frequency(ST_CENTER);
uint32_t span = center > freq ? center - freq : freq - center; freq_t span = center > freq ? center - freq : freq - center;
set_sweep_frequency(ST_SPAN, span * 2); set_sweep_frequency(ST_SPAN, span * 2);
} else { } else {
// if 2 or more marker active, set start and stop freq to each marker // if 2 or more marker active, set start and stop freq to each marker
uint32_t freq2 = get_marker_frequency(previous_marker); freq_t freq2 = get_marker_frequency(previous_marker);
if (freq2 == 0) if (freq2 == 0)
return; return;
if (freq > freq2) { if (freq > freq2) {
@ -1234,6 +1234,7 @@ menu_move_back(void)
if (current_menu_is_form()) { if (current_menu_is_form()) {
redraw_frame(); redraw_frame();
redraw_request |= REDRAW_BATTERY;
area_width = 0; area_width = 0;
} else { } else {
// redraw_frame(); // redraw_frame();
@ -1269,6 +1270,7 @@ menu_push_submenu(const menuitem_t *submenu)
ensure_selection(); ensure_selection();
if (menu_is_form(submenu)) { if (menu_is_form(submenu)) {
redraw_frame(); redraw_frame();
redraw_request |= REDRAW_BATTERY;
area_width = 0; area_width = 0;
} else { } else {
// redraw_frame(); // redraw_frame();
@ -1901,17 +1903,17 @@ void set_keypad_value(int v)
set_numeric_value(); set_numeric_value();
} }
void check_frequency_slider(uint32_t slider_freq) void check_frequency_slider(freq_t slider_freq)
{ {
if ( (maxFreq - minFreq) < (uint32_t)setting.slider_span ) { if ( (maxFreq - minFreq) < (freq_t)setting.slider_span ) {
setting.slider_span = maxFreq - minFreq; // absolute mode with max step size setting.slider_span = maxFreq - minFreq; // absolute mode with max step size
} }
uint32_t half_span = setting.slider_span >> 1; freq_t half_span = setting.slider_span >> 1;
if (minFreq + (uint32_t)half_span > slider_freq) { if (minFreq + (freq_t)half_span > slider_freq) {
setting.slider_position -= (minFreq + half_span - slider_freq) / (setting.slider_span / (MENU_FORM_WIDTH-8)); // reposition if needed setting.slider_position -= (minFreq + half_span - slider_freq) / (setting.slider_span / (MENU_FORM_WIDTH-8)); // reposition if needed
} }
if (maxFreq < slider_freq + (uint32_t)half_span) { if (maxFreq < slider_freq + (freq_t)half_span) {
setting.slider_position += (slider_freq + half_span - maxFreq) / (setting.slider_span /(MENU_FORM_WIDTH-8)); // reposition if needed setting.slider_position += (slider_freq + half_span - maxFreq) / (setting.slider_span /(MENU_FORM_WIDTH-8)); // reposition if needed
} }
} }
@ -1967,12 +1969,12 @@ menu_select_touch(int i, int pos)
setting.slider_position = new_slider; setting.slider_position = new_slider;
set_keypad_value(keypad); set_keypad_value(keypad);
dirty = false; dirty = false;
perform(false, 0, (uint32_t)uistat.value, false); perform(false, 0, (freq_t)uistat.value, false);
draw_menu(); draw_menu();
} else if (mode == SL_SPAN ){ } else if (mode == SL_SPAN ){
uint32_t slider_freq; freq_t slider_freq;
first_span: first_span:
slider_freq = (uint32_t) uistat.value; slider_freq = (freq_t) uistat.value;
int pw=new_slider + LCD_WIDTH/2; int pw=new_slider + LCD_WIDTH/2;
setting.slider_position = pw - LCD_WIDTH/2; // Show delta on slider setting.slider_position = pw - LCD_WIDTH/2; // Show delta on slider
setting.slider_span = 10; setting.slider_span = 10;
@ -1988,9 +1990,9 @@ menu_select_touch(int i, int pos)
setting.slider_span *= 2; setting.slider_span *= 2;
pw -= 12; pw -= 12;
} }
if ((uint32_t)setting.slider_span > (maxFreq - minFreq)) if ((freq_t)setting.slider_span > (maxFreq - minFreq))
setting.slider_span = (maxFreq - minFreq); setting.slider_span = (maxFreq - minFreq);
uint32_t old_minFreq = minFreq; // Save when in high mode freq_t old_minFreq = minFreq; // Save when in high mode
minFreq = 0; // And set minFreq to 0 for span display minFreq = 0; // And set minFreq to 0 for span display
uistat.value = setting.slider_span; uistat.value = setting.slider_span;
set_keypad_value(keypad); set_keypad_value(keypad);
@ -2077,7 +2079,7 @@ menu_select_touch(int i, int pos)
step = setting.slider_span; step = setting.slider_span;
break; break;
} }
if (step < 0 && get_sweep_frequency(ST_CENTER) < (uint32_t)(-step)) if (step < 0 && get_sweep_frequency(ST_CENTER) < (freq_t)(-step))
uistat.value = 0; uistat.value = 0;
else else
uistat.value = get_sweep_frequency(ST_CENTER) + step; uistat.value = get_sweep_frequency(ST_CENTER) + step;
@ -2361,11 +2363,11 @@ lever_search_marker(int status)
// ex. 10942 -> 10000 // ex. 10942 -> 10000
// 6791 -> 5000 // 6791 -> 5000
// 341 -> 200 // 341 -> 200
static uint32_t static freq_t
step_round(uint32_t v) step_round(freq_t v)
{ {
// decade step // decade step
uint32_t x = 1; freq_t x = 1;
for (x = 1; x*10 <= v; x*= 10) for (x = 1; x*10 <= v; x*= 10)
; ;
@ -2381,9 +2383,9 @@ step_round(uint32_t v)
static void static void
lever_zoom_span(int status) lever_zoom_span(int status)
{ {
uint32_t span = get_sweep_frequency(ST_SPAN); freq_t span = get_sweep_frequency(ST_SPAN);
if (uistat.auto_center_marker) { if (uistat.auto_center_marker) {
uint32_t freq = get_marker_frequency(active_marker); freq_t freq = get_marker_frequency(active_marker);
search_maximum(active_marker, freq, 10 ); search_maximum(active_marker, freq, 10 );
if (freq != 0) if (freq != 0)
set_sweep_frequency(ST_CENTER, freq); set_sweep_frequency(ST_CENTER, freq);
@ -2415,8 +2417,8 @@ lever_zoom_time(int status)
static void static void
lever_move(int status, int mode) lever_move(int status, int mode)
{ {
uint32_t center = get_sweep_frequency(mode); freq_t center = get_sweep_frequency(mode);
uint32_t span = get_sweep_frequency(ST_SPAN); freq_t span = get_sweep_frequency(ST_SPAN);
span = step_round(span / 3); span = step_round(span / 3);
if (status & EVT_UP) { if (status & EVT_UP) {
set_sweep_frequency(mode, center + span); set_sweep_frequency(mode, center + span);

16
ui_sa.c
Unescape View File

@ -901,7 +901,7 @@ static UI_FUNCTION_ADV_CALLBACK(menu_measure_acb)
markers[i].enabled = M_ENABLED; markers[i].enabled = M_ENABLED;
markers[i].mtype = M_DELTA;// | M_TRACKING; markers[i].mtype = M_DELTA;// | M_TRACKING;
} }
uint32_t center, span; freq_t center, span;
markers[0].mtype = M_REFERENCE;// | M_TRACKING; markers[0].mtype = M_REFERENCE;// | M_TRACKING;
kp_help_text = "Frequency of signal"; kp_help_text = "Frequency of signal";
ui_mode_keypad(KM_CENTER); ui_mode_keypad(KM_CENTER);
@ -2167,7 +2167,7 @@ static void fetch_numeric_target(void)
} }
{ {
uint32_t x = uistat.value; freq_t x = uistat.value;
int n = 0; int n = 0;
for (; x >= 10 && n < 9; n++) for (; x >= 10 && n < 9; n++)
x /= 10; x /= 10;
@ -2181,20 +2181,20 @@ set_numeric_value(void)
{ {
switch (keypad_mode) { switch (keypad_mode) {
case KM_START: case KM_START:
set_sweep_frequency(ST_START, (uint32_t)uistat.value); set_sweep_frequency(ST_START, (freq_t)uistat.value);
break; break;
case KM_STOP: case KM_STOP:
set_sweep_frequency(ST_STOP, (uint32_t)uistat.value); set_sweep_frequency(ST_STOP, (freq_t)uistat.value);
break; break;
case KM_CENTER: case KM_CENTER:
set_sweep_frequency(ST_CENTER, (uint32_t)uistat.value); set_sweep_frequency(ST_CENTER, (freq_t)uistat.value);
break; break;
case KM_SPAN: case KM_SPAN:
setting.modulation = MO_NONE; setting.modulation = MO_NONE;
set_sweep_frequency(ST_SPAN, (uint32_t)uistat.value); set_sweep_frequency(ST_SPAN, (freq_t)uistat.value);
break; break;
case KM_CW: case KM_CW:
set_sweep_frequency(ST_CW, (uint32_t)uistat.value); set_sweep_frequency(ST_CW, (freq_t)uistat.value);
break; break;
case KM_SCALE: case KM_SCALE:
user_set_scale(uistat.value); user_set_scale(uistat.value);
@ -2272,7 +2272,7 @@ set_numeric_value(void)
set_gridlines(uistat.value); set_gridlines(uistat.value);
break; break;
case KM_MARKER: case KM_MARKER:
set_marker_frequency(active_marker, (uint32_t)uistat.value); set_marker_frequency(active_marker, (freq_t)uistat.value);
break; break;
case KM_MODULATION: case KM_MODULATION:
set_modulation_frequency((int)uistat.value); set_modulation_frequency((int)uistat.value);

Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.