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

Code style

Browse Source 
Code cleanup
Implement custom jog step feature
multi_trace
DiSlord 5 years ago committed by erikkaashoek
parent da28f02423
commit d27ad33dc2
5 changed files with 112 additions and 470 deletions
Show Stats Download Patch File Download Diff File

10
main.c
Unescape View File

@ -28,13 +28,10 @@
#include <string.h>
#include <math.h>
extern freq_t minFreq;
extern freq_t maxFreq;
freq_t frequencyStart;
freq_t frequencyStop;
int32_t frequencyExtra;
#define START_MIN minFreq
#define STOP_MAX maxFreq
/*
* Shell settings
*/
@ -936,10 +933,7 @@ static const marker_t def_markers[MARKERS_MAX] = {
void load_LCD_properties(void)
{
//Magic add on caldata_save
//current_props.magic = CONFIG_MAGIC;
// current_props._setting.frequency0 = 0; // start = 0Hz
// current_props._setting.frequency1 = 350000000; // end = 350MHz
// current_props._setting.frequency_IF= 433800000,
//setting.magic = CONFIG_MAGIC;
setting._sweep_points = POINTS_COUNT;
setting.trace_scale = 10.0;
setting.trace_refpos = 0;

87
nanovna.h
Unescape View File

@ -148,27 +148,30 @@
typedef uint32_t freq_t;
typedef int32_t long_t;
extern bool has_esd;
#define CORRECTION_POINTS 10 // Frequency dependent level correction table entries
#define CORRECTION_LOW 0
#define CORRECTION_HIGH 1
#define CORRECTION_SIZE 2
#define CORRECTION_POINTS 10 // Frequency dependent level correction table entries
#define CORRECTION_LOW 0
#define CORRECTION_HIGH 1
#define CORRECTION_SIZE 2
#endif
#ifdef TINYSA4
typedef uint64_t freq_t;
typedef int64_t long_t;
#define CORRECTION_POINTS 20 // Frequency dependent level correction table entries
#define CORRECTION_LOW 0
#define CORRECTION_LNA 1
#define CORRECTION_LOW_OUT 2
#define CORRECTION_HIGH 3
#define CORRECTION_SIZE 4
#endif
#define CORRECTION_POINTS 20 // Frequency dependent level correction table entries
#define CORRECTION_LOW 0
#define CORRECTION_LNA 1
#define CORRECTION_LOW_OUT 2
#define CORRECTION_HIGH 3
#define CORRECTION_SIZE 4
#endif
typedef float measurement_t[TRACES_MAX][POINTS_COUNT];
extern measurement_t measured;
#endif
extern freq_t minFreq;
extern freq_t maxFreq;
#define START_MIN minFreq
#define STOP_MAX maxFreq
extern const char TINYSA_VERSION[];
#ifdef __REMOTE_DESKTOP__
@ -178,63 +181,6 @@ extern int16_t mouse_y;
extern uint8_t mouse_down;
#endif
#ifdef __VNA__
// Minimum frequency set
#define START_MIN 50000
// Maximum frequency set
#define STOP_MAX 2700000000U
// Frequency offset (sin_cos table in dsp.c generated for this offset, if change need create new table)
#define FREQUENCY_OFFSET 5000
// Speed of light const
#define SPEED_OF_LIGHT 299792458
// pi const
#define VNA_PI 3.14159265358979323846
#define POINTS_COUNT 101
extern float measured[2][POINTS_COUNT][2];
#define CAL_LOAD 0
#define CAL_OPEN 1
#define CAL_SHORT 2
#define CAL_THRU 3
#define CAL_ISOLN 4
#define CALSTAT_LOAD (1<<0)
#define CALSTAT_OPEN (1<<1)
#define CALSTAT_SHORT (1<<2)
#define CALSTAT_THRU (1<<3)
#define CALSTAT_ISOLN (1<<4)
#define CALSTAT_ES (1<<5)
#define CALSTAT_ER (1<<6)
#define CALSTAT_ET (1<<7)
#define CALSTAT_ED CALSTAT_LOAD
#define CALSTAT_EX CALSTAT_ISOLN
#define CALSTAT_APPLY (1<<8)
#define CALSTAT_INTERPOLATED (1<<9)
#define ETERM_ED 0 /* error term directivity */
#define ETERM_ES 1 /* error term source match */
#define ETERM_ER 2 /* error term refrection tracking */
#define ETERM_ET 3 /* error term transmission tracking */
#define ETERM_EX 4 /* error term isolation */
#define DOMAIN_MODE (1<<0)
#define DOMAIN_FREQ (0<<0)
#define DOMAIN_TIME (1<<0)
#define TD_FUNC (0b11<<1)
#define TD_FUNC_BANDPASS (0b00<<1)
#define TD_FUNC_LOWPASS_IMPULSE (0b01<<1)
#define TD_FUNC_LOWPASS_STEP (0b10<<1)
#define TD_WINDOW (0b11<<3)
#define TD_WINDOW_NORMAL (0b00<<3)
#define TD_WINDOW_MINIMUM (0b01<<3)
#define TD_WINDOW_MAXIMUM (0b10<<3)
#define FFT_SIZE 256
void cal_collect(int type);
void cal_done(void);
#endif
#define MAX_FREQ_TYPE 5
enum stimulus_type {
ST_START=0, ST_STOP, ST_CENTER, ST_SPAN, ST_CW, ST_DUMMY // Last is used in marker ops
@ -1053,6 +999,7 @@ typedef struct setting
freq_t frequency_step;
freq_t frequency0;
freq_t frequency1;
freq_t frequency_var;
freq_t frequency_IF;
freq_t frequency_offset;
#define FREQUENCY_SHIFT 100000000 // 100MHz upconversion maximum

1
sa_core.c
Unescape View File

@ -203,6 +203,7 @@ void reset_settings(int m)
drive_dBm = (float *) (setting.mode == M_GENHIGH && config.high_out_adf4350 ? adf_drive_dBm : si_drive_dBm);
#endif
update_min_max_freq();
setting.frequency_var = 0;
sweep_mode |= SWEEP_ENABLE;
setting.unit_scale_index = 0;
setting.unit_scale = 1;

382
ui.c
Unescape View File

@ -21,7 +21,6 @@
#include "hal.h"
#include "chprintf.h"
#include "nanovna.h"
//#include <stdlib.h>
#include <string.h>
#include <math.h>
@ -90,12 +89,6 @@ enum {
UI_NORMAL, UI_MENU, UI_KEYPAD
};
#ifdef __VNA__
enum {
KM_START, KM_STOP, KM_CENTER, KM_SPAN, KM_CW, KM_SCALE, KM_REFPOS, KM_EDELAY, KM_VELOCITY_FACTOR, KM_SCALEDELAY
};
#endif
#define NUMINPUT_LEN 12
static uint8_t ui_mode = UI_NORMAL;
static uint8_t keypad_mode;
@ -729,6 +722,7 @@ static UI_FUNCTION_CALLBACK(menu_marker_op_cb)
static UI_FUNCTION_CALLBACK(menu_markers_reset_cb)
{
(void)item;
(void)data;
markers_reset();
}
@ -953,114 +947,6 @@ menu_invoke(int item)
draw_menu();
}
#ifdef __VNA__
// Key names
#define KP_0 0
#define KP_1 1
#define KP_2 2
#define KP_3 3
#define KP_4 4
#define KP_5 5
#define KP_6 6
#define KP_7 7
#define KP_8 8
#define KP_9 9
#define KP_PERIOD 10
#define KP_MINUS 11
#define KP_X1 12
#define KP_K 13
#define KP_M 14
#define KP_G 15
#define KP_BS 16
#define KP_INF 17
#define KP_DB 18
#define KP_PLUSMINUS 19
#define KP_KEYPAD 20
#define KP_N 21
#define KP_P 22
typedef struct {
uint8_t x:4;
uint8_t y:4;
int8_t c;
} keypads_t;
static const keypads_t *keypads;
static const keypads_t keypads_freq[] = {
{ 1, 3, KP_PERIOD },
{ 0, 3, KP_0 },
{ 0, 2, KP_1 },
{ 1, 2, KP_2 },
{ 2, 2, KP_3 },
{ 0, 1, KP_4 },
{ 1, 1, KP_5 },
{ 2, 1, KP_6 },
{ 0, 0, KP_7 },
{ 1, 0, KP_8 },
{ 2, 0, KP_9 },
{ 3, 0, KP_G },
{ 3, 1, KP_M },
{ 3, 2, KP_K },
{ 3, 3, KP_X1 },
{ 2, 3, KP_BS },
{ 0, 0, -1 }
};
static const keypads_t keypads_scale[] = {
{ 1, 3, KP_PERIOD },
{ 0, 3, KP_0 },
{ 0, 2, KP_1 },
{ 1, 2, KP_2 },
{ 2, 2, KP_3 },
{ 0, 1, KP_4 },
{ 1, 1, KP_5 },
{ 2, 1, KP_6 },
{ 0, 0, KP_7 },
{ 1, 0, KP_8 },
{ 2, 0, KP_9 },
{ 3, 3, KP_X1 },
{ 2, 3, KP_BS },
{ 0, 0, -1 }
};
static const keypads_t keypads_time[] = {
{ 1, 3, KP_PERIOD },
{ 0, 3, KP_0 },
{ 0, 2, KP_1 },
{ 1, 2, KP_2 },
{ 2, 2, KP_3 },
{ 0, 1, KP_4 },
{ 1, 1, KP_5 },
{ 2, 1, KP_6 },
{ 0, 0, KP_7 },
{ 1, 0, KP_8 },
{ 2, 0, KP_9 },
{ 3, 1, KP_N },
{ 3, 2, KP_P },
{ 3, 3, KP_MINUS },
{ 2, 3, KP_BS },
{ 0, 0, -1 }
};
static const keypads_t * const keypads_mode_tbl[] = {
keypads_freq, // start
keypads_freq, // stop
keypads_freq, // center
keypads_freq, // span
keypads_freq, // cw freq
keypads_scale, // scale
keypads_scale, // refpos
keypads_time, // electrical delay
keypads_scale, // velocity factor
keypads_time // scale of delay
};
static const char * const keypad_mode_label[] = {
"START", "STOP", "CENTER", "SPAN", "CW FREQ", "SCALE", "REFPOS", "EDELAY", "VELOCITY%", "DELAY"
};
#endif
static const char * const keypad_scale_text[] = {"0", "1", "2", "5", "10", "20" , "50", "100", "200", "500"};
//static const int keypad_scale_value[] = { 1, 2, 5, 10, 20 , 50, 100, 200, 500};
@ -1187,83 +1073,6 @@ draw_numeric_area_frame(void)
draw_numeric_input("");
}
#ifdef __VNA__
static void
menu_item_modify_attribute(const menuitem_t *menu, int item,
uint16_t *fg, uint16_t *bg)
{
if (menu == menu_trace && item < TRACES_MAX) {
if (trace[item].enabled)
*bg = config.trace_color[item];
} else if (menu == menu_marker_sel) {
if (item < 4) {
if (markers[item].enabled) {
*bg = LCD_MENU_TEXT_COLOR;
*fg = config.menu_normal_color;
}
} else if (item == 5) {
if (uistat.marker_delta) {
*bg = LCD_MENU_TEXT_COLOR;
*fg = config.menu_normal_color;
}
}
} else if (menu == menu_marker_search) {
if (item == 4 && uistat.marker_tracking) {
*bg = LCD_MENU_TEXT_COLOR;
*fg = config.menu_normal_color;
}
} else if (menu == menu_marker_smith) {
if (marker_smith_format == item) {
*bg = LCD_MENU_TEXT_COLOR;
*fg = config.menu_normal_color;
}
} else if (menu == menu_calop) {
if ((item == 0 && (cal_status & CALSTAT_OPEN))
|| (item == 1 && (cal_status & CALSTAT_SHORT))
|| (item == 2 && (cal_status & CALSTAT_LOAD))
|| (item == 3 && (cal_status & CALSTAT_ISOLN))
|| (item == 4 && (cal_status & CALSTAT_THRU))) {
domain_mode = (domain_mode & ~DOMAIN_MODE) | DOMAIN_FREQ;
*bg = LCD_MENU_TEXT_COLOR;
*fg = config.menu_normal_color;
}
} else if (menu == menu_stimulus) {
if (item == 5 /* PAUSE */ && !(sweep_mode&SWEEP_ENABLE)) {
*bg = LCD_MENU_TEXT_COLOR;
*fg = config.menu_normal_color;
}
} else if (menu == menu_cal) {
if (item == 3 /* CORRECTION */ && (cal_status & CALSTAT_APPLY)) {
*bg = LCD_MENU_TEXT_COLOR;
*fg = config.menu_normal_color;
}
} else if (menu == menu_bandwidth) {
if (item == bandwidth) {
*bg = 0x0000;
*fg = 0xffff;
}
} else if (menu == menu_transform) {
if ((item == 0 && (domain_mode & DOMAIN_MODE) == DOMAIN_TIME)
|| (item == 1 && (domain_mode & TD_FUNC) == TD_FUNC_LOWPASS_IMPULSE)
|| (item == 2 && (domain_mode & TD_FUNC) == TD_FUNC_LOWPASS_STEP)
|| (item == 3 && (domain_mode & TD_FUNC) == TD_FUNC_BANDPASS)
) {
*bg = LCD_MENU_TEXT_COLOR;
*fg = config.menu_normal_color;
}
} else if (menu == menu_transform_window) {
if ((item == 0 && (domain_mode & TD_WINDOW) == TD_WINDOW_MINIMUM)
|| (item == 1 && (domain_mode & TD_WINDOW) == TD_WINDOW_NORMAL)
|| (item == 2 && (domain_mode & TD_WINDOW) == TD_WINDOW_MAXIMUM)
) {
*bg = LCD_MENU_TEXT_COLOR;
*fg = config.menu_normal_color;
}
}
}
#endif
#ifndef __VNA__
extern void menu_item_modify_attribute(
const menuitem_t *menu, int item, ui_button_t *button);
@ -1418,9 +1227,8 @@ draw_menu_buttons(const menuitem_t *menu, int only)
else
text = menu[i].label;
// Only keypad retrieves value
if (menu[i].type & MT_FORM && MT_MASK(menu[i].type) == MT_KEYPAD) {
keypad_mode = menu[i].data;
fetch_numeric_target();
if (MT_MASK(menu[i].type) == MT_KEYPAD) {
fetch_numeric_target(menu[i].data);
plot_printf(button.text, sizeof button.text, menu[i].label, uistat.text);
text = button.text;
}
@ -1556,8 +1364,7 @@ menu_select_touch(int i, int pos)
if (dt > BUTTON_DOWN_LONG_TICKS) {
touch_position(&touch_x, &touch_y);
if (touch_x != prev_touch_x /* - 1 || prev_touch_x + 1 < touch_x */ ) {
keypad_mode = keypad;
fetch_numeric_target();
fetch_numeric_target(keypad);
int new_slider = touch_x - LCD_WIDTH/2; // Can have negative outcome
if (new_slider < - (MENU_FORM_WIDTH-8)/2 - 1)
new_slider = -(MENU_FORM_WIDTH-8)/2 - 1;
@ -1818,89 +1625,6 @@ leave_ui_mode()
redraw_request|=REDRAW_AREA | REDRAW_FREQUENCY | REDRAW_CAL_STATUS | REDRAW_BATTERY;
}
#ifdef __VNA__
static void
fetch_numeric_target(void)
{
switch (keypad_mode) {
case KM_START:
uistat.value = get_sweep_frequency(ST_START);
break;
case KM_STOP:
uistat.value = get_sweep_frequency(ST_STOP);
break;
case KM_CENTER:
uistat.value = get_sweep_frequency(ST_CENTER);
break;
case KM_SPAN:
uistat.value = get_sweep_frequency(ST_SPAN);
break;
case KM_CW:
uistat.value = get_sweep_frequency(ST_CW);
break;
case KM_SCALE:
uistat.value = get_trace_scale(uistat.current_trace) * 1000;
break;
case KM_REFPOS:
uistat.value = get_trace_refpos(uistat.current_trace) * 1000;
break;
case KM_EDELAY:
uistat.value = get_electrical_delay();
break;
case KM_VELOCITY_FACTOR:
uistat.value = velocity_factor * 100;
break;
case KM_SCALEDELAY:
uistat.value = get_trace_scale(uistat.current_trace) * 1e12;
break;
}
{
uint32_t x = uistat.value;
int n = 0;
for (; x >= 10 && n < 9; n++)
x /= 10;
uistat.digit = n;
}
// uistat.previous_value = uistat.value;
}
static void
set_numeric_value(void)
{
switch (keypad_mode) {
case KM_START:
set_sweep_frequency(ST_START, uistat.value);
break;
case KM_STOP:
set_sweep_frequency(ST_STOP, uistat.value);
break;
case KM_CENTER:
set_sweep_frequency(ST_CENTER, uistat.value);
break;
case KM_SPAN:
set_sweep_frequency(ST_SPAN, uistat.value);
break;
case KM_CW:
set_sweep_frequency(ST_CW, uistat.value);
break;
case KM_SCALE:
set_trace_scale(uistat.current_trace, uistat.value / 1000.0);
break;
case KM_REFPOS:
set_trace_refpos(uistat.current_trace, uistat.value / 1000.0);
break;
case KM_EDELAY:
set_electrical_delay(uistat.value);
break;
case KM_VELOCITY_FACTOR:
velocity_factor = uistat.value/100.0;
break;
}
}
#endif
void
ui_mode_menu(void)
{
@ -2014,25 +1738,6 @@ step_round(freq_t v)
return x * 5;
}
static void
lever_zoom_span(int status)
{
freq_t span = get_sweep_frequency(ST_SPAN);
if (uistat.auto_center_marker) {
freq_t freq = get_marker_frequency(active_marker);
search_maximum(active_marker, freq, 10 );
if (freq != 0)
set_sweep_frequency(ST_CENTER, freq);
}
if (status & EVT_UP) {
span = step_round(span - 1);
} else if (status & EVT_DOWN) {
span = step_round(span + 1);
span = step_round(span * 3);
}
set_sweep_frequency(ST_SPAN, span);
}
static void
lever_zoom_time(int status)
{
@ -2051,35 +1756,30 @@ lever_zoom_time(int status)
static void
lever_move(int status, int mode)
{
freq_t center = get_sweep_frequency(mode);
freq_t span = get_sweep_frequency(ST_SPAN);
span = step_round(span / 3);
if (status & EVT_UP) {
set_sweep_frequency(mode, center + span);
} else if (status & EVT_DOWN) {
set_sweep_frequency(mode, center - span);
freq_t freq = get_sweep_frequency(mode);
if (mode == ST_SPAN){
if (uistat.auto_center_marker) {
freq = get_marker_frequency(active_marker);
search_maximum(active_marker, freq, 10 );
if (freq == 0) return;
set_sweep_frequency(ST_CENTER, freq);
return;
}
if (status & EVT_UP ) freq = setting.frequency_var ? (freq + setting.frequency_var) : step_round(freq*4 + 1);
if (status & EVT_DOWN) freq = setting.frequency_var ? (freq - setting.frequency_var) : step_round(freq - 1);
}
else {
freq_t span = setting.frequency_var ? setting.frequency_var : step_round(get_sweep_frequency(ST_SPAN) / 4);
if (status & EVT_UP ) freq+= span;
if (status & EVT_DOWN) freq-= span;
}
if (freq > STOP_MAX || freq < START_MIN) return;
set_sweep_frequency(mode, freq);
}
#define STEPRATIO 0.2
#ifdef __VNA__
static void
lever_edelay(int status)
{
float value = get_electrical_delay();
float ratio = STEPRATIO;
if (value < 0)
ratio = -ratio;
if (status & EVT_UP) {
value = (1 - ratio) * value;
} else if (status & EVT_DOWN) {
value = (1 + ratio) * value;
}
set_electrical_delay(value);
}
#endif
static void
ui_process_normal(void)
ui_process_normal_lever(void)
{
int status = btn_check();
if (status != 0) {
@ -2089,24 +1789,13 @@ ui_process_normal(void)
switch (uistat.lever_mode) {
case LM_MARKER: lever_move_marker(status); break;
case LM_SEARCH: lever_search_marker(status); break;
case LM_CENTER:
lever_move(status, FREQ_IS_STARTSTOP() ? ST_START : ST_CENTER);
break;
case LM_CENTER: lever_move(status, FREQ_IS_STARTSTOP() ? ST_START : ST_CENTER); break;
case LM_SPAN:
if (FREQ_IS_STARTSTOP())
lever_move(status, ST_STOP);
else {
if (FREQ_IS_CW())
lever_zoom_time(status);
else
lever_zoom_span(status);
}
break;
#ifdef __VNA__
case LM_EDELAY:
lever_edelay(status);
if (FREQ_IS_CW())
lever_zoom_time(status);
else
lever_move(status, FREQ_IS_STARTSTOP() ? ST_STOP : ST_SPAN);
break;
#endif
}
}
}
@ -2129,7 +1818,7 @@ ui_process_listen_lever(void)
#endif
static void
ui_process_menu(void)
ui_process_menu_lever(void)
{
// Flag show, can close menu if user come out from it
// if false user must select some thing
@ -2164,8 +1853,7 @@ ui_process_menu(void)
ensure_selection();
draw_menu();
chThdSleepMilliseconds(50); // Add delay for not move so fast in menu
status = btn_wait_release();
} while (status != 0);
} while ((status = btn_wait_release()) != 0);
}
}
return;
@ -2318,14 +2006,14 @@ ui_process_lever(void)
{
switch (ui_mode) {
case UI_NORMAL:
ui_process_normal();
ui_process_normal_lever();
break;
case UI_MENU:
ui_process_menu();
break;
case UI_KEYPAD:
ui_process_keypad();
ui_process_menu_lever();
break;
// case UI_KEYPAD:
// ui_process_keypad();
// break;
}
}

102
ui_sa.c
Unescape View File

@ -430,6 +430,7 @@ enum {
#endif
KM_MARKER_TIME,
// #35
KM_VAR,
KM_NONE // always at enum end
};
@ -437,56 +438,60 @@ static const struct {
const keypads_t *keypad_type;
char * name;
} keypads_mode_tbl[KM_NONE] = {
{keypads_freq , "START"}, // start
{keypads_freq , "STOP"}, // stop
{keypads_freq , "CENTER"}, // center
{keypads_freq , "SPAN"}, // span
{keypads_freq , "FREQ"}, // cw freq
{keypads_plusmin_unit, "REF\nLEVEL"}, // reflevel #5
{keypads_pos_unit , "SCALE"}, // scale
{keypads_positive , "ATTENUATE"}, // attenuation
{keypads_plusmin_unit, "ACTUAL\nPOWER"}, // actual power
{keypads_freq , "IF"}, // IF
{keypads_positive , "SAMPLE\nDELAY"}, // sample delay #10
{keypads_plusmin , "OUTPUT\nLEVEL"}, // KM_LOWOUTLEVEL
{keypads_positive , "DECAY"}, // KM_DECAY
{keypads_positive , "NOISE\nLEVEL"}, // KM_NOISE
{keypads_freq , "FREQ"}, // KM_30MHz | KM_10MHz
{keypads_positive , "SAMPLE\nREPEAT"}, // KM_REPEA #15
{keypads_plusmin , "EXT\nGAIN"}, // KM_EXT_GAIN
{keypads_plusmin_unit, "TRIGGER\nLEVEL"}, // KM_TRIGGER
{keypads_plusmin , "LEVEL\nSWEEP"}, // KM_LEVELSWEEP
{keypads_time , "SWEEP\nSECONDS"}, // KM_SWEEP_TIME
{keypads_positive , "OFFSET\nDELAY"}, // KM_OFFSET_DELAY #20
{keypads_positive , "FAST\nSPEEDUP"}, // KM_FAST_SPEEDUP
{keypads_positive , "MINIMUM\nGRIDLINES"}, // KM_GRIDLINES
{keypads_freq , "MARKER\nFREQ"}, // KM_MARKER
{keypads_freq , "MODULATION\nFREQ"}, // KM_MODULATION
{keypads_plusmin , "OUTPUT\nLEVEL"}, // KM_HIGHOUTLEVEL #25
[KM_START] = {keypads_freq , "START"}, // start
[KM_STOP] = {keypads_freq , "STOP"}, // stop
[KM_CENTER] = {keypads_freq , "CENTER"}, // center
[KM_SPAN] = {keypads_freq , "SPAN"}, // span
[KM_CW] = {keypads_freq , "FREQ"}, // cw freq
[KM_REFLEVEL] = {keypads_plusmin_unit, "REF\nLEVEL"}, // reflevel #5
[KM_SCALE] = {keypads_pos_unit , "SCALE"}, // scale
[KM_ATTENUATION] = {keypads_positive , "ATTENUATE"}, // attenuation
[KM_ACTUALPOWER] = {keypads_plusmin_unit, "ACTUAL\nPOWER"}, // actual power
[KM_IF] = {keypads_freq , "IF"}, // IF
[KM_SAMPLETIME] = {keypads_positive , "SAMPLE\nDELAY"}, // sample delay #10
[KM_LOWOUTLEVEL] = {keypads_plusmin , "OUTPUT\nLEVEL"}, // KM_LOWOUTLEVEL
[KM_DECAY] = {keypads_positive , "DECAY"}, // KM_DECAY
[KM_NOISE] = {keypads_positive , "NOISE\nLEVEL"}, // KM_NOISE
#ifdef TINYSA4
{keypads_plusmin , "COR\nAM"}, // KM_COR_AM
{keypads_plusmin , "COR\nWFM"}, // KM_COR_WFM
{keypads_plusmin , "COR\nNFM"}, // KM_COR_NFM
{keypads_freq , "IF2"}, // KM_IF2
{keypads_positive , "R"}, // KM_R #30
{keypads_positive , "MODULO"}, // KM_MOD
{keypads_positive , "CP"}, // KM_CP
#endif
{keypads_positive , "ATTACK"}, // KM_ATTACK
[KM_30MHZ] = {keypads_freq , "FREQ"}, // KM_30MHz
#else
[KM_10MHZ] = {keypads_freq , "FREQ"}, // KM_10MHz
#endif
[KM_REPEAT] = {keypads_positive , "SAMPLE\nREPEAT"}, // KM_REPEA #15
[KM_EXT_GAIN] = {keypads_plusmin , "EXT\nGAIN"}, // KM_EXT_GAIN
[KM_TRIGGER] = {keypads_plusmin_unit, "TRIGGER\nLEVEL"}, // KM_TRIGGER
[KM_LEVELSWEEP] = {keypads_plusmin , "LEVEL\nSWEEP"}, // KM_LEVELSWEEP
[KM_SWEEP_TIME] = {keypads_time , "SWEEP\nSECONDS"}, // KM_SWEEP_TIME
[KM_OFFSET_DELAY] = {keypads_positive , "OFFSET\nDELAY"}, // KM_OFFSET_DELAY #20
[KM_FAST_SPEEDUP] = {keypads_positive , "FAST\nSPEEDUP"}, // KM_FAST_SPEEDUP
[KM_GRIDLINES] = {keypads_positive , "MINIMUM\nGRIDLINES"}, // KM_GRIDLINES
[KM_MARKER] = {keypads_freq , "MARKER\nFREQ"}, // KM_MARKER
[KM_MODULATION] = {keypads_freq , "MODULATION\nFREQ"}, // KM_MODULATION
[KM_HIGHOUTLEVEL] = {keypads_plusmin , "OUTPUT\nLEVEL"}, // KM_HIGHOUTLEVEL #25
#ifdef TINYSA4
[KM_COR_AM] = {keypads_plusmin , "COR\nAM"}, // KM_COR_AM
[KM_COR_WFM] = {keypads_plusmin , "COR\nWFM"}, // KM_COR_WFM
[KM_COR_NFM] = {keypads_plusmin , "COR\nNFM"}, // KM_COR_NFM
[KM_IF2] = {keypads_freq , "IF2"}, // KM_IF2
[KM_R] = {keypads_positive , "R"}, // KM_R #30
[KM_MOD] = {keypads_positive , "MODULO"}, // KM_MOD
[KM_CP] = {keypads_positive , "CP"}, // KM_CP
#endif
[KM_ATTACK] = {keypads_positive , "ATTACK"}, // KM_ATTACK
#ifdef TINYSA4
{keypads_freq , "ULTRA\nSTART"}, // KM_LPF
[KM_LPF] = {keypads_freq , "ULTRA\nSTART"}, // KM_LPF
#endif
{keypads_plusmin , "LEVEL"}, // KM_LEVEL
[KM_LEVEL] = {keypads_plusmin , "LEVEL"}, // KM_LEVEL
#ifdef __LIMITS__
{keypads_freq , "END\nFREQ"}, // KM_LIMIT_FREQ
{keypads_plusmin_unit , "LEVEL"}, // KM_LIMIT_LEVEL
[KM_LIMIT_FREQ] = {keypads_freq , "END\nFREQ"}, // KM_LIMIT_FREQ
[KM_LIMIT_LEVEL] = {keypads_plusmin_unit , "LEVEL"}, // KM_LIMIT_LEVEL
#endif
{keypads_time , "MARKER\nTIME"}, // KM_MARKER_TIME
[KM_MARKER_TIME] = {keypads_time , "MARKER\nTIME"}, // KM_MARKER_TIME
[KM_VAR] = {keypads_freq , "JOG\nSTEP"}, // jog step
};
#if 0 // Not used
#if 0 // Not used
enum { SL_GENLOW_FREQ, SL_GENHIGH_FREQ, SL_GENLOW_LEVEL, SL_GENHIGH_LEVEL };
ui_slider_t ui_sliders [] =
{
{ KM_CENTER, true, 0, 1000000, 0, 350000000, M_GENLOW},
@ -2752,6 +2757,7 @@ static const menuitem_t menu_stimulus[] = {
{ MT_KEYPAD, KM_CENTER, "CENTER", NULL},
{ MT_KEYPAD, KM_SPAN, "SPAN", NULL},
{ MT_KEYPAD, KM_CW, "ZERO SPAN", NULL},
{ MT_KEYPAD, KM_VAR, "JOG STEP\n%s","0 - AUTO"},
{ MT_SUBMENU,0, "RBW", menu_rbw},
{ MT_ADV_CALLBACK,0, "SHIFT\nFREQ", menu_shift_acb},
{ MT_CANCEL, 0, S_LARROW" BACK", NULL },
@ -2827,9 +2833,9 @@ static void menu_item_modify_attribute(
}
}
static void fetch_numeric_target(void)
static void fetch_numeric_target(uint8_t mode)
{
switch (keypad_mode) {
switch (mode) {
case KM_START:
uistat.freq_value = get_sweep_frequency(ST_START) + (setting.frequency_offset - FREQUENCY_SHIFT);
plot_printf(uistat.text, sizeof uistat.text, "%3.3fMHz", uistat.freq_value / 1000000.0);
@ -2984,6 +2990,10 @@ static void fetch_numeric_target(void)
plot_printf(uistat.text, sizeof uistat.text, "%7.0fHz", uistat.value);
}
break;
case KM_VAR:
uistat.freq_value = setting.frequency_var;
plot_printf(uistat.text, sizeof uistat.text, setting.frequency_var ? "%QHz" : " AUTO", setting.frequency_var);
break;
}
{
@ -2993,7 +3003,6 @@ static void fetch_numeric_target(void)
x /= 10;
uistat.digit = n;
}
// uistat.previous_value = uistat.value;
}
static void
@ -3156,6 +3165,9 @@ set_numeric_value(void)
dirty = true;
break;
#endif
case KM_VAR:
setting.frequency_var = uistat.freq_value;
break;
}
}

Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.