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

Merge branch 'DiSlord_tinySA-V4-SI4463' into tinySA-V4-SI4463

Browse Source
Removed_REF_marker
erikkaashoek 5 years ago
parent a471408671 41eac5bce7
commit 27b036cadf
14 changed files with 296 additions and 303 deletions
Show Stats Download Patch File Download Diff File

4
NANOVNA_STM32_F072/mcuconf.h
Unescape View File

@ -175,7 +175,7 @@
* I2S driver system settings. * I2S driver system settings.
*/ */
#define STM32_I2S_USE_SPI1 FALSE #define STM32_I2S_USE_SPI1 FALSE
#define STM32_I2S_USE_SPI2 TRUE #define STM32_I2S_USE_SPI2 FALSE
#define STM32_I2S_SPI1_MODE (STM32_I2S_MODE_MASTER | \ #define STM32_I2S_SPI1_MODE (STM32_I2S_MODE_MASTER | \
STM32_I2S_MODE_RX) STM32_I2S_MODE_RX)
#define STM32_I2S_SPI2_MODE (STM32_I2S_MODE_SLAVE | \ #define STM32_I2S_SPI2_MODE (STM32_I2S_MODE_SLAVE | \
@ -222,7 +222,7 @@
/* /*
* SPI driver system settings. * SPI driver system settings.
*/ */
#define STM32_SPI_USE_SPI1 TRUE #define STM32_SPI_USE_SPI1 FALSE
#define STM32_SPI_USE_SPI2 FALSE #define STM32_SPI_USE_SPI2 FALSE
#define STM32_SPI_USE_SPI3 FALSE #define STM32_SPI_USE_SPI3 FALSE
#define STM32_SPI_SPI1_RX_DMA_STREAM STM32_DMA_STREAM_ID(1, 2) #define STM32_SPI_SPI1_RX_DMA_STREAM STM32_DMA_STREAM_ID(1, 2)

2
NANOVNA_STM32_F303/mcuconf.h
Unescape View File

@ -226,7 +226,7 @@
/* /*
* SPI driver system settings. * SPI driver system settings.
*/ */
#define STM32_SPI_USE_SPI1 TRUE #define STM32_SPI_USE_SPI1 FALSE
#define STM32_SPI_USE_SPI2 FALSE #define STM32_SPI_USE_SPI2 FALSE
#define STM32_SPI_USE_SPI3 FALSE #define STM32_SPI_USE_SPI3 FALSE
#define STM32_SPI_SPI1_RX_DMA_STREAM STM32_DMA_STREAM_ID(1, 2) #define STM32_SPI_SPI1_RX_DMA_STREAM STM32_DMA_STREAM_ID(1, 2)

2
adc.c
Unescape View File

@ -80,7 +80,7 @@ int16_t adc_vbat_read(void)
// Vbat measure averange count = 2^VBAT_AVERAGE // Vbat measure averange count = 2^VBAT_AVERAGE
#define VBAT_AVERAGE 4 #define VBAT_AVERAGE 4
// Measure vbat every 5 second // Measure vbat every 5 second
#define VBAT_MEASURE_INTERVAL 50000 #define VBAT_MEASURE_INTERVAL S2ST(5)
static int16_t vbat_raw = 0; static int16_t vbat_raw = 0;
static systime_t vbat_time = -VBAT_MEASURE_INTERVAL-1; static systime_t vbat_time = -VBAT_MEASURE_INTERVAL-1;

2
adc_F303.c
Unescape View File

@ -96,7 +96,7 @@ int16_t adc_vbat_read(void)
// Vbat measure averange count = 2^VBAT_AVERAGE // Vbat measure averange count = 2^VBAT_AVERAGE
#define VBAT_AVERAGE 4 #define VBAT_AVERAGE 4
// Measure vbat every 5 second // Measure vbat every 5 second
#define VBAT_MEASURE_INTERVAL 50000 #define VBAT_MEASURE_INTERVAL S2ST(5)
static int16_t vbat_raw = 0; static int16_t vbat_raw = 0;
static systime_t vbat_time = -VBAT_MEASURE_INTERVAL-1; static systime_t vbat_time = -VBAT_MEASURE_INTERVAL-1;

2
halconf.h
Unescape View File

@ -150,7 +150,7 @@
* @brief Enables the SPI subsystem. * @brief Enables the SPI subsystem.
*/ */
#if !defined(HAL_USE_SPI) || defined(__DOXYGEN__) #if !defined(HAL_USE_SPI) || defined(__DOXYGEN__)
#define HAL_USE_SPI TRUE #define HAL_USE_SPI FALSE
#endif #endif
/** /**

46
ili9341.c
Unescape View File

@ -23,7 +23,7 @@
#ifdef TINYSA4 #ifdef TINYSA4
#include "si4432.h" #include "si4432.h"
#endif #endif
#include "chprintf.h"
#include "spi.h" #include "spi.h"
// Pin macros for LCD // Pin macros for LCD
@ -841,6 +841,50 @@ void ili9341_drawstring_10x14(const char *str, int x, int y)
#endif #endif
} }
typedef struct {
const void *vmt;
int16_t start_x;
int16_t start_y;
int16_t x;
int16_t y;
} lcdPrintStream;
static msg_t lcd_put(void *ip, uint8_t ch) {
lcdPrintStream *ps = ip;
if (ch == '\n') {ps->x = ps->start_x; ps->y+=FONT_STR_HEIGHT; return MSG_OK;}
uint16_t w = FONT_GET_WIDTH(ch);
ili9341_blitBitmap(ps->x, ps->y, w, FONT_GET_HEIGHT, FONT_GET_DATA(ch));
ps->x+= w;
return MSG_OK;
}
#if 0
static msg_t lcd_put_7x13(void *ip, uint8_t ch) {
lcdPrintStream *ps = ip;
if (ch == '\n') {ps->x = ps->start_x; ps->y+=FONT_STR_HEIGHT; return MSG_OK;}
uint16_t w = FONT_GET_WIDTH(ch);
ili9341_blitBitmap(ps->x, ps->y, w, FONT_GET_HEIGHT, FONT_GET_DATA(ch));
ps->x+= w;
return MSG_OK;
}
#endif
// Simple print in buffer function
int lcd_printf(int16_t x, int16_t y, const char *fmt, ...) {
// Init small lcd print stream
struct lcd_printStreamVMT {
_base_sequential_stream_methods
} lcd_vmt = {NULL, NULL, lcd_put, NULL};
lcdPrintStream ps = {&lcd_vmt, x, y, x, y};
// Performing the print operation using the common code.
va_list ap;
va_start(ap, fmt);
int retval = chvprintf((BaseSequentialStream *)(void *)&ps, fmt, ap);
va_end(ap);
// Return number of bytes that would have been written.
return retval;
}
void ili9341_drawstringV(const char *str, int x, int y) void ili9341_drawstringV(const char *str, int x, int y)
{ {
ili9341_set_rotation(DISPLAY_ROTATION_270); ili9341_set_rotation(DISPLAY_ROTATION_270);

62
main.c
Unescape View File

@ -2046,9 +2046,8 @@ static const I2CConfig i2ccfg = {
}; };
#endif #endif
static DACConfig dac1cfg1 = { static const DACConfig dac1cfg1 = {
//init: 2047U, init: 0,
init: 1922U,
datamode: DAC_DHRM_12BIT_RIGHT datamode: DAC_DHRM_12BIT_RIGHT
}; };
@ -2224,18 +2223,7 @@ int main(void)
shell_init_connection(); shell_init_connection();
#ifdef TINYSA4
dac1cfg1.init = config.dac_value;
#else
dac1cfg1.init = 0;
#endif
/*
* Starting DAC1 driver, setting up the output pin as analog as suggested
* by the Reference Manual.
*/
dacStart(&DACD2, &dac1cfg1);
dacStart(&DACD1, &dac1cfg1);
set_sweep_points(POINTS_COUNT); set_sweep_points(POINTS_COUNT);
@ -2279,11 +2267,16 @@ int main(void)
ui_mode_normal(); ui_mode_normal();
/* /*
* Set LCD display brightness * Set LCD display brightness (use DAC2 for control)
* Starting DAC1 driver, setting up the output pin as analog as suggested by the Reference Manual.
*/ */
#ifdef __LCD_BRIGHTNESS__ #ifdef __LCD_BRIGHTNESS__
lcd_setBrightness(config._brightness); lcd_setBrightness(config._brightness);
#else
dacStart(&DACD2, &dac1cfg1);
dacPutChannelX(&DACD2, 0, config.dac_value);
#endif #endif
dacStart(&DACD1, &dac1cfg1);
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO-1, Thread1, NULL); chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO-1, Thread1, NULL);
@ -2351,27 +2344,25 @@ void hard_fault_handler_c(uint32_t *sp)
uint32_t psr = sp[7]; uint32_t psr = sp[7];
int y = 0; int y = 0;
int x = OFFSETX + 1; int x = OFFSETX + 1;
static char buf[96];
ili9341_set_background(LCD_BG_COLOR); ili9341_set_background(LCD_BG_COLOR);
ili9341_set_foreground(LCD_FG_COLOR); ili9341_set_foreground(LCD_FG_COLOR);
lcd_printf(x, y+=FONT_STR_HEIGHT, "SP 0x%08x", (uint32_t)sp);
plot_printf(buf, sizeof(buf), "SP 0x%08x", (uint32_t)sp);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "R0 0x%08x", r0);
plot_printf(buf, sizeof(buf), "R0 0x%08x", r0);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "R1 0x%08x", r1);
plot_printf(buf, sizeof(buf), "R1 0x%08x", r1);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "R2 0x%08x", r2);
plot_printf(buf, sizeof(buf), "R2 0x%08x", r2);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "R3 0x%08x", r3);
plot_printf(buf, sizeof(buf), "R3 0x%08x", r3);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "R4 0x%08x", r4);
plot_printf(buf, sizeof(buf), "R4 0x%08x", r4);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "R5 0x%08x", r5);
plot_printf(buf, sizeof(buf), "R5 0x%08x", r5);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "R6 0x%08x", r6);
plot_printf(buf, sizeof(buf), "R6 0x%08x", r6);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "R7 0x%08x", r7);
plot_printf(buf, sizeof(buf), "R7 0x%08x", r7);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "R8 0x%08x", r8);
plot_printf(buf, sizeof(buf), "R8 0x%08x", r8);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "R9 0x%08x", r9);
plot_printf(buf, sizeof(buf), "R9 0x%08x", r9);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "R10 0x%08x", r10);
plot_printf(buf, sizeof(buf), "R10 0x%08x", r10);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "R11 0x%08x", r11);
plot_printf(buf, sizeof(buf), "R11 0x%08x", r11);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "R12 0x%08x", r12);
plot_printf(buf, sizeof(buf), "R12 0x%08x", r12);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "LR 0x%08x", lr);
plot_printf(buf, sizeof(buf), "LR 0x%08x", lr);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "PC 0x%08x", pc);
plot_printf(buf, sizeof(buf), "PC 0x%08x", pc);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT); lcd_printf(x, y+=FONT_STR_HEIGHT, "PSR 0x%08x", psr);
plot_printf(buf, sizeof(buf), "PSR 0x%08x", psr);ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT);
#ifdef ENABLE_THREADS_COMMAND #ifdef ENABLE_THREADS_COMMAND
thread_t *tp; thread_t *tp;
tp = chRegFirstThread(); tp = chRegFirstThread();
@ -2385,11 +2376,10 @@ void hard_fault_handler_c(uint32_t *sp)
#else #else
uint32_t stklimit = 0U; uint32_t stklimit = 0U;
#endif #endif
plot_printf(buf, sizeof(buf), "%08x|%08x|%08x|%08x|%4u|%4u|%9s|%12s", lcd_printf(x, y+=FONT_STR_HEIGHT, "%08x|%08x|%08x|%08x|%4u|%4u|%9s|%12s",
stklimit, (uint32_t)tp->ctx.sp, max_stack_use, (uint32_t)tp, stklimit, (uint32_t)tp->ctx.sp, max_stack_use, (uint32_t)tp,
(uint32_t)tp->refs - 1, (uint32_t)tp->prio, states[tp->state], (uint32_t)tp->refs - 1, (uint32_t)tp->prio, states[tp->state],
tp->name == NULL ? "" : tp->name); tp->name == NULL ? "" : tp->name);
ili9341_drawstring(buf, x, y+=FONT_STR_HEIGHT);
tp = chRegNextThread(tp); tp = chRegNextThread(tp);
} while (tp != NULL); } while (tp != NULL);
#endif #endif

7
nanovna.h
Unescape View File

@ -18,7 +18,7 @@
*/ */
#include "ch.h" #include "ch.h"
//#ifdef TINYSA_F303 #ifdef TINYSA_F303
#include "adc_F303.h" #include "adc_F303.h"
#ifdef TINYSA_F072 #ifdef TINYSA_F072
#error "Remove comment for #ifdef TINYSA_F303" #error "Remove comment for #ifdef TINYSA_F303"
@ -27,7 +27,7 @@
#define TINYSA4 #define TINYSA4
#endif #endif
#define TINYSA4_PROTO #define TINYSA4_PROTO
//#endif #endif
#ifdef TINYSA_F072 #ifdef TINYSA_F072
#ifdef TINYSA_F303 #ifdef TINYSA_F303
@ -962,6 +962,7 @@ void ili9341_drawchar(uint8_t ch, int x, int y);
void ili9341_drawstring(const char *str, int x, int y); void ili9341_drawstring(const char *str, int x, int y);
void ili9341_drawstring_7x13(const char *str, int x, int y); void ili9341_drawstring_7x13(const char *str, int x, int y);
void ili9341_drawstring_10x14(const char *str, int x, int y); void ili9341_drawstring_10x14(const char *str, int x, int y);
int lcd_printf(int16_t x, int16_t y, const char *fmt, ...);
void ili9341_drawstringV(const char *str, int x, int y); void ili9341_drawstringV(const char *str, int x, int y);
int ili9341_drawchar_size(uint8_t ch, int x, int y, uint8_t size); int ili9341_drawchar_size(uint8_t ch, int x, int y, uint8_t size);
void ili9341_drawstring_size(const char *str, int x, int y, uint8_t size); void ili9341_drawstring_size(const char *str, int x, int y, uint8_t size);
@ -1444,6 +1445,8 @@ enum {
T_AUTO, T_NORMAL, T_SINGLE, T_DONE, T_UP, T_DOWN, T_MODE, T_PRE, T_POST, T_MID T_AUTO, T_NORMAL, T_SINGLE, T_DONE, T_UP, T_DOWN, T_MODE, T_PRE, T_POST, T_MID
}; };
//!!! Warning can show not correct results on CH_CFG_ST_FREQUENCY not round by 1000 or > 1000000UL
#define sa_ST2US(n) ((n)*(1000000UL/(CH_CFG_ST_FREQUENCY)))
extern const uint8_t SI4432_RBW_count; extern const uint8_t SI4432_RBW_count;
extern void SI4432_Listen(int s); extern void SI4432_Listen(int s);

267
plot.c
Unescape View File

@ -631,8 +631,7 @@ static const uint8_t reference_bitmap[]={
#define X_MARKER_OFFSET 3 #define X_MARKER_OFFSET 3
#define Y_MARKER_OFFSET 10 #define Y_MARKER_OFFSET 10
#define MARKER_BITMAP(i) (&marker_bitmap[(i)*MARKER_HEIGHT]) #define MARKER_BITMAP(i) (&marker_bitmap[(i)*MARKER_HEIGHT])
static const uint8_t marker_bitmap[]= static const uint8_t marker_bitmap[]={
{
// Marker Back plate // Marker Back plate
_BMP8(0b11111110), _BMP8(0b11111110),
_BMP8(0b11111110), _BMP8(0b11111110),
@ -655,6 +654,7 @@ static const uint8_t marker_bitmap[]=
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b00000000), _BMP8(0b00000000),
#if MARKERS_MAX >=2
// Marker 2 // Marker 2
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b00111000), _BMP8(0b00111000),
@ -666,6 +666,8 @@ static const uint8_t marker_bitmap[]=
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b00000000), _BMP8(0b00000000),
#endif
#if MARKERS_MAX >=3
// Marker 3 // Marker 3
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b00111000), _BMP8(0b00111000),
@ -677,6 +679,8 @@ static const uint8_t marker_bitmap[]=
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b00000000), _BMP8(0b00000000),
#endif
#if MARKERS_MAX >=4
// Marker 4 // Marker 4
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b00001000), _BMP8(0b00001000),
@ -688,63 +692,69 @@ static const uint8_t marker_bitmap[]=
_BMP8(0b00001000), _BMP8(0b00001000),
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b00000000), _BMP8(0b00000000),
#if MARKER_COUNT > 4 #endif
#if MARKERS_MAX >=5
// Marker 5 // Marker 5
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b11110000), _BMP8(0b01111100),
_BMP8(0b10000000), _BMP8(0b01000000),
_BMP8(0b11100000), _BMP8(0b01111000),
_BMP8(0b00010000), _BMP8(0b00000100),
_BMP8(0b00010000), _BMP8(0b01000100),
_BMP8(0b10010000), _BMP8(0b00111000),
_BMP8(0b01100000), _BMP8(0b00000000),
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b00000000), _BMP8(0b00000000),
#endif
#if MARKERS_MAX >=6
// Marker 6 // Marker 6
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b01100000), _BMP8(0b00111100),
_BMP8(0b10010000), _BMP8(0b01000000),
_BMP8(0b10000000), _BMP8(0b01111000),
_BMP8(0b11100000), _BMP8(0b01000100),
_BMP8(0b10010000), _BMP8(0b01000100),
_BMP8(0b10010000), _BMP8(0b00111000),
_BMP8(0b01100000), _BMP8(0b00000000),
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b00000000), _BMP8(0b00000000),
#endif
#if MARKERS_MAX >=7
// Marker 7 // Marker 7
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b11110000), _BMP8(0b01111100),
_BMP8(0b01000100),
_BMP8(0b00000100),
_BMP8(0b00001000),
_BMP8(0b00010000),
_BMP8(0b00010000),
_BMP8(0b00010000), _BMP8(0b00010000),
_BMP8(0b00100000),
_BMP8(0b00100000),
_BMP8(0b01000000),
_BMP8(0b01000000),
_BMP8(0b01000000),
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b00000000), _BMP8(0b00000000),
#endif
#if MARKERS_MAX >=8
// Marker 8 // Marker 8
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b01100000), _BMP8(0b00111000),
_BMP8(0b10010000), _BMP8(0b01000100),
_BMP8(0b10010000), _BMP8(0b00111000),
_BMP8(0b01100000), _BMP8(0b01000100),
_BMP8(0b10010000), _BMP8(0b01000100),
_BMP8(0b10010000), _BMP8(0b00111000),
_BMP8(0b01100000), _BMP8(0b00000000),
_BMP8(0b00000000), _BMP8(0b00000000),
_BMP8(0b00000000), _BMP8(0b00000000),
#endif #endif
}; };
#elif _MARKER_SIZE_ == 1 #elif _MARKER_SIZE_ == 1
#define MARKER_WIDTH 10 #define MARKER_WIDTH 10
#define MARKER_HEIGHT 13 #define MARKER_HEIGHT 13
#define X_MARKER_OFFSET 4 #define X_MARKER_OFFSET 4
#define Y_MARKER_OFFSET 13 #define Y_MARKER_OFFSET 13
#define MARKER_BITMAP(i) (&marker_bitmap[(i)*2*MARKER_HEIGHT]) #define MARKER_BITMAP(i) (&marker_bitmap[(i)*2*MARKER_HEIGHT])
static const uint8_t marker_bitmap[]= static const uint8_t marker_bitmap[]={
{
// Marker Back plate // Marker Back plate
_BMP16(0b1111111110000000), _BMP16(0b1111111110000000),
_BMP16(0b1111111110000000), _BMP16(0b1111111110000000),
@ -773,20 +783,23 @@ static const uint8_t marker_bitmap[]=
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
#if MARKERS_MAX >=2
// Marker 2 // Marker 2
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0001111000000000), _BMP16(0b0001111000000000),
_BMP16(0b0011001100000000), _BMP16(0b0011001100000000),
_BMP16(0b0011001100000000), _BMP16(0b0011001100000000),
_BMP16(0b0000001100000000),
_BMP16(0b0000011000000000), _BMP16(0b0000011000000000),
_BMP16(0b0000110000000000), _BMP16(0b0001110000000000),
_BMP16(0b0001100000000000),
_BMP16(0b0011000000000000), _BMP16(0b0011000000000000),
_BMP16(0b0011111100000000), _BMP16(0b0011000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0011111000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
#endif
#if MARKERS_MAX >=3
// Marker 3 // Marker 3
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0011111000000000), _BMP16(0b0011111000000000),
@ -801,6 +814,8 @@ static const uint8_t marker_bitmap[]=
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
#endif
#if MARKERS_MAX >=4
// Marker 4 // Marker 4
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000011000000000), _BMP16(0b0000011000000000),
@ -815,60 +830,67 @@ static const uint8_t marker_bitmap[]=
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
#if MARKER_COUNT>4 #endif
#if MARKERS_MAX >=5
// Marker 5 // Marker 5
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b11111100<<6), _BMP16(0b0111111100000000),
_BMP16(0b11000000<<6), _BMP16(0b0110000000000000),
_BMP16(0b11000000<<6), _BMP16(0b0110000000000000),
_BMP16(0b11111000<<6), _BMP16(0b0111111000000000),
_BMP16(0b11001100<<6), _BMP16(0b0110001100000000),
_BMP16(0b00001100<<6), _BMP16(0b0000001100000000),
_BMP16(0b00001100<<6), _BMP16(0b0000001100000000),
_BMP16(0b11001100<<6), _BMP16(0b0110001100000000),
_BMP16(0b01111000<<6), _BMP16(0b0011111000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
#endif
#if MARKERS_MAX >=6
// Marker 6 // Marker 6
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b01111000<<6), _BMP16(0b0011111000000000),
_BMP16(0b11001100<<6), _BMP16(0b0110001100000000),
_BMP16(0b11000000<<6), _BMP16(0b0110000000000000),
_BMP16(0b11000000<<6), _BMP16(0b0110111000000000),
_BMP16(0b11111000<<6), _BMP16(0b0111001100000000),
_BMP16(0b11001100<<6), _BMP16(0b0110001100000000),
_BMP16(0b11001100<<6), _BMP16(0b0110001100000000),
_BMP16(0b11001100<<6), _BMP16(0b0110001100000000),
_BMP16(0b01111000<<6), _BMP16(0b0011111000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
#endif
#if MARKERS_MAX >=7
// Marker 7 // Marker 7
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b11111100<<6), _BMP16(0b0111111100000000),
_BMP16(0b00001100<<6), _BMP16(0b0110001100000000),
_BMP16(0b00001100<<6), _BMP16(0b0000001100000000),
_BMP16(0b00011000<<6), _BMP16(0b0000011000000000),
_BMP16(0b00011000<<6), _BMP16(0b0000110000000000),
_BMP16(0b00110000<<6), _BMP16(0b0001100000000000),
_BMP16(0b00110000<<6), _BMP16(0b0001100000000000),
_BMP16(0b01100000<<6), _BMP16(0b0001100000000000),
_BMP16(0b01100000<<6), _BMP16(0b0001100000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
#endif
#if MARKERS_MAX >=8
// Marker 8 // Marker 8
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b01111000<<6), _BMP16(0b0011111000000000),
_BMP16(0b11001100<<6), _BMP16(0b0110001100000000),
_BMP16(0b11001100<<6), _BMP16(0b0110001100000000),
_BMP16(0b11001100<<6), _BMP16(0b0011111000000000),
_BMP16(0b01111000<<6), _BMP16(0b0110001100000000),
_BMP16(0b11001100<<6), _BMP16(0b0110001100000000),
_BMP16(0b11001100<<6), _BMP16(0b0110001100000000),
_BMP16(0b11001100<<6), _BMP16(0b0110001100000000),
_BMP16(0b01111000<<6), _BMP16(0b0011111000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
_BMP16(0b0000000000000000), _BMP16(0b0000000000000000),
@ -1294,77 +1316,8 @@ cell_drawchar_size(uint8_t ch, int x, int y, int size)
} }
#endif #endif
/*
void
cell_drawstring(char *str, int x, int y)
{
if ((uint32_t)(y+FONT_GET_HEIGHT) >= CELLHEIGHT + FONT_GET_HEIGHT)
return;
while (*str) {
if (x >= CELLWIDTH)
return;
uint16_t ch = *str++;
uint16_t w = FONT_GET_WIDTH(ch);
cell_blit_bitmap(x, y, w, FONT_GET_HEIGHT, FONT_GET_DATA(ch));
x += w;
}
}
static void
cell_drawstring_7x13(char *str, int x, int y)
{
if ((uint32_t)(y+bFONT_GET_HEIGHT) >= CELLHEIGHT + bFONT_GET_HEIGHT)
return;
while (*str) {
if (x >= CELLWIDTH)
return;
uint8_t ch = *str++;
uint16_t w = bFONT_GET_WIDTH(ch);
cell_blit_bitmap(x, y, w, bFONT_GET_HEIGHT, bFONT_GET_DATA(ch));
x += w;
}
}
#ifndef wFONT_GET_DATA
void
cell_drawstring_size(char *str, int x, int y, int size)
{
if (y <= -FONT_GET_HEIGHT*2 || y >= CELLHEIGHT)
return;
while (*str) {
if (x >= CELLWIDTH)
return;
x += cell_drawchar_size(*str++, x, y, size);
}
}
#endif
void
cell_drawstring_10x14(char *str, int x, int y)
{
#ifdef wFONT_GET_DATA
if ((uint32_t)(y+wFONT_GET_HEIGHT) >= CELLHEIGHT + wFONT_GET_HEIGHT)
return;
while (*str) {
if (x >= CELLWIDTH)
return;
uint8_t ch = *str++;
uint16_t w = wFONT_GET_WIDTH(ch);
cell_blit_bitmap(x, y, w <=8 ? 9 : w, wFONT_GET_HEIGHT, wFONT_GET_DATA(ch));
x+=w;
}
#else
cell_drawstring_size(str, x, y, 2);
#endif
}
*/
struct cellprintStreamVMT {
_base_sequential_stream_methods
};
typedef struct { typedef struct {
const struct cellprintStreamVMT *vmt; const void *vmt;
int16_t x; int16_t x;
int16_t y; int16_t y;
} screenPrintStream; } screenPrintStream;
@ -1378,7 +1331,6 @@ static msg_t cellPut(void *ip, uint8_t ch) {
} }
return MSG_OK; return MSG_OK;
} }
static const struct cellprintStreamVMT cell_vmt_s = {NULL, NULL, cellPut, NULL};
static msg_t cellPut7x13(void *ip, uint8_t ch) { static msg_t cellPut7x13(void *ip, uint8_t ch) {
screenPrintStream *ps = ip; screenPrintStream *ps = ip;
@ -1389,10 +1341,8 @@ static msg_t cellPut7x13(void *ip, uint8_t ch) {
} }
return MSG_OK; return MSG_OK;
} }
static const struct cellprintStreamVMT cell_vmt_b = {NULL, NULL, cellPut7x13, NULL};
//#define ENABLE_WIDE_FONT_ON_CELL //#define ENABLE_WIDE_FONT_ON_CELL
#ifdef ENABLE_WIDE_FONT_ON_CELL #ifdef ENABLE_WIDE_FONT_ON_CELL
static msg_t cellPut10x14(void *ip, uint8_t ch) { static msg_t cellPut10x14(void *ip, uint8_t ch) {
screenPrintStream *ps = ip; screenPrintStream *ps = ip;
@ -1407,25 +1357,27 @@ static msg_t cellPut10x14(void *ip, uint8_t ch) {
} }
return MSG_OK; return MSG_OK;
} }
static const struct cellprintStreamVMT cell_vmt_w = {NULL, NULL, cellPut10x14, NULL};
#endif #endif
// Simple print in buffer function // Simple print in buffer function
int cell_printf(int16_t x, int16_t y, const char *fmt, ...) { int cell_printf(int16_t x, int16_t y, const char *fmt, ...) {
// skip always if right // skip always if right
if (x>=CELLWIDTH) return 0; if (x>=CELLWIDTH) return 0;
uint8_t font_type = *fmt++; // Init small cell print stream
screenPrintStream ps; struct cellprintStreamVMT {
_base_sequential_stream_methods
} cell_vmt = {NULL, NULL, NULL, NULL};
screenPrintStream ps = {&cell_vmt, x, y};
// Select font and skip print if not on cell (at top/bottom) // Select font and skip print if not on cell (at top/bottom)
switch (font_type){ switch (*fmt++){
case _FONT_s: case _FONT_s:
if ((uint32_t)(y+FONT_GET_HEIGHT) >= CELLHEIGHT + FONT_GET_HEIGHT) return 0; if ((uint32_t)(y+FONT_GET_HEIGHT) >= CELLHEIGHT + FONT_GET_HEIGHT) return 0;
ps.vmt = &cell_vmt_s; cell_vmt.put = cellPut;
break; break;
#ifdef ENABLE_WIDE_FONT_ON_CELL #ifdef ENABLE_WIDE_FONT_ON_CELL
case _FONT_w: case _FONT_w:
if ((uint32_t)(y+FONT_GET_HEIGHT) >= CELLHEIGHT + FONT_GET_HEIGHT) return 0; if ((uint32_t)(y+FONT_GET_HEIGHT) >= CELLHEIGHT + FONT_GET_HEIGHT) return 0;
ps.vmt = &cell_vmt_w; cell_vmt.put = cellPut10x14;
break; break;
#endif #endif
default: default:
@ -1433,14 +1385,11 @@ int cell_printf(int16_t x, int16_t y, const char *fmt, ...) {
__attribute__ ((fallthrough)); // prevent warning __attribute__ ((fallthrough)); // prevent warning
case _FONT_b: case _FONT_b:
if ((uint32_t)(y+bFONT_GET_HEIGHT) >= CELLHEIGHT + bFONT_GET_HEIGHT) return 0; if ((uint32_t)(y+bFONT_GET_HEIGHT) >= CELLHEIGHT + bFONT_GET_HEIGHT) return 0;
ps.vmt = &cell_vmt_b; cell_vmt.put = cellPut7x13;
break; break;
} }
va_list ap;
// Init small cell print stream
ps.x = x;
ps.y = y;
// Performing the print operation using the common code. // Performing the print operation using the common code.
va_list ap;
va_start(ap, fmt); va_start(ap, fmt);
int retval = chvprintf((BaseSequentialStream *)(void *)&ps, fmt, ap); int retval = chvprintf((BaseSequentialStream *)(void *)&ps, fmt, ap);
va_end(ap); va_end(ap);
@ -1754,7 +1703,7 @@ draw_frequencies(void)
// Draw battery level // Draw battery level
#define BATTERY_TOP_LEVEL 4200 #define BATTERY_TOP_LEVEL 4200
#define BATTERY_BOTTOM_LEVEL 3200 #define BATTERY_BOTTOM_LEVEL 3300
#define BATTERY_WARNING_LEVEL 3300 #define BATTERY_WARNING_LEVEL 3300
#define BATTERY_MID_LEVEL 3600 #define BATTERY_MID_LEVEL 3600

36
sa_core.c
Unescape View File

@ -3441,7 +3441,7 @@ again: // Spur redu
// i = 1; // Everything set so skip LO setting // i = 1; // Everything set so skip LO setting
#define MODULATION_CYCLES_TEST 10000 #define MODULATION_CYCLES_TEST 10000
if (in_selftest && modulation_count_iter++ >= 10000) { if (in_selftest && modulation_count_iter++ >= 10000) {
start_of_sweep_timestamp = (chVTGetSystemTimeX() - start_of_sweep_timestamp)*MODULATION_STEPS*100/MODULATION_CYCLES_TEST; // uS per cycle start_of_sweep_timestamp = sa_ST2US(chVTGetSystemTimeX() - start_of_sweep_timestamp)*MODULATION_STEPS/MODULATION_CYCLES_TEST; // uS per cycle
return 0; return 0;
} }
goto modulation_again; // Keep repeating sweep loop till user aborts by input goto modulation_again; // Keep repeating sweep loop till user aborts by input
@ -3775,7 +3775,7 @@ static bool sweep(bool break_on_operation)
} }
} }
} }
systime_t local_sweep_time = (chVTGetSystemTimeX() - start_of_sweep_timestamp)*100 ; systime_t local_sweep_time = sa_ST2US(chVTGetSystemTimeX() - start_of_sweep_timestamp);
if (setting.actual_sweep_time_us > ONE_SECOND_TIME) if (setting.actual_sweep_time_us > ONE_SECOND_TIME)
local_sweep_time = setting.actual_sweep_time_us; local_sweep_time = setting.actual_sweep_time_us;
if (show_bar && (( local_sweep_time > ONE_SECOND_TIME && (i & 0x07) == 0) || ( local_sweep_time > ONE_SECOND_TIME*10)) ) if (show_bar && (( local_sweep_time > ONE_SECOND_TIME && (i & 0x07) == 0) || ( local_sweep_time > ONE_SECOND_TIME*10)) )
@ -4116,7 +4116,7 @@ static volatile int dummy;
// ---------------------- process measured actual sweep time ----------------- // ---------------------- process measured actual sweep time -----------------
// For CW mode value calculated in SI4432_Fill // For CW mode value calculated in SI4432_Fill
if (setting.measure_sweep_time_us == 0) if (setting.measure_sweep_time_us == 0)
setting.measure_sweep_time_us = (chVTGetSystemTimeX() - start_of_sweep_timestamp) * 100; setting.measure_sweep_time_us = sa_ST2US(chVTGetSystemTimeX() - start_of_sweep_timestamp);
// Update actual time on change on status panel // Update actual time on change on status panel
uint32_t delta = abs((int)(setting.actual_sweep_time_us - setting.measure_sweep_time_us)); uint32_t delta = abs((int)(setting.actual_sweep_time_us - setting.measure_sweep_time_us));
@ -4218,7 +4218,7 @@ static volatile int dummy;
} else if (actual_max_level > target_level && setting.attenuate_x2 < 60) { } else if (actual_max_level > target_level && setting.attenuate_x2 < 60) {
delta = actual_max_level - target_level; delta = actual_max_level - target_level;
} }
if ((chVTGetSystemTimeX() - sweep_elapsed > 10000 && ( delta < -5 || delta > +5)) || delta > 10 ) { if ((chVTGetSystemTimeX() - sweep_elapsed > MS2ST(1000) && ( delta < -5 || delta > +5)) || delta > 10 ) {
setting.attenuate_x2 += delta + delta; setting.attenuate_x2 += delta + delta;
if (setting.attenuate_x2 < 0) if (setting.attenuate_x2 < 0)
setting.attenuate_x2= 0; setting.attenuate_x2= 0;
@ -4828,7 +4828,6 @@ static void test_acquire(int i)
} }
int cell_printf(int16_t x, int16_t y, const char *fmt, ...); int cell_printf(int16_t x, int16_t y, const char *fmt, ...);
static char self_test_status_buf[35];
void cell_draw_test_info(int x0, int y0) void cell_draw_test_info(int x0, int y0)
{ {
#define INFO_SPACING 13 #define INFO_SPACING 13
@ -4840,17 +4839,10 @@ void cell_draw_test_info(int x0, int y0)
i++; i++;
int xpos = 25 - x0; int xpos = 25 - x0;
int ypos = 50+i*INFO_SPACING - y0; int ypos = 50+i*INFO_SPACING - y0;
unsigned int color = LCD_FG_COLOR; pixel_t color;
if (i == -1) { if (i < 0)
plot_printf(self_test_status_buf, sizeof self_test_status_buf, FONT_s"Self test status:"); color = LCD_FG_COLOR;
} else if (test_case[i].kind == TC_END) { else if (test_status[i] == TS_PASS)
if (test_wait)
plot_printf(self_test_status_buf, sizeof self_test_status_buf, FONT_s"Touch screen to continue");
else
self_test_status_buf[0] = 0;
} else {
plot_printf(self_test_status_buf, sizeof self_test_status_buf, FONT_s"Test %d: %s%s", i+1, test_fail_cause[i], test_text[test_status[i]] );
if (test_status[i] == TS_PASS)
color = LCD_BRIGHT_COLOR_GREEN; color = LCD_BRIGHT_COLOR_GREEN;
else if (test_status[i] == TS_CRITICAL) else if (test_status[i] == TS_CRITICAL)
color = LCD_TRACE_3_COLOR; // Yellow color = LCD_TRACE_3_COLOR; // Yellow
@ -4858,9 +4850,17 @@ void cell_draw_test_info(int x0, int y0)
color = LCD_BRIGHT_COLOR_RED; color = LCD_BRIGHT_COLOR_RED;
else else
color = LCD_BRIGHT_COLOR_BLUE; color = LCD_BRIGHT_COLOR_BLUE;
}
ili9341_set_foreground(color); ili9341_set_foreground(color);
cell_printf(xpos, ypos, self_test_status_buf); if (i == -1) {
cell_printf(xpos, ypos, FONT_s"Self test status:");
} else if (test_case[i].kind == TC_END) {
if (test_wait)
cell_printf(xpos, ypos, FONT_s"Touch screen to continue");
continue;
} else {
cell_printf(xpos, ypos, FONT_s"Test %d: %s%s", i+1, test_fail_cause[i], test_text[test_status[i]] );
continue;
}
} while (test_case[i].kind != TC_END); } while (test_case[i].kind != TC_END);
} }

4
si4432.c
Unescape View File

@ -593,7 +593,7 @@ void SI4432_trigger_fill(int s, uint8_t trigger_lvl, int up_direction, int trigg
case ST_ARMING: case ST_ARMING:
if (i == sweep_points-1) { if (i == sweep_points-1) {
waiting = ST_WAITING; waiting = ST_WAITING;
setting.measure_sweep_time_us = (chVTGetSystemTimeX() - measure)*100; setting.measure_sweep_time_us = sa_ST2US(chVTGetSystemTimeX() - measure);
} }
break; break;
case ST_WAITING: case ST_WAITING:
@ -674,7 +674,7 @@ void SI4432_Fill(int s, int start)
shiftInBuf(sel, SI4432_REG_RSSI, &age[start], sweep_points - start, t); shiftInBuf(sel, SI4432_REG_RSSI, &age[start], sweep_points - start, t);
#endif #endif
// __enable_irq(); // __enable_irq();
setting.measure_sweep_time_us = (chVTGetSystemTimeX() - measure)*100; setting.measure_sweep_time_us = sa_ST2US(chVTGetSystemTimeX() - measure);
buf_index = start; // Is used to skip 1st entry during level triggering buf_index = start; // Is used to skip 1st entry during level triggering
buf_end = sweep_points - 1; buf_end = sweep_points - 1;
buf_read = true; buf_read = true;

2
si4468.c
Unescape View File

@ -1276,7 +1276,7 @@ void SI446x_Fill(int s, int start)
} while(1); } while(1);
__enable_irq(); __enable_irq();
setting.measure_sweep_time_us = (chVTGetSystemTimeX() - measure)*100; setting.measure_sweep_time_us = sa_ST2US(chVTGetSystemTimeX() - measure);
buf_index = (start<=0 ? 0 : start); // Is used to skip 1st entry during level triggering buf_index = (start<=0 ? 0 : start); // Is used to skip 1st entry during level triggering
buf_read = true; buf_read = true;
} }

41
ui.c
Unescape View File

@ -64,7 +64,11 @@ static uint16_t last_button = 0b0000;
static uint32_t last_button_down_ticks; static uint32_t last_button_down_ticks;
static uint32_t last_button_repeat_ticks; static uint32_t last_button_repeat_ticks;
//static uint16_t menu_button_height = MENU_BUTTON_HEIGHT_N(MENU_BUTTON_MIN); #define MENU_USE_AUTOHEIGHT
#ifdef MENU_USE_AUTOHEIGHT
static uint16_t menu_button_height = MENU_BUTTON_HEIGHT_N(MENU_BUTTON_MIN);
#endif
volatile uint8_t operation_requested = OP_NONE; volatile uint8_t operation_requested = OP_NONE;
int8_t previous_marker = MARKER_INVALID; int8_t previous_marker = MARKER_INVALID;
@ -641,6 +645,8 @@ enum {
//#define MT_LEAVE 0x20 //#define MT_LEAVE 0x20
#define MT_MASK(x) (0xF & (x)) #define MT_MASK(x) (0xF & (x))
#define MT_CUSTOM_LABEL 0
// Call back functions for MT_CALLBACK type // Call back functions for MT_CALLBACK type
typedef void (*menuaction_cb_t)(int item, uint16_t data); typedef void (*menuaction_cb_t)(int item, uint16_t data);
#define UI_FUNCTION_CALLBACK(ui_function_name) void ui_function_name(int item, uint16_t data) #define UI_FUNCTION_CALLBACK(ui_function_name) void ui_function_name(int item, uint16_t data)
@ -820,7 +826,9 @@ ensure_selection(void)
if (MT_MASK(menu[0].type) == MT_TITLE && selection == 0) selection = 1; if (MT_MASK(menu[0].type) == MT_TITLE && selection == 0) selection = 1;
if (i < MENU_BUTTON_MIN) i = MENU_BUTTON_MIN; if (i < MENU_BUTTON_MIN) i = MENU_BUTTON_MIN;
if (i >= MENU_BUTTON_MAX) i = MENU_BUTTON_MAX; if (i >= MENU_BUTTON_MAX) i = MENU_BUTTON_MAX;
// menu_button_height = MENU_BUTTON_HEIGHT_N(i); #ifdef MENU_USE_AUTOHEIGHT
menu_button_height = MENU_BUTTON_HEIGHT_N(i);
#endif
} }
static void static void
@ -1118,6 +1126,7 @@ static int
menu_is_multiline(const char *label) menu_is_multiline(const char *label)
{ {
int n = 1; int n = 1;
if (label)
while (*label) while (*label)
if (*label++ == '\n') if (*label++ == '\n')
n++; n++;
@ -1343,11 +1352,13 @@ static const uint8_t check_box[] = {
static const char *step_text[5] = {"-10dB", "-1dB", "set", "+1dB", "+10dB"}; static const char *step_text[5] = {"-10dB", "-1dB", "set", "+1dB", "+10dB"};
static char step_text_freq[5][10] = { "-100MHz", "-10MHz", "set", "+10MHz", "+100MHz" }; static char step_text_freq[5][10] = { "-100MHz", "-10MHz", "set", "+10MHz", "+100MHz" };
#ifndef MENU_USE_AUTOHEIGHT
#ifdef TINYSA4 #ifdef TINYSA4
#define menu_button_height ((menu[i].type & MT_FORM) || menu_is_multiline(menu[i].label) == 2 ? LCD_HEIGHT/10 : LCD_HEIGHT/12 ) #define menu_button_height ((menu[i].type & MT_FORM) || menu_is_multiline(menu[i].label) == 2 ? LCD_HEIGHT/10 : LCD_HEIGHT/12 )
#else #else
#define menu_button_height ((menu[i].type & MT_FORM) || menu_is_multiline(menu[i].label) == 2 ? LCD_HEIGHT/8 : LCD_HEIGHT/10 ) #define menu_button_height ((menu[i].type & MT_FORM) || menu_is_multiline(menu[i].label) == 2 ? LCD_HEIGHT/8 : LCD_HEIGHT/10 )
#endif #endif
#endif
static void static void
draw_menu_buttons(const menuitem_t *menu, int only) draw_menu_buttons(const menuitem_t *menu, int only)
@ -1390,24 +1401,26 @@ draw_menu_buttons(const menuitem_t *menu, int only)
// Need replace this obsolete bad function on new MT_ADV_CALLBACK variant // Need replace this obsolete bad function on new MT_ADV_CALLBACK variant
menu_item_modify_attribute(menu, i, &button); // before plot_printf to create status text menu_item_modify_attribute(menu, i, &button); // before plot_printf to create status text
char *text;
// MT_ADV_CALLBACK - allow change button data in callback, more easy and correct // MT_ADV_CALLBACK - allow change button data in callback, more easy and correct
if (MT_MASK(menu[i].type) == MT_ADV_CALLBACK){ if (MT_MASK(menu[i].type) == MT_ADV_CALLBACK){
menuaction_acb_t cb = (menuaction_acb_t)menu[i].reference; menuaction_acb_t cb = (menuaction_acb_t)menu[i].reference;
if (cb) (*cb)(i, menu[i].data, &button); if (cb) (*cb)(i, menu[i].data, &button);
// Apply custom text, from button label and
if (menu[i].label != MT_CUSTOM_LABEL)
plot_printf(button.text, sizeof(button.text), menu[i].label, button.param_1.u);
text = button.text;
} }
else
text = menu[i].label;
// Only keypad retrieves value // Only keypad retrieves value
if (menu[i].type & MT_FORM && MT_MASK(menu[i].type) == MT_KEYPAD) { if (menu[i].type & MT_FORM && MT_MASK(menu[i].type) == MT_KEYPAD) {
keypad_mode = menu[i].data; keypad_mode = menu[i].data;
fetch_numeric_target(); fetch_numeric_target();
button.param_1.text = uistat.text; plot_printf(button.text, sizeof button.text, menu[i].label, uistat.text);
text = button.text;
} }
// Prepare button label
plot_printf(button.text, sizeof button.text, menu[i].label, button.param_1.u, button.param_2.u);
int button_height = menu_button_height;
if (menu[i].type & MT_FORM) { if (menu[i].type & MT_FORM) {
int button_width = MENU_FORM_WIDTH; int button_width = MENU_FORM_WIDTH;
int button_start = (LCD_WIDTH - MENU_FORM_WIDTH)/2; // At center of screen int button_start = (LCD_WIDTH - MENU_FORM_WIDTH)/2; // At center of screen
@ -1455,8 +1468,8 @@ draw_menu_buttons(const menuitem_t *menu, int only)
goto draw_slider; goto draw_slider;
} }
} }
// ili9341_drawstring_size(button.text, text_offs, y+(button_height-2*FONT_GET_HEIGHT)/2-local_text_shift, 2); // ili9341_drawstring_size(text, text_offs, y+(button_height-2*FONT_GET_HEIGHT)/2-local_text_shift, 2);
ili9341_drawstring_10x14(button.text, text_offs, y+(button_height-wFONT_GET_HEIGHT)/2-local_text_shift); ili9341_drawstring_10x14(text, text_offs, y+(button_height-wFONT_GET_HEIGHT)/2-local_text_shift);
} else { } else {
int button_width = MENU_BUTTON_WIDTH; int button_width = MENU_BUTTON_WIDTH;
int button_start = LCD_WIDTH - MENU_BUTTON_WIDTH; int button_start = LCD_WIDTH - MENU_BUTTON_WIDTH;
@ -1466,12 +1479,12 @@ draw_menu_buttons(const menuitem_t *menu, int only)
ili9341_blitBitmap(button_start+2, y+(button_height-ICON_HEIGHT)/2, ICON_WIDTH, ICON_HEIGHT, &check_box[button.icon*2*ICON_HEIGHT]); ili9341_blitBitmap(button_start+2, y+(button_height-ICON_HEIGHT)/2, ICON_WIDTH, ICON_HEIGHT, &check_box[button.icon*2*ICON_HEIGHT]);
text_offs = button_start+2+ICON_WIDTH; text_offs = button_start+2+ICON_WIDTH;
} }
int lines = menu_is_multiline(button.text); int lines = menu_is_multiline(text);
#define BIG_BUTTON_FONT 1 #define BIG_BUTTON_FONT 1
#ifdef BIG_BUTTON_FONT #ifdef BIG_BUTTON_FONT
ili9341_drawstring_7x13(button.text, text_offs, y+(button_height-lines*bFONT_GET_HEIGHT)/2); ili9341_drawstring_7x13(text, text_offs, y+(button_height-lines*bFONT_GET_HEIGHT)/2);
#else #else
ili9341_drawstring(button.text, text_offs, y+(button_height-linesFONT_GET_HEIGHT)/2); ili9341_drawstring(text, text_offs, y+(button_height-linesFONT_GET_HEIGHT)/2);
#endif #endif
} }
y += button_height; y += button_height;

100
ui_sa.c
Unescape View File

@ -527,14 +527,13 @@ static UI_FUNCTION_ADV_CALLBACK(menu_sweep_acb)
(void)item; (void)item;
if (b){ if (b){
if (setting.level_sweep != 0 || get_sweep_frequency(ST_SPAN) != 0) { if (setting.level_sweep != 0 || get_sweep_frequency(ST_SPAN) != 0) {
plot_printf(uistat.text, sizeof uistat.text, "SW:%3.2fMHz %+ddB %.3Fs", plot_printf(b->text, sizeof b->text, "SW:%3.2fMHz %+ddB %.3Fs",
get_sweep_frequency(ST_SPAN) / 1000000.0, get_sweep_frequency(ST_SPAN) / 1000000.0,
(int)setting.level_sweep, (int)setting.level_sweep,
setting.sweep_time_us/(float)ONE_SECOND_TIME); setting.sweep_time_us/(float)ONE_SECOND_TIME);
b->param_1.text = uistat.text;
} }
else else
b->param_1.text = "SWEEP: OFF"; plot_printf(b->text, sizeof b->text, "SWEEP: OFF");
return; return;
} }
menu_push_submenu(menu_sweep); menu_push_submenu(menu_sweep);
@ -547,11 +546,10 @@ static UI_FUNCTION_ADV_CALLBACK(menu_restart_acb){
if(b){ if(b){
if (current_index >= 0 && setting.sweep) { if (current_index >= 0 && setting.sweep) {
float current_level = setting.level + ((float)current_index)* setting.level_sweep / (float)sweep_points; float current_level = setting.level + ((float)current_index)* setting.level_sweep / (float)sweep_points;
plot_printf(uistat.text, sizeof uistat.text, "STOP %5.3QHz %+.1fdBm", frequencies[current_index], current_level); plot_printf(b->text, sizeof b->text, "STOP %5.3QHz %+.1fdBm", frequencies[current_index], current_level);
b->param_1.text = uistat.text;
} else {
b->param_1.text = "START SWEEP";
} }
else
plot_printf(b->text, sizeof b->text, "START SWEEP");
return; return;
} }
setting.sweep = !setting.sweep; setting.sweep = !setting.sweep;
@ -570,10 +568,9 @@ static UI_FUNCTION_ADV_CALLBACK(menu_curve_acb)
(void)item; (void)item;
int old_m; int old_m;
if (b){ if (b){
plot_printf(uistat.text, sizeof uistat.text, "%8.3QHz %+4.1fdB", plot_printf(b->text, sizeof b->text, "%8.3QHz %+4.1fdB",
config.correction_frequency[current_curve][data], config.correction_frequency[current_curve][data],
config.correction_value[current_curve][data]); config.correction_value[current_curve][data]);
b->param_1.text = uistat.text;
return; return;
} }
switch(current_curve) { switch(current_curve) {
@ -747,12 +744,10 @@ static UI_FUNCTION_ADV_CALLBACK(menu_load_preset_acb)
(void)item; (void)item;
if(b){ if(b){
setting_t *p = caldata_pointer(data); setting_t *p = caldata_pointer(data);
char *t = (char *)spi_buffer;
if (p) if (p)
plot_printf(t, 64, "%.6FHz\n%.6FHz", (float)p->frequency0, (float)p->frequency1);//\n%d-drstx8 plot_printf(b->text, sizeof(b->text), "%.6FHz\n%.6FHz", (float)p->frequency0, (float)p->frequency1);
else else
plot_printf(t, 64, "EMPTY %d", (int)data); plot_printf(b->text, sizeof(b->text), "EMPTY %d", (int)data);
b->param_1.text = t;
return; return;
} }
if (caldata_recall(data) == -1) { if (caldata_recall(data) == -1) {
@ -923,10 +918,9 @@ static UI_FUNCTION_ADV_CALLBACK(menu_smodulation_acb){
(void)data; (void)data;
if(b){ if(b){
if (setting.modulation == MO_NONE || setting.modulation == MO_EXTERNAL) if (setting.modulation == MO_NONE || setting.modulation == MO_EXTERNAL)
b->param_1.text = menu_modulation_text[setting.modulation]; plot_printf(b->text, sizeof b->text, "MOD: %s", menu_modulation_text[setting.modulation]);
else { else {
plot_printf(uistat.text, sizeof uistat.text, "%5.3fkHz %s", setting.modulation_frequency / 1000.0, menu_modulation_text[setting.modulation]); plot_printf(b->text, sizeof b->text, "MOD: %5.3fkHz %s", setting.modulation_frequency / 1000.0, menu_modulation_text[setting.modulation]);
b->param_1.text = uistat.text;
} }
return; return;
} }
@ -1975,11 +1969,11 @@ static const menuitem_t menu_store_preset_high[8] =
static const menuitem_t menu_load_preset_high[] = static const menuitem_t menu_load_preset_high[] =
{ {
{ MT_ADV_CALLBACK, 0, "LOAD\nSTARTUP",menu_load_preset_acb}, { MT_ADV_CALLBACK, 0, "LOAD\nSTARTUP", menu_load_preset_acb},
{ MT_ADV_CALLBACK, 5, "LOAD %s", menu_load_preset_acb}, { MT_ADV_CALLBACK, 5, MT_CUSTOM_LABEL, menu_load_preset_acb},
{ MT_ADV_CALLBACK, 6, "LOAD %s", menu_load_preset_acb}, { MT_ADV_CALLBACK, 6, MT_CUSTOM_LABEL, menu_load_preset_acb},
{ MT_ADV_CALLBACK, 7, "LOAD %s", menu_load_preset_acb}, { MT_ADV_CALLBACK, 7, MT_CUSTOM_LABEL, menu_load_preset_acb},
{ MT_ADV_CALLBACK, 8, "LOAD %s", menu_load_preset_acb}, { MT_ADV_CALLBACK, 8, MT_CUSTOM_LABEL, menu_load_preset_acb},
{ MT_SUBMENU, 0, "STORE" , menu_store_preset_high}, { MT_SUBMENU, 0, "STORE" , menu_store_preset_high},
{ MT_CANCEL, 255, S_LARROW" BACK", NULL }, { MT_CANCEL, 255, S_LARROW" BACK", NULL },
{ MT_NONE, 0, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
@ -2000,11 +1994,11 @@ static const menuitem_t menu_store_preset[] =
static const menuitem_t menu_load_preset[] = static const menuitem_t menu_load_preset[] =
{ {
{ MT_ADV_CALLBACK, 0, "LOAD\nSTARTUP",menu_load_preset_acb}, { MT_ADV_CALLBACK, 0, "LOAD\nSTARTUP", menu_load_preset_acb},
{ MT_ADV_CALLBACK, 1, "%s" , menu_load_preset_acb}, { MT_ADV_CALLBACK, 1, MT_CUSTOM_LABEL, menu_load_preset_acb},
{ MT_ADV_CALLBACK, 2, "%s" , menu_load_preset_acb}, { MT_ADV_CALLBACK, 2, MT_CUSTOM_LABEL, menu_load_preset_acb},
{ MT_ADV_CALLBACK, 3, "%s" , menu_load_preset_acb}, { MT_ADV_CALLBACK, 3, MT_CUSTOM_LABEL, menu_load_preset_acb},
{ MT_ADV_CALLBACK, 4, "%s" , menu_load_preset_acb}, { MT_ADV_CALLBACK, 4, MT_CUSTOM_LABEL, menu_load_preset_acb},
{ MT_SUBMENU, 0, "STORE" , menu_store_preset}, { MT_SUBMENU, 0, "STORE" , menu_store_preset},
{ MT_CANCEL, 0, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, 0, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
@ -2059,10 +2053,10 @@ static const menuitem_t menu_lowoutputmode[] = {
// { MT_FORM | MT_ADV_CALLBACK, 0, "MOD: %s", menu_smodulation_acb}, // { MT_FORM | MT_ADV_CALLBACK, 0, "MOD: %s", menu_smodulation_acb},
{ MT_FORM | MT_KEYPAD, KM_CENTER, center_text, VARIANT("10kHz..350MHz","10kHz..850MHz")}, { MT_FORM | MT_KEYPAD, KM_CENTER, center_text, VARIANT("10kHz..350MHz","10kHz..850MHz")},
{ MT_FORM | MT_KEYPAD, KM_LOWOUTLEVEL, "LEVEL: %s", low_level_help_text}, { MT_FORM | MT_KEYPAD, KM_LOWOUTLEVEL, "LEVEL: %s", low_level_help_text},
{ MT_FORM | MT_ADV_CALLBACK, 0, "MOD: %s", menu_smodulation_acb}, { MT_FORM | MT_ADV_CALLBACK, 0, MT_CUSTOM_LABEL, menu_smodulation_acb},
{ MT_FORM | MT_ADV_CALLBACK, 0, "%s", menu_sweep_acb}, { MT_FORM | MT_ADV_CALLBACK, 0, MT_CUSTOM_LABEL, menu_sweep_acb},
#ifdef __SWEEP_RESTART__ #ifdef __SWEEP_RESTART__
{ MT_FORM | MT_ADV_CALLBACK, 0, "%s", menu_restart_acb}, { MT_FORM | MT_ADV_CALLBACK, 0, MT_CUSTOM_LABEL, menu_restart_acb},
#endif #endif
{ MT_FORM | MT_KEYPAD, KM_EXT_GAIN, "EXTERNAL GAIN: %s", "-100..+100"}, { MT_FORM | MT_KEYPAD, KM_EXT_GAIN, "EXTERNAL GAIN: %s", "-100..+100"},
#ifdef TINYSA4 #ifdef TINYSA4
@ -2076,10 +2070,10 @@ static const menuitem_t menu_highoutputmode[] = {
{ MT_FORM | MT_ADV_CALLBACK, 0, "HIGH OUTPUT %s", menu_outputmode_acb}, { MT_FORM | MT_ADV_CALLBACK, 0, "HIGH OUTPUT %s", menu_outputmode_acb},
{ MT_FORM | MT_KEYPAD, KM_CENTER, center_text, VARIANT("240MHz..960MHz",range_text)}, { MT_FORM | MT_KEYPAD, KM_CENTER, center_text, VARIANT("240MHz..960MHz",range_text)},
{ MT_FORM | MT_KEYPAD, KM_HIGHOUTLEVEL, "LEVEL: %s", low_level_help_text /* "-76..-6" */}, { MT_FORM | MT_KEYPAD, KM_HIGHOUTLEVEL, "LEVEL: %s", low_level_help_text /* "-76..-6" */},
{ MT_FORM | MT_ADV_CALLBACK, 0, "MOD: %s", menu_smodulation_acb}, { MT_FORM | MT_ADV_CALLBACK, 0, MT_CUSTOM_LABEL, menu_smodulation_acb},
{ MT_FORM | MT_ADV_CALLBACK, 0, "%s", menu_sweep_acb}, { MT_FORM | MT_ADV_CALLBACK, 0, MT_CUSTOM_LABEL, menu_sweep_acb},
#ifdef __SWEEP_RESTART__ #ifdef __SWEEP_RESTART__
{ MT_FORM | MT_ADV_CALLBACK, 0, "%s", menu_restart_acb}, { MT_FORM | MT_ADV_CALLBACK, 0, MT_CUSTOM_LABEL, menu_restart_acb},
#endif #endif
{ MT_FORM | MT_KEYPAD, KM_EXT_GAIN, "EXTERNAL GAIN: %s", "-100..+100"}, { MT_FORM | MT_KEYPAD, KM_EXT_GAIN, "EXTERNAL GAIN: %s", "-100..+100"},
#ifdef TINYSA4 #ifdef TINYSA4
@ -2467,37 +2461,37 @@ static const menuitem_t menu_settings2[] =
#ifdef TINYSA4 #ifdef TINYSA4
static const menuitem_t menu_curve3[] = { static const menuitem_t menu_curve3[] = {
{ MT_FORM | MT_ADV_CALLBACK, 14, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 14, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 15, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 15, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 16, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 16, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 17, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 17, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 18, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 18, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 19, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 19, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_CANCEL, 0, S_LARROW" BACK", NULL }, { MT_FORM | MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, 0, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
static const menuitem_t menu_curve2[] = { static const menuitem_t menu_curve2[] = {
{ MT_FORM | MT_ADV_CALLBACK, 7, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 7, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 8, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 8, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 9, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 9, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 10, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 10, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 11, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 11, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 12, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 12, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 13, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 13, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_SUBMENU, 0, S_RARROW" MORE", menu_curve3}, { MT_FORM | MT_SUBMENU, 0, S_RARROW" MORE", menu_curve3},
{ MT_FORM | MT_CANCEL, 0, S_LARROW" BACK", NULL }, { MT_FORM | MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, 0, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
}; };
static const menuitem_t menu_curve[] = { static const menuitem_t menu_curve[] = {
{ MT_FORM | MT_ADV_CALLBACK, 0, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 0, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 1, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 1, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 2, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 2, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 3, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 3, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 4, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 4, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 5, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 5, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_ADV_CALLBACK, 6, "%s", menu_curve_acb }, { MT_FORM | MT_ADV_CALLBACK, 6, MT_CUSTOM_LABEL, menu_curve_acb },
{ MT_FORM | MT_SUBMENU, 0, S_RARROW" MORE", menu_curve2}, { MT_FORM | MT_SUBMENU, 0, S_RARROW" MORE", menu_curve2},
{ MT_FORM | MT_CANCEL, 0, S_LARROW" BACK", NULL }, { MT_FORM | MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, 0, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel
@ -2638,7 +2632,7 @@ static const menuitem_t menu_config[] = {
{ MT_SUBMENU, 0, S_RARROW" DFU", menu_dfu}, { MT_SUBMENU, 0, S_RARROW" DFU", menu_dfu},
#endif #endif
#ifdef __LCD_BRIGHTNESS__ #ifdef __LCD_BRIGHTNESS__
{ MT_CALLBACK, 0, "BRIGHTHESS", menu_brightness_cb}, { MT_CALLBACK, 0, "BRIGHTNESS", menu_brightness_cb},
#endif #endif
{ MT_CANCEL, 0, S_LARROW" BACK", NULL }, { MT_CANCEL, 0, S_LARROW" BACK", NULL },
{ MT_NONE, 0, NULL, NULL } // sentinel { MT_NONE, 0, NULL, NULL } // sentinel

Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.