/* -*- mode: c; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4; coding: utf-8 -*- */ /************************************************************************************ ** ** ** mcHF QRP Transceiver ** ** K Atanassov - M0NKA 2014 ** ** C Turner - KA7OEI 2014 ** ** ** **---------------------------------------------------------------------------------** ** ** ** File name: ui_menu.c ** ** Description: main user interface configuration/adjustment menu system ** ** Last Modified: ** ** Licence: GNU GPLv3 ** ************************************************************************************/ // Common // #include #include "uhsdr_board.h" #include "ui_menu.h" #include "ui_menu_internal.h" #include "ui_configuration.h" #include "config_storage.h" #include "serial_eeprom.h" #include "ui_spectrum.h" #include "rtc.h" #include "uhsdr_hmc1023.h" #include #include #include "arm_math.h" #include "math.h" #include "codec.h" #include "radio_management.h" #include "soft_tcxo.h" #include "cw_decoder.h" #include "osc_si5351a.h" #include "osc_si570.h" #include "audio_nr.h" #include "audio_agc.h" #include "fm_subaudible_tone_table.h" #include "tx_processor.h" #include "audio_reverb.h" #define CLR_OR_SET_BITMASK(cond,value,mask) ((value) = (((cond))? ((value) | (mask)): ((value) & ~(mask)))) void float2fixedstr(char* buf, int maxchar, float32_t f, uint16_t digitsBefore, uint16_t digitsAfter) { char formatstr[16],numberstr[32]; int32_t mult_digits = pow10(digitsAfter); snprintf(formatstr,16,(digitsBefore + digitsBefore > 0)?"%%%dd":"%%d",digitsBefore + digitsAfter); snprintf(numberstr, 31, formatstr, (int32_t)(f * mult_digits)); int32_t num_len = strnlen(numberstr,32); int idx = 0; for (idx= 0; idx < num_len - digitsAfter && idx < maxchar; idx++) { buf[idx] = numberstr[idx]; } if (idx == 0 || buf[idx-1] == '-') { buf[idx++] = '0'; } else if (buf[idx-1] == ' ') { buf[idx-1] = '0'; } buf[idx++] = '.'; for (int i= num_len - digitsAfter; i < num_len && i < maxchar; i++) { char c = numberstr[i]; if (c == ' ') { c = '0'; } buf[idx++] = c; } buf[idx] = '\0'; } // LCD #include "ui_lcd_hy28.h" // for colors! #include "uhsdr_hw_i2c.h" #include "uhsdr_rtc.h" // Codec control #include "codec.h" #include "softdds.h" #include "audio_driver.h" #include "audio_filter.h" #include "audio_management.h" #include "ui_driver.h" #include "cat_driver.h" // CW generation #include "cw_gen.h" // returns true if the value was changed in its value! bool __attribute__ ((noinline)) UiDriverMenuItemChangeUInt8(int var, MenuProcessingMode_t mode, volatile uint8_t* val_ptr,uint8_t val_min,uint8_t val_max, uint8_t val_default, uint8_t increment) { uint8_t old_val = *val_ptr; if(var >= 1) // setting increase? { ts.menu_var_changed = 1; // indicate that a change has occurred if (*val_ptr < val_max) { (*val_ptr)+= increment; } } else if(var <= -1) // setting decrease? { ts.menu_var_changed = 1; if (*val_ptr > val_min) { (*val_ptr)-= increment; } } if(*val_ptr < val_min) { ts.menu_var_changed = 1; *val_ptr = val_min; } if(*val_ptr > val_max) { ts.menu_var_changed = 1; *val_ptr = val_max; } if(mode == MENU_PROCESS_VALUE_SETDEFAULT) { ts.menu_var_changed = 1; *val_ptr = val_default; } return old_val != *val_ptr; } bool __attribute__ ((noinline)) UiDriverMenuItemChangeUInt32(int var, MenuProcessingMode_t mode, volatile uint32_t* val_ptr,uint32_t val_min,uint32_t val_max, uint32_t val_default, uint32_t increment) { uint32_t old_val = *val_ptr; if(var >= 1) // setting increase? { ts.menu_var_changed = 1; // indicate that a change has occurred if (*val_ptr < val_max) { (*val_ptr)+= increment; } } else if(var <= -1) // setting decrease? { ts.menu_var_changed = 1; if (*val_ptr > val_min) { (*val_ptr)-= increment; } } if(*val_ptr < val_min) { ts.menu_var_changed = 1; *val_ptr = val_min; } if(*val_ptr > val_max) { ts.menu_var_changed = 1; *val_ptr = val_max; } if(mode == MENU_PROCESS_VALUE_SETDEFAULT) { ts.menu_var_changed = 1; *val_ptr = val_default; } return old_val != *val_ptr; } bool __attribute__ ((noinline)) UiDriverMenuItemChangeInt(int var, MenuProcessingMode_t mode, volatile int* val_ptr,int val_min,int val_max, int val_default, uint32_t increment) { uint32_t old_val = *val_ptr; if(var >= 1) // setting increase? { ts.menu_var_changed = 1; // indicate that a change has occurred if (*val_ptr < val_max) { (*val_ptr)+= increment; } } else if(var <= -1) // setting decrease? { ts.menu_var_changed = 1; if (*val_ptr > val_min) { (*val_ptr)-= increment; } } if(*val_ptr < val_min) { ts.menu_var_changed = 1; *val_ptr = val_min; } if(*val_ptr > val_max) { ts.menu_var_changed = 1; *val_ptr = val_max; } if(mode == MENU_PROCESS_VALUE_SETDEFAULT) { ts.menu_var_changed = 1; *val_ptr = val_default; } return old_val != *val_ptr; } inline bool UiDriverMenuItemChangeInt32(int var, MenuProcessingMode_t mode, volatile int32_t* val_ptr,int val_min,int val_max, int val_default, uint32_t increment) { return UiDriverMenuItemChangeInt(var, mode, (int*)val_ptr,val_min,val_max, val_default, increment); } bool __attribute__ ((noinline)) UiDriverMenuItemChangeInt16(int var, MenuProcessingMode_t mode, volatile int16_t* val_ptr,int16_t val_min,int16_t val_max, int16_t val_default, uint16_t increment) { uint32_t old_val = *val_ptr; if(var >= 1) // setting increase? { ts.menu_var_changed = 1; // indicate that a change has occurred if (*val_ptr < val_max) { (*val_ptr)+= increment; } } else if(var <= -1) // setting decrease? { ts.menu_var_changed = 1; if (*val_ptr > val_min) { (*val_ptr)-= increment; } } if(*val_ptr < val_min) { ts.menu_var_changed = 1; *val_ptr = val_min; } if(*val_ptr > val_max) { ts.menu_var_changed = 1; *val_ptr = val_max; } if(mode == MENU_PROCESS_VALUE_SETDEFAULT) { ts.menu_var_changed = 1; *val_ptr = val_default; } return old_val != *val_ptr; } bool __attribute__ ((noinline)) UiDriverMenuItemChangeOnOff(int var, MenuProcessingMode_t mode, volatile uint8_t* val_ptr, uint8_t val_default) { // we have to align the values to true and false, since sometimes other values are passed for true (use of temp_var) // but this does not work properly. *val_ptr = (*val_ptr)?1:0; return UiDriverMenuItemChangeUInt8(var, mode, val_ptr, 0, 1, val_default, 1 ); } // always sets 1 or 0 as result, no matter what is passed as "true" value. Only 0 is recognized as false/ bool __attribute__ ((noinline)) UiDriverMenuItemChangeDisableOnOff(int var, MenuProcessingMode_t mode, volatile uint8_t* val_ptr, uint8_t val_default, char* options, uint32_t* clr_ptr) { bool res = UiDriverMenuItemChangeOnOff(var, mode, val_ptr, val_default); strcpy(options, *val_ptr?"OFF":" ON"); if (*val_ptr) { *clr_ptr = Orange; } return res; } bool __attribute__ ((noinline)) UiDriverMenuItemChangeEnableOnOff(int var, MenuProcessingMode_t mode, volatile uint8_t* val_ptr, uint8_t val_default, char* options, uint32_t* clr_ptr) { bool res = UiDriverMenuItemChangeOnOff(var, mode, val_ptr, val_default); strcpy(options, *val_ptr?" ON":"OFF"); if (!*val_ptr) { *clr_ptr = Orange; } return res; } bool UiDriverMenuItemChangeEnableOnOffBool(int var, MenuProcessingMode_t mode, volatile bool* val_ptr, uint8_t val_default, char* options, uint32_t* clr_ptr) { uint8_t temp = *val_ptr; bool res = UiDriverMenuItemChangeEnableOnOff(var, mode, &temp, val_default, options, clr_ptr); *val_ptr = temp; return res; } bool UiDriverMenuItemChangeEnableOnOffFlag(int var, MenuProcessingMode_t mode, volatile uint16_t* val_ptr, uint8_t val_default, char* options, uint32_t* clr_ptr, uint16_t mask) { uint8_t temp = (*val_ptr & mask)?1:0; bool res = UiDriverMenuItemChangeEnableOnOff(var, mode, &temp, val_default, options, clr_ptr); CLR_OR_SET_BITMASK(temp,*val_ptr,mask); return res; } bool __attribute__ ((noinline)) UiMenu_ChangeFilterPathMemory(int var, MenuProcessingMode_t mode, char* options, uint32_t* clr_ptr, uint16_t filter_mode,uint8_t memory_idx) { uint32_t temp_var = ts.filter_path_mem[filter_mode][memory_idx]; uint16_t old_fp = temp_var; // for now just a single location CW for testing bool tchange = UiDriverMenuItemChangeUInt32(var, mode, &temp_var, 0, AUDIO_FILTER_PATH_NUM, 0, 1); if(tchange) // did something change? { uint16_t fp = AudioFilter_NextApplicableFilterPath(PATH_ALL_APPLICABLE|PATH_DONT_STORE | (temp_var< old_fp?PATH_DOWN:PATH_UP),filter_mode,old_fp); if (fp >= old_fp && temp_var < old_fp) { // wrap around -> we need to insert "0" fp = 0; } ts.filter_path_mem[filter_mode][memory_idx] = fp; } if (ts.filter_path_mem[filter_mode][memory_idx] > 0) { const char *filter_names[2]; AudioFilter_GetNamesOfFilterPath(ts.filter_path_mem[filter_mode][memory_idx],filter_names); sprintf(options, " %s/%s", filter_names[0],filter_names[1]); } else { sprintf(options, " UNUSED"); } return tchange; } void UiMenu_HandleDemodModeDisable(int var, MenuProcessingMode_t mode, char* options, uint32_t* clr_ptr, uint16_t demod_mode_disable) { uint8_t var_change; uint8_t mode_disable = 1; if (ts.demod_mode_disable & demod_mode_disable) { mode_disable = 0; } var_change = UiDriverMenuItemChangeEnableOnOff(var, mode, &mode_disable,0,options,clr_ptr); if (var_change) { if(mode_disable == false) { ts.demod_mode_disable |= demod_mode_disable; } else { ts.demod_mode_disable &= ~demod_mode_disable; } } } void UiMenu_HandleIQAdjust(int var, MenuProcessingMode_t mode, char* options, uint32_t* clr_ptr, volatile int32_t* val_ptr, const uint16_t txrx_mode, int32_t min, int32_t max, iq_trans_idx_t valid_for) { bool tchange = false; // used to decide whether the current transceiver state enables us to change the value // later also mode is used but this is for the menu internal operation // txrx_mode valid_t Cond // RX IQ_TRANS_OFF RadioManagement_GetRealFreqTranslationMode(txrx_mode, ts.dmod_mode, ts.iq_freq_mode) == FREQ_IQ_CONV_MODE_OFF && (is_ssb(ts.dmod_mode) || ts.dmod_mode == DEMOD_CW) // if freq translate is off, ssb and cw are fine // TX IQ_TRANS_OFF RadioManagement_GetRealFreqTranslationMode(txrx_mode, ts.dmod_mode, ts.iq_freq_mode) == FREQ_IQ_CONV_MODE_OFF && (is_ssb(ts.dmod_mode) || ts.dmod_mode == DEMOD_CW) // we transmit in CW always in non-translated mode // RX IQ_TRANS_ON RadioManagement_GetRealFreqTranslationMode(txrx_mode, ts.dmod_mode, ts.iq_freq_mode) != FREQ_IQ_CONV_MODE_OFF && (is_ssb(ts.dmod_mode) || ts.dmod_mode == DEMOD_CW) // TX IQ_TRANS_ON RadioManagement_GetRealFreqTranslationMode(txrx_mode, ts.dmod_mode, ts.iq_freq_mode) != FREQ_IQ_CONV_MODE_OFF && (is_ssb(ts.dmod_mode) || ts.dmod_mode == DEMOD_CW) iq_trans_idx_t current_trans_idx = RadioManagement_GetRealFreqTranslationMode(ts.txrx_mode, ts.dmod_mode, ts.iq_freq_mode) == FREQ_IQ_CONV_MODE_OFF? IQ_TRANS_OFF : IQ_TRANS_ON; bool trans_mode_match = current_trans_idx == valid_for && (is_ssb(ts.dmod_mode) || ts.dmod_mode == DEMOD_CW); if(trans_mode_match && (ts.txrx_mode == txrx_mode)) // only allow adjustment if in right mode { tchange = UiDriverMenuItemChangeInt32(var, mode, val_ptr, min, max, min, 1); if(tchange) { AudioManagement_CalcIqPhaseGainAdjust(ts.tune_freq); } } else // Orange if not in correct mode { *clr_ptr = Orange; } if (*val_ptr == IQ_BALANCE_OFF) { snprintf(options,32, " OFF"); } else { snprintf(options,32, "%4d", (int)*val_ptr); } } void UiMenu_HandleIQAdjustGain(int var, MenuProcessingMode_t mode, char* options, uint32_t* clr_ptr, volatile int32_t* val_ptr, const uint16_t txrx_mode, iq_trans_idx_t valid_for) { UiMenu_HandleIQAdjust(var, mode, options, clr_ptr, val_ptr, txrx_mode, MIN_IQ_GAIN_BALANCE, MAX_IQ_GAIN_BALANCE, valid_for); } void UiMenu_HandleIQAdjustPhase(int var, MenuProcessingMode_t mode, char* options, uint32_t* clr_ptr, volatile int32_t* val_ptr, const uint16_t txrx_mode, iq_trans_idx_t valid_for) { UiMenu_HandleIQAdjust(var, mode, options, clr_ptr, val_ptr, txrx_mode, MIN_IQ_PHASE_BALANCE, MAX_IQ_PHASE_BALANCE, valid_for); } const ColorNameValue MchfColor_Id2ValueName[SPEC_MAX_COLOUR] = { { White, "Whit"}, { Grey, "Grey"}, { Blue, "Blue"}, { Red, "Red1"}, { Red2, "Red2"}, { Red3, "Red3"}, { Magenta, "Mgnt"}, { Green, "Gren"}, { Cyan, "Cyan"}, { Yellow, "Yelw"}, { Orange, "Oran"}, { Cream, "Crea"}, { Black, "Blck"}, { Grey1, "Gry1"}, { Grey2, "Gry2"}, { Grey3, "Gry3"}, { Grey4, "Gry4"}, { Grey5, "Gry5"}, { Grey6, "Gry6"}, { Grey7, "Gry7"}, { Red4, "Red4"}, { Green2, "Gre2"}, { Blue3, "Blu3"}, { Brown, "Brow"}, }; void __attribute__ ((noinline)) UiMenu_MapColors(uint32_t color ,char* options,volatile uint32_t* clr_ptr) { const ColorNameValue* cnv; if (color < SPEC_MAX_COLOUR) { cnv = &MchfColor_Id2ValueName[color]; } else { cnv = &MchfColor_Id2ValueName[SPEC_GREY]; } if (options != NULL) { strcpy(options,cnv->name); } *clr_ptr = cnv->value; } void __attribute__ ((noinline)) UiDriverMenuMapStrings(char* output, uint32_t value ,const uint32_t string_max, const char** strings) { strcpy(output,(value <= string_max)?strings[value]:"UNDEFINED"); } /** * @returns: information for requested item as string. Do not write to this string. */ const char* UiMenu_GetSystemInfo(uint32_t* m_clr_ptr, int info_item) { static char out[48]; const char* outs = NULL; *m_clr_ptr = White; out[0] = 0; switch (info_item) { case INFO_DISPLAY: { outs = UiLcdHy28_DisplayInfoGet(ts.display->display_type)->name; break; } case INFO_DISPLAY_CTRL: { // const char* disp_com = ts.display_type==3?"parallel":"SPI"; // snprintf(out,32,"ILI%04x %s",ts.DeviceCode,disp_com); if(ts.display->DeviceCode==0x8875) { snprintf(out,32,"RA%04x",ts.display->DeviceCode); } else if(ts.display->DeviceCode==0x7796) { snprintf(out,32,"ST%04x",ts.display->DeviceCode); } else { snprintf(out,32,"ILI%04x",ts.display->DeviceCode); } break; } #ifdef USE_OSC_SI570 case INFO_SI570: { if (osc->type == OSC_SI570) { float suf = Si570_GetStartupFrequency(); int vorkomma = (int)(suf); int nachkomma = (int) roundf((suf-vorkomma)*10000); snprintf(out,32,"%xh / %u.%04u MHz",(Si570_GetI2CAddress() >> 1),vorkomma,nachkomma); } else { outs = "Not applicable"; if (osc == NULL) { *m_clr_ptr = Red; } } } break; #endif case INFO_OSC_NAME: { if (osc->isPresent) { outs = osc->name; } else { outs = "Not present"; *m_clr_ptr = Red; } } break; case INFO_TP: outs = (ts.tp->present == 0)?"n/a":"XPT2046"; break; case INFO_RFBOARD: switch(ts.rf_board) { case FOUND_RF_BOARD_OVI40: outs = "OVI40 RF Board"; break; default: outs = "mcHF RF Board"; break; } break; case INFO_FLASH: snprintf(out,32,"%d",(STM32_GetFlashSize())); break; case INFO_CPU: snprintf(out,32,"%3lx:%04lxh",HAL_GetDEVID(),HAL_GetREVID()); break; case INFO_RAM: snprintf(out,32,"%d",(ts.ramsize)); break; case INFO_EEPROM: { const char* label = ""; switch(ts.configstore_in_use) { case CONFIGSTORE_IN_USE_I2C: label = " [used]"; *m_clr_ptr = Green; break; // in use & ok case CONFIGSTORE_IN_USE_ERROR: // not ok label = " [error]"; *m_clr_ptr = Red; break; default: label = " [not used]"; if (ts.ser_eeprom_type >= SERIAL_EEPROM_DESC_REAL && SerialEEPROM_eepromTypeDescs[ts.ser_eeprom_type].size < SERIAL_EEPROM_MIN_USEABLE_SIZE) { label = " [too small]"; } *m_clr_ptr = Red; } const char* i2c_size_unit = "K"; uint i2c_size = 0; if(ts.ser_eeprom_type < SERIAL_EEPROM_DESC_NUM) { i2c_size = SerialEEPROM_eepromTypeDescs[ts.ser_eeprom_type].size / 1024; } // in case we have no or very small eeprom (less than 1K) if (i2c_size == 0) { i2c_size = SerialEEPROM_eepromTypeDescs[ts.ser_eeprom_type].size; i2c_size_unit = "B"; } snprintf(out,48,"%s/%u%s%s",SerialEEPROM_eepromTypeDescs[ts.ser_eeprom_type].name, i2c_size, i2c_size_unit, label); } break; case INFO_BL_VERSION: { outs = Board_BootloaderVersion(); } break; case INFO_FW_VERSION: { #ifdef OFFICIAL_BUILD #ifdef IS_SMALL_BUILD snprintf(out,32, "S%s", UHSDR_VERSION+4); #else snprintf(out,32, "D%s", UHSDR_VERSION+4); #endif #else snprintf(out,32, "%s", UHSDR_VERSION+4); #endif } break; case INFO_BUILD: { snprintf(out,32, "%s", UHSDR_BUILD_DAT+4); } break; case INFO_RTC: { snprintf(out,32, "%s", ts.rtc_present?"Yes":"N/A"); } break; case INFO_VBAT: { snprintf(out,32, "%s", ts.vbat_present?"Yes":"N/A"); } break; case INFO_CODEC: { #ifdef UI_BRD_MCHF snprintf(out,32, "%s", ts.codec_present?"Yes":"N/A"); #else // OVI40 or Amber-UI if(ts.codec_present) { snprintf(out,32, "%s", " 2xWM8731"); } else if(ts.codecWM8731_Audio_present) { snprintf(out,32, "%s", ts.codecCS4270_present?" WM8731+CS4270":" IQ N/A"); } else { snprintf(out,32, "%s", "N/A"); } #endif } break; case INFO_CODEC_TWINPEAKS: { if (ts.iq_auto_correction == 1) { switch (ts.twinpeaks_tested) { case TWINPEAKS_UNCORRECTABLE: outs = " Failed"; break; case TWINPEAKS_DONE: outs = " Done"; break; default: outs = " Not done"; } } else { outs = "Deactivated"; // IQ correction is off, Twinpeaks auto correction cannot be done. } } break; case INFO_LO_TX_SUPR_DACs: { snprintf(out,32, "%s", ts.lotx_dacs_present ? "Yes" : "N/A"); } break; #ifdef SDR_AMBER case INFO_AMBER_IO8: { snprintf(out,32, "%s", ts.amber_io8_present ? "Yes" : "N/A"); } break; case INFO_AMBER_IO4: { snprintf(out,32, "%s", ts.amber_io4_present ? "Yes" : "N/A"); } break; case INFO_AMBER_DAC_PWR_TX: { snprintf(out,32, "%s", ts.amber_dac_pwr_tx_present ? "Yes" : "N/A"); } break; #endif case INFO_LICENCE: { snprintf(out,32, "%s", UHSDR_LICENCE); } break; #ifdef TRX_HW_LIC case INFO_HWLICENCE: { snprintf(out,32, "%s", TRX_HW_LIC); } break; #endif default: outs = "NO INFO"; } if (outs == NULL) { outs = out; } return outs; } bool __attribute__ ((noinline)) UiDriverMenuBandPowerAdjust(int var, MenuProcessingMode_t mode, uint8_t band_mode, uint8_t pa_level, char* options, uint32_t* clr_ptr) { volatile uint8_t* adj_ptr = &ts.pwr_adj[pa_level == PA_LEVEL_FULL?ADJ_FULL_POWER:ADJ_REF_PWR][band_mode]; bool tchange = false; const BandInfo* band = RadioManagement_GetBand(df.tune_old); if((band_mode == band->band_mode) && (ts.power_level == pa_level)) { tchange = UiDriverMenuItemChangeUInt8(var, mode, adj_ptr, TX_POWER_FACTOR_MIN, RadioManagement_IsPowerFactorReduce(df.tune_old)?TX_POWER_FACTOR_MAX:TX_POWER_FACTOR_MAX/4, TX_POWER_FACTOR_MIN, 1 ); if(tchange) // did something change? { RadioManagement_SetPowerLevel(band, pa_level); // yes, update the power factor } } else { // not enabled *clr_ptr = Orange; } sprintf(options, " %u", *adj_ptr); return tchange; } bool __attribute__ ((noinline)) UiDriverMenuBandRevCouplingAdjust(int var, MenuProcessingMode_t mode, uint8_t coupling_band, char* options, uint32_t* clr_ptr) { bool tchange = false; volatile uint8_t *adj_ptr = &swrm.coupling_calc[coupling_band]; if(ts.coupling_band == coupling_band) // is this band selected? { tchange = UiDriverMenuItemChangeUInt8(var, mode, adj_ptr, SWR_COUPLING_MIN, SWR_COUPLING_MAX, SWR_COUPLING_DEFAULT, 1 ); } if((ts.txrx_mode != TRX_MODE_TX) || (ts.coupling_band != coupling_band)) // Orange if not in TX mode or NOT on this band *clr_ptr = Orange; sprintf(options, " %u", *adj_ptr); return tchange; } /** * * @param select * @param mode selects if the entry is just to be displayed or can be changed. * @param pos which line the menu item is being displayed on, used for positioning value display in some cases. * @param var the actual menu item to change / display * @param options the to be displayed value is returned as a string in this array. Shown unless txt_ptr_ptr does not point to a NULL ptr * @param txt_ptr_ptr this is a return value. if the address in the referenced pointer is not NULL, this is displayed, not options. * @param clr_ptr pointer to the value display color */ void UiMenu_UpdateItem(uint16_t select, MenuProcessingMode_t mode, int pos, int var, char* options, const char** txt_ptr_ptr, uint32_t* clr_ptr) { const char* txt_ptr = NULL; uint32_t clr = *clr_ptr; uint8_t nr_step; // case statement local variables defined for convenience here bool var_change = false; uint8_t temp_var_u8; // used to temporarily represent some configuration values as uint8_t value bool temp_var_bool; #ifdef HELP_MENU ts.menu_selected_item = select; #endif if(mode == MENU_PROCESS_VALUE_CHANGE) { if(select == CONFIG_XVTR_FREQUENCY_OFFSET) // signal if we are in XVTR FREQUENCY OFFSET adjust mode for alternate frequency steps ts.xvtr_adjust_flag = 1; else // NOT in transverter mode { if(ts.xvtr_adjust_flag) // had transverter frequency mode been active? { ts.xvtr_adjust_flag = 0; // yes - disable flag UiDriver_ChangeTuningStep(0); // force to valid frequency step size for normal tuning UiDriver_ChangeTuningStep(1); } } } // switch(select) // DSP_NR_STRENGTH_MAX // { // case MENU_DSP_NR_STRENGTH: // DSP Noise reduction strength if(select==MENU_DSP_NR_STRENGTH) { nr_step = DSP_NR_STRENGTH_STEP; if(ts.dsp.nr_strength >= 190 || ts.dsp.nr_strength <= 10) { nr_step = 1; } var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.dsp.nr_strength, DSP_NR_STRENGTH_MIN, DSP_NR_STRENGTH_MAX, DSP_NR_STRENGTH_DEFAULT, nr_step ); if(var_change) { if(ts.dsp.nr_strength == 189) { ts.dsp.nr_strength = 185; } if(ts.dsp.nr_strength == 11) { ts.dsp.nr_strength = 15; } // did it change? if(ts.dsp.active & DSP_NR_ENABLE) // only change if DSP active { // this causes considerable noise //AudioDriver_SetRxAudioProcessing(ts.dmod_mode, false); // we do this instead nr_params.alpha = 0.799 + ((float32_t)ts.dsp.nr_strength / 1000.0); } } #ifdef OBSOLETE_NR if(!(ts.dsp.active & DSP_NR_ENABLE)) // make red if DSP not active { clr = Orange; } else { if(ts.dsp.nr_strength >= DSP_STRENGTH_RED) clr = Red; else if(ts.dsp.nr_strength >= DSP_STRENGTH_ORANGE) clr = Orange; else if(ts.dsp.nr_strength >= DSP_STRENGTH_YELLOW) clr = Yellow; } #endif // snprintf(options,32, " %u", ts.dsp.nr_strength); // break; } // case MENU_AM_DISABLE: // AM mode enable/disable else if(select==MENU_AM_DISABLE) { UiMenu_HandleDemodModeDisable(var, mode, options, &clr, DEMOD_AM_DISABLE); // break; } // case MENU_DIGI_DISABLE: // AM mode enable/disable else if(select==MENU_DIGI_DISABLE) { UiMenu_HandleDemodModeDisable(var, mode, options, &clr, DEMOD_DIGI_DISABLE); // break; } // case MENU_CW_DISABLE: // AM mode enable/disable else if(select==MENU_CW_DISABLE) { UiMenu_HandleDemodModeDisable(var, mode, options, &clr, DEMOD_CW_DISABLE); // break; } // case MENU_DEMOD_SAM: // Enable demodulation mode SAM else if(select==MENU_DEMOD_SAM) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.flags1,0,options,&clr, FLAGS1_SAM_ENABLE); // break; } // case MENU_SSB_AUTO_MODE_SELECT: // Enable/Disable auto LSB/USB select else if(select==MENU_SSB_AUTO_MODE_SELECT) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.lsb_usb_auto_select, 0, AUTO_LSB_USB_MAX, AUTO_LSB_USB_OFF, 1 ); switch(ts.lsb_usb_auto_select) { case AUTO_LSB_USB_ON: // LSB on bands < 10 MHz txt_ptr = " ON"; // yes break; case AUTO_LSB_USB_60M: // USB on 60 meters? txt_ptr = "USB 60M"; // yes break; default: txt_ptr = " OFF"; // no (obviously!) } // break; } // case MENU_FM_MODE_ENABLE: // Enable/Disable FM else if(select==MENU_FM_MODE_ENABLE) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.flags2,0,options,&clr, FLAGS2_FM_MODE_ENABLE); // break; } // case MENU_FM_GEN_SUBAUDIBLE_TONE: // Selection of subaudible tone for FM transmission else if(select==MENU_FM_GEN_SUBAUDIBLE_TONE) { var_change = UiDriverMenuItemChangeUInt32(var, mode, &ts.fm_subaudible_tone_gen_select, 0, NUM_SUBAUDIBLE_TONES, FM_SUBAUDIBLE_TONE_OFF, 1 ); if (var_change) { AudioManagement_CalcSubaudibleGenFreq(fm_subaudible_tone_table[ts.fm_subaudible_tone_gen_select]); } if(ts.fm_subaudible_tone_gen_select != FM_SUBAUDIBLE_TONE_OFF) // tone select not zero (tone activated { int a = (int)(ads.fm_conf.subaudible_tone_gen_freq * 10); // convert to integer, Hz*10 snprintf(options,32, "%d.%01dHz", a/10, a%10); } else // tone is off { snprintf(options,32, " OFF"); // make it dislay "off" } if(ts.dmod_mode != DEMOD_FM) // make orange if we are NOT in FM mode { clr = Orange; } else if(ads.fm_conf.subaudible_tone_det_freq > 200) // yellow for tones above 200 Hz as they are more audible { clr = Yellow; } // break; } // case MENU_FM_DET_SUBAUDIBLE_TONE: // Selection of subaudible tone for FM reception else if(select==MENU_FM_DET_SUBAUDIBLE_TONE) { UiDriverMenuItemChangeUInt32(var, mode, &ts.fm_subaudible_tone_det_select, 0, NUM_SUBAUDIBLE_TONES, FM_SUBAUDIBLE_TONE_OFF, 1 ); AudioManagement_CalcSubaudibleDetFreq(fm_subaudible_tone_table[ts.fm_subaudible_tone_det_select]); if(ts.fm_subaudible_tone_det_select) // tone select not zero (tone activated { // calculate frequency word int a = (int)(ads.fm_conf.subaudible_tone_det_freq * 10); // convert to integer, Hz*10 snprintf(options,32, "%d.%01dHz", a/10, a%10); } else // tone is off { snprintf(options,32, " OFF"); // make it dislay "off" } if(ts.dmod_mode != DEMOD_FM) // make orange if we are NOT in FM { clr = Orange; } else if(ads.fm_conf.subaudible_tone_det_freq > 200) // yellow for tones above 200 Hz as they are more audible { clr = Yellow; } // break; } // case MENU_FM_TONE_BURST_MODE: else if(select==MENU_FM_TONE_BURST_MODE) { UiDriverMenuItemChangeUInt8(var, mode, &ts.fm_tone_burst_mode, 0, FM_TONE_BURST_MAX, FM_TONE_BURST_OFF, 1 ); ads.fm_conf.tone_burst_active = 0; // make sure it is turned off AudioManagement_LoadToneBurstMode(); // activate setting if (ts.fm_tone_burst_mode != FM_TONE_BURST_OFF) { snprintf(options, 32, " %lu Hz", fm_tone_burst_freq[ts.fm_tone_burst_mode]); } else { txt_ptr = " OFF"; } if(ts.dmod_mode != DEMOD_FM) // make orange if we are NOT in FM { clr = Orange; } // break; } // case MENU_FM_DEV_MODE: // Select +/- 2.5 or 5 kHz deviation on RX and TX else if(select==MENU_FM_DEV_MODE) { if(ts.iq_freq_mode) { temp_var_u8 = RadioManagement_FmDevIs5khz(); var_change = UiDriverMenuItemChangeEnableOnOff(var, mode, &temp_var_u8,0,options,&clr); if(var_change) { RadioManagement_FmDevSet5khz(temp_var_u8 != 0); // band up/down swap is to be enabled } if(RadioManagement_FmDevIs5khz()) // Check state of bit indication 2.5/5 kHz { txt_ptr = "+-5k (Wide)"; // Bit is set - 5 kHz } else { txt_ptr = "+-2k5 (Nar)"; // Not set - 2.5 kHz } } else // translate mode is off - NO FM!!! { txt_ptr = " OFF"; // Say that it is OFF! clr = Red; } // break; } #if 0 // case MENU_AGC_MODE: // AGC mode else if(select==MENU_AGC_MODE) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.agc_mode, 0, AGC_MAX_MODE, AGC_DEFAULT, 1 ); switch(ts.agc_mode) { case AGC_SLOW: txt_ptr = " SLOW"; break; case AGC_MED: txt_ptr = " MED"; break; case AGC_FAST: txt_ptr = " FAST"; break; case AGC_OFF: txt_ptr = "MANUAL"; clr = Red; break; case AGC_CUSTOM: txt_ptr = "CUSTOM"; break; } if(var_change) { // now set the AGC AudioManagement_CalcAGCDecay(); // initialize AGC decay ("hang time") values } if(ts.txrx_mode == TRX_MODE_TX) // Orange if in TX mode { clr = Orange; } // break; } // case MENU_RF_GAIN_ADJ: // RF gain control adjust else if(select==MENU_RF_GAIN_ADJ) { var_change = UiDriverMenuItemChangeInt(var, mode, &ts.rf_gain, 0, MAX_RF_GAIN, DEFAULT_RF_GAIN, 1 ); if(var_change) { AudioManagement_CalcRFGain(); } if(ts.rf_gain < 20) { clr = Red; } else if(ts.rf_gain < 30) { clr = Orange; } else if(ts.rf_gain < 40) { clr = Yellow; } else { clr = White; } if(var_change) // did RFGain get changed? { UiDriver_RefreshEncoderDisplay(); // maybe shown on encoder boxes } snprintf(options, 32, " %d", ts.rf_gain); // break; } #endif // case MENU_AGC_WDSP_MODE: // AGC mode else if(select==MENU_AGC_WDSP_MODE) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &agc_wdsp_conf.mode, 0, // 5, 2, 1 ); switch(agc_wdsp_conf.mode) { case 0: txt_ptr = "very LONG"; break; case 1: txt_ptr = " LONG"; break; case 2: txt_ptr = " SLOW"; break; case 3: txt_ptr = " MED"; break; case 4: txt_ptr = " FAST"; break; case 5: txt_ptr = " OFF "; clr = Red; break; } if(var_change) { // now set the AGC parameters agc_wdsp_conf.switch_mode = 1; // set flag to 1 for parameter change AudioDriver_AgcWdsp_Set(); UiMenu_RenderMenu(MENU_RENDER_ONLY); } if(ts.txrx_mode == TRX_MODE_TX) // Orange if in TX mode { clr = Orange; } // break; } // case MENU_AGC_WDSP_SLOPE: // else if(select==MENU_AGC_WDSP_SLOPE) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &agc_wdsp_conf.slope, 0, 200, 40, 10 ); if(var_change) { AudioDriver_AgcWdsp_Set(); } snprintf(options, 32, " %ddB", agc_wdsp_conf.slope / 10); // break; } // case MENU_AGC_WDSP_THRESH: // else if(select==MENU_AGC_WDSP_THRESH) { var_change = UiDriverMenuItemChangeInt(var, mode, &agc_wdsp_conf.thresh, -20, 120, 40, 1 ); if(var_change) { AudioDriver_AgcWdsp_Set(); } snprintf(options, 32, " %ddB", agc_wdsp_conf.thresh); // break; } // case MENU_AGC_WDSP_HANG_THRESH: // else if(select==MENU_AGC_WDSP_HANG_THRESH) { var_change = UiDriverMenuItemChangeInt(var, mode, &agc_wdsp_conf.hang_thresh, -20, 120, 40, 1 ); if(var_change) { AudioDriver_AgcWdsp_Set(); } snprintf(options, 32, " %ddB", agc_wdsp_conf.hang_thresh); // break; } // case MENU_AGC_WDSP_TAU_DECAY: // else if(select==MENU_AGC_WDSP_TAU_DECAY) { var_change = UiDriverMenuItemChangeInt(var, mode, &agc_wdsp_conf.tau_decay[agc_wdsp_conf.mode], 100, 5000, 1000, 100 ); if(var_change) { AudioDriver_AgcWdsp_Set(); } snprintf(options, 32, " %ums", agc_wdsp_conf.tau_decay[agc_wdsp_conf.mode]); // break; } // case MENU_AGC_WDSP_TAU_HANG_DECAY: // else if(select==MENU_AGC_WDSP_TAU_HANG_DECAY) { var_change = UiDriverMenuItemChangeInt(var, mode, &agc_wdsp_conf.tau_hang_decay, 100, 5000, 1000, 100 ); if(var_change) { AudioDriver_AgcWdsp_Set(); } snprintf(options, 32, " %ums", agc_wdsp_conf.tau_hang_decay); // break; } // case MENU_DBM_CALIBRATE: // else if(select==MENU_DBM_CALIBRATE) { var_change = UiDriverMenuItemChangeInt32(var, mode, &ts.dbm_constant, -100, 100, 0, 1 ); snprintf(options, 32, " %lddB", ts.dbm_constant); // break; } // case MENU_UI_INVERSE_SCROLLING: // else if(select==MENU_UI_INVERSE_SCROLLING) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.flags2,0,options,&clr,FLAGS2_UI_INVERSE_SCROLLING); if(var_change) { UiMenu_RenderMenu(MENU_RENDER_ONLY); } // break; } // case MENU_AGC_WDSP_HANG_TIME: // else if(select==MENU_AGC_WDSP_HANG_TIME) { var_change = UiDriverMenuItemChangeInt(var, mode, &agc_wdsp_conf.hang_time, 10, 5000, 250, 10 ); if(var_change) { AudioDriver_AgcWdsp_Set(); } snprintf(options, 32, " %dms", agc_wdsp_conf.hang_time); // break; } #if 0 // case MENU_AGC_WDSP_SWITCH: // Enable/Disable wdsp AGC else if(select==MENU_AGC_WDSP_SWITCH) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &agc_wdsp_conf, 0, 1, 0, 1 ); switch(agc_wdsp_conf) { case 1: // txt_ptr = " WDSP AGC"; // break; default: txt_ptr = "Standard AGC"; // } // break; } #endif // case MENU_AGC_WDSP_HANG_ENABLE: // else if(select==MENU_AGC_WDSP_HANG_ENABLE) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &agc_wdsp_conf.hang_enable, 0, 1, 0, 1 ); switch(agc_wdsp_conf.hang_enable) { case 1: // txt_ptr = " ON"; // break; case 0: txt_ptr = " OFF"; // } // break; } // case MENU_SAM_PLL_LOCKING_RANGE: // else if(select==MENU_SAM_PLL_LOCKING_RANGE) { var_change = UiDriverMenuItemChangeInt(var, mode, &ads.pll_fmax_int, 50, 8000, 500, 10 ); if(var_change) { AudioDriver_SetSamPllParameters(); } snprintf(options, 32, " %d", ads.pll_fmax_int); // break; } // case MENU_SAM_PLL_STEP_RESPONSE: // else if(select==MENU_SAM_PLL_STEP_RESPONSE) { var_change = UiDriverMenuItemChangeInt(var, mode, &ads.zeta_int, 1, 100, 65, 1 ); if(var_change) { AudioDriver_SetSamPllParameters(); } snprintf(options, 32, " %d", ads.zeta_int); // break; } // case MENU_SAM_PLL_BANDWIDTH: // else if(select==MENU_SAM_PLL_BANDWIDTH) { var_change = UiDriverMenuItemChangeInt(var, mode, &ads.omegaN_int, 25, 1000, 250, 5 ); if(var_change) { AudioDriver_SetSamPllParameters(); } snprintf(options, 32, " %d", ads.omegaN_int); // break; } // case MENU_SAM_FADE_LEVELER: // Enable/Disable fade leveler for SAM else if(select==MENU_SAM_FADE_LEVELER) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ads.fade_leveler, 0, 1, 0, 1 ); switch(ads.fade_leveler) { case 1: // txt_ptr = " ON"; // break; default: txt_ptr = " OFF"; // } // break; } /* case MENU_SAM_SIDEBAND: // var_change = UiDriverMenuItemChangeUInt8(var, mode, &ads.sam_sideband, 0, 2, 0, 1 ); if(var_change) { UiDriver_ShowMode(); } // if(ads.sam_sideband == 1 || ads.sam_sideband == 2) { clr = Red; } switch(ads.sam_sideband) { case 0: txt_ptr = "BOTH"; break; case 1: txt_ptr = " LSB"; break; case 2: txt_ptr = " USB"; break; } break; case CONFIG_SAM_PLL_TAUR: // var_change = UiDriverMenuItemChangeInt(var, mode, &ads.tauR_int, 1, 1000, 20, 1 ); if(var_change) { set_SAM_PLL_parameters(); } snprintf(options, 32, " %d", ads.tauR_int); break; case CONFIG_SAM_PLL_TAUI: // var_change = UiDriverMenuItemChangeInt(var, mode, &ads.tauI_int, 1, 1000, 140, 1 ); if(var_change) { } snprintf(options, 32, " %d", ads.tauI_int); break; */ // RX Codec gain adjust #if 0 // case MENU_CUSTOM_AGC: // Custom AGC adjust else if(select==MENU_CUSTOM_AGC) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.agc_custom_decay, 0, AGC_CUSTOM_MAX, AGC_CUSTOM_DEFAULT, 1 ); if(var_change) { if(ts.agc_custom_decay > AGC_CUSTOM_MAX) ts.agc_custom_decay = AGC_CUSTOM_MAX; // now set the custom AGC - if in custom mode if(ts.agc_mode == AGC_CUSTOM) { float tcalc; tcalc = (float)ts.agc_custom_decay; // use temp var "tcalc" as audio function tcalc += 30; // can be called mid-calculation! tcalc /= 10; tcalc *= -1; tcalc = powf(10, tcalc); ads.agc_decay = tcalc; } } if((ts.txrx_mode == TRX_MODE_TX) || (ts.agc_mode != AGC_CUSTOM)) // Orange if in TX mode { clr = Orange; } else if(ts.agc_custom_decay <= AGC_CUSTOM_FAST_WARNING) // Display in red if setting may be too fast { clr = Red; } snprintf(options,32, " %d", ts.agc_custom_decay); // break; } #endif // A/D Codec Gain/Mode setting/adjust // case MENU_CODEC_GAIN_MODE: else if(select==MENU_CODEC_GAIN_MODE) { UiDriverMenuItemChangeUInt8(var, mode, &ts.rf_codec_gain, 0, MAX_RF_CODEC_GAIN_VAL, DEFAULT_RF_CODEC_GAIN_VAL, 1 ); if(ts.rf_codec_gain == 9) strcpy(options, " AUTO"); else // if anything other than "Auto" give a warning in RED { snprintf(options,32,"> %u <", ts.rf_codec_gain); clr = Red; } // break; } // case MENU_NOISE_BLANKER_SETTING: else if(select==MENU_NOISE_BLANKER_SETTING) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.dsp.nb_setting, 0, MAX_NB_SETTING, 10, 1 ); clr = UiDriver_GetNBColor(); snprintf(options,32," %u", ts.dsp.nb_setting); // break; } // case MENU_RX_FREQ_CONV: // Enable/Disable receive frequency conversion else if(select==MENU_RX_FREQ_CONV) { ; uchar firstmode = FREQ_IQ_CONV_MODE_OFF; if(ts.dmod_mode == DEMOD_AM || ts.dmod_mode == DEMOD_SAM || ts.dmod_mode == DEMOD_FM) { firstmode = FREQ_IQ_CONV_P6KHZ; } var_change = UiDriverMenuItemChangeInt32(var, mode, &ts.iq_freq_mode, firstmode, FREQ_IQ_CONV_MODE_MAX, FREQ_IQ_CONV_MODE_DEFAULT, 1 ); switch(ts.iq_freq_mode) { case FREQ_IQ_CONV_MODE_OFF: txt_ptr = ">> OFF! <<"; clr = Red3; break; case FREQ_IQ_CONV_P6KHZ: txt_ptr ="RX +6kHz"; break; case FREQ_IQ_CONV_M6KHZ: txt_ptr = "RX -6kHz"; break; case FREQ_IQ_CONV_P12KHZ: txt_ptr = "RX +12kHz"; break; case FREQ_IQ_CONV_M12KHZ: txt_ptr = "RX -12kHz"; break; case FREQ_IQ_CONV_SLIDE: txt_ptr = "RX Slide"; break; } if(var_change) // update parameters if changed { UiDriver_FrequencyUpdateLOandDisplay(true); // update frequency display without checking encoder, unconditionally updating synthesizer } // break; } // case MENU_MIC_LINE_MODE: // Mic/Line mode else if(select==MENU_MIC_LINE_MODE) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.tx_audio_source, 0, TX_AUDIO_MAX_ITEMS, TX_AUDIO_MIC, 1 ); switch(ts.tx_audio_source) { case TX_AUDIO_MIC: txt_ptr = " MIC"; break; case TX_AUDIO_LINEIN_L: txt_ptr = " LINE-L"; break; case TX_AUDIO_LINEIN_R: txt_ptr = " LINE-R"; break; case TX_AUDIO_DIG: txt_ptr = " DIGITAL"; break; case TX_AUDIO_DIGIQ: txt_ptr = " DIG I/Q"; break; } if(var_change) // if there was a change, do update of on-screen information { if(ts.dmod_mode != DEMOD_CW) { UiDriver_RefreshEncoderDisplay(); // maybe shown on encoder boxes } } // break; } // case MENU_MIC_TYPE: // selecting a mic type determines a mic boost level (for now, one of two boost gains) else if(select==MENU_MIC_TYPE) { UiDriverMenuItemChangeUInt8(var, mode, &ts.tx_mic_boost, 0, MIC_BOOST_DYNAMIC, // 14 dB (Dynamic) MIC_BOOST_DEFAULT, // 0 dB (Electret) 1 ); // if(ts.tx_mic_boost > 0) { txt_ptr = " Dynamic"; } else { txt_ptr = "Electret"; } #ifndef UI_BRD_MCHF // if(var_change) // { MIC_bias_set(); // } #endif // break; } // case MENU_MIC_GAIN: // Mic Gain setting else if(select==MENU_MIC_GAIN) { if(ts.tx_audio_source == TX_AUDIO_MIC) // Allow adjustment only if in MIC mode { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.tx_gain[TX_AUDIO_MIC], MIC_GAIN_MIN, MIC_GAIN_MAX, MIC_GAIN_DEFAULT, 1 ); } if(var_change) { Codec_SwitchMicTxRxMode(ts.txrx_mode); if(ts.dmod_mode != DEMOD_CW) { UiDriver_RefreshEncoderDisplay(); // maybe shown on encoder boxes } } if(ts.tx_audio_source != TX_AUDIO_MIC) // Orange if not in MIC-IN mode { clr = Orange; } snprintf(options,32, " %u", ts.tx_gain[TX_AUDIO_MIC]); // break; } // case MENU_LINE_GAIN: // Line Gain setting else if(select==MENU_LINE_GAIN) { // TODO: Revise, since it now changes the currently selected tx source setting if(ts.tx_audio_source != TX_AUDIO_MIC) // Allow adjustment only if in line-in mode { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.tx_gain[ts.tx_audio_source], LINE_GAIN_MIN, LINE_GAIN_MAX, LINE_GAIN_DEFAULT, 1 ); } if(var_change) // update on-screen info and codec if there was a change { if(ts.dmod_mode != DEMOD_CW) { UiDriver_RefreshEncoderDisplay(); // maybe shown on encoder boxes if(ts.txrx_mode == TRX_MODE_TX) // in transmit mode? { // TODO: Think about this, this is a hack Codec_LineInGainAdj(ts.tx_gain[TX_AUDIO_LINEIN_L]); // change codec gain } } } if(ts.tx_audio_source == TX_AUDIO_MIC) // Orange if in MIC mode { clr = Orange; snprintf(options,32, " %u", ts.tx_gain[TX_AUDIO_LINEIN_L]); } else { snprintf(options,32, " %u", ts.tx_gain[ts.tx_audio_source]); } // break; } // case MENU_ALC_RELEASE: // ALC Release adjust else if(select==MENU_ALC_RELEASE) { if(ts.tx_comp_level == TX_AUDIO_COMPRESSION_MAX) { var_change = UiDriverMenuItemChangeUInt32(var, mode, &ts.alc_decay_var, 0, ALC_DECAY_MAX, ALC_DECAY_DEFAULT, 1 ); if(var_change) // value changed? Recalculate { AudioManagement_CalcALCDecay(); } } else // indicate RED if "Compression Level" below was nonzero { clr = Red; ts.alc_decay_var = 10; } if(ts.tx_comp_level == TX_AUDIO_COMPRESSION_SV) // in "selectable value" mode? { ts.alc_decay = ts.alc_decay_var; // yes, save new value } snprintf(options,32, " %d", (int)ts.alc_decay_var); // break; } // case MENU_ALC_POSTFILT_GAIN: // ALC TX Post-filter gain (Compressor level) else if(select==MENU_ALC_POSTFILT_GAIN) { if(ts.tx_comp_level == TX_AUDIO_COMPRESSION_MAX) { var_change = UiDriverMenuItemChangeUInt32(var, mode, &ts.alc_tx_postfilt_gain_var, ALC_POSTFILT_GAIN_MIN, ALC_POSTFILT_GAIN_MAX, ALC_POSTFILT_GAIN_DEFAULT, 1 ); if(var_change) { if(ts.dmod_mode != DEMOD_CW) // In voice mode? { UiDriver_RefreshEncoderDisplay(); // maybe shown on encoder boxes } } } else // indicate RED if "Compression Level" below was nonzero { clr = Red; } if(ts.tx_comp_level == TX_AUDIO_COMPRESSION_SV) // in "selectable value" mode? { ts.alc_tx_postfilt_gain = ts.alc_tx_postfilt_gain_var; // yes, save new value } snprintf(options,32, " %d", (int)ts.alc_tx_postfilt_gain_var); // break; } // case MENU_TX_COMPRESSION_LEVEL: // ALC TX Post-filter gain (Compressor level) else if(select==MENU_TX_COMPRESSION_LEVEL) { var_change = UiDriverMenuItemChangeInt16(var, mode, &ts.tx_comp_level, -1, TX_AUDIO_COMPRESSION_MAX, TX_AUDIO_COMPRESSION_DEFAULT, 1 ); if(var_change) { AudioManagement_CalcTxCompLevel(); // calculate parameters for selected amount of compression if(ts.dmod_mode != DEMOD_CW) // In voice mode? { UiDriver_RefreshEncoderDisplay(); // maybe shown on encoder boxes } } if(ts.tx_comp_level < TX_AUDIO_COMPRESSION_SV && 0 <= ts.tx_comp_level) // display numbers for all but the highest value { snprintf(options,32," %d",ts.tx_comp_level); } else // show "CUSTOM" (Stored Value) for highest value { if (ts.tx_comp_level == TX_AUDIO_COMPRESSION_MIN) { txt_ptr = "OFF"; } else { txt_ptr = "CUS"; } } // break; } // case MENU_KEYER_MODE: // Keyer mode else if(select==MENU_KEYER_MODE) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.cw_keyer_mode, 0, CW_KEYER_MODE_ULTIMATE, CW_KEYER_MODE_IAM_B, 1 ); switch(ts.cw_keyer_mode) { case CW_KEYER_MODE_IAM_B: txt_ptr = "IAM_B"; break; case CW_KEYER_MODE_IAM_A: txt_ptr = "IAM_A"; break; case CW_KEYER_MODE_STRAIGHT: txt_ptr = "STR_K"; break; case CW_KEYER_MODE_ULTIMATE: txt_ptr = "ULTIM"; break; } // break; } // case MENU_KEYER_SPEED: // keyer speed else if(select==MENU_KEYER_SPEED) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.cw_keyer_speed, CW_KEYER_SPEED_MIN, CW_KEYER_SPEED_MAX, CW_KEYER_SPEED_DEFAULT, 1 ); if(var_change && ts.dmod_mode == DEMOD_CW) // did it change? { CwGen_SetSpeed(); // make sure keyerspeed is being used UiDriver_RefreshEncoderDisplay(); // maybe shown on encoder boxes ts.cw_keyer_speed_bak = ts.cw_keyer_speed; } snprintf(options,32, " %u", ts.cw_keyer_speed); // break; } // case MENU_KEYER_WEIGHT: // keyer weight else if(select==MENU_KEYER_WEIGHT) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.cw_keyer_weight, CW_KEYER_WEIGHT_MIN, CW_KEYER_WEIGHT_MAX, CW_KEYER_WEIGHT_DEFAULT, 1 ); if(var_change && ts.dmod_mode == DEMOD_CW) // did it change? { CwGen_SetSpeed(); // make sure keyerspeed is being used UiDriver_RefreshEncoderDisplay(); // maybe shown on encoder boxes } snprintf(options,32, " %u.%02u", ts.cw_keyer_weight/100,ts.cw_keyer_weight%100); // break; } // case MENU_SIDETONE_GAIN: // sidetone gain else if(select==MENU_SIDETONE_GAIN) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.cw_sidetone_gain, 0, SIDETONE_MAX_GAIN, DEFAULT_SIDETONE_GAIN, 1 ); if(var_change && ts.dmod_mode == DEMOD_CW) // did it change? { UiDriver_RefreshEncoderDisplay(); // maybe shown on encoder boxes } snprintf(options,32, " %u", ts.cw_sidetone_gain); // break; } // case MENU_SIDETONE_FREQUENCY: // sidetone frequency else if(select==MENU_SIDETONE_FREQUENCY) { var_change = UiDriverMenuItemChangeUInt32(var, mode, &ts.cw_sidetone_freq, CW_SIDETONE_FREQ_MIN, CW_SIDETONE_FREQ_MAX*10, CW_SIDETONE_FREQ_DEFAULT, 10 ); if(var_change && ts.dmod_mode == DEMOD_CW) // did it change? { float freq[2] = { ts.cw_sidetone_freq, 0.0 }; softdds_configRunIQ(freq,ts.samp_rate,0); UiDriver_FrequencyUpdateLOandDisplay(false); CwDecode_Filter_Set(); } snprintf(options,32, " %uHz", (uint)ts.cw_sidetone_freq); // break; } // case MENU_PADDLE_REVERSE: // CW Paddle reverse else if(select==MENU_PADDLE_REVERSE) { var_change = UiDriverMenuItemChangeEnableOnOff(var, mode, &ts.cw_paddle_reverse,0,options,&clr); // break; } // case MENU_CW_TX_RX_DELAY: // CW TX->RX delay else if(select==MENU_CW_TX_RX_DELAY) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.cw_rx_delay, 0, CW_RX_DELAY_MAX, CW_TX2RX_DELAY_DEFAULT, 1 ); snprintf(options,32, "%3ums", ts.cw_rx_delay*10); // break; } // case MENU_CW_AUTO_MODE_SELECT: // Enable/Disable auto LSB/USB select else if(select==MENU_CW_AUTO_MODE_SELECT) { const cw_mode_map_entry_t* curr_mode = RadioManagement_CWConfigValueToModeEntry(ts.cw_offset_mode); temp_var_u8 = curr_mode->sideband_mode; var_change = UiDriverMenuItemChangeUInt8(var, mode, &temp_var_u8, 0, 2, 2, 1 ); if(var_change) // update parameters if changed { cw_mode_map_entry_t new_mode; new_mode.dial_mode = curr_mode->dial_mode; new_mode.sideband_mode = temp_var_u8; ts.cw_offset_mode = RadioManagement_CWModeEntryToConfigValue(&new_mode); ts.cw_lsb = RadioManagement_CalculateCWSidebandMode(); UiDriver_DisplayDemodMode(); UiDriver_FrequencyUpdateLOandDisplay(true); // update frequency display and local oscillator } switch(temp_var_u8) { case CW_SB_LSB: txt_ptr = " LSB"; break; case CW_SB_USB: txt_ptr = " USB"; break; case CW_SB_AUTO: txt_ptr = "AUTO"; break; } // break; } // case MENU_CW_OFFSET_MODE: // CW offset mode (e.g. USB, LSB, etc.) else if(select==MENU_CW_OFFSET_MODE) { const cw_mode_map_entry_t* curr_mode = RadioManagement_CWConfigValueToModeEntry(ts.cw_offset_mode); temp_var_u8 = curr_mode->dial_mode; var_change = UiDriverMenuItemChangeUInt8(var, mode, &temp_var_u8, 0, 2, 2, 1 ); if(var_change) // update parameters if changed { cw_mode_map_entry_t new_mode; new_mode.sideband_mode = curr_mode->sideband_mode; new_mode.dial_mode = temp_var_u8; ts.cw_offset_mode = RadioManagement_CWModeEntryToConfigValue(&new_mode); ts.cw_lsb = RadioManagement_CalculateCWSidebandMode(); UiDriver_DisplayDemodMode(); UiDriver_FrequencyUpdateLOandDisplay(true); // update frequency display and local oscillator } switch(temp_var_u8) { case CW_OFFSET_RX: txt_ptr = " RX"; break; case CW_OFFSET_TX: txt_ptr = " TX"; break; case CW_OFFSET_SHIFT: txt_ptr = "SHIFT"; break; } // break; } // case MENU_CW_DECODER_THRESH: // else if(select==MENU_CW_DECODER_THRESH) { var_change = UiDriverMenuItemChangeUInt32(var, mode, &cw_decoder_config.thresh, CW_DECODER_THRESH_MIN, CW_DECODER_THRESH_MAX, CW_DECODER_THRESH_DEFAULT, 500 ); snprintf(options,32, " %u", (unsigned int)cw_decoder_config.thresh); // break; } //ts.cw_decode_average - wieviele Goertzel-Sch�tzwerte werden in einem //moving window zusammengefasst [uint8_t 1 - 20] #if 0 // case MENU_CW_DECODER_AVERAGE: // averager for CW decode [1 - 20] else if(select==MENU_CW_DECODER_AVERAGE) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &cw_decoder_config.average, 2, 20, 2, 1 ); if(cw_decoder_config.average !=1) { snprintf(options,32, " %u", cw_decoder_config.average); } else { txt_ptr = "OFF"; } // break; } #endif // case MENU_CW_DECODER_BLOCKSIZE: // processing block size for cw decoder else if(select==MENU_CW_DECODER_BLOCKSIZE) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &cw_decoder_config.blocksize, CW_DECODER_BLOCKSIZE_MIN, CW_DECODER_BLOCKSIZE_MAX, CW_DECODER_BLOCKSIZE_DEFAULT, 8 ); snprintf(options,32, " %u", cw_decoder_config.blocksize); CwDecode_Filter_Set(); // break; } #if 0 // case MENU_CW_DECODER_AGC: // On/Off else if(select==MENU_CW_DECODER_AGC) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &cw_decoder_config.AGC_enable, 0, 1, 0, 1 ); switch(cw_decoder_config.AGC_enable) { case 0: txt_ptr = " OFF"; break; case 1: txt_ptr = " ON"; break; } // break; } #endif // case MENU_CW_DECODER_NOISECANCEL: // On/Off else if(select==MENU_CW_DECODER_NOISECANCEL) { // var_change = UiDriverMenuItemChangeUInt8(var, mode, &cw_decoder_config.noisecancel_enable, // 0, // 1, // 1, // 1 // ); temp_var_bool = cw_decoder_config.noisecancel_enable; var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &temp_var_bool, 0, options, &clr); cw_decoder_config.noisecancel_enable = temp_var_bool; // switch(cw_decoder_config.noisecancel_enable) { // case 0: // txt_ptr = " OFF"; // break; // case 1: // txt_ptr = " ON"; // break; // } // break; } // case MENU_CW_DECODER_SPIKECANCEL: // On/Off else if(select==MENU_CW_DECODER_SPIKECANCEL) { // var_change = UiDriverMenuItemChangeUInt8(var, mode, &cw_decoder_config.spikecancel, temp_var_u8 = cw_decoder_config.spikecancel; var_change = UiDriverMenuItemChangeUInt8(var, mode, &temp_var_u8, 0, 2, 0, 1 ); cw_decoder_config.spikecancel = temp_var_u8; switch(cw_decoder_config.spikecancel) { case 0: txt_ptr = " OFF"; break; case 1: txt_ptr = "SPIKE"; break; case 2: txt_ptr = "SHORT"; break; } // break; } // case MENU_TCXO_MODE: // TCXO On/Off else if(select==MENU_TCXO_MODE) { temp_var_u8 = RadioManagement_TcxoGetMode(); // get current setting without upper nibble var_change = UiDriverMenuItemChangeUInt8(var, mode, &temp_var_u8, 0, TCXO_STATE_NUMBER-1, TCXO_ON, 1 ); if(lo.sensor_present == false) // no sensor present { temp_var_u8 = TCXO_OFF; // force TCXO disabled var_change = true; } RadioManagement_TcxoSetMode(temp_var_u8); // overlay new temperature setting with old status of upper nibble if(var_change) { UiDriver_CreateTemperatureDisplay(); } switch(temp_var_u8) { case TCXO_OFF: txt_ptr = " OFF"; break; case TCXO_ON: txt_ptr = " ON"; break; case TCXO_STOP: txt_ptr = "STOP"; break; } // break; } // case CONFIG_IQ_AUTO_CORRECTION: // On/Off else if(select==CONFIG_IQ_AUTO_CORRECTION) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.iq_auto_correction, 0, 1, 0, 1 ); switch(ts.iq_auto_correction) { case 0: txt_ptr = " OFF"; ts.display_rx_iq = true; break; case 1: txt_ptr = " ON"; ts.display_rx_iq = false; break; } // if(var_change) temporarily disabled because function does not provide dynamical hiding recently // { // UiMenu_RenderMenu(MENU_RENDER_ONLY); // } // break; } // case MENU_TCXO_C_F: // TCXO display C/F mode else if(select==MENU_TCXO_C_F) { temp_var_u8 = (RadioManagement_TcxoIsFahrenheit() == true) ? 1 : 0; // Yes - Is Fahrenheit mode enabled? if(RadioManagement_TcxoIsEnabled()) // is temperature display enabled at all? { var_change = UiDriverMenuItemChangeUInt8(var, mode, &temp_var_u8, 0, 1, 0, 1 ); RadioManagement_TcxoSetUnit(temp_var_u8 != 0? TCXO_UNIT_F: TCXO_UNIT_C); } else { clr = Orange; } if(var_change) // update screen if a change was made { UiDriver_CreateTemperatureDisplay(); } txt_ptr =temp_var_u8?"F":"C"; // break; } // case MENU_SCOPE_SPEED: // spectrum scope speed else if(select==MENU_SCOPE_SPEED) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.scope_speed, SPECTRUM_SCOPE_SPEED_MIN, SPECTRUM_SCOPE_SPEED_MAX, SPECTRUM_SCOPE_SPEED_DEFAULT, 1 ); if(ts.scope_speed) { snprintf(options,32, " %u", ts.scope_speed); } else { txt_ptr = "OFF"; } // break; } // case MENU_SPECTRUM_FILTER_STRENGTH: // spectrum filter strength else if(select==MENU_SPECTRUM_FILTER_STRENGTH) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.spectrum_filter, SPECTRUM_FILTER_MIN, SPECTRUM_FILTER_MAX, SPECTRUM_FILTER_DEFAULT, 1 ); snprintf(options,32, " %u", ts.spectrum_filter); // break; } // case MENU_SCOPE_TRACE_COLOUR: // spectrum scope trace colour else if(select==MENU_SCOPE_TRACE_COLOUR) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.scope_trace_colour, 0, SPEC_MAX_COLOUR, SPEC_COLOUR_TRACE_DEFAULT, 1 ); UiMenu_MapColors(ts.scope_trace_colour,options,&clr); // break; } // case MENU_SCOPE_TRACE_HL_COLOUR: //spectrum highlighted bandwidth colour else if(select==MENU_SCOPE_TRACE_HL_COLOUR) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.scope_trace_BW_colour, 0, SPEC_MAX_COLOUR, SPEC_COLOUR_TRACEBW_DEFAULT, 1 ); UiMenu_MapColors(ts.scope_trace_BW_colour,options,&clr); // break; } // case MENU_SCOPE_BACKGROUND_HL_COLOUR: // set step size of of waterfall display? else if(select==MENU_SCOPE_BACKGROUND_HL_COLOUR) { UiDriverMenuItemChangeUInt8(var, mode, &ts.scope_backgr_BW_colour, 0, 100, SPEC_COLOUR_BACKGRBW_DEFAULT, 10 ); snprintf(options,32, " %u%%", ts.scope_backgr_BW_colour); // break; } // case MENU_SCOPE_GRID_COLOUR: // spectrum scope grid colour else if(select==MENU_SCOPE_GRID_COLOUR) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.scope_grid_colour, 0, SPEC_MAX_COLOUR, SPEC_COLOUR_GRID_DEFAULT, 1 ); UiMenu_MapColors(ts.scope_grid_colour,options,&clr); // break; } // case MENU_SPECTRUM_FREQSCALE_COLOUR: // spectrum scope/waterfall scale colour else if(select==MENU_SPECTRUM_FREQSCALE_COLOUR) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.spectrum_freqscale_colour, 0, SPEC_MAX_COLOUR, SPEC_COLOUR_SCALE_DEFAULT, 1 ); UiMenu_MapColors(ts.spectrum_freqscale_colour,options,&clr); // break; } // case MENU_SPECTRUM_MAGNIFY: // WF/Spectrum magnifying else if(select==MENU_SPECTRUM_MAGNIFY) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &sd.magnify, MAGNIFY_MIN, MAGNIFY_MAX, MAGNIFY_DEFAULT, 1 ); switch(sd.magnify) { case 1: txt_ptr = " x2"; break; case 2: txt_ptr = " x4"; break; case 3: txt_ptr = " x8"; break; case 4: txt_ptr = "x16"; break; case 5: txt_ptr = "x32"; break; case 0: default: txt_ptr = " x1"; break; } UiDriver_SpectrumChangeLayoutParameters(); // break; } // case MENU_SCOPE_AGC_ADJUST: // Spectrum scope AGC adjust else if(select==MENU_SCOPE_AGC_ADJUST) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.spectrum_agc_rate, SPECTRUM_SCOPE_AGC_MIN, SPECTRUM_SCOPE_AGC_MAX, SPECTRUM_SCOPE_AGC_DEFAULT, 1 ); if(var_change) // update system variable if rate changed { sd.agc_rate = (float)ts.spectrum_agc_rate; // calculate agc rate sd.agc_rate = sd.agc_rate/SPECTRUM_AGC_SCALING; } snprintf(options,32, " %u", ts.spectrum_agc_rate); // break; } // case MENU_SCOPE_DB_DIVISION: // Adjustment of dB/division of spectrum scope else if(select==MENU_SCOPE_DB_DIVISION) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.spectrum_db_scale, DB_DIV_ADJUST_MIN, DB_DIV_ADJUST_MAX, DB_DIV_ADJUST_DEFAULT, 1 ); switch(ts.spectrum_db_scale) // convert variable to setting { case DB_DIV_5: txt_ptr = " 5dB"; break; case DB_DIV_7: txt_ptr = " 7.5dB"; break; case DB_DIV_15: txt_ptr = " 15dB"; break; case DB_DIV_20: txt_ptr = " 20dB"; break; case S_1_DIV: txt_ptr = "1S-Unit"; break; case S_2_DIV: txt_ptr = "2S-Unit"; break; case S_3_DIV: txt_ptr = "3S-Unit"; break; case DB_DIV_10: default: txt_ptr = " 10dB"; break; } // break; } // case MENU_SPECTRUM_CENTER_LINE_COLOUR: // spectrum scope grid center line colour else if(select==MENU_SPECTRUM_CENTER_LINE_COLOUR) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.spectrum_centre_line_colour, 0, SPEC_GREY2, SPEC_COLOUR_GRID_DEFAULT, 1 ); UiMenu_MapColors(ts.spectrum_centre_line_colour,options,&clr); // break; } // case MENU_SCOPE_LIGHT_ENABLE: // Spectrum light: no grid, larger, only points, no bars else if(select==MENU_SCOPE_LIGHT_ENABLE) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.flags1,0,options,&clr,FLAGS1_SCOPE_LIGHT_ENABLE); // break; } // case MENU_SPECTRUM_MODE: else if(select==MENU_SPECTRUM_MODE) { temp_var_u8 = UiDriver_GetSpectrumMode(); var_change = UiDriverMenuItemChangeUInt8(var, mode, &temp_var_u8, SPECTRUM_WATERFALL, SPECTRUM_DUAL, SPECTRUM_DUAL, 1 ); switch(temp_var_u8) { case SPECTRUM_DUAL: txt_ptr = " DUAL"; break; case SPECTRUM_SCOPE: txt_ptr = "SCOPE"; break; case SPECTRUM_WATERFALL: txt_ptr = "WFALL"; break; case SPECTRUM_BLANK: txt_ptr = " OFF"; break; } UiDriver_SetSpectrumMode(temp_var_u8); UiSpectrum_ResetSpectrum(); // break; } // case MENU_WFALL_COLOR_SCHEME: // Adjustment of dB/division of spectrum scope else if(select==MENU_WFALL_COLOR_SCHEME) { UiDriverMenuItemChangeUInt8(var, mode, &ts.waterfall.color_scheme, WATERFALL_COLOR_MIN, WATERFALL_COLOR_MAX , WATERFALL_COLOR_DEFAULT, 1 ); switch(ts.waterfall.color_scheme) // convert variable to setting { case WFALL_HOT_COLD: txt_ptr = "HotCold"; break; case WFALL_FLAME: txt_ptr = " Flame"; break; case WFALL_SUNSET: txt_ptr = " Sunset"; break; case WFALL_RAINBOW: txt_ptr = "Rainbow"; break; case WFALL_BLUE: txt_ptr = " Blue"; break; case WFALL_GRAY_INVERSE: txt_ptr = "INVGrey"; break; case WFALL_GRAY: default: txt_ptr = " Grey" ; break; } // break; } // case MENU_DBM_DISPLAY: else if(select==MENU_DBM_DISPLAY) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.display_dbm, 0, 2, 0, 1 ); switch(ts.display_dbm) { case 1: // txt_ptr = " dBm"; // dbm display break; case 2: // txt_ptr = " dBm/Hz"; // dbm/Hz display break; default: txt_ptr = " OFF"; // dbm display off break; } // break; } #ifdef USE_8bit_FONT // case MENU_FREQ_FONT: else if(select==MENU_FREQ_FONT) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.FreqDisplayFont, 0, 1, 0, 1 ); switch(ts.FreqDisplayFont) { case 0: txt_ptr = " old"; //old font break; case 1: txt_ptr = " modern"; //old font break; } UiDriver_FrequencyUpdateLOandDisplay(true); // break; } #endif // case MENU_METER_COLOUR_UP: // upper meter colour else if(select==MENU_METER_COLOUR_UP) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.meter_colour_up, 0, SPEC_MAX_COLOUR, SPEC_BLUE, 1 ); UiMenu_MapColors(ts.meter_colour_up,options,&clr); // break; } // case MENU_METER_COLOUR_DOWN: // lower meter colour else if(select==MENU_METER_COLOUR_DOWN) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.meter_colour_down, 0, SPEC_MAX_COLOUR, SPEC_CYAN, 1 ); UiMenu_MapColors(ts.meter_colour_down,options,&clr); // break; } // case MENU_WFALL_STEP_SIZE: // set step size of of waterfall display? else if(select==MENU_WFALL_STEP_SIZE) { UiDriverMenuItemChangeUInt8(var, mode, &ts.waterfall.vert_step_size, WATERFALL_STEP_SIZE_MIN, WATERFALL_STEP_SIZE_MAX, WATERFALL_STEP_SIZE_DEFAULT, 1 ); snprintf(options,32, " %u", ts.waterfall.vert_step_size); // break; } #if 0 // case MENU_WFALL_OFFSET: // set step size of of waterfall display? else if(select==MENU_WFALL_OFFSET) { UiDriverMenuItemChangeInt32(var, mode, &ts.waterfall.offset, WATERFALL_OFFSET_MIN, WATERFALL_OFFSET_MAX, WATERFALL_OFFSET_DEFAULT, 1 ); snprintf(options,32, " %u", (unsigned int)ts.waterfall.offset); // break; } #endif // case MENU_WFALL_CONTRAST: // set step size of of waterfall display? else if(select==MENU_WFALL_CONTRAST) { UiDriverMenuItemChangeUInt32(var, mode, &ts.waterfall.contrast, WATERFALL_CONTRAST_MIN, WATERFALL_CONTRAST_MAX, WATERFALL_CONTRAST_DEFAULT, 2 ); snprintf(options,32, " %u", (unsigned int)ts.waterfall.contrast); // break; } // case MENU_WFALL_SPEED: // set step size of of waterfall display? else if(select==MENU_WFALL_SPEED) { UiDriverMenuItemChangeUInt8(var, mode, &ts.waterfall.speed, WATERFALL_SPEED_MIN, WATERFALL_SPEED_MAX, WATERFALL_SPEED_DEFAULT, 1 ); if(ts.waterfall.speed <= WATERFALL_SPEED_WARN) { clr = Red; } else if(ts.waterfall.speed <= WATERFALL_SPEED_WARN1) { clr = Yellow; } if (ts.waterfall.speed > 0) { snprintf(options,32, " %u", ts.waterfall.speed); } else { txt_ptr = "OFF"; } // break; } #if 0 // case MENU_SCOPE_NOSIG_ADJUST: // set step size of of waterfall display? else if(select==MENU_SCOPE_NOSIG_ADJUST) { UiDriverMenuItemChangeUInt8(var, mode, &ts.spectrum_scope_nosig_adjust, SPECTRUM_SCOPE_NOSIG_ADJUST_MIN, SPECTRUM_SCOPE_NOSIG_ADJUST_MAX, SPECTRUM_SCOPE_NOSIG_ADJUST_DEFAULT, 1 ); snprintf(options,32, " %u", ts.spectrum_scope_nosig_adjust); // break; } // case MENU_WFALL_NOSIG_ADJUST: // set step size of of waterfall display? else if(select==MENU_WFALL_NOSIG_ADJUST) { UiDriverMenuItemChangeUInt8(var, mode, &ts.waterfall.nosig_adjust, WATERFALL_NOSIG_ADJUST_MIN, WATERFALL_NOSIG_ADJUST_MAX, WATERFALL_NOSIG_ADJUST_DEFAULT, 1 ); snprintf(options,32, " %u", ts.waterfall.nosig_adjust); // break; } #endif // case MENU_SPECTRUM_SIZE: // set view size of of spectrum display (big disables title bar)? else if(select==MENU_SPECTRUM_SIZE) { UiDriverMenuItemChangeUInt8(var, mode, &ts.spectrum_size, 0, SPECTRUM_BIG, SPECTRUM_SIZE_DEFAULT, 1 ); // switch(ts.spectrum_size) { case SPECTRUM_BIG: txt_ptr = " Big"; break; case SPECTRUM_NORMAL: default: txt_ptr = "Normal"; break; } // break; } #ifdef USE_CONFIGSTORAGE_FLASH // case MENU_BACKUP_CONFIG: else if(select==MENU_BACKUP_CONFIG) { txt_ptr = "n/a"; if(ts.configstore_in_use == CONFIGSTORE_IN_USE_I2C) { uint8_t test = 0; clr = White; UiDriverMenuItemChangeUInt8(var, mode, &test, 0, 0, 10, 1 ); switch(test) { case 0: txt_ptr = "press DEFLT"; break; case 10: UiMenu_DisplayValue(" Working",Red,pos); ConfigStorage_CopySerial2Flash(); clr = Green; txt_ptr = " Done..."; break; } } // break; } // case MENU_RESTORE_CONFIG: else if(select==MENU_RESTORE_CONFIG) { txt_ptr = "n/a"; if(ts.configstore_in_use == CONFIGSTORE_IN_USE_I2C) { uint8_t test = 0; clr = White; UiDriverMenuItemChangeUInt8(var, mode, &test, 0, 0, 10, 1 ); switch(test) { case 0: txt_ptr = "press DEFLT"; break; case 10: UiMenu_DisplayValue(" Working",Red,pos); ConfigStorage_CopyFlash2Serial(); Board_Reboot(); break; } } // break; } #endif // case MENU_RESTART_CODEC: else if(select==MENU_RESTART_CODEC) { txt_ptr = " Do it!"; clr = White; if(var>=1) { UiMenu_DisplayValue("Restart",Red,pos); Codec_RestartI2S(); var = 0; } // break; } // case MENU_DEBUG_TWINPEAKS_CORR_RUN: else if(select==MENU_DEBUG_TWINPEAKS_CORR_RUN) { if (ts.iq_auto_correction == 0) { txt_ptr = "Not possible"; clr = Red; } else { txt_ptr = " Do it!"; clr = White; } if(var>=1) { UiMenu_DisplayValue(" Started",Green, pos); ts.twinpeaks_tested = TWINPEAKS_WAIT; while(ts.twinpeaks_tested != TWINPEAKS_DONE && ts.twinpeaks_tested != TWINPEAKS_UNCORRECTABLE ) { asm("nop");} UiMenu_DisplayValue("Finished",Green, pos); var = 0; } // break; } // case CONFIG_FREQ_STEP_MARKER_LINE: // Frequency step marker line on/off else if(select==CONFIG_FREQ_STEP_MARKER_LINE) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.freq_step_config,0,options,&clr, FREQ_STEP_SHOW_MARKER); if(var_change) // something changed? { UiDriver_DisplayFreqStepSize(); // update screen } // break; } // case CONFIG_STEP_SIZE_BUTTON_SWAP: // Step size button swap on/off else if(select==CONFIG_STEP_SIZE_BUTTON_SWAP) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.freq_step_config,0,options,&clr, FREQ_STEP_SWAP_BTN); // break; } // case MENU_DYNAMICTUNE: // Dynamic Tune on/off else if(select==MENU_DYNAMICTUNE) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.flags1,0,options,&clr, FLAGS1_DYN_TUNE_ENABLE); if(var_change) { UiDriver_DisplayFreqStepSize(); } // break; } // case CONFIG_BAND_BUTTON_SWAP: // Swap position of Band+ and Band- buttons else if(select==CONFIG_BAND_BUTTON_SWAP) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.flags1,0,options,&clr, FLAGS1_SWAP_BAND_BTN); // break; } // case CONFIG_TX_DISABLE: // Step size button swap on/off else if(select==CONFIG_TX_DISABLE) { uint16_t flag = ts.tx_disable; var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &flag,0,options,&clr, TX_DISABLE_ALWAYS); ts.tx_disable = flag; if(var_change) { // FIXME: Call "abstract" function to update status of tune, // do not redraw menu button here directly UiDriver_DrawFButtonLabel(5,"TUNE",ts.tx_disable?Grey1:White); } } // break; // case CONFIG_TX_OUT_ENABLE: // Enable transmitting outside HAM bands else if(select==CONFIG_TX_OUT_ENABLE) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.flags1,0,options,&clr, FLAGS1_TX_OUTSIDE_BANDS); // break; } // case CONFIG_AUDIO_MAIN_SCREEN_MENU_SWITCH: // AFG/(STG/CMP) and RIT/(WPM/MIC/LIN) are to change automatically with TX/RX else if(select==CONFIG_AUDIO_MAIN_SCREEN_MENU_SWITCH) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.flags1,0,options,&clr, FLAGS1_TX_AUTOSWITCH_UI_DISABLE); // break; } // case CONFIG_MUTE_LINE_OUT_TX: // Enable/disable MUTE of TX audio on LINE OUT else if(select==CONFIG_MUTE_LINE_OUT_TX) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.flags1,0,options,&clr, FLAGS1_MUTE_LINEOUT_TX); if(ts.iq_freq_mode) // Mark RED if translate mode is active { clr = Red; } // break; } // case CONFIG_TXRX_SWITCH_AUDIO_MUTE: // maximum RX gain setting else if(select==CONFIG_TXRX_SWITCH_AUDIO_MUTE) { UiDriverMenuItemChangeUInt8(var, mode, &ts.txrx_switch_audio_muting_timing, 0, TXRX_SWITCH_AUDIO_MUTE_DELAY_MAX, 0, 1 ); snprintf(options,32, "%3ums", ts.txrx_switch_audio_muting_timing*10); // break; } // case CONFIG_LCD_AUTO_OFF_MODE: // LCD auto-off mode control else if(select==CONFIG_LCD_AUTO_OFF_MODE) { temp_var_u8 = ts.lcd_backlight_blanking; // get control variable temp_var_u8 &= LCD_BLANKING_TIMEMASK; // mask off upper nybble var_change = UiDriverMenuItemChangeUInt8(var, mode, &temp_var_u8, 0, LCD_BLANKING_TIMEMASK, BACKLIGHT_BLANK_TIMING_DEFAULT, 1 ); if(var_change) // timing has been changed manually { if(temp_var_u8) // is the time non-zero? { ts.lcd_backlight_blanking = temp_var_u8; // yes, copy current value into variable ts.lcd_backlight_blanking |= LCD_BLANKING_ENABLE; // set MSB to enable auto-blanking } else { ts.lcd_backlight_blanking = 0; // zero out variable } UiDriver_LcdBlankingStartTimer(); // update the LCD timing parameters } // if(ts.lcd_backlight_blanking & LCD_BLANKING_ENABLE) // timed auto-blanking enabled? snprintf(options,32,"%02d sec",ts.lcd_backlight_blanking & LCD_BLANKING_TIMEMASK); // yes - Update screen indicator with number of seconds else snprintf(options,32," OFF"); // Or if turned off // break; } // case CONFIG_VOLTMETER_CALIBRATION: // Voltmeter calibration else if(select==CONFIG_VOLTMETER_CALIBRATION) { var_change = UiDriverMenuItemChangeUInt32(var, mode, &ts.voltmeter_calibrate, POWER_VOLTMETER_CALIBRATE_MIN, POWER_VOLTMETER_CALIBRATE_MAX, POWER_VOLTMETER_CALIBRATE_DEFAULT, 1 ); snprintf(options,32, " %u", (unsigned int)ts.voltmeter_calibrate); // break; } // case MENU_LOW_POWER_SHUTDOWN: // Auto shutdown when below low voltage threshold else if(select==MENU_LOW_POWER_SHUTDOWN) { temp_var_u8 = (ts.low_power_config & LOW_POWER_ENABLE_MASK) == LOW_POWER_ENABLE? 1 : 0 ; // get control variable var_change = UiDriverMenuItemChangeEnableOnOff(var, mode, &temp_var_u8, 0,options,&clr); if (var_change) { CLR_OR_SET_BITMASK(temp_var_u8, ts.low_power_config, LOW_POWER_ENABLE); } // break; } // case CONFIG_LOW_POWER_THRESHOLD: // Configure low voltage threshold else if(select==CONFIG_LOW_POWER_THRESHOLD) { temp_var_u8 = ts.low_power_config & LOW_POWER_THRESHOLD_MASK; // get control variable var_change = UiDriverMenuItemChangeUInt8(var, mode, &temp_var_u8, LOW_POWER_THRESHOLD_MIN, LOW_POWER_THRESHOLD_MAX, LOW_POWER_THRESHOLD_DEFAULT, 1 ); if(var_change) { ts.low_power_config = (ts.low_power_config & ~LOW_POWER_THRESHOLD_MASK) | (temp_var_u8 & LOW_POWER_THRESHOLD_MASK); } snprintf(options,32,"%2d.%dV",(temp_var_u8 + LOW_POWER_THRESHOLD_OFFSET) / 10, (temp_var_u8 + LOW_POWER_THRESHOLD_OFFSET) % 10); // break; } // case CONFIG_DISP_FILTER_BANDWIDTH: // Display filter bandwidth else if(select==CONFIG_DISP_FILTER_BANDWIDTH) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.filter_disp_colour, 0, SPEC_BLACK, SPEC_COLOUR_GRID_DEFAULT, 1 ); UiMenu_MapColors(ts.filter_disp_colour,options,&clr); // break; } // case CONFIG_MAX_VOLUME: // maximum audio volume else if(select==CONFIG_MAX_VOLUME) { UiDriverMenuItemChangeUInt8(var, mode, &ts.rx_gain[RX_AUDIO_SPKR].max, MAX_VOLUME_MIN, MAX_VOLUME_MAX, MAX_VOLUME_DEFAULT, 1 ); if(ts.rx_gain[RX_AUDIO_SPKR].value > ts.rx_gain[RX_AUDIO_SPKR].max) // is the volume currently higher than the new setting? { ts.rx_gain[RX_AUDIO_SPKR].value = ts.rx_gain[RX_AUDIO_SPKR].max; // yes - force the volume to the new value UiDriver_RefreshEncoderDisplay(); // maybe shown on encoder boxes } snprintf(options,32, " %u", ts.rx_gain[RX_AUDIO_SPKR].max); // if(ts.rx_gain[RX_AUDIO_SPKR].max <= MAX_VOLUME_RED_THRESH) // Indicate that gain has been reduced by changing color clr = Red; else if(ts.rx_gain[RX_AUDIO_SPKR].max <= MAX_VOLUME_YELLOW_THRESH) clr = Orange; // break; } #if 0 // case CONFIG_MAX_RX_GAIN: // maximum RX gain setting else if(select==CONFIG_MAX_RX_GAIN) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.max_rf_gain, 0, MAX_RF_GAIN_MAX, MAX_RF_GAIN_DEFAULT, 1 ); if(var_change) { AudioManagement_CalcAGCVals(); // calculate new internal AGC values from user settings } snprintf(options,32, " %u", ts.max_rf_gain); // break; } #endif // case CONFIG_LINEOUT_GAIN: else if(select==CONFIG_LINEOUT_GAIN) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.lineout_gain, LINEOUT_GAIN_MIN, LINEOUT_GAIN_MAX, LINEOUT_GAIN_DEFAULT, 1 ); if(var_change) { Codec_VolumeLineOut(ts.txrx_mode); } snprintf(options,32, "%3u", ts.lineout_gain); // break; } // case CONFIG_BEEP_FREQ: // Beep frequency else if(select==CONFIG_BEEP_FREQ) { if(ts.flags2 & FLAGS2_KEY_BEEP_ENABLE) // is beep enabled? { var_change = UiDriverMenuItemChangeUInt32(var, mode, &ts.beep_frequency, MIN_BEEP_FREQUENCY, MAX_BEEP_FREQUENCY, DEFAULT_BEEP_FREQUENCY, 25); if(var_change) { AudioManagement_KeyBeepPrepare(); AudioManagement_KeyBeep(); // make beep to demonstrate frequency } } else // beep not enabled - display frequency in red clr = Orange; snprintf(options,32, " %uHz", (uint)ts.beep_frequency); // casted to int because display errors if uint32_t // break; } // case CONFIG_BEEP_VOLUME: // beep loudness else if(select==CONFIG_BEEP_VOLUME) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.beep_loudness, 0, MAX_BEEP_LOUDNESS, DEFAULT_BEEP_LOUDNESS, 1); if(var_change) { if(ts.beep_loudness) { ts.flags2 |= FLAGS2_KEY_BEEP_ENABLE; AudioManagement_KeyBeepPrepare(); AudioManagement_KeyBeep(); // make beep to demonstrate loudness } else { ts.flags2 &= ~FLAGS2_KEY_BEEP_ENABLE; } } if(ts.beep_loudness) { snprintf(options,32, " %u", ts.beep_loudness); } else { snprintf(options,32, "%s", "OFF"); } // break; } // case CONFIG_FREQUENCY_CALIBRATE: // Frequency Calibration else if(select==CONFIG_FREQUENCY_CALIBRATE) { if(var >= 1) // setting increase? { ts.menu_var_changed = 1; // indicate that a change has occurred ts.freq_cal += 1; // df.tuning_step; var_change = 1; } else if(var <= -1) // setting decrease? { ts.menu_var_changed = 1; // indicate that a change has occurred ts.freq_cal -= 1 ; // df.tuning_step; var_change = 1; } if(ts.freq_cal < MIN_FREQ_CAL) { ts.freq_cal = MIN_FREQ_CAL; } else if(ts.freq_cal > MAX_FREQ_CAL) { ts.freq_cal = MAX_FREQ_CAL; } // if(mode == MENU_PROCESS_VALUE_SETDEFAULT) { ts.menu_var_changed = 1; // indicate that a change has occurred ts.freq_cal = 0; var_change = 1; } if(var_change) { osc->setPPM(((float32_t)ts.freq_cal)/10.0); // Update LO PPM (will automatically adjust frequency) // this is a little trick // FIXME: Use a better approach to trigger retuning df.temp_factor_changed = true; } { char numstr[16]; float2fixedstr(numstr, 16, ((float32_t)ts.freq_cal)/10.0, 4, 1); snprintf(options,32, "%sppm", numstr ); } // break; } // case CONFIG_FREQ_LIMIT_RELAX: // Enable/disable Frequency tuning limits else if(select==CONFIG_FREQ_LIMIT_RELAX) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.flags1,0,options,&clr, FLAGS1_FREQ_LIMIT_RELAX); if(ts.flags1 & FLAGS1_FREQ_LIMIT_RELAX) // tuning limit is disabled { clr = Orange; // warn user! } // break; } // case CONFIG_FREQ_MEM_LIMIT_RELAX: // Enable/disable Frequency memory limits else if(select==CONFIG_FREQ_MEM_LIMIT_RELAX) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.flags2,0,options,&clr, FLAGS2_FREQ_MEM_LIMIT_RELAX); if(ts.flags2 & FLAGS2_FREQ_MEM_LIMIT_RELAX) // frequency/memory limit is disabled { clr = Orange; // warn user! } // break; } /* #define UI_MENU_CONFIG_IQ_RX_ADJ(bandName) \ case CONFIG_##bandName##_RX_IQ_GAIN_BAL: \ UiMenu_HandleIQAdjustGain(var, mode, options, &clr, &iq_adjust[IQ_##bandName].adj.rx.gain, TRX_MODE_RX, IQ_TRANS_ON); \ break; \ case CONFIG_##bandName##_RX_IQ_PHASE_BAL: \ UiMenu_HandleIQAdjustPhase(var, mode, options, &clr, &iq_adjust[IQ_##bandName].adj.rx.phase, TRX_MODE_RX, IQ_TRANS_ON); \ break; */ #define UI_MENU_CONFIG_IQ_RX_ADJ(bandName) \ else if(select==CONFIG_##bandName##_RX_IQ_GAIN_BAL) \ {UiMenu_HandleIQAdjustGain(var, mode, options, &clr, &iq_adjust[IQ_##bandName].adj.rx.gain, TRX_MODE_RX, IQ_TRANS_ON);} \ else if(select==CONFIG_##bandName##_RX_IQ_PHASE_BAL) \ {UiMenu_HandleIQAdjustPhase(var, mode, options, &clr, &iq_adjust[IQ_##bandName].adj.rx.phase, TRX_MODE_RX, IQ_TRANS_ON);} UI_MENU_CONFIG_IQ_RX_ADJ(80M) UI_MENU_CONFIG_IQ_RX_ADJ(10M) /* #define UI_MENU_CONFIG_IQ_TX_ADJ(bandName) \ case CONFIG_##bandName##_TX_IQ_GAIN_BAL: \ UiMenu_HandleIQAdjustGain(var, mode, options, &clr, &iq_adjust[IQ_##bandName].adj.tx[IQ_TRANS_ON].gain, TRX_MODE_TX, IQ_TRANS_ON); \ break; \ case CONFIG_##bandName##_TX_IQ_PHASE_BAL: \ UiMenu_HandleIQAdjustPhase(var, mode, options, &clr, &iq_adjust[IQ_##bandName].adj.tx[IQ_TRANS_ON].phase, TRX_MODE_TX, IQ_TRANS_ON); \ break; \ case CONFIG_##bandName##_TX_IQ_GAIN_BAL_TRANS_OFF: \ UiMenu_HandleIQAdjustGain(var, mode, options, &clr, &iq_adjust[IQ_##bandName].adj.tx[IQ_TRANS_OFF].gain, TRX_MODE_TX, IQ_TRANS_OFF); \ break; \ case CONFIG_##bandName##_TX_IQ_PHASE_BAL_TRANS_OFF: \ UiMenu_HandleIQAdjustPhase(var, mode, options, &clr, &iq_adjust[IQ_##bandName].adj.tx[IQ_TRANS_OFF].phase, TRX_MODE_TX, IQ_TRANS_OFF); \ break; */ #define UI_MENU_CONFIG_IQ_TX_ADJ(bandName) \ else if(select==CONFIG_##bandName##_TX_IQ_GAIN_BAL) \ {UiMenu_HandleIQAdjustGain(var, mode, options, &clr, &iq_adjust[IQ_##bandName].adj.tx[IQ_TRANS_ON].gain, TRX_MODE_TX, IQ_TRANS_ON);} \ else if(select==CONFIG_##bandName##_TX_IQ_PHASE_BAL) \ {UiMenu_HandleIQAdjustPhase(var, mode, options, &clr, &iq_adjust[IQ_##bandName].adj.tx[IQ_TRANS_ON].phase, TRX_MODE_TX, IQ_TRANS_ON);} \ else if(select==CONFIG_##bandName##_TX_IQ_GAIN_BAL_TRANS_OFF) \ {UiMenu_HandleIQAdjustGain(var, mode, options, &clr, &iq_adjust[IQ_##bandName].adj.tx[IQ_TRANS_OFF].gain, TRX_MODE_TX, IQ_TRANS_OFF);} \ else if(select==CONFIG_##bandName##_TX_IQ_PHASE_BAL_TRANS_OFF) \ {UiMenu_HandleIQAdjustPhase(var, mode, options, &clr, &iq_adjust[IQ_##bandName].adj.tx[IQ_TRANS_OFF].phase, TRX_MODE_TX, IQ_TRANS_OFF);} UI_MENU_CONFIG_IQ_TX_ADJ(160M) UI_MENU_CONFIG_IQ_TX_ADJ(80M) UI_MENU_CONFIG_IQ_TX_ADJ(40M) UI_MENU_CONFIG_IQ_TX_ADJ(30M) UI_MENU_CONFIG_IQ_TX_ADJ(20M) UI_MENU_CONFIG_IQ_TX_ADJ(17M) UI_MENU_CONFIG_IQ_TX_ADJ(15M) UI_MENU_CONFIG_IQ_TX_ADJ(12M) UI_MENU_CONFIG_IQ_TX_ADJ(10M) UI_MENU_CONFIG_IQ_TX_ADJ(10M_UP) UI_MENU_CONFIG_IQ_TX_ADJ(6M) // case CONFIG_CW_PA_BIAS: // CW PA Bias adjust else if(select==CONFIG_CW_PA_BIAS) { if((ts.tune) || (ts.txrx_mode == TRX_MODE_TX)) // enable only in TUNE mode { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.pa_cw_bias, 0, PA_BIAS_MAX, 0, 1); if(var_change) { RadioManagement_SetPaBias(); } if(ts.pa_cw_bias < PA_BIAS_LOW_LIMIT) { clr = Yellow; } } else // Orange if not in TUNE or TX mode { clr = Orange; } snprintf(options,32, " %u", ts.pa_cw_bias); // break; } // case CONFIG_PA_BIAS: // PA Bias adjust (Including CW if CW bias == 0) else if(select==CONFIG_PA_BIAS) { if((ts.tune) || (ts.txrx_mode == TRX_MODE_TX)) // enable only in TUNE mode { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.pa_bias, 0, PA_BIAS_MAX, 0, 1); if(var_change) { RadioManagement_SetPaBias(); } if(ts.pa_bias < PA_BIAS_LOW_LIMIT) { clr = Yellow; } } else // Orange if not in TUNE or TX mode { clr = Orange; } snprintf(options,32, " %u", ts.pa_bias); // break; } // case CONFIG_FWD_REV_PWR_DISP: // Enable/disable display of FWD/REV A/D inputs on power sensor else if(select==CONFIG_FWD_REV_PWR_DISP) { var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &swrm.pwr_meter_disp,0,options,&clr); // break; } // case CONFIG_RF_FWD_PWR_NULL: // RF power FWD power meter calibrate else if(select==CONFIG_RF_FWD_PWR_NULL) { if(swrm.pwr_meter_disp) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &swrm.sensor_null, SWR_CAL_MIN, SWR_CAL_MAX, SWR_CAL_DEFAULT, 1); if(ts.txrx_mode != TRX_MODE_TX) // Orange if not in TX mode { clr = Orange; } } else // numerical display NOT active { clr = Orange; // make it red to indicate that adjustment is NOT available } snprintf(options,32, " %u", swrm.sensor_null); // break; } // case CONFIG_FWD_REV_COUPLING_2200M_ADJ: // RF power sensor coupling adjust (2200m) else if(select==CONFIG_FWD_REV_COUPLING_2200M_ADJ) { UiDriverMenuBandRevCouplingAdjust(var, mode, COUPLING_2200M, options, &clr); // break; } // case CONFIG_FWD_REV_COUPLING_630M_ADJ: // RF power sensor coupling adjust (630m) else if(select==CONFIG_FWD_REV_COUPLING_630M_ADJ) { UiDriverMenuBandRevCouplingAdjust(var, mode, COUPLING_630M, options, &clr); // break; } // case CONFIG_FWD_REV_COUPLING_160M_ADJ: // RF power sensor coupling adjust (160m) else if(select==CONFIG_FWD_REV_COUPLING_160M_ADJ) { UiDriverMenuBandRevCouplingAdjust(var, mode, COUPLING_160M, options, &clr); // break; } // case CONFIG_FWD_REV_COUPLING_80M_ADJ: // RF power sensor coupling adjust (80m) else if(select==CONFIG_FWD_REV_COUPLING_80M_ADJ) { UiDriverMenuBandRevCouplingAdjust(var, mode, COUPLING_80M, options, &clr); // break; } // case CONFIG_FWD_REV_COUPLING_40M_ADJ: // RF power sensor coupling adjust (40m) else if(select==CONFIG_FWD_REV_COUPLING_40M_ADJ) { UiDriverMenuBandRevCouplingAdjust(var, mode, COUPLING_40M, options, &clr); // break; } // case CONFIG_FWD_REV_COUPLING_20M_ADJ: // RF power sensor coupling adjust (20m) else if(select==CONFIG_FWD_REV_COUPLING_20M_ADJ) { UiDriverMenuBandRevCouplingAdjust(var, mode, COUPLING_20M, options, &clr); // break; } // case CONFIG_FWD_REV_COUPLING_15M_ADJ: // RF power sensor coupling adjust (15m) else if(select==CONFIG_FWD_REV_COUPLING_15M_ADJ) { UiDriverMenuBandRevCouplingAdjust(var, mode, COUPLING_15M, options, &clr); // break; } // case CONFIG_FWD_REV_COUPLING_10M_ADJ: // RF power sensor coupling adjust (15m) else if(select==CONFIG_FWD_REV_COUPLING_10M_ADJ) { UiDriverMenuBandRevCouplingAdjust(var, mode, COUPLING_10M, options, &clr); // break; } // case CONFIG_FWD_REV_COUPLING_6M_ADJ: // RF power sensor coupling adjust (6m) else if(select==CONFIG_FWD_REV_COUPLING_6M_ADJ) { UiDriverMenuBandRevCouplingAdjust(var, mode, COUPLING_6M, options, &clr); // break; } // case CONFIG_FWD_REV_COUPLING_2M_ADJ: // RF power sensor coupling adjust (2m) else if(select==CONFIG_FWD_REV_COUPLING_2M_ADJ) { UiDriverMenuBandRevCouplingAdjust(var, mode, COUPLING_2M, options, &clr); // break; } // case CONFIG_FWD_REV_COUPLING_70CM_ADJ: // RF power sensor coupling adjust (70cm) else if(select==CONFIG_FWD_REV_COUPLING_70CM_ADJ) { UiDriverMenuBandRevCouplingAdjust(var, mode, COUPLING_70CM, options, &clr); // break; } // case CONFIG_FWD_REV_COUPLING_23CM_ADJ: // RF power sensor coupling adjust (23cm) else if(select==CONFIG_FWD_REV_COUPLING_23CM_ADJ) { UiDriverMenuBandRevCouplingAdjust(var, mode, COUPLING_23CM, options, &clr); // break; } // case CONFIG_FWD_REV_SENSE_SWAP: // Enable/disable swap of FWD/REV A/D inputs on power sensor else if(select==CONFIG_FWD_REV_SENSE_SWAP) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.flags1,0,options,&clr, FLAGS1_SWAP_FWDREV_SENSE); if(ts.flags1 & FLAGS1_SWAP_FWDREV_SENSE) // Display status FWD/REV swapping { clr = Orange; // warn user swapping is on! } // break; } // case CONFIG_XVTR_OFFSET_MULT: // Transverter Frequency Display Offset/Multiplier Mode On/Off else if(select==CONFIG_XVTR_OFFSET_MULT) { // var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.xverter_mode, temp_var_u8 = ts.xverter_mode & 0xf; var_change = UiDriverMenuItemChangeUInt8(var, mode, &temp_var_u8, 0, XVERTER_MULT_MAX, 0, 1); ts.xverter_mode = (ts.xverter_mode & 0xfffffff0) | temp_var_u8; if(var_change) // change? { #ifdef SDR_AMBER if(temp_var_u8 & ts.show_wide_spectrum) { //Don't show BndMem ts.expflags1 = ts.expflags1 | EXPFLAGS1_NO_SHOW_BNDMEM; UiDriver_ClearMemoryLabel(); } if (ts.expflags2 & EXPFLAGS2_XVTR_OFF_PA) { if(temp_var_u8) { ts.amber_io8_state = ts.amber_io8_state & ~128; // reset bit } else { ts.amber_io8_state = ts.amber_io8_state | 128; // set bit } Board_AmberIOx8_Write(ts.amber_io8_state); } #endif UiDriver_CreateMainFreqDisplay(true); UiDriver_FrequencyUpdateLOandDisplay(true); } // if(ts.xverter_mode) if(temp_var_u8) { // snprintf(options,32, " ON x%u", ts.xverter_mode); // Display on/multiplication factor // clr = Red; snprintf(options,32, " ON x%u", (uint)ts.xverter_mode); // Display on/multiplication factor } else { // txt_ptr = " OFF"; txt_ptr = " OFF"; clr = Orange; } // break; } // case CONFIG_XVTR_FREQUENCY_OFFSET: // Adjust transverter Frequency offset else if(select==CONFIG_XVTR_FREQUENCY_OFFSET) { if(var >= 1) // setting increase? { ts.menu_var_changed = 1; // indicate that a change has occurred ts.xverter_offset += df.tuning_step; var_change = 1; } else if(var <= -1) // setting decrease? { ts.menu_var_changed = 1; // indicate that a change has occurred if(ts.xverter_offset >= df.tuning_step) // subtract only if we have room to do so { ts.xverter_offset -= df.tuning_step; } else { ts.xverter_offset = 0; // else set to zero } var_change = 1; } if(ts.xverter_offset > XVERTER_OFFSET_MAX) { ts.xverter_offset = XVERTER_OFFSET_MAX; } if(mode == MENU_PROCESS_VALUE_SETDEFAULT) { ts.menu_var_changed = 1; // indicate that a change has occurred ts.xverter_offset = 0; // default for this option is to zero it out var_change = 1; } if(var_change) // change? { UiDriver_FrequencyUpdateLOandDisplay(true); } // if(ts.xverter_mode) // transvert mode active? if(RadioManagement_Transverter_IsEnabled() == false) // transvert mode inactive? { clr = Orange; // make number red to alert user of this! } uint32_t offset_offset = ts.xverter_offset > XVERTER_OFFSET_MAX_HZ? ((XVERTER_OFFSET_MAX_HZ)-(XVERTER_OFFSET_MAX_HZ)/1000):0; snprintf(options,32, ts.xverter_offset > XVERTER_OFFSET_MAX_HZ? " %9ukHz" : " %9uHz", (uint)(ts.xverter_offset-offset_offset)); // print with nine digits // break; } // case CONFIG_XVTR_FREQUENCY_OFFSET_TX: // Adjust transverter tx Frequency offset else if(select==CONFIG_XVTR_FREQUENCY_OFFSET_TX) { if(var >= 1) // setting increase? { ts.menu_var_changed = 1; // indicate that a change has occurred ts.xverter_offset_tx += df.tuning_step; var_change = 1; } else if(var <= -1) // setting decrease? { ts.menu_var_changed = 1; // indicate that a change has occurred if(ts.xverter_offset_tx >= df.tuning_step) // subtract only if we have room to do so { ts.xverter_offset_tx -= df.tuning_step; } else { ts.xverter_offset_tx = 0; // else set to zero } var_change = 1; } if(ts.xverter_offset_tx > XVERTER_OFFSET_MAX) { ts.xverter_offset_tx = XVERTER_OFFSET_MAX; } if(mode == MENU_PROCESS_VALUE_SETDEFAULT) { ts.menu_var_changed = 1; // indicate that a change has occurred ts.xverter_offset_tx = 0; // default for this option is to zero it out var_change = 1; } if(var_change) // change? { UiDriver_FrequencyUpdateLOandDisplay(true); } if(RadioManagement_Transverter_IsEnabled() == false) // transvert mode inactive? { // clr = Red; // make number red to alert user of this! clr = Orange; // make number orange to alert user of this! } // snprintf(options,32, " %9uHz", (uint)ts.xverter_offset); // print with nine digits if (ts.xverter_offset_tx != 0) { uint32_t offset_offset = ts.xverter_offset_tx > XVERTER_OFFSET_MAX_HZ? ((XVERTER_OFFSET_MAX_HZ)-(XVERTER_OFFSET_MAX_HZ)/1000):0; snprintf(options,32, ts.xverter_offset_tx > XVERTER_OFFSET_MAX_HZ? " %9ukHz" : " %9uHz", (uint)(ts.xverter_offset_tx-offset_offset)); // print with nine digits } else { txt_ptr = " Same as RX"; } // break; } // case CONFIG_2200M_5W_ADJUST: // 2200m 5 watt adjust else if(select==CONFIG_2200M_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_2200, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_630M_5W_ADJUST: // 630m 5 watt adjust else if(select==CONFIG_630M_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_630, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_160M_5W_ADJUST: // 160m 5 watt adjust else if(select==CONFIG_160M_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_160, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_80M_5W_ADJUST: // 80m 5 watt adjust else if(select==CONFIG_80M_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_80, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_60M_5W_ADJUST: // 60m 5 watt adjust else if(select==CONFIG_60M_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_60, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_40M_5W_ADJUST: // 40m 5 watt adjust else if(select==CONFIG_40M_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_40, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_30M_5W_ADJUST: // 30m 5 watt adjust else if(select==CONFIG_30M_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_30, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_20M_5W_ADJUST: // 20m 5 watt adjust else if(select==CONFIG_20M_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_20, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_17M_5W_ADJUST: // 17m 5 watt adjust else if(select==CONFIG_17M_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_17, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_15M_5W_ADJUST: // 15m 5 watt adjust else if(select==CONFIG_15M_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_15, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_12M_5W_ADJUST: // 12m 5 watt adjust else if(select==CONFIG_12M_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_12, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_10M_5W_ADJUST: // 10m 5 watt adjust else if(select==CONFIG_10M_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_10, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_6M_5W_ADJUST: // 6m 5 watt adjust else if(select==CONFIG_6M_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_6, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_4M_5W_ADJUST: // 4m 5 watt adjust else if(select==CONFIG_4M_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_4, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_2M_5W_ADJUST: // 2m 5 watt adjust else if(select==CONFIG_2M_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_2, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_70CM_5W_ADJUST: // 70cm 5 watt adjust else if(select==CONFIG_70CM_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_70, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_23CM_5W_ADJUST: // 23cm 5 watt adjust else if(select==CONFIG_23CM_5W_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_23, PA_LEVEL_HIGH, options, &clr); // break; } // case CONFIG_2200M_FULL_POWER_ADJUST: // 2200m 5 watt adjust else if(select==CONFIG_2200M_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_2200, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_630M_FULL_POWER_ADJUST: // 630m 5 watt adjust else if(select==CONFIG_630M_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_630, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_160M_FULL_POWER_ADJUST: // 160m 5 watt adjust else if(select==CONFIG_160M_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_160, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_80M_FULL_POWER_ADJUST: // 80m 5 watt adjust else if(select==CONFIG_80M_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_80, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_60M_FULL_POWER_ADJUST: // 60m 5 watt adjust else if(select==CONFIG_60M_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_60, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_40M_FULL_POWER_ADJUST: // 40m 5 watt adjust else if(select==CONFIG_40M_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_40, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_30M_FULL_POWER_ADJUST: // 30m 5 watt adjust else if(select==CONFIG_30M_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_30, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_20M_FULL_POWER_ADJUST: // 20m 5 watt adjust else if(select==CONFIG_20M_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_20, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_17M_FULL_POWER_ADJUST: // 17m 5 watt adjust else if(select==CONFIG_17M_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_17, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_15M_FULL_POWER_ADJUST: // 15m 5 watt adjust else if(select==CONFIG_15M_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_15, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_12M_FULL_POWER_ADJUST: // 12m 5 watt adjust else if(select==CONFIG_12M_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_12, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_10M_FULL_POWER_ADJUST: // 10m 5 watt adjust else if(select==CONFIG_10M_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_10, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_6M_FULL_POWER_ADJUST: // 6m 5 watt adjust else if(select==CONFIG_6M_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_6, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_4M_FULL_POWER_ADJUST: // 4m 5 watt adjust else if(select==CONFIG_4M_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_4, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_2M_FULL_POWER_ADJUST: // 2m 5 watt adjust else if(select==CONFIG_2M_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_2, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_70CM_FULL_POWER_ADJUST: // 70cm 5 watt adjust else if(select==CONFIG_70CM_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_70, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_23CM_FULL_POWER_ADJUST: // 23cm 5 watt adjust else if(select==CONFIG_23CM_FULL_POWER_ADJUST) { UiDriverMenuBandPowerAdjust(var, mode, BAND_MODE_23, PA_LEVEL_FULL, options, &clr); // break; } // case CONFIG_REDUCE_POWER_ON_LOW_BANDS: else if(select==CONFIG_REDUCE_POWER_ON_LOW_BANDS) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.flags2,0,options,&clr, FLAGS2_LOW_BAND_BIAS_REDUCE); // break; } // case CONFIG_REDUCE_POWER_ON_HIGH_BANDS: else if(select==CONFIG_REDUCE_POWER_ON_HIGH_BANDS) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.flags2,0,options,&clr, FLAGS2_HIGH_BAND_BIAS_REDUCE); // break; } #ifdef OBSOLETE_NR // case CONFIG_DSP_NR_DECORRELATOR_BUFFER_LENGTH: // Adjustment of DSP noise reduction de-correlation delay buffer length else if(select==CONFIG_DSP_NR_DECORRELATOR_BUFFER_LENGTH) { ts.dsp.nr_delaybuf_len &= 0xfff0; // mask bottom nybble to enforce 16-count boundary var_change = UiDriverMenuItemChangeUInt32(var, mode, &ts.dsp.nr_delaybuf_len, DSP_NR_BUFLEN_MIN, DSP_NR_BUFLEN_MAX, DSP_NR_BUFLEN_DEFAULT, 16); if(ts.dsp.nr_delaybuf_len <= ts.dsp.nr_numtaps) // is buffer smaller/equal to number of taps? ts.dsp.nr_delaybuf_len = ts.dsp.nr_numtaps + 16; // yes - it must always be larger than number of taps! if(var_change) // did something change? { if(ts.dsp.active & DSP_NR_ENABLE) // only update if DSP NR active AudioDriver_SetProcessingChain(ts.dmod_mode, false); } if(!(ts.dsp.active & DSP_NR_ENABLE)) // mark orange if DSP NR not active clr = Orange; if(ts.dsp.nr_numtaps >= ts.dsp.nr_delaybuf_len) // Warn if number of taps greater than/equal buffer length! clr = Red; snprintf(options,32, " %u", (uint)ts.dsp.nr_delaybuf_len); // break; } // case CONFIG_DSP_NR_FFT_NUMTAPS: // Adjustment of DSP noise reduction de-correlation delay buffer length else if(select==CONFIG_DSP_NR_FFT_NUMTAPS) { ts.dsp.nr_numtaps &= 0xf0; // mask bottom nybble to enforce 16-count boundary var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.dsp.nr_numtaps, DSP_NR_NUMTAPS_MIN, DSP_NR_NUMTAPS_MAX, DSP_NR_NUMTAPS_DEFAULT, 16); if(ts.dsp.nr_numtaps >= ts.dsp.nr_delaybuf_len) // is number of taps equal or greater than buffer length? { ts.dsp.nr_delaybuf_len = ts.dsp.nr_numtaps + 16; // yes - make buffer larger } if(var_change) // did something change? { if(ts.dsp.active & DSP_NR_ENABLE) // only update if DSP NR active AudioDriver_SetProcessingChain(ts.dmod_mode, false); } if(!(ts.dsp.active & DSP_NR_ENABLE)) // mark orange if DSP NR not active { clr = Orange; } if(ts.dsp.nr_numtaps >= ts.dsp.nr_delaybuf_len) // Warn if number of taps greater than/equal buffer length! { clr = Red; } snprintf(options,32, " %u", ts.dsp.nr_numtaps); // break; } // case CONFIG_DSP_NOTCH_CONVERGE_RATE: // Adjustment of DSP noise reduction de-correlation delay buffer length else if(select==CONFIG_DSP_NOTCH_CONVERGE_RATE) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.dsp.notch_mu, 0, DSP_NOTCH_MU_MAX, DSP_NOTCH_MU_DEFAULT, 1); if(var_change) // did something change? { if(ts.dsp.active & DSP_NOTCH_ENABLE) // only update if Notch DSP is active { AudioDriver_SetProcessingChain(ts.dmod_mode, false); } } if(!(ts.dsp.active & DSP_NOTCH_ENABLE)) // mark orange if Notch DSP not active { clr = Orange; } snprintf(options,32, " %u", ts.dsp.notch_mu); // break; } // case CONFIG_DSP_NOTCH_DECORRELATOR_BUFFER_LENGTH: // Adjustment of DSP noise reduction de-correlation delay buffer length else if(select==CONFIG_DSP_NOTCH_DECORRELATOR_BUFFER_LENGTH) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.dsp.notch_delaybuf_len, DSP_NOTCH_BUFLEN_MIN, DSP_NOTCH_BUFLEN_MAX, DSP_NOTCH_DELAYBUF_DEFAULT, 8); if(ts.dsp.notch_delaybuf_len <= ts.dsp.notch_numtaps) // did we try to decrease it smaller than FFT size? { ts.dsp.notch_delaybuf_len = ts.dsp.notch_numtaps + 8; // yes - limit it to previous size } if(var_change) // did something change? { if(ts.dsp.active & DSP_NOTCH_ENABLE) // only update if DSP Notch active { AudioDriver_SetProcessingChain(ts.dmod_mode, false); } } if(!(ts.dsp.active & DSP_NOTCH_ENABLE)) // mark orange if DSP Notch not active { clr = Orange; } if(ts.dsp.notch_numtaps >= ts.dsp.notch_delaybuf_len) { clr = Red; } snprintf(options,32, " %u", (uint)ts.dsp.notch_delaybuf_len); // break; } // case CONFIG_DSP_NOTCH_FFT_NUMTAPS: // Adjustment of DSP noise reduction de-correlation delay buffer length else if(select==CONFIG_DSP_NOTCH_FFT_NUMTAPS) { ts.dsp.notch_numtaps &= 0xf0; // mask bottom nybble to enforce 16-count boundary var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.dsp.notch_numtaps, 0, DSP_NOTCH_NUMTAPS_MAX, DSP_NOTCH_NUMTAPS_DEFAULT, 16); if(ts.dsp.notch_numtaps >= ts.dsp.notch_delaybuf_len) // force buffer size to always be larger than number of taps ts.dsp.notch_delaybuf_len = ts.dsp.notch_numtaps + 8; if(var_change) // did something change? { if(ts.dsp.active & DSP_NOTCH_ENABLE) // only update if DSP NR active { AudioDriver_SetProcessingChain(ts.dmod_mode, false); } } if(!(ts.dsp.active & DSP_NOTCH_ENABLE)) // mark orange if DSP NR not active { clr = Orange; } if(ts.dsp.notch_numtaps >= ts.dsp.notch_delaybuf_len) // Warn if number of taps greater than/equal buffer length! { clr = Red; } snprintf(options,32, " %u", ts.dsp.notch_numtaps); // break; } /* case CONFIG_AGC_TIME_CONSTANT: // Adjustment of Noise Blanker AGC Time Constant var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.nb_agc_time_const, 0, NB_MAX_AGC_SETTING, NB_AGC_DEFAULT, 1); if(var_change) // parameter changed? { AudioManagement_CalcNB_AGC(); // yes - recalculate new values for Noise Blanker AGC } snprintf(options,32, " %u", ts.nb_agc_time_const); break; */ #endif #ifdef USE_LMS_AUTONOTCH // case CONFIG_DSP_NOTCH_CONVERGE_RATE: // Adjustment of DSP autonotch convergence rate else if(select==CONFIG_DSP_NOTCH_CONVERGE_RATE) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.dsp.notch_mu, 0, DSP_NOTCH_MU_MAX, DSP_NOTCH_MU_DEFAULT, 1); if(var_change) // did something change? { if(ts.dsp.active & DSP_NOTCH_ENABLE) // only update if Notch DSP is active { AudioDriver_SetProcessingChain(ts.dmod_mode, false); } } if(!(ts.dsp.active & DSP_NOTCH_ENABLE)) // mark orange if Notch DSP not active { clr = Orange; } snprintf(options,32, " %u", ts.dsp.notch_mu); // break; } // case CONFIG_DSP_NOTCH_DECORRELATOR_BUFFER_LENGTH: // Adjustment of DSP noise reduction de-correlation delay buffer length else if(select==CONFIG_DSP_NOTCH_DECORRELATOR_BUFFER_LENGTH) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.dsp.notch_delaybuf_len, DSP_NOTCH_BUFLEN_MIN, DSP_NOTCH_BUFLEN_MAX, DSP_NOTCH_DELAYBUF_DEFAULT, 8); if(ts.dsp.notch_delaybuf_len <= ts.dsp.notch_numtaps) // did we try to decrease it smaller than FFT size? { ts.dsp.notch_delaybuf_len = ts.dsp.notch_numtaps + 8; // yes - limit it to previous size } if(var_change) // did something change? { if(ts.dsp.active & DSP_NOTCH_ENABLE) // only update if DSP Notch active { AudioDriver_SetProcessingChain(ts.dmod_mode, false); } } if(!(ts.dsp.active & DSP_NOTCH_ENABLE)) // mark orange if DSP Notch not active { clr = Orange; } if(ts.dsp.notch_numtaps >= ts.dsp.notch_delaybuf_len) { clr = Red; } snprintf(options,32, " %u", (uint)ts.dsp.notch_delaybuf_len); // break; } // case CONFIG_DSP_NOTCH_FFT_NUMTAPS: // Adjustment of DSP noise reduction de-correlation delay buffer length else if(select==CONFIG_DSP_NOTCH_FFT_NUMTAPS) { ts.dsp.notch_numtaps &= 0xf0; // mask bottom nybble to enforce 16-count boundary var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.dsp.notch_numtaps, 16, DSP_NOTCH_NUMTAPS_MAX, DSP_NOTCH_NUMTAPS_DEFAULT, 16); // if(ts.dsp.notch_numtaps >= ts.dsp.notch_delaybuf_len) // force buffer size to always be larger than number of taps // ts.dsp.notch_delaybuf_len = ts.dsp.notch_numtaps + 8; if(var_change) // did something change? { if(ts.dsp.active & DSP_NOTCH_ENABLE) // only update if DSP NR active { AudioDriver_SetProcessingChain(ts.dmod_mode, false); } } if(!(ts.dsp.active & DSP_NOTCH_ENABLE)) // mark orange if DSP NR not active { clr = Orange; } if(ts.dsp.notch_numtaps >= ts.dsp.notch_delaybuf_len) // Warn if number of taps greater than/equal buffer length! { clr = Red; } snprintf(options,32, " %u", ts.dsp.notch_numtaps); // break; } #endif // case CONFIG_AM_TX_FILTER_DISABLE: // Enable/disable AM TX audio filter else if(select==CONFIG_AM_TX_FILTER_DISABLE) { temp_var_u8 = !(ts.flags1 & FLAGS1_AM_TX_FILTER_DISABLE); var_change = UiDriverMenuItemChangeEnableOnOff(var, mode, &temp_var_u8,0,options,&clr); if(var_change) // did the status change and is translate mode NOT active? { CLR_OR_SET_BITMASK(!temp_var_u8, ts.flags1, FLAGS1_AM_TX_FILTER_DISABLE); } if(ts.flags1 & FLAGS1_AM_TX_FILTER_DISABLE) // Display status of TX audio filter { clr = Orange; // warn user that filter is off! } // break; } /* case CONFIG_SSB_TX_FILTER_DISABLE: // Enable/disable SSB TX audio filter temp_var = ts.flags1 & FLAGS1_SSB_TX_FILTER_DISABLE; tchange = UiDriverMenuItemChangeDisableOnOff(var, mode, &temp_var,0,options,&clr); if(tchange) // did the status change and is translate mode NOT active? { if(temp_var) // SSB TX audio filter is disabled { ts.flags1 |= FLAGS1_SSB_TX_FILTER_DISABLE; // set bit } else { // SSB TX audio filter is enabled ts.flags1 &= ~FLAGS1_SSB_TX_FILTER_DISABLE; // clear bit } } if(ts.flags1 & FLAGS1_SSB_TX_FILTER_DISABLE) // Display status of TX audio filter { clr = Red; // warn user that filter is off! } break; */ // case CONFIG_SSB_TX_FILTER: // Type of SSB TX audio filter else if(select==CONFIG_SSB_TX_FILTER) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.tx_filter, // 0, 1, TX_FILTER_ESSB_6k, TX_FILTER_TENOR, 1 ); switch(ts.tx_filter) { case TX_FILTER_SOPRANO: txt_ptr = " SOPRANO"; break; case TX_FILTER_TENOR: txt_ptr = " TENOR"; break; case TX_FILTER_BASS: txt_ptr = " BASS"; break; case TX_FILTER_ESSB_4k: txt_ptr = " eSSB 4k"; break; case TX_FILTER_ESSB_5k: txt_ptr = " eSSB 5k"; break; case TX_FILTER_ESSB_6k: txt_ptr = " eSSB 6k"; break; } if(var_change) { TxProcessor_Set(ts.dmod_mode); } // break; } // case CONFIG_TUNE_TONE_MODE: // set power for antenne tuning else if(select==CONFIG_TUNE_TONE_MODE) { temp_var_u8 = ts.menu_var_changed; // this is not save, so no need to mark as dirty, // we just remember the state and restore it var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.tune_tone_mode, TUNE_TONE_SINGLE, TUNE_TONE_TWO, TUNE_TONE_SINGLE, 1); switch(ts.tune_tone_mode) { case TUNE_TONE_SINGLE: txt_ptr = " Single"; break; case TUNE_TONE_TWO: txt_ptr = "Two Tone"; break; default: break; } ts.menu_var_changed = temp_var_u8; // break; } // case CONFIG_TUNE_POWER_LEVEL: // set power for antenne tuning else if(select==CONFIG_TUNE_POWER_LEVEL) { var_change = UiDriverMenuItemChangeUInt8(var*(-1), mode, &ts.tune_power_level, 0, PA_LEVEL_TUNE_KEEP_CURRENT, PA_LEVEL_TUNE_KEEP_CURRENT, 1); if (ts.tune_power_level < mchf_power_levelsInfo.count) { char txt[5]; UiDriver_Power2String(txt,sizeof(txt),mchf_power_levelsInfo.levels[ts.tune_power_level].mW); snprintf(options,32," %s",txt); } else { txt_ptr = " as TX PWR"; } // break; } #if 0 // case CONFIG_SPECTRUM_FFT_WINDOW_TYPE: // set step size of of waterfall display? else if(select==CONFIG_SPECTRUM_FFT_WINDOW_TYPE) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.fft_window_type, 0, FFT_WINDOW_MAX-1, FFT_WINDOW_DEFAULT, 1); switch(ts.fft_window_type) { case FFT_WINDOW_RECTANGULAR: txt_ptr = "Rectangular"; break; case FFT_WINDOW_COSINE: txt_ptr = " Cosine"; break; case FFT_WINDOW_BARTLETT: txt_ptr = " Bartlett"; break; case FFT_WINDOW_WELCH: txt_ptr = " Welch"; break; case FFT_WINDOW_HANN: txt_ptr = " Hann"; break; case FFT_WINDOW_HAMMING: txt_ptr = " Hamming"; break; case FFT_WINDOW_BLACKMAN: txt_ptr = " Blackman"; break; case FFT_WINDOW_NUTTALL: txt_ptr = " Nuttall"; break; } // break; } #endif // case CONFIG_RESET_SER_EEPROM: else if(select==CONFIG_RESET_SER_EEPROM) { if(SerialEEPROM_24xx_Exists() == false) { txt_ptr = " n/a"; clr = Red; } else { txt_ptr = "n/a"; uint8_t test = 0; clr = White; UiDriverMenuItemChangeUInt8(var, mode, &test, 0, 0, 10, 1 ); switch(test) { case 0: txt_ptr = "press DEFLT"; break; case 10: UiMenu_DisplayValue(" Working",Red,pos); // clear EEPROM SerialEEPROM_Clear_Signature(); SerialEEPROM_Clear_AllVariables(); Board_Reboot(); break; } } // break; } // case CONFIG_RESET_SER_EEPROM_SIGNATURE: else if(select==CONFIG_RESET_SER_EEPROM_SIGNATURE) { if(SerialEEPROM_24xx_Exists() == false) { txt_ptr = " n/a"; clr = Red; } else { txt_ptr = "n/a"; uint8_t test = 0; clr = White; UiDriverMenuItemChangeUInt8(var, mode, &test, 0, 0, 10, 1 ); switch(test) { case 0: txt_ptr = "press DEFLT"; break; case 10: UiMenu_DisplayValue(" Working",Red,pos); // clear EEPROM SerialEEPROM_Clear_Signature(); Board_Reboot(); break; } } // break; } // case MENU_FP_CW_01: // case MENU_FP_CW_02: // case MENU_FP_CW_03: // case MENU_FP_CW_04: else if(select==MENU_FP_CW_01 || select==MENU_FP_CW_02 || select==MENU_FP_CW_03 || select==MENU_FP_CW_04) { UiMenu_ChangeFilterPathMemory(var, mode, options, &clr, FILTER_MODE_CW,(select - MENU_FP_CW_01)+1); // break; } // case MENU_FP_AM_01: // case MENU_FP_AM_02: // case MENU_FP_AM_03: // case MENU_FP_AM_04: else if(select==MENU_FP_AM_01 || select==MENU_FP_AM_02 || select==MENU_FP_AM_03 || select==MENU_FP_AM_04) { UiMenu_ChangeFilterPathMemory(var, mode, options, &clr, FILTER_MODE_AM,(select - MENU_FP_AM_01)+1); // break; } // case MENU_FP_SSB_01: // case MENU_FP_SSB_02: // case MENU_FP_SSB_03: // case MENU_FP_SSB_04: else if(select==MENU_FP_SSB_01 || select==MENU_FP_SSB_02 || select==MENU_FP_SSB_03 || select==MENU_FP_SSB_04) { UiMenu_ChangeFilterPathMemory(var, mode, options, &clr, FILTER_MODE_SSB,(select - MENU_FP_SSB_01)+1); // break; } // case MENU_FP_SAM_01: // case MENU_FP_SAM_02: // case MENU_FP_SAM_03: // case MENU_FP_SAM_04: // UiMenu_ChangeFilterPathMemory(var, mode, options, &clr, FILTER_MODE_SAM,(select - MENU_FP_SAM_01)+1); // break; // case CONFIG_CAT_IN_SANDBOX: else if(select==CONFIG_CAT_IN_SANDBOX) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.flags1,0,options,&clr, FLAGS1_CAT_IN_SANDBOX); if(!(ts.flags1 & FLAGS1_CAT_IN_SANDBOX)) { ts.cat_band_index = 255; } // break; } // case CONFIG_CAT_XLAT: // CAT xlat reporting else if(select==CONFIG_CAT_XLAT) { var_change = UiDriverMenuItemChangeEnableOnOff(var, mode, &ts.xlat,0,options,&clr); // break; } // case MENU_DEBUG_TX_AUDIO: // Step size button swap on/off else if(select==MENU_DEBUG_TX_AUDIO) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.stream_tx_audio, 0, STREAM_TX_AUDIO_NUM-1, STREAM_TX_AUDIO_OFF, 1); switch(ts.stream_tx_audio) { case STREAM_TX_AUDIO_OFF: txt_ptr = " OFF"; break; case STREAM_TX_AUDIO_SRC: txt_ptr = " Source"; break; case STREAM_TX_AUDIO_FILT: txt_ptr = " Filtered"; break; case STREAM_TX_AUDIO_DIGIQ: txt_ptr = " Final IQ"; break; case STREAM_TX_AUDIO_GENIQ: txt_ptr = "Generated IQ"; break; } // break; } #ifdef STM32F4 // case CONFIG_I2C1_SPEED: // else if(select==CONFIG_I2C1_SPEED) { var_change = UiDriverMenuItemChangeUInt32(var, mode, &ts.i2c_speed[I2C_BUS_1], 1, 20, I2C1_SPEED_DEFAULT, 1 ); if(var_change) { UhsdrHw_I2C_ChangeSpeed(&hi2c1); } snprintf(options, 32, " %3dkHz",(unsigned int)(ts.i2c_speed[I2C_BUS_1]*I2C_BUS_SPEED_MULT) / 1000 ); if((ts.i2c_speed[I2C_BUS_1]*I2C_BUS_SPEED_MULT) / 1000 < 50 || (ts.i2c_speed[I2C_BUS_1]*I2C_BUS_SPEED_MULT) / 1000 > 250) { clr = Red; } if(((ts.i2c_speed[I2C_BUS_1]*I2C_BUS_SPEED_MULT) / 1000 > 50 && (ts.i2c_speed[I2C_BUS_1]*I2C_BUS_SPEED_MULT) / 1000 < 90) || ((ts.i2c_speed[I2C_BUS_1]*I2C_BUS_SPEED_MULT) / 1000 > 210 && (ts.i2c_speed[I2C_BUS_1]*I2C_BUS_SPEED_MULT) / 1000 < 250)) { clr = Yellow; } if((ts.i2c_speed[I2C_BUS_1]*I2C_BUS_SPEED_MULT) / 1000 > 90 && (ts.i2c_speed[I2C_BUS_1]*I2C_BUS_SPEED_MULT) / 1000 < 210) { clr = Green; } // break; } // case CONFIG_I2C2_SPEED: // else if(select==CONFIG_I2C2_SPEED) { var_change = UiDriverMenuItemChangeUInt32(var, mode, &ts.i2c_speed[I2C_BUS_2], 1, 20, I2C2_SPEED_DEFAULT, 1 ); if(var_change) { UhsdrHw_I2C_ChangeSpeed(&hi2c2); } snprintf(options, 32, " %3ukHz",(unsigned int)(ts.i2c_speed[I2C_BUS_2]*I2C_BUS_SPEED_MULT) / 1000 ); if((ts.i2c_speed[I2C_BUS_2]*I2C_BUS_SPEED_MULT) / 1000 < 50 || (ts.i2c_speed[I2C_BUS_2]*I2C_BUS_SPEED_MULT) / 1000 > 250) { clr = Red; } if(((ts.i2c_speed[I2C_BUS_2]*I2C_BUS_SPEED_MULT) / 1000 > 50 && (ts.i2c_speed[I2C_BUS_2]*I2C_BUS_SPEED_MULT) / 1000 < 90) || ((ts.i2c_speed[I2C_BUS_2]*I2C_BUS_SPEED_MULT) / 1000 > 210 && (ts.i2c_speed[I2C_BUS_2]*I2C_BUS_SPEED_MULT) / 1000 < 250)) { clr = Yellow; } if((ts.i2c_speed[I2C_BUS_2]*I2C_BUS_SPEED_MULT) / 1000 > 90 && (ts.i2c_speed[I2C_BUS_1]*I2C_BUS_SPEED_MULT) / 1000 < 210) { clr = Green; } // break; } #endif // case CONFIG_RTC_HOUR: else if(select==CONFIG_RTC_HOUR) { RTC_TimeTypeDef rtc; Rtc_GetTime(&hrtc, &rtc, RTC_FORMAT_BIN); rtc.DayLightSaving = RTC_DAYLIGHTSAVING_NONE; rtc.StoreOperation = RTC_STOREOPERATION_SET; var_change = UiDriverMenuItemChangeUInt8(var, mode, &rtc.Hours, 0, 23, 0, 1); if(var_change) // did something change? { HAL_RTC_SetTime(&hrtc, &rtc, RTC_FORMAT_BIN); } snprintf(options,32, " %2u", rtc.Hours); // break; } // case CONFIG_RTC_MIN: else if(select==CONFIG_RTC_MIN) { RTC_TimeTypeDef rtc; Rtc_GetTime(&hrtc, &rtc, RTC_FORMAT_BIN); rtc.DayLightSaving = RTC_DAYLIGHTSAVING_NONE; rtc.StoreOperation = RTC_STOREOPERATION_SET; var_change = UiDriverMenuItemChangeUInt8(var, mode, &rtc.Minutes, 0, 59, 0, 1); if(var_change) // did something change? { HAL_RTC_SetTime(&hrtc, &rtc, RTC_FORMAT_BIN); } snprintf(options,32, " %2u", rtc.Minutes); // break; } // case CONFIG_RTC_SEC: else if(select==CONFIG_RTC_SEC) { RTC_TimeTypeDef rtc; Rtc_GetTime(&hrtc, &rtc, RTC_FORMAT_BIN); rtc.DayLightSaving = RTC_DAYLIGHTSAVING_NONE; rtc.StoreOperation = RTC_STOREOPERATION_SET; var_change = UiDriverMenuItemChangeUInt8(var, mode, &rtc.Seconds, 0, 59, 0, 1); if(var_change) // did something change? { HAL_RTC_SetTime(&hrtc, &rtc, RTC_FORMAT_BIN); } snprintf(options,32, " %2u", rtc.Seconds); // break; } // case CONFIG_RTC_CALIB: else if(select==CONFIG_RTC_CALIB) { var_change = UiDriverMenuItemChangeInt16(var, mode, &ts.rtc_calib, RTC_CALIB_PPM_MIN, RTC_CALIB_PPM_MAX, RTC_CALIB_PPM_DEFAULT, 1); if(var_change) // did something change? { Rtc_SetPpm(ts.rtc_calib); } snprintf(options,32, "%4dppm", ts.rtc_calib); // break; } // case CONFIG_RTC_START: else if(select==CONFIG_RTC_START) { txt_ptr = "Do it!"; clr = White; if(var>=1) { Rtc_Start(); Board_Reboot(); // TODO: we will not reach this but in future we may switch the keyboard dynamically... txt_ptr = " Done!"; clr = Green; } // break; } // case CONFIG_RTC_RESET: else if(select==CONFIG_RTC_RESET) { txt_ptr = "Do it!"; clr = White; if(var>=1) { Rtc_FullReset(); txt_ptr = " Done!"; clr = Green; } // break; } // case MENU_DEBUG_ENABLE_INFO: // Debug infos on LCD on/off else if(select==MENU_DEBUG_ENABLE_INFO) { var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &ts.show_debug_info,0,options,&clr); if(var_change) { UiDriver_DebugInfo_DisplayEnable(ts.show_debug_info); } // break; } #ifdef USE_TWO_CHANNEL_AUDIO // case MENU_DEBUG_ENABLE_STEREO: // stereo demodulation on/off else if(select==MENU_DEBUG_ENABLE_STEREO) { var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &ts.stereo_enable,0,options,&clr); switch(ts.stereo_enable) { case 0: txt_ptr = " OFF"; break; case 1: txt_ptr = " ON"; break; } // break; } #endif #ifdef USE_LEAKY_LMS // case MENU_DEBUG_LEAKY_LMS: else if(select==MENU_DEBUG_LEAKY_LMS) { var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &ts.enable_leaky_LMS,0,options,&clr); // break; } // case MENU_DEBUG_NR_POST_AGC_SELECT: // selection of location of DSP noise reduction - pre audio filter/AGC or post AGC/filter else if(select==MENU_DEBUG_NR_POST_AGC_SELECT) { temp_var_u8 = ts.dsp.active & DSP_NR_POSTAGC_ENABLE; var_change = UiDriverMenuItemChangeEnableOnOff(var, mode, &temp_var_u8,0,options,&clr); // var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.dsp.active, 0, options, &clr, DSP_NR_POSTAGC_ENABLE); if(var_change) // did something change? { CLR_OR_SET_BITMASK(temp_var_u8, ts.dsp.active, DSP_NR_POSTAGC_ENABLE); if(ts.dsp.active & DSP_NR_ENABLE) // only update if DSP NR active { AudioDriver_SetProcessingChain(ts.dmod_mode, false); } } // break; } // case MENU_DEBUG_ANR_GAIN: // else if(select==MENU_DEBUG_ANR_GAIN) { var_change = UiDriverMenuItemChangeUInt32(var, mode, &leakyLMS.two_mu_int, 1, 10000, 100, 10 ); if(var_change) { leakyLMS.two_mu = leakyLMS.two_mu_int / 1000000; ts.anr_two_mu_int = leakyLMS.two_mu_int; } snprintf(options, 32, " %4u",(unsigned int)leakyLMS.two_mu_int); // break; } // case MENU_DEBUG_ANR_LEAK: // else if(select==MENU_DEBUG_ANR_LEAK) { var_change = UiDriverMenuItemChangeUInt32(var, mode, &leakyLMS.gamma_int, 1, 1000, 100, 10 ); if(var_change) { leakyLMS.gamma = leakyLMS.gamma_int / 1000.0; ts.anr_gamma_int = leakyLMS.gamma_int; } snprintf(options, 32, " %4u",(unsigned int)leakyLMS.gamma_int); // break; } // case MENU_DEBUG_ANR_TAPS: // else if(select==MENU_DEBUG_ANR_TAPS) { var_change = UiDriverMenuItemChangeInt16(var, mode, &leakyLMS.n_taps, 1, 192, 64, 2 ); if(var_change) { // leakyLMS.gamma = leakyLMS.gamma_int / 1000; } snprintf(options, 32, " %3u",(unsigned int)leakyLMS.n_taps); ts.anr_n_taps = leakyLMS.n_taps; // break; } // case MENU_DEBUG_ANR_DELAY: // else if(select==MENU_DEBUG_ANR_DELAY) { var_change = UiDriverMenuItemChangeInt16(var, mode, &leakyLMS.delay, 1, 64, 16, 2 ); if(var_change) { ts.anr_delay = leakyLMS.delay; } snprintf(options, 32, " %3u",(unsigned int)leakyLMS.delay); // break; } #endif // this is now adjusted by ts.dsp.nr_strength /* case MENU_DEBUG_NR_ALPHA: // var_change = UiDriverMenuItemChangeInt16(var, mode, &nr_params.alpha_int, 700, 999, 920, 2 ); if(var_change) { nr_params.alpha = (float32_t)nr_params.alpha_int / 1000.0; } snprintf(options, 32, " %3u",(unsigned int)nr_params.alpha_int); break; */ // case MENU_DEBUG_NR_GAIN_SHOW: // else if(select==MENU_DEBUG_NR_GAIN_SHOW) { var_change = UiDriverMenuItemChangeInt16(var, mode, &ts.nr_gain_display, 0, 1, 0, 1 ); switch(ts.nr_gain_display) { case 0: txt_ptr = " OFF"; break; case 1: txt_ptr = " Hk"; break; /*case 2: txt_ptr = " notch"; break; case 3: txt_ptr = "HK & notch"; break; */ } // break; } /*case MENU_DEBUG_NR_GAIN_SMOOTH_ALPHA: // var_change = UiDriverMenuItemChangeInt16(var, mode, &nr_params.gain_smooth_alpha_int, 100, 990, 250, 2 ); if(var_change) { nr_params.gain_smooth_alpha = (float32_t)nr_params.gain_smooth_alpha_int / 1000.0; } snprintf(options, 32, " %3u",(unsigned int)nr_params.gain_smooth_alpha_int); break; case MENU_DEBUG_NR_LONG_TONE_ALPHA: // var_change = UiDriverMenuItemChangeUInt32(var, mode, &nr_params.long_tone_alpha_int, 90000, 99999, 99900, 10 ); if(var_change) { nr_params.long_tone_alpha = (float32_t)nr_params.long_tone_alpha_int / 100000.0; } snprintf(options, 32, " %5u",(unsigned int)nr_params.long_tone_alpha_int); break; case MENU_DEBUG_NR_LONG_TONE_THRESH: // var_change = UiDriverMenuItemChangeInt16(var, mode, &nr_params.long_tone_thresh, 10, 16000, 600, 200 ); if(var_change) { // nr_params.vad_thresh = (float32_t)nr_params.vad_thresh_int / 1000.0; } snprintf(options, 32, " %5u",(unsigned int)nr_params.long_tone_thresh); break; case MENU_DEBUG_NR_THRESH: // var_change = UiDriverMenuItemChangeUInt32(var, mode, &nr_params.vad_thresh_int, 100, 20000, 1000, 50 ); if(var_change) { nr_params.vad_thresh = (float32_t)nr_params.vad_thresh_int / 1000.0; } snprintf(options, 32, " %5u",(unsigned int)nr_params.vad_thresh_int); break;*/ // case MENU_DEBUG_NR_BETA: // else if(select==MENU_DEBUG_NR_BETA) { { int16_t beta_int = nr_params.beta * 1000; var_change = UiDriverMenuItemChangeInt16(var, mode, &beta_int, 700, 999, 960, 2 ); if(var_change) { nr_params.beta = (float32_t)beta_int / 1000.0; } snprintf(options, 32, " %3u",(unsigned int)beta_int); } // break; } /*case MENU_DEBUG_NR_Mode: // var_change = UiDriverMenuItemChangeInt16(var, mode, &nr_params.mode, 0, 2, 0, 1 ); switch(nr_params.mode) { case 0: txt_ptr = " Release"; break; case 1: txt_ptr = " Devel1"; break; case 2: txt_ptr = " Devel2"; } if(var_change) { switch(nr_params.mode) { case 0: nr_params.beta = 0.850; nr_params.beta_int=850; nr_params.first_time = 1; //Restart the noisereduction break; case 1: nr_params.beta = 0.960; nr_params.beta_int=960; nr_params.first_time = 1; //Restart the noisereduction case 2: nr_params.beta = 0.960; nr_params.beta_int=960; nr_params.first_time = 1; //Restart the noisereduction break; } } break; */ // case MENU_DEBUG_NR_ASNR: else if(select==MENU_DEBUG_NR_ASNR) { var_change = UiDriverMenuItemChangeInt16(var, mode, &NR2.asnr, 2, 30, 30, 1); if(var_change) // did something change? { //nr_params.first_time = 1; } snprintf(options,32, " %3u", (unsigned int)NR2.asnr); // break; } // case MENU_DEBUG_NR_GAIN_SMOOTH_WIDTH: else if(select==MENU_DEBUG_NR_GAIN_SMOOTH_WIDTH) { var_change = UiDriverMenuItemChangeInt16(var, mode, &NR2.width, 1, 5, 4, 1); if(var_change) // did something change? { //nr_params.first_time = 1; } snprintf(options,32, " %3u", (unsigned int)NR2.width); // break; } // case MENU_DEBUG_NR_GAIN_SMOOTH_THRESHOLD: else if(select==MENU_DEBUG_NR_GAIN_SMOOTH_THRESHOLD) { var_change = UiDriverMenuItemChangeInt16(var, mode, &NR2.power_threshold_int, 10, 100, 40, 5); if(var_change) // did something change? { //nr_params.first_time = 1; } snprintf(options,32, " %3u", (unsigned int)NR2.power_threshold_int); // break; } /* case MENU_DEBUG_NR_VAD_DELAY: // var_change = UiDriverMenuItemChangeInt16(var, mode, &nr_params.vad_delay, 0, 20, 2, 1 ); if(var_change) { } snprintf(options, 32, " %2u",(unsigned int)nr_params.vad_delay); break; */ // case MENU_DEBUG_CLONEOUT: else if(select==MENU_DEBUG_CLONEOUT) { txt_ptr = " Do it!"; clr = White; if(var>=1) { CatDriver_CloneOutStart(); txt_ptr = "Working"; var = 1; clr = Green; } // break; } // case MENU_DEBUG_CLONEIN: else if(select==MENU_DEBUG_CLONEIN) { txt_ptr = " Do it!"; clr = White; if(var>=1) { CatDriver_CloneInStart(); txt_ptr = "Waiting"; var = 1; clr = Green; } // break; } // case MENU_DEBUG_NEW_NB: // var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &ts.new_nb,0,options,&clr); // break;// //#if defined(STM32F7) || defined(STM32H7) /* case MENU_DEBUG_NR_FFT_SIZE: var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &nr_params.fft_256_enable,0,options,&clr); ts.NR_FFT_L = 128; ts.NR_FFT_LOOP_NO = 2; if(nr_params.fft_256_enable) { ts.NR_FFT_LOOP_NO = 1; ts.NR_FFT_L = 256; } break; case MENU_DEBUG_NR_DEC_ENABLE: var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &ts.NR_decimation_enable,0,options,&clr); break; //#endif // case MENU_DEBUG_NR_ENABLE: // var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &nr_params.enable,0,options,&clr); // break; case MENU_DEBUG_NR_LONG_TONE_ENABLE: var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &nr_params.long_tone_enable,0,options,&clr); if(var_change) { nr_params.long_tone_reset = true; } break;*/ /* case MENU_DEBUG_NR_VAD_TYPE: var_change = UiDriverMenuItemChangeUInt8(var, mode, &NR2.VAD_type, 0, 2, 0, 1); switch(NR2.VAD_type) { case 0: txt_ptr = " Sohn"; break; case 1: txt_ptr = "Esch & Vary"; break; case 2: txt_ptr = " ZCR"; break; } break; case MENU_DEBUG_NR_GAIN_SMOOTH_ENABLE: var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &nr_params.gain_smooth_enable,0,options,&clr); break;*/ // case MENU_DEBUG_RTTY_ATC: // var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &ts.rtty_atc_enable,0,options,&clr); // break; // case MENU_CW_DECODER: else if(select==MENU_CW_DECODER) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.cw_decoder_enable, 0, 1, 0, 1); if (var_change) { if (ts.dmod_mode == DEMOD_CW) { UiDriver_UpdateDemodSpecificDisplayAfterParamChange(); } Board_RedLed(LED_STATE_OFF); } switch(ts.cw_decoder_enable) { case 0: txt_ptr = "OFF"; break; case 1: txt_ptr = " ON"; break; } // break; } // case MENU_DEBUG_CW_OFFSET_SHIFT_KEEP_SIGNAL: else if(select==MENU_DEBUG_CW_OFFSET_SHIFT_KEEP_SIGNAL) { var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &ts.cw_offset_shift_keep_signal,0,options,&clr); // break; } // case MENU_CW_DECODER_USE_3_GOERTZEL: else if(select==MENU_CW_DECODER_USE_3_GOERTZEL) { // var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &cw_decoder_config.use_3_goertzels,0,options,&clr); temp_var_bool = cw_decoder_config.use_3_goertzels; var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &temp_var_bool, 0, options, &clr); cw_decoder_config.use_3_goertzels = temp_var_bool; // break; } // case MENU_CW_DECODER_SHOW_CW_LED: else if(select==MENU_CW_DECODER_SHOW_CW_LED) { // var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &cw_decoder_config.show_CW_LED,0,options,&clr); temp_var_bool = cw_decoder_config.show_CW_LED; var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &temp_var_bool, 0, options, &clr); cw_decoder_config.show_CW_LED = temp_var_bool; if (cw_decoder_config.show_CW_LED == false) { Board_RedLed(LED_STATE_OFF); } // break; } // case MENU_CW_DECODER_SNAP_ENABLE: else if(select==MENU_CW_DECODER_SNAP_ENABLE) { // var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &cw_decoder_config.snap_enable,0,options,&clr); temp_var_bool = cw_decoder_config.snap_enable; var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &temp_var_bool, 0, options, &clr); cw_decoder_config.snap_enable = temp_var_bool; if (var_change) { if (ts.dmod_mode == DEMOD_CW) { UiDriver_UpdateDemodSpecificDisplayAfterParamChange(); } if(!cw_decoder_config.snap_enable) { ts.expflags1 = ts.expflags1 | EXPFLAGS1_TUNE_HELPER_DEFENABLE; } else { ts.expflags1 = ts.expflags1 & ~EXPFLAGS1_TUNE_HELPER_DEFENABLE; } } // break; } // case MENU_DIGITAL_MODE_SELECT: else if(select==MENU_DIGITAL_MODE_SELECT) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.digital_mode,0,DigitalMode_Num_Modes-1,0,1); if (var_change) { // TODO: Factor this out into a Ui function for (de-)activating Rtty mode if (RadioManagement_IsApplicableDemodMode(DEMOD_DIGI)) { UiDriver_SetDemodMode(DEMOD_DIGI); } } snprintf(options,32," %s",digimodes[ts.digital_mode].label); clr = digimodes[ts.digital_mode].enabled?White:Red; // break; } // case CONFIG_BANDEF_SELECT: else if(select==CONFIG_BANDEF_SELECT) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &bandinfo_idx,0,BAND_INFO_SET_NUM-1,0,1); if (var_change) { bandInfo = bandInfos[bandinfo_idx].bands; UiDriver_UpdateDisplayAfterParamChange(); } snprintf(options,32," %s",bandInfos[bandinfo_idx].name); // break; } // case CONFIG_CAT_PTT_RTS: else if(select==CONFIG_CAT_PTT_RTS) { var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &ts.enable_ptt_rts,0,options,&clr); // break; } // case MENU_DEBUG_OSC_SI5351_PLLRESET: else if(select==MENU_DEBUG_OSC_SI5351_PLLRESET) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.debug_si5351a_pllreset, 0, 3, 0, 1); switch(ts.debug_si5351a_pllreset) { case 0: txt_ptr = " Always"; break; case 1: txt_ptr = " Divider"; break; case 2: txt_ptr = "IQ Divider"; break; case 3: txt_ptr = " Never"; break; } // break; } #ifdef USE_HMC1023 // case MENU_DEBUG_HMC1023_COARSE: else if(select==MENU_DEBUG_HMC1023_COARSE) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &hmc1023.coarse,0,8,0,1); if (var_change) { hmc1023_set_coarse(hmc1023.coarse); } snprintf(options,32," %2d",hmc1023.coarse); // break; } // case MENU_DEBUG_HMC1023_FINE: else if(select==MENU_DEBUG_HMC1023_FINE) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &hmc1023.fine,0,11,0,1); if (var_change) { hmc1023_set_fine(hmc1023.fine); } snprintf(options,32," %2d",hmc1023.fine); // break; } // case MENU_DEBUG_HMC1023_OPAMP: else if(select==MENU_DEBUG_HMC1023_OPAMP) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &hmc1023.opamp,0,3,0,1); if (var_change) { hmc1023_set_bias_opamp(hmc1023.opamp); } snprintf(options,32," %2d",hmc1023.opamp); // break; } // case MENU_DEBUG_HMC1023_DRVR: else if(select==MENU_DEBUG_HMC1023_DRVR) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &hmc1023.drvr,0,3,0,1); if (var_change) { hmc1023_set_bias_drvr(hmc1023.drvr); } snprintf(options,32," %2d",hmc1023.drvr); // break; } // case MENU_DEBUG_HMC1023_GAIN: else if(select==MENU_DEBUG_HMC1023_GAIN) { var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &hmc1023.gain,0,options,&clr); if (var_change) { hmc1023_set_gain(hmc1023.gain); } // break; } // case MENU_DEBUG_HMC1023_BYPASS: else if(select==MENU_DEBUG_HMC1023_BYPASS) { var_change = UiDriverMenuItemChangeEnableOnOffBool(var, mode, &hmc1023.bypass,0,options,&clr); if (var_change) { hmc1023_set_bypass(hmc1023.bypass); } // break; } #endif //Menu CONTEST // case MENU_DEBUG_CONTEST: else if(select==MENU_DEBUG_CONTEST) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.contest_enable, 0, 1, 0, 1); switch(ts.contest_enable) { case 0: txt_ptr = "OFF"; break; case 1: txt_ptr = " ON"; break; } // break; } else if(select==MENU_DEBUG_CQCOLOR) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.cq_colour, 0, SPEC_MAX_COLOUR, SPEC_BLUE3, 1 ); UiMenu_MapColors(ts.cq_colour,options,&clr); // break; } // case CONFIG_SMETER_ATTACK: else if(select==CONFIG_SMETER_ATTACK) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &sm.config.alphaSplit.AttackAlpha, SMETER_ALPHA_MIN, SMETER_ALPHA_MAX, SMETER_ALPHA_ATTACK_DEFAULT,1); snprintf(options,32," %d",sm.config.alphaSplit.AttackAlpha); // break; } // case CONFIG_SMETER_DECAY: else if(select==CONFIG_SMETER_DECAY) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &sm.config.alphaSplit.DecayAlpha, SMETER_ALPHA_MIN, SMETER_ALPHA_MAX, SMETER_ALPHA_DECAY_DEFAULT,1); snprintf(options,32," %d",sm.config.alphaSplit.DecayAlpha); // break; } // case CONFIG_VSWR_PROTECTION_THRESHOLD: else if(select==CONFIG_VSWR_PROTECTION_THRESHOLD) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.debug_vswr_protection_threshold, 1, 10, 1, 1); if (ts.debug_vswr_protection_threshold < 2) { txt_ptr = "OFF"; } else { snprintf(options,32," %d",ts.debug_vswr_protection_threshold); } // break; } #ifdef USE_FREEDV // case MENU_DEBUG_FREEDV_MODE: else if(select==MENU_DEBUG_FREEDV_MODE) { temp_var_u8 = freedv_conf.mode; var_change = UiDriverMenuItemChangeUInt8(var, mode, &temp_var_u8, 0, freedv_modes_num-1, 0, 1); if (var_change) { if (FreeDV_SetMode(temp_var_u8, false) == false) { clr = Red; } } txt_ptr = freedv_modes[freedv_conf.mode].name; // break; } // case MENU_DEBUG_FREEDV_SQL_THRESHOLD: else if(select==MENU_DEBUG_FREEDV_SQL_THRESHOLD) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &freedv_conf.squelch_snr_thresh, FDV_SQUELCH_OFF, FDV_SQUELCH_MAX, FDV_SQUELCH_DEFAULT, 1); if (var_change) { FreeDV_Squelch_Update(&freedv_conf); } if (FreeDV_Is_Squelch_Enable(&freedv_conf)) { snprintf(options,32," %ld",FreeDV_Get_Squelch_SNR(&freedv_conf)); } else { txt_ptr = "OFF"; } // break; } #endif // case MENU_DEBUG_SMOOTH_DYN_TUNE: else if(select==MENU_DEBUG_SMOOTH_DYN_TUNE) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags1,0,options,&clr, EXPFLAGS1_SMOOTH_DYNAMIC_TUNE); clr = White; // break; } // case MENU_DEBUG_CAL_LO_TX_SUPR_0: else if(select==MENU_DEBUG_CAL_LO_TX_SUPR_0) { // if ((!ts.lotx_dacs_present) || (ts.band_lo_tx_supr == 13)) if (!ts.lotx_dacs_present) { clr = Orange; txt_ptr = "N/A"; // break; } if (ts.lotx_dacs_present) //(ts.txrx_mode == TRX_MODE_TX) // only allow adjustment if in right mode { var_change = UiDriverMenuItemChangeInt16(var, mode, &ts.cal_lo_tx_supr0[ts.band_lo_tx_supr], MIN_LO_TX_SUPR_BALANCE, MAX_LO_TX_SUPR_BALANCE, 2048, 1); } else // Orange if not in correct mode { *clr_ptr = Orange; } if (ts.cal_lo_tx_supr0[ts.band_lo_tx_supr] == 2048) { snprintf(options,32, " OFF"); } else { snprintf(options,32, "%4d", ts.cal_lo_tx_supr0[ts.band_lo_tx_supr]); } if(var_change) { LO_TX_SUPR_DAC_WriteReg(0, ts.cal_lo_tx_supr0[ts.band_lo_tx_supr]); // Set the DAC0 voltage } // break; } // case MENU_DEBUG_CAL_LO_TX_SUPR_1: else if(select==MENU_DEBUG_CAL_LO_TX_SUPR_1) { // if ((!ts.lotx_dacs_present) || (ts.band_lo_tx_supr == 13)) if (!ts.lotx_dacs_present) { clr = Orange; txt_ptr = "N/A"; // break; } if (ts.lotx_dacs_present) //(ts.txrx_mode == TRX_MODE_TX) // only allow adjustment if in right mode { var_change = UiDriverMenuItemChangeInt16(var, mode, &ts.cal_lo_tx_supr1[ts.band_lo_tx_supr], MIN_LO_TX_SUPR_BALANCE, MAX_LO_TX_SUPR_BALANCE, 2048, 1); } else // Orange if not in correct mode { *clr_ptr = Orange; } if (ts.cal_lo_tx_supr1[ts.band_lo_tx_supr] == 2048) { snprintf(options,32, " OFF"); } else { snprintf(options,32, "%4d", ts.cal_lo_tx_supr1[ts.band_lo_tx_supr]); } if(var_change) { LO_TX_SUPR_DAC_WriteReg(1, ts.cal_lo_tx_supr1[ts.band_lo_tx_supr]); // Set the DAC1 voltage } // break; } // case CONFIG_WIDE_SPEC_DEF: else if(select==CONFIG_WIDE_SPEC_DEF) { if ((ts.txrx_mode != TRX_MODE_TX) && (ts.Layout->Size.x == 320)) // only allow adjustment if in right mode { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags1,0,options,&clr, EXPFLAGS1_WIDE_SPEC_DEF); clr = White; } else { *clr_ptr = Orange; } // break; } // case MENU_NO_SHOW_BNDMEM: else if(select==MENU_NO_SHOW_BNDMEM) { if (ts.txrx_mode != TRX_MODE_TX) // only allow adjustment if in right mode { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags1,0,options,&clr, EXPFLAGS1_NO_SHOW_BNDMEM); clr = White; } else { *clr_ptr = Orange; } if(var_change) { if(ts.expflags1 & EXPFLAGS1_NO_SHOW_BNDMEM) { UiDriver_ClearMemoryLabel(); } UiDriver_DisplayMemoryLabel(); } // break; } // case CONFIG_BANDCH_JUMP_SWAP: else if(select==CONFIG_BANDCH_JUMP_SWAP) { if (ts.txrx_mode != TRX_MODE_TX) // only allow adjustment if in right mode { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags1,0,options,&clr, EXPFLAGS1_BANDCH_JUMP_SWAP); clr = White; } else { *clr_ptr = Orange; } // break; } #ifdef SDR_AMBER // case MENU_INPUT_STATE: else if(select==MENU_INPUT_STATE) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.amber_input_state, 0, 3, 0, 1); if (ts.amber_input_state == 0) { txt_ptr = " PRE"; } else if(ts.amber_input_state == 1) { txt_ptr = "NoPRE"; } else if(ts.amber_input_state == 2) { txt_ptr = "ATT12"; } else if(ts.amber_input_state == 3) { txt_ptr = "ATT24"; } if(var_change) { Board_Amber_InputStateSet(ts.amber_input_state); } // break; } #endif // case MENU_BOX_COLOUR: // screen boxes colour else if(select==MENU_BOX_COLOUR) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.box_colour, 0, SPEC_MAX_COLOUR, SPEC_BLUE, 1 ); if(var_change) { UiDriver_UpdateDisplayAfterParamChange(); } UiMenu_MapColors(ts.box_colour,options,&clr); // break; } // case MENU_TXTLINE_COLOUR: // ticker colour else if(select==MENU_TXTLINE_COLOUR) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.txtline_colour, 0, SPEC_MAX_COLOUR, SPEC_YELLOW, 1 ); if(var_change) { UiDriver_UpdateDisplayAfterParamChange(); } UiMenu_MapColors(ts.txtline_colour,options,&clr); // break; } // case CONFIG_ENC123_REVERSE: else if(select==CONFIG_ENC1_REVERSE) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags1,0,options,&clr, EXPFLAGS1_ENC1_REVERSE); clr = White; // break; } else if(select==CONFIG_ENC2_REVERSE) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags2,0,options,&clr, EXPFLAGS2_ENC2_REVERSE); clr = White; } else if(select==CONFIG_ENC3_REVERSE) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags2,0,options,&clr, EXPFLAGS2_ENC3_REVERSE); clr = White; } // case CONFIG_ENC4_REVERSE: else if(select==CONFIG_ENC4_REVERSE) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags1,0,options,&clr, EXPFLAGS1_ENC4_REVERSE); clr = White; // break; } // case MENU_CW_BEACON_INTERVAL: else if(select==MENU_CW_BEACON_INTERVAL) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.swbi, BEACON_INTERVAL_1M, BEACON_INTERVAL_15M, 1, 1); if (ts.swbi == BEACON_INTERVAL_1M) { txt_ptr = " 1"; } else if(ts.swbi == BEACON_INTERVAL_3M) { txt_ptr = " 3"; } else if(ts.swbi == BEACON_INTERVAL_5M) { txt_ptr = " 5"; } else if(ts.swbi == BEACON_INTERVAL_10M) { txt_ptr = "10"; } else if(ts.swbi == BEACON_INTERVAL_15M) { txt_ptr = "15"; } if (var_change) { if (ts.swbi == BEACON_INTERVAL_1M) { ts.cw_beacon_interval = 6000; } else if(ts.swbi == BEACON_INTERVAL_3M) { ts.cw_beacon_interval = 18000; } else if(ts.swbi == BEACON_INTERVAL_5M) { ts.cw_beacon_interval = 30000; } else if(ts.swbi == BEACON_INTERVAL_10M) { ts.cw_beacon_interval = 60000; } else if(ts.swbi == BEACON_INTERVAL_15M) { ts.cw_beacon_interval = 90000; } } // break; } // case MENU_CW_MACRO_INTERVAL: else if(select==MENU_CW_MACRO_INTERVAL) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.keyer_cycled_interval, 1, 5, 3, 1 ); if (ts.keyer_cycled_interval == 1) { txt_ptr = "1"; } else if(ts.keyer_cycled_interval == 2) { txt_ptr = "2"; } else if(ts.keyer_cycled_interval == 3) { txt_ptr = "3"; } else if(ts.keyer_cycled_interval == 4) { txt_ptr = "4"; } else if(ts.keyer_cycled_interval == 5) { txt_ptr = "5"; } // break; } // case MENU_DEBUG_SHOW_GREETING: else if(select==MENU_DEBUG_SHOW_GREETING) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags1,0,options,&clr, EXPFLAGS1_SHOW_GREETING); if (ts.txrx_mode == TRX_MODE_RX) // only allow adjustment if in right mode { clr = White; } else { *clr_ptr = Orange; } // break; } // case MENU_PEAK_IND_TUNE: else if(select==MENU_PEAK_IND_TUNE) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.peak_ind_tune, 0, 24, 0, 1); clr = White; if(ts.peak_ind_tune == 0) { txt_ptr = " OFF";; } else { // snprintf(options,32, " %3.2f", ts.peak_ind_tune * 0.25); snprintf(options,32, " %4u", ts.peak_ind_tune * 250); } // break; } // case MENU_CLEAR_PAN_ON_TX: else if(select==MENU_CLEAR_PAN_ON_TX) { if (ts.txrx_mode != TRX_MODE_TX) // only allow adjustment if in right mode { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags1,0,options,&clr, EXPFLAGS1_CLEAR_PAN_ON_TX); clr = White; } else { *clr_ptr = Orange; } // break; } // case MENU_SMETER_AM_NOT_LO: else if(select==MENU_SMETER_AM_NOT_LO) { if (ts.txrx_mode != TRX_MODE_TX) // only allow adjustment if in right mode { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags1,0,options,&clr, EXPFLAGS1_SMETER_AM_NOT_LO); clr = White; } else { *clr_ptr = Orange; } // break; } // case MENU_CW_FAST_MACRO_1_2: else if(select==MENU_CW_FAST_MACRO_1_2) { if (ts.txrx_mode != TRX_MODE_TX) // only allow adjustment if in right mode { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags1,0,options,&clr, EXPFLAGS1_FAST_MACRO_1_2); clr = White; } else { *clr_ptr = Orange; } // break; } // case MENU_DEBUG_CLEAN_TX_CW_RTTY_BPSK: else if(select==MENU_DEBUG_CLEAN_TX_CW_RTTY_BPSK) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags1,0,options,&clr, EXPFLAGS1_CLEAR_TX_CW_RTTY_BPSK); if (ts.txrx_mode == TRX_MODE_RX) // only allow adjustment if in right mode { clr = White; } else { *clr_ptr = Orange; } // break; } // case MENU_CW_SMOOTH: else if(select==MENU_CW_SMOOTH) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.cw_smooth, 0, 3, 1, 1); if (ts.cw_smooth == 0) { txt_ptr = " 3"; } else if(ts.cw_smooth == 1) { txt_ptr = " 5"; } else if(ts.cw_smooth == 2) { txt_ptr = " 8"; } else if(ts.cw_smooth == 3) { txt_ptr = "10"; } if (var_change) { CW_Smooth_Settings(); } // break; } // case MENU_DEBUG_CB_27MC_TX_ENABLE: else if(select==MENU_DEBUG_CB_27MC_TX_ENABLE) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags1,0,options,&clr, EXPFLAGS1_CB_27MC_TX_ENABLE); if (ts.txrx_mode == TRX_MODE_RX) // only allow adjustment if in right mode { clr = White; } else { clr = Orange; } // break; } // case MENU_DEBUG_CB_26MC_TX_ENABLE: else if(select==MENU_DEBUG_CB_26MC_TX_ENABLE) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags1,0,options,&clr, EXPFLAGS1_CB_26MC_TX_ENABLE); if (ts.txrx_mode == TRX_MODE_RX) // only allow adjustment if in right mode { clr = White; } else { clr = Orange; } // break; } // case MENU_DEBUG_CB_12W_SSB_TX_ENABLE: else if(select==MENU_DEBUG_CB_12W_SSB_TX_ENABLE) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags1,0,options,&clr, EXPFLAGS1_CB_12W_SSB_TX_ENABLE); if (ts.txrx_mode == TRX_MODE_RX) // only allow adjustment if in right mode { clr = White; } else { clr = Orange; } // break; } // case MENU_DEBUG_CB_10W_TX_ENABLE: else if(select==MENU_DEBUG_CB_10W_TX_ENABLE) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags1,0,options,&clr, EXPFLAGS1_CB_10W_TX_ENABLE); if (ts.txrx_mode == TRX_MODE_RX) // only allow adjustment if in right mode { clr = White; } else { clr = Orange; } // break; } // case MENU_DEBUG_MEM_BW_MOD_BAND: else if(select==MENU_DEBUG_MEM_BW_MOD_BAND) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags2,0,options,&clr, EXPFLAGS2_TEMP_MEM_BW_MOD_BAND); if (ts.txrx_mode == TRX_MODE_RX) // only allow adjustment if in right mode { clr = White; } else { clr = Orange; } // break; } #ifdef SDR_AMBER else if(select==MENU_DEBUG_ILLUM_BUTT) { if(!ts.amber_io8_present) { txt_ptr = "N/A"; clr = Orange; } else { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags2,0,options,&clr, EXPFLAGS2_ILLUM_BUTT); if (var_change) { Board_IllumButt(); } clr = White; } } else if(select==MENU_DEBUG_BPF_OPTION) { if(!ts.amber_io8_present) { txt_ptr = "N/A"; clr = Orange; } else { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags2,0,options,&clr, EXPFLAGS2_3_ADD_BPF); clr = White; } } else if(select==MENU_DEBUG_XVTR_OFF_PA) { if(!ts.amber_io8_present) { txt_ptr = "N/A"; clr = Orange; } else if (ts.txrx_mode == TRX_MODE_TX) // only allow adjustment if in right mode { clr = Orange; } else { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags2,0,options,&clr, EXPFLAGS2_XVTR_OFF_PA); clr = White; } if (var_change) { if ((ts.expflags2 & EXPFLAGS2_XVTR_OFF_PA) && (ts.xverter_mode & 0xf)) // Option is ON & XVTR mode is ON { ts.amber_io8_state = ts.amber_io8_state & ~128; // reset bit } else { ts.amber_io8_state = ts.amber_io8_state | 128; // set bit } Board_AmberIOx8_Write(ts.amber_io8_state); } } else if(select==MENU_DEBUG_BANDCODE) { if(!ts.amber_io8_present) { txt_ptr = "N/A"; } else { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.amber_pa_bandcode_mode, 0, 3, 1, 1); if (ts.amber_pa_bandcode_mode == 0) {txt_ptr = " OFF";} else if(ts.amber_pa_bandcode_mode == 1) {txt_ptr = " 4LPF direct";} else if(ts.amber_pa_bandcode_mode == 2) {txt_ptr = " 4LPF code";} else if(ts.amber_pa_bandcode_mode == 3) {txt_ptr = "Yaesu FT-891";} if (var_change) { RadioManagement_Set_PA_Bandcode(ts.tune_freq); } } } else if(select==MENU_DEBUG_ALT_PWR_CTRL) { if(!ts.amber_dac_pwr_tx_present) { clr = Orange; txt_ptr = "N/A"; } else { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags2,0,options,&clr, EXPFLAGS2_ALT_PWR_CTRL); clr = White; if(ts.expflags2 & EXPFLAGS2_ALT_PWR_CTRL) { // ts.expflags2 = ts.expflags2 | EXPFLAGS2_ALT_PWR_CTRL; txt_ptr = " ON"; // UiDriver_RefreshPowerLevel(ts.band_effective, ts.power_level); } else { txt_ptr = "OFF"; ts.amber_dac_pwr_tx_state = DAC_5W; ALT_RWP_CTRL_DAC_WriteReg(DAC_5W); // Set the DAC voltage // UiDriver_RefreshPowerLevel(ts.band_effective, ts.power_level); } } } else if(select==MENU_DEBUG_ALT_PWR_CTRL_VOL) { if (!ts.amber_dac_pwr_tx_present) { clr = Orange; txt_ptr = "N/A"; } else { var_change = UiDriverMenuItemChangeInt16(var, mode, &ts.amber_dac_pwr_tx_state, 0, 4096, 2048, 10); clr = White; if (ts.amber_dac_pwr_tx_state == 2048) { snprintf(options,32, "HALF"); } else { snprintf(options,32, "%4d", ts.amber_dac_pwr_tx_state); } if(var_change) { ALT_RWP_CTRL_DAC_WriteReg(ts.amber_dac_pwr_tx_state); // Set the DAC voltage } } } #endif else if(select==MENU_DEBUG_DISABLE_TP) // Disable touchscreen actions { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags2,0,options,&clr, EXPFLAGS2_DISABLE_TP); if (ts.tp->present) // only allow adjustment if touchscreen are present { clr = White; } else { *clr_ptr = Orange; } if (var_change) { if(ts.expflags2 & EXPFLAGS2_DISABLE_TP) { ts.disabled_tp = true; } else { ts.disabled_tp = false; } } } else if(select==MENU_DEBUG_FMENUS_SEL) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags2,0,options,&clr, EXPFLAGS2_FMENUS_SELECT); clr = White; if(ts.expflags2 & EXPFLAGS2_FMENUS_SELECT) { txt_ptr = " Menu"; } else { txt_ptr = "Carousel"; } } else if(select==MENU_DEBUG_IMPROV_IQ_ADJ) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags2,0,options,&clr, EXPFLAGS2_IMPROV_IQ_ADJ); } else if(select==MENU_DEBUG_F6_IND_SEL) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags2,0,options,&clr, EXPFLAGS2_AMBER_4INCH_F6_IND); clr = White; if(ts.expflags2 & EXPFLAGS2_AMBER_4INCH_F6_IND) { txt_ptr = " AT"; } else { txt_ptr = "Soft"; } if (var_change) { UiDriver_CreateFunctionButtons(false); } } else if(select==MENU_DEBUG_F7_IND_SEL) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags2,0,options,&clr, EXPFLAGS2_AMBER_4INCH_F7_IND); clr = White; if(ts.expflags2 & EXPFLAGS2_AMBER_4INCH_F7_IND) { txt_ptr = "POWER"; } else { txt_ptr = " AT"; } if (var_change) { UiDriver_CreateFunctionButtons(false); } } else if(select==CONFIG_TX_REVERB_GAIN) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.reverb_gain, 0, 100, 0, 1 ); if(var_change) { AudioReverb_SetWet(); } snprintf(options, 32, " %u%%", ts.reverb_gain); if(ts.reverb_gain == 0) { txt_ptr = " OFF"; } } else if(select==CONFIG_TX_REVERB_DELAY) { var_change = UiDriverMenuItemChangeUInt8(var, mode, &ts.reverb_delay, 25, 100, 25, 1 ); if(var_change) { AudioReverb_SetDelay(); } snprintf(options, 32, " %u%%", ts.reverb_delay); } else if(select==CONFIG_TX_EQ0 || select==CONFIG_TX_EQ1 || select==CONFIG_TX_EQ2 || select==CONFIG_TX_EQ3 || select==CONFIG_TX_EQ4) { uint8_t n = 0; switch (select) { case CONFIG_TX_EQ0: n = 0; break; case CONFIG_TX_EQ1: n = 1; break; case CONFIG_TX_EQ2: n = 2; break; case CONFIG_TX_EQ3: n = 3; break; case CONFIG_TX_EQ4: n = 4; break; }; var_change = UiDriverMenuItemChangeInt(var, mode, &ts.dsp.tx_eq_gain[n], MIN_TX_EQ, MAX_TX_EQ, 0, 1 ); if(var_change) { AudioDriver_SetProcessingChain(ts.dmod_mode, false); } snprintf(options, 32, " %ddb", ts.dsp.tx_eq_gain[n]); } else if(select==MENU_DEBUG_BEEP_GEN) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags2,0,options,&clr, EXPFLAGS2_BEEP_GEN); clr = White; if(ts.expflags2 & EXPFLAGS2_BEEP_GEN) { txt_ptr = " ON"; } else { txt_ptr = "OFF"; } } else if(select==MENU_DEBUG_BAND_OFF_160M) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags3,0,options,&clr, EXPFLAGS3_BAND_OFF_160M); clr = White; if(ts.expflags3 & EXPFLAGS3_BAND_OFF_160M) { txt_ptr = "YES"; } else { txt_ptr = " NO"; } } else if(select==MENU_DEBUG_BAND_OFF_80M) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags3,0,options,&clr, EXPFLAGS3_BAND_OFF_80M); clr = White; if(ts.expflags3 & EXPFLAGS3_BAND_OFF_80M) { txt_ptr = "YES"; } else { txt_ptr = " NO"; } } else if(select==MENU_DEBUG_BAND_OFF_60M) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags3,0,options,&clr, EXPFLAGS3_BAND_OFF_60M); clr = White; if(ts.expflags3 & EXPFLAGS3_BAND_OFF_60M) { txt_ptr = "YES"; } else { txt_ptr = " NO"; } } else if(select==MENU_DEBUG_BAND_OFF_40M) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags3,0,options,&clr, EXPFLAGS3_BAND_OFF_40M); clr = White; if(ts.expflags3 & EXPFLAGS3_BAND_OFF_40M) { txt_ptr = "YES"; } else { txt_ptr = " NO"; } } else if(select==MENU_DEBUG_BAND_OFF_30M) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags3,0,options,&clr, EXPFLAGS3_BAND_OFF_30M); clr = White; if(ts.expflags3 & EXPFLAGS3_BAND_OFF_30M) { txt_ptr = "YES"; } else { txt_ptr = " NO"; } } else if(select==MENU_DEBUG_BAND_OFF_20M) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags3,0,options,&clr, EXPFLAGS3_BAND_OFF_20M); clr = White; if(ts.expflags3 & EXPFLAGS3_BAND_OFF_20M) { txt_ptr = "YES"; } else { txt_ptr = " NO"; } } else if(select==MENU_DEBUG_BAND_OFF_17M) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags3,0,options,&clr, EXPFLAGS3_BAND_OFF_17M); clr = White; if(ts.expflags3 & EXPFLAGS3_BAND_OFF_17M) { txt_ptr = "YES"; } else { txt_ptr = " NO"; } } else if(select==MENU_DEBUG_BAND_OFF_15M) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags3,0,options,&clr, EXPFLAGS3_BAND_OFF_15M); clr = White; if(ts.expflags3 & EXPFLAGS3_BAND_OFF_15M) { txt_ptr = "YES"; } else { txt_ptr = " NO"; } } else if(select==MENU_DEBUG_BAND_OFF_12M) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags3,0,options,&clr, EXPFLAGS3_BAND_OFF_12M); clr = White; if(ts.expflags3 & EXPFLAGS3_BAND_OFF_12M) { txt_ptr = "YES"; } else { txt_ptr = " NO"; } } else if(select==MENU_DEBUG_BAND_OFF_10M) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags3,0,options,&clr, EXPFLAGS3_BAND_OFF_10M); clr = White; if(ts.expflags3 & EXPFLAGS3_BAND_OFF_10M) { txt_ptr = "YES"; } else { txt_ptr = " NO"; } } else if(select==MENU_DEBUG_BAND_OFF_6M) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags3,0,options,&clr, EXPFLAGS3_BAND_OFF_6M); clr = White; if(ts.expflags3 & EXPFLAGS3_BAND_OFF_6M) { txt_ptr = "YES"; } else { txt_ptr = " NO"; } } else if(select==MENU_DEBUG_REDUCE_POWER_ON_LOW_BANDS_MORE) { var_change = UiDriverMenuItemChangeEnableOnOffFlag(var, mode, &ts.expflags3,0,options,&clr, EXPFLAGS3_LOW_BAND_BIAS_REDUCE_MORE); } // default: // Move to this location if we get to the bottom of the table! else { txt_ptr = "ERROR!"; // break; } *txt_ptr_ptr = txt_ptr; *clr_ptr = clr; }