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

Cleanup settings

Browse Source
tinySA
erikkaashoek 6 years ago
parent 393d568050
commit dea4d02631
6 changed files with 255 additions and 252 deletions
Show Stats Download Patch File Download Diff File

18
main.c
Unescape View File

@ -998,7 +998,8 @@ set_frequencies(uint32_t start, uint32_t stop, uint16_t points)
// disable at out of sweep range // disable at out of sweep range
for (; i < POINTS_COUNT; i++) for (; i < POINTS_COUNT; i++)
frequencies[i] = 0; frequencies[i] = 0;
update_rbw(frequencies[1] - frequencies[0]); setting_frequency_step = delta;
update_rbw();
} }
static void static void
@ -2229,7 +2230,7 @@ VNA_SHELL_FUNCTION(cmd_d)
{ {
(void) argc; (void) argc;
int32_t a = my_atoi(argv[0]); int32_t a = my_atoi(argv[0]);
settingDrive = a; setting_drive = a;
} }
@ -2256,11 +2257,11 @@ VNA_SHELL_FUNCTION(cmd_t)
VNA_SHELL_FUNCTION(cmd_e) VNA_SHELL_FUNCTION(cmd_e)
{ {
(void)argc; (void)argc;
trackingVFO = my_atoi(argv[0]); setting_tracking = my_atoi(argv[0]);
if (trackingVFO == -1) if (setting_tracking == -1)
trackingVFO = false; setting_tracking = false;
else else
trackingVFO = true; setting_tracking = true;
if (argc >1) if (argc >1)
frequencyExtra = my_atoi(argv[1]); frequencyExtra = my_atoi(argv[1]);
@ -2279,11 +2280,12 @@ VNA_SHELL_FUNCTION(cmd_m)
pause_sweep(); pause_sweep();
int32_t f_step = (frequencyStop-frequencyStart)/ points; int32_t f_step = (frequencyStop-frequencyStart)/ points;
palClearPad(GPIOC, GPIOC_LED); // disable led and wait for voltage stabilization palClearPad(GPIOC, GPIOC_LED); // disable led and wait for voltage stabilization
update_rbw(f_step); setting_frequency_step = f_step;
update_rbw();
chThdSleepMilliseconds(10); chThdSleepMilliseconds(10);
streamPut(shell_stream, '{'); streamPut(shell_stream, '{');
for (int i = 0; i<points; i++) { for (int i = 0; i<points; i++) {
float val = perform(false, i, frequencyStart - frequency_IF + f_step * i, trackingVFO); float val = perform(false, i, frequencyStart - frequency_IF + f_step * i, setting_tracking);
streamPut(shell_stream, 'x'); streamPut(shell_stream, 'x');
int v = val*2 + 256; int v = val*2 + 256;
streamPut(shell_stream, (uint8_t)(v & 0xFF)); streamPut(shell_stream, (uint8_t)(v & 0xFF));

16
nanovna.h
Unescape View File

@ -410,6 +410,7 @@ void ili9341_clear_screen(void);
void blit8BitWidthBitmap(uint16_t x, uint16_t y, uint16_t width, uint16_t height, const uint8_t *bitmap); void blit8BitWidthBitmap(uint16_t x, uint16_t y, uint16_t width, uint16_t height, const uint8_t *bitmap);
void ili9341_drawchar(uint8_t ch, int x, int y); void ili9341_drawchar(uint8_t ch, int x, int y);
void ili9341_drawstring(const char *str, int x, int y); void ili9341_drawstring(const char *str, int x, int y);
void ili9341_drawstring_7x13(const char *str, int x, int y);
void ili9341_drawstringV(const char *str, int x, int y); void ili9341_drawstringV(const char *str, int x, int y);
int ili9341_drawchar_size(uint8_t ch, int x, int y, uint8_t size); int ili9341_drawchar_size(uint8_t ch, int x, int y, uint8_t size);
void ili9341_drawstring_size(const char *str, int x, int y, uint8_t size); void ili9341_drawstring_size(const char *str, int x, int y, uint8_t size);
@ -588,12 +589,12 @@ int16_t adc_vbat_read(void);
*/ */
int plot_printf(char *str, int, const char *fmt, ...); int plot_printf(char *str, int, const char *fmt, ...);
#define PULSE do { palClearPad(GPIOC, GPIOC_LED); palSetPad(GPIOC, GPIOC_LED);} while(0) #define PULSE do { palClearPad(GPIOC, GPIOC_LED); palSetPad(GPIOC, GPIOC_LED);} while(0)
extern int settingAttenuate; extern int setting_attenuate;
extern int settingPowerCal; extern int settingPowerCal;
extern int settingStepDelay; extern int setting_step_delay;
extern int actualStepDelay; extern int actualStepDelay;
extern int settingMode; extern int setting_mode;
void update_rbw(uint32_t delta_f); void update_rbw(void);
int GetActualRBW(void); int GetActualRBW(void);
#define byte uint8_t #define byte uint8_t
@ -619,8 +620,11 @@ int GetRBW(void);
int GetStorage(void); int GetStorage(void);
int GetSubtractStorage(void); int GetSubtractStorage(void);
int get_waterfall(void); int get_waterfall(void);
void toggle_tracking(void);
void calibrate(void); void calibrate(void);
void reset_calibration(void); void reset_calibration(void);
void SetRefpos(int);
void SetScale(int);
void SetRBW(int);
void SetRX(int);
/*EOF*/ /*EOF*/

2
plot.c
Unescape View File

@ -1900,7 +1900,7 @@ draw_frequencies(void)
{ {
char buf1[32]; char buf1[32];
char buf2[32]; buf2[0] = 0; char buf2[32]; buf2[0] = 0;
if (MODE_OUTPUT(settingMode)) // No frequencies during output if (MODE_OUTPUT(setting_mode)) // No frequencies during output
return; return;
if (current_menu_is_form() && !in_selftest) if (current_menu_is_form() && !in_selftest)
return; return;

423
sa_core.c
Unescape View File

@ -2,61 +2,105 @@
#include "SI4432.h" // comment out for simulation #include "SI4432.h" // comment out for simulation
int settingMode = M_LOW; int setting_mode = M_LOW;
int dirty = true; int dirty = true;
int scandirty = true; int scandirty = true;
int settingAttenuate = 0; int setting_attenuate = 0;
int settingRBW = 0; int setting_rbw = 0;
int settingAverage = 0; int setting_average = 0;
int settingShowStorage = 0; int setting_show_stored = 0;
int settingSubtractStorage = 0; int setting_subtract_stored = 0;
int settingDrive=0; // 0-3 , 3=+20dBm int setting_drive=0; // 0-3 , 3=+20dBm
int settingAGC = true; int setting_agc = true;
int settingLNA = false; int setting_lna = false;
int trackingVFO = false; int setting_tracking = false;
int settingModulation = MO_NONE; int setting_modulation = MO_NONE;
int settingStepDelay = 0; int setting_step_delay = 0;
int setting_frequency_step;
float actual_rbw = 0; float actual_rbw = 0;
float setting_vbw = 0; float setting_vbw = 0;
int settingSpur = 0;
int vbwSteps = 1;
//int setting_spur = 0;
uint32_t minFreq = 0; uint32_t minFreq = 0;
uint32_t maxFreq = 520000000; uint32_t maxFreq = 520000000;
int settingRefer = -1; // Off by default int setting_refer = -1; // Off by default
const int refferFreq[] = {30000000, 15000000, 10000000, 4000000, 3000000, 2000000, 1000000}; const int reffer_freq[] = {30000000, 15000000, 10000000, 4000000, 3000000, 2000000, 1000000};
int in_selftest = false; int in_selftest = false;
void set_refer_output(int v) void reset_settings(int m)
{ {
settingRefer = v; setting_mode = m;
setting_attenuate = 0;
setting_rbw = 0;
setting_average = 0;
setting_show_stored = 0;
setting_subtract_stored = 0;
setting_drive=0; // 0-3 , 3=+20dBm
setting_agc = true;
setting_lna = false;
setting_tracking = false;
setting_modulation = MO_NONE;
setting_step_delay = 0;
setting_vbw = 0;
// setting_spur = 0;
switch(m) {
case M_LOW:
minFreq = 0;
maxFreq = 520000000;
set_sweep_frequency(ST_START, (int32_t) 0);
set_sweep_frequency(ST_STOP, (int32_t) 350000000);
SetRefpos(-10);
break;
case M_GENLOW:
minFreq = 0;
maxFreq = 520000000;
set_sweep_frequency(ST_CENTER, (int32_t) 10000000);
set_sweep_frequency(ST_SPAN, 0);
break;
case M_HIGH:
minFreq = 240000000;
maxFreq = 960000000;
set_sweep_frequency(ST_START, (int32_t) minFreq);
set_sweep_frequency(ST_STOP, (int32_t) maxFreq);
SetRefpos(-30);
break;
case M_GENHIGH:
minFreq = 240000000;
maxFreq = 960000000;
set_sweep_frequency(ST_CENTER, (int32_t) 300000000);
set_sweep_frequency(ST_SPAN, 0);
break;
}
SetScale(10);
dirty = true; dirty = true;
} }
int get_refer_output(void) void set_refer_output(int v)
{ {
return(settingRefer); setting_refer = v;
dirty = true;
} }
#if 0 int get_refer_output(void)
void SetGenerate(int g)
{ {
settingGenerate = g; return(setting_refer);
dirty = true;
} }
#endif
void SetDrive(int d) void SetDrive(int d)
{ {
settingDrive = d; setting_drive = d;
dirty = true; dirty = true;
} }
void SetModulation(int m) void SetModulation(int m)
{ {
settingModulation = m; setting_modulation = m;
dirty = true; dirty = true;
} }
void SetIF(int f) void SetIF(int f)
@ -67,7 +111,7 @@ void SetIF(int f)
int GetMode(void) int GetMode(void)
{ {
return(settingMode); return(setting_mode);
dirty = true; dirty = true;
} }
@ -77,9 +121,9 @@ void SetAttenuation(int a)
a = 0; a = 0;
if (a> 31) if (a> 31)
a=31; a=31;
if (settingAttenuate == a) if (setting_attenuate == a)
return; return;
settingAttenuate = a; setting_attenuate = a;
dirty = true; dirty = true;
} }
@ -87,49 +131,50 @@ void SetStorage(void)
{ {
for (int i=0; i<POINTS_COUNT;i++) for (int i=0; i<POINTS_COUNT;i++)
stored_t[i] = actual_t[i]; stored_t[i] = actual_t[i];
settingShowStorage = true; setting_show_stored = true;
trace[TRACE_STORED].enabled = true; trace[TRACE_STORED].enabled = true;
dirty = true; dirty = true;
} }
int GetStorage(void) int GetStorage(void)
{ {
return(settingShowStorage); return(setting_show_stored);
} }
void SetClearStorage(void) void SetClearStorage(void)
{ {
settingShowStorage = false; setting_show_stored = false;
settingSubtractStorage = false; setting_subtract_stored = false;
trace[TRACE_STORED].enabled = false; trace[TRACE_STORED].enabled = false;
dirty = true; dirty = true;
} }
void SetSubtractStorage(void) void SetSubtractStorage(void)
{ {
if (!settingSubtractStorage) { if (!setting_subtract_stored) {
if (!settingShowStorage) if (!setting_show_stored)
SetStorage(); SetStorage();
settingSubtractStorage = true; setting_subtract_stored = true;
} else { } else {
settingSubtractStorage = false; setting_subtract_stored = false;
} }
dirty = true; dirty = true;
} }
int GetSubtractStorage(void) int GetSubtractStorage(void)
{ {
return(settingSubtractStorage); return(setting_subtract_stored);
} }
extern float peakLevel; extern float peakLevel;
void SetPowerLevel(int o) void SetPowerLevel(int o)
{ {
float new_offset = o - peakLevel - setting_attenuate + settingLevelOffset();
if (o != 100) { if (o != 100) {
if (settingMode == M_HIGH) if (setting_mode == M_HIGH)
config.high_level_offset = o - peakLevel - settingAttenuate + settingLevelOffset(); config.high_level_offset = new_offset;
else if (settingMode == M_LOW) else if (setting_mode == M_LOW)
config.low_level_offset = o - peakLevel - settingAttenuate + settingLevelOffset(); config.low_level_offset = new_offset;
} }
else { else {
config.low_level_offset = 100; config.low_level_offset = 100;
@ -140,12 +185,12 @@ void SetPowerLevel(int o)
int settingLevelOffset(void) int settingLevelOffset(void)
{ {
if (settingMode == M_HIGH) { if (setting_mode == M_HIGH) {
if (config.high_level_offset == 100) if (config.high_level_offset == 100)
return 0; return 0;
return(config.high_level_offset); return(config.high_level_offset);
} }
if (settingMode == M_LOW) { if (setting_mode == M_LOW) {
if (config.low_level_offset == 100) if (config.low_level_offset == 100)
return 0; return 0;
return(config.low_level_offset); return(config.low_level_offset);
@ -155,89 +200,86 @@ int settingLevelOffset(void)
int level_is_calibrated(void) int level_is_calibrated(void)
{ {
if (settingMode == M_HIGH && config.high_level_offset != 100) if (setting_mode == M_HIGH && config.high_level_offset != 100)
return 1; return 1;
if (settingMode == M_LOW && config.low_level_offset != 100) if (setting_mode == M_LOW && config.low_level_offset != 100)
return 1; return 1;
return(0); return(0);
} }
void SetRBW(int v) void SetRBW(int v)
{ {
settingRBW = v; setting_rbw = v;
update_rbw(frequencies[1] - frequencies[0]); update_rbw();
dirty = true; dirty = true;
} }
int GetRBW(void) int GetRBW(void)
{ {
return(settingRBW); return(setting_rbw);
} }
int GetActualRBW(void) int GetActualRBW(void)
{ {
return((int) actual_rbw); return((int) actual_rbw);
} }
#if 0
void SetSpur(int v) void SetSpur(int v)
{ {
settingSpur = v; // setting_spur = v;
dirty = true; dirty = true;
} }
#endif
void SetStepDelay(int d) void SetStepDelay(int d)
{ {
settingStepDelay = d; setting_step_delay = d;
dirty = true; dirty = true;
} }
int GetSpur(void)
{
return(settingSpur);
}
void SetAverage(int v) void SetAverage(int v)
{ {
settingAverage = v; setting_average = v;
trace[TRACE_TEMP].enabled = (v != 0); trace[TRACE_TEMP].enabled = (v != 0);
dirty = true; dirty = true;
} }
int GetAverage(void) int GetAverage(void)
{ {
return(settingAverage); return(setting_average);
} }
void ToggleLNA(void) void ToggleLNA(void)
{ {
settingLNA = !settingLNA; setting_lna = !setting_lna;
dirty = true; dirty = true;
} }
void ToggleVFO(void) void toggle_tracking(void)
{ {
trackingVFO = !trackingVFO; setting_tracking = !setting_tracking;
dirty = true; dirty = true;
} }
int GetExtraVFO(void) int GetExtraVFO(void)
{ {
return(trackingVFO); return(setting_tracking);
} }
int GetLNA(void) int GetLNA(void)
{ {
return(settingLNA); return(setting_lna);
} }
void ToggleAGC(void) void ToggleAGC(void)
{ {
settingAGC = !settingAGC; setting_agc = !setting_agc;
dirty = true; dirty = true;
} }
int GetAGC(void) int GetAGC(void)
{ {
return(settingAGC); return(setting_agc);
} }
void SetRefpos(int level) void SetRefpos(int level)
@ -256,50 +298,46 @@ void SetScale(int s) {
void SetMode(int m) void SetMode(int m)
{ {
if (settingMode == m) if (setting_mode == m)
return; return;
settingMode = m; reset_settings(m);
switch(m) {
case M_LOW:
minFreq = 0;
maxFreq = 520000000;
set_sweep_frequency(ST_START, (int32_t) 0);
set_sweep_frequency(ST_STOP, (int32_t) 300000000);
SetRefpos(-10);
settingSpur = 0; // Not for output mode
break;
case M_GENLOW:
minFreq = 0;
maxFreq = 520000000;
set_sweep_frequency(ST_CENTER, (int32_t) 10000000);
set_sweep_frequency(ST_SPAN, 0);
settingSpur = 0; // Not for output mode
settingRefer = -1; // No refer output in output mode
break;
case M_HIGH:
minFreq = 240000000;
maxFreq = 960000000;
set_sweep_frequency(ST_START, (int32_t) 300000000);
set_sweep_frequency(ST_STOP, (int32_t) 960000000);
SetRefpos(-30);
goto common_high;
case M_GENHIGH:
minFreq = 240000000;
maxFreq = 960000000;
set_sweep_frequency(ST_CENTER, (int32_t) 300000000);
set_sweep_frequency(ST_SPAN, 0);
settingRefer = -1; // No refer output in output mode
common_high:
trackingVFO = false; // Not possible in high mode
settingSpur = 0; // Not possible in high mode
break;
}
settingAttenuate = 0;
SetRBW(0);
SetScale(10);
dirty = true;
} }
void apply_settings(void)
{
if (setting_step_delay == 0){
if (MODE_LOW(setting_mode)) {
if (actual_rbw >300.0) actualStepDelay = 400;
else if (actual_rbw >100.0) actualStepDelay = 500;
else if (actual_rbw > 30.0) actualStepDelay = 900;
else if (actual_rbw > 10.0) actualStepDelay = 900;
else if (actual_rbw > 3.0) actualStepDelay = 1000;
else actualStepDelay = 1500;
} else {
if (actual_rbw >300.0) actualStepDelay = 900;
else if (actual_rbw >100.0) actualStepDelay = 900;
else if (actual_rbw > 30.0) actualStepDelay = 900;
else if (actual_rbw > 10.0) actualStepDelay = 1800;
else if (actual_rbw > 3.0) actualStepDelay = 6000;
else actualStepDelay = 8000;
}
} else
actualStepDelay = setting_step_delay;
PE4302_Write_Byte(setting_attenuate * 2);
if (setting_modulation == MO_NFM ) {
SI4432_Sel = 1;
SI4432_Write_Byte(0x7A, 1); // Use frequency hopping channel width for FM modulation
} else if (setting_modulation == MO_WFM ) {
SI4432_Sel = 1;
SI4432_Write_Byte(0x7A, 10); // Use frequency hopping channel width for FM modulation
} else {
SI4432_Sel = 1;
SI4432_Write_Byte(0x79, 0); // IF no FM back to channel 0
}
SetRX(setting_mode);
SI4432_SetReference(setting_refer);
update_rbw();
}
//------------------------------------------ //------------------------------------------
@ -311,11 +349,6 @@ int peakIndex;
float temppeakLevel; float temppeakLevel;
int temppeakIndex; int temppeakIndex;
#define BARSTART 24
int vbwSteps = 1;
void setupSA(void) void setupSA(void)
{ {
SI4432_Init(); SI4432_Init();
@ -346,8 +379,8 @@ void SetSwitchReceive(void) {
void SetAGCLNA(void) { void SetAGCLNA(void) {
unsigned char v = 0x40; unsigned char v = 0x40;
if (settingAGC) v |= 0x20; if (setting_agc) v |= 0x20;
if (settingLNA) v |= 0x10; if (setting_lna) v |= 0x10;
SI4432_Write_Byte(0x69, v); SI4432_Write_Byte(0x69, v);
} }
@ -363,8 +396,8 @@ case M_LOW: // Mixed into 0
SI4432_Sel = 1; SI4432_Sel = 1;
SetSwitchReceive(); SetSwitchReceive();
// SI4432_Receive(); For noise testing only // SI4432_Receive(); For noise testing only
SI4432_Transmit(settingDrive); SI4432_Transmit(setting_drive);
// SI4432_SetReference(settingRefer); // SI4432_SetReference(setting_refer);
break; break;
case M_HIGH: // Direct into 1 case M_HIGH: // Direct into 1
// SI4432_SetReference(-1); // Stop reference output // SI4432_SetReference(-1); // Stop reference output
@ -381,11 +414,11 @@ case M_HIGH: // Direct into 1
case M_GENLOW: // Mixed output from 0 case M_GENLOW: // Mixed output from 0
SI4432_Sel = 0; SI4432_Sel = 0;
SetSwitchTransmit(); SetSwitchTransmit();
SI4432_Transmit(settingDrive); SI4432_Transmit(setting_drive);
SI4432_Sel = 1; SI4432_Sel = 1;
SetSwitchReceive(); SetSwitchReceive();
SI4432_Transmit(settingDrive); SI4432_Transmit(setting_drive);
break; break;
case M_GENHIGH: // Direct output from 1 case M_GENHIGH: // Direct output from 1
@ -395,16 +428,16 @@ case M_GENHIGH: // Direct output from 1
SI4432_Sel = 1; SI4432_Sel = 1;
SetSwitchTransmit(); SetSwitchTransmit();
SI4432_Transmit(settingDrive); SI4432_Transmit(setting_drive);
break; break;
} }
} }
void update_rbw(uint32_t delta_f) void update_rbw(void)
{ {
setting_vbw = (delta_f)/1000.0; setting_vbw = (setting_frequency_step)/1000.0;
actual_rbw = settingRBW; actual_rbw = setting_rbw;
// float old_rbw = actual_rbw; // float old_rbw = actual_rbw;
if (actual_rbw == 0) if (actual_rbw == 0)
actual_rbw = 2*setting_vbw; actual_rbw = 2*setting_vbw;
@ -412,9 +445,12 @@ void update_rbw(uint32_t delta_f)
actual_rbw = 2.6; actual_rbw = 2.6;
if (actual_rbw > 600) if (actual_rbw > 600)
actual_rbw = 600; actual_rbw = 600;
SI4432_Sel = MODE_SELECT(settingMode);
SI4432_Sel = MODE_SELECT(setting_mode);
actual_rbw = SI4432_SET_RBW(actual_rbw); actual_rbw = SI4432_SET_RBW(actual_rbw);
vbwSteps = ((int)(2 * setting_vbw / actual_rbw)); vbwSteps = ((int)(2 * setting_vbw / actual_rbw));
if (vbwSteps < 1) if (vbwSteps < 1)
vbwSteps = 1; vbwSteps = 1;
dirty = true; dirty = true;
@ -461,14 +497,8 @@ int avoid_spur(int f)
int window = ((int)actual_rbw ) * 1000*2; int window = ((int)actual_rbw ) * 1000*2;
if (window < 50000) if (window < 50000)
window = 50000; window = 50000;
if (! settingMode == M_LOW) if (! setting_mode == M_LOW || frequency_IF != spur_IF || actual_rbw > 300.0)
return false ;
if (frequency_IF != spur_IF)
return false;
if (actual_rbw > 300.0)
return(false); return(false);
// if (spur_old_stepdelay != 0 && actualStepDelay != spur_old_stepdelay) // restore stepdelay
// actualStepDelay = spur_old_stepdelay;
for (unsigned int i = 0; i < (sizeof spur_table)/sizeof(int); i++) { for (unsigned int i = 0; i < (sizeof spur_table)/sizeof(int); i++) {
if (f/window == spur_table[i]/window) { if (f/window == spur_table[i]/window) {
// spur_old_stepdelay = actualStepDelay; // spur_old_stepdelay = actualStepDelay;
@ -481,11 +511,11 @@ int avoid_spur(int f)
static int modulation_counter = 0; static int modulation_counter = 0;
float perform(bool break_on_operation, int i, int32_t f, int extraV) float perform(bool break_on_operation, int i, int32_t f, int tracking)
{ {
// long local_IF = (MODE_LOW(settingMode)?frequency_IF + (int)(actual_rbw < 300.0?settingSpur * 1000 * actual_rbw :0):0); // long local_IF = (MODE_LOW(setting_mode)?frequency_IF + (int)(actual_rbw < 300.0?setting_spur * 1000 * actual_rbw :0):0);
long local_IF; long local_IF;
if (MODE_HIGH(settingMode)) if (MODE_HIGH(setting_mode))
local_IF = 0; local_IF = 0;
else if (avoid_spur(f)) else if (avoid_spur(f))
local_IF = spur_alternate_IF; local_IF = spur_alternate_IF;
@ -493,59 +523,22 @@ float perform(bool break_on_operation, int i, int32_t f, int extraV)
local_IF = frequency_IF; local_IF = frequency_IF;
if (i == 0 && dirty) { if (i == 0 && dirty) {
if (settingStepDelay == 0){ apply_settings();
if (MODE_LOW(settingMode)) { scandirty = true;
if (actual_rbw >300.0) actualStepDelay = 400; dirty = false;
else if (actual_rbw >100.0) actualStepDelay = 500;
else if (actual_rbw > 30.0) actualStepDelay = 900;
else if (actual_rbw > 10.0) actualStepDelay = 900;
else if (actual_rbw > 3.0) actualStepDelay = 1000;
else actualStepDelay = 1500;
} else {
if (actual_rbw >300.0) actualStepDelay = 900;
else if (actual_rbw >100.0) actualStepDelay = 900;
else if (actual_rbw > 30.0) actualStepDelay = 900;
else if (actual_rbw > 10.0) actualStepDelay = 1800;
else if (actual_rbw > 3.0) actualStepDelay = 6000;
else actualStepDelay = 8000;
}
} else
actualStepDelay = settingStepDelay;
// setupSA();
int p = settingAttenuate * 2;
PE4302_Write_Byte(p);
if (settingModulation == MO_NFM ) {
SI4432_Sel = 1;
SI4432_Write_Byte(0x7A, 1); // Use frequency hopping channel width for FM modulation
} else if (settingModulation == MO_WFM ) {
SI4432_Sel = 1;
SI4432_Write_Byte(0x7A, 10); // Use frequency hopping channel width for FM modulation
} else {
SI4432_Sel = 1;
SI4432_Write_Byte(0x79, 0); // IF no FM back to channel 0
}
SetRX(settingMode);
SI4432_SetReference(settingRefer);
// if (dirty) {
scandirty = true;
dirty = false;
// }
} }
if (local_IF) { if (local_IF) {
setFreq (0, local_IF); setFreq (0, local_IF);
} }
if (settingModulation == MO_AM) { if (setting_modulation == MO_AM) {
int p = settingAttenuate * 2 + modulation_counter; int p = setting_attenuate * 2 + modulation_counter;
PE4302_Write_Byte(p); PE4302_Write_Byte(p);
if (modulation_counter == 3) if (modulation_counter == 3)
modulation_counter = 0; modulation_counter = 0;
else else
modulation_counter++; modulation_counter++;
chThdSleepMicroseconds(250); chThdSleepMicroseconds(250);
} else if (settingModulation == MO_NFM || settingModulation == MO_WFM ) { } else if (setting_modulation == MO_NFM || setting_modulation == MO_WFM ) {
SI4432_Sel = 1; SI4432_Sel = 1;
SI4432_Write_Byte(0x79, modulation_counter); // Use frequency hopping channel for FM modulation SI4432_Write_Byte(0x79, modulation_counter); // Use frequency hopping channel for FM modulation
if (modulation_counter == 3) if (modulation_counter == 3)
@ -554,23 +547,22 @@ float perform(bool break_on_operation, int i, int32_t f, int extraV)
modulation_counter++; modulation_counter++;
chThdSleepMicroseconds(250); chThdSleepMicroseconds(250);
} }
volatile int subSteps = ((int)(2 * setting_vbw / actual_rbw));
float RSSI = -150.0; float RSSI = -150.0;
int t = 0; int t = 0;
do { do {
int lf = (uint32_t)(f + (int)(t * 500 * actual_rbw)); int lf = (uint32_t)(f + (int)(t * 500 * actual_rbw));
if (extraV) if (tracking)
setFreq (0, local_IF + lf - refferFreq[settingRefer]); // Offset so fundamental of reffer is visible setFreq (0, local_IF + lf - reffer_freq[setting_refer]); // Offset so fundamental of reffer is visible
setFreq (1, local_IF + lf); setFreq (1, local_IF + lf);
if (MODE_OUTPUT(settingMode)) if (MODE_OUTPUT(setting_mode))
return(0); return(0);
float subRSSI = SI4432_RSSI(lf, MODE_SELECT(settingMode))+settingLevelOffset()+settingAttenuate; float subRSSI = SI4432_RSSI(lf, MODE_SELECT(setting_mode))+settingLevelOffset()+setting_attenuate;
if (RSSI < subRSSI) if (RSSI < subRSSI)
RSSI = subRSSI; RSSI = subRSSI;
t++; t++;
if ((operation_requested && break_on_operation ) || (MODE_OUTPUT(settingMode))) // output modes do not step. if ((operation_requested && break_on_operation ) || (MODE_OUTPUT(setting_mode))) // output modes do not step.
subSteps = 0; // abort break; // abort
} while (subSteps-- > 0); } while (t < vbwSteps);
return(RSSI); return(RSSI);
} }
@ -582,28 +574,28 @@ static bool sweep(bool break_on_operation)
temppeakLevel = -150; temppeakLevel = -150;
float temp_min_level = 100; float temp_min_level = 100;
// spur_old_stepdelay = 0; // spur_old_stepdelay = 0;
again: //again:
for (int i = 0; i < sweep_points; i++) { for (int i = 0; i < sweep_points; i++) {
RSSI = perform(break_on_operation, i, frequencies[i], trackingVFO); RSSI = perform(break_on_operation, i, frequencies[i], setting_tracking);
// back to toplevel to handle ui operation // back to toplevel to handle ui operation
if (operation_requested && break_on_operation) if (operation_requested && break_on_operation)
return false; return false;
if (settingSpur == 1) { // First pass // if (setting_spur == 1) { // First pass
temp_t[i] = RSSI; // temp_t[i] = RSSI;
continue; // Skip all other processing // continue; // Skip all other processing
} // }
if (settingSpur == -1) // Second pass // if (setting_spur == -1) // Second pass
RSSI = ( RSSI < temp_t[i] ? RSSI : temp_t[i]); // Minimum of two passes // RSSI = ( RSSI < temp_t[i] ? RSSI : temp_t[i]); // Minimum of two passes
temp_t[i] = RSSI; temp_t[i] = RSSI;
if (settingSubtractStorage) { if (setting_subtract_stored) {
RSSI = RSSI - stored_t[i] ; RSSI = RSSI - stored_t[i] ;
} }
// stored_t[i] = (SI4432_Read_Byte(0x69) & 0x0f) * 3.0 - 90.0; // Display the AGC value in thestored trace // stored_t[i] = (SI4432_Read_Byte(0x69) & 0x0f) * 3.0 - 90.0; // Display the AGC value in thestored trace
if (scandirty || settingAverage == AV_OFF) if (scandirty || setting_average == AV_OFF)
actual_t[i] = RSSI; actual_t[i] = RSSI;
else { else {
switch(settingAverage) { switch(setting_average) {
case AV_MIN: if (actual_t[i] > RSSI) actual_t[i] = RSSI; break; case AV_MIN: if (actual_t[i] > RSSI) actual_t[i] = RSSI; break;
case AV_MAX: if (actual_t[i] < RSSI) actual_t[i] = RSSI; break; case AV_MAX: if (actual_t[i] < RSSI) actual_t[i] = RSSI; break;
case AV_2: actual_t[i] = (actual_t[i] + RSSI) / 2.0; break; case AV_2: actual_t[i] = (actual_t[i] + RSSI) / 2.0; break;
@ -620,11 +612,11 @@ again:
if (temp_min_level > actual_t[i]) if (temp_min_level > actual_t[i])
temp_min_level = actual_t[i]; temp_min_level = actual_t[i];
} }
if (settingSpur == 1) { // if (setting_spur == 1) {
settingSpur = -1; // setting_spur = -1;
goto again; // goto again;
} else if (settingSpur == -1) // } else if (setting_spur == -1)
settingSpur = 1; // setting_spur = 1;
if (scandirty) { if (scandirty) {
scandirty = false; scandirty = false;
@ -708,7 +700,7 @@ void PeakSearch()
peakIndex = temppeakIndex; peakIndex = temppeakIndex;
peakLevel = actual_t[peakIndex]; peakLevel = actual_t[peakIndex];
peakFreq = frequencies[peakIndex]; peakFreq = frequencies[peakIndex];
settingSpur = -settingSpur; setting_spur = -setting_spur;
int peak_marker = 0; int peak_marker = 0;
markers[peak_marker].enabled = true; markers[peak_marker].enabled = true;
markers[peak_marker].index = peakIndex; markers[peak_marker].index = peakIndex;
@ -738,7 +730,7 @@ void draw_cal_status(void)
ili9341_fill(x, y, OFFSETX, HEIGHT, 0x0000); ili9341_fill(x, y, OFFSETX, HEIGHT, 0x0000);
if (MODE_OUTPUT(settingMode)) // No cal status during output if (MODE_OUTPUT(setting_mode)) // No cal status during output
return; return;
if (current_menu_is_form() && !in_selftest) if (current_menu_is_form() && !in_selftest)
return; return;
@ -759,29 +751,29 @@ void draw_cal_status(void)
plot_printf(buf, BLEN, "%ddB/",(int)get_trace_scale(0)); plot_printf(buf, BLEN, "%ddB/",(int)get_trace_scale(0));
ili9341_drawstring(buf, x, y); ili9341_drawstring(buf, x, y);
if (settingAttenuate) { if (setting_attenuate) {
ili9341_set_foreground(BRIGHT_COLOR_GREEN); ili9341_set_foreground(BRIGHT_COLOR_GREEN);
y += YSTEP*2; y += YSTEP*2;
ili9341_drawstring("Attn:", x, y); ili9341_drawstring("Attn:", x, y);
y += YSTEP; y += YSTEP;
plot_printf(buf, BLEN, "-%ddB", settingAttenuate); plot_printf(buf, BLEN, "-%ddB", setting_attenuate);
buf[5]=0; buf[5]=0;
ili9341_drawstring(buf, x, y); ili9341_drawstring(buf, x, y);
} }
if (settingAverage>0) { if (setting_average>0) {
ili9341_set_foreground(BRIGHT_COLOR_BLUE); ili9341_set_foreground(BRIGHT_COLOR_BLUE);
y += YSTEP*2; y += YSTEP*2;
ili9341_drawstring("Aver:", x, y); ili9341_drawstring("Aver:", x, y);
y += YSTEP; y += YSTEP;
plot_printf(buf, BLEN, "%s",averageText[settingAverage]); plot_printf(buf, BLEN, "%s",averageText[setting_average]);
buf[5]=0; buf[5]=0;
ili9341_drawstring(buf, x, y); ili9341_drawstring(buf, x, y);
} }
#if 0
if (settingSpur) { if (setting_spur) {
ili9341_set_foreground(BRIGHT_COLOR_BLUE); ili9341_set_foreground(BRIGHT_COLOR_BLUE);
y += YSTEP*2; y += YSTEP*2;
ili9341_drawstring("Spur:", x, y); ili9341_drawstring("Spur:", x, y);
@ -790,8 +782,9 @@ void draw_cal_status(void)
plot_printf(buf, BLEN, "ON"); plot_printf(buf, BLEN, "ON");
ili9341_drawstring(buf, x, y); ili9341_drawstring(buf, x, y);
} }
#endif
if (settingRBW) if (setting_rbw)
color = BRIGHT_COLOR_GREEN; color = BRIGHT_COLOR_GREEN;
else else
color = DEFAULT_FG_COLOR; color = DEFAULT_FG_COLOR;
@ -821,7 +814,7 @@ void draw_cal_status(void)
ili9341_drawstring("Scan:", x, y); ili9341_drawstring("Scan:", x, y);
y += YSTEP; y += YSTEP;
int32_t t = (int)((2* vbwSteps * sweep_points * ( actualStepDelay / 100) )) /10 * (settingSpur ? 2 : 1); // in mS int32_t t = (int)((2* vbwSteps * sweep_points * ( actualStepDelay / 100) )) /10 /* * (setting_spur ? 2 : 1) */; // in mS
if (t>1000) if (t>1000)
plot_printf(buf, BLEN, "%dS",(t+500)/1000); plot_printf(buf, BLEN, "%dS",(t+500)/1000);
else else
@ -831,13 +824,13 @@ void draw_cal_status(void)
ili9341_drawstring(buf, x, y); ili9341_drawstring(buf, x, y);
if (settingRefer >= 0) { if (setting_refer >= 0) {
ili9341_set_foreground(BRIGHT_COLOR_RED); ili9341_set_foreground(BRIGHT_COLOR_RED);
y += YSTEP*2; y += YSTEP*2;
ili9341_drawstring("Ref:", x, y); ili9341_drawstring("Ref:", x, y);
y += YSTEP; y += YSTEP;
plot_printf(buf, BLEN, "%dMHz",refMHz[settingRefer]); plot_printf(buf, BLEN, "%dMHz",reffer_freq[setting_refer]/1000000);
buf[5]=0; buf[5]=0;
ili9341_drawstring(buf, x, y); ili9341_drawstring(buf, x, y);
} }
@ -911,9 +904,9 @@ static void test_acquire(int i)
pause_sweep(); pause_sweep();
#if 0 #if 0
if (test_case[i].center < 300) if (test_case[i].center < 300)
settingMode = M_LOW; setting_mode = M_LOW;
else else
settingMode = M_HIGH; setting_mode = M_HIGH;
#endif #endif
set_sweep_frequency(ST_CENTER, (int32_t)(test_case[i].center * 1000000)); set_sweep_frequency(ST_CENTER, (int32_t)(test_case[i].center * 1000000));
set_sweep_frequency(ST_SPAN, (int32_t)(test_case[i].span * 1000000)); set_sweep_frequency(ST_SPAN, (int32_t)(test_case[i].span * 1000000));
@ -1109,7 +1102,7 @@ int test_validate(int i)
void test_prepare(int i) void test_prepare(int i)
{ {
trackingVFO = false; //Default test setup setting_tracking = false; //Default test setup
switch(test_case[i].setup) { // Prepare test conditions switch(test_case[i].setup) { // Prepare test conditions
case TPH_SILENT: // No input signal case TPH_SILENT: // No input signal
SetMode(M_HIGH); SetMode(M_HIGH);
@ -1123,7 +1116,7 @@ common_silent:
break; break;
case TP_10MHZEXTRA: // Swept receiver case TP_10MHZEXTRA: // Swept receiver
SetMode(M_LOW); SetMode(M_LOW);
trackingVFO = true; //Sweep BPF setting_tracking = true; //Sweep BPF
set_refer_output(2); set_refer_output(2);
goto common; goto common;
case TP_10MHZ: // 10MHz input case TP_10MHZ: // 10MHz input

4
si4432.c
Unescape View File

@ -240,8 +240,8 @@ float SI4432_RSSI(uint32_t i, int s)
SI4432_Sel = s; SI4432_Sel = s;
chThdSleepMicroseconds(actualStepDelay); chThdSleepMicroseconds(actualStepDelay);
RSSI_RAW = (unsigned char)SI4432_Read_Byte( 0x26 ) ; RSSI_RAW = (unsigned char)SI4432_Read_Byte( 0x26 ) ;
if (settingMode < 2 && RSSI_RAW == 0) // if (MODE_INPUT(setting_mode) && RSSI_RAW == 0)
SI4432_Init(); // SI4432_Init();
float dBm = 0.5 * RSSI_RAW - 120.0 ; float dBm = 0.5 * RSSI_RAW - 120.0 ;
#ifdef __SIMULATION__ #ifdef __SIMULATION__
dBm = Simulated_SI4432_RSSI(i,s); dBm = Simulated_SI4432_RSSI(i,s);

44
ui_sa.c
Unescape View File

@ -17,12 +17,12 @@ void SetRBW(int);
void SetDrive(int d); void SetDrive(int d);
void SetIF(int f); void SetIF(int f);
void SetStepDelay(int t); void SetStepDelay(int t);
extern int settingRBW; extern int setting_rbw;
void SetSpur(int); void SetSpur(int);
int GetSpur(void); int GetSpur(void);
void SetAverage(int); void SetAverage(int);
int GetAverage(void); int GetAverage(void);
extern int settingAverage; extern int setting_average;
void SetStorage(void); void SetStorage(void);
void SetClearStorage(void); void SetClearStorage(void);
void SetSubtractStorage(void); void SetSubtractStorage(void);
@ -38,14 +38,14 @@ void ToggleAGC(void);
void redrawHisto(void); void redrawHisto(void);
void self_test(void); void self_test(void);
extern int32_t frequencyExtra; extern int32_t frequencyExtra;
extern int trackingVFO; extern int setting_tracking;
extern int settingDrive; extern int setting_drive;
extern int settingLNA; extern int setting_lna;
extern int settingAGC; extern int setting_agc;
void SetModulation(int); void SetModulation(int);
extern int settingModulation; extern int setting_modulation;
// extern int settingSpeed; // extern int settingSpeed;
extern int settingStepDelay; extern int setting_step_delay;
@ -324,6 +324,7 @@ static void menu_spur_cb(int item, uint8_t data)
{ {
(void)data; (void)data;
(void)item; (void)item;
#if 0
if (GetSpur()) if (GetSpur())
SetSpur(0); SetSpur(0);
else else
@ -331,6 +332,7 @@ static void menu_spur_cb(int item, uint8_t data)
// menu_move_back(); // menu_move_back();
ui_mode_normal(); ui_mode_normal();
draw_cal_status(); draw_cal_status();
#endif
} }
static void menu_storage_cb(int item, uint8_t data) static void menu_storage_cb(int item, uint8_t data)
@ -523,7 +525,7 @@ static void menu_settings2_cb(int item, uint8_t data)
ToggleLNA();; ToggleLNA();;
break; break;
case 2: case 2:
ToggleVFO(); toggle_tracking();
break; break;
} }
draw_cal_status(); draw_cal_status();
@ -860,7 +862,7 @@ static void menu_item_modify_attribute(
} }
} else if (menu == menu_lowoutputmode || menu == menu_highoutputmode) { } else if (menu == menu_lowoutputmode || menu == menu_highoutputmode) {
if (item == 3) { if (item == 3) {
plot_printf(uistat.text, sizeof uistat.text, menu_modulation_text[settingModulation]); plot_printf(uistat.text, sizeof uistat.text, menu_modulation_text[setting_modulation]);
} }
} else if (menu == menu_reffer) { } else if (menu == menu_reffer) {
if (item < 5 && item == get_refer_output() + 1){ if (item < 5 && item == get_refer_output() + 1){
@ -878,10 +880,12 @@ static void menu_item_modify_attribute(
*fg = config.menu_normal_color; *fg = config.menu_normal_color;
} }
} else if (menu == menu_scale) { } else if (menu == menu_scale) {
#if 0
if (item == 4 /* Spur reduction */ && GetSpur()) { if (item == 4 /* Spur reduction */ && GetSpur()) {
*bg = DEFAULT_MENU_TEXT_COLOR; *bg = DEFAULT_MENU_TEXT_COLOR;
*fg = config.menu_normal_color; *fg = config.menu_normal_color;
} }
#endif
} else if (menu == menu_average) { } else if (menu == menu_average) {
if (item == GetAverage()){ if (item == GetAverage()){
*bg = DEFAULT_MENU_TEXT_COLOR; *bg = DEFAULT_MENU_TEXT_COLOR;
@ -912,15 +916,15 @@ static void menu_item_modify_attribute(
*fg = config.menu_normal_color; *fg = config.menu_normal_color;
} }
} else if (menu == menu_settings2 || menu == menu_settingshigh2) { } else if (menu == menu_settings2 || menu == menu_settingshigh2) {
if (item ==0 && settingAGC){ if (item ==0 && setting_agc){
*bg = DEFAULT_MENU_TEXT_COLOR; *bg = DEFAULT_MENU_TEXT_COLOR;
*fg = config.menu_normal_color; *fg = config.menu_normal_color;
} }
if (item == 1 && settingLNA){ if (item == 1 && setting_lna){
*bg = DEFAULT_MENU_TEXT_COLOR; *bg = DEFAULT_MENU_TEXT_COLOR;
*fg = config.menu_normal_color; *fg = config.menu_normal_color;
} }
if (item == 2 && trackingVFO){ // should not happen in high mode if (item == 2 && setting_tracking){ // should not happen in high mode
*bg = DEFAULT_MENU_TEXT_COLOR; *bg = DEFAULT_MENU_TEXT_COLOR;
*fg = config.menu_normal_color; *fg = config.menu_normal_color;
} }
@ -948,7 +952,7 @@ static void menu_item_modify_attribute(
plot_printf(buf, sizeof buf, "%3.3fMHz", frequency0 / 1000000.0); plot_printf(buf, sizeof buf, "%3.3fMHz", frequency0 / 1000000.0);
break; break;
case 1: case 1:
plot_printf(buf, sizeof buf, "%ddB", -10 - settingAttenuate); plot_printf(buf, sizeof buf, "%ddB", -10 - setting_attenuate);
break; break;
} }
} }
@ -959,7 +963,7 @@ static void menu_item_modify_attribute(
plot_printf(buf, sizeof buf, "%3.3fMHz", frequency0 / 1000000.0); plot_printf(buf, sizeof buf, "%3.3fMHz", frequency0 / 1000000.0);
break; break;
case 1: case 1:
plot_printf(buf, sizeof buf, "%ddB", -10 - settingDrive); plot_printf(buf, sizeof buf, "%ddB", -10 - setting_drive);
break; break;
} }
} }
@ -1003,7 +1007,7 @@ static void fetch_numeric_target(void)
plot_printf(uistat.text, sizeof uistat.text, "%ddB", uistat.value / 1000); plot_printf(uistat.text, sizeof uistat.text, "%ddB", uistat.value / 1000);
break; break;
case KM_ATTENUATION: case KM_ATTENUATION:
uistat.value = settingAttenuate; uistat.value = setting_attenuate;
plot_printf(uistat.text, sizeof uistat.text, "%ddB", uistat.value); plot_printf(uistat.text, sizeof uistat.text, "%ddB", uistat.value);
break; break;
case KM_ACTUALPOWER: case KM_ACTUALPOWER:
@ -1015,20 +1019,20 @@ static void fetch_numeric_target(void)
plot_printf(uistat.text, sizeof uistat.text, "%3.3fMHz", uistat.value / 1000000.0); plot_printf(uistat.text, sizeof uistat.text, "%3.3fMHz", uistat.value / 1000000.0);
break; break;
case KM_SAMPLETIME: case KM_SAMPLETIME:
uistat.value = settingStepDelay; uistat.value = setting_step_delay;
plot_printf(uistat.text, sizeof uistat.text, "%3duS", uistat.value); plot_printf(uistat.text, sizeof uistat.text, "%3duS", uistat.value);
break; break;
case KM_DRIVE: case KM_DRIVE:
uistat.value = settingDrive; uistat.value = setting_drive;
plot_printf(uistat.text, sizeof uistat.text, "%3ddB", uistat.value); plot_printf(uistat.text, sizeof uistat.text, "%3ddB", uistat.value);
break; break;
case KM_LOWOUTLEVEL: case KM_LOWOUTLEVEL:
uistat.value = settingAttenuate; uistat.value = setting_attenuate;
uistat.value = -5 - uistat.value; // compensation for dB offset during low output mode uistat.value = -5 - uistat.value; // compensation for dB offset during low output mode
plot_printf(uistat.text, sizeof uistat.text, "%ddB", uistat.value); plot_printf(uistat.text, sizeof uistat.text, "%ddB", uistat.value);
break; break;
case KM_HIGHOUTLEVEL: case KM_HIGHOUTLEVEL:
uistat.value = settingDrive*5 + 5; uistat.value = setting_drive*5 + 5;
plot_printf(uistat.text, sizeof uistat.text, "%3ddB", uistat.value); plot_printf(uistat.text, sizeof uistat.text, "%3ddB", uistat.value);
break; break;
} }

Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.