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

Increase screen render (in some cases up to 2x speedup), decrease stack usage (code size less on 1500 bytes)

Browse source 
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
This commit is contained in:
DiSlord 2020-02-24 22:47:52 +03:00
parent 5ee23be06f
commit d2431f0cdc
7 changed files with 594 additions and 592 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Font5x7.c
View file

@ -11,6 +11,7 @@
#define FONT_GET_DATA(ch) (&x5x7_bits[ch*7]) #define FONT_GET_DATA(ch) (&x5x7_bits[ch*7])
#define FONT_GET_WIDTH(ch) (8-x5x7_bits[ch*7]&7) #define FONT_GET_WIDTH(ch) (8-x5x7_bits[ch*7]&7)
#define FONT_MAX_WIDTH 7
#define FONT_GET_HEIGHT 7 #define FONT_GET_HEIGHT 7
#define CHAR5x7_WIDTH_1px 0x07 #define CHAR5x7_WIDTH_1px 0x07

2
Makefile
View file

@ -70,7 +70,7 @@ endif
# Stack size to the allocated to the Cortex-M main/exceptions stack. This # Stack size to the allocated to the Cortex-M main/exceptions stack. This
# stack is used for processing interrupts and exceptions. # stack is used for processing interrupts and exceptions.
ifeq ($(USE_EXCEPTIONS_STACKSIZE),) ifeq ($(USE_EXCEPTIONS_STACKSIZE),)
USE_EXCEPTIONS_STACKSIZE = 0x180 USE_EXCEPTIONS_STACKSIZE = 0x200
endif endif
# #

124
chprintf.c
View file

@ -29,7 +29,7 @@
#include "hal.h" #include "hal.h"
#include "chprintf.h" #include "chprintf.h"
#include "memstreams.h" //#include "memstreams.h"
#include <math.h> #include <math.h>
// Enable [flags], support: // Enable [flags], support:
@ -53,7 +53,6 @@ static char smallPrefix[]= { 'm', 0x1d, 'n', 'p', 'f', 'a', 'z', 'y',
#pragma pack(pop) #pragma pack(pop)
//86066 5116 11456 102622 190de build/ch.elf
static char *long_to_string_with_divisor(char *p, static char *long_to_string_with_divisor(char *p,
uint32_t num, uint32_t num,
uint32_t radix, uint32_t radix,
@ -63,7 +62,7 @@ static char *long_to_string_with_divisor(char *p,
// convert to string from end buffer to begin // convert to string from end buffer to begin
do { do {
uint8_t c = num % radix; uint8_t c = num % radix;
num /= radix; num /= radix;
*--q = c + ((c > 9) ? ('A'-10) : '0'); *--q = c + ((c > 9) ? ('A'-10) : '0');
}while((precision && --precision) || num); }while((precision && --precision) || num);
// copy string at begin // copy string at begin
@ -103,7 +102,7 @@ static char *ulong_freq(char *p, uint32_t freq, uint32_t precision){
// freq = freq / 10; // freq = freq / 10;
uint32_t c = freq; uint32_t c = freq;
freq>>=1; freq>>=1;
freq+=freq>>1; freq+=freq>>1;
freq+=freq>>4; freq+=freq>>4;
freq+=freq>>8; freq+=freq>>8;
freq+=freq>>16; // freq = 858993459*freq/1073741824 = freq * 0,799999999813735485076904296875 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 c-= freq*10; // freq*10 = (freq*4+freq)*2 = ((freq<<2)+freq)<<1
while (c>=10) {freq++;c-=10;} while (c>=10) {freq++;c-=10;}
#endif #endif
*--q = c + '0'; *--q = c + '0';
if (freq==0) if (freq==0)
break; break;
// Add spaces, calculate prefix // Add spaces, calculate prefix
if (format&1) {*--q = ' '; s++;} if (format&1) {*--q = ' '; s++;}
format>>=1; format>>=1;
} while (1); } while (1);
s = bigPrefix[s]; s = bigPrefix[s];
@ -144,7 +143,7 @@ static char *ulong_freq(char *p, uint32_t freq, uint32_t precision){
}while (--i); }while (--i);
// Put pref (amd space before it if need) // Put pref (amd space before it if need)
if (flag&FREQ_PREFIX_SPACE && s!=' ') if (flag&FREQ_PREFIX_SPACE && s!=' ')
*p++ = ' '; *p++ = ' ';
*p++ = s; *p++ = s;
return p; return p;
} }
@ -162,9 +161,9 @@ static char *ftoa(char *p, float num, uint32_t precision) {
if (k>=multi){k-=multi;l++;} if (k>=multi){k-=multi;l++;}
p = long_to_string_with_divisor(p, l, 10, 0); p = long_to_string_with_divisor(p, l, 10, 0);
if (precision && k){ if (precision && k){
*p++ = '.'; *p++ = '.';
p=long_to_string_with_divisor(p, k, 10, precision); p=long_to_string_with_divisor(p, k, 10, precision);
// remove zeros at end // remove zeros at end
while (p[-1]=='0') p--; while (p[-1]=='0') p--;
if (p[-1]=='.') p--; if (p[-1]=='.') p--;
} }
@ -175,14 +174,14 @@ static char *ftoaS(char *p, float num, uint32_t precision) {
char prefix=0; char prefix=0;
char *ptr; char *ptr;
if (num > 1000.0){ if (num > 1000.0){
for (ptr = bigPrefix+1; *ptr && num > 1000.0; num/=1000, ptr++) for (ptr = bigPrefix+1; *ptr && num > 1000.0; num/=1000, ptr++)
; ;
prefix = ptr[-1]; prefix = ptr[-1];
} }
else if (num < 1){ else if (num < 1){
for (ptr = smallPrefix; *ptr && num < 1.0; num*=1000, ptr++) for (ptr = smallPrefix; *ptr && num < 1.0; num*=1000, ptr++)
; ;
prefix = num > 1e-3 ? ptr[-1] : 0; prefix = num > 1e-3 ? ptr[-1] : 0;
} }
// Auto set prescision // Auto set prescision
uint32_t l = num; uint32_t l = num;
@ -274,13 +273,13 @@ int chvprintf(BaseSequentialStream *chp, const char *fmt, va_list ap) {
else if (*fmt == '+') else if (*fmt == '+')
state|=POSITIVE; state|=POSITIVE;
else if (*fmt == '0') else if (*fmt == '0')
state|=PAD_ZERO; state|=PAD_ZERO;
#ifdef CHPRINTF_USE_SPACE_FLAG #ifdef CHPRINTF_USE_SPACE_FLAG
else if (*fmt == ' ') else if (*fmt == ' ')
state|=PLUS_SPACE; state|=PLUS_SPACE;
#endif #endif
else else
break; break;
fmt++; fmt++;
} }
// Get [width] - The Width field specifies a minimum number of characters to output // 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 else
state|=DEFAULT_PRESCISION; state|=DEFAULT_PRESCISION;
//Get [length] //Get [length]
/* /*
if (c == 'l' || c == 'L') { if (c == 'l' || c == 'L') {
@ -342,42 +341,42 @@ int chvprintf(BaseSequentialStream *chp, const char *fmt, va_list ap) {
if (state & IS_LONG) if (state & IS_LONG)
value.l = va_arg(ap, long); value.l = va_arg(ap, long);
else*/ else*/
value.l = va_arg(ap, uint32_t); value.l = va_arg(ap, uint32_t);
if (value.l < 0) { if (value.l < 0) {
state|=NEGATIVE; state|=NEGATIVE;
*p++ = '-'; *p++ = '-';
value.l = -value.l; value.l = -value.l;
} }
else if (state & POSITIVE) else if (state & POSITIVE)
*p++ = '+'; *p++ = '+';
#ifdef CHPRINTF_USE_SPACE_FLAG #ifdef CHPRINTF_USE_SPACE_FLAG
else if (state & PLUS_SPACE) else if (state & PLUS_SPACE)
*p++ = ' '; *p++ = ' ';
#endif #endif
p = long_to_string_with_divisor(p, value.l, 10, 0); p = long_to_string_with_divisor(p, value.l, 10, 0);
break; break;
case 'q': case 'q':
value.u = va_arg(ap, uint32_t); value.u = va_arg(ap, uint32_t);
p=ulong_freq(p, value.u, precision); p=ulong_freq(p, value.u, precision);
break; break;
#if CHPRINTF_USE_FLOAT #if CHPRINTF_USE_FLOAT
case 'F': case 'F':
case 'f': case 'f':
value.f = va_arg(ap, double); value.f = va_arg(ap, double);
if (value.f < 0) { if (value.f < 0) {
state|=NEGATIVE; state|=NEGATIVE;
*p++ = '-'; *p++ = '-';
value.f = -value.f; value.f = -value.f;
} }
else if (state & POSITIVE) else if (state & POSITIVE)
*p++ = '+'; *p++ = '+';
#ifdef CHPRINTF_USE_SPACE_FLAG #ifdef CHPRINTF_USE_SPACE_FLAG
else if (state & PLUS_SPACE) else if (state & PLUS_SPACE)
*p++ = ' '; *p++ = ' ';
#endif #endif
if (value.f == INFINITY){ if (value.f == INFINITY){
*p++ = 0x19; *p++ = 0x19;
break; break;
} }
p = (c=='F') ? ftoaS(p, value.f, precision) : ftoa(p, value.f, state&DEFAULT_PRESCISION ? FLOAT_PRECISION : precision); p = (c=='F') ? ftoaS(p, value.f, precision) : ftoa(p, value.f, state&DEFAULT_PRESCISION ? FLOAT_PRECISION : precision);
break; break;
@ -422,7 +421,7 @@ unsigned_common:/*
while (width){ while (width){
streamPut(chp, (uint8_t)filler); streamPut(chp, (uint8_t)filler);
n++; n++;
width--; width--;
} }
} }
// put data // put data
@ -462,6 +461,7 @@ unsigned_common:/*
* *
* @api * @api
*/ */
#if 0
int chprintf(BaseSequentialStream *chp, const char *fmt, ...) { int chprintf(BaseSequentialStream *chp, const char *fmt, ...) {
va_list ap; va_list ap;
int formatted_bytes; int formatted_bytes;
@ -472,7 +472,7 @@ int chprintf(BaseSequentialStream *chp, const char *fmt, ...) {
return formatted_bytes; return formatted_bytes;
} }
#endif
/** /**
* @brief System formatted output function. * @brief System formatted output function.
* @details This function implements a minimal @p vprintf()-like functionality * @details This function implements a minimal @p vprintf()-like functionality
@ -501,6 +501,7 @@ int chprintf(BaseSequentialStream *chp, const char *fmt, ...) {
* *
* @api * @api
*/ */
#if 0
int chsnprintf(char *str, size_t size, const char *fmt, ...) { int chsnprintf(char *str, size_t size, const char *fmt, ...) {
va_list ap; va_list ap;
MemoryStream ms; 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 number of bytes that would have been written.*/
return retval; 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;
}
/** @} */ /** @} */

579
main.c
View file

File diff suppressed because it is too large Load diff

5
nanovna.h
View file

@ -168,6 +168,7 @@ extern int16_t area_height;
extern const uint8_t x5x7_bits []; extern const uint8_t x5x7_bits [];
#define FONT_GET_DATA(ch) (&x5x7_bits[ch*7]) #define FONT_GET_DATA(ch) (&x5x7_bits[ch*7])
#define FONT_GET_WIDTH(ch) (8-(x5x7_bits[ch*7]&7)) #define FONT_GET_WIDTH(ch) (8-(x5x7_bits[ch*7]&7))
#define FONT_MAX_WIDTH 7
#define FONT_GET_HEIGHT 7 #define FONT_GET_HEIGHT 7
extern const uint16_t numfont16x22[]; extern const uint16_t numfont16x22[];
@ -463,6 +464,10 @@ int16_t adc_vbat_read(ADC_TypeDef *adc);
/* /*
* misclinous * misclinous
*/ */
int plot_printf(char *str, int, const char *fmt, ...);
#define PULSE do { palClearPad(GPIOC, GPIOC_LED); palSetPad(GPIOC, GPIOC_LED);} while(0) #define PULSE do { palClearPad(GPIOC, GPIOC_LED); palSetPad(GPIOC, GPIOC_LED);} while(0)
// 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*/ /*EOF*/

463
plot.c
View file

@ -5,7 +5,7 @@
#include "chprintf.h" #include "chprintf.h"
#include "nanovna.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_offset;
int16_t grid_width; int16_t grid_width;
@ -569,23 +569,23 @@ format_smith_value(char *buf, int len, const float coeff[2], uint32_t frequency)
float value; float value;
switch (marker_smith_format) { switch (marker_smith_format) {
case MS_LIN: 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; break;
case MS_LOG: { case MS_LOG: {
float v = logmag(coeff); float v = logmag(coeff);
if (v == -INFINITY) if (v == -INFINITY)
chsnprintf(buf, len, "-"S_INFINITY" dB"); plot_printf(buf, len, "-"S_INFINITY" dB");
else else
chsnprintf(buf, len, "%.1fdB %.1f" S_DEGREE, v, phase(coeff)); plot_printf(buf, len, "%.1fdB %.1f" S_DEGREE, v, phase(coeff));
} }
break; break;
case MS_REIM: case MS_REIM:
chsnprintf(buf, len, "%F%+Fj", coeff[0], coeff[1]); plot_printf(buf, len, "%F%+Fj", coeff[0], coeff[1]);
break; break;
case MS_RX: case MS_RX:
chsnprintf(buf, len, "%F"S_OHM"%+Fj", zr, zi); plot_printf(buf, len, "%F"S_OHM"%+Fj", zr, zi);
break; break;
case MS_RLC: case MS_RLC:
@ -597,7 +597,7 @@ format_smith_value(char *buf, int len, const float coeff[2], uint32_t frequency)
prefix = 'H'; prefix = 'H';
value = zi / (2 * M_PI * frequency); 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; break;
} }
} }
@ -650,11 +650,11 @@ trace_get_value_string(int t, char *buf, int len, float array[POINTS_COUNT][2],
return; return;
//case TRC_ADMIT: //case TRC_ADMIT:
case TRC_POLAR: case TRC_POLAR:
chsnprintf(buf, len, "%.2f%+.2fj", coeff[0], coeff[1]); plot_printf(buf, len, "%.2f%+.2fj", coeff[0], coeff[1]);
default: default:
return; return;
} }
chsnprintf(buf, len, format, v); plot_printf(buf, len, format, v);
} }
static void static void
@ -708,12 +708,12 @@ trace_get_value_string_delta(int t, char *buf, int len, float array[POINTS_COUNT
break; break;
//case TRC_ADMIT: //case TRC_ADMIT:
case TRC_POLAR: case TRC_POLAR:
chsnprintf(buf, len, "%.2f%+.2fj", coeff[0], coeff[1]); plot_printf(buf, len, "%.2f%+.2fj", coeff[0], coeff[1]);
return; return;
default: default:
return; return;
} }
chsnprintf(buf, len, format, v); plot_printf(buf, len, format, v);
} }
static int static int
@ -723,18 +723,18 @@ trace_get_info(int t, char *buf, int len)
float scale = get_trace_scale(t); float scale = get_trace_scale(t);
switch (trace[t].type) { switch (trace[t].type) {
case TRC_LOGMAG: 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: 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_SMITH:
//case TRC_ADMIT: //case TRC_ADMIT:
case TRC_POLAR: case TRC_POLAR:
if (scale != 1.0) if (scale != 1.0)
return chsnprintf(buf, len, "%s %.1fFS", name, scale); return plot_printf(buf, len, "%s %.1fFS", name, scale);
else else
return chsnprintf(buf, len, "%s ", name); return plot_printf(buf, len, "%s ", name);
default: default:
return chsnprintf(buf, len, "%s %F/", name, scale); return plot_printf(buf, len, "%s %F/", name, scale);
} }
return 0; return 0;
} }
@ -839,98 +839,37 @@ markmap_upperarea(void)
invalidateRect(0, 0, AREA_WIDTH_NORMAL, 31); invalidateRect(0, 0, AREA_WIDTH_NORMAL, 31);
} }
#define INSIDE 0b0000; #define SWAP(x,y) {int t=x;x=y;y=t;}
#define LEFT 0b0001; //
#define RIGHT 0b0010; // in most cases _compute_outcode clip calculation not give render line speedup
#define BOTTOM 0b0100; //
#define TOP 0b1000; static inline void
cell_drawline(int x0, int y0, int x1, int y1, int c)
static uint32_t
_compute_outcode(int w, int h, int x, int y)
{ {
uint32_t code = INSIDE; if (x0<0 && x1<0) return;
if (x < 0) { if (y0<0 && y1<0) return;
code |= LEFT; if (x0>=CELLWIDTH && x1>=CELLWIDTH )return;
} else if (y0>=CELLHEIGHT && y1>=CELLHEIGHT)return;
if (x > w) {
code |= RIGHT;
}
if (y < 0) {
code |= BOTTOM;
} else
if (y > h) {
code |= TOP;
}
return code;
}
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 // 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 dy = y1 - y0, sy = 1; if (dy < 0) {dy = -dy; sy = -1;}
int err = (dx > dy ? dx : -dy) / 2; int err = (dx > dy ? dx : -dy) / 2;
while (1){ while (1){
if (//outcode1 == 0 || if (y0>=0 && y0<CELLHEIGHT && x0>=0 && x0<CELLWIDTH)
(y0 >= 0 && y0 < h && x0 >= 0 && x0 < w)) spi_buffer[y0*CELLWIDTH+x0]|= c;
spi_buffer[y0*w+x0] |= c;
if (x0 == x1 && y0 == y1) if (x0 == x1 && y0 == y1)
break; return;
int e2 = err; int e2 = err;
if (e2 > -dx) { err -= dy; x0 += sx; } if (e2 > -dx) { err -= dy; x0++; }
if (e2 < dy) { err += dx; y0 += sy; } if (e2 < dy) { err += dx; y0+=sy;}
} }
} }
#if 0 // Give a little speedup then draw rectangular plot (50 systick on all calls, all render req 700 systick)
int // Write more difficult algoritm for seach indexes not give speedup
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
static int static int
search_index_range_x(int x1, int x2, uint32_t index[POINTS_COUNT], int *i0, int *i1) 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 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; int y0=y, j;
for (j=0; j<REFERENCE_HEIGHT; j++, y0++){ for (j=0; j<REFERENCE_HEIGHT; j++, y0++){
if (y0 < 0 || y0 >= h) if (y0 < 0 || y0 >= CELLHEIGHT)
continue; continue;
int x0=x; int x0=x;
uint8_t bits = reference_bitmap[j]; uint8_t bits = reference_bitmap[j];
while (bits){ while (bits){
if (x0 >= 0 && x0 < w) if (x0 >= 0 && x0 < CELLWIDTH)
spi_buffer[y0*w+x0] = (bits&0x80) ? c : DEFAULT_BG_COLOR; spi_buffer[y0*CELLWIDTH+x0] = (bits&0x80) ? c : DEFAULT_BG_COLOR;
x0++; x0++;
bits<<=1; bits<<=1;
} }
@ -1055,21 +994,21 @@ static const uint8_t marker_bitmap[]={
}; };
static void 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; int y0=y, j;
for (j=0;j<MARKER_HEIGHT;j++,y0++){ for (j=0;j<MARKER_HEIGHT;j++,y0++){
int x0=x; int x0=x;
uint8_t bits = marker_bitmap[ch*10+j]; uint8_t bits = marker_bitmap[ch*MARKER_HEIGHT+j];
bool force_color = false; bool force_color = false;
while (bits){ while (bits){
if (bits&0x80) if (bits&0x80)
force_color = true; force_color = true;
if (x0 >= 0 && x0 < w && y0 >= 0 && y0 < h){ if (x0 >= 0 && x0 < CELLWIDTH && y0 >= 0 && y0 < CELLHEIGHT){
if (bits&0x80) if (bits&0x80)
spi_buffer[y0*w+x0] = c; spi_buffer[y0*CELLWIDTH+x0] = c;
else if (force_color) else if (force_color)
spi_buffer[y0*w+x0] = DEFAULT_BG_COLOR; spi_buffer[y0*CELLWIDTH+x0] = DEFAULT_BG_COLOR;
} }
x0++; x0++;
bits<<=1; bits<<=1;
@ -1257,6 +1196,7 @@ draw_cell(int m, int n)
int x, y; int x, y;
int i0, i1, i; int i0, i1, i;
int t; int t;
uint16_t c;
// Clip cell by area // Clip cell by area
if (x0 + w > area_width) if (x0 + w > area_width)
w = area_width - x0; w = area_width - x0;
@ -1264,62 +1204,81 @@ draw_cell(int m, int n)
h = area_height - y0; h = area_height - y0;
if (w <= 0 || h <= 0) if (w <= 0 || h <= 0)
return; return;
// PULSE;
PULSE; // Clear buffer ("0 : height" lines)
// 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<<trace[t].type);
// Draw rectangular plot
if (trace_type&RECTANGULAR_GRID_MASK){
for (x = 0; x < w; x++) {
if (rectangular_grid_x(x+x0)){
for (y = 0; y < h; y++)
spi_buffer[y * w + x] = c;
}
}
for (y = 0; y < h; y++) {
if (rectangular_grid_y(y+y0)){
for (x = 0; x < w; x++)
if (x+x0 >= CELLOFFSETX && x+x0 <= WIDTH+CELLOFFSETX)
spi_buffer[y * w + x] = c;
}
}
continue;
}
if(trace_type&(1<<TRC_SMITH)){
for (y = 0; y < h; y++)
for (x = 0; x < w; x++)
if (smith_grid(x+x0, y+y0))
spi_buffer[y * w + x] = c;
continue;
}
if(trace_type&(1<<TRC_POLAR)){
for (y = 0; y < h; y++)
for (x = 0; x < w; x++)
if (polar_grid(x+x0, y+y0))
spi_buffer[y * w + x] = c;
continue;
}
#if 0 #if 0
if(trace_type&(1<<TRC_ADMIT)){ // use memset 350 system ticks for all screen calls
for (y = 0; y < h; y++) // as understand it use 8 bit set, slow down on 32 bit systems
for (x = 0; x < w; x++) memset(spi_buffer, DEFAULT_BG_COLOR, (h*CELLWIDTH)*sizeof(uint16_t));
if (smith_grid3(x+x0, y+y0) #else
// smith_grid2(x+x0, y+y0, 0.5)) // use direct set 35 system ticks for all screen calls
spi_buffer[y * w + x] = c; #if CELLWIDTH%8 != 0
continue; #error "CELLWIDTH % 8 should be == 0 for speed, or need rewrite cell cleanup"
}
#endif #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;
} }
PULSE; #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<<trace[t].type);
// Draw rectangular plot (40 system ticks for all screen calls)
if (trace_type&RECTANGULAR_GRID_MASK){
for (x = 0; x < w; x++) {
if (rectangular_grid_x(x+x0)){
for (y = 0; y < h; y++)
spi_buffer[y * CELLWIDTH + x] = c;
}
}
for (y = 0; y < h; y++) {
if (rectangular_grid_y(y+y0)){
for (x = 0; x < w; x++)
if (x+x0 >= 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<<TRC_SMITH)){
for (y = 0; y < h; y++)
for (x = 0; x < w; x++)
if (smith_grid(x+x0, y+y0))
spi_buffer[y * CELLWIDTH + x] = c;
}
// Polar greed line (800 system ticks for all screen calls)
else if(trace_type&(1<<TRC_POLAR)){
for (y = 0; y < h; y++)
for (x = 0; x < w; x++)
if (polar_grid(x+x0, y+y0))
spi_buffer[y * CELLWIDTH + x] = c;
}
#if 0
else if(trace_type&(1<<TRC_ADMIT)){
for (y = 0; y < h; y++)
for (x = 0; x < w; x++)
if (smith_grid3(x+x0, y+y0)
// smith_grid2(x+x0, y+y0, 0.5))
spi_buffer[y * CELLWIDTH + x] = c;
}
#endif
#endif
// PULSE;
// Draw traces (50-600 system ticks for all screen calls, depend from lines count and size)
#if 1 #if 1
// Draw traces
for (t = 0; t < TRACES_MAX; t++) { for (t = 0; t < TRACES_MAX; t++) {
if (!trace[t].enabled) if (!trace[t].enabled)
continue; continue;
@ -1329,19 +1288,24 @@ draw_cell(int m, int n)
uint32_t trace_type = (1<<trace[t].type); uint32_t trace_type = (1<<trace[t].type);
if (trace_type & ((1<<TRC_SMITH)|(1<<TRC_POLAR))) if (trace_type & ((1<<TRC_SMITH)|(1<<TRC_POLAR)))
i1 = sweep_points-1; i1 = sweep_points-1;
else // draw rectangular plot (search index range in cell) else // draw rectangular plot (search index range in cell, save 50-70 system ticks for all screen calls)
search_index_range_x(x0, x0+w, trace_index[t], &i0, &i1); search_index_range_x(x0, x0+w, trace_index[t], &i0, &i1);
uint32_t *index = trace_index[t];
for (i=i0; i < i1; i++) { for (i=i0; i < i1; i++) {
int x1 = CELL_X(trace_index[t][i ]) - x0; int x1 = CELL_X(index[i ]) - x0;
int y1 = CELL_Y(trace_index[t][i ]) - y0; int y1 = CELL_Y(index[i ]) - y0;
int x2 = CELL_X(trace_index[t][i+1]) - x0; int x2 = CELL_X(index[i+1]) - x0;
int y2 = CELL_Y(trace_index[t][i+1]) - y0; int y2 = CELL_Y(index[i+1]) - y0;
cell_drawline(w, h, x1, y1, x2, y2, c); cell_drawline(x1, y1, x2, y2, c);
} }
} }
#else
for (x=0;x<area_width;x+=6)
cell_drawline(x-x0, 0-y0, area_width-x-x0, area_height-y0, config.trace_color[0]);
#endif #endif
PULSE; // PULSE;
//draw marker symbols on each trace //draw marker symbols on each trace (<10 system ticks for all screen calls)
#if 1
for (i = 0; i < MARKERS_MAX; i++) { for (i = 0; i < MARKERS_MAX; i++) {
if (!markers[i].enabled) if (!markers[i].enabled)
continue; continue;
@ -1352,17 +1316,18 @@ draw_cell(int m, int n)
int x = CELL_X(index) - x0 - X_MARKER_OFFSET; int x = CELL_X(index) - x0 - X_MARKER_OFFSET;
int y = CELL_Y(index) - y0 - Y_MARKER_OFFSET; int y = CELL_Y(index) - y0 - Y_MARKER_OFFSET;
// Check marker icon on cell // Check marker icon on cell
if (x+MARKER_WIDTH>=0 && x-MARKER_WIDTH<w && y+MARKER_HEIGHT>=0 && y-MARKER_HEIGHT<h) if (x+MARKER_WIDTH>=0 && x-MARKER_WIDTH<CELLWIDTH && y+MARKER_HEIGHT>=0 && y-MARKER_HEIGHT<CELLHEIGHT)
draw_marker(w, h, x, y, config.trace_color[t], i); draw_marker(x, y, config.trace_color[t], i);
} }
} }
// Draw trace and marker info on the top #endif
// Draw trace and marker info on the top (50 system ticks for all screen calls)
#if 1
if (n == 0) if (n == 0)
cell_draw_marker_info(m, n, w, h); cell_draw_marker_info(x0, y0);
#endif
PULSE; // PULSE;
// Draw reference position (<10 system ticks for all screen calls)
// Draw refrence position
for (t = 0; t < TRACES_MAX; t++) { for (t = 0; t < TRACES_MAX; t++) {
if (!trace[t].enabled) if (!trace[t].enabled)
continue; continue;
@ -1370,20 +1335,30 @@ draw_cell(int m, int n)
if (trace_type&((1<<TRC_SMITH)|(1<<TRC_POLAR))) if (trace_type&((1<<TRC_SMITH)|(1<<TRC_POLAR)))
continue; continue;
int x = 0 - x0 + CELLOFFSETX - REFERENCE_X_OFFSET; int x = 0 - x0 + CELLOFFSETX - REFERENCE_X_OFFSET;
if (x+REFERENCE_WIDTH>=0 && x-REFERENCE_WIDTH<w){ if (x+REFERENCE_WIDTH>=0 && x-REFERENCE_WIDTH<CELLWIDTH){
int y = HEIGHT - floatToInt((get_trace_refpos(t) * GRIDY)) - y0 - REFERENCE_Y_OFFSET; int y = HEIGHT - floatToInt((get_trace_refpos(t) * GRIDY)) - y0 - REFERENCE_Y_OFFSET;
if (y+REFERENCE_HEIGHT>=0 && y-REFERENCE_HEIGHT<h) if (y+REFERENCE_HEIGHT>=0 && y-REFERENCE_HEIGHT<CELLHEIGHT)
draw_refpos(w, h, x, y, config.trace_color[t]); draw_refpos(x, y, config.trace_color[t]);
} }
} }
// Draw cell // Need right clip cell render (25 system ticks for all screen calls)
#if 1
if (w < CELLWIDTH){
uint16_t *src = spi_buffer+CELLWIDTH;
uint16_t *dst = spi_buffer+w;
for (y=h; --y; src+=CELLWIDTH-w)
for(x=w;x--;)
*dst++=*src++;
}
#endif
// Draw cell (500 system ticks for all screen calls)
ili9341_bulk(OFFSETX + x0, OFFSETY + y0, w, h); ili9341_bulk(OFFSETX + x0, OFFSETY + y0, w, h);
} }
static void static void
draw_all_cells(bool flush_markmap) draw_all_cells(bool flush_markmap){
{
int m, n; int m, n;
// START_PROFILE
for (m = 0; m < (area_width+CELLWIDTH-1) / CELLWIDTH; m++) for (m = 0; m < (area_width+CELLWIDTH-1) / CELLWIDTH; m++)
for (n = 0; n < (area_height+CELLHEIGHT-1) / CELLHEIGHT; n++) { for (n = 0; n < (area_height+CELLHEIGHT-1) / CELLHEIGHT; n++) {
uint16_t bit = 1<<m; uint16_t bit = 1<<m;
@ -1391,10 +1366,10 @@ draw_all_cells(bool flush_markmap)
draw_cell(m, n); draw_cell(m, n);
// ili9341_fill(m*CELLWIDTH+10, n*CELLHEIGHT, 2, 2, RGB565(255,0,0)); // ili9341_fill(m*CELLWIDTH+10, n*CELLHEIGHT, 2, 2, RGB565(255,0,0));
} }
// else // else
// ili9341_fill(m*CELLWIDTH+10, n*CELLHEIGHT, 2, 2, RGB565(0,255,0)); // ili9341_fill(m*CELLWIDTH+10, n*CELLHEIGHT, 2, 2, RGB565(0,255,0));
} }
// STOP_PROFILE
if (flush_markmap) { if (flush_markmap) {
// keep current map for update // keep current map for update
swap_markmap(); swap_markmap();
@ -1449,21 +1424,23 @@ request_to_draw_cells_behind_numeric_input(void)
} }
static int static int
cell_drawchar(int w, int h, uint8_t ch, int x, int y) cell_drawchar(uint8_t ch, int x, int y)
{ {
uint8_t bits; uint8_t bits;
int c, r, ch_size; int c, r, ch_size;
const uint8_t *char_buf = FONT_GET_DATA(ch); const uint8_t *char_buf = FONT_GET_DATA(ch);
ch_size=FONT_GET_WIDTH(ch); ch_size=FONT_GET_WIDTH(ch);
if (y <= -FONT_GET_HEIGHT || y >= 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; return ch_size;
for(c = 0; c < FONT_GET_HEIGHT; c++) { for(c = 0; c < FONT_GET_HEIGHT; c++) {
bits = *char_buf++; bits = *char_buf++;
if ((y + c) < 0 || (y + c) >= h) if ((y + c) < 0 || (y + c) >= CELLHEIGHT)
continue; continue;
for (r = 0; r < ch_size; r++) { for (r = 0; r < ch_size; r++) {
if ((x+r) >= 0 && (x+r) < w && (0x80 & bits)) if ((x+r) >= 0 && (x+r) < CELLWIDTH && (0x80 & bits))
spi_buffer[(y+c)*w + (x+r)] = foreground_color; spi_buffer[(y+c)*CELLWIDTH + (x+r)] = foreground_color;
bits <<= 1; bits <<= 1;
} }
} }
@ -1471,142 +1448,136 @@ cell_drawchar(int w, int h, uint8_t ch, int x, int y)
} }
static void 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) { while (*str) {
x += cell_drawchar(w, h, *str, x, y); if (x >= CELLWIDTH)
str++; return;
x += cell_drawchar(*str++, x, y);
} }
} }
static void 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]; char buf[32];
int t; int t;
if (n != 0)
return;
if (active_marker < 0) if (active_marker < 0)
return; return;
int idx = markers[active_marker].index; int idx = markers[active_marker].index;
int j = 0; 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 t = uistat.current_trace;
int mk; int mk;
for (mk = 0; mk < MARKERS_MAX; mk++) { for (mk = 0; mk < MARKERS_MAX; mk++) {
if (!markers[mk].enabled) if (!markers[mk].enabled)
continue; continue;
int xpos = 1 + (j%2)*146; int xpos = 1 + (j%2)*146 + CELLOFFSETX - x0;
int ypos = 1 + (j/2)*8; int ypos = 1 + (j/2)*8 - y0;
xpos -= m * CELLWIDTH - CELLOFFSETX;
ypos -= n * CELLHEIGHT;
setForegroundColor(config.trace_color[t]); setForegroundColor(config.trace_color[t]);
if (mk == active_marker) if (mk == active_marker)
cell_drawstring(w, h, S_SARROW, xpos, ypos); cell_drawstring(S_SARROW, xpos, ypos);
xpos += 5; xpos += 5;
chsnprintf(buf, sizeof buf, "M%d", mk+1); plot_printf(buf, sizeof buf, "M%d", mk+1);
cell_drawstring(w, h, buf, xpos, ypos); cell_drawstring(buf, xpos, ypos);
xpos += 13; xpos += 13;
//trace_get_info(t, buf, sizeof buf); //trace_get_info(t, buf, sizeof buf);
uint32_t freq = frequencies[markers[mk].index]; uint32_t freq = frequencies[markers[mk].index];
if (uistat.marker_delta && mk != active_marker) { if (uistat.marker_delta && mk != active_marker) {
uint32_t freq1 = frequencies[markers[active_marker].index]; uint32_t freq1 = frequencies[markers[active_marker].index];
uint32_t delta = freq > freq1 ? freq - freq1 : freq1 - freq; 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 { } 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; xpos += 67;
if (uistat.marker_delta && mk != active_marker) if (uistat.marker_delta && mk != active_marker)
trace_get_value_string_delta(t, buf, sizeof buf, measured[trace[t].channel], markers[mk].index, markers[active_marker].index); trace_get_value_string_delta(t, buf, sizeof buf, measured[trace[t].channel], markers[mk].index, markers[active_marker].index);
else else
trace_get_value_string(t, buf, sizeof buf, measured[trace[t].channel], markers[mk].index); trace_get_value_string(t, buf, sizeof buf, measured[trace[t].channel], markers[mk].index);
setForegroundColor(DEFAULT_FG_COLOR); setForegroundColor(DEFAULT_FG_COLOR);
cell_drawstring(w, h, buf, xpos, ypos); cell_drawstring(buf, xpos, ypos);
j++; j++;
} }
// draw marker delta // draw marker delta
if (!uistat.marker_delta && previous_marker >= 0 && active_marker != previous_marker && markers[previous_marker].enabled) { if (!uistat.marker_delta && previous_marker >= 0 && active_marker != previous_marker && markers[previous_marker].enabled) {
int idx0 = markers[previous_marker].index; int idx0 = markers[previous_marker].index;
int xpos = 180; int xpos = 180 + CELLOFFSETX - x0;
int ypos = 1 + (j/2)*8; int ypos = 1 + (j/2)*8 - y0;
xpos -= m * CELLWIDTH -CELLOFFSETX;
ypos -= n * CELLHEIGHT; plot_printf(buf, sizeof buf, S_DELTA"%d-%d", active_marker+1, previous_marker+1);
chsnprintf(buf, sizeof buf, S_DELTA"%d-%d", active_marker+1, previous_marker+1);
setForegroundColor(DEFAULT_FG_COLOR); setForegroundColor(DEFAULT_FG_COLOR);
cell_drawstring(w, h, buf, xpos, ypos); cell_drawstring(buf, xpos, ypos);
xpos += 24; xpos += 24;
if ((domain_mode & DOMAIN_MODE) == DOMAIN_FREQ) { if ((domain_mode & DOMAIN_MODE) == DOMAIN_FREQ) {
uint32_t freq = frequencies[idx]; uint32_t freq = frequencies[idx];
uint32_t freq1 = frequencies[idx0]; uint32_t freq1 = frequencies[idx0];
uint32_t delta = freq > freq1 ? freq - freq1 : freq1 - freq; 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 { } 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 { } else {
for (t = 0; t < TRACES_MAX; t++) { for (t = 0; t < TRACES_MAX; t++) {
if (!trace[t].enabled) if (!trace[t].enabled)
continue; continue;
int xpos = 1 + (j%2)*146; int xpos = 1 + (j%2)*146 + CELLOFFSETX - x0;
int ypos = 1 + (j/2)*8; int ypos = 1 + (j/2)*8 - y0;
xpos -= m * CELLWIDTH -CELLOFFSETX;
ypos -= n * CELLHEIGHT;
setForegroundColor(config.trace_color[t]); setForegroundColor(config.trace_color[t]);
if (t == uistat.current_trace) if (t == uistat.current_trace)
cell_drawstring(w, h, S_SARROW, xpos, ypos); cell_drawstring(S_SARROW, xpos, ypos);
xpos += 5; xpos += 5;
chsnprintf(buf, sizeof buf, "CH%d", trace[t].channel); plot_printf(buf, sizeof buf, "CH%d", trace[t].channel);
cell_drawstring(w, h, buf, xpos, ypos); cell_drawstring(buf, xpos, ypos);
xpos += 19; xpos += 19;
int n = trace_get_info(t, buf, sizeof buf); 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 += n * 5 + 2;
//xpos += 60; //xpos += 60;
trace_get_value_string(t, buf, sizeof buf, measured[trace[t].channel], idx); trace_get_value_string(t, buf, sizeof buf, measured[trace[t].channel], idx);
setForegroundColor(DEFAULT_FG_COLOR); setForegroundColor(DEFAULT_FG_COLOR);
cell_drawstring(w, h, buf, xpos, ypos); cell_drawstring(buf, xpos, ypos);
j++; j++;
} }
// draw marker frequency // draw marker frequency
int xpos = 185; int xpos = 185 + CELLOFFSETX - x0;
int ypos = 1 + (j/2)*8; int ypos = 1 + (j/2)*8 - y0;
xpos -= m * CELLWIDTH -CELLOFFSETX;
ypos -= n * CELLHEIGHT;
setForegroundColor(DEFAULT_FG_COLOR); setForegroundColor(DEFAULT_FG_COLOR);
if (uistat.lever_mode == LM_MARKER) if (uistat.lever_mode == LM_MARKER)
cell_drawstring(w, h, S_SARROW, xpos, ypos); cell_drawstring(S_SARROW, xpos, ypos);
xpos += 5; xpos += 5;
chsnprintf(buf, sizeof buf, "M%d:", active_marker+1); plot_printf(buf, sizeof buf, "M%d:", active_marker+1);
cell_drawstring(w, h, buf, xpos, ypos); cell_drawstring(buf, xpos, ypos);
xpos += 19; xpos += 19;
if ((domain_mode & DOMAIN_MODE) == DOMAIN_FREQ) { if ((domain_mode & DOMAIN_MODE) == DOMAIN_FREQ) {
chsnprintf(buf, sizeof buf, "%qHz", frequencies[idx]); plot_printf(buf, sizeof buf, "%qHz", frequencies[idx]);
} else { } 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); setForegroundColor(DEFAULT_FG_COLOR);
if (electrical_delay != 0) { if (electrical_delay != 0) {
// draw electrical delay // draw electrical delay
int xpos = 21; int xpos = 21 + CELLOFFSETX - x0;
int ypos = 1 + ((j+1)/2)*8; int ypos = 1 + ((j+1)/2)*8 - y0;
xpos -= m * CELLWIDTH -CELLOFFSETX;
ypos -= n * CELLHEIGHT;
float light_speed_ps = 299792458e-12; //(m/ps) 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); 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; char buf2[32];buf2[0]=0;
if ((domain_mode & DOMAIN_MODE) == DOMAIN_FREQ) { if ((domain_mode & DOMAIN_MODE) == DOMAIN_FREQ) {
if (FREQ_IS_STARTSTOP()) { if (FREQ_IS_STARTSTOP()) {
chsnprintf(buf1, sizeof(buf1), " START %qHz", frequency0); plot_printf(buf1, sizeof(buf1), " START %qHz", frequency0);
chsnprintf(buf2, sizeof(buf2), " STOP %qHz", frequency1); plot_printf(buf2, sizeof(buf2), " STOP %qHz", frequency1);
} else if (FREQ_IS_CENTERSPAN()) { } else if (FREQ_IS_CENTERSPAN()) {
chsnprintf(buf1, sizeof(buf1), " CENTER %qHz", FREQ_CENTER()); plot_printf(buf1, sizeof(buf1), " CENTER %qHz", FREQ_CENTER());
chsnprintf(buf2, sizeof(buf2), " SPAN %qHz", FREQ_SPAN()); plot_printf(buf2, sizeof(buf2), " SPAN %qHz", FREQ_SPAN());
} else { } else {
chsnprintf(buf1, sizeof(buf1), " CW %qHz", frequency0); plot_printf(buf1, sizeof(buf1), " CW %qHz", frequency0);
} }
} else { } else {
chsnprintf(buf1, sizeof(buf1), " START 0s"); plot_printf(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(buf2, sizeof(buf2), "STOP %Fs (%Fm)", time_of_index(POINTS_COUNT-1), distance_of_index(POINTS_COUNT-1));
} }
setForegroundColor(DEFAULT_FG_COLOR); setForegroundColor(DEFAULT_FG_COLOR);
setBackgroundColor(DEFAULT_BG_COLOR); setBackgroundColor(DEFAULT_BG_COLOR);
@ -1696,7 +1667,7 @@ draw_battery_status(void)
// Set battery color // Set battery color
setForegroundColor(vbat < BATTERY_WARNING_LEVEL ? DEFAULT_LOW_BAT_COLOR : DEFAULT_NORMAL_BAT_COLOR); setForegroundColor(vbat < BATTERY_WARNING_LEVEL ? DEFAULT_LOW_BAT_COLOR : DEFAULT_NORMAL_BAT_COLOR);
setBackgroundColor(DEFAULT_BG_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); // ili9341_drawstringV(string_buf, 1, 60);
// Prepare battery bitmap image // Prepare battery bitmap image
// Battery top // Battery top
@ -1713,7 +1684,7 @@ draw_battery_status(void)
// string_buf[x++] = 0b10000001; // string_buf[x++] = 0b10000001;
string_buf[x++] = 0b11111111; string_buf[x++] = 0b11111111;
// Draw battery // Draw battery
blit8BitWidthBitmap(0, 1, 8, x, string_buf); blit8BitWidthBitmap(1, 1, 8, x, string_buf);
} }
void void

12
ui.c
View file

@ -782,7 +782,7 @@ static void
menu_marker_search_cb(int item, uint8_t data) menu_marker_search_cb(int item, uint8_t data)
{ {
(void)data; (void)data;
int i; int i = -1;
if (active_marker == -1) if (active_marker == -1)
return; return;
@ -791,23 +791,19 @@ menu_marker_search_cb(int item, uint8_t data)
case 1: /* minimum */ case 1: /* minimum */
set_marker_search(item); set_marker_search(item);
i = marker_search(); i = marker_search();
if (i != -1)
markers[active_marker].index = i;
break; break;
case 2: /* search Left */ case 2: /* search Left */
i = marker_search_left(markers[active_marker].index); i = marker_search_left(markers[active_marker].index);
if (i != -1)
markers[active_marker].index = i;
break; break;
case 3: /* search right */ case 3: /* search right */
i = marker_search_right(markers[active_marker].index); i = marker_search_right(markers[active_marker].index);
if (i != -1)
markers[active_marker].index = i;
break; break;
case 4: /* tracking */ case 4: /* tracking */
marker_tracking = !marker_tracking; marker_tracking = !marker_tracking;
break; break;
} }
if (i != -1)
markers[active_marker].index = i;
draw_menu(); draw_menu();
redraw_marker(active_marker, TRUE); redraw_marker(active_marker, TRUE);
select_lever_mode(LM_SEARCH); select_lever_mode(LM_SEARCH);
@ -1601,7 +1597,7 @@ static void
draw_numeric_area(void) draw_numeric_area(void)
{ {
char buf[10]; char buf[10];
chsnprintf(buf, sizeof buf, "%9d", uistat.value); plot_printf(buf, sizeof buf, "%9d", uistat.value);
draw_numeric_input(buf); draw_numeric_input(buf);
} }