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); }