ttrftech/NanoVNA
1
0
Fork 0
mirror of https://github.com/ttrftech/NanoVNA.git synced 2025-12-06 03:31:59 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Continue size optimization (save 700-900 bytes)

Browse source 
Set menuitem_t size align as WORD (more compact on flash)
Add data to menuitem_t (more easy use callback functions, and save its sizing)
Rewrite some ui callback functions for use data field

More better look infinity and delta symbols
Fix grid sizing in update_grid (broken after frequency0 and frequency1 set as uint)
This commit is contained in:
ВшЫдщкв 2020-01-25 15:46:09 +03:00
parent 992e51cf8b
commit 4a0ba6741e
3 changed files with 259 additions and 347 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

31
Font5x7.c
View file

@ -103,20 +103,20 @@ const uint8_t x5x7_bits[127*7] =
width=7 width=7
+--------+ +--------+
| | | |
| |
| * |
| ** | | ** |
| ** | | ** |
| * * | | * * |
|******* | | * * |
|* * |
|****** |
+--------+ */ +--------+ */
0b00000000|CHAR5x7_WIDTH_7px, 0b00000000|CHAR5x7_WIDTH_7px,
0b00000000, 0b00110000,
0b00010000, 0b00110000,
0b00101000, 0b01001000,
0b01000100, 0b01001000,
0b10000010, 0b10000100,
0b11111110, 0b11111100,
/* Character (0x05): /* Character (0x05):
width=5 width=5
@ -502,20 +502,21 @@ const uint8_t x5x7_bits[127*7] =
width=7 width=7
+--------+ +--------+
| | | |
| ** * | | ** ** |
|* ** * | |* ** * |
|* * * | |* * * |
|* ** * | |* ** * |
| * ** | | ** ** |
| | | |
+--------+ */ +--------+ */
0b00000000|CHAR5x7_WIDTH_7px, 0b00000000|CHAR5x7_WIDTH_7px,
0b01100100, 0b01101100,
0b10011010,
0b10010010,
0b10110010, 0b10110010,
0b01001100, 0b10010010,
0b10011010,
0b01101100,
0b00000000, 0b00000000,
/* Character (0x1a): /* Character (0x1a):
width=6 width=6
+--------+ +--------+

16
plot.c
View file

@ -58,24 +58,23 @@ uint32_t trace_index[TRACES_MAX][101];
#define CELL_P(i, x, y) (((((x)&0x03e0UL)<<22) | (((y)&0x03e0UL)<<17)) == ((i)&0xffc00000UL)) #define CELL_P(i, x, y) (((((x)&0x03e0UL)<<22) | (((y)&0x03e0UL)<<17)) == ((i)&0xffc00000UL))
//#define floatToInt(v) ((int)(v)) //#define floatToInt(v) ((int)(v))
//*
int floatToInt(float v){ int floatToInt(float v){
if (v < 0) return v-0.5; if (v < 0) return v-0.5;
if (v > 0) return v+0.5; if (v > 0) return v+0.5;
return 0; return 0;
}/**/ }
void update_grid(void) void update_grid(void)
{ {
int32_t gdigit = 100000000; int32_t gdigit = 100000000;
int32_t fstart, fspan; int32_t fstart, fspan;
int32_t grid; int32_t grid;
if (frequency1 > 0) { if (frequency0 < frequency1) {
fstart = frequency0; fstart = frequency0;
fspan = frequency1 - frequency0; fspan = frequency1 - frequency0;
} else { } else {
fspan = -frequency1; fstart = frequency1;
fstart = frequency0 - fspan/2; fspan = frequency0 - frequency1;
} }
while (gdigit > 100) { while (gdigit > 100) {
@ -465,7 +464,7 @@ float linear(const float *v)
float swr(const float *v) float swr(const float *v)
{ {
float x = sqrtf(v[0]*v[0] + v[1]*v[1]); float x = sqrtf(v[0]*v[0] + v[1]*v[1]);
if (x > 1) if (x >= 1)
return INFINITY; return INFINITY;
return (1 + x)/(1 - x); return (1 + x)/(1 - x);
} }
@ -731,6 +730,9 @@ trace_get_value_string(int t, char *buf, int len, float array[101][2], int i)
break; break;
case TRC_SWR: case TRC_SWR:
v = swr(coeff); v = swr(coeff);
if (v == INFINITY)
chsnprintf(buf, len, S_INFINITY);
else
chsnprintf(buf, len, "%.2f", v); chsnprintf(buf, len, "%.2f", v);
break; break;
case TRC_SMITH: case TRC_SMITH:
@ -1676,7 +1678,7 @@ cell_draw_marker_info(int m, int n, int w, int h)
frequency_string_short(buf, sizeof buf, freq, 0); frequency_string_short(buf, sizeof buf, freq, 0);
} }
cell_drawstring(w, h, buf, xpos, ypos); cell_drawstring(w, h, buf, xpos, ypos);
xpos += 60; xpos += 64;
if (uistat.marker_delta && mk != active_marker) if (uistat.marker_delta && mk != active_marker)
trace_get_value_string_delta(t, buf, sizeof buf, measured[trace[t].channel], markers[mk].index, markers[active_marker].index); trace_get_value_string_delta(t, buf, sizeof buf, measured[trace[t].channel], markers[mk].index, markers[active_marker].index);
else else

521
ui.c
View file

@ -76,11 +76,15 @@ uint8_t ui_mode = UI_NORMAL;
uint8_t keypad_mode; uint8_t keypad_mode;
int8_t selection = 0; int8_t selection = 0;
// Set structure align as WORD (save flash memory)
#pragma pack(push, 2)
typedef struct { typedef struct {
uint8_t type; uint8_t type;
uint8_t data;
char *label; char *label;
const void *reference; const void *reference;
} menuitem_t; } menuitem_t;
#pragma pack(pop)
int8_t last_touch_status = FALSE; int8_t last_touch_status = FALSE;
int16_t last_touch_x; int16_t last_touch_x;
@ -117,8 +121,6 @@ static void ui_process_numeric(void);
static void menu_push_submenu(const menuitem_t *submenu); static void menu_push_submenu(const menuitem_t *submenu);
static int btn_check(void) static int btn_check(void)
{ {
int cur_button = READ_PORT() & BUTTON_MASK; int cur_button = READ_PORT() & BUTTON_MASK;
@ -448,48 +450,28 @@ enum {
MT_CLOSE MT_CLOSE
}; };
typedef void (*menuaction_cb_t)(int item); typedef void (*menuaction_cb_t)(int item, uint8_t data);
static void menu_move_back(void); static void menu_move_back(void);
static void static void
menu_calop_cb(int item) menu_calop_cb(int item, uint8_t data)
{ {
static const uint8_t cal_type[]={CAL_OPEN, CAL_SHORT, CAL_LOAD, CAL_ISOLN, CAL_THRU}; cal_collect(data);
if (item < 0 && item >= sizeof(cal_type))
return;
cal_collect(cal_type[item]);
/*
switch (item) {
case 0: // OPEN
cal_collect(CAL_OPEN);
break;
case 1: // SHORT
cal_collect(CAL_SHORT);
break;
case 2: // LOAD
cal_collect(CAL_LOAD);
break;
case 3: // ISOLN
cal_collect(CAL_ISOLN);
break;
case 4: // THRU
cal_collect(CAL_THRU);
break;
}*/
selection = item+1; selection = item+1;
draw_cal_status(); draw_cal_status();
draw_menu(); draw_menu();
} }
static void static void
menu_caldone_cb(int item) menu_caldone_cb(int item, uint8_t data)
{ {
extern const menuitem_t menu_save[]; extern const menuitem_t menu_save[];
//extern const menuitem_t menu_cal[]; //extern const menuitem_t menu_cal[];
(void)item; (void)item;
(void)data;
cal_done(); cal_done();
draw_cal_status(); draw_cal_status();
menu_move_back(); menu_move_back();
@ -497,15 +479,15 @@ menu_caldone_cb(int item)
} }
static void static void
menu_cal2_cb(int item) menu_cal2_cb(int item, uint8_t data)
{ {
(void)data;
switch (item) { switch (item) {
case 2: // RESET case 2: // RESET
cal_status = 0; cal_status = 0;
break; break;
case 3: // CORRECTION case 3: // CORRECTION
// toggle applying correction // toggle applying correction
if (cal_status)
cal_status ^= CALSTAT_APPLY; cal_status ^= CALSTAT_APPLY;
draw_menu(); draw_menu();
break; break;
@ -515,11 +497,10 @@ menu_cal2_cb(int item)
} }
static void static void
menu_recall_cb(int item) menu_recall_cb(int item, uint8_t data)
{ {
if (item < 0 || item >= 5) (void)item;
return; if (caldata_recall(data) == 0) {
if (caldata_recall(item) == 0) {
menu_move_back(); menu_move_back();
ui_mode_normal(); ui_mode_normal();
update_grid(); update_grid();
@ -528,8 +509,9 @@ menu_recall_cb(int item)
} }
static void static void
menu_config_cb(int item) menu_config_cb(int item, uint8_t data)
{ {
(void)data;
switch (item) { switch (item) {
case 0: case 0:
touch_cal_exec(); touch_cal_exec();
@ -557,20 +539,18 @@ menu_config_cb(int item)
} }
static void static void
menu_dfu_cb(int item) menu_dfu_cb(int item, uint8_t data)
{ {
switch (item) { (void)item;
case 0: (void)data;
enter_dfu(); enter_dfu();
} }
}
static void static void
menu_save_cb(int item) menu_save_cb(int item, uint8_t data)
{ {
if (item < 0 || item >= 5) (void)item;
return; if (caldata_save(data) == 0) {
if (caldata_save(item) == 0) {
menu_move_back(); menu_move_back();
ui_mode_normal(); ui_mode_normal();
draw_cal_status(); draw_cal_status();
@ -592,21 +572,19 @@ choose_active_trace(void)
} }
static void static void
menu_trace_cb(int item) menu_trace_cb(int item, uint8_t data)
{ {
if (item < 0 || item >= 4) if (trace[data].enabled) {
return; if (data == uistat.current_trace) {
if (trace[item].enabled) {
if (item == uistat.current_trace) {
// disable if active trace is selected // disable if active trace is selected
trace[item].enabled = FALSE; trace[data].enabled = FALSE;
choose_active_trace(); choose_active_trace();
} else { } else {
// make active selected trace // make active selected trace
uistat.current_trace = item; uistat.current_trace = item;
} }
} else { } else {
trace[item].enabled = TRUE; trace[data].enabled = TRUE;
uistat.current_trace = item; uistat.current_trace = item;
} }
request_to_redraw_grid(); request_to_redraw_grid();
@ -614,128 +592,49 @@ menu_trace_cb(int item)
} }
static void static void
menu_format_cb(int item) menu_format_cb(int item, uint8_t data)
{ {
static const uint8_t types[]={TRC_LOGMAG, TRC_PHASE, TRC_DELAY, TRC_SMITH, TRC_SWR}; (void)item;
if (item < 0 && item >= sizeof(types)) set_trace_type(uistat.current_trace, data);
return;
set_trace_type(uistat.current_trace, types[item]);
/*
switch (item) {
case 0:
set_trace_type(uistat.current_trace, TRC_LOGMAG);
break;
case 1:
set_trace_type(uistat.current_trace, TRC_PHASE);
break;
case 2:
set_trace_type(uistat.current_trace, TRC_DELAY);
break;
case 3:
set_trace_type(uistat.current_trace, TRC_SMITH);
break;
case 4:
set_trace_type(uistat.current_trace, TRC_SWR);
break;
}*/
request_to_redraw_grid(); request_to_redraw_grid();
ui_mode_normal(); ui_mode_normal();
//redraw_all(); //redraw_all();
} }
static void static void
menu_format2_cb(int item) menu_channel_cb(int item, uint8_t data)
{ {
static const uint8_t types[]={TRC_POLAR, TRC_LINEAR, TRC_REAL, TRC_IMAG, TRC_R, TRC_X}; (void)item;
if (item < 0 && item >= sizeof(types)) set_trace_channel(uistat.current_trace, data);
return;
set_trace_type(uistat.current_trace, types[item]);
/*
switch (item) {
case 0:
set_trace_type(uistat.current_trace, TRC_POLAR);
break;
case 1:
set_trace_type(uistat.current_trace, TRC_LINEAR);
break;
case 2:
set_trace_type(uistat.current_trace, TRC_REAL);
break;
case 3:
set_trace_type(uistat.current_trace, TRC_IMAG);
break;
case 4:
set_trace_type(uistat.current_trace, TRC_R);
break;
case 5:
set_trace_type(uistat.current_trace, TRC_X);
break;
}*/
request_to_redraw_grid();
ui_mode_normal();
}
static void
menu_channel_cb(int item)
{
if (item < 0 || item >= 2)
return;
set_trace_channel(uistat.current_trace, item);
menu_move_back(); menu_move_back();
ui_mode_normal(); ui_mode_normal();
} }
static void static void
menu_transform_window_cb(int item) menu_transform_window_cb(int item, uint8_t data)
{ {
(void)item;
// TODO // TODO
switch (item) { domain_mode = (domain_mode & ~TD_WINDOW) | data;
case 0:
domain_mode = (domain_mode & ~TD_WINDOW) | TD_WINDOW_MINIMUM;
ui_mode_normal(); ui_mode_normal();
break;
case 1:
domain_mode = (domain_mode & ~TD_WINDOW) | TD_WINDOW_NORMAL;
ui_mode_normal();
break;
case 2:
domain_mode = (domain_mode & ~TD_WINDOW) | TD_WINDOW_MAXIMUM;
ui_mode_normal();
break;
}
} }
static void static void
menu_transform_cb(int item) menu_transform_cb(int item, uint8_t data)
{ {
int status; (void)item;
switch (item) { (void)data;
case 0: domain_mode ^= DOMAIN_TIME;
if ((domain_mode & DOMAIN_MODE) == DOMAIN_TIME) {
domain_mode = (domain_mode & ~DOMAIN_MODE) | DOMAIN_FREQ;
} else {
domain_mode = (domain_mode & ~DOMAIN_MODE) | DOMAIN_TIME;
}
uistat.lever_mode = LM_MARKER; uistat.lever_mode = LM_MARKER;
draw_frequencies(); draw_frequencies();
ui_mode_normal(); ui_mode_normal();
break; }
case 1:
domain_mode = (domain_mode & ~TD_FUNC) | TD_FUNC_LOWPASS_IMPULSE; static void
ui_mode_normal(); menu_velocity_cb(int item, uint8_t data){
break; (void)item;
case 2: (void)data;
domain_mode = (domain_mode & ~TD_FUNC) | TD_FUNC_LOWPASS_STEP; int status = btn_wait_release();
ui_mode_normal();
break;
case 3:
domain_mode = (domain_mode & ~TD_FUNC) | TD_FUNC_BANDPASS;
ui_mode_normal();
break;
case 5:
status = btn_wait_release();
if (status & EVT_BUTTON_DOWN_LONG) { if (status & EVT_BUTTON_DOWN_LONG) {
ui_mode_numeric(KM_VELOCITY_FACTOR); ui_mode_numeric(KM_VELOCITY_FACTOR);
ui_process_numeric(); ui_process_numeric();
@ -743,8 +642,14 @@ menu_transform_cb(int item)
ui_mode_keypad(KM_VELOCITY_FACTOR); ui_mode_keypad(KM_VELOCITY_FACTOR);
ui_process_keypad(); ui_process_keypad();
} }
break;
} }
static void
menu_transform_filter_cb(int item, uint8_t data)
{
(void)item;
domain_mode = (domain_mode & ~TD_FUNC) | data;
ui_mode_normal();
} }
static void static void
@ -760,26 +665,26 @@ choose_active_marker(void)
} }
static void static void
menu_scale_cb(int item) menu_scale_cb(int item, uint8_t data)
{ {
int status; (void)item;
int km = KM_SCALE + item; if (data == KM_SCALE && trace[uistat.current_trace].type == TRC_DELAY) {
if (km == KM_SCALE && trace[uistat.current_trace].type == TRC_DELAY) { data = KM_SCALEDELAY;
km = KM_SCALEDELAY;
} }
status = btn_wait_release(); int status = btn_wait_release();
if (status & EVT_BUTTON_DOWN_LONG) { if (status & EVT_BUTTON_DOWN_LONG) {
ui_mode_numeric(km); ui_mode_numeric(data);
ui_process_numeric(); ui_process_numeric();
} else { } else {
ui_mode_keypad(km); ui_mode_keypad(data);
ui_process_keypad(); ui_process_keypad();
} }
} }
static void static void
menu_stimulus_cb(int item) menu_stimulus_cb(int item, uint8_t data)
{ {
(void)data;
int status; int status;
switch (item) { switch (item) {
case 0: /* START */ case 0: /* START */
@ -818,8 +723,9 @@ get_marker_frequency(int marker)
} }
static void static void
menu_marker_op_cb(int item) menu_marker_op_cb(int item, uint8_t data)
{ {
(void)data;
int32_t freq = get_marker_frequency(active_marker); int32_t freq = get_marker_frequency(active_marker);
if (freq < 0) if (freq < 0)
return; // no active marker return; // no active marker
@ -872,8 +778,9 @@ menu_marker_op_cb(int item)
} }
static void static void
menu_marker_search_cb(int item) menu_marker_search_cb(int item, uint8_t data)
{ {
(void)data;
int i; int i;
if (active_marker == -1) if (active_marker == -1)
return; return;
@ -909,9 +816,10 @@ menu_marker_search_cb(int item)
} }
static void static void
menu_marker_smith_cb(int item) menu_marker_smith_cb(int item, uint8_t data)
{ {
marker_smith_format = item; (void)item;
marker_smith_format = data;
redraw_marker(active_marker, TRUE); redraw_marker(active_marker, TRUE);
draw_menu(); draw_menu();
} }
@ -933,8 +841,9 @@ active_marker_select(int item)
} }
static void static void
menu_marker_sel_cb(int item) menu_marker_sel_cb(int item, uint8_t data)
{ {
(void)data;
if (item >= 0 && item < 4) { if (item >= 0 && item < 4) {
if (markers[item].enabled) { if (markers[item].enabled) {
if (item == active_marker) { if (item == active_marker) {
@ -964,215 +873,215 @@ menu_marker_sel_cb(int item)
} }
const menuitem_t menu_calop[] = { const menuitem_t menu_calop[] = {
{ MT_CALLBACK, "OPEN", menu_calop_cb }, { MT_CALLBACK, CAL_OPEN, "OPEN", menu_calop_cb },
{ MT_CALLBACK, "SHORT", menu_calop_cb }, { MT_CALLBACK, CAL_SHORT, "SHORT", menu_calop_cb },
{ MT_CALLBACK, "LOAD", menu_calop_cb }, { MT_CALLBACK, CAL_LOAD, "LOAD", menu_calop_cb },
{ MT_CALLBACK, "ISOLN", menu_calop_cb }, { MT_CALLBACK, CAL_ISOLN, "ISOLN", menu_calop_cb },
{ MT_CALLBACK, "THRU", menu_calop_cb }, { MT_CALLBACK, CAL_THRU, "THRU", menu_calop_cb },
{ MT_CALLBACK, "DONE", menu_caldone_cb }, { MT_CALLBACK, 0, "DONE", menu_caldone_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_save[] = { const menuitem_t menu_save[] = {
{ MT_CALLBACK, "SAVE 0", menu_save_cb }, { MT_CALLBACK, 0, "SAVE 0", menu_save_cb },
{ MT_CALLBACK, "SAVE 1", menu_save_cb }, { MT_CALLBACK, 1, "SAVE 1", menu_save_cb },
{ MT_CALLBACK, "SAVE 2", menu_save_cb }, { MT_CALLBACK, 2, "SAVE 2", menu_save_cb },
{ MT_CALLBACK, "SAVE 3", menu_save_cb }, { MT_CALLBACK, 3, "SAVE 3", menu_save_cb },
{ MT_CALLBACK, "SAVE 4", menu_save_cb }, { MT_CALLBACK, 4, "SAVE 4", menu_save_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_cal[] = { const menuitem_t menu_cal[] = {
{ MT_SUBMENU, "CALIBRATE", menu_calop }, { MT_SUBMENU, 0, "CALIBRATE", menu_calop },
{ MT_SUBMENU, "SAVE", menu_save }, { MT_SUBMENU, 0, "SAVE", menu_save },
{ MT_CALLBACK, "RESET", menu_cal2_cb }, { MT_CALLBACK, 0, "RESET", menu_cal2_cb },
{ MT_CALLBACK, "CORRECTION", menu_cal2_cb }, { MT_CALLBACK, 0, "CORRECTION", menu_cal2_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_trace[] = { const menuitem_t menu_trace[] = {
{ MT_CALLBACK, "TRACE 0", menu_trace_cb }, { MT_CALLBACK, 0, "TRACE 0", menu_trace_cb },
{ MT_CALLBACK, "TRACE 1", menu_trace_cb }, { MT_CALLBACK, 1, "TRACE 1", menu_trace_cb },
{ MT_CALLBACK, "TRACE 2", menu_trace_cb }, { MT_CALLBACK, 2, "TRACE 2", menu_trace_cb },
{ MT_CALLBACK, "TRACE 3", menu_trace_cb }, { MT_CALLBACK, 3, "TRACE 3", menu_trace_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_format2[] = { const menuitem_t menu_format2[] = {
{ MT_CALLBACK, "POLAR", menu_format2_cb }, { MT_CALLBACK, TRC_POLAR, "POLAR", menu_format_cb },
{ MT_CALLBACK, "LINEAR", menu_format2_cb }, { MT_CALLBACK, TRC_LINEAR, "LINEAR", menu_format_cb },
{ MT_CALLBACK, "REAL", menu_format2_cb }, { MT_CALLBACK, TRC_REAL, "REAL", menu_format_cb },
{ MT_CALLBACK, "IMAG", menu_format2_cb }, { MT_CALLBACK, TRC_IMAG, "IMAG", menu_format_cb },
{ MT_CALLBACK, "RESISTANCE", menu_format2_cb }, { MT_CALLBACK, TRC_R, "RESISTANCE", menu_format_cb },
{ MT_CALLBACK, "REACTANCE", menu_format2_cb }, { MT_CALLBACK, TRC_X, "REACTANCE", menu_format_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_format[] = { const menuitem_t menu_format[] = {
{ MT_CALLBACK, "LOGMAG", menu_format_cb }, { MT_CALLBACK, TRC_LOGMAG, "LOGMAG", menu_format_cb },
{ MT_CALLBACK, "PHASE", menu_format_cb }, { MT_CALLBACK, TRC_PHASE, "PHASE", menu_format_cb },
{ MT_CALLBACK, "DELAY", menu_format_cb }, { MT_CALLBACK, TRC_DELAY, "DELAY", menu_format_cb },
{ MT_CALLBACK, "SMITH", menu_format_cb }, { MT_CALLBACK, TRC_SMITH, "SMITH", menu_format_cb },
{ MT_CALLBACK, "SWR", menu_format_cb }, { MT_CALLBACK, TRC_SWR, "SWR", menu_format_cb },
{ MT_SUBMENU, S_RARROW" MORE", menu_format2 }, { MT_SUBMENU, 0, S_RARROW" MORE", menu_format2 },
//{ MT_CALLBACK, "LINEAR", menu_format_cb }, //{ MT_CALLBACK, TRC_LINEAR, "LINEAR", menu_format_cb },
//{ MT_CALLBACK, "SWR", menu_format_cb }, //{ MT_CALLBACK, TRC_SWR, "SWR", menu_format_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_scale[] = { const menuitem_t menu_scale[] = {
{ MT_CALLBACK, "SCALE/DIV", menu_scale_cb }, { MT_CALLBACK, KM_SCALE, "SCALE/DIV", menu_scale_cb },
{ MT_CALLBACK, "\2REFERENCE\0POSITION", menu_scale_cb }, { MT_CALLBACK, KM_REFPOS, "\2REFERENCE\0POSITION", menu_scale_cb },
{ MT_CALLBACK, "\2ELECTRICAL\0DELAY", menu_scale_cb }, { MT_CALLBACK, KM_EDELAY, "\2ELECTRICAL\0DELAY", menu_scale_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_channel[] = { const menuitem_t menu_channel[] = {
{ MT_CALLBACK, "\2CH0\0REFLECT", menu_channel_cb }, { MT_CALLBACK, 0, "\2CH0\0REFLECT", menu_channel_cb },
{ MT_CALLBACK, "\2CH1\0THROUGH", menu_channel_cb }, { MT_CALLBACK, 1, "\2CH1\0THROUGH", menu_channel_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_transform_window[] = { const menuitem_t menu_transform_window[] = {
{ MT_CALLBACK, "MINIMUM", menu_transform_window_cb }, { MT_CALLBACK, TD_WINDOW_MINIMUM, "MINIMUM", menu_transform_window_cb },
{ MT_CALLBACK, "NORMAL", menu_transform_window_cb }, { MT_CALLBACK, TD_WINDOW_NORMAL, "NORMAL", menu_transform_window_cb },
{ MT_CALLBACK, "MAXIMUM", menu_transform_window_cb }, { MT_CALLBACK, TD_WINDOW_MAXIMUM, "MAXIMUM", menu_transform_window_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_transform[] = { const menuitem_t menu_transform[] = {
{ MT_CALLBACK, "\2TRANSFORM\0ON", menu_transform_cb }, { MT_CALLBACK, 0, "\2TRANSFORM\0ON", menu_transform_cb },
{ MT_CALLBACK, "\2LOW PASS\0IMPULSE", menu_transform_cb }, { MT_CALLBACK, TD_FUNC_LOWPASS_IMPULSE, "\2LOW PASS\0IMPULSE", menu_transform_filter_cb },
{ MT_CALLBACK, "\2LOW PASS\0STEP", menu_transform_cb }, { MT_CALLBACK, TD_FUNC_LOWPASS_STEP, "\2LOW PASS\0STEP", menu_transform_filter_cb },
{ MT_CALLBACK, "BANDPASS", menu_transform_cb }, { MT_CALLBACK, TD_FUNC_BANDPASS, "BANDPASS", menu_transform_filter_cb },
{ MT_SUBMENU, "WINDOW", menu_transform_window }, { MT_SUBMENU, 0, "WINDOW", menu_transform_window },
{ MT_CALLBACK, "\2VELOCITY\0FACTOR", menu_transform_cb }, { MT_CALLBACK, 0, "\2VELOCITY\0FACTOR", menu_velocity_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_display[] = { const menuitem_t menu_display[] = {
{ MT_SUBMENU, "TRACE", menu_trace }, { MT_SUBMENU, 0, "TRACE", menu_trace },
{ MT_SUBMENU, "FORMAT", menu_format }, { MT_SUBMENU, 0, "FORMAT", menu_format },
{ MT_SUBMENU, "SCALE", menu_scale }, { MT_SUBMENU, 0, "SCALE", menu_scale },
{ MT_SUBMENU, "CHANNEL", menu_channel }, { MT_SUBMENU, 0, "CHANNEL", menu_channel },
{ MT_SUBMENU, "TRANSFORM", menu_transform }, { MT_SUBMENU, 0, "TRANSFORM", menu_transform },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_stimulus[] = { const menuitem_t menu_stimulus[] = {
{ MT_CALLBACK, "START", menu_stimulus_cb }, { MT_CALLBACK, 0, "START", menu_stimulus_cb },
{ MT_CALLBACK, "STOP", menu_stimulus_cb }, { MT_CALLBACK, 0, "STOP", menu_stimulus_cb },
{ MT_CALLBACK, "CENTER", menu_stimulus_cb }, { MT_CALLBACK, 0, "CENTER", menu_stimulus_cb },
{ MT_CALLBACK, "SPAN", menu_stimulus_cb }, { MT_CALLBACK, 0, "SPAN", menu_stimulus_cb },
{ MT_CALLBACK, "CW FREQ", menu_stimulus_cb }, { MT_CALLBACK, 0, "CW FREQ", menu_stimulus_cb },
{ MT_CALLBACK, "\2PAUSE\0SWEEP", menu_stimulus_cb }, { MT_CALLBACK, 0, "\2PAUSE\0SWEEP", menu_stimulus_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_marker_sel[] = { const menuitem_t menu_marker_sel[] = {
{ MT_CALLBACK, "MARKER 1", menu_marker_sel_cb }, { MT_CALLBACK, 1, "MARKER 1", menu_marker_sel_cb },
{ MT_CALLBACK, "MARKER 2", menu_marker_sel_cb }, { MT_CALLBACK, 2, "MARKER 2", menu_marker_sel_cb },
{ MT_CALLBACK, "MARKER 3", menu_marker_sel_cb }, { MT_CALLBACK, 3, "MARKER 3", menu_marker_sel_cb },
{ MT_CALLBACK, "MARKER 4", menu_marker_sel_cb }, { MT_CALLBACK, 4, "MARKER 4", menu_marker_sel_cb },
{ MT_CALLBACK, "ALL OFF", menu_marker_sel_cb }, { MT_CALLBACK, 0, "ALL OFF", menu_marker_sel_cb },
{ MT_CALLBACK, "DELTA", menu_marker_sel_cb }, { MT_CALLBACK, 0, "DELTA", menu_marker_sel_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_marker_ops[] = { const menuitem_t menu_marker_ops[] = {
{ MT_CALLBACK, S_RARROW"START", menu_marker_op_cb }, { MT_CALLBACK, 0, S_RARROW"START", menu_marker_op_cb },
{ MT_CALLBACK, S_RARROW"STOP", menu_marker_op_cb }, { MT_CALLBACK, 0, S_RARROW"STOP", menu_marker_op_cb },
{ MT_CALLBACK, S_RARROW"CENTER", menu_marker_op_cb }, { MT_CALLBACK, 0, S_RARROW"CENTER", menu_marker_op_cb },
{ MT_CALLBACK, S_RARROW"SPAN", menu_marker_op_cb }, { MT_CALLBACK, 0, S_RARROW"SPAN", menu_marker_op_cb },
{ MT_CALLBACK, S_RARROW"EDELAY", menu_marker_op_cb }, { MT_CALLBACK, 0, S_RARROW"EDELAY", menu_marker_op_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_marker_search[] = { const menuitem_t menu_marker_search[] = {
//{ MT_CALLBACK, "OFF", menu_marker_search_cb }, //{ MT_CALLBACK, "OFF", menu_marker_search_cb },
{ MT_CALLBACK, "MAXIMUM", menu_marker_search_cb }, { MT_CALLBACK, 0, "MAXIMUM", menu_marker_search_cb },
{ MT_CALLBACK, "MINIMUM", menu_marker_search_cb }, { MT_CALLBACK, 0, "MINIMUM", menu_marker_search_cb },
{ MT_CALLBACK, "\2SEARCH\0" S_LARROW" LEFT", menu_marker_search_cb }, { MT_CALLBACK, 0, "\2SEARCH\0" S_LARROW" LEFT", menu_marker_search_cb },
{ MT_CALLBACK, "\2SEARCH\0" S_RARROW" RIGHT", menu_marker_search_cb }, { MT_CALLBACK, 0, "\2SEARCH\0" S_RARROW" RIGHT", menu_marker_search_cb },
{ MT_CALLBACK, "TRACKING", menu_marker_search_cb }, { MT_CALLBACK, 0, "TRACKING", menu_marker_search_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_marker_smith[] = { const menuitem_t menu_marker_smith[] = {
{ MT_CALLBACK, "LIN", menu_marker_smith_cb }, { MT_CALLBACK, MS_LIN, "LIN", menu_marker_smith_cb },
{ MT_CALLBACK, "LOG", menu_marker_smith_cb }, { MT_CALLBACK, MS_LOG, "LOG", menu_marker_smith_cb },
{ MT_CALLBACK, "Re+Im", menu_marker_smith_cb }, { MT_CALLBACK, MS_REIM,"Re+Im", menu_marker_smith_cb },
{ MT_CALLBACK, "R+Xj", menu_marker_smith_cb }, { MT_CALLBACK, MS_RX, "R+Xj", menu_marker_smith_cb },
{ MT_CALLBACK, "R+L/C", menu_marker_smith_cb }, { MT_CALLBACK, MS_RLC, "R+L/C", menu_marker_smith_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_marker[] = { const menuitem_t menu_marker[] = {
{ MT_SUBMENU, "\2SELECT\0MARKER", menu_marker_sel }, { MT_SUBMENU, 0, "\2SELECT\0MARKER", menu_marker_sel },
{ MT_SUBMENU, "SEARCH", menu_marker_search }, { MT_SUBMENU, 0, "SEARCH", menu_marker_search },
{ MT_SUBMENU, "OPERATIONS", menu_marker_ops }, { MT_SUBMENU, 0, "OPERATIONS", menu_marker_ops },
{ MT_SUBMENU, "\2SMITH\0VALUE", menu_marker_smith }, { MT_SUBMENU, 0, "\2SMITH\0VALUE", menu_marker_smith },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_recall[] = { const menuitem_t menu_recall[] = {
{ MT_CALLBACK, "RECALL 0", menu_recall_cb }, { MT_CALLBACK, 0, "RECALL 0", menu_recall_cb },
{ MT_CALLBACK, "RECALL 1", menu_recall_cb }, { MT_CALLBACK, 1, "RECALL 1", menu_recall_cb },
{ MT_CALLBACK, "RECALL 2", menu_recall_cb }, { MT_CALLBACK, 2, "RECALL 2", menu_recall_cb },
{ MT_CALLBACK, "RECALL 3", menu_recall_cb }, { MT_CALLBACK, 3, "RECALL 3", menu_recall_cb },
{ MT_CALLBACK, "RECALL 4", menu_recall_cb }, { MT_CALLBACK, 4, "RECALL 4", menu_recall_cb },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_dfu[] = { const menuitem_t menu_dfu[] = {
{ MT_CALLBACK, "\2RESET AND\0ENTER DFU", menu_dfu_cb }, { MT_CALLBACK, 0, "\2RESET AND\0ENTER DFU", menu_dfu_cb },
{ MT_CANCEL, S_LARROW"CANCEL", NULL }, { MT_CANCEL, 0, S_LARROW"CANCEL", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_config[] = { const menuitem_t menu_config[] = {
{ MT_CALLBACK, "TOUCH CAL", menu_config_cb }, { MT_CALLBACK, 0, "TOUCH CAL", menu_config_cb },
{ MT_CALLBACK, "TOUCH TEST", menu_config_cb }, { MT_CALLBACK, 0, "TOUCH TEST", menu_config_cb },
{ MT_CALLBACK, "SAVE", menu_config_cb }, { MT_CALLBACK, 0, "SAVE", menu_config_cb },
{ MT_CALLBACK, "VERSION", menu_config_cb }, { MT_CALLBACK, 0, "VERSION", menu_config_cb },
{ MT_SUBMENU, S_RARROW"DFU", menu_dfu }, { MT_SUBMENU, 0, S_RARROW"DFU", menu_dfu },
{ MT_CANCEL, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
const menuitem_t menu_top[] = { const menuitem_t menu_top[] = {
{ MT_SUBMENU, "DISPLAY", menu_display }, { MT_SUBMENU, 0, "DISPLAY", menu_display },
{ MT_SUBMENU, "MARKER", menu_marker }, { MT_SUBMENU, 0, "MARKER", menu_marker },
{ MT_SUBMENU, "STIMULUS", menu_stimulus }, { MT_SUBMENU, 0, "STIMULUS", menu_stimulus },
{ MT_SUBMENU, "CAL", menu_cal }, { MT_SUBMENU, 0, "CAL", menu_cal },
{ MT_SUBMENU, "RECALL", menu_recall }, { MT_SUBMENU, 0, "RECALL", menu_recall },
{ MT_SUBMENU, "CONFIG", menu_config }, { MT_SUBMENU, 0, "CONFIG", menu_config },
{ MT_NONE, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
#define MENU_STACK_DEPTH_MAX 4 #define MENU_STACK_DEPTH_MAX 4
uint8_t menu_current_level = 0; uint8_t menu_current_level = 0;
const menuitem_t *menu_stack[4] = { const menuitem_t *menu_stack[4] = {
menu_top, NULL, NULL, NULL menu_top, 0, NULL, NULL, NULL
}; };
static void static void
@ -1238,7 +1147,7 @@ void menu_invoke(int item)
menuaction_cb_t cb = (menuaction_cb_t)menu->reference; menuaction_cb_t cb = (menuaction_cb_t)menu->reference;
if (cb == NULL) if (cb == NULL)
return; return;
(*cb)(item); (*cb)(item, menu->data);
break; break;
} }