From d2431f0cdc7979536372333c731f846ce0f51b80 Mon Sep 17 00:00:00 2001 From: DiSlord Date: Mon, 24 Feb 2020 22:47:52 +0300 Subject: [PATCH] Increase screen render (in some cases up to 2x speedup), decrease stack usage (code size less on 1500 bytes) Write simple profiling definitions START_PROFILE STOP_PROFILE Use it for detect sys tick amount and output to screen main.c Reduce VNA_SHELL_MAX_LENGTH to 48, and made shell_line as static (reduce stack usage) Remove BaseSequentialStream *chp from command calls (use static shell_stream), it reduce code size and stack usage Use VNA_SHELL_FUNCTION definition for all commands Remove chMtxLock(&mutex);chMtxUnlock(&mutex); from commands, and define command flag for use it in calls Apply default scale from trace_info on trace change Led blink outside from main sweep cycle (better look, and less noise) Some size fixes chprintf.c Implement small memory stream object, only put function and plot_printf(char *str, int size, const char *fmt, ...) Use it in all code (little increase speed, and huge decrease size) Restore USE_EXCEPTIONS_STACKSIZE = 0x180 (possible not need, but not good tested) plot.c Made huge screen render profile (add some comments) Not use cell clipping on draw cell data (use constants increase speed, decrease stack usage (not need put it to stack)) Clip cell if need only on screen flush Use new plot_printf, remove chsnprintf usage Apply code style ============================================================================================================ Interesting fact Usage memset(spi_buffer, DEFAULT_BG_COLOR, (h*CELLWIDTH)*sizeof(uint16_t)); dramatically decrease render speed possibly it fill buffer by 8 bit data, so slow Usage uint32_t *p = (uint32_t *)spi_buffer; while (count--) { p[0] = DEFAULT_BG_COLOR|(DEFAULT_BG_COLOR<<16); p[1] = DEFAULT_BG_COLOR|(DEFAULT_BG_COLOR<<16); p[2] = DEFAULT_BG_COLOR|(DEFAULT_BG_COLOR<<16); p[3] = DEFAULT_BG_COLOR|(DEFAULT_BG_COLOR<<16); p+=4; } gives x10 speed perfomance Draw polar and smit grid very slow (but i don`t know how increase it except use bitmaps, but it need about 5-8k flash size and file prepare) On long lines render slow down, but clipping use more calculation, and not give good result Need made stack usage check --- Font5x7.c | 1 + Makefile | 2 +- chprintf.c | 124 ++++++++---- main.c | 579 ++++++++++++++++++++++++++--------------------------- nanovna.h | 5 + plot.c | 459 ++++++++++++++++++++---------------------- ui.c | 12 +- 7 files changed, 592 insertions(+), 590 deletions(-) diff --git a/Font5x7.c b/Font5x7.c index a69bcc7..87b9127 100644 --- a/Font5x7.c +++ b/Font5x7.c @@ -11,6 +11,7 @@ #define FONT_GET_DATA(ch) (&x5x7_bits[ch*7]) #define FONT_GET_WIDTH(ch) (8-x5x7_bits[ch*7]&7) +#define FONT_MAX_WIDTH 7 #define FONT_GET_HEIGHT 7 #define CHAR5x7_WIDTH_1px 0x07 diff --git a/Makefile b/Makefile index 7c8be0c..766ae71 100644 --- a/Makefile +++ b/Makefile @@ -70,7 +70,7 @@ endif # Stack size to the allocated to the Cortex-M main/exceptions stack. This # stack is used for processing interrupts and exceptions. ifeq ($(USE_EXCEPTIONS_STACKSIZE),) - USE_EXCEPTIONS_STACKSIZE = 0x180 + USE_EXCEPTIONS_STACKSIZE = 0x200 endif # diff --git a/chprintf.c b/chprintf.c index 6ba7efd..c9aae43 100644 --- a/chprintf.c +++ b/chprintf.c @@ -29,7 +29,7 @@ #include "hal.h" #include "chprintf.h" -#include "memstreams.h" +//#include "memstreams.h" #include // Enable [flags], support: @@ -53,7 +53,6 @@ static char smallPrefix[]= { 'm', 0x1d, 'n', 'p', 'f', 'a', 'z', 'y', #pragma pack(pop) -//86066 5116 11456 102622 190de build/ch.elf static char *long_to_string_with_divisor(char *p, uint32_t num, uint32_t radix, @@ -63,7 +62,7 @@ static char *long_to_string_with_divisor(char *p, // convert to string from end buffer to begin do { uint8_t c = num % radix; - num /= radix; + num /= radix; *--q = c + ((c > 9) ? ('A'-10) : '0'); }while((precision && --precision) || num); // copy string at begin @@ -103,7 +102,7 @@ static char *ulong_freq(char *p, uint32_t freq, uint32_t precision){ // freq = freq / 10; uint32_t c = freq; freq>>=1; - freq+=freq>>1; + freq+=freq>>1; freq+=freq>>4; freq+=freq>>8; freq+=freq>>16; // freq = 858993459*freq/1073741824 = freq * 0,799999999813735485076904296875 @@ -111,12 +110,12 @@ static char *ulong_freq(char *p, uint32_t freq, uint32_t precision){ c-= freq*10; // freq*10 = (freq*4+freq)*2 = ((freq<<2)+freq)<<1 while (c>=10) {freq++;c-=10;} #endif - *--q = c + '0'; - if (freq==0) - break; - // Add spaces, calculate prefix - if (format&1) {*--q = ' '; s++;} - format>>=1; + *--q = c + '0'; + if (freq==0) + break; + // Add spaces, calculate prefix + if (format&1) {*--q = ' '; s++;} + format>>=1; } while (1); s = bigPrefix[s]; @@ -144,7 +143,7 @@ static char *ulong_freq(char *p, uint32_t freq, uint32_t precision){ }while (--i); // Put pref (amd space before it if need) if (flag&FREQ_PREFIX_SPACE && s!=' ') - *p++ = ' '; + *p++ = ' '; *p++ = s; return p; } @@ -162,9 +161,9 @@ static char *ftoa(char *p, float num, uint32_t precision) { if (k>=multi){k-=multi;l++;} p = long_to_string_with_divisor(p, l, 10, 0); if (precision && k){ - *p++ = '.'; - p=long_to_string_with_divisor(p, k, 10, precision); - // remove zeros at end + *p++ = '.'; + p=long_to_string_with_divisor(p, k, 10, precision); + // remove zeros at end while (p[-1]=='0') p--; if (p[-1]=='.') p--; } @@ -175,14 +174,14 @@ static char *ftoaS(char *p, float num, uint32_t precision) { char prefix=0; char *ptr; if (num > 1000.0){ - for (ptr = bigPrefix+1; *ptr && num > 1000.0; num/=1000, ptr++) - ; - prefix = ptr[-1]; + for (ptr = bigPrefix+1; *ptr && num > 1000.0; num/=1000, ptr++) + ; + prefix = ptr[-1]; } else if (num < 1){ - for (ptr = smallPrefix; *ptr && num < 1.0; num*=1000, ptr++) - ; - prefix = num > 1e-3 ? ptr[-1] : 0; + for (ptr = smallPrefix; *ptr && num < 1.0; num*=1000, ptr++) + ; + prefix = num > 1e-3 ? ptr[-1] : 0; } // Auto set prescision uint32_t l = num; @@ -274,13 +273,13 @@ int chvprintf(BaseSequentialStream *chp, const char *fmt, va_list ap) { else if (*fmt == '+') state|=POSITIVE; else if (*fmt == '0') - state|=PAD_ZERO; + state|=PAD_ZERO; #ifdef CHPRINTF_USE_SPACE_FLAG else if (*fmt == ' ') - state|=PLUS_SPACE; + state|=PLUS_SPACE; #endif else - break; + break; fmt++; } // Get [width] - The Width field specifies a minimum number of characters to output @@ -309,7 +308,7 @@ int chvprintf(BaseSequentialStream *chp, const char *fmt, va_list ap) { } } else - state|=DEFAULT_PRESCISION; + state|=DEFAULT_PRESCISION; //Get [length] /* if (c == 'l' || c == 'L') { @@ -342,42 +341,42 @@ int chvprintf(BaseSequentialStream *chp, const char *fmt, va_list ap) { if (state & IS_LONG) value.l = va_arg(ap, long); else*/ - value.l = va_arg(ap, uint32_t); + value.l = va_arg(ap, uint32_t); if (value.l < 0) { - state|=NEGATIVE; + state|=NEGATIVE; *p++ = '-'; value.l = -value.l; } else if (state & POSITIVE) - *p++ = '+'; + *p++ = '+'; #ifdef CHPRINTF_USE_SPACE_FLAG else if (state & PLUS_SPACE) - *p++ = ' '; + *p++ = ' '; #endif p = long_to_string_with_divisor(p, value.l, 10, 0); break; - case 'q': - value.u = va_arg(ap, uint32_t); - p=ulong_freq(p, value.u, precision); - break; + case 'q': + value.u = va_arg(ap, uint32_t); + p=ulong_freq(p, value.u, precision); + break; #if CHPRINTF_USE_FLOAT case 'F': case 'f': value.f = va_arg(ap, double); if (value.f < 0) { - state|=NEGATIVE; + state|=NEGATIVE; *p++ = '-'; value.f = -value.f; } else if (state & POSITIVE) - *p++ = '+'; + *p++ = '+'; #ifdef CHPRINTF_USE_SPACE_FLAG else if (state & PLUS_SPACE) *p++ = ' '; #endif if (value.f == INFINITY){ - *p++ = 0x19; - break; + *p++ = 0x19; + break; } p = (c=='F') ? ftoaS(p, value.f, precision) : ftoa(p, value.f, state&DEFAULT_PRESCISION ? FLOAT_PRECISION : precision); break; @@ -422,7 +421,7 @@ unsigned_common:/* while (width){ streamPut(chp, (uint8_t)filler); n++; - width--; + width--; } } // put data @@ -462,6 +461,7 @@ unsigned_common:/* * * @api */ +#if 0 int chprintf(BaseSequentialStream *chp, const char *fmt, ...) { va_list ap; int formatted_bytes; @@ -472,7 +472,7 @@ int chprintf(BaseSequentialStream *chp, const char *fmt, ...) { return formatted_bytes; } - +#endif /** * @brief System formatted output function. * @details This function implements a minimal @p vprintf()-like functionality @@ -501,6 +501,7 @@ int chprintf(BaseSequentialStream *chp, const char *fmt, ...) { * * @api */ +#if 0 int chsnprintf(char *str, size_t size, const char *fmt, ...) { va_list ap; MemoryStream ms; @@ -530,5 +531,52 @@ int chsnprintf(char *str, size_t size, const char *fmt, ...) { /* Return number of bytes that would have been written.*/ return retval; } +#endif + +// +// Small memory stream object, only put function +// +struct printStreamVMT { + _base_sequential_stream_methods +}; + +typedef struct { + const struct printStreamVMT *vmt; + uint8_t *buffer; + uint16_t size; +} printStream; + +static msg_t put(void *ip, uint8_t b) { + printStream *ps = ip; + if (ps->size > 1){ + *(ps->buffer++) = b; + ps->size--; + } + return MSG_OK; +} + +static const struct printStreamVMT vmt = {NULL, NULL, put, NULL}; +void printObjectInit(printStream *ps, int size, uint8_t *buffer){ + ps->vmt = &vmt; + ps->buffer = buffer; + ps->size = size; +} +// Simple print in buffer function +int plot_printf(char *str, int size, const char *fmt, ...) { + va_list ap; + printStream ps; + int retval; + if (size <= 0) return 0; + // Init small memory stream for print + printObjectInit(&ps, size, (uint8_t *)str); + // Performing the print operation using the common code. + va_start(ap, fmt); + retval = chvprintf((BaseSequentialStream *)(void *)&ps, fmt, ap); + va_end(ap); + *(ps.buffer)=0; + if (retval > size-1) retval = size-1; + // Return number of bytes that would have been written. + return retval; +} /** @} */ diff --git a/main.c b/main.c index b7b0f26..bfbdee2 100644 --- a/main.c +++ b/main.c @@ -46,15 +46,17 @@ static BaseSequentialStream *shell_stream = (BaseSequentialStream *)&SDU1; // Shell max arguments #define VNA_SHELL_MAX_ARGUMENTS 4 // Shell max command line size -#define VNA_SHELL_MAX_LENGTH 64 +#define VNA_SHELL_MAX_LENGTH 48 // Shell command functions prototypes -typedef void (*vna_shellcmd_t)(BaseSequentialStream *chp, int argc, char *argv[]); -#define VNA_SHELL_FUNCTION(command_name) static void command_name(BaseSequentialStream *chp, int argc, char *argv[]) +typedef void (*vna_shellcmd_t)(int argc, char *argv[]); +#define VNA_SHELL_FUNCTION(command_name) static void command_name(int argc, char *argv[]) + +// Shell command line buffer +static char shell_line[VNA_SHELL_MAX_LENGTH]; //#define ENABLED_DUMP //#define ENABLE_THREADS_COMMAND - static void apply_error_term_at(int i); static void apply_edelay_at(int i); static void cal_interpolate(int s); @@ -88,6 +90,7 @@ static THD_FUNCTION(Thread1, arg) bool completed = false; if (sweep_enabled || sweep_once) { chMtxLock(&mutex); + // Sweep require 8367 system tick completed = sweep(true); sweep_once = FALSE; chMtxUnlock(&mutex); @@ -96,6 +99,7 @@ static THD_FUNCTION(Thread1, arg) } chMtxLock(&mutex); + // Ui and render require 800 system tick ui_process(); if (sweep_enabled) { @@ -171,7 +175,6 @@ kaiser_window(float k, float n, float beta) { static void transform_domain(void) { - if ((domain_mode & DOMAIN_MODE) != DOMAIN_TIME) return; // nothing to do for freq domain // use spi_buffer as temporary buffer // and calculate ifft for time domain float* tmp = (float*)spi_buffer; @@ -204,7 +207,6 @@ transform_domain(void) break; } - for (int ch = 0; ch < 2; ch++) { memcpy(tmp, measured[ch], sizeof(measured[0])); for (int i = 0; i < POINTS_COUNT; i++) { @@ -242,60 +244,56 @@ transform_domain(void) } // Shell commands output -static int shell_printf(BaseSequentialStream *chp, const char *fmt, ...) { +static int shell_printf(const char *fmt, ...) { va_list ap; int formatted_bytes; va_start(ap, fmt); - formatted_bytes = chvprintf(chp, fmt, ap); + formatted_bytes = chvprintf(shell_stream, fmt, ap); va_end(ap); return formatted_bytes; } -static void cmd_pause(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_pause) { - (void)chp; - (void)argc; - (void)argv; - pause_sweep(); + (void)argc; + (void)argv; + pause_sweep(); } -static void cmd_resume(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_resume) { - (void)chp; - (void)argc; - (void)argv; + (void)argc; + (void)argv; - // restore frequencies array and cal - update_frequencies(); - if (cal_auto_interpolate && (cal_status & CALSTAT_APPLY)) - cal_interpolate(lastsaveid); + // restore frequencies array and cal + update_frequencies(); + if (cal_auto_interpolate && (cal_status & CALSTAT_APPLY)) + cal_interpolate(lastsaveid); - resume_sweep(); + resume_sweep(); } -static void cmd_reset(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_reset) { - (void)argc; - (void)argv; + (void)argc; + (void)argv; - if (argc == 1) { - if (strcmp(argv[0], "dfu") == 0) { - shell_printf(chp, "Performing reset to DFU mode\r\n"); - enter_dfu(); - return; - } + if (argc == 1) { + if (strcmp(argv[0], "dfu") == 0) { + shell_printf("Performing reset to DFU mode\r\n"); + enter_dfu(); + return; } + } + shell_printf("Performing reset\r\n"); - shell_printf(chp, "Performing reset\r\n"); - - rccEnableWWDG(FALSE); - - WWDG->CFR = 0x60; - WWDG->CR = 0xff; + rccEnableWWDG(FALSE); + WWDG->CFR = 0x60; + WWDG->CR = 0xff; - /* wait forever */ - while (1) - ; + /* wait forever */ + while (1) + ; } const int8_t gain_table[] = { @@ -327,15 +325,15 @@ adjust_gain(int newfreq) int set_frequency(uint32_t freq) { - int delay = adjust_gain(freq); - int8_t ds = drive_strength; - if (ds == DRIVE_STRENGTH_AUTO) { - ds = freq > FREQ_HARMONICS ? SI5351_CLK_DRIVE_STRENGTH_8MA : SI5351_CLK_DRIVE_STRENGTH_2MA; - } - delay += si5351_set_frequency_with_offset(freq, frequency_offset, ds); + int delay = adjust_gain(freq); + int8_t ds = drive_strength; + if (ds == DRIVE_STRENGTH_AUTO) { + ds = freq > FREQ_HARMONICS ? SI5351_CLK_DRIVE_STRENGTH_8MA : SI5351_CLK_DRIVE_STRENGTH_2MA; + } + delay += si5351_set_frequency_with_offset(freq, frequency_offset, ds); - frequency = freq; - return delay; + frequency = freq; + return delay; } // Use macro, std isdigit more big @@ -432,17 +430,17 @@ static int getStringIndex(char *v, const char *list){ return -1; } -static void cmd_offset(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_offset) { if (argc != 1) { - shell_printf(chp, "usage: offset {frequency offset(Hz)}\r\n"); + shell_printf("usage: offset {frequency offset(Hz)}\r\n"); return; } frequency_offset = my_atoui(argv[0]); set_frequency(frequency); } -static void cmd_freq(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_freq) { if (argc != 1) { goto usage; @@ -450,82 +448,80 @@ static void cmd_freq(BaseSequentialStream *chp, int argc, char *argv[]) uint32_t freq = my_atoui(argv[0]); pause_sweep(); - chMtxLock(&mutex); set_frequency(freq); - chMtxUnlock(&mutex); return; usage: - shell_printf(chp, "usage: freq {frequency(Hz)}\r\n"); + shell_printf("usage: freq {frequency(Hz)}\r\n"); } -static void cmd_power(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_power) { - if (argc != 1) { - shell_printf(chp, "usage: power {0-3|-1}\r\n"); - return; - } - drive_strength = my_atoi(argv[0]); - set_frequency(frequency); + if (argc != 1) { + shell_printf("usage: power {0-3|-1}\r\n"); + return; + } + drive_strength = my_atoi(argv[0]); + set_frequency(frequency); } -static void cmd_time(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_time) { - RTCDateTime timespec; - (void)argc; - (void)argv; - rtcGetTime(&RTCD1, ×pec); - shell_printf(chp, "%d/%d/%d %d\r\n", timespec.year+1980, timespec.month, timespec.day, timespec.millisecond); + RTCDateTime timespec; + (void)argc; + (void)argv; + rtcGetTime(&RTCD1, ×pec); + shell_printf("%d/%d/%d %d\r\n", timespec.year+1980, timespec.month, timespec.day, timespec.millisecond); } -static void cmd_dac(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_dac) { - int value; - if (argc != 1) { - shell_printf(chp, "usage: dac {value(0-4095)}\r\n"\ - "current value: %d\r\n", config.dac_value); - return; - } - value = my_atoi(argv[0]); - config.dac_value = value; - dacPutChannelX(&DACD2, 0, value); + int value; + if (argc != 1) { + shell_printf("usage: dac {value(0-4095)}\r\n"\ + "current value: %d\r\n", config.dac_value); + return; + } + value = my_atoi(argv[0]); + config.dac_value = value; + dacPutChannelX(&DACD2, 0, value); } -static void cmd_threshold(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_threshold) { - uint32_t value; - if (argc != 1) { - shell_printf(chp, "usage: threshold {frequency in harmonic mode}\r\n"\ - "current: %d\r\n", config.harmonic_freq_threshold); - return; - } - value = my_atoui(argv[0]); - config.harmonic_freq_threshold = value; + uint32_t value; + if (argc != 1) { + shell_printf("usage: threshold {frequency in harmonic mode}\r\n"\ + "current: %d\r\n", config.harmonic_freq_threshold); + return; + } + value = my_atoui(argv[0]); + config.harmonic_freq_threshold = value; } -static void cmd_saveconfig(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_saveconfig) { (void)argc; (void)argv; config_save(); - shell_printf(chp, "Config saved.\r\n"); + shell_printf("Config saved.\r\n"); } -static void cmd_clearconfig(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_clearconfig) { if (argc != 1) { - shell_printf(chp, "usage: clearconfig {protection key}\r\n"); + shell_printf("usage: clearconfig {protection key}\r\n"); return; } if (strcmp(argv[0], "1234") != 0) { - shell_printf(chp, "Key unmatched.\r\n"); + shell_printf("Key unmatched.\r\n"); return; } clear_all_config_prop_data(); - shell_printf(chp, "Config and all cal data cleared.\r\n"\ - "Do reset manually to take effect. Then do touch cal and save.\r\n"); + shell_printf("Config and all cal data cleared.\r\n"\ + "Do reset manually to take effect. Then do touch cal and save.\r\n"); } static struct { @@ -610,34 +606,29 @@ static const I2SConfig i2sconfig = { 2 // i2spr }; -static void cmd_data(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_data) { int i; int sel = 0; - + float (*array)[2]; if (argc == 1) sel = my_atoi(argv[0]); - if (sel == 0 || sel == 1) { - chMtxLock(&mutex); - for (i = 0; i < sweep_points; i++) { - if (frequencies[i] != 0) - shell_printf(chp, "%f %f\r\n", measured[sel][i][0], measured[sel][i][1]); - } - chMtxUnlock(&mutex); - } else if (sel >= 2 && sel < 7) { - chMtxLock(&mutex); - for (i = 0; i < sweep_points; i++) { - if (frequencies[i] != 0) - shell_printf(chp, "%f %f\r\n", cal_data[sel-2][i][0], cal_data[sel-2][i][1]); - } - chMtxUnlock(&mutex); - } else { - shell_printf(chp, "usage: data [array]\r\n"); - } + + if (sel == 0 || sel == 1) + array = measured[sel]; + else if (sel >= 2 && sel < 7) + array = cal_data[sel-2]; + else + goto usage; + for (i = 0; i < sweep_points; i++) + shell_printf("%f %f\r\n", array[i][0], array[i][1]); + return; +usage: + shell_printf("usage: data [array]\r\n"); } #ifdef ENABLED_DUMP -static void cmd_dump(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_dump) { int i, j; int len; @@ -652,37 +643,35 @@ static void cmd_dump(BaseSequentialStream *chp, int argc, char *argv[]) len /= 2; for (i = 0; i < len; ) { for (j = 0; j < 16; j++, i++) { - shell_printf(chp, "%04x ", 0xffff & (int)dump_buffer[i]); + shell_printf("%04x ", 0xffff & (int)dump_buffer[i]); } - shell_printf(chp, "\r\n"); + shell_printf("\r\n"); } } #endif -static void cmd_capture(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_capture) { // read pixel count at one time (PART*2 bytes required for read buffer) - (void)argc; - (void)argv; - - chMtxLock(&mutex); - - // read 2 row pixel time (read buffer limit by 2/3 + 1 from spi_buffer size) - for (int y=0; y < 240; y+=2) - { - // use uint16_t spi_buffer[2048] (defined in ili9341) for read buffer - uint8_t *buf = (uint8_t *)spi_buffer; - ili9341_read_memory(0, y, 320, 2, 2*320, spi_buffer); - for (int i = 0; i < 4*320; i++) { - streamPut(chp, *buf++); - } + (void)argc; + (void)argv; + int i, y; +#if SPI_BUFFER_SIZE < (3*320 + 1) +#error "Low size of spi_buffer for cmd_capture" +#endif + // read 2 row pixel time (read buffer limit by 2/3 + 1 from spi_buffer size) + for (y=0; y < 240; y+=2){ + // use uint16_t spi_buffer[2048] (defined in ili9341) for read buffer + uint8_t *buf = (uint8_t *)spi_buffer; + ili9341_read_memory(0, y, 320, 2, 2*320, spi_buffer); + for (i = 0; i < 4*320; i++) { + streamPut(shell_stream, *buf++); } - - chMtxUnlock(&mutex); + } } #if 0 -static void cmd_gamma(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_gamma) { float gamma[2]; (void)argc; @@ -694,13 +683,13 @@ static void cmd_gamma(BaseSequentialStream *chp, int argc, char *argv[]) calculate_gamma(gamma); chMtxUnlock(&mutex); - shell_printf(chp, "%d %d\r\n", gamma[0], gamma[1]); + shell_printf("%d %d\r\n", gamma[0], gamma[1]); } #endif static void (*sample_func)(float *gamma) = calculate_gamma; -static void cmd_sample(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_sample) { if (argc!=1) goto usage; // 0 1 2 @@ -712,7 +701,7 @@ static void cmd_sample(BaseSequentialStream *chp, int argc, char *argv[]) default:break; } usage: - shell_printf(chp, "usage: sample {%s}\r\n", cmd_sample_list); + shell_printf("usage: sample {%s}\r\n", cmd_sample_list); } config_t config = { @@ -765,27 +754,22 @@ ensure_edit_config(void) bool sweep(bool break_on_operation) { int i; - + // blink LED while scanning + palClearPad(GPIOC, GPIOC_LED); for (i = 0; i < sweep_points; i++) { int delay = set_frequency(frequencies[i]); tlv320aic3204_select(0); // CH0:REFLECT wait_dsp(delay); - // blink LED while scanning - palClearPad(GPIOC, GPIOC_LED); - - /* calculate reflection coeficient */ + /* calculate reflection coefficient */ (*sample_func)(measured[0][i]); tlv320aic3204_select(1); // CH1:TRANSMISSION wait_dsp(DELAY_CHANNEL_CHANGE); - /* calculate transmission coeficient */ + /* calculate transmission coefficient */ (*sample_func)(measured[1][i]); - // blink LED while scanning - palSetPad(GPIOC, GPIOC_LED); - if (cal_status & CALSTAT_APPLY) apply_error_term_at(i); @@ -796,31 +780,33 @@ bool sweep(bool break_on_operation) if (operation_requested && break_on_operation) return false; } - - transform_domain(); + // blink LED while scanning + palSetPad(GPIOC, GPIOC_LED); + if ((domain_mode & DOMAIN_MODE) == DOMAIN_TIME) + transform_domain(); return true; } -static void cmd_scan(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_scan) { uint32_t start, stop; int16_t points = sweep_points; if (argc != 2 && argc != 3) { - shell_printf(chp, "usage: scan {start(Hz)} {stop(Hz)} [points]\r\n"); + shell_printf("usage: scan {start(Hz)} {stop(Hz)} [points]\r\n"); return; } start = my_atoui(argv[0]); stop = my_atoui(argv[1]); if (start == 0 || stop == 0 || start > stop) { - shell_printf(chp, "frequency range is invalid\r\n"); + shell_printf("frequency range is invalid\r\n"); return; } if (argc == 3) { points = my_atoi(argv[2]); if (points <= 0 || points > sweep_points) { - shell_printf(chp, "sweep points exceeds range\r\n"); + shell_printf("sweep points exceeds range\r\n"); return; } } @@ -848,21 +834,18 @@ update_marker_index(void) if (!markers[m].enabled) continue; uint32_t f = markers[m].frequency; - if (f < frequencies[0]) { + uint32_t fstart = get_sweep_frequency(ST_START); + uint32_t fstop = get_sweep_frequency(ST_STOP); + if (f < fstart) { markers[m].index = 0; - markers[m].frequency = frequencies[0]; - } else if (f >= frequencies[sweep_points-1]) { + markers[m].frequency = fstart; + } else if (f >= fstop) { markers[m].index = sweep_points-1; - markers[m].frequency = frequencies[sweep_points-1]; + markers[m].frequency = fstop; } else { for (i = 0; i < sweep_points-1; i++) { if (frequencies[i] <= f && f < frequencies[i+1]) { - uint32_t mid = (frequencies[i] + frequencies[i+1])/2; - if (f < mid) { - markers[m].index = i; - } else { - markers[m].index = i + 1; - } + markers[m].index = f < (frequencies[i]/2 + frequencies[i+1]/2) ? i : i+1; break; } } @@ -1038,10 +1021,10 @@ get_sweep_frequency(int type) return 0; } -static void cmd_sweep(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_sweep) { if (argc == 0) { - shell_printf(chp, "%d %d %d\r\n", frequency0, frequency1, sweep_points); + shell_printf("%d %d %d\r\n", frequency0, frequency1, sweep_points); return; } else if (argc > 3) { goto usage; @@ -1070,8 +1053,8 @@ static void cmd_sweep(BaseSequentialStream *chp, int argc, char *argv[]) set_sweep_frequency(ST_STOP, value1); return; usage: - shell_printf(chp, "usage: sweep {start(Hz)} [stop(Hz)]\r\n"\ - "\tsweep {%s} {freq(Hz)}\r\n", sweep_cmd); + shell_printf("usage: sweep {start(Hz)} [stop(Hz)]\r\n"\ + "\tsweep {%s} {freq(Hz)}\r\n", sweep_cmd); } @@ -1282,7 +1265,6 @@ void cal_collect(int type) { ensure_edit_config(); - chMtxLock(&mutex); switch (type) { case CAL_LOAD: @@ -1312,7 +1294,6 @@ cal_collect(int type) memcpy(cal_data[CAL_ISOLN], measured[1], sizeof measured[0]); break; } - chMtxUnlock(&mutex); redraw_request |= REDRAW_CAL_STATUS; } @@ -1415,17 +1396,17 @@ cal_interpolate(int s) redraw_request |= REDRAW_CAL_STATUS; } -static void cmd_cal(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_cal) { - const char *items[] = { "load", "open", "short", "thru", "isoln", "Es", "Er", "Et", "cal'ed" }; + static const char *items[] = { "load", "open", "short", "thru", "isoln", "Es", "Er", "Et", "cal'ed" }; if (argc == 0) { int i; for (i = 0; i < 9; i++) { if (cal_status & (1< 1) ? my_atoi(argv[1]) : 0); @@ -1454,13 +1435,11 @@ static void cmd_cal(BaseSequentialStream *chp, int argc, char *argv[]) default:break; } - shell_printf(chp, "usage: cal [%s]\r\n", cmd_cal_list); + shell_printf("usage: cal [%s]\r\n", cmd_cal_list); } -static void cmd_save(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_save) { - (void)chp; - if (argc != 1) goto usage; @@ -1472,12 +1451,11 @@ static void cmd_save(BaseSequentialStream *chp, int argc, char *argv[]) return; usage: - shell_printf(chp, "save {id}\r\n"); + shell_printf("save {id}\r\n"); } -static void cmd_recall(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_recall) { - (void)chp; if (argc != 1) goto usage; @@ -1486,18 +1464,16 @@ static void cmd_recall(BaseSequentialStream *chp, int argc, char *argv[]) goto usage; pause_sweep(); - chMtxLock(&mutex); if (caldata_recall(id) == 0) { // success update_frequencies(); redraw_request |= REDRAW_CAL_STATUS; } - chMtxUnlock(&mutex); resume_sweep(); return; usage: - shell_printf(chp, "recall {id}\r\n"); + shell_printf("recall {id}\r\n"); } static const struct { @@ -1511,14 +1487,14 @@ static const struct { { "SMITH", 0, 1.00 }, { "POLAR", 0, 1.00 }, { "LINEAR", 0, 0.125}, - { "SWR", 0, 1.00 }, + { "SWR", 0, 0.25 }, { "REAL", NGRIDY/2, 0.25 }, { "IMAG", NGRIDY/2, 0.25 }, { "R", NGRIDY/2, 100.0 }, { "X", NGRIDY/2, 100.0 } }; -const char * const trc_channel_name[] = { +static const char * const trc_channel_name[] = { "CH0", "CH1" }; @@ -1538,7 +1514,10 @@ void set_trace_type(int t, int type) } if (trace[t].type != type) { trace[t].type = type; + // Set default trace refpos trace[t].refpos = trace_info[type].refpos; + // Set default trace scale + trace[t].scale = trace_info[type].scale_unit; force = TRUE; } if (force) { @@ -1557,7 +1536,6 @@ void set_trace_channel(int t, int channel) void set_trace_scale(int t, float scale) { -// scale /= trace_info[trace[t].type].scale_unit; if (trace[t].scale != scale) { trace[t].scale = scale; force_set_markmap(); @@ -1566,7 +1544,7 @@ void set_trace_scale(int t, float scale) float get_trace_scale(int t) { - return trace[t].scale;// * trace_info[trace[t].type].scale_unit; + return trace[t].scale; } void set_trace_refpos(int t, float refpos) @@ -1582,17 +1560,17 @@ float get_trace_refpos(int t) return trace[t].refpos; } -static void cmd_trace(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_trace) { int t; if (argc == 0) { for (t = 0; t < TRACES_MAX; t++) { if (trace[t].enabled) { - const char *type = trace_info[trace[t].type].name; + const char *type = get_trace_typename(t); const char *channel = trc_channel_name[trace[t].channel]; float scale = get_trace_scale(t); float refpos = get_trace_refpos(t); - shell_printf(chp, "%d %s %s %f %f\r\n", t, type, channel, scale, refpos); + shell_printf("%d %s %s %f %f\r\n", t, type, channel, scale, refpos); } } return; @@ -1611,7 +1589,7 @@ static void cmd_trace(BaseSequentialStream *chp, int argc, char *argv[]) if (argc == 1) { const char *type = get_trace_typename(t); const char *channel = trc_channel_name[trace[t].channel]; - shell_printf(chp, "%d %s %s\r\n", t, type, channel); + shell_printf("%d %s %s\r\n", t, type, channel); return; } #if MAX_TRACE_TYPE!=12 @@ -1650,8 +1628,8 @@ check_ch_num: exit: return; usage: - shell_printf(chp, "trace {0|1|2|3|all} [%s] [src]\r\n"\ - "trace {0|1|2|3} {%s} {value}\r\n", cmd_type_list, cmd_scale_ref_list); + shell_printf("trace {0|1|2|3|all} [%s] [src]\r\n"\ + "trace {0|1|2|3} {%s} {value}\r\n", cmd_type_list, cmd_scale_ref_list); } @@ -1668,10 +1646,10 @@ float get_electrical_delay(void) return electrical_delay; } -static void cmd_edelay(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_edelay) { if (argc == 0) { - shell_printf(chp, "%f\r\n", electrical_delay); + shell_printf("%f\r\n", electrical_delay); return; } if (argc > 0) { @@ -1680,13 +1658,13 @@ static void cmd_edelay(BaseSequentialStream *chp, int argc, char *argv[]) } -static void cmd_marker(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_marker) { int t; if (argc == 0) { for (t = 0; t < MARKERS_MAX; t++) { if (markers[t].enabled) { - shell_printf(chp, "%d %d %d\r\n", t+1, markers[t].index, markers[t].frequency); + shell_printf("%d %d %d\r\n", t+1, markers[t].index, markers[t].frequency); } } return; @@ -1703,7 +1681,7 @@ static void cmd_marker(BaseSequentialStream *chp, int argc, char *argv[]) if (t < 0 || t >= MARKERS_MAX) goto usage; if (argc == 1) { - shell_printf(chp, "%d %d %d\r\n", t+1, markers[t].index, frequency); + shell_printf("%d %d %d\r\n", t+1, markers[t].index, frequency); active_marker = t; // select active marker markers[t].enabled = TRUE; @@ -1725,51 +1703,44 @@ static void cmd_marker(BaseSequentialStream *chp, int argc, char *argv[]) return; } usage: - shell_printf(chp, "marker [n] [%s|{index}]\r\n", cmd_marker_list); + shell_printf("marker [n] [%s|{index}]\r\n", cmd_marker_list); } -static void cmd_touchcal(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_touchcal) { (void)argc; (void)argv; //extern int16_t touch_cal[4]; int i; - chMtxLock(&mutex); - shell_printf(chp, "first touch upper left, then lower right..."); + shell_printf("first touch upper left, then lower right..."); touch_cal_exec(); - shell_printf(chp, "done\r\n"); + shell_printf("done\r\n"); - shell_printf(chp, "touch cal params: "); + shell_printf("touch cal params: "); for (i = 0; i < 4; i++) { - shell_printf(chp, "%d ", config.touch_cal[i]); + shell_printf("%d ", config.touch_cal[i]); } - shell_printf(chp, "\r\n"); - chMtxUnlock(&mutex); + shell_printf("\r\n"); } -static void cmd_touchtest(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_touchtest) { - (void)chp; (void)argc; (void)argv; - chMtxLock(&mutex); do { touch_draw_test(); } while(argc); - chMtxUnlock(&mutex); - } -static void cmd_frequencies(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_frequencies) { int i; - (void)chp; (void)argc; (void)argv; for (i = 0; i < sweep_points; i++) { if (frequencies[i] != 0) - shell_printf(chp, "%d\r\n", frequencies[i]); + shell_printf("%d\r\n", frequencies[i]); } } @@ -1795,7 +1766,7 @@ set_timedomain_window(int func) // accept TD_WINDOW_MINIMUM/TD_WINDOW_NORMAL/TD_ domain_mode = (domain_mode & ~TD_WINDOW) | (func & TD_WINDOW); } -static void cmd_transform(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_transform) { int i; if (argc == 0) { @@ -1818,12 +1789,11 @@ static void cmd_transform(BaseSequentialStream *chp, int argc, char *argv[]) } return; usage: - shell_printf(chp, "usage: transform {%s} [...]\r\n", cmd_transform_list); + shell_printf("usage: transform {%s} [...]\r\n", cmd_transform_list); } -static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_test) { - (void)chp; (void)argc; (void)argv; @@ -1858,32 +1828,32 @@ static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) #if 0 //extern adcsample_t adc_samples[2]; - //shell_printf(chp, "adc: %d %d\r\n", adc_samples[0], adc_samples[1]); + //shell_printf("adc: %d %d\r\n", adc_samples[0], adc_samples[1]); int i; int x, y; for (i = 0; i < 50; i++) { test_touch(&x, &y); - shell_printf(chp, "adc: %d %d\r\n", x, y); + shell_printf("adc: %d %d\r\n", x, y); chThdSleepMilliseconds(200); } //extern int touch_x, touch_y; - //shell_printf(chp, "adc: %d %d\r\n", touch_x, touch_y); + //shell_printf("adc: %d %d\r\n", touch_x, touch_y); #endif while (argc > 1) { int x, y; touch_position(&x, &y); - shell_printf(chp, "touch: %d %d\r\n", x, y); + shell_printf("touch: %d %d\r\n", x, y); chThdSleepMilliseconds(200); } } -static void cmd_gain(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_gain) { int rvalue; int lvalue = 0; if (argc != 1 && argc != 2) { - shell_printf(chp, "usage: gain {lgain(0-95)} [rgain(0-95)]\r\n"); + shell_printf("usage: gain {lgain(0-95)} [rgain(0-95)]\r\n"); return; } rvalue = my_atoi(argv[0]); @@ -1892,18 +1862,18 @@ static void cmd_gain(BaseSequentialStream *chp, int argc, char *argv[]) tlv320aic3204_set_gain(lvalue, rvalue); } -static void cmd_port(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_port) { int port; if (argc != 1) { - shell_printf(chp, "usage: port {0:TX 1:RX}\r\n"); + shell_printf("usage: port {0:TX 1:RX}\r\n"); return; } port = my_atoi(argv[0]); tlv320aic3204_select(port); } -static void cmd_stat(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_stat) { int16_t *p = &rx_buffer[0]; int32_t acc0, acc1; @@ -1929,14 +1899,14 @@ static void cmd_stat(BaseSequentialStream *chp, int argc, char *argv[]) stat.ave[0] = ave0; stat.ave[1] = ave1; - shell_printf(chp, "average: %d %d\r\n", stat.ave[0], stat.ave[1]); - shell_printf(chp, "rms: %d %d\r\n", stat.rms[0], stat.rms[1]); - shell_printf(chp, "callback count: %d\r\n", stat.callback_count); - //shell_printf(chp, "interval cycle: %d\r\n", stat.interval_cycles); - //shell_printf(chp, "busy cycle: %d\r\n", stat.busy_cycles); - //shell_printf(chp, "load: %d\r\n", stat.busy_cycles * 100 / stat.interval_cycles); + shell_printf("average: %d %d\r\n", stat.ave[0], stat.ave[1]); + shell_printf("rms: %d %d\r\n", stat.rms[0], stat.rms[1]); + shell_printf("callback count: %d\r\n", stat.callback_count); + //shell_printf("interval cycle: %d\r\n", stat.interval_cycles); + //shell_printf("busy cycle: %d\r\n", stat.busy_cycles); + //shell_printf("load: %d\r\n", stat.busy_cycles * 100 / stat.interval_cycles); extern int awd_count; - shell_printf(chp, "awd: %d\r\n", awd_count); + shell_printf("awd: %d\r\n", awd_count); } @@ -1946,25 +1916,25 @@ static void cmd_stat(BaseSequentialStream *chp, int argc, char *argv[]) const char NANOVNA_VERSION[] = VERSION; -static void cmd_version(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_version) { (void)argc; (void)argv; - shell_printf(chp, "%s\r\n", NANOVNA_VERSION); + shell_printf("%s\r\n", NANOVNA_VERSION); } -static void cmd_vbat(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_vbat) { (void)argc; (void)argv; - shell_printf(chp, "%d mV\r\n", vbat); + shell_printf("%d mV\r\n", vbat); } #ifdef ENABLE_THREADS_COMMAND #if CH_CFG_USE_REGISTRY == FALSE #error "Threads Requite enabled CH_CFG_USE_REGISTRY in chconf.h" #endif -static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) { +VNA_SHELL_FUNCTION(cmd_threads) { static const char *states[] = {CH_STATE_NAMES}; thread_t *tp; (void)argc; @@ -1973,7 +1943,7 @@ static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) { tp = chRegFirstThread(); do { uint32_t stklimit = (uint32_t)tp->wabase; - shell_printf(chp, "%08x %08x %08x %4u %4u %9s %12s"VNA_SHELL_NEWLINE_STR, + shell_printf("%08x %08x %08x %4u %4u %9s %12s"VNA_SHELL_NEWLINE_STR, stklimit, (uint32_t)tp->ctx.sp, (uint32_t)tp, (uint32_t)tp->refs - 1, (uint32_t)tp->prio, states[tp->state], tp->name == NULL ? "" : tp->name); @@ -1983,68 +1953,74 @@ static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) { #endif //============================================================================= -static void cmd_help(BaseSequentialStream *chp, int argc, char *argv[]); +VNA_SHELL_FUNCTION(cmd_help); + +#pragma pack(push, 2) typedef struct { const char *sc_name; vna_shellcmd_t sc_function; + uint16_t flags; } VNAShellCommand; +#pragma pack(pop) +// Some commands can executed only if process thread not in main cycle +#define CMD_WAIT_MUTEX 1 static const VNAShellCommand commands[] = { - { "version" , cmd_version }, - { "reset" , cmd_reset }, - { "freq" , cmd_freq }, - { "offset" , cmd_offset }, - { "time" , cmd_time }, - { "dac" , cmd_dac }, - { "saveconfig" , cmd_saveconfig }, - { "clearconfig" , cmd_clearconfig }, - { "data" , cmd_data }, + {"version" , cmd_version , 0}, + {"reset" , cmd_reset , 0}, + {"freq" , cmd_freq , CMD_WAIT_MUTEX}, + {"offset" , cmd_offset , 0}, + {"time" , cmd_time , 0}, + {"dac" , cmd_dac , 0}, + {"saveconfig" , cmd_saveconfig , 0}, + {"clearconfig" , cmd_clearconfig , 0}, + {"data" , cmd_data , CMD_WAIT_MUTEX}, #ifdef ENABLED_DUMP - { "dump" , cmd_dump }, + {"dump" , cmd_dump , 0}, #endif - { "frequencies" , cmd_frequencies }, - { "port" , cmd_port }, - { "stat" , cmd_stat }, - { "gain" , cmd_gain }, - { "power" , cmd_power }, - { "sample" , cmd_sample }, -// { "gamma" , cmd_gamma }, - { "scan" , cmd_scan }, - { "sweep" , cmd_sweep }, - { "test" , cmd_test }, - { "touchcal" , cmd_touchcal }, - { "touchtest" , cmd_touchtest }, - { "pause" , cmd_pause }, - { "resume" , cmd_resume }, - { "cal" , cmd_cal }, - { "save" , cmd_save }, - { "recall" , cmd_recall }, - { "trace" , cmd_trace }, - { "marker" , cmd_marker }, - { "edelay" , cmd_edelay }, - { "capture" , cmd_capture }, - { "vbat" , cmd_vbat }, - { "transform" , cmd_transform }, - { "threshold" , cmd_threshold }, - { "help" , cmd_help }, + {"frequencies" , cmd_frequencies , 0}, + {"port" , cmd_port , 0}, + {"stat" , cmd_stat , 0}, + {"gain" , cmd_gain , 0}, + {"power" , cmd_power , 0}, + {"sample" , cmd_sample , 0}, +// {"gamma" , cmd_gamma , 0}, + {"scan" , cmd_scan , 0}, // Wait mutex hardcoded in cmd, need wait one sweep manually + {"sweep" , cmd_sweep , 0}, + {"test" , cmd_test , 0}, + {"touchcal" , cmd_touchcal , CMD_WAIT_MUTEX}, + {"touchtest" , cmd_touchtest , CMD_WAIT_MUTEX}, + {"pause" , cmd_pause , 0}, + {"resume" , cmd_resume , 0}, + {"cal" , cmd_cal , CMD_WAIT_MUTEX}, + {"save" , cmd_save , 0}, + {"recall" , cmd_recall , CMD_WAIT_MUTEX}, + {"trace" , cmd_trace , 0}, + {"marker" , cmd_marker , 0}, + {"edelay" , cmd_edelay , 0}, + {"capture" , cmd_capture , CMD_WAIT_MUTEX}, + {"vbat" , cmd_vbat , 0}, + {"transform" , cmd_transform , 0}, + {"threshold" , cmd_threshold , 0}, + {"help" , cmd_help , 0}, #ifdef ENABLE_THREADS_COMMAND - { "threads" , cmd_threads }, + {"threads" , cmd_threads , 0}, #endif - { NULL , NULL } + {NULL , NULL , 0} }; -static void cmd_help(BaseSequentialStream *chp, int argc, char *argv[]) +VNA_SHELL_FUNCTION(cmd_help) { (void)argc; (void)argv; const VNAShellCommand *scp = commands; - shell_printf(chp, "Commands:"); + shell_printf("Commands:"); while (scp->sc_name != NULL) { - shell_printf(chp, " %s", scp->sc_name); + shell_printf(" %s", scp->sc_name); scp++; } - shell_printf(chp, VNA_SHELL_NEWLINE_STR); + shell_printf(VNA_SHELL_NEWLINE_STR); return; } @@ -2067,14 +2043,14 @@ static int VNAShell_readLine(char *line, int max_size){ if (c == 8 || c == 0x7f) { if (ptr != line) { static const char backspace[] = {0x08,0x20,0x08,0x00}; - shell_printf(shell_stream, backspace); + shell_printf(backspace); ptr--; } continue; } // New line (Enter) if (c == '\r') { - shell_printf(shell_stream, VNA_SHELL_NEWLINE_STR); + shell_printf(VNA_SHELL_NEWLINE_STR); *ptr = 0; return 1; } @@ -2090,6 +2066,9 @@ static int VNAShell_readLine(char *line, int max_size){ return 0; } +// Macros for convert define value to string +#define STR1(x) #x +#define define_to_STR(x) STR1(x) // // Parse and run command line // @@ -2110,7 +2089,7 @@ static void VNAShell_executeLine(char *line){ break; // Argument limits check if (n > VNA_SHELL_MAX_ARGUMENTS) { - shell_printf(shell_stream, "too many arguments, max 4"VNA_SHELL_NEWLINE_STR); + shell_printf("too many arguments, max "define_to_STR(VNA_SHELL_MAX_ARGUMENTS)""VNA_SHELL_NEWLINE_STR); return; } // Set zero at the end of string and continue check @@ -2122,13 +2101,17 @@ static void VNAShell_executeLine(char *line){ const VNAShellCommand *scp; for (scp = commands; scp->sc_name!=NULL;scp++) { if (strcmp(scp->sc_name, args[0]) == 0) { -// chMtxLock(&mutex); - scp->sc_function(shell_stream, n-1, &args[1]); -// chMtxUnlock(&mutex); + if (scp->flags&CMD_WAIT_MUTEX) { + chMtxLock(&mutex); + scp->sc_function(n-1, &args[1]); + chMtxUnlock(&mutex); + } + else + scp->sc_function(n-1, &args[1]); return; } } - shell_printf(shell_stream, "%s?"VNA_SHELL_NEWLINE_STR, args[0]); + shell_printf("%s?"VNA_SHELL_NEWLINE_STR, args[0]); } #ifdef VNA_SHELL_THREAD @@ -2136,10 +2119,9 @@ static THD_WORKING_AREA(waThread2, /* cmd_* max stack size + alpha */442); THD_FUNCTION(myshellThread, p) { (void)p; chRegSetThreadName("shell"); - char shell_line[VNA_SHELL_MAX_LENGTH]; - shell_printf(shell_stream, VNA_SHELL_NEWLINE_STR"NanoVNA Shell"VNA_SHELL_NEWLINE_STR); + shell_printf(VNA_SHELL_NEWLINE_STR"NanoVNA Shell"VNA_SHELL_NEWLINE_STR); while (true) { - shell_printf(shell_stream, VNA_SHELL_PROMPT_STR); + shell_printf(VNA_SHELL_PROMPT_STR); if (VNAShell_readLine(shell_line, VNA_SHELL_MAX_LENGTH)) VNAShell_executeLine(shell_line); else // Putting a delay in order to avoid an endless loop trying to read an unavailable stream. @@ -2240,10 +2222,9 @@ int main(void) myshellThread, NULL); chThdWait(shelltp); #else - char shell_line[VNA_SHELL_MAX_LENGTH]; - shell_printf(shell_stream, VNA_SHELL_NEWLINE_STR"NanoVNA Shell"VNA_SHELL_NEWLINE_STR); + shell_printf(VNA_SHELL_NEWLINE_STR"NanoVNA Shell"VNA_SHELL_NEWLINE_STR); do { - shell_printf(shell_stream, VNA_SHELL_PROMPT_STR); + shell_printf(VNA_SHELL_PROMPT_STR); if (VNAShell_readLine(shell_line, VNA_SHELL_MAX_LENGTH)) VNAShell_executeLine(shell_line); else diff --git a/nanovna.h b/nanovna.h index 97522ec..b1dc275 100644 --- a/nanovna.h +++ b/nanovna.h @@ -168,6 +168,7 @@ extern int16_t area_height; extern const uint8_t x5x7_bits []; #define FONT_GET_DATA(ch) (&x5x7_bits[ch*7]) #define FONT_GET_WIDTH(ch) (8-(x5x7_bits[ch*7]&7)) +#define FONT_MAX_WIDTH 7 #define FONT_GET_HEIGHT 7 extern const uint16_t numfont16x22[]; @@ -463,6 +464,10 @@ int16_t adc_vbat_read(ADC_TypeDef *adc); /* * misclinous */ +int plot_printf(char *str, int, const char *fmt, ...); #define PULSE do { palClearPad(GPIOC, GPIOC_LED); palSetPad(GPIOC, GPIOC_LED);} while(0) +// Speed profile definition +#define START_PROFILE systime_t time = chVTGetSystemTimeX(); +#define STOP_PROFILE {char string_buf[12];plot_printf(string_buf, sizeof string_buf, "T:%06d", chVTGetSystemTimeX() - time);ili9341_drawstringV(string_buf, 1, 60);} /*EOF*/ diff --git a/plot.c b/plot.c index 0e67fbd..c909e09 100644 --- a/plot.c +++ b/plot.c @@ -5,7 +5,7 @@ #include "chprintf.h" #include "nanovna.h" -static void cell_draw_marker_info(int m, int n, int w, int h); +static void cell_draw_marker_info(int x0, int y0); int16_t grid_offset; int16_t grid_width; @@ -569,23 +569,23 @@ format_smith_value(char *buf, int len, const float coeff[2], uint32_t frequency) float value; switch (marker_smith_format) { case MS_LIN: - chsnprintf(buf, len, "%.2f %.1f" S_DEGREE, linear(coeff), phase(coeff)); + plot_printf(buf, len, "%.2f %.1f" S_DEGREE, linear(coeff), phase(coeff)); break; case MS_LOG: { float v = logmag(coeff); if (v == -INFINITY) - chsnprintf(buf, len, "-"S_INFINITY" dB"); + plot_printf(buf, len, "-"S_INFINITY" dB"); else - chsnprintf(buf, len, "%.1fdB %.1f" S_DEGREE, v, phase(coeff)); + plot_printf(buf, len, "%.1fdB %.1f" S_DEGREE, v, phase(coeff)); } break; case MS_REIM: - chsnprintf(buf, len, "%F%+Fj", coeff[0], coeff[1]); + plot_printf(buf, len, "%F%+Fj", coeff[0], coeff[1]); break; case MS_RX: - chsnprintf(buf, len, "%F"S_OHM"%+Fj", zr, zi); + plot_printf(buf, len, "%F"S_OHM"%+Fj", zr, zi); break; case MS_RLC: @@ -597,7 +597,7 @@ format_smith_value(char *buf, int len, const float coeff[2], uint32_t frequency) prefix = 'H'; value = zi / (2 * M_PI * frequency); } - chsnprintf(buf, len, "%F"S_OHM" %F%c", zr, value, prefix); + plot_printf(buf, len, "%F"S_OHM" %F%c", zr, value, prefix); break; } } @@ -650,11 +650,11 @@ trace_get_value_string(int t, char *buf, int len, float array[POINTS_COUNT][2], return; //case TRC_ADMIT: case TRC_POLAR: - chsnprintf(buf, len, "%.2f%+.2fj", coeff[0], coeff[1]); + plot_printf(buf, len, "%.2f%+.2fj", coeff[0], coeff[1]); default: return; } - chsnprintf(buf, len, format, v); + plot_printf(buf, len, format, v); } static void @@ -708,12 +708,12 @@ trace_get_value_string_delta(int t, char *buf, int len, float array[POINTS_COUNT break; //case TRC_ADMIT: case TRC_POLAR: - chsnprintf(buf, len, "%.2f%+.2fj", coeff[0], coeff[1]); + plot_printf(buf, len, "%.2f%+.2fj", coeff[0], coeff[1]); return; default: return; } - chsnprintf(buf, len, format, v); + plot_printf(buf, len, format, v); } static int @@ -723,18 +723,18 @@ trace_get_info(int t, char *buf, int len) float scale = get_trace_scale(t); switch (trace[t].type) { case TRC_LOGMAG: - return chsnprintf(buf, len, "%s %ddB/", name, (int)scale); + return plot_printf(buf, len, "%s %ddB/", name, (int)scale); case TRC_PHASE: - return chsnprintf(buf, len, "%s %d" S_DEGREE "/", name, (int)scale); + return plot_printf(buf, len, "%s %d" S_DEGREE "/", name, (int)scale); case TRC_SMITH: //case TRC_ADMIT: case TRC_POLAR: if (scale != 1.0) - return chsnprintf(buf, len, "%s %.1fFS", name, scale); + return plot_printf(buf, len, "%s %.1fFS", name, scale); else - return chsnprintf(buf, len, "%s ", name); + return plot_printf(buf, len, "%s ", name); default: - return chsnprintf(buf, len, "%s %F/", name, scale); + return plot_printf(buf, len, "%s %F/", name, scale); } return 0; } @@ -839,98 +839,37 @@ markmap_upperarea(void) invalidateRect(0, 0, AREA_WIDTH_NORMAL, 31); } -#define INSIDE 0b0000; -#define LEFT 0b0001; -#define RIGHT 0b0010; -#define BOTTOM 0b0100; -#define TOP 0b1000; - -static uint32_t -_compute_outcode(int w, int h, int x, int y) +#define SWAP(x,y) {int t=x;x=y;y=t;} +// +// in most cases _compute_outcode clip calculation not give render line speedup +// +static inline void +cell_drawline(int x0, int y0, int x1, int y1, int c) { - uint32_t code = INSIDE; - if (x < 0) { - code |= LEFT; - } else - if (x > w) { - code |= RIGHT; - } - if (y < 0) { - code |= BOTTOM; - } else - if (y > h) { - code |= TOP; - } - return code; -} + if (x0<0 && x1<0) return; + if (y0<0 && y1<0) return; + if (x0>=CELLWIDTH && x1>=CELLWIDTH )return; + if (y0>=CELLHEIGHT && y1>=CELLHEIGHT)return; -static void -cell_drawline(int w, int h, int x0, int y0, int x1, int y1, int c) -{ - uint32_t outcode1 = _compute_outcode(w, h, x0, y0); - uint32_t outcode2 = _compute_outcode(w, h, x1, y1); - if (outcode1 & outcode2) { - // this line is out of requested area. early return - return; - } - // If outcode1 == 0 && outcode2 == 0, no clipping, not need check - //outcode1+=outcode2; // modifed Bresenham's line algorithm, see https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm - int dx = x1 - x0, sx = 1; if (dx < 0) {dx = -dx; sx = -1;} + if (x1 < x0) {SWAP(x0,x1);SWAP(y0,y1);} + int dx = x1 - x0; int dy = y1 - y0, sy = 1; if (dy < 0) {dy = -dy; sy = -1;} int err = (dx > dy ? dx : -dy) / 2; while (1){ - if (//outcode1 == 0 || - (y0 >= 0 && y0 < h && x0 >= 0 && x0 < w)) - spi_buffer[y0*w+x0] |= c; + if (y0>=0 && y0=0 && x0 -dx) { err -= dy; x0 += sx; } - if (e2 < dy) { err += dx; y0 += sy; } + if (e2 > -dx) { err -= dy; x0++; } + if (e2 < dy) { err += dx; y0+=sy;} } } -#if 0 -int -search_index_range(int x, int y, uint32_t index[POINTS_COUNT], int *i0, int *i1) -{ - int i, j; - int head = 0; - int tail = sweep_points; - i = 0; - x &= 0x03e0; - y &= 0x03e0; - while (head < tail) { - i = (head + tail) / 2; - if (x < CELL_X0(index[i])) - tail = i+1; - else if (x > CELL_X0(index[i])) - head = i; - else if (y < CELL_Y0(index[i])) - tail = i+1; - else if (y > CELL_Y0(index[i])) - head = i; - else - break; - } - - if (x != CELL_X0(index[i]) || y != CELL_Y0(index[i])) - return FALSE; - - j = i; - while (j > 0 && x == CELL_X0(index[j-1]) && y == CELL_Y0(index[j-1])) - j--; - *i0 = j; - j = i; - while (j < POINTS_COUNT-1 && x == CELL_X0(index[j+1]) && y == CELL_Y0(index[j+1])) - j++; - *i1 = j; - return TRUE; -} -#endif - +// Give a little speedup then draw rectangular plot (50 systick on all calls, all render req 700 systick) +// Write more difficult algoritm for seach indexes not give speedup static int search_index_range_x(int x1, int x2, uint32_t index[POINTS_COUNT], int *i0, int *i1) { @@ -986,17 +925,17 @@ static const uint8_t reference_bitmap[]={ }; static void -draw_refpos(int w, int h, int x, int y, int c) +draw_refpos(int x, int y, int c) { int y0=y, j; for (j=0; j= h) + if (y0 < 0 || y0 >= CELLHEIGHT) continue; int x0=x; uint8_t bits = reference_bitmap[j]; while (bits){ - if (x0 >= 0 && x0 < w) - spi_buffer[y0*w+x0] = (bits&0x80) ? c : DEFAULT_BG_COLOR; + if (x0 >= 0 && x0 < CELLWIDTH) + spi_buffer[y0*CELLWIDTH+x0] = (bits&0x80) ? c : DEFAULT_BG_COLOR; x0++; bits<<=1; } @@ -1055,21 +994,21 @@ static const uint8_t marker_bitmap[]={ }; static void -draw_marker(int w, int h, int x, int y, int c, int ch) +draw_marker(int x, int y, int c, int ch) { int y0=y, j; for (j=0;j= 0 && x0 < w && y0 >= 0 && y0 < h){ + if (x0 >= 0 && x0 < CELLWIDTH && y0 >= 0 && y0 < CELLHEIGHT){ if (bits&0x80) - spi_buffer[y0*w+x0] = c; + spi_buffer[y0*CELLWIDTH+x0] = c; else if (force_color) - spi_buffer[y0*w+x0] = DEFAULT_BG_COLOR; + spi_buffer[y0*CELLWIDTH+x0] = DEFAULT_BG_COLOR; } x0++; bits<<=1; @@ -1257,6 +1196,7 @@ draw_cell(int m, int n) int x, y; int i0, i1, i; int t; + uint16_t c; // Clip cell by area if (x0 + w > area_width) w = area_width - x0; @@ -1264,62 +1204,81 @@ draw_cell(int m, int n) h = area_height - y0; if (w <= 0 || h <= 0) return; +// PULSE; - PULSE; - // Clear buffer - memset(spi_buffer, DEFAULT_BG_COLOR, sizeof spi_buffer); - uint16_t c = config.grid_color; - // Draw grid - for (t = 0; t < TRACES_MAX; t++) { - if (!trace[t].enabled) - continue; - uint32_t trace_type = (1<= CELLOFFSETX && x+x0 <= WIDTH+CELLOFFSETX) - spi_buffer[y * w + x] = c; - } + // Clear buffer ("0 : height" lines) +#if 0 + // use memset 350 system ticks for all screen calls + // as understand it use 8 bit set, slow down on 32 bit systems + memset(spi_buffer, DEFAULT_BG_COLOR, (h*CELLWIDTH)*sizeof(uint16_t)); +#else + // use direct set 35 system ticks for all screen calls +#if CELLWIDTH%8 != 0 +#error "CELLWIDTH % 8 should be == 0 for speed, or need rewrite cell cleanup" +#endif + // Set DEFAULT_BG_COLOR for 8 pixels in one cycle + int count = h*CELLWIDTH / 8; + uint32_t *p = (uint32_t *)spi_buffer; + while (count--) { + p[0] = DEFAULT_BG_COLOR|(DEFAULT_BG_COLOR<<16); + p[1] = DEFAULT_BG_COLOR|(DEFAULT_BG_COLOR<<16); + p[2] = DEFAULT_BG_COLOR|(DEFAULT_BG_COLOR<<16); + p[3] = DEFAULT_BG_COLOR|(DEFAULT_BG_COLOR<<16); + p+=4; + } +#endif + +// Draw grid +#if 1 + c = config.grid_color; + // Generate grid type list + uint32_t trace_type = 0; + for (t = 0; t < TRACES_MAX; t++) + if (trace[t].enabled) + trace_type|=(1<= CELLOFFSETX && x+x0 <= WIDTH+CELLOFFSETX) + spi_buffer[y * CELLWIDTH + x] = c; + } } + } + // Smith greed line (1000 system ticks for all screen calls) + if(trace_type&(1<=0 && x-MARKER_WIDTH=0 && y-MARKER_HEIGHT=0 && x-MARKER_WIDTH=0 && y-MARKER_HEIGHT=0 && x-REFERENCE_WIDTH=0 && x-REFERENCE_WIDTH=0 && y-REFERENCE_HEIGHT=0 && y-REFERENCE_HEIGHT= h || x <= -ch_size || x >= w) +// if (y <= -FONT_GET_HEIGHT || y >= CELLHEIGHT || x <= -ch_size || x >= CELLWIDTH) +// return ch_size; + if (x <= -ch_size) return ch_size; for(c = 0; c < FONT_GET_HEIGHT; c++) { bits = *char_buf++; - if ((y + c) < 0 || (y + c) >= h) + if ((y + c) < 0 || (y + c) >= CELLHEIGHT) continue; for (r = 0; r < ch_size; r++) { - if ((x+r) >= 0 && (x+r) < w && (0x80 & bits)) - spi_buffer[(y+c)*w + (x+r)] = foreground_color; + if ((x+r) >= 0 && (x+r) < CELLWIDTH && (0x80 & bits)) + spi_buffer[(y+c)*CELLWIDTH + (x+r)] = foreground_color; bits <<= 1; } } @@ -1471,142 +1448,136 @@ cell_drawchar(int w, int h, uint8_t ch, int x, int y) } static void -cell_drawstring(int w, int h, char *str, int x, int y) +cell_drawstring(char *str, int x, int y) { + if (y <= -FONT_GET_HEIGHT || y >= CELLHEIGHT) + return; while (*str) { - x += cell_drawchar(w, h, *str, x, y); - str++; + if (x >= CELLWIDTH) + return; + x += cell_drawchar(*str++, x, y); } } static void -cell_draw_marker_info(int m, int n, int w, int h) +cell_draw_marker_info(int x0, int y0) { char buf[32]; int t; - if (n != 0) - return; if (active_marker < 0) return; int idx = markers[active_marker].index; int j = 0; - if (active_marker != -1 && previous_marker != -1 && uistat.current_trace != -1) { + if (previous_marker != -1 && uistat.current_trace != -1) { int t = uistat.current_trace; int mk; for (mk = 0; mk < MARKERS_MAX; mk++) { if (!markers[mk].enabled) continue; - int xpos = 1 + (j%2)*146; - int ypos = 1 + (j/2)*8; - xpos -= m * CELLWIDTH - CELLOFFSETX; - ypos -= n * CELLHEIGHT; + int xpos = 1 + (j%2)*146 + CELLOFFSETX - x0; + int ypos = 1 + (j/2)*8 - y0; setForegroundColor(config.trace_color[t]); if (mk == active_marker) - cell_drawstring(w, h, S_SARROW, xpos, ypos); + cell_drawstring(S_SARROW, xpos, ypos); xpos += 5; - chsnprintf(buf, sizeof buf, "M%d", mk+1); - cell_drawstring(w, h, buf, xpos, ypos); + plot_printf(buf, sizeof buf, "M%d", mk+1); + cell_drawstring(buf, xpos, ypos); xpos += 13; //trace_get_info(t, buf, sizeof buf); uint32_t freq = frequencies[markers[mk].index]; if (uistat.marker_delta && mk != active_marker) { uint32_t freq1 = frequencies[markers[active_marker].index]; uint32_t delta = freq > freq1 ? freq - freq1 : freq1 - freq; - chsnprintf(buf, sizeof buf, S_DELTA"%.9qHz", delta); + plot_printf(buf, sizeof buf, S_DELTA"%.9qHz", delta); } else { - chsnprintf(buf, sizeof buf, "%.10qHz", freq); + plot_printf(buf, sizeof buf, "%.10qHz", freq); } - cell_drawstring(w, h, buf, xpos, ypos); + cell_drawstring(buf, xpos, ypos); xpos += 67; 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); else trace_get_value_string(t, buf, sizeof buf, measured[trace[t].channel], markers[mk].index); setForegroundColor(DEFAULT_FG_COLOR); - cell_drawstring(w, h, buf, xpos, ypos); + cell_drawstring(buf, xpos, ypos); j++; } // draw marker delta if (!uistat.marker_delta && previous_marker >= 0 && active_marker != previous_marker && markers[previous_marker].enabled) { int idx0 = markers[previous_marker].index; - int xpos = 180; - int ypos = 1 + (j/2)*8; - xpos -= m * CELLWIDTH -CELLOFFSETX; - ypos -= n * CELLHEIGHT; - chsnprintf(buf, sizeof buf, S_DELTA"%d-%d", active_marker+1, previous_marker+1); + int xpos = 180 + CELLOFFSETX - x0; + int ypos = 1 + (j/2)*8 - y0; + + plot_printf(buf, sizeof buf, S_DELTA"%d-%d", active_marker+1, previous_marker+1); setForegroundColor(DEFAULT_FG_COLOR); - cell_drawstring(w, h, buf, xpos, ypos); + cell_drawstring(buf, xpos, ypos); xpos += 24; if ((domain_mode & DOMAIN_MODE) == DOMAIN_FREQ) { uint32_t freq = frequencies[idx]; uint32_t freq1 = frequencies[idx0]; uint32_t delta = freq > freq1 ? freq - freq1 : freq1 - freq; - chsnprintf(buf, sizeof buf, "%c%.13qHz", freq >= freq1 ? '+' : '-', delta); + plot_printf(buf, sizeof buf, "%c%.13qHz", freq >= freq1 ? '+' : '-', delta); } else { - chsnprintf(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)); } - cell_drawstring(w, h, buf, xpos, ypos); + cell_drawstring(buf, xpos, ypos); } } else { for (t = 0; t < TRACES_MAX; t++) { if (!trace[t].enabled) continue; - int xpos = 1 + (j%2)*146; - int ypos = 1 + (j/2)*8; - xpos -= m * CELLWIDTH -CELLOFFSETX; - ypos -= n * CELLHEIGHT; + int xpos = 1 + (j%2)*146 + CELLOFFSETX - x0; + int ypos = 1 + (j/2)*8 - y0; + setForegroundColor(config.trace_color[t]); if (t == uistat.current_trace) - cell_drawstring(w, h, S_SARROW, xpos, ypos); + cell_drawstring(S_SARROW, xpos, ypos); xpos += 5; - chsnprintf(buf, sizeof buf, "CH%d", trace[t].channel); - cell_drawstring(w, h, buf, xpos, ypos); + plot_printf(buf, sizeof buf, "CH%d", trace[t].channel); + cell_drawstring(buf, xpos, ypos); xpos += 19; int n = trace_get_info(t, buf, sizeof buf); - cell_drawstring(w, h, buf, xpos, ypos); + cell_drawstring(buf, xpos, ypos); xpos += n * 5 + 2; //xpos += 60; trace_get_value_string(t, buf, sizeof buf, measured[trace[t].channel], idx); setForegroundColor(DEFAULT_FG_COLOR); - cell_drawstring(w, h, buf, xpos, ypos); + cell_drawstring(buf, xpos, ypos); j++; } // draw marker frequency - int xpos = 185; - int ypos = 1 + (j/2)*8; - xpos -= m * CELLWIDTH -CELLOFFSETX; - ypos -= n * CELLHEIGHT; + int xpos = 185 + CELLOFFSETX - x0; + int ypos = 1 + (j/2)*8 - y0; + setForegroundColor(DEFAULT_FG_COLOR); if (uistat.lever_mode == LM_MARKER) - cell_drawstring(w, h, S_SARROW, xpos, ypos); + cell_drawstring(S_SARROW, xpos, ypos); xpos += 5; - chsnprintf(buf, sizeof buf, "M%d:", active_marker+1); - cell_drawstring(w, h, buf, xpos, ypos); + plot_printf(buf, sizeof buf, "M%d:", active_marker+1); + cell_drawstring(buf, xpos, ypos); xpos += 19; if ((domain_mode & DOMAIN_MODE) == DOMAIN_FREQ) { - chsnprintf(buf, sizeof buf, "%qHz", frequencies[idx]); + plot_printf(buf, sizeof buf, "%qHz", frequencies[idx]); } else { - chsnprintf(buf, sizeof buf, "%Fs (%Fm)", time_of_index(idx), distance_of_index(idx)); + plot_printf(buf, sizeof buf, "%Fs (%Fm)", time_of_index(idx), distance_of_index(idx)); } - cell_drawstring(w, h, buf, xpos, ypos); + cell_drawstring(buf, xpos, ypos); } setForegroundColor(DEFAULT_FG_COLOR); if (electrical_delay != 0) { // draw electrical delay - int xpos = 21; - int ypos = 1 + ((j+1)/2)*8; - xpos -= m * CELLWIDTH -CELLOFFSETX; - ypos -= n * CELLHEIGHT; + int xpos = 21 + CELLOFFSETX - x0; + int ypos = 1 + ((j+1)/2)*8 - y0; float light_speed_ps = 299792458e-12; //(m/ps) - chsnprintf(buf, sizeof buf, "Edelay %Fs %Fm", electrical_delay * 1e-12, + plot_printf(buf, sizeof buf, "Edelay %Fs %Fm", electrical_delay * 1e-12, electrical_delay * light_speed_ps * velocity_factor); - cell_drawstring(w, h, buf, xpos, ypos); + cell_drawstring(buf, xpos, ypos); } } @@ -1617,17 +1588,17 @@ draw_frequencies(void) char buf2[32];buf2[0]=0; if ((domain_mode & DOMAIN_MODE) == DOMAIN_FREQ) { if (FREQ_IS_STARTSTOP()) { - chsnprintf(buf1, sizeof(buf1), " START %qHz", frequency0); - chsnprintf(buf2, sizeof(buf2), " STOP %qHz", frequency1); + plot_printf(buf1, sizeof(buf1), " START %qHz", frequency0); + plot_printf(buf2, sizeof(buf2), " STOP %qHz", frequency1); } else if (FREQ_IS_CENTERSPAN()) { - chsnprintf(buf1, sizeof(buf1), " CENTER %qHz", FREQ_CENTER()); - chsnprintf(buf2, sizeof(buf2), " SPAN %qHz", FREQ_SPAN()); + plot_printf(buf1, sizeof(buf1), " CENTER %qHz", FREQ_CENTER()); + plot_printf(buf2, sizeof(buf2), " SPAN %qHz", FREQ_SPAN()); } else { - chsnprintf(buf1, sizeof(buf1), " CW %qHz", frequency0); + plot_printf(buf1, sizeof(buf1), " CW %qHz", frequency0); } } else { - chsnprintf(buf1, sizeof(buf1), " START 0s"); - chsnprintf(buf2, sizeof(buf2), "STOP %Fs (%Fm)", time_of_index(POINTS_COUNT-1), distance_of_index(POINTS_COUNT-1)); + plot_printf(buf1, sizeof(buf1), " START 0s"); + plot_printf(buf2, sizeof(buf2), "STOP %Fs (%Fm)", time_of_index(POINTS_COUNT-1), distance_of_index(POINTS_COUNT-1)); } setForegroundColor(DEFAULT_FG_COLOR); setBackgroundColor(DEFAULT_BG_COLOR); @@ -1696,7 +1667,7 @@ draw_battery_status(void) // Set battery color setForegroundColor(vbat < BATTERY_WARNING_LEVEL ? DEFAULT_LOW_BAT_COLOR : DEFAULT_NORMAL_BAT_COLOR); setBackgroundColor(DEFAULT_BG_COLOR); -// chsnprintf(string_buf, sizeof string_buf, "V:%d", vbat); +// plot_printf(string_buf, sizeof string_buf, "V:%d", vbat); // ili9341_drawstringV(string_buf, 1, 60); // Prepare battery bitmap image // Battery top @@ -1713,7 +1684,7 @@ draw_battery_status(void) // string_buf[x++] = 0b10000001; string_buf[x++] = 0b11111111; // Draw battery - blit8BitWidthBitmap(0, 1, 8, x, string_buf); + blit8BitWidthBitmap(1, 1, 8, x, string_buf); } void diff --git a/ui.c b/ui.c index bd00964..01ece2d 100644 --- a/ui.c +++ b/ui.c @@ -782,7 +782,7 @@ static void menu_marker_search_cb(int item, uint8_t data) { (void)data; - int i; + int i = -1; if (active_marker == -1) return; @@ -791,23 +791,19 @@ menu_marker_search_cb(int item, uint8_t data) case 1: /* minimum */ set_marker_search(item); i = marker_search(); - if (i != -1) - markers[active_marker].index = i; break; case 2: /* search Left */ i = marker_search_left(markers[active_marker].index); - if (i != -1) - markers[active_marker].index = i; break; case 3: /* search right */ i = marker_search_right(markers[active_marker].index); - if (i != -1) - markers[active_marker].index = i; break; case 4: /* tracking */ marker_tracking = !marker_tracking; break; } + if (i != -1) + markers[active_marker].index = i; draw_menu(); redraw_marker(active_marker, TRUE); select_lever_mode(LM_SEARCH); @@ -1601,7 +1597,7 @@ static void draw_numeric_area(void) { char buf[10]; - chsnprintf(buf, sizeof buf, "%9d", uistat.value); + plot_printf(buf, sizeof buf, "%9d", uistat.value); draw_numeric_input(buf); }