#include "system_menu.h" #include "lcd.h" #include "settings.h" #include "audio_filters.h" #include "bootloader.h" #include "functions.h" #include "swr_analyzer.h" #include "fonts.h" #include "agc.h" #include "screen_layout.h" #include "bands.h" static void SYSMENU_HANDL_TRX_RFPower(int8_t direction); static void SYSMENU_HANDL_TRX_BandMap(int8_t direction); static void SYSMENU_HANDL_TRX_AutoGain(int8_t direction); static void SYSMENU_HANDL_TRX_TWO_SIGNAL_TUNE(int8_t direction); static void SYSMENU_HANDL_TRX_RFFilters(int8_t direction); static void SYSMENU_HANDL_TRX_MICIN(int8_t direction); static void SYSMENU_HANDL_TRX_LINEIN(int8_t direction); static void SYSMENU_HANDL_TRX_USBIN(int8_t direction); static void SYSMENU_HANDL_TRX_SHIFT_INTERVAL(int8_t direction); static void SYSMENU_HANDL_TRX_FRQ_STEP(int8_t direction); static void SYSMENU_HANDL_TRX_FRQ_FAST_STEP(int8_t direction); static void SYSMENU_HANDL_TRX_FRQ_ENC_STEP(int8_t direction); static void SYSMENU_HANDL_TRX_FRQ_ENC_FAST_STEP(int8_t direction); static void SYSMENU_HANDL_TRX_ENC_ACCELERATE(int8_t direction); static void SYSMENU_HANDL_TXOFF_ENC(int8_t direction); static void SYSMENU_HANDL_TRX_ATT_STEP(int8_t direction); static void SYSMENU_HANDL_TRX_DEBUG_CONSOLE(int8_t direction); static void SYSMENU_HANDL_TRX_SetCallsign(int8_t direction); static void SYSMENU_HANDL_TRX_TRANSV_ENABLE(int8_t direction); static void SYSMENU_HANDL_TRX_TRANSV_OFFSET(int8_t direction); static void SYSMENU_HANDL_AUDIO_VOLUME(int8_t direction); static void SYSMENU_HANDL_AUDIO_STEP(int8_t direction); static void SYSMENU_HANDL_AUDIO_IFGain(int8_t direction); static void SYSMENU_HANDL_AUDIO_AGC_GAIN_TARGET(int8_t direction); static void SYSMENU_HANDL_AUDIO_MIC_Gain(int8_t direction); static void SYSMENU_HANDL_AUDIO_MIC_Boost(int8_t direction); static void SYSMENU_HANDL_AUDIO_DNR_THRES(int8_t direction); static void SYSMENU_HANDL_AUDIO_DNR_AVERAGE(int8_t direction); static void SYSMENU_HANDL_AUDIO_DNR_MINMAL(int8_t direction); static void SYSMENU_HANDL_AUDIO_SSB_HPF_pass(int8_t direction); static void SYSMENU_HANDL_AUDIO_SSB_RX_LPF_pass(int8_t direction); static void SYSMENU_HANDL_AUDIO_SSB_TX_LPF_pass(int8_t direction); static void SYSMENU_HANDL_AUDIO_CW_LPF_pass(int8_t direction); static void SYSMENU_HANDL_AUDIO_CW_HPF_pass(int8_t direction); static void SYSMENU_HANDL_AUDIO_AM_RX_LPF_pass(int8_t direction); static void SYSMENU_HANDL_AUDIO_AM_TX_LPF_pass(int8_t direction); static void SYSMENU_HANDL_AUDIO_FM_RX_LPF_pass(int8_t direction); static void SYSMENU_HANDL_AUDIO_FM_TX_LPF_pass(int8_t direction); static void SYSMENU_HANDL_AUDIO_TX_CompressorSpeed_SSB(int8_t direction); static void SYSMENU_HANDL_AUDIO_TX_CompressorSpeed_AMFM(int8_t direction); static void SYSMENU_HANDL_AUDIO_TX_CompressorMaxGain_SSB(int8_t direction); static void SYSMENU_HANDL_AUDIO_TX_CompressorMaxGain_AMFM(int8_t direction); static void SYSMENU_HANDL_AUDIO_RX_AGC_Max_gain(int8_t direction); static void SYSMENU_HANDL_AUDIO_MIC_EQ_LOW(int8_t direction); static void SYSMENU_HANDL_AUDIO_MIC_EQ_MID(int8_t direction); static void SYSMENU_HANDL_AUDIO_MIC_EQ_HIG(int8_t direction); static void SYSMENU_HANDL_AUDIO_RX_EQ_LOW(int8_t direction); static void SYSMENU_HANDL_AUDIO_RX_EQ_MID(int8_t direction); static void SYSMENU_HANDL_AUDIO_RX_EQ_HIG(int8_t direction); static void SYSMENU_HANDL_AUDIO_RX_AGC_SSB_Speed(int8_t direction); static void SYSMENU_HANDL_AUDIO_RX_AGC_CW_Speed(int8_t direction); static void SYSMENU_HANDL_AUDIO_TX_AGCSpeed(int8_t direction); static void SYSMENU_HANDL_AUDIO_RX_AGC_Hold(int8_t direction); static void SYSMENU_HANDL_AUDIO_FMSquelch(int8_t direction); static void SYSMENU_HANDL_AUDIO_VAD_Squelch(int8_t direction); static void SYSMENU_HANDL_AUDIO_Beeper(int8_t direction); static void SYSMENU_HANDL_CW_GENERATOR_SHIFT_HZ(int8_t direction); static void SYSMENU_HANDL_CW_SelfHear(int8_t direction); static void SYSMENU_HANDL_CW_Keyer(int8_t direction); static void SYSMENU_HANDL_CW_Keyer_WPM(int8_t direction); static void SYSMENU_HANDL_CW_Key_timeout(int8_t direction); static void SYSMENU_HANDL_CW_GaussFilter(int8_t direction); static void SYSMENU_HANDL_SCREEN_FFT_Enabled(int8_t direction); static void SYSMENU_HANDL_SCREEN_COLOR_THEME(int8_t direction); static void SYSMENU_HANDL_SCREEN_FFT_Averaging(int8_t direction); static void SYSMENU_HANDL_SCREEN_FFT_Window(int8_t direction); static void SYSMENU_HANDL_SCREEN_FFT_Zoom(int8_t direction); //static void SYSMENU_HANDL_SCREEN_FFT_Color(int8_t direction); static void SYSMENU_HANDL_SCREEN_Freq_Font(int8_t direction); static void SYSMENU_HANDL_SCREEN_FFT_Grid(int8_t direction); static void SYSMENU_HANDL_SCREEN_FFT_Background(int8_t direction); static void SYSMENU_HANDL_SCREEN_FFT_Compressor(int8_t direction); static void SYSMENU_HANDL_SCREEN_FFT_Automatic(int8_t direction); static void SYSMENU_HANDL_SCREEN_FFT_Sensitivity(int8_t direction); //static void SYSMENU_HANDL_SCREEN_LCD_position(int8_t direction);//LCD povorot static void SYSMENU_HANDL_SCREEN_FFT_HoldPeaks(int8_t direction); static void SYSMENU_HANDL_ADC_PGA(int8_t direction); static void SYSMENU_HANDL_ADC_RAND(int8_t direction); static void SYSMENU_HANDL_ADC_SHDN(int8_t direction); static void SYSMENU_HANDL_ADC_DITH(int8_t direction); static void SYSMENU_HANDL_ADC_DRIVER(int8_t direction); static void SYSMENU_HANDL_SETTIME(int8_t direction); static void SYSMENU_HANDL_Bootloader(int8_t direction); static void SYSMENU_HANDL_CALIB_ENCODER_SLOW_RATE(int8_t direction); static void SYSMENU_HANDL_CALIB_ENCODER2_SLOW_RATE(int8_t direction); static void SYSMENU_HANDL_CALIB_ENCODER_INVERT(int8_t direction); static void SYSMENU_HANDL_CALIB_ENCODER2_INVERT(int8_t direction); static void SYSMENU_HANDL_CALIB_ENCODER_DEBOUNCE(int8_t direction); static void SYSMENU_HANDL_CALIB_ENCODER2_DEBOUNCE(int8_t direction); static void SYSMENU_HANDL_CALIB_ENCODER_ON_FALLING(int8_t direction); static void SYSMENU_HANDL_CALIB_CICCOMP_SHIFT(int8_t direction); static void SYSMENU_HANDL_CALIB_TXCICCOMP_SHIFT(int8_t direction); static void SYSMENU_HANDL_CALIB_DAC_SHIFT(int8_t direction); static void SYSMENU_HANDL_CALIB_RF_GAIN_LF(int8_t direction); static void SYSMENU_HANDL_CALIB_RF_GAIN_HF_LOW(int8_t direction); static void SYSMENU_HANDL_CALIB_RF_GAIN_HF(int8_t direction); static void SYSMENU_HANDL_CALIB_RF_GAIN_HF_HIGH(int8_t direction); static void SYSMENU_HANDL_CALIB_S_METER(int8_t direction); static void SYSMENU_HANDL_CALIB_VOLT(int8_t direction); static void SYSMENU_HANDL_CALIB_ADC_OFFSET(int8_t direction); static void SYSMENU_HANDL_CALIB_SWR_TRANS_RATE(int8_t direction); static void SYSMENU_HANDL_CALIB_RF_GAIN_160M(int8_t direction); static void SYSMENU_HANDL_CALIB_RF_GAIN_80M(int8_t direction); static void SYSMENU_HANDL_CALIB_RF_GAIN_40M(int8_t direction); static void SYSMENU_HANDL_CALIB_RF_GAIN_30M(int8_t direction); static void SYSMENU_HANDL_CALIB_RF_GAIN_20M(int8_t direction); static void SYSMENU_HANDL_CALIB_RF_GAIN_17M(int8_t direction); static void SYSMENU_HANDL_CALIB_RF_GAIN_15M(int8_t direction); static void SYSMENU_HANDL_CALIB_RF_GAIN_12M(int8_t direction); static void SYSMENU_HANDL_CALIB_RF_GAIN_10M(int8_t direction); static void SYSMENU_HANDL_VCXO_CALIBR(int8_t direction); static void SYSMENU_HANDL_TRXMENU(int8_t direction); static void SYSMENU_HANDL_AUDIOMENU(int8_t direction); static void SYSMENU_HANDL_CWMENU(int8_t direction); static void SYSMENU_HANDL_LCDMENU(int8_t direction); static void SYSMENU_HANDL_ADCMENU(int8_t direction); static void SYSMENU_HANDL_CALIBRATIONMENU(int8_t direction); static void SYSMENU_HANDL_SERVICESMENU(int8_t direction); static void SYSMENU_HANDL_SWR_BAND_START(int8_t direction); static void SYSMENU_HANDL_SWR_HF_START(int8_t direction); static const struct sysmenu_item_handler sysmenu_handlers[] = { {"TRX Settings", SYSMENU_MENU, 0, SYSMENU_HANDL_TRXMENU}, {"AUDIO Settings", SYSMENU_MENU, 0, SYSMENU_HANDL_AUDIOMENU}, {"CW Settings", SYSMENU_MENU, 0, SYSMENU_HANDL_CWMENU}, {"SCREEN Settings", SYSMENU_MENU, 0, SYSMENU_HANDL_LCDMENU}, {"ADC/DAC Settings", SYSMENU_MENU, 0, SYSMENU_HANDL_ADCMENU}, {"Services", SYSMENU_MENU, 0, SYSMENU_HANDL_SERVICESMENU}, {"Set Clock Time", SYSMENU_RUN, 0, SYSMENU_HANDL_SETTIME}, {"Flash update", SYSMENU_RUN, 0, SYSMENU_HANDL_Bootloader}, {"Calibration", SYSMENU_HIDDEN_MENU, 0, SYSMENU_HANDL_CALIBRATIONMENU}, }; static const uint8_t sysmenu_item_count = sizeof(sysmenu_handlers) / sizeof(sysmenu_handlers[0]); static const struct sysmenu_item_handler sysmenu_trx_handlers[] = { {"RF Power", SYSMENU_UINT8, (uint32_t *)&TRX.RF_Power, SYSMENU_HANDL_TRX_RFPower}, // {"LCD position", SYSMENU_UINT8, (uint32_t *)&TRX.LCD_position, SYSMENU_HANDL_SCREEN_LCD_position},// LCD povorot {"Band Map", SYSMENU_BOOLEAN, (uint32_t *)&TRX.BandMapEnabled, SYSMENU_HANDL_TRX_BandMap}, {"AutoGainer", SYSMENU_BOOLEAN, (uint32_t *)&TRX.AutoGain, SYSMENU_HANDL_TRX_AutoGain}, {"Two Signal TUNE", SYSMENU_BOOLEAN, (uint32_t *)&TRX.TWO_SIGNAL_TUNE, SYSMENU_HANDL_TRX_TWO_SIGNAL_TUNE}, {"Shift Interval", SYSMENU_UINT16, (uint32_t *)&TRX.SHIFT_INTERVAL, SYSMENU_HANDL_TRX_SHIFT_INTERVAL}, {"Freq Step", SYSMENU_UINT16, (uint32_t *)&TRX.FRQ_STEP, SYSMENU_HANDL_TRX_FRQ_STEP}, {"Freq Step FAST", SYSMENU_UINT16, (uint32_t *)&TRX.FRQ_FAST_STEP, SYSMENU_HANDL_TRX_FRQ_FAST_STEP}, {"Freq Step ENC2", SYSMENU_UINT16, (uint32_t *)&TRX.FRQ_ENC_STEP, SYSMENU_HANDL_TRX_FRQ_ENC_STEP}, {"Freq Step FAST ENC2", SYSMENU_UINT16, (uint32_t *)&TRX.FRQ_ENC_FAST_STEP, SYSMENU_HANDL_TRX_FRQ_ENC_FAST_STEP}, {"Encoder Accelerate", SYSMENU_BOOLEAN, (uint32_t *)&TRX.Encoder_Accelerate, SYSMENU_HANDL_TRX_ENC_ACCELERATE}, {"Encoder TX/OFF", SYSMENU_BOOLEAN, (uint32_t *)&TRX.Encoder_OFF, SYSMENU_HANDL_TXOFF_ENC}, {"Att step, dB", SYSMENU_UINT8, (uint32_t *)&TRX.ATT_STEP, SYSMENU_HANDL_TRX_ATT_STEP}, {"DEBUG Console", SYSMENU_BOOLEAN, (uint32_t *)&TRX.Debug_Console, SYSMENU_HANDL_TRX_DEBUG_CONSOLE}, {"MIC IN", SYSMENU_BOOLEAN, (uint32_t *)&TRX.InputType_MIC, SYSMENU_HANDL_TRX_MICIN}, {"LINE IN", SYSMENU_BOOLEAN, (uint32_t *)&TRX.InputType_LINE, SYSMENU_HANDL_TRX_LINEIN}, {"USB IN", SYSMENU_BOOLEAN, (uint32_t *)&TRX.InputType_USB, SYSMENU_HANDL_TRX_USBIN}, {"Callsign", SYSMENU_RUN, 0, SYSMENU_HANDL_TRX_SetCallsign}, {"Transverter Enable", SYSMENU_BOOLEAN, (uint32_t *)&TRX.Transverter_Enabled, SYSMENU_HANDL_TRX_TRANSV_ENABLE}, {"Transverter Offset, mHz", SYSMENU_UINT16, (uint32_t *)&TRX.Transverter_Offset_Mhz, SYSMENU_HANDL_TRX_TRANSV_OFFSET}, }; static const uint8_t sysmenu_trx_item_count = sizeof(sysmenu_trx_handlers) / sizeof(sysmenu_trx_handlers[0]); static const struct sysmenu_item_handler sysmenu_audio_handlers[] = { {"Volume", SYSMENU_UINT8, (uint32_t *)&TRX.Volume, SYSMENU_HANDL_AUDIO_VOLUME}, {"Volume Step", SYSMENU_UINT8, (uint32_t *)&TRX.Volume_Step, SYSMENU_HANDL_AUDIO_STEP}, {"IF Gain, dB", SYSMENU_UINT8, (uint32_t *)&TRX.IF_Gain, SYSMENU_HANDL_AUDIO_IFGain}, {"AGC Gain target, LKFS", SYSMENU_INT8, (uint32_t *)&TRX.AGC_GAIN_TARGET, SYSMENU_HANDL_AUDIO_AGC_GAIN_TARGET}, {"Mic Gain", SYSMENU_UINT8, (uint32_t *)&TRX.MIC_GAIN, SYSMENU_HANDL_AUDIO_MIC_Gain}, {"Mic Boost", SYSMENU_BOOLEAN, (uint32_t *)&TRX.MIC_BOOST, SYSMENU_HANDL_AUDIO_MIC_Boost}, {"DNR Threshold", SYSMENU_UINT8, (uint32_t *)&TRX.DNR_SNR_THRESHOLD, SYSMENU_HANDL_AUDIO_DNR_THRES}, {"DNR Average", SYSMENU_UINT8, (uint32_t *)&TRX.DNR_AVERAGE, SYSMENU_HANDL_AUDIO_DNR_AVERAGE}, {"DNR Minimal", SYSMENU_UINT8, (uint32_t *)&TRX.DNR_MINIMAL, SYSMENU_HANDL_AUDIO_DNR_MINMAL}, {"SSB HPF Pass", SYSMENU_UINT16, (uint32_t *)&TRX.SSB_HPF_Filter, SYSMENU_HANDL_AUDIO_SSB_HPF_pass}, {"SSB RX LPF Pass", SYSMENU_UINT16, (uint32_t *)&TRX.RX_SSB_LPF_Filter, SYSMENU_HANDL_AUDIO_SSB_RX_LPF_pass}, {"SSB TX LPF Pass", SYSMENU_UINT16, (uint32_t *)&TRX.TX_SSB_LPF_Filter, SYSMENU_HANDL_AUDIO_SSB_TX_LPF_pass}, {"CW HPF Pass", SYSMENU_UINT16, (uint32_t *)&TRX.CW_HPF_Filter, SYSMENU_HANDL_AUDIO_CW_HPF_pass}, {"CW LPF Pass", SYSMENU_UINT16, (uint32_t *)&TRX.CW_LPF_Filter, SYSMENU_HANDL_AUDIO_CW_LPF_pass}, {"AM RX LPF Pass", SYSMENU_UINT16, (uint32_t *)&TRX.RX_AM_LPF_Filter, SYSMENU_HANDL_AUDIO_AM_RX_LPF_pass}, {"AM TX LPF Pass", SYSMENU_UINT16, (uint32_t *)&TRX.TX_AM_LPF_Filter, SYSMENU_HANDL_AUDIO_AM_TX_LPF_pass}, {"FM RX LPF Pass", SYSMENU_UINT16, (uint32_t *)&TRX.RX_FM_LPF_Filter, SYSMENU_HANDL_AUDIO_FM_RX_LPF_pass}, {"FM TX LPF Pass", SYSMENU_UINT16, (uint32_t *)&TRX.TX_FM_LPF_Filter, SYSMENU_HANDL_AUDIO_FM_TX_LPF_pass}, {"FM Squelch", SYSMENU_UINT8, (uint32_t *)&TRX.FM_SQL_threshold, SYSMENU_HANDL_AUDIO_FMSquelch}, {"TX Compr Speed SSB", SYSMENU_UINT8, (uint32_t *)&TRX.TX_Compressor_speed_SSB, SYSMENU_HANDL_AUDIO_TX_CompressorSpeed_SSB}, {"TX Compr MaxGain SSB", SYSMENU_UINT8, (uint32_t *)&TRX.TX_Compressor_maxgain_SSB, SYSMENU_HANDL_AUDIO_TX_CompressorMaxGain_SSB}, {"TX Compr Speed AMFM", SYSMENU_UINT8, (uint32_t *)&TRX.TX_Compressor_speed_AMFM, SYSMENU_HANDL_AUDIO_TX_CompressorSpeed_AMFM}, {"TX Compr MaxGain AMFM", SYSMENU_UINT8,(uint32_t *)&TRX.TX_Compressor_maxgain_AMFM, SYSMENU_HANDL_AUDIO_TX_CompressorMaxGain_AMFM}, {"MIC EQ Low", SYSMENU_INT8, (uint32_t *)&TRX.MIC_EQ_LOW, SYSMENU_HANDL_AUDIO_MIC_EQ_LOW}, {"MIC EQ Mid", SYSMENU_INT8, (uint32_t *)&TRX.MIC_EQ_MID, SYSMENU_HANDL_AUDIO_MIC_EQ_MID}, {"MIC EQ High", SYSMENU_INT8, (uint32_t *)&TRX.MIC_EQ_HIG, SYSMENU_HANDL_AUDIO_MIC_EQ_HIG}, {"RX EQ Low", SYSMENU_INT8, (uint32_t *)&TRX.RX_EQ_LOW, SYSMENU_HANDL_AUDIO_RX_EQ_LOW}, {"RX EQ Mid", SYSMENU_INT8, (uint32_t *)&TRX.RX_EQ_MID, SYSMENU_HANDL_AUDIO_RX_EQ_MID}, {"RX EQ High", SYSMENU_INT8, (uint32_t *)&TRX.RX_EQ_HIG, SYSMENU_HANDL_AUDIO_RX_EQ_HIG}, {"RX AGC SSB Speed", SYSMENU_UINT8, (uint32_t *)&TRX.RX_AGC_SSB_speed, SYSMENU_HANDL_AUDIO_RX_AGC_SSB_Speed}, {"RX AGC CW Speed", SYSMENU_UINT8, (uint32_t *)&TRX.RX_AGC_CW_speed, SYSMENU_HANDL_AUDIO_RX_AGC_CW_Speed}, {"RX AGC Max gain", SYSMENU_UINT8, (uint32_t *)&TRX.RX_AGC_Max_gain, SYSMENU_HANDL_AUDIO_RX_AGC_Max_gain}, {"RX AGC Hold time", SYSMENU_UINT16, (uint32_t *)&TRX.RX_AGC_Hold, SYSMENU_HANDL_AUDIO_RX_AGC_Hold}, {"TX AGC Speed", SYSMENU_UINT8, (uint32_t *)&TRX.TX_AGC_speed, SYSMENU_HANDL_AUDIO_TX_AGCSpeed}, {"Beeper", SYSMENU_BOOLEAN, (uint32_t *)&TRX.Beeper, SYSMENU_HANDL_AUDIO_Beeper}, }; static const uint8_t sysmenu_audio_item_count = sizeof(sysmenu_audio_handlers) / sizeof(sysmenu_audio_handlers[0]); static const struct sysmenu_item_handler sysmenu_cw_handlers[] = { {"CW Key timeout", SYSMENU_UINT16, (uint32_t *)&TRX.CW_Key_timeout, SYSMENU_HANDL_CW_Key_timeout}, {"CW Generator shift", SYSMENU_UINT16, (uint32_t *)&TRX.CW_GENERATOR_SHIFT_HZ, SYSMENU_HANDL_CW_GENERATOR_SHIFT_HZ}, {"CW Self Hear", SYSMENU_BOOLEAN, (uint32_t *)&TRX.CW_SelfHear, SYSMENU_HANDL_CW_SelfHear}, {"CW Keyer", SYSMENU_BOOLEAN, (uint32_t *)&TRX.CW_KEYER, SYSMENU_HANDL_CW_Keyer}, {"CW Keyer WPM", SYSMENU_UINT8, (uint32_t *)&TRX.CW_KEYER_WPM, SYSMENU_HANDL_CW_Keyer_WPM}, {"CW Gauss filter", SYSMENU_BOOLEAN, (uint32_t *)&TRX.CW_GaussFilter, SYSMENU_HANDL_CW_GaussFilter}, }; static const uint8_t sysmenu_cw_item_count = sizeof(sysmenu_cw_handlers) / sizeof(sysmenu_cw_handlers[0]); static const struct sysmenu_item_handler sysmenu_screen_handlers[] = { {"FFT Zoom", SYSMENU_UINT8, (uint32_t *)&TRX.FFT_Zoom, SYSMENU_HANDL_SCREEN_FFT_Zoom}, {"Color Theme", SYSMENU_UINT8, (uint32_t *)&TRX.ColorThemeId, SYSMENU_HANDL_SCREEN_COLOR_THEME}, // {"3.FFT Color", SYSMENU_UINT8, (uint32_t *)&TRX.FFT_Color, SYSMENU_HANDL_SCREEN_FFT_Color}, {"Freq Font", SYSMENU_UINT8, (uint32_t *)&TRX.Freq_Font, SYSMENU_HANDL_SCREEN_Freq_Font}, {"FFT Grid", SYSMENU_UINT8, (uint32_t *)&TRX.FFT_Grid, SYSMENU_HANDL_SCREEN_FFT_Grid}, {"FFT Background", SYSMENU_BOOLEAN, (uint32_t *)&TRX.FFT_Background, SYSMENU_HANDL_SCREEN_FFT_Background}, {"FFT Enabled", SYSMENU_BOOLEAN, (uint32_t *)&TRX.FFT_Enabled, SYSMENU_HANDL_SCREEN_FFT_Enabled}, {"FFT Compressor", SYSMENU_BOOLEAN, (uint32_t *)&TRX.FFT_Compressor, SYSMENU_HANDL_SCREEN_FFT_Compressor}, {"FFT Averaging", SYSMENU_UINT8, (uint32_t *)&TRX.FFT_Averaging, SYSMENU_HANDL_SCREEN_FFT_Averaging}, {"FFT Window", SYSMENU_UINT8, (uint32_t *)&TRX.FFT_Window, SYSMENU_HANDL_SCREEN_FFT_Window}, {"FFT Hold Peaks", SYSMENU_BOOLEAN, (uint32_t *)&TRX.FFT_HoldPeaks, SYSMENU_HANDL_SCREEN_FFT_HoldPeaks}, {"FFT Automatic", SYSMENU_BOOLEAN, (uint32_t *)&TRX.FFT_Automatic, SYSMENU_HANDL_SCREEN_FFT_Automatic}, {"FFT Sensitivity", SYSMENU_UINT8, (uint32_t *) &TRX.FFT_Sensitivity, SYSMENU_HANDL_SCREEN_FFT_Sensitivity}, }; static const uint8_t sysmenu_screen_item_count = sizeof(sysmenu_screen_handlers) / sizeof(sysmenu_screen_handlers[0]); static const struct sysmenu_item_handler sysmenu_adc_handlers[] = { {"ADC Driver", SYSMENU_BOOLEAN, (uint32_t *)&TRX.ADC_Driver, SYSMENU_HANDL_ADC_DRIVER}, {"ADC Shutdown", SYSMENU_BOOLEAN, (uint32_t *)&TRX.ADC_SHDN, SYSMENU_HANDL_ADC_SHDN}, }; static const uint8_t sysmenu_adc_item_count = sizeof(sysmenu_adc_handlers) / sizeof(sysmenu_adc_handlers[0]); static const struct sysmenu_item_handler sysmenu_calibration_handlers[] = { {"Encoder invert", SYSMENU_BOOLEAN, (uint32_t *)&CALIBRATE.ENCODER_INVERT, SYSMENU_HANDL_CALIB_ENCODER_INVERT}, {"Encoder2 invert", SYSMENU_BOOLEAN, (uint32_t *)&CALIBRATE.ENCODER2_INVERT, SYSMENU_HANDL_CALIB_ENCODER2_INVERT}, {"Encoder debounce", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.ENCODER_DEBOUNCE, SYSMENU_HANDL_CALIB_ENCODER_DEBOUNCE}, {"Encoder2 debounce", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.ENCODER2_DEBOUNCE, SYSMENU_HANDL_CALIB_ENCODER2_DEBOUNCE}, {"Encoder slow rate", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.ENCODER_SLOW_RATE, SYSMENU_HANDL_CALIB_ENCODER_SLOW_RATE}, {"Encoder2 slow rate", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.ENCODER2_SLOW_RATE, SYSMENU_HANDL_CALIB_ENCODER2_SLOW_RATE}, {"Encoder on falling", SYSMENU_BOOLEAN, (uint32_t *)&CALIBRATE.ENCODER_ON_FALLING, SYSMENU_HANDL_CALIB_ENCODER_ON_FALLING}, {"CICCOMP Shift", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.CICFIR_GAINER_val, SYSMENU_HANDL_CALIB_CICCOMP_SHIFT}, {"TX CICCOMP Shift", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.TXCICFIR_GAINER_val, SYSMENU_HANDL_CALIB_TXCICCOMP_SHIFT}, {"DAC Shift", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.DAC_GAINER_val, SYSMENU_HANDL_CALIB_DAC_SHIFT}, {"RF GAIN LF", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.rf_out_power_lf, SYSMENU_HANDL_CALIB_RF_GAIN_LF}, //-V641 {"RF GAIN HF LOW", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.rf_out_power_hf_low, SYSMENU_HANDL_CALIB_RF_GAIN_HF_LOW}, //-V641 {"RF GAIN HF", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.rf_out_power_hf, SYSMENU_HANDL_CALIB_RF_GAIN_HF}, //-V641 {"RF GAIN HF HIGH", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.rf_out_power_hf_high, SYSMENU_HANDL_CALIB_RF_GAIN_HF_HIGH}, //-V641 {"S METER", SYSMENU_INT16, (uint32_t *)&CALIBRATE.smeter_calibration, SYSMENU_HANDL_CALIB_S_METER}, {"SWR TRANS RATE", SYSMENU_FLOAT32, (uint32_t *)&CALIBRATE.swr_trans_rate, SYSMENU_HANDL_CALIB_SWR_TRANS_RATE}, {"VOLT CALIBR", SYSMENU_FLOAT32, (uint32_t *)&CALIBRATE.volt_cal_rate, SYSMENU_HANDL_CALIB_VOLT}, {"VCXO CALIBR", SYSMENU_INT16, (uint32_t *)&CALIBRATE.vcxo_calibration, SYSMENU_HANDL_VCXO_CALIBR}, // {"F-correctur 160m", SYSMENU_INT16, (uint32_t *)&CALIBRATE.freq_correctur_160, SYSMENU_HANDL_CALIB_FREQUENCY_160M}, // {"F-correctur 80m", SYSMENU_INT16, (uint32_t *)&CALIBRATE.freq_correctur_80, SYSMENU_HANDL_CALIB_FREQUENCY_80M}, // {"F-correctur 40m", SYSMENU_INT16, (uint32_t *)&CALIBRATE.freq_correctur_40, SYSMENU_HANDL_CALIB_FREQUENCY_40M}, // {"F-correctur 30m", SYSMENU_INT16, (uint32_t *)&CALIBRATE.freq_correctur_30, SYSMENU_HANDL_CALIB_FREQUENCY_30M}, // {"F-correctur 20m", SYSMENU_INT16, (uint32_t *)&CALIBRATE.freq_correctur_20, SYSMENU_HANDL_CALIB_FREQUENCY_20M}, // {"F-correctur 17m", SYSMENU_INT16, (uint32_t *)&CALIBRATE.freq_correctur_17, SYSMENU_HANDL_CALIB_FREQUENCY_17M}, // {"F-correctur 15m", SYSMENU_INT16, (uint32_t *)&CALIBRATE.freq_correctur_15, SYSMENU_HANDL_CALIB_FREQUENCY_15M}, // {"F-correctur 12m", SYSMENU_INT16, (uint32_t *)&CALIBRATE.freq_correctur_12, SYSMENU_HANDL_CALIB_FREQUENCY_12M}, // {"F-correctur 27MHz", SYSMENU_INT16, (uint32_t *)&CALIBRATE.freq_correctur_sibi, SYSMENU_HANDL_CALIB_FREQUENCY_SIBI}, // {"F-correctur 10m", SYSMENU_INT16, (uint32_t *)&CALIBRATE.freq_correctur_10, SYSMENU_HANDL_CALIB_FREQUENCY_10M}, // {"F-correctur 52MHz", SYSMENU_INT16, (uint32_t *)&CALIBRATE.freq_correctur_52, SYSMENU_HANDL_CALIB_FREQUENCY_52}, {"RF GAIN 160m", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.rf_out_power_160m, SYSMENU_HANDL_CALIB_RF_GAIN_160M}, {"RF GAIN 80m", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.rf_out_power_80m, SYSMENU_HANDL_CALIB_RF_GAIN_80M}, {"RF GAIN 40m", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.rf_out_power_40m, SYSMENU_HANDL_CALIB_RF_GAIN_40M}, {"RF GAIN 30m", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.rf_out_power_30m, SYSMENU_HANDL_CALIB_RF_GAIN_30M}, {"RF GAIN 20m", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.rf_out_power_20m, SYSMENU_HANDL_CALIB_RF_GAIN_20M}, {"RF GAIN 17m", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.rf_out_power_17m, SYSMENU_HANDL_CALIB_RF_GAIN_17M}, {"RF GAIN 15m", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.rf_out_power_15m, SYSMENU_HANDL_CALIB_RF_GAIN_15M}, {"RF GAIN 12m", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.rf_out_power_12m, SYSMENU_HANDL_CALIB_RF_GAIN_12M}, {"RF GAIN 10m", SYSMENU_UINT8, (uint32_t *)&CALIBRATE.rf_out_power_10m, SYSMENU_HANDL_CALIB_RF_GAIN_10M}, }; static const uint8_t sysmenu_calibration_item_count = sizeof(sysmenu_calibration_handlers) / sizeof(sysmenu_calibration_handlers[0]); static const struct sysmenu_item_handler sysmenu_services_handlers[] = { {"Band SWR", SYSMENU_RUN, 0, SYSMENU_HANDL_SWR_BAND_START}, {"HF SWR", SYSMENU_RUN, 0, SYSMENU_HANDL_SWR_HF_START}, }; static const uint8_t sysmenu_services_item_count = sizeof(sysmenu_services_handlers) / sizeof(sysmenu_services_handlers[0]); //COMMON MENU static void drawSystemMenuElement(char *title, SystemMenuType type, uint32_t *value, bool onlyVal); static void SYSMENU_WIFI_DrawSelectAPMenu(bool full_redraw); static void SYSMENU_WIFI_SelectAPMenuMove(int8_t dir); static void SYSMENU_WIFI_DrawAPpasswordMenu(bool full_redraw); static void SYSMENU_WIFI_RotatePasswordChar(int8_t dir); static void SYSMENU_TRX_DrawCallsignMenu(bool full_redraw); static void SYSMENU_TRX_RotateCallsignChar(int8_t dir); static struct sysmenu_item_handler *sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_handlers[0]; static uint8_t *sysmenu_item_count_selected = (uint8_t*)&sysmenu_item_count; static uint8_t systemMenuIndex = 0; static uint8_t systemMenuRootIndex = 0; static uint16_t sysmenu_y = 5; static uint8_t sysmenu_i = 0; static bool sysmenu_onroot = true; bool sysmenu_hiddenmenu_enabled = false; static bool sysmenu_services_opened = false; static bool sysmenu_infowindow_opened = false; static bool sysmenu_item_selected_by_enc2 = false; static bool sysmenu_trx_setCallsign_menu_opened = false; static uint8_t sysmenu_trx_selected_callsign_char_index = 0; //Time menu static bool sysmenu_timeMenuOpened = false; static uint8_t TimeMenuSelection = 0; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" //TRX MENU static void SYSMENU_HANDL_TRXMENU(int8_t direction) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_trx_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_trx_item_count; sysmenu_onroot = false; systemMenuIndex = 0; LCD_UpdateQuery.SystemMenuRedraw = true; } void SYSMENU_TRX_RFPOWER_HOTKEY(void) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_trx_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_trx_item_count; sysmenu_onroot = false; systemMenuIndex = 0; LCD_redraw(false); } void SYSMENU_TRX_STEP_HOTKEY(void) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_trx_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_trx_item_count; sysmenu_onroot = false; systemMenuIndex = 7; if (TRX.Fast) systemMenuIndex = 8; LCD_redraw(false); } static void SYSMENU_HANDL_TRX_BandMap(int8_t direction) { if (direction > 0) TRX.BandMapEnabled = true; if (direction < 0) TRX.BandMapEnabled = false; } static void SYSMENU_HANDL_TRX_AutoGain(int8_t direction) { if (direction > 0) TRX.AutoGain = true; if (direction < 0) TRX.AutoGain = false; TRX.ATT = false; FPGA_NeedSendParams = true; LCD_UpdateQuery.TopButtons = true; NeedSaveSettings = true; } static void SYSMENU_HANDL_TRX_TWO_SIGNAL_TUNE(int8_t direction) { if (direction > 0) TRX.TWO_SIGNAL_TUNE = true; if (direction < 0) TRX.TWO_SIGNAL_TUNE = false; } static void SYSMENU_HANDL_TRX_RFPower(int8_t direction) { if (direction > 0 || TRX.RF_Power > 0) TRX.RF_Power += direction; if (TRX.RF_Power > 100) TRX.RF_Power = 100; } static void SYSMENU_HANDL_TRX_MICIN(int8_t direction) { if (direction > 0) TRX.InputType_MIC = true; if (direction < 0) TRX.InputType_MIC = false; TRX.InputType_LINE = false; TRX.InputType_USB = false; LCD_UpdateQuery.SystemMenu = true; TRX_Restart_Mode(); WM8731_TXRX_mode(); } static void SYSMENU_HANDL_TRX_LINEIN(int8_t direction) { if (direction > 0) TRX.InputType_LINE = true; if (direction < 0) TRX.InputType_LINE = false; TRX.InputType_MIC = false; TRX.InputType_USB = false; LCD_UpdateQuery.SystemMenu = true; TRX_Restart_Mode(); WM8731_TXRX_mode(); } static void SYSMENU_HANDL_TRX_USBIN(int8_t direction) { if (direction > 0) TRX.InputType_USB = true; if (direction < 0) TRX.InputType_USB = false; TRX.InputType_MIC = false; TRX.InputType_LINE = false; LCD_UpdateQuery.SystemMenu = true; TRX_Restart_Mode(); WM8731_TXRX_mode(); } static void SYSMENU_HANDL_TRX_DEBUG_CONSOLE(int8_t direction) { if (direction > 0) TRX.Debug_Console = true; if (direction < 0) TRX.Debug_Console = false; } static void SYSMENU_HANDL_TRX_SHIFT_INTERVAL(int8_t direction) { TRX.SHIFT_INTERVAL += direction * 100; if (TRX.SHIFT_INTERVAL < 100) TRX.SHIFT_INTERVAL = 100; if (TRX.SHIFT_INTERVAL > 10000) TRX.SHIFT_INTERVAL = 10000; } static void SYSMENU_HANDL_TRX_FRQ_STEP(int8_t direction) { const uint16_t freq_steps[] = {1, 10, 25, 50, 100}; for (uint8_t i = 0; i < ARRLENTH(freq_steps); i++) if (TRX.FRQ_STEP == freq_steps[i]) { if (direction < 0) { if (i > 0) TRX.FRQ_STEP = freq_steps[i - 1]; else TRX.FRQ_STEP = freq_steps[0]; return; } else { if (i < (ARRLENTH(freq_steps) - 1)) TRX.FRQ_STEP = freq_steps[i + 1]; else TRX.FRQ_STEP = freq_steps[ARRLENTH(freq_steps) - 1]; return; } } TRX.FRQ_STEP = freq_steps[0]; } static void SYSMENU_HANDL_TRX_FRQ_FAST_STEP(int8_t direction) { const uint16_t freq_steps[] = {10, 25, 50, 100, 500, 1000}; for (uint8_t i = 0; i < ARRLENTH(freq_steps); i++) if (TRX.FRQ_FAST_STEP == freq_steps[i]) { if (direction < 0) { if (i > 0) TRX.FRQ_FAST_STEP = freq_steps[i - 1]; else TRX.FRQ_FAST_STEP = freq_steps[0]; return; } else { if (i < (ARRLENTH(freq_steps) - 1)) TRX.FRQ_FAST_STEP = freq_steps[i + 1]; else TRX.FRQ_FAST_STEP = freq_steps[ARRLENTH(freq_steps) - 1]; return; } } TRX.FRQ_FAST_STEP = freq_steps[0]; } static void SYSMENU_HANDL_TRX_FRQ_ENC_STEP(int8_t direction) { const uint16_t freq_steps[] = {1, 10, 25, 50, 100, 500, 1000, 5000}; for (uint8_t i = 0; i < ARRLENTH(freq_steps); i++) if (TRX.FRQ_ENC_STEP == freq_steps[i]) { if (direction < 0) { if (i > 0) TRX.FRQ_ENC_STEP = freq_steps[i - 1]; else TRX.FRQ_ENC_STEP = freq_steps[0]; return; } else { if (i < (ARRLENTH(freq_steps) - 1)) TRX.FRQ_ENC_STEP = freq_steps[i + 1]; else TRX.FRQ_ENC_STEP = freq_steps[ARRLENTH(freq_steps) - 1]; return; } } TRX.FRQ_ENC_STEP = freq_steps[0]; } static void SYSMENU_HANDL_TRX_FRQ_ENC_FAST_STEP(int8_t direction) { const uint16_t freq_steps[] = {1, 10, 25, 50, 100, 500, 1000, 5000}; for (uint8_t i = 0; i < ARRLENTH(freq_steps); i++) if (TRX.FRQ_ENC_FAST_STEP == freq_steps[i]) { if (direction < 0) { if (i > 0) TRX.FRQ_ENC_FAST_STEP = freq_steps[i - 1]; else TRX.FRQ_ENC_FAST_STEP = freq_steps[0]; return; } else { if (i < (ARRLENTH(freq_steps) - 1)) TRX.FRQ_ENC_FAST_STEP = freq_steps[i + 1]; else TRX.FRQ_ENC_FAST_STEP = freq_steps[ARRLENTH(freq_steps) - 1]; return; } } TRX.FRQ_ENC_FAST_STEP = freq_steps[0]; } static void SYSMENU_HANDL_TRX_ENC_ACCELERATE(int8_t direction) { if (direction > 0) TRX.Encoder_Accelerate = true; if (direction < 0) TRX.Encoder_Accelerate = false; } static void SYSMENU_HANDL_TXOFF_ENC(int8_t direction) { if (direction < 0) TRX.Encoder_OFF = true; if (direction > 0) TRX.Encoder_OFF = false; } static void SYSMENU_HANDL_TRX_ATT_STEP(int8_t direction) { TRX.ATT_STEP += direction; if (TRX.ATT_STEP < 1) TRX.ATT_STEP = 1; if (TRX.ATT_STEP > 15) TRX.ATT_STEP = 15; } static void SYSMENU_TRX_DrawCallsignMenu(bool full_redraw) { if (full_redraw) { LCDDriver_Fill(BG_COLOR); LCDDriver_printText("CALLSIGN:", 5, 5, FG_COLOR, BG_COLOR, 2); } LCDDriver_printText(TRX.CALLSIGN, 10, 37, COLOR_GREEN, BG_COLOR, 2); LCDDriver_drawFastHLine(8 + sysmenu_trx_selected_callsign_char_index * 12, 54, 12, COLOR_RED); } static void SYSMENU_TRX_RotateCallsignChar(int8_t dir) { bool full_redraw = false; if (TRX.CALLSIGN[sysmenu_trx_selected_callsign_char_index] == 0) full_redraw = true; TRX.CALLSIGN[sysmenu_trx_selected_callsign_char_index] += dir; // do not show special characters if (TRX.CALLSIGN[sysmenu_trx_selected_callsign_char_index] >= 1 && TRX.CALLSIGN[sysmenu_trx_selected_callsign_char_index] <= 32 && dir > 0) TRX.CALLSIGN[sysmenu_trx_selected_callsign_char_index] = 33; if (TRX.CALLSIGN[sysmenu_trx_selected_callsign_char_index] >= 1 && TRX.CALLSIGN[sysmenu_trx_selected_callsign_char_index] <= 32 && dir < 0) TRX.CALLSIGN[sysmenu_trx_selected_callsign_char_index] = 0; if (TRX.CALLSIGN[sysmenu_trx_selected_callsign_char_index] >= 127) TRX.CALLSIGN[sysmenu_trx_selected_callsign_char_index] = 0; if (TRX.CALLSIGN[sysmenu_trx_selected_callsign_char_index] == 0) full_redraw = true; if (full_redraw) LCD_UpdateQuery.SystemMenuRedraw = true; else LCD_UpdateQuery.SystemMenu = true; } static void SYSMENU_HANDL_TRX_SetCallsign(int8_t direction) { sysmenu_trx_setCallsign_menu_opened = true; SYSMENU_TRX_DrawCallsignMenu(true); LCD_UpdateQuery.SystemMenuRedraw = true; } static void SYSMENU_HANDL_TRX_TRANSV_ENABLE(int8_t direction) { if (direction > 0) TRX.Transverter_Enabled = true; if (direction < 0) TRX.Transverter_Enabled = false; } static void SYSMENU_HANDL_TRX_TRANSV_OFFSET(int8_t direction) { TRX.Transverter_Offset_Mhz += direction; if (TRX.Transverter_Offset_Mhz < 1) TRX.Transverter_Offset_Mhz = 1; if (TRX.Transverter_Offset_Mhz > 500) TRX.Transverter_Offset_Mhz = 500; } //AUDIO MENU static void SYSMENU_HANDL_AUDIOMENU(int8_t direction) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_audio_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_audio_item_count; sysmenu_onroot = false; systemMenuIndex = 0; LCD_UpdateQuery.SystemMenuRedraw = true; } void SYSMENU_AUDIO_VOLUME_HOTKEY(void) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_audio_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_audio_item_count; sysmenu_onroot = false; systemMenuIndex = 0; LCD_redraw(false); } void SYSMENU_AUDIO_BW_SSB_HOTKEY(void) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_audio_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_audio_item_count; sysmenu_onroot = false; systemMenuIndex = 8; LCD_redraw(false); } void SYSMENU_AUDIO_BW_CW_HOTKEY(void) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_audio_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_audio_item_count; sysmenu_onroot = false; systemMenuIndex = 10; LCD_redraw(false); } void SYSMENU_AUDIO_BW_AM_HOTKEY(void) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_audio_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_audio_item_count; sysmenu_onroot = false; systemMenuIndex = 11; LCD_redraw(false); } void SYSMENU_AUDIO_BW_FM_HOTKEY(void) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_audio_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_audio_item_count; sysmenu_onroot = false; systemMenuIndex = 12; LCD_redraw(false); } void SYSMENU_AUDIO_HPF_SSB_HOTKEY(void) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_audio_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_audio_item_count; sysmenu_onroot = false; systemMenuIndex = 7; LCD_redraw(false); } void SYSMENU_AUDIO_HPF_CW_HOTKEY(void) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_audio_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_audio_item_count; systemMenuIndex = 9; LCD_redraw(false); } void SYSMENU_AUDIO_SQUELCH_HOTKEY(void) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_audio_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_audio_item_count; sysmenu_onroot = false; systemMenuIndex = 13; LCD_redraw(false); } void SYSMENU_AUDIO_AGC_HOTKEY(void) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_audio_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_audio_item_count; sysmenu_onroot = false; systemMenuIndex = 21; LCD_redraw(false); } static void SYSMENU_HANDL_AUDIO_IFGain(int8_t direction) { TRX.IF_Gain += direction; if (TRX.IF_Gain < 1) TRX.IF_Gain = 1; if (TRX.IF_Gain > 80) TRX.IF_Gain = 80; int8_t band = getBandFromFreq(CurrentVFO()->Freq, true); if (band > 0) { TRX.BANDS_SAVED_SETTINGS[band].IF_Gain = TRX.IF_Gain; } NeedSaveSettings = true; } static void SYSMENU_HANDL_AUDIO_VOLUME(int8_t direction) { TRX.Volume += direction; if (TRX.Volume < 1) TRX.Volume = 1; if (TRX.Volume > 100) TRX.Volume = 100; } static void SYSMENU_HANDL_AUDIO_STEP(int8_t direction) { TRX.Volume_Step += direction; if (TRX.Volume_Step < 1) TRX.Volume_Step = 1; if (TRX.Volume_Step > 5) TRX.Volume_Step = 5; } static void SYSMENU_HANDL_AUDIO_AGC_GAIN_TARGET(int8_t direction) { TRX.AGC_GAIN_TARGET += direction; if (TRX.AGC_GAIN_TARGET < -80) TRX.AGC_GAIN_TARGET = -80; if (TRX.AGC_GAIN_TARGET > -10) TRX.AGC_GAIN_TARGET = -10; } static void SYSMENU_HANDL_AUDIO_MIC_Gain(int8_t direction) { TRX.MIC_GAIN += direction; if (TRX.MIC_GAIN < 1) TRX.MIC_GAIN = 1; if (TRX.MIC_GAIN > 20) TRX.MIC_GAIN = 20; } static void SYSMENU_HANDL_AUDIO_MIC_Boost(int8_t direction) { if (direction > 0) TRX.MIC_BOOST = true; if (direction < 0) TRX.MIC_BOOST = false; //reinit codec WM8731_TXRX_mode(); } static void SYSMENU_HANDL_AUDIO_DNR_THRES(int8_t direction) { TRX.DNR_SNR_THRESHOLD += direction; if (TRX.DNR_SNR_THRESHOLD < 1) TRX.DNR_SNR_THRESHOLD = 1; if (TRX.DNR_SNR_THRESHOLD > 100) TRX.DNR_SNR_THRESHOLD = 100; } static void SYSMENU_HANDL_AUDIO_DNR_AVERAGE(int8_t direction) { TRX.DNR_AVERAGE += direction; if (TRX.DNR_AVERAGE < 1) TRX.DNR_AVERAGE = 1; if (TRX.DNR_AVERAGE > 100) TRX.DNR_AVERAGE = 100; } static void SYSMENU_HANDL_AUDIO_DNR_MINMAL(int8_t direction) { TRX.DNR_MINIMAL += direction; if (TRX.DNR_MINIMAL < 1) TRX.DNR_MINIMAL = 1; if (TRX.DNR_MINIMAL > 100) TRX.DNR_MINIMAL = 100; } static void SYSMENU_HANDL_AUDIO_MIC_EQ_LOW(int8_t direction) { TRX.MIC_EQ_LOW += direction; if (TRX.MIC_EQ_LOW < -10) TRX.MIC_EQ_LOW = -10; if (TRX.MIC_EQ_LOW > 10) TRX.MIC_EQ_LOW = 10; NeedReinitAudioFilters = true; } static void SYSMENU_HANDL_AUDIO_MIC_EQ_MID(int8_t direction) { TRX.MIC_EQ_MID += direction; if (TRX.MIC_EQ_MID < -10) TRX.MIC_EQ_MID = -10; if (TRX.MIC_EQ_MID > 10) TRX.MIC_EQ_MID = 10; NeedReinitAudioFilters = true; } static void SYSMENU_HANDL_AUDIO_MIC_EQ_HIG(int8_t direction) { TRX.MIC_EQ_HIG += direction; if (TRX.MIC_EQ_HIG < -10) TRX.MIC_EQ_HIG = -10; if (TRX.MIC_EQ_HIG > 10) TRX.MIC_EQ_HIG = 10; NeedReinitAudioFilters = true; } static void SYSMENU_HANDL_AUDIO_RX_EQ_LOW(int8_t direction) { TRX.RX_EQ_LOW += direction; if (TRX.RX_EQ_LOW < -10) TRX.RX_EQ_LOW = -10; if (TRX.RX_EQ_LOW > 10) TRX.RX_EQ_LOW = 10; NeedReinitAudioFilters = true; } static void SYSMENU_HANDL_AUDIO_RX_EQ_MID(int8_t direction) { TRX.RX_EQ_MID += direction; if (TRX.RX_EQ_MID < -10) TRX.RX_EQ_MID = -10; if (TRX.RX_EQ_MID > 10) TRX.RX_EQ_MID = 10; NeedReinitAudioFilters = true; } static void SYSMENU_HANDL_AUDIO_RX_EQ_HIG(int8_t direction) { TRX.RX_EQ_HIG += direction; if (TRX.RX_EQ_HIG < -10) TRX.RX_EQ_HIG = -10; if (TRX.RX_EQ_HIG > 10) TRX.RX_EQ_HIG = 10; NeedReinitAudioFilters = true; } static void SYSMENU_HANDL_AUDIO_RX_AGC_SSB_Speed(int8_t direction) { TRX.RX_AGC_SSB_speed += direction; if (TRX.RX_AGC_SSB_speed < 1) TRX.RX_AGC_SSB_speed = 1; if (TRX.RX_AGC_SSB_speed > 20) TRX.RX_AGC_SSB_speed = 20; } static void SYSMENU_HANDL_AUDIO_RX_AGC_CW_Speed(int8_t direction) { TRX.RX_AGC_CW_speed += direction; if (TRX.RX_AGC_CW_speed < 1) TRX.RX_AGC_CW_speed = 1; if (TRX.RX_AGC_CW_speed > 20) TRX.RX_AGC_CW_speed = 20; } static void SYSMENU_HANDL_AUDIO_RX_AGC_Max_gain(int8_t direction) { TRX.RX_AGC_Max_gain += direction; if (TRX.RX_AGC_Max_gain < 1) TRX.RX_AGC_Max_gain = 1; if (TRX.RX_AGC_Max_gain > 50) TRX.RX_AGC_Max_gain = 50; } static void SYSMENU_HANDL_AUDIO_RX_AGC_Hold(int8_t direction) { if(TRX.RX_AGC_Hold > 0 || direction > 0) TRX.RX_AGC_Hold += direction * 100; if (TRX.RX_AGC_Hold > 5000) TRX.RX_AGC_Hold = 5000; } static void SYSMENU_HANDL_AUDIO_TX_AGCSpeed(int8_t direction) { TRX.TX_AGC_speed += direction; if (TRX.TX_AGC_speed < 1) TRX.TX_AGC_speed = 1; if (TRX.TX_AGC_speed > 10) TRX.TX_AGC_speed = 10; } static void SYSMENU_HANDL_AUDIO_FMSquelch(int8_t direction) { if (direction < 0 && TRX.FM_SQL_threshold == 0) return; TRX.FM_SQL_threshold += direction; if (TRX.FM_SQL_threshold > 10) TRX.FM_SQL_threshold = 10; int8_t band = getBandFromFreq(CurrentVFO()->Freq, true); if (band > 0) TRX.BANDS_SAVED_SETTINGS[band].FM_SQL_threshold = TRX.FM_SQL_threshold; } static void SYSMENU_HANDL_AUDIO_TX_CompressorSpeed_SSB(int8_t direction) { TRX.TX_Compressor_speed_SSB += direction; if (TRX.TX_Compressor_speed_SSB < 1) TRX.TX_Compressor_speed_SSB = 1; if (TRX.TX_Compressor_speed_SSB > 200) TRX.TX_Compressor_speed_SSB = 200; } static void SYSMENU_HANDL_AUDIO_TX_CompressorSpeed_AMFM(int8_t direction) { TRX.TX_Compressor_speed_AMFM += direction; if (TRX.TX_Compressor_speed_AMFM < 1) TRX.TX_Compressor_speed_AMFM = 1; if (TRX.TX_Compressor_speed_AMFM > 200) TRX.TX_Compressor_speed_AMFM = 200; } static void SYSMENU_HANDL_AUDIO_TX_CompressorMaxGain_SSB(int8_t direction) { TRX.TX_Compressor_maxgain_SSB += direction; if (TRX.TX_Compressor_maxgain_SSB < 1) TRX.TX_Compressor_maxgain_SSB = 1; if (TRX.TX_Compressor_maxgain_SSB > 30) TRX.TX_Compressor_maxgain_SSB = 30; } static void SYSMENU_HANDL_AUDIO_TX_CompressorMaxGain_AMFM(int8_t direction) { TRX.TX_Compressor_maxgain_AMFM += direction; if (TRX.TX_Compressor_maxgain_AMFM < 1) TRX.TX_Compressor_maxgain_AMFM = 1; if (TRX.TX_Compressor_maxgain_AMFM > 30) TRX.TX_Compressor_maxgain_AMFM = 30; } static void SYSMENU_HANDL_AUDIO_SSB_HPF_pass(int8_t direction) { if (direction > 0) { if (TRX.SSB_HPF_Filter == 0) TRX.SSB_HPF_Filter = 60; else if (TRX.SSB_HPF_Filter == 60) TRX.SSB_HPF_Filter = 100; else if (TRX.SSB_HPF_Filter == 100) TRX.SSB_HPF_Filter = 200; else if (TRX.SSB_HPF_Filter == 200) TRX.SSB_HPF_Filter = 300; else if (TRX.SSB_HPF_Filter == 300) TRX.SSB_HPF_Filter = 400; else if (TRX.SSB_HPF_Filter == 400) TRX.SSB_HPF_Filter = 500; } else { if (TRX.SSB_HPF_Filter == 60) TRX.SSB_HPF_Filter = 0; else if (TRX.SSB_HPF_Filter == 100) TRX.SSB_HPF_Filter = 60; else if (TRX.SSB_HPF_Filter == 200) TRX.SSB_HPF_Filter = 100; else if (TRX.SSB_HPF_Filter == 300) TRX.SSB_HPF_Filter = 200; else if (TRX.SSB_HPF_Filter == 400) TRX.SSB_HPF_Filter = 300; else if (TRX.SSB_HPF_Filter == 500) TRX.SSB_HPF_Filter = 400; } TRX_setMode(SecondaryVFO()->Mode, SecondaryVFO()); TRX_setMode(CurrentVFO()->Mode, CurrentVFO()); } static void SYSMENU_HANDL_AUDIO_CW_HPF_pass(int8_t direction) { if (direction > 0) { if (TRX.CW_HPF_Filter == 0) TRX.CW_HPF_Filter = 60; else if (TRX.CW_HPF_Filter == 60) TRX.CW_HPF_Filter = 100; } else { if (TRX.CW_HPF_Filter == 60) TRX.CW_HPF_Filter = 0; else if (TRX.CW_HPF_Filter == 100) TRX.CW_HPF_Filter = 60; } TRX_setMode(SecondaryVFO()->Mode, SecondaryVFO()); TRX_setMode(CurrentVFO()->Mode, CurrentVFO()); } static void SYSMENU_HANDL_AUDIO_CW_LPF_pass(int8_t direction) { if (direction > 0) { if (TRX.CW_LPF_Filter == 100) TRX.CW_LPF_Filter = 150; else if (TRX.CW_LPF_Filter == 150) TRX.CW_LPF_Filter = 200; else if (TRX.CW_LPF_Filter == 200) TRX.CW_LPF_Filter = 250; else if (TRX.CW_LPF_Filter == 250) TRX.CW_LPF_Filter = 300; else if (TRX.CW_LPF_Filter == 300) TRX.CW_LPF_Filter = 350; else if (TRX.CW_LPF_Filter == 350) TRX.CW_LPF_Filter = 400; else if (TRX.CW_LPF_Filter == 400) TRX.CW_LPF_Filter = 450; else if (TRX.CW_LPF_Filter == 450) TRX.CW_LPF_Filter = 500; else if (TRX.CW_LPF_Filter == 500) TRX.CW_LPF_Filter = 550; else if (TRX.CW_LPF_Filter == 550) TRX.CW_LPF_Filter = 600; else if (TRX.CW_LPF_Filter == 600) TRX.CW_LPF_Filter = 650; else if (TRX.CW_LPF_Filter == 650) TRX.CW_LPF_Filter = 700; else if (TRX.CW_LPF_Filter == 700) TRX.CW_LPF_Filter = 750; else if (TRX.CW_LPF_Filter == 750) TRX.CW_LPF_Filter = 800; else if (TRX.CW_LPF_Filter == 800) TRX.CW_LPF_Filter = 850; else if (TRX.CW_LPF_Filter == 850) TRX.CW_LPF_Filter = 900; else if (TRX.CW_LPF_Filter == 900) TRX.CW_LPF_Filter = 950; else if (TRX.CW_LPF_Filter == 950) TRX.CW_LPF_Filter = 1000; } else { if (TRX.CW_LPF_Filter == 1000) TRX.CW_LPF_Filter = 950; else if (TRX.CW_LPF_Filter == 950) TRX.CW_LPF_Filter = 900; else if (TRX.CW_LPF_Filter == 900) TRX.CW_LPF_Filter = 850; else if (TRX.CW_LPF_Filter == 850) TRX.CW_LPF_Filter = 800; else if (TRX.CW_LPF_Filter == 800) TRX.CW_LPF_Filter = 750; else if (TRX.CW_LPF_Filter == 750) TRX.CW_LPF_Filter = 700; else if (TRX.CW_LPF_Filter == 700) TRX.CW_LPF_Filter = 650; else if (TRX.CW_LPF_Filter == 650) TRX.CW_LPF_Filter = 600; else if (TRX.CW_LPF_Filter == 600) TRX.CW_LPF_Filter = 550; else if (TRX.CW_LPF_Filter == 550) TRX.CW_LPF_Filter = 500; else if (TRX.CW_LPF_Filter == 500) TRX.CW_LPF_Filter = 450; else if (TRX.CW_LPF_Filter == 450) TRX.CW_LPF_Filter = 400; else if (TRX.CW_LPF_Filter == 400) TRX.CW_LPF_Filter = 350; else if (TRX.CW_LPF_Filter == 350) TRX.CW_LPF_Filter = 300; else if (TRX.CW_LPF_Filter == 300) TRX.CW_LPF_Filter = 250; else if (TRX.CW_LPF_Filter == 250) TRX.CW_LPF_Filter = 200; else if (TRX.CW_LPF_Filter == 200) TRX.CW_LPF_Filter = 150; else if (TRX.CW_LPF_Filter == 150) TRX.CW_LPF_Filter = 100; } TRX_setMode(SecondaryVFO()->Mode, SecondaryVFO()); TRX_setMode(CurrentVFO()->Mode, CurrentVFO()); } static void SYSMENU_HANDL_AUDIO_SSB_RX_LPF_pass(int8_t direction) { if (direction > 0) { if (TRX.RX_SSB_LPF_Filter == 0) TRX.RX_SSB_LPF_Filter = 1400; if (TRX.RX_SSB_LPF_Filter == 1400) TRX.RX_SSB_LPF_Filter = 1600; else if (TRX.RX_SSB_LPF_Filter == 1600) TRX.RX_SSB_LPF_Filter = 1800; else if (TRX.RX_SSB_LPF_Filter == 1800) TRX.RX_SSB_LPF_Filter = 2100; else if (TRX.RX_SSB_LPF_Filter == 2100) TRX.RX_SSB_LPF_Filter = 2300; else if (TRX.RX_SSB_LPF_Filter == 2300) TRX.RX_SSB_LPF_Filter = 2500; else if (TRX.RX_SSB_LPF_Filter == 2500) TRX.RX_SSB_LPF_Filter = 2700; else if (TRX.RX_SSB_LPF_Filter == 2700) TRX.RX_SSB_LPF_Filter = 2900; else if (TRX.RX_SSB_LPF_Filter == 2900) TRX.RX_SSB_LPF_Filter = 3000; else if (TRX.RX_SSB_LPF_Filter == 3000) TRX.RX_SSB_LPF_Filter = 3200; else if (TRX.RX_SSB_LPF_Filter == 3200) TRX.RX_SSB_LPF_Filter = 3400; } else { if (TRX.RX_SSB_LPF_Filter == 1600) TRX.RX_SSB_LPF_Filter = 1400; else if (TRX.RX_SSB_LPF_Filter == 1800) TRX.RX_SSB_LPF_Filter = 1600; else if (TRX.RX_SSB_LPF_Filter == 2100) TRX.RX_SSB_LPF_Filter = 1800; else if (TRX.RX_SSB_LPF_Filter == 2300) TRX.RX_SSB_LPF_Filter = 2100; else if (TRX.RX_SSB_LPF_Filter == 2500) TRX.RX_SSB_LPF_Filter = 2300; else if (TRX.RX_SSB_LPF_Filter == 2700) TRX.RX_SSB_LPF_Filter = 2500; else if (TRX.RX_SSB_LPF_Filter == 2900) TRX.RX_SSB_LPF_Filter = 2700; else if (TRX.RX_SSB_LPF_Filter == 3000) TRX.RX_SSB_LPF_Filter = 2900; else if (TRX.RX_SSB_LPF_Filter == 3200) TRX.RX_SSB_LPF_Filter = 3000; else if (TRX.RX_SSB_LPF_Filter == 3400) TRX.RX_SSB_LPF_Filter = 3200; } TRX_setMode(SecondaryVFO()->Mode, SecondaryVFO()); TRX_setMode(CurrentVFO()->Mode, CurrentVFO()); } static void SYSMENU_HANDL_AUDIO_SSB_TX_LPF_pass(int8_t direction) { if (direction > 0) { if (TRX.TX_SSB_LPF_Filter == 0) TRX.TX_SSB_LPF_Filter = 1400; if (TRX.TX_SSB_LPF_Filter == 1400) TRX.TX_SSB_LPF_Filter = 1600; else if (TRX.TX_SSB_LPF_Filter == 1600) TRX.TX_SSB_LPF_Filter = 1800; else if (TRX.TX_SSB_LPF_Filter == 1800) TRX.TX_SSB_LPF_Filter = 2100; else if (TRX.TX_SSB_LPF_Filter == 2100) TRX.TX_SSB_LPF_Filter = 2300; else if (TRX.TX_SSB_LPF_Filter == 2300) TRX.TX_SSB_LPF_Filter = 2500; else if (TRX.TX_SSB_LPF_Filter == 2500) TRX.TX_SSB_LPF_Filter = 2700; else if (TRX.TX_SSB_LPF_Filter == 2700) TRX.TX_SSB_LPF_Filter = 2900; else if (TRX.TX_SSB_LPF_Filter == 2900) TRX.TX_SSB_LPF_Filter = 3000; else if (TRX.TX_SSB_LPF_Filter == 3000) TRX.TX_SSB_LPF_Filter = 3200; else if (TRX.TX_SSB_LPF_Filter == 3200) TRX.TX_SSB_LPF_Filter = 3400; } else { if (TRX.TX_SSB_LPF_Filter == 1600) TRX.TX_SSB_LPF_Filter = 1400; else if (TRX.TX_SSB_LPF_Filter == 1800) TRX.TX_SSB_LPF_Filter = 1600; else if (TRX.TX_SSB_LPF_Filter == 2100) TRX.TX_SSB_LPF_Filter = 1800; else if (TRX.TX_SSB_LPF_Filter == 2300) TRX.TX_SSB_LPF_Filter = 2100; else if (TRX.TX_SSB_LPF_Filter == 2500) TRX.TX_SSB_LPF_Filter = 2300; else if (TRX.TX_SSB_LPF_Filter == 2700) TRX.TX_SSB_LPF_Filter = 2500; else if (TRX.TX_SSB_LPF_Filter == 2900) TRX.TX_SSB_LPF_Filter = 2700; else if (TRX.TX_SSB_LPF_Filter == 3000) TRX.TX_SSB_LPF_Filter = 2900; else if (TRX.TX_SSB_LPF_Filter == 3200) TRX.TX_SSB_LPF_Filter = 3000; else if (TRX.TX_SSB_LPF_Filter == 3400) TRX.TX_SSB_LPF_Filter = 3200; } TRX_setMode(SecondaryVFO()->Mode, SecondaryVFO()); TRX_setMode(CurrentVFO()->Mode, CurrentVFO()); } static void SYSMENU_HANDL_AUDIO_AM_RX_LPF_pass(int8_t direction) { if (direction > 0) { if (TRX.RX_AM_LPF_Filter == 2100) TRX.RX_AM_LPF_Filter = 2300; else if (TRX.RX_AM_LPF_Filter == 2300) TRX.RX_AM_LPF_Filter = 2500; else if (TRX.RX_AM_LPF_Filter == 2500) TRX.RX_AM_LPF_Filter = 2700; else if (TRX.RX_AM_LPF_Filter == 2700) TRX.RX_AM_LPF_Filter = 2900; else if (TRX.RX_AM_LPF_Filter == 2900) TRX.RX_AM_LPF_Filter = 3000; else if (TRX.RX_AM_LPF_Filter == 3000) TRX.RX_AM_LPF_Filter = 3200; else if (TRX.RX_AM_LPF_Filter == 3200) TRX.RX_AM_LPF_Filter = 3400; else if (TRX.RX_AM_LPF_Filter == 3400) TRX.RX_AM_LPF_Filter = 3600; else if (TRX.RX_AM_LPF_Filter == 3600) TRX.RX_AM_LPF_Filter = 3800; else if (TRX.RX_AM_LPF_Filter == 3800) TRX.RX_AM_LPF_Filter = 4000; else if (TRX.RX_AM_LPF_Filter == 4000) TRX.RX_AM_LPF_Filter = 4500; else if (TRX.RX_AM_LPF_Filter == 4500) TRX.RX_AM_LPF_Filter = 5000; else if (TRX.RX_AM_LPF_Filter == 5000) TRX.RX_AM_LPF_Filter = 6000; else if (TRX.RX_AM_LPF_Filter == 6000) TRX.RX_AM_LPF_Filter = 7000; else if (TRX.RX_AM_LPF_Filter == 7000) TRX.RX_AM_LPF_Filter = 8000; else if (TRX.RX_AM_LPF_Filter == 8000) TRX.RX_AM_LPF_Filter = 9000; else if (TRX.RX_AM_LPF_Filter == 9000) TRX.RX_AM_LPF_Filter = 10000; } else { if (TRX.RX_AM_LPF_Filter == 2300) TRX.RX_AM_LPF_Filter = 2100; else if (TRX.RX_AM_LPF_Filter == 2500) TRX.RX_AM_LPF_Filter = 2300; else if (TRX.RX_AM_LPF_Filter == 2700) TRX.RX_AM_LPF_Filter = 2500; else if (TRX.RX_AM_LPF_Filter == 2900) TRX.RX_AM_LPF_Filter = 2700; else if (TRX.RX_AM_LPF_Filter == 3000) TRX.RX_AM_LPF_Filter = 2900; else if (TRX.RX_AM_LPF_Filter == 3200) TRX.RX_AM_LPF_Filter = 3000; else if (TRX.RX_AM_LPF_Filter == 3400) TRX.RX_AM_LPF_Filter = 3200; else if (TRX.RX_AM_LPF_Filter == 3600) TRX.RX_AM_LPF_Filter = 3400; else if (TRX.RX_AM_LPF_Filter == 3800) TRX.RX_AM_LPF_Filter = 3400; else if (TRX.RX_AM_LPF_Filter == 4000) TRX.RX_AM_LPF_Filter = 3800; else if (TRX.RX_AM_LPF_Filter == 4500) TRX.RX_AM_LPF_Filter = 3800; else if (TRX.RX_AM_LPF_Filter == 5000) TRX.RX_AM_LPF_Filter = 4500; else if (TRX.RX_AM_LPF_Filter == 6000) TRX.RX_AM_LPF_Filter = 5000; else if (TRX.RX_AM_LPF_Filter == 7000) TRX.RX_AM_LPF_Filter = 6000; else if (TRX.RX_AM_LPF_Filter == 8000) TRX.RX_AM_LPF_Filter = 7000; else if (TRX.RX_AM_LPF_Filter == 9000) TRX.RX_AM_LPF_Filter = 8000; else if (TRX.RX_AM_LPF_Filter == 10000) TRX.RX_AM_LPF_Filter = 9000; } TRX_setMode(SecondaryVFO()->Mode, SecondaryVFO()); TRX_setMode(CurrentVFO()->Mode, CurrentVFO()); } static void SYSMENU_HANDL_AUDIO_AM_TX_LPF_pass(int8_t direction) { if (direction > 0) { if (TRX.TX_AM_LPF_Filter == 2100) TRX.TX_AM_LPF_Filter = 2300; else if (TRX.TX_AM_LPF_Filter == 2300) TRX.TX_AM_LPF_Filter = 2500; else if (TRX.TX_AM_LPF_Filter == 2500) TRX.TX_AM_LPF_Filter = 2700; else if (TRX.TX_AM_LPF_Filter == 2700) TRX.TX_AM_LPF_Filter = 2900; else if (TRX.TX_AM_LPF_Filter == 2900) TRX.TX_AM_LPF_Filter = 3000; else if (TRX.TX_AM_LPF_Filter == 3000) TRX.TX_AM_LPF_Filter = 3200; else if (TRX.TX_AM_LPF_Filter == 3200) TRX.TX_AM_LPF_Filter = 3400; else if (TRX.TX_AM_LPF_Filter == 3400) TRX.TX_AM_LPF_Filter = 3600; else if (TRX.TX_AM_LPF_Filter == 3600) TRX.TX_AM_LPF_Filter = 3800; else if (TRX.TX_AM_LPF_Filter == 3800) TRX.TX_AM_LPF_Filter = 4000; else if (TRX.TX_AM_LPF_Filter == 4000) TRX.TX_AM_LPF_Filter = 4500; else if (TRX.TX_AM_LPF_Filter == 4500) TRX.TX_AM_LPF_Filter = 5000; else if (TRX.TX_AM_LPF_Filter == 5000) TRX.TX_AM_LPF_Filter = 6000; else if (TRX.TX_AM_LPF_Filter == 6000) TRX.TX_AM_LPF_Filter = 7000; else if (TRX.TX_AM_LPF_Filter == 7000) TRX.TX_AM_LPF_Filter = 8000; else if (TRX.TX_AM_LPF_Filter == 8000) TRX.TX_AM_LPF_Filter = 9000; else if (TRX.TX_AM_LPF_Filter == 9000) TRX.TX_AM_LPF_Filter = 10000; } else { if (TRX.TX_AM_LPF_Filter == 2300) TRX.TX_AM_LPF_Filter = 2100; else if (TRX.TX_AM_LPF_Filter == 2500) TRX.TX_AM_LPF_Filter = 2300; else if (TRX.TX_AM_LPF_Filter == 2700) TRX.TX_AM_LPF_Filter = 2500; else if (TRX.TX_AM_LPF_Filter == 2900) TRX.TX_AM_LPF_Filter = 2700; else if (TRX.TX_AM_LPF_Filter == 3000) TRX.TX_AM_LPF_Filter = 2900; else if (TRX.TX_AM_LPF_Filter == 3200) TRX.TX_AM_LPF_Filter = 3000; else if (TRX.TX_AM_LPF_Filter == 3400) TRX.TX_AM_LPF_Filter = 3200; else if (TRX.TX_AM_LPF_Filter == 3600) TRX.TX_AM_LPF_Filter = 3400; else if (TRX.TX_AM_LPF_Filter == 3800) TRX.TX_AM_LPF_Filter = 3400; else if (TRX.TX_AM_LPF_Filter == 4000) TRX.TX_AM_LPF_Filter = 3800; else if (TRX.TX_AM_LPF_Filter == 4500) TRX.TX_AM_LPF_Filter = 3800; else if (TRX.TX_AM_LPF_Filter == 5000) TRX.TX_AM_LPF_Filter = 4500; else if (TRX.TX_AM_LPF_Filter == 6000) TRX.TX_AM_LPF_Filter = 5000; else if (TRX.TX_AM_LPF_Filter == 7000) TRX.TX_AM_LPF_Filter = 6000; else if (TRX.TX_AM_LPF_Filter == 8000) TRX.TX_AM_LPF_Filter = 7000; else if (TRX.TX_AM_LPF_Filter == 9000) TRX.TX_AM_LPF_Filter = 8000; else if (TRX.TX_AM_LPF_Filter == 10000) TRX.TX_AM_LPF_Filter = 9000; } TRX_setMode(SecondaryVFO()->Mode, SecondaryVFO()); TRX_setMode(CurrentVFO()->Mode, CurrentVFO()); } static void SYSMENU_HANDL_AUDIO_FM_RX_LPF_pass(int8_t direction) { if (direction > 0) { if (TRX.RX_FM_LPF_Filter == 5000) TRX.RX_FM_LPF_Filter = 6000; else if (TRX.RX_FM_LPF_Filter == 6000) TRX.RX_FM_LPF_Filter = 7000; else if (TRX.RX_FM_LPF_Filter == 7000) TRX.RX_FM_LPF_Filter = 8000; else if (TRX.RX_FM_LPF_Filter == 8000) TRX.RX_FM_LPF_Filter = 9000; else if (TRX.RX_FM_LPF_Filter == 9000) TRX.RX_FM_LPF_Filter = 10000; else if (TRX.RX_FM_LPF_Filter == 10000) TRX.RX_FM_LPF_Filter = 15000; else if (TRX.RX_FM_LPF_Filter == 15000) TRX.RX_FM_LPF_Filter = 20000; } else { if (TRX.RX_FM_LPF_Filter == 6000) TRX.RX_FM_LPF_Filter = 5000; else if (TRX.RX_FM_LPF_Filter == 7000) TRX.RX_FM_LPF_Filter = 6000; else if (TRX.RX_FM_LPF_Filter == 8000) TRX.RX_FM_LPF_Filter = 7000; else if (TRX.RX_FM_LPF_Filter == 9000) TRX.RX_FM_LPF_Filter = 8000; else if (TRX.RX_FM_LPF_Filter == 10000) TRX.RX_FM_LPF_Filter = 9000; else if (TRX.RX_FM_LPF_Filter == 15000) TRX.RX_FM_LPF_Filter = 10000; else if (TRX.RX_FM_LPF_Filter == 20000) TRX.RX_FM_LPF_Filter = 15000; } TRX_setMode(SecondaryVFO()->Mode, SecondaryVFO()); TRX_setMode(CurrentVFO()->Mode, CurrentVFO()); } static void SYSMENU_HANDL_AUDIO_FM_TX_LPF_pass(int8_t direction) { if (direction > 0) { if (TRX.TX_FM_LPF_Filter == 5000) TRX.TX_FM_LPF_Filter = 6000; else if (TRX.TX_FM_LPF_Filter == 6000) TRX.TX_FM_LPF_Filter = 7000; else if (TRX.TX_FM_LPF_Filter == 7000) TRX.TX_FM_LPF_Filter = 8000; else if (TRX.TX_FM_LPF_Filter == 8000) TRX.TX_FM_LPF_Filter = 9000; else if (TRX.TX_FM_LPF_Filter == 9000) TRX.TX_FM_LPF_Filter = 10000; else if (TRX.TX_FM_LPF_Filter == 10000) TRX.TX_FM_LPF_Filter = 15000; else if (TRX.TX_FM_LPF_Filter == 15000) TRX.TX_FM_LPF_Filter = 20000; } else { if (TRX.TX_FM_LPF_Filter == 6000) TRX.TX_FM_LPF_Filter = 5000; else if (TRX.TX_FM_LPF_Filter == 7000) TRX.TX_FM_LPF_Filter = 6000; else if (TRX.TX_FM_LPF_Filter == 8000) TRX.TX_FM_LPF_Filter = 7000; else if (TRX.TX_FM_LPF_Filter == 9000) TRX.TX_FM_LPF_Filter = 8000; else if (TRX.TX_FM_LPF_Filter == 10000) TRX.TX_FM_LPF_Filter = 9000; else if (TRX.TX_FM_LPF_Filter == 15000) TRX.TX_FM_LPF_Filter = 10000; else if (TRX.TX_FM_LPF_Filter == 20000) TRX.TX_FM_LPF_Filter = 15000; } TRX_setMode(SecondaryVFO()->Mode, SecondaryVFO()); TRX_setMode(CurrentVFO()->Mode, CurrentVFO()); } static void SYSMENU_HANDL_AUDIO_Beeper(int8_t direction) { if (direction > 0) TRX.Beeper = true; if (direction < 0) TRX.Beeper = false; } //CW MENU static void SYSMENU_HANDL_CWMENU(int8_t direction) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_cw_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_cw_item_count; sysmenu_onroot = false; systemMenuIndex = 0; LCD_redraw(false); } void SYSMENU_CW_WPM_HOTKEY(void) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_cw_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_cw_item_count; sysmenu_onroot = false; systemMenuIndex = 4; LCD_redraw(false); } void SYSMENU_CW_KEYER_HOTKEY(void) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_cw_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_cw_item_count; sysmenu_onroot = false; systemMenuIndex = 3; LCD_redraw(false); } static void SYSMENU_HANDL_CW_GENERATOR_SHIFT_HZ(int8_t direction) { TRX.CW_GENERATOR_SHIFT_HZ += direction * 100; if (TRX.CW_GENERATOR_SHIFT_HZ < 100) TRX.CW_GENERATOR_SHIFT_HZ = 100; if (TRX.CW_GENERATOR_SHIFT_HZ > 10000) TRX.CW_GENERATOR_SHIFT_HZ = 10000; } static void SYSMENU_HANDL_CW_Key_timeout(int8_t direction) { TRX.CW_Key_timeout += direction * 50; if (TRX.CW_Key_timeout < 50) TRX.CW_Key_timeout = 50; if (TRX.CW_Key_timeout > 5000) TRX.CW_Key_timeout = 5000; } static void SYSMENU_HANDL_CW_Keyer(int8_t direction) { if (direction > 0) TRX.CW_KEYER = true; if (direction < 0) TRX.CW_KEYER = false; } static void SYSMENU_HANDL_CW_Keyer_WPM(int8_t direction) { TRX.CW_KEYER_WPM += direction; if (TRX.CW_KEYER_WPM < 1) TRX.CW_KEYER_WPM = 1; if (TRX.CW_KEYER_WPM > 200) TRX.CW_KEYER_WPM = 200; } static void SYSMENU_HANDL_CW_SelfHear(int8_t direction) { if (direction > 0) TRX.CW_SelfHear = true; if (direction < 0) TRX.CW_SelfHear = false; } static void SYSMENU_HANDL_CW_GaussFilter(int8_t direction) { if (direction > 0) TRX.CW_GaussFilter = true; if (direction < 0) TRX.CW_GaussFilter = false; NeedReinitAudioFilters = true; } //----------------------------------------------------------------------- //static void SYSMENU_HANDL_SCREEN_LCD_position(int8_t direction) //{ // TRX.LCD_position += direction*2; // if (TRX.LCD_position < 2) // TRX.LCD_position = 2; // if (TRX.LCD_position > 4) // TRX.LCD_position = 4; // LCD_Init(); // LCD_redraw(true); //} //----------------------------------------------------------------------- static void SYSMENU_HANDL_SCREEN_FFT_HoldPeaks(int8_t direction) { if (direction > 0) TRX.FFT_HoldPeaks = true; if (direction < 0) TRX.FFT_HoldPeaks = false; } static void SYSMENU_HANDL_SCREEN_FFT_Automatic(int8_t direction) { if (direction > 0) TRX.FFT_Automatic = true; if (direction < 0) TRX.FFT_Automatic = false; } static void SYSMENU_HANDL_SCREEN_FFT_Sensitivity(int8_t direction) { TRX.FFT_Sensitivity += direction; if (TRX.FFT_Sensitivity < FFT_MIN + 1) TRX.FFT_Sensitivity = FFT_MIN + 1; if (TRX.FFT_Sensitivity > FFT_MAX_TOP_SCALE) TRX.FFT_Sensitivity = FFT_MAX_TOP_SCALE; } //----------------------------------------------------------------------- //SCREEN MENU static void SYSMENU_HANDL_LCDMENU(int8_t direction) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_screen_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_screen_item_count; sysmenu_onroot = false; systemMenuIndex = 0; LCD_UpdateQuery.SystemMenuRedraw = true; } static void SYSMENU_HANDL_SCREEN_FFT_Enabled(int8_t direction) { if (direction > 0) TRX.FFT_Enabled = true; if (direction < 0) TRX.FFT_Enabled = false; } static void SYSMENU_HANDL_SCREEN_COLOR_THEME(int8_t direction) { if(direction > 0 || TRX.ColorThemeId > 0) TRX.ColorThemeId += direction; if (TRX.ColorThemeId > (COLOR_THEMES_COUNT - 1)) TRX.ColorThemeId = (COLOR_THEMES_COUNT - 1); COLOR = &COLOR_THEMES[TRX.ColorThemeId]; FFT_Init(); LCD_redraw(false); } static void SYSMENU_HANDL_SCREEN_FFT_Compressor(int8_t direction) { if (direction > 0) TRX.FFT_Compressor = true; if (direction < 0) TRX.FFT_Compressor = false; } static void SYSMENU_HANDL_SCREEN_FFT_Averaging(int8_t direction) { TRX.FFT_Averaging += direction; if (TRX.FFT_Averaging < 1) TRX.FFT_Averaging = 1; if (TRX.FFT_Averaging > 10) TRX.FFT_Averaging = 10; } static void SYSMENU_HANDL_SCREEN_FFT_Window(int8_t direction) { TRX.FFT_Window += direction; if (TRX.FFT_Window < 1) TRX.FFT_Window = 1; if (TRX.FFT_Window > 3) TRX.FFT_Window = 3; FFT_PreInit(); FFT_Init(); } static void SYSMENU_HANDL_SCREEN_FFT_Zoom(int8_t direction) { if (direction > 0) { if (TRX.FFT_Zoom == 1) TRX.FFT_Zoom = 2; else if (TRX.FFT_Zoom == 2) TRX.FFT_Zoom = 4; else if (TRX.FFT_Zoom == 4) TRX.FFT_Zoom = 8; else if (TRX.FFT_Zoom == 8) TRX.FFT_Zoom = 16; } else { if (TRX.FFT_Zoom == 2) TRX.FFT_Zoom = 1; else if (TRX.FFT_Zoom == 4) TRX.FFT_Zoom = 2; else if (TRX.FFT_Zoom == 8) TRX.FFT_Zoom = 4; else if (TRX.FFT_Zoom == 16) TRX.FFT_Zoom = 8; } FFT_Init(); } /* static void SYSMENU_HANDL_SCREEN_FFT_Color(int8_t direction) { TRX.FFT_Color += direction; if (TRX.FFT_Color < 1) TRX.FFT_Color = 1; if (TRX.FFT_Color > 7) TRX.FFT_Color = 7; FFT_Init(); }*/ static void SYSMENU_HANDL_SCREEN_Freq_Font(int8_t direction) { TRX.Freq_Font += direction; if (TRX.Freq_Font < 1) TRX.Freq_Font = 1; if (TRX.Freq_Font > 2) TRX.Freq_Font = 2; // FFT_Init(); } static void SYSMENU_HANDL_SCREEN_FFT_Grid(int8_t direction) { TRX.FFT_Grid += direction; if (TRX.FFT_Grid < 0) TRX.FFT_Grid = 0; if (TRX.FFT_Grid > 3) TRX.FFT_Grid = 3; FFT_Init(); } static void SYSMENU_HANDL_SCREEN_FFT_Background(int8_t direction) { if (direction > 0) TRX.FFT_Background = true; if (direction < 0) TRX.FFT_Background = false; } //ADC/DAC MENU static void SYSMENU_HANDL_ADCMENU(int8_t direction) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_adc_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_adc_item_count; sysmenu_onroot = false; systemMenuIndex = 0; LCD_UpdateQuery.SystemMenuRedraw = true; } static void SYSMENU_HANDL_ADC_DRIVER(int8_t direction) { if (direction > 0) TRX.ADC_Driver = true; if (direction < 0) TRX.ADC_Driver = false; int8_t band = getBandFromFreq(CurrentVFO()->Freq, true); if (band > 0) TRX.BANDS_SAVED_SETTINGS[band].ADC_Driver = TRX.ADC_Driver; FPGA_NeedSendParams = true; } static void SYSMENU_HANDL_ADC_SHDN(int8_t direction) { if (direction > 0) TRX.ADC_SHDN = true; if (direction < 0) TRX.ADC_SHDN = false; FPGA_NeedSendParams = true; } //SET TIME MENU static void SYSMENU_HANDL_SETTIME(int8_t direction) { if (!sysmenu_timeMenuOpened) LCDDriver_Fill(BG_COLOR); sysmenu_timeMenuOpened = true; static uint8_t Hours; static uint8_t Minutes; static uint8_t Seconds; static uint32_t Time; char ctmp[50]; Time = RTC->TR; Hours = ((Time >> 20) & 0x03) * 10 + ((Time >> 16) & 0x0f); Minutes = ((Time >> 12) & 0x07) * 10 + ((Time >> 8) & 0x0f); Seconds = ((Time >> 4) & 0x07) * 10 + ((Time >> 0) & 0x0f); if (direction != 0) { if (TimeMenuSelection == 0) { if (Hours == 0 && direction < 0) return; Hours = (uint8_t)(Hours + direction); } if (TimeMenuSelection == 1) { if (Minutes == 0 && direction < 0) return; Minutes = (uint8_t)(Minutes + direction); } if (TimeMenuSelection == 2) { if (Seconds == 0 && direction < 0) return; Seconds = (uint8_t)(Seconds + direction); } if (Hours >= 24) Hours = 0; if (Minutes >= 60) Minutes = 0; if (Seconds >= 60) Seconds = 0; RTC_TimeTypeDef sTime; sTime.TimeFormat = RTC_HOURFORMAT12_PM; sTime.SubSeconds = 0; sTime.SecondFraction = 0; sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE; sTime.StoreOperation = RTC_STOREOPERATION_SET; sTime.Hours = Hours; sTime.Minutes = Minutes; sTime.Seconds = Seconds; BKPSRAM_Enable(); HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BIN); } sprintf(ctmp, "%d", Hours); addSymbols(ctmp, ctmp, 2, "0", false); LCDDriver_printText(ctmp, 76, 100, COLOR->BUTTON_TEXT, TimeMenuSelection == 0 ? FG_COLOR : BG_COLOR, 3); LCDDriver_printText(":", 124, 100, COLOR->BUTTON_TEXT, BG_COLOR, 3); sprintf(ctmp, "%d", Minutes); addSymbols(ctmp, ctmp, 2, "0", false); LCDDriver_printText(ctmp, 148, 100, COLOR->BUTTON_TEXT, TimeMenuSelection == 1 ? FG_COLOR : BG_COLOR, 3); LCDDriver_printText(":", 194, 100, COLOR->BUTTON_TEXT, BG_COLOR, 3); sprintf(ctmp, "%d", Seconds); addSymbols(ctmp, ctmp, 2, "0", false); LCDDriver_printText(ctmp, 220, 100, COLOR->BUTTON_TEXT, TimeMenuSelection == 2 ? FG_COLOR : BG_COLOR, 3); } //FLASH MENU static void SYSMENU_HANDL_Bootloader(int8_t direction) { WM8731_CleanBuffer(); TRX_NeedGoToBootloader = true; TRX_Inited = false; LCD_busy = true; } #pragma GCC diagnostic ignored "-Wsign-conversion" //CALIBRATION MENU static void SYSMENU_HANDL_CALIB_ENCODER_INVERT(int8_t direction) { if (direction > 0) CALIBRATE.ENCODER_INVERT = true; if (direction < 0) CALIBRATE.ENCODER_INVERT = false; } static void SYSMENU_HANDL_CALIB_ENCODER2_INVERT(int8_t direction) { if (direction > 0) CALIBRATE.ENCODER2_INVERT = true; if (direction < 0) CALIBRATE.ENCODER2_INVERT = false; } static void SYSMENU_HANDL_CALIB_ENCODER_DEBOUNCE(int8_t direction) { if (CALIBRATE.ENCODER_DEBOUNCE > 0 || direction > 0) CALIBRATE.ENCODER_DEBOUNCE += direction; if (CALIBRATE.ENCODER_DEBOUNCE > 250) CALIBRATE.ENCODER_DEBOUNCE = 250; } static void SYSMENU_HANDL_CALIB_ENCODER2_DEBOUNCE(int8_t direction) { if (CALIBRATE.ENCODER2_DEBOUNCE > 0 || direction > 0) CALIBRATE.ENCODER2_DEBOUNCE += direction; if (CALIBRATE.ENCODER2_DEBOUNCE > 250) CALIBRATE.ENCODER2_DEBOUNCE = 250; } static void SYSMENU_HANDL_CALIB_ENCODER_SLOW_RATE(int8_t direction) { CALIBRATE.ENCODER_SLOW_RATE += direction; if (CALIBRATE.ENCODER_SLOW_RATE < 1) CALIBRATE.ENCODER_SLOW_RATE = 1; if (CALIBRATE.ENCODER_SLOW_RATE > 100) CALIBRATE.ENCODER_SLOW_RATE = 100; } static void SYSMENU_HANDL_CALIB_ENCODER2_SLOW_RATE(int8_t direction) { CALIBRATE.ENCODER2_SLOW_RATE += direction; if (CALIBRATE.ENCODER2_SLOW_RATE < 1) CALIBRATE.ENCODER2_SLOW_RATE = 1; if (CALIBRATE.ENCODER2_SLOW_RATE > 100) CALIBRATE.ENCODER2_SLOW_RATE = 100; } static void SYSMENU_HANDL_CALIB_ENCODER_ON_FALLING(int8_t direction) { if (direction > 0) CALIBRATE.ENCODER_ON_FALLING = true; if (direction < 0) CALIBRATE.ENCODER_ON_FALLING = false; } static void SYSMENU_HANDL_CALIBRATIONMENU(int8_t direction) { if (!sysmenu_hiddenmenu_enabled) return; sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_calibration_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_calibration_item_count; sysmenu_onroot = false; systemMenuIndex = 0; LCD_UpdateQuery.SystemMenuRedraw = true; } static void SYSMENU_HANDL_CALIB_CICCOMP_SHIFT(int8_t direction) { CALIBRATE.CICFIR_GAINER_val += direction; if (CALIBRATE.CICFIR_GAINER_val < 16) CALIBRATE.CICFIR_GAINER_val = 16; if (CALIBRATE.CICFIR_GAINER_val > 46) CALIBRATE.CICFIR_GAINER_val = 46; } static void SYSMENU_HANDL_CALIB_TXCICCOMP_SHIFT(int8_t direction) { CALIBRATE.TXCICFIR_GAINER_val += direction; if (CALIBRATE.TXCICFIR_GAINER_val < 16) CALIBRATE.TXCICFIR_GAINER_val = 16; if (CALIBRATE.TXCICFIR_GAINER_val > 30) CALIBRATE.TXCICFIR_GAINER_val = 30; } static void SYSMENU_HANDL_CALIB_DAC_SHIFT(int8_t direction) { CALIBRATE.DAC_GAINER_val += direction; if (CALIBRATE.DAC_GAINER_val < 14) CALIBRATE.DAC_GAINER_val = 14; if (CALIBRATE.DAC_GAINER_val > 28) CALIBRATE.DAC_GAINER_val = 28; } static void SYSMENU_HANDL_CALIB_RF_GAIN_160M(int8_t direction) { if (CALIBRATE.rf_out_power_160m > 0) CALIBRATE.rf_out_power_160m += direction; if (CALIBRATE.rf_out_power_160m == 0 && direction > 0) CALIBRATE.rf_out_power_160m += direction; if (CALIBRATE.rf_out_power_160m > 100) CALIBRATE.rf_out_power_160m = 100; TRX_MAX_TX_Amplitude = getMaxTXAmplitudeOnFreq(CurrentVFO()->Freq); } static void SYSMENU_HANDL_CALIB_RF_GAIN_80M(int8_t direction) { if (CALIBRATE.rf_out_power_80m > 0) CALIBRATE.rf_out_power_80m += direction; if (CALIBRATE.rf_out_power_80m == 0 && direction > 0) CALIBRATE.rf_out_power_80m += direction; if (CALIBRATE.rf_out_power_80m > 100) CALIBRATE.rf_out_power_80m = 100; TRX_MAX_TX_Amplitude = getMaxTXAmplitudeOnFreq(CurrentVFO()->Freq); } static void SYSMENU_HANDL_CALIB_RF_GAIN_40M(int8_t direction) { if (CALIBRATE.rf_out_power_40m > 0) CALIBRATE.rf_out_power_40m += direction; if (CALIBRATE.rf_out_power_40m == 0 && direction > 0) CALIBRATE.rf_out_power_40m += direction; if (CALIBRATE.rf_out_power_40m > 100) CALIBRATE.rf_out_power_40m = 100; TRX_MAX_TX_Amplitude = getMaxTXAmplitudeOnFreq(CurrentVFO()->Freq); } static void SYSMENU_HANDL_CALIB_RF_GAIN_30M(int8_t direction) { if (CALIBRATE.rf_out_power_30m > 0) CALIBRATE.rf_out_power_30m += direction; if (CALIBRATE.rf_out_power_30m == 0 && direction > 0) CALIBRATE.rf_out_power_30m += direction; if (CALIBRATE.rf_out_power_30m > 100) CALIBRATE.rf_out_power_30m = 100; TRX_MAX_TX_Amplitude = getMaxTXAmplitudeOnFreq(CurrentVFO()->Freq); } static void SYSMENU_HANDL_CALIB_RF_GAIN_20M(int8_t direction) { if (CALIBRATE.rf_out_power_20m > 0) CALIBRATE.rf_out_power_20m += direction; if (CALIBRATE.rf_out_power_20m == 0 && direction > 0) CALIBRATE.rf_out_power_20m += direction; if (CALIBRATE.rf_out_power_20m > 100) CALIBRATE.rf_out_power_20m = 100; TRX_MAX_TX_Amplitude = getMaxTXAmplitudeOnFreq(CurrentVFO()->Freq); } static void SYSMENU_HANDL_CALIB_RF_GAIN_17M(int8_t direction) { if (CALIBRATE.rf_out_power_17m > 0) CALIBRATE.rf_out_power_17m += direction; if (CALIBRATE.rf_out_power_17m == 0 && direction > 0) CALIBRATE.rf_out_power_17m += direction; if (CALIBRATE.rf_out_power_17m > 100) CALIBRATE.rf_out_power_17m = 100; TRX_MAX_TX_Amplitude = getMaxTXAmplitudeOnFreq(CurrentVFO()->Freq); } static void SYSMENU_HANDL_CALIB_RF_GAIN_15M(int8_t direction) { if (CALIBRATE.rf_out_power_15m > 0) CALIBRATE.rf_out_power_15m += direction; if (CALIBRATE.rf_out_power_15m == 0 && direction > 0) CALIBRATE.rf_out_power_15m += direction; if (CALIBRATE.rf_out_power_15m > 100) CALIBRATE.rf_out_power_15m = 100; TRX_MAX_TX_Amplitude = getMaxTXAmplitudeOnFreq(CurrentVFO()->Freq); } static void SYSMENU_HANDL_CALIB_RF_GAIN_12M(int8_t direction) { if (CALIBRATE.rf_out_power_12m > 0) CALIBRATE.rf_out_power_12m += direction; if (CALIBRATE.rf_out_power_12m == 0 && direction > 0) CALIBRATE.rf_out_power_12m += direction; if (CALIBRATE.rf_out_power_12m > 100) CALIBRATE.rf_out_power_12m = 100; TRX_MAX_TX_Amplitude = getMaxTXAmplitudeOnFreq(CurrentVFO()->Freq); } static void SYSMENU_HANDL_CALIB_RF_GAIN_10M(int8_t direction) { if (CALIBRATE.rf_out_power_10m > 0) CALIBRATE.rf_out_power_10m += direction; if (CALIBRATE.rf_out_power_10m == 0 && direction > 0) CALIBRATE.rf_out_power_10m += direction; if (CALIBRATE.rf_out_power_10m > 100) CALIBRATE.rf_out_power_10m = 100; TRX_MAX_TX_Amplitude = getMaxTXAmplitudeOnFreq(CurrentVFO()->Freq); } static void SYSMENU_HANDL_CALIB_RF_GAIN_LF(int8_t direction) { if (CALIBRATE.rf_out_power_lf > 0) CALIBRATE.rf_out_power_lf += direction; if (CALIBRATE.rf_out_power_lf == 0 && direction > 0) CALIBRATE.rf_out_power_lf += direction; if (CALIBRATE.rf_out_power_lf > 100) CALIBRATE.rf_out_power_lf = 100; TRX_MAX_TX_Amplitude = getMaxTXAmplitudeOnFreq(CurrentVFO()->Freq); } static void SYSMENU_HANDL_CALIB_RF_GAIN_HF_LOW(int8_t direction) { if (CALIBRATE.rf_out_power_hf_low > 0) CALIBRATE.rf_out_power_hf_low += direction; if (CALIBRATE.rf_out_power_hf_low == 0 && direction > 0) CALIBRATE.rf_out_power_hf_low += direction; if (CALIBRATE.rf_out_power_hf_low > 100) CALIBRATE.rf_out_power_hf_low = 100; TRX_MAX_TX_Amplitude = getMaxTXAmplitudeOnFreq(CurrentVFO()->Freq); } static void SYSMENU_HANDL_CALIB_RF_GAIN_HF(int8_t direction) { if (CALIBRATE.rf_out_power_hf > 0) CALIBRATE.rf_out_power_hf += direction; if (CALIBRATE.rf_out_power_hf == 0 && direction > 0) CALIBRATE.rf_out_power_hf += direction; if (CALIBRATE.rf_out_power_hf > 100) CALIBRATE.rf_out_power_hf = 100; TRX_MAX_TX_Amplitude = getMaxTXAmplitudeOnFreq(CurrentVFO()->Freq); } static void SYSMENU_HANDL_CALIB_RF_GAIN_HF_HIGH(int8_t direction) { if (CALIBRATE.rf_out_power_hf_high > 0) CALIBRATE.rf_out_power_hf_high += direction; if (CALIBRATE.rf_out_power_hf_high == 0 && direction > 0) CALIBRATE.rf_out_power_hf_high += direction; if (CALIBRATE.rf_out_power_hf_high > 100) CALIBRATE.rf_out_power_hf_high = 100; TRX_MAX_TX_Amplitude = getMaxTXAmplitudeOnFreq(CurrentVFO()->Freq); } static void SYSMENU_HANDL_CALIB_RF_GAIN_VHF(int8_t direction) { if (CALIBRATE.rf_out_power_vhf > 0) CALIBRATE.rf_out_power_vhf += direction; if (CALIBRATE.rf_out_power_vhf == 0 && direction > 0) CALIBRATE.rf_out_power_vhf += direction; if (CALIBRATE.rf_out_power_vhf > 100) CALIBRATE.rf_out_power_vhf = 100; TRX_MAX_TX_Amplitude = getMaxTXAmplitudeOnFreq(CurrentVFO()->Freq); } static void SYSMENU_HANDL_CALIB_S_METER(int8_t direction) { CALIBRATE.smeter_calibration += direction; if (CALIBRATE.smeter_calibration < -50) CALIBRATE.smeter_calibration = -50; if (CALIBRATE.smeter_calibration > 50) CALIBRATE.smeter_calibration = 50; } #pragma GCC diagnostic ignored "-Wsign-conversion" static void SYSMENU_HANDL_CALIB_SWR_TRANS_RATE(int8_t direction) { CALIBRATE.swr_trans_rate += (float32_t)direction * 0.1f; if (CALIBRATE.swr_trans_rate < 1.0f) CALIBRATE.swr_trans_rate = 1.0f; if (CALIBRATE.swr_trans_rate > 50.0f) CALIBRATE.swr_trans_rate = 50.0f; } //VOLT-CALIBR static void SYSMENU_HANDL_CALIB_VOLT(int8_t direction) { CALIBRATE.volt_cal_rate += (float32_t)direction * 0.1f; if (CALIBRATE.volt_cal_rate < 1.0f) CALIBRATE.volt_cal_rate = 1.0f; if (CALIBRATE.volt_cal_rate > 50.0f) CALIBRATE.volt_cal_rate = 50.0f; } //F-CALIBR //########################################################################################################### static void SYSMENU_HANDL_VCXO_CALIBR(int8_t direction) { CALIBRATE.vcxo_calibration += direction * 10 ; if (CALIBRATE.vcxo_calibration < -700) CALIBRATE.vcxo_calibration = -700; if (CALIBRATE.vcxo_calibration > 700) CALIBRATE.vcxo_calibration = 700; #if defined(FRONT_R7KBI_61_440) || defined(FRONT_ALEX_61_440) FPGA_NeedSendParams = true; #endif #if defined(FRONT_R7KBI_64_320) || defined(FRONT_ALEX_64_320) TRX_setFrequency(CurrentVFO()->Freq, CurrentVFO()); #endif } // //160M //static void SYSMENU_HANDL_CALIB_FREQUENCY_160M(int8_t direction) //{ // CALIBRATE.freq_correctur_160 += direction; // if (CALIBRATE.freq_correctur_160 < -1000) // CALIBRATE.freq_correctur_160 = -1000; // if (CALIBRATE.freq_correctur_160 > 1000) // CALIBRATE.freq_correctur_160 = 1000; // TRX_setFrequency(CurrentVFO()->Freq, CurrentVFO()); //} // //80M //static void SYSMENU_HANDL_CALIB_FREQUENCY_80M(int8_t direction) //{ // CALIBRATE.freq_correctur_80 += direction; // if (CALIBRATE.freq_correctur_80 < -1000) // CALIBRATE.freq_correctur_80 = -1000; // if (CALIBRATE.freq_correctur_80 > 1000) // CALIBRATE.freq_correctur_80 = 1000; // TRX_setFrequency(CurrentVFO()->Freq, CurrentVFO()); //} //// 40M //static void SYSMENU_HANDL_CALIB_FREQUENCY_40M(int8_t direction) //{ // CALIBRATE.freq_correctur_40 += direction; // if (CALIBRATE.freq_correctur_40 < -1000) // CALIBRATE.freq_correctur_40 = -1000; // if (CALIBRATE.freq_correctur_40 > 1000) // CALIBRATE.freq_correctur_40 = 1000; // TRX_setFrequency(CurrentVFO()->Freq, CurrentVFO()); //} //// 30M //static void SYSMENU_HANDL_CALIB_FREQUENCY_30M(int8_t direction) //{ // CALIBRATE.freq_correctur_30 += direction; // if (CALIBRATE.freq_correctur_30 < -1000) // CALIBRATE.freq_correctur_30 = -1000; // if (CALIBRATE.freq_correctur_30 > 1000) // CALIBRATE.freq_correctur_30 = 1000; // TRX_setFrequency(CurrentVFO()->Freq, CurrentVFO()); //} //// 20M //static void SYSMENU_HANDL_CALIB_FREQUENCY_20M(int8_t direction) //{ // CALIBRATE.freq_correctur_20 += direction; // if (CALIBRATE.freq_correctur_20 < -1000) // CALIBRATE.freq_correctur_20 = -1000; // if (CALIBRATE.freq_correctur_20 > 1000) // CALIBRATE.freq_correctur_20 = 1000; // TRX_setFrequency(CurrentVFO()->Freq, CurrentVFO()); //} //// 17M //static void SYSMENU_HANDL_CALIB_FREQUENCY_17M(int8_t direction) //{ // CALIBRATE.freq_correctur_17 += direction; // if (CALIBRATE.freq_correctur_17 < -1000) // CALIBRATE.freq_correctur_17 = -1000; // if (CALIBRATE.freq_correctur_17 > 1000) // CALIBRATE.freq_correctur_17 = 1000; // TRX_setFrequency(CurrentVFO()->Freq, CurrentVFO()); //} //// 15M //static void SYSMENU_HANDL_CALIB_FREQUENCY_15M(int8_t direction) //{ // CALIBRATE.freq_correctur_15 += direction; // if (CALIBRATE.freq_correctur_15 < -1000) // CALIBRATE.freq_correctur_15 = -1000; // if (CALIBRATE.freq_correctur_15 > 1000) // CALIBRATE.freq_correctur_15 = 1000; // TRX_setFrequency(CurrentVFO()->Freq, CurrentVFO()); //} //// 12M //static void SYSMENU_HANDL_CALIB_FREQUENCY_12M(int8_t direction) //{ // CALIBRATE.freq_correctur_12 += direction; // if (CALIBRATE.freq_correctur_12 < -1000) // CALIBRATE.freq_correctur_12 = -1000; // if (CALIBRATE.freq_correctur_12 > 1000) // CALIBRATE.freq_correctur_12 = 1000; // TRX_setFrequency(CurrentVFO()->Freq, CurrentVFO()); //} //// 10M //static void SYSMENU_HANDL_CALIB_FREQUENCY_10M(int8_t direction) //{ // CALIBRATE.freq_correctur_10 += direction; // if (CALIBRATE.freq_correctur_10 < -1000) // CALIBRATE.freq_correctur_10 = -1000; // if (CALIBRATE.freq_correctur_10 > 1000) // CALIBRATE.freq_correctur_10 = 1000; // TRX_setFrequency(CurrentVFO()->Freq, CurrentVFO()); //} //// SiBi //static void SYSMENU_HANDL_CALIB_FREQUENCY_SIBI(int8_t direction) //{ // CALIBRATE.freq_correctur_sibi += direction; // if (CALIBRATE.freq_correctur_sibi < -1000) // CALIBRATE.freq_correctur_sibi = -1000; // if (CALIBRATE.freq_correctur_sibi > 1000) // CALIBRATE.freq_correctur_sibi = 1000; // TRX_setFrequency(CurrentVFO()->Freq, CurrentVFO()); //} //// 52Hz //static void SYSMENU_HANDL_CALIB_FREQUENCY_52(int8_t direction) //{ // CALIBRATE.freq_correctur_52 += direction; // if (CALIBRATE.freq_correctur_52 < -1000) // CALIBRATE.freq_correctur_52 = -1000; // if (CALIBRATE.freq_correctur_52 > 1000) // CALIBRATE.freq_correctur_52 = 1000; // TRX_setFrequency(CurrentVFO()->Freq, CurrentVFO()); //} //########################################################################################################## //SERVICES void SYSMENU_HANDL_SERVICESMENU(int8_t direction) { sysmenu_services_opened = true; sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_services_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_services_item_count; sysmenu_onroot = false; systemMenuIndex = 0; LCD_redraw(false); } //SWR BAND ANALYZER static void SYSMENU_HANDL_SWR_BAND_START(int8_t direction) { if (sysmenu_swr_opened) { SWR_EncRotate(direction); } else { sysmenu_swr_opened = true; int8_t band = getBandFromFreq(CurrentVFO()->Freq, true); SWR_Start(BANDS[band].startFreq - 100000, BANDS[band].endFreq + 100000); LCD_UpdateQuery.SystemMenuRedraw = true; } } //SWR HF ANALYZER static void SYSMENU_HANDL_SWR_HF_START(int8_t direction) { if (sysmenu_swr_opened) { SWR_EncRotate(direction); } else { sysmenu_swr_opened = true; SWR_Start(1000000, 60000000); LCD_UpdateQuery.SystemMenuRedraw = true; } } //COMMON MENU FUNCTIONS void SYSMENU_drawSystemMenu(bool draw_background) { if (LCD_busy) { LCD_UpdateQuery.SystemMenu = true; if(draw_background) LCD_UpdateQuery.SystemMenuRedraw = true; return; } if (!LCD_systemMenuOpened) return; if (sysmenu_timeMenuOpened) { SYSMENU_HANDL_SETTIME(0); } else if (sysmenu_trx_setCallsign_menu_opened) { SYSMENU_TRX_DrawCallsignMenu(draw_background); } else if (sysmenu_swr_opened) { SWR_Draw(); } else if (sysmenu_infowindow_opened) { } else { LCD_busy = true; sysmenu_i = 0; sysmenu_y = 5; if (draw_background) LCDDriver_Fill(BG_COLOR); uint8_t current_selected_page = systemMenuIndex / LAY_SYSMENU_MAX_ITEMS_ON_PAGE; if (current_selected_page * LAY_SYSMENU_MAX_ITEMS_ON_PAGE > *sysmenu_item_count_selected) current_selected_page = 0; for (uint8_t m = 0; m < *sysmenu_item_count_selected; m++) { uint8_t current_page = m / LAY_SYSMENU_MAX_ITEMS_ON_PAGE; if (current_selected_page == current_page) drawSystemMenuElement(sysmenu_handlers_selected[m].title, sysmenu_handlers_selected[m].type, sysmenu_handlers_selected[m].value, false); } LCD_busy = false; } LCD_UpdateQuery.SystemMenu = false; if(draw_background) LCD_UpdateQuery.SystemMenuRedraw = false; } void eventRotateSystemMenu(int8_t direction) { if (sysmenu_trx_setCallsign_menu_opened) { SYSMENU_TRX_RotateCallsignChar(direction); return; } if (sysmenu_timeMenuOpened) { SYSMENU_HANDL_SETTIME(direction); return; } if (sysmenu_handlers_selected[systemMenuIndex].type != SYSMENU_INFOLINE) sysmenu_handlers_selected[systemMenuIndex].menuHandler(direction); if (sysmenu_handlers_selected[systemMenuIndex].type != SYSMENU_RUN) LCD_UpdateQuery.SystemMenuCurrent = true; } void eventCloseSystemMenu(void) { if (sysmenu_trx_setCallsign_menu_opened) { sysmenu_trx_setCallsign_menu_opened = false; systemMenuIndex = 0; SYSMENU_drawSystemMenu(true); } else if (sysmenu_timeMenuOpened) { sysmenu_timeMenuOpened = false; systemMenuIndex = 0; SYSMENU_drawSystemMenu(true); } else if (sysmenu_swr_opened) { sysmenu_swr_opened = false; SWR_Stop(); systemMenuIndex = 0; SYSMENU_drawSystemMenu(true); } else if (sysmenu_infowindow_opened) { sysmenu_infowindow_opened = false; systemMenuIndex = 0; SYSMENU_drawSystemMenu(true); } else if (sysmenu_services_opened) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_item_count; sysmenu_onroot = true; systemMenuIndex = systemMenuRootIndex; sysmenu_services_opened = false; LCD_systemMenuOpened = false; LCD_UpdateQuery.Background = true; LCD_redraw(false); } else { if (sysmenu_onroot) { LCD_systemMenuOpened = false; LCD_UpdateQuery.Background = true; LCD_redraw(false); } else { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_item_count; sysmenu_onroot = true; systemMenuIndex = systemMenuRootIndex; SYSMENU_drawSystemMenu(true); } } sysmenu_item_selected_by_enc2 = false; NeedSaveSettings = true; if (sysmenu_hiddenmenu_enabled) NeedSaveCalibration = true; } void eventCloseAllSystemMenu(void) { sysmenu_handlers_selected = (struct sysmenu_item_handler*)&sysmenu_handlers[0]; sysmenu_item_count_selected = (uint8_t*)&sysmenu_item_count; sysmenu_onroot = true; systemMenuIndex = systemMenuRootIndex; sysmenu_item_selected_by_enc2 = false; LCD_systemMenuOpened = false; LCD_UpdateQuery.Background = true; LCD_redraw(false); } void eventSecRotateSystemMenu(int8_t direction) { //Callsign menu if (sysmenu_trx_setCallsign_menu_opened) { if (direction < 0 && sysmenu_trx_selected_callsign_char_index > 0) { sysmenu_trx_selected_callsign_char_index--; SYSMENU_TRX_DrawCallsignMenu(true); } else if (sysmenu_trx_selected_callsign_char_index < (MAX_CALLSIGN_LENGTH - 1)) { sysmenu_trx_selected_callsign_char_index++; SYSMENU_TRX_DrawCallsignMenu(true); } return; } if (sysmenu_swr_opened) return; if (sysmenu_infowindow_opened) return; //time menu if (sysmenu_timeMenuOpened) { LCDDriver_Fill(BG_COLOR); if (direction < 0) { TimeMenuSelection--; if (TimeMenuSelection > 2) TimeMenuSelection = 2; } else { TimeMenuSelection++; if (TimeMenuSelection == 3) TimeMenuSelection = 0; } LCD_UpdateQuery.SystemMenu = true; return; } //other if (sysmenu_item_selected_by_enc2) //selected by secondary encoder { eventRotateSystemMenu(direction); return; } uint8_t current_page = systemMenuIndex / LAY_SYSMENU_MAX_ITEMS_ON_PAGE; LCDDriver_drawFastHLine(0, (5 + (systemMenuIndex - current_page * LAY_SYSMENU_MAX_ITEMS_ON_PAGE) * LAY_SYSMENU_ITEM_HEIGHT) + 17, LAY_SYSMENU_W, BG_COLOR); if (direction < 0) { if (systemMenuIndex > 0) systemMenuIndex--; else if (!sysmenu_hiddenmenu_enabled && sysmenu_onroot) systemMenuIndex = *sysmenu_item_count_selected - 2; else systemMenuIndex = *sysmenu_item_count_selected - 1; } else { if (systemMenuIndex < (*sysmenu_item_count_selected - 1)) { systemMenuIndex++; } else systemMenuIndex = 0; } if (!sysmenu_hiddenmenu_enabled && sysmenu_handlers_selected[systemMenuIndex].type == SYSMENU_HIDDEN_MENU) systemMenuIndex = 0; while (systemMenuIndex > 0 && sysmenu_handlers_selected[systemMenuIndex].type == SYSMENU_INFOLINE) systemMenuIndex = 0; SYSMENU_redrawCurrentItem(); if (sysmenu_onroot) systemMenuRootIndex = systemMenuIndex; uint8_t new_page = systemMenuIndex / LAY_SYSMENU_MAX_ITEMS_ON_PAGE; if (current_page != new_page) SYSMENU_drawSystemMenu(true); } void SYSMENU_redrawCurrentItem(void) { uint8_t current_page = systemMenuIndex / LAY_SYSMENU_MAX_ITEMS_ON_PAGE; sysmenu_i = (uint8_t)(systemMenuIndex - current_page * LAY_SYSMENU_MAX_ITEMS_ON_PAGE); sysmenu_y = 5 + (systemMenuIndex - current_page * LAY_SYSMENU_MAX_ITEMS_ON_PAGE) * LAY_SYSMENU_ITEM_HEIGHT; drawSystemMenuElement(sysmenu_handlers_selected[systemMenuIndex].title, sysmenu_handlers_selected[systemMenuIndex].type, sysmenu_handlers_selected[systemMenuIndex].value, true); } static void drawSystemMenuElement(char *title, SystemMenuType type, uint32_t *value, bool onlyVal) { if (!sysmenu_hiddenmenu_enabled && type == SYSMENU_HIDDEN_MENU) return; char ctmp[10] = {0}; if (!onlyVal) { LCDDriver_Fill_RectXY(0, sysmenu_y, LAY_SYSMENU_W, sysmenu_y + 17, BG_COLOR); LCDDriver_printText(title, LAY_SYSMENU_X1, sysmenu_y, FG_COLOR, BG_COLOR, 2); } uint16_t x_pos = LAY_SYSMENU_X2; float32_t tmp_float = 0; switch (type) { case SYSMENU_UINT8: sprintf(ctmp, "%d", (uint8_t)*value); break; case SYSMENU_UINT16: sprintf(ctmp, "%d", (uint16_t)*value); break; case SYSMENU_UINT32: sprintf(ctmp, "%u", (uint32_t)*value); x_pos = LAY_SYSMENU_X2_BIGINT; break; case SYSMENU_UINT32R: sprintf(ctmp, "%u", (uint32_t)*value); x_pos = LAY_SYSMENU_X2R_BIGINT; //-V1048 break; case SYSMENU_INT8: sprintf(ctmp, "%d", (int8_t)*value); break; case SYSMENU_INT16: sprintf(ctmp, "%d", (int16_t)*value); break; case SYSMENU_INT32: sprintf(ctmp, "%d", (int32_t)*value); x_pos = LAY_SYSMENU_X2_BIGINT; break; case SYSMENU_FLOAT32: memcpy(&tmp_float, value, sizeof(float32_t)); sprintf(ctmp, "%.2f", (double)tmp_float); x_pos = LAY_SYSMENU_X2_BIGINT; break; case SYSMENU_BOOLEAN: sprintf(ctmp, "%d", (int8_t)*value); if ((uint8_t)*value == 1) sprintf(ctmp, "YES"); else sprintf(ctmp, "NO"); break; case SYSMENU_RUN: sprintf(ctmp, "RUN"); break; case SYSMENU_MENU: sprintf(ctmp, "->"); break; case SYSMENU_HIDDEN_MENU: sprintf(ctmp, "!!!"); break; case SYSMENU_INFOLINE: break; } if (onlyVal) LCDDriver_Fill_RectWH(x_pos, sysmenu_y, 6 * 12, 13, BG_COLOR); if (type != SYSMENU_INFOLINE) LCDDriver_printText(ctmp, x_pos, sysmenu_y, FG_COLOR, BG_COLOR, 2); uint8_t current_selected_page = systemMenuIndex / LAY_SYSMENU_MAX_ITEMS_ON_PAGE; if (systemMenuIndex == sysmenu_i + current_selected_page * LAY_SYSMENU_MAX_ITEMS_ON_PAGE) { if (sysmenu_item_selected_by_enc2) LCDDriver_drawFastHLine(0, sysmenu_y + 17, LAY_SYSMENU_W, COLOR->BUTTON_TEXT); else LCDDriver_drawFastHLine(0, sysmenu_y + 17, LAY_SYSMENU_W, FG_COLOR); } sysmenu_i++; sysmenu_y += LAY_SYSMENU_ITEM_HEIGHT; } //secondary encoder click void SYSMENU_eventSecEncoderClickSystemMenu(void) { if (sysmenu_handlers_selected[systemMenuIndex].type == SYSMENU_MENU || sysmenu_handlers_selected[systemMenuIndex].type == SYSMENU_HIDDEN_MENU || sysmenu_handlers_selected[systemMenuIndex].type == SYSMENU_RUN || sysmenu_handlers_selected[systemMenuIndex].type == SYSMENU_INFOLINE) { sysmenu_item_selected_by_enc2 = false; eventRotateSystemMenu(1); } else { sysmenu_item_selected_by_enc2 = !sysmenu_item_selected_by_enc2; LCD_UpdateQuery.SystemMenuCurrent = true; } }