/* Copyright 2023 Dual Tachyon * https://github.com/DualTachyon * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "assert.h" #ifdef ENABLE_FLASHLIGHT #include "app/flashlight.h" #endif #include #include #include #include "mdc1200.h" #include "app/action.h" #ifdef ENABLE_AIRCOPY #include "app/aircopy.h" #endif #include "app/app.h" #include "app/chFrScanner.h" #include "app/dtmf.h" #include "driver/uart.h" #ifdef ENABLE_FMRADIO #include "app/fm.h" #endif #include "app/generic.h" #include "app/main.h" #include "app/menu.h" #include "app/scanner.h" #ifdef ENABLE_UART #include "app/uart.h" #endif #include "ARMCM0.h" #include "audio.h" #include "board.h" #include "bsp/dp32g030/gpio.h" #include "driver/backlight.h" #ifdef ENABLE_FMRADIO #include "driver/bk1080.h" #endif #include "driver/bk4819.h" #include "driver/gpio.h" #include "driver/keyboard.h" #include "driver/st7565.h" #include "driver/system.h" #include "am_fix.h" #include "dtmf.h" //#include "external/printf/printf.h" #include "frequencies.h" #include "functions.h" #include "helper/battery.h" #include "misc.h" #include "radio.h" #include "settings.h" #if defined(ENABLE_OVERLAY) #include "sram-overlay.h" #endif #include "ui/battery.h" #include "ui/inputbox.h" #include "ui/main.h" #include "ui/menu.h" #include "ui/status.h" #include "ui/ui.h" static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld); void (*ProcessKeysFunctions[])(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld) = { [DISPLAY_MAIN] = &MAIN_ProcessKeys, [DISPLAY_MENU] = &MENU_ProcessKeys, [DISPLAY_SCANNER] = &SCANNER_ProcessKeys, #ifdef ENABLE_FMRADIO [DISPLAY_FM] = &FM_ProcessKeys, #endif #ifdef ENABLE_AIRCOPY [DISPLAY_AIRCOPY] = &AIRCOPY_ProcessKeys, #endif }; static_assert(ARRAY_SIZE(ProcessKeysFunctions) == DISPLAY_N_ELEM); static void CheckForIncoming(void) { if (!g_SquelchLost) return; // squelch is closed // squelch is open if (gScanStateDir == SCAN_OFF) { // not RF scanning if (gEeprom.DUAL_WATCH == DUAL_WATCH_OFF) { // dual watch is disabled #ifdef ENABLE_NOAA if (gIsNoaaMode) { gNOAA_Countdown_10ms = NOAA_countdown_3_10ms; gScheduleNOAA = false; } #endif if (gCurrentFunction != FUNCTION_INCOMING) { FUNCTION_Select(FUNCTION_INCOMING); //gUpdateDisplay = true; } return; } // dual watch is enabled and we're RX'ing a signal if (gRxReceptionMode != RX_MODE_NONE) { if (gCurrentFunction != FUNCTION_INCOMING) { FUNCTION_Select(FUNCTION_INCOMING); //gUpdateDisplay = true; } return; } gDualWatchCountdown_10ms = dual_watch_count_after_rx_10ms; gScheduleDualWatch = false; // let the user see DW is not active gDualWatchActive = false; gUpdateStatus = true; } else { // RF scanning if (gRxReceptionMode != RX_MODE_NONE) { if (gCurrentFunction != FUNCTION_INCOMING) { FUNCTION_Select(FUNCTION_INCOMING); //gUpdateDisplay = true; } return; } gScanPauseDelayIn_10ms = scan_pause_delay_in_3_10ms; gScheduleScanListen = false; } gRxReceptionMode = RX_MODE_DETECTED; if (gCurrentFunction != FUNCTION_INCOMING) { FUNCTION_Select(FUNCTION_INCOMING); //gUpdateDisplay = true; } } static void HandleIncoming(void) { if (!g_SquelchLost) { // squelch is closed #ifdef ENABLE_DTMF_CALLING if (gDTMF_RX_index > 0) DTMF_clear_RX(); #endif if (gCurrentFunction != FUNCTION_FOREGROUND) { FUNCTION_Select(FUNCTION_FOREGROUND); gUpdateDisplay = true; } return; } bool bFlag = (gScanStateDir == SCAN_OFF && gCurrentCodeType == CODE_TYPE_OFF); #ifdef ENABLE_NOAA if (IS_NOAA_CHANNEL(gRxVfo->CHANNEL_SAVE) && gNOAACountdown_10ms > 0) { gNOAACountdown_10ms = 0; bFlag = true; } #endif if (g_CTCSS_Lost && gCurrentCodeType == CODE_TYPE_CONTINUOUS_TONE) { bFlag = true; gFoundCTCSS = false; } if (g_CDCSS_Lost && gCDCSSCodeType == CDCSS_POSITIVE_CODE && (gCurrentCodeType == CODE_TYPE_DIGITAL || gCurrentCodeType == CODE_TYPE_REVERSE_DIGITAL)) { gFoundCDCSS = false; } else if (!bFlag) return; #ifdef ENABLE_DTMF_CALLING if (gScanStateDir == SCAN_OFF && (gRxVfo->DTMF_DECODING_ENABLE || gSetting_KILLED)) { // DTMF DCD is enabled DTMF_HandleRequest(); if (gDTMF_CallState == DTMF_CALL_STATE_NONE) { if (gRxReceptionMode != RX_MODE_DETECTED) { return; } gDualWatchCountdown_10ms = dual_watch_count_after_1_10ms; gScheduleDualWatch = false; gRxReceptionMode = RX_MODE_LISTENING; // let the user see DW is not active gDualWatchActive = false; gUpdateStatus = true; gUpdateDisplay = true; return; } } #endif APP_StartListening(gMonitor ? FUNCTION_MONITOR : FUNCTION_RECEIVE); } static void HandleReceive(void) { #define END_OF_RX_MODE_SKIP 0 #define END_OF_RX_MODE_END 1 #define END_OF_RX_MODE_TTE 2 uint8_t Mode = END_OF_RX_MODE_SKIP; if (gFlagTailNoteEliminationComplete) { Mode = END_OF_RX_MODE_END; goto Skip; } if (gScanStateDir != SCAN_OFF && IS_FREQ_CHANNEL(gNextMrChannel)) { // we are scanning in the frequency mode if (g_SquelchLost) return; Mode = END_OF_RX_MODE_END; goto Skip; } switch (gCurrentCodeType) { default: case CODE_TYPE_OFF: break; case CODE_TYPE_CONTINUOUS_TONE: if (gFoundCTCSS && gFoundCTCSSCountdown_10ms == 0) { gFoundCTCSS = false; gFoundCDCSS = false; Mode = END_OF_RX_MODE_END; goto Skip; } break; case CODE_TYPE_DIGITAL: case CODE_TYPE_REVERSE_DIGITAL: if (gFoundCDCSS && gFoundCDCSSCountdown_10ms == 0) { gFoundCTCSS = false; gFoundCDCSS = false; Mode = END_OF_RX_MODE_END; goto Skip; } break; } if (g_SquelchLost) { #ifdef ENABLE_NOAA if (!gEndOfRxDetectedMaybe && !IS_NOAA_CHANNEL(gRxVfo->CHANNEL_SAVE)) #else if (!gEndOfRxDetectedMaybe) #endif { switch (gCurrentCodeType) { case CODE_TYPE_OFF: if (gEeprom.SQUELCH_LEVEL) { if (g_CxCSS_TAIL_Found) { Mode = END_OF_RX_MODE_TTE; g_CxCSS_TAIL_Found = false; } } break; case CODE_TYPE_CONTINUOUS_TONE: if (g_CTCSS_Lost) { gFoundCTCSS = false; } else if (!gFoundCTCSS) { gFoundCTCSS = true; gFoundCTCSSCountdown_10ms = 100; // 1 sec } if (g_CxCSS_TAIL_Found) { Mode = END_OF_RX_MODE_TTE; g_CxCSS_TAIL_Found = false; } break; case CODE_TYPE_DIGITAL: case CODE_TYPE_REVERSE_DIGITAL: if (g_CDCSS_Lost && gCDCSSCodeType == CDCSS_POSITIVE_CODE) { gFoundCDCSS = false; } else if (!gFoundCDCSS) { gFoundCDCSS = true; gFoundCDCSSCountdown_10ms = 100; // 1 sec } if (g_CxCSS_TAIL_Found) { if (BK4819_GetCTCType() == 1) Mode = END_OF_RX_MODE_TTE; g_CxCSS_TAIL_Found = false; } break; } } } else Mode = END_OF_RX_MODE_END; if (!gEndOfRxDetectedMaybe && Mode == END_OF_RX_MODE_SKIP && gNextTimeslice40ms && gEeprom.TAIL_TONE_ELIMINATION && (gCurrentCodeType == CODE_TYPE_DIGITAL || gCurrentCodeType == CODE_TYPE_REVERSE_DIGITAL) && BK4819_GetCTCType() == 1) Mode = END_OF_RX_MODE_TTE; else gNextTimeslice40ms = false; Skip: switch (Mode) { case END_OF_RX_MODE_SKIP: break; case END_OF_RX_MODE_END: RADIO_SetupRegisters(true); #ifdef ENABLE_NOAA if (IS_NOAA_CHANNEL(gRxVfo->CHANNEL_SAVE)) gNOAACountdown_10ms = 300; // 3 sec #endif gUpdateDisplay = true; if (gScanStateDir != SCAN_OFF) { switch (gEeprom.SCAN_RESUME_MODE) { case SCAN_RESUME_TO: break; case SCAN_RESUME_CO: gScanPauseDelayIn_10ms = scan_pause_delay_in_7_10ms; gScheduleScanListen = false; break; case SCAN_RESUME_SE: CHFRSCANNER_Stop(); break; } } break; case END_OF_RX_MODE_TTE: if (gEeprom.TAIL_TONE_ELIMINATION) { AUDIO_AudioPathOff(); gTailNoteEliminationCountdown_10ms = 20; gFlagTailNoteEliminationComplete = false; gEndOfRxDetectedMaybe = true; gEnableSpeaker = false; } break; } } static void HandlePowerSave() { if (!gRxIdleMode) { CheckForIncoming(); } } static void (*HandleFunction_fn_table[])(void) = { [FUNCTION_FOREGROUND] = &CheckForIncoming, [FUNCTION_TRANSMIT] = &FUNCTION_NOP, [FUNCTION_MONITOR] = &FUNCTION_NOP, [FUNCTION_INCOMING] = &HandleIncoming, [FUNCTION_RECEIVE] = &HandleReceive, [FUNCTION_POWER_SAVE] = &HandlePowerSave, [FUNCTION_BAND_SCOPE] = &FUNCTION_NOP, }; static_assert(ARRAY_SIZE(HandleFunction_fn_table) == FUNCTION_N_ELEM); static void HandleFunction(void) { HandleFunction_fn_table[gCurrentFunction](); } void APP_StartListening(FUNCTION_Type_t function){ const unsigned int vfo = gEeprom.RX_VFO; // const unsigned int chan = gRxVfo->CHANNEL_SAVE; #ifdef ENABLE_DTMF_CALLING if (gSetting_KILLED) return; #endif #ifdef ENABLE_FMRADIO if (gFmRadioMode) BK1080_Init(0, false); #endif // clear the other vfo's rssi level (to hide the antenna symbol) gVFO_RSSI_bar_level[!vfo] = 0; AUDIO_AudioPathOn(); gEnableSpeaker = true; BACKLIGHT_TurnOn(); if (gScanStateDir != SCAN_OFF) CHFRSCANNER_Found(); #ifdef ENABLE_NOAA if (IS_NOAA_CHANNEL(gRxVfo->CHANNEL_SAVE) && gIsNoaaMode) { gRxVfo->CHANNEL_SAVE = gNoaaChannel + NOAA_CHANNEL_FIRST; gRxVfo->pRX->Frequency = NoaaFrequencyTable[gNoaaChannel]; gRxVfo->pTX->Frequency = NoaaFrequencyTable[gNoaaChannel]; gEeprom.ScreenChannel[vfo] = gRxVfo->CHANNEL_SAVE; gNOAA_Countdown_10ms = 500; // 5 sec gScheduleNOAA = false; } #endif if (gScanStateDir == SCAN_OFF && gEeprom.DUAL_WATCH != DUAL_WATCH_OFF) { // not scanning, dual watch is enabled gDualWatchCountdown_10ms = dual_watch_count_after_2_10ms; gScheduleDualWatch = false; // when crossband is active only the main VFO should be used for TX if(gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF) gRxVfoIsActive = true; // let the user see DW is not active gDualWatchActive = false; gUpdateStatus = true; } BK4819_WriteRegister(BK4819_REG_48, (11u << 12) | // ??? .. 0 to 15, doesn't seem to make any difference ( 0u << 10) | // AF Rx Gain-1 (gEeprom.VOLUME_GAIN << 4) | // AF Rx Gain-2 (gEeprom.DAC_GAIN << 0)); // AF DAC Gain (after Gain-1 and Gain-2) #ifdef ENABLE_VOICE if (gVoiceWriteIndex == 0) // AM/FM RX mode will be set when the voice has finished #endif RADIO_SetModulation(gRxVfo->Modulation); // no need, set it now FUNCTION_Select(function); #ifdef ENABLE_FMRADIO if (function == FUNCTION_MONITOR || gFmRadioMode) #else if (function == FUNCTION_MONITOR) #endif { // squelch is disabled if (gScreenToDisplay != DISPLAY_MENU) // 1of11 .. don't close the menu GUI_SelectNextDisplay(DISPLAY_MAIN); } else gUpdateDisplay = true; gUpdateStatus = true; } uint32_t APP_SetFreqByStepAndLimits(VFO_Info_t *pInfo, int8_t direction, uint32_t lower, uint32_t upper) { uint32_t Frequency = FREQUENCY_RoundToStep(pInfo->freq_config_RX.Frequency + (direction * pInfo->StepFrequency), pInfo->StepFrequency); if (Frequency >= upper) Frequency = lower; else if (Frequency < lower) Frequency = FREQUENCY_RoundToStep(upper - pInfo->StepFrequency, pInfo->StepFrequency); return Frequency; } uint32_t APP_SetFrequencyByStep(VFO_Info_t *pInfo, int8_t direction) { return APP_SetFreqByStepAndLimits(pInfo, direction, frequencyBandTable[pInfo->Band].lower, frequencyBandTable[pInfo->Band].upper); } #ifdef ENABLE_NOAA static void NOAA_IncreaseChannel(void) { if (++gNoaaChannel > 9) gNoaaChannel = 0; } #endif static void DualwatchAlternate(void) { #ifdef ENABLE_NOAA if (gIsNoaaMode) { if (!IS_NOAA_CHANNEL(gEeprom.ScreenChannel[0]) || !IS_NOAA_CHANNEL(gEeprom.ScreenChannel[1])) gEeprom.RX_VFO = (gEeprom.RX_VFO + 1) & 1; else gEeprom.RX_VFO = 0; gRxVfo = &gEeprom.VfoInfo[gEeprom.RX_VFO]; if (IS_NOAA_CHANNEL(gEeprom.VfoInfo[0].CHANNEL_SAVE)) NOAA_IncreaseChannel(); } else #endif { // toggle between VFO's gEeprom.RX_VFO = !gEeprom.RX_VFO; gRxVfo = &gEeprom.VfoInfo[gEeprom.RX_VFO]; if (!gDualWatchActive) { // let the user see DW is active gDualWatchActive = true; gUpdateStatus = true; } } RADIO_SetupRegisters(false); #ifdef ENABLE_NOAA gDualWatchCountdown_10ms = gIsNoaaMode ? dual_watch_count_noaa_10ms : dual_watch_count_toggle_10ms; #else gDualWatchCountdown_10ms = dual_watch_count_toggle_10ms; #endif } static void CheckRadioInterrupts(void) { if (SCANNER_IsScanning()) return; while (BK4819_ReadRegister(BK4819_REG_0C) & 1u) { // BK chip interrupt request uint16_t interrupt_status_bits; // reset the interrupt ? BK4819_WriteRegister(BK4819_REG_02, 0); // fetch the interrupt status bits interrupt_status_bits = BK4819_ReadRegister(BK4819_REG_02); // 0 = no phase shift // 1 = 120deg phase shift // 2 = 180deg phase shift // 3 = 240deg phase shift // const uint8_t ctcss_shift = BK4819_GetCTCShift(); // if (ctcss_shift > 0) // g_CTCSS_Lost = true; if (interrupt_status_bits & BK4819_REG_02_DTMF_5TONE_FOUND) { // save the RX'ed DTMF character const char c = DTMF_GetCharacter(BK4819_GetDTMF_5TONE_Code()); if (c != 0xff) { if (gCurrentFunction != FUNCTION_TRANSMIT) { if (gSetting_live_DTMF_decoder) { size_t len = strlen(gDTMF_RX_live); if (len >= (sizeof(gDTMF_RX_live) - 1)) { // make room memmove(&gDTMF_RX_live[0], &gDTMF_RX_live[1], sizeof(gDTMF_RX_live) - 1); len--; } gDTMF_RX_live[len++] = c; gDTMF_RX_live[len] = 0; gDTMF_RX_live_timeout = DTMF_RX_live_timeout_500ms; // time till we delete it gUpdateDisplay = true; } #ifdef ENABLE_DTMF_CALLING if (gRxVfo->DTMF_DECODING_ENABLE || gSetting_KILLED) { if (gDTMF_RX_index >= (sizeof(gDTMF_RX) - 1)) { // make room memmove(&gDTMF_RX[0], &gDTMF_RX[1], sizeof(gDTMF_RX) - 1); gDTMF_RX_index--; } gDTMF_RX[gDTMF_RX_index++] = c; gDTMF_RX[gDTMF_RX_index] = 0; gDTMF_RX_timeout = DTMF_RX_timeout_500ms; // time till we delete it gDTMF_RX_pending = true; SYSTEM_DelayMs(3);//fix DTMF not reply@Yurisu DTMF_HandleRequest(); } #endif } } } if (interrupt_status_bits & BK4819_REG_02_CxCSS_TAIL) g_CxCSS_TAIL_Found = true; if (interrupt_status_bits & BK4819_REG_02_CDCSS_LOST) { g_CDCSS_Lost = true; gCDCSSCodeType = BK4819_GetCDCSSCodeType(); } if (interrupt_status_bits & BK4819_REG_02_CDCSS_FOUND) g_CDCSS_Lost = false; if (interrupt_status_bits & BK4819_REG_02_CTCSS_LOST) g_CTCSS_Lost = true; if (interrupt_status_bits & BK4819_REG_02_CTCSS_FOUND) g_CTCSS_Lost = false; #ifdef ENABLE_VOX if (interrupt_status_bits & BK4819_REG_02_VOX_LOST) { g_VOX_Lost = true; gVoxPauseCountdown = 10; if (gEeprom.VOX_SWITCH) { if (gCurrentFunction == FUNCTION_POWER_SAVE && !gRxIdleMode) { gPowerSave_10ms = power_save2_10ms; gPowerSaveCountdownExpired = 0; } if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF && (gScheduleDualWatch || gDualWatchCountdown_10ms < dual_watch_count_after_vox_10ms)) { gDualWatchCountdown_10ms = dual_watch_count_after_vox_10ms; gScheduleDualWatch = false; // let the user see DW is not active gDualWatchActive = false; gUpdateStatus = true; } } } if (interrupt_status_bits & BK4819_REG_02_VOX_FOUND) { g_VOX_Lost = false; gVoxPauseCountdown = 0; } #endif if (interrupt_status_bits & BK4819_REG_02_SQUELCH_LOST) { g_SquelchLost = true; BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, true); } if (interrupt_status_bits & BK4819_REG_02_SQUELCH_FOUND) { g_SquelchLost = false; BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, false); } #ifdef ENABLE_AIRCOPY if (interrupt_status_bits & BK4819_REG_02_FSK_FIFO_ALMOST_FULL && gScreenToDisplay == DISPLAY_AIRCOPY && gAircopyState == AIRCOPY_TRANSFER && gAirCopyIsSendMode == 0) { for (unsigned int i = 0; i < 4; i++) { g_FSK_Buffer[gFSKWriteIndex++] = BK4819_ReadRegister(BK4819_REG_5F); } AIRCOPY_StorePacket(); } #endif #ifdef ENABLE_MDC1200 MDC1200_process_rx( interrupt_status_bits); #endif } } void APP_EndTransmission(void) { // back to RX mode RADIO_SendEndOfTransmission(); gFlagEndTransmission = true; if (gMonitor) { //turn the monitor back on gFlagReconfigureVfos = true; } } #ifdef ENABLE_VOX static void HandleVox(void) { #ifdef ENABLE_DTMF_CALLING if (gSetting_KILLED) return; #endif if (gVoxResumeCountdown == 0) { if (gVoxPauseCountdown) return; } else { g_VOX_Lost = false; gVoxPauseCountdown = 0; } #ifdef ENABLE_FMRADIO if (gFmRadioMode) return; #endif if (gCurrentFunction == FUNCTION_RECEIVE || gCurrentFunction == FUNCTION_MONITOR) return; if (gScanStateDir != SCAN_OFF) return; if (gVOX_NoiseDetected) { if (g_VOX_Lost) gVoxStopCountdown_10ms = vox_stop_count_down_10ms; else if (gVoxStopCountdown_10ms == 0) gVOX_NoiseDetected = false; if (gCurrentFunction == FUNCTION_TRANSMIT && !gPttIsPressed && !gVOX_NoiseDetected) { if (gFlagEndTransmission) { //if (gCurrentFunction != FUNCTION_FOREGROUND) FUNCTION_Select(FUNCTION_FOREGROUND); } else { APP_EndTransmission(); if (gEeprom.REPEATER_TAIL_TONE_ELIMINATION == 0) { //if (gCurrentFunction != FUNCTION_FOREGROUND) FUNCTION_Select(FUNCTION_FOREGROUND); } else gRTTECountdown = gEeprom.REPEATER_TAIL_TONE_ELIMINATION * 10; } gUpdateStatus = true; gUpdateDisplay = true; gFlagEndTransmission = false; } return; } if (g_VOX_Lost) { gVOX_NoiseDetected = true; if (gCurrentFunction == FUNCTION_POWER_SAVE) FUNCTION_Select(FUNCTION_FOREGROUND); if (gCurrentFunction != FUNCTION_TRANSMIT && !SerialConfigInProgress()) { #ifdef ENABLE_DTMF_CALLING gDTMF_ReplyState = DTMF_REPLY_NONE; #endif RADIO_PrepareTX(); gUpdateDisplay = true; } } } #endif void APP_Update(void) { #ifdef ENABLE_VOICE if (gFlagPlayQueuedVoice) { AUDIO_PlayQueuedVoice(); gFlagPlayQueuedVoice = false; } #endif if (gCurrentFunction == FUNCTION_TRANSMIT && (gTxTimeoutReached || SerialConfigInProgress())) { // transmitter timed out or must de-key gTxTimeoutReached = false; APP_EndTransmission(); AUDIO_PlayBeep(BEEP_880HZ_60MS_TRIPLE_BEEP); RADIO_SetVfoState(VFO_STATE_TIMEOUT); GUI_DisplayScreen(); } if (gReducedService) return; if (gCurrentFunction != FUNCTION_TRANSMIT) HandleFunction(); #ifdef ENABLE_FMRADIO // if (gFmRadioCountdown_500ms > 0) if (gFmRadioMode && gFmRadioCountdown_500ms > 0) // 1of11 return; #endif #ifdef ENABLE_VOICE if (!SCANNER_IsScanning() && gScanStateDir != SCAN_OFF && gScheduleScanListen && !gPttIsPressed && gVoiceWriteIndex == 0) #else if (!SCANNER_IsScanning() && gScanStateDir != SCAN_OFF && gScheduleScanListen && !gPttIsPressed) #endif { // scanning CHFRSCANNER_ContinueScanning(); } #ifdef ENABLE_NOAA #ifdef ENABLE_VOICE if (gEeprom.DUAL_WATCH == DUAL_WATCH_OFF && gIsNoaaMode && gScheduleNOAA && gVoiceWriteIndex == 0) #else if (gEeprom.DUAL_WATCH == DUAL_WATCH_OFF && gIsNoaaMode && gScheduleNOAA) #endif { NOAA_IncreaseChannel(); RADIO_SetupRegisters(false); gNOAA_Countdown_10ms = 7; // 70ms gScheduleNOAA = false; } #endif // toggle between the VFO's if dual watch is enabled if (!SCANNER_IsScanning() && gEeprom.DUAL_WATCH != DUAL_WATCH_OFF && gScheduleDualWatch && gScanStateDir == SCAN_OFF && !gPttIsPressed && gCurrentFunction != FUNCTION_POWER_SAVE #ifdef ENABLE_VOICE && gVoiceWriteIndex == 0 #endif #ifdef ENABLE_FMRADIO && !gFmRadioMode #endif #ifdef ENABLE_DTMF_CALLING && gDTMF_CallState == DTMF_CALL_STATE_NONE #endif ) { DualwatchAlternate(); // toggle between the two VFO's if (gRxVfoIsActive && gScreenToDisplay == DISPLAY_MAIN) { GUI_SelectNextDisplay(DISPLAY_MAIN); } gRxVfoIsActive = false; gScanPauseMode = false; gRxReceptionMode = RX_MODE_NONE; gScheduleDualWatch = false; } #ifdef ENABLE_FMRADIO if (gScheduleFM && gFM_ScanState != FM_SCAN_OFF && !FUNCTION_IsRx()) { // switch to FM radio mode FM_Play(); gScheduleFM = false; } #endif #ifdef ENABLE_VOX if (gEeprom.VOX_SWITCH) HandleVox(); #endif if (gSchedulePowerSave) { if (gPttIsPressed || gKeyBeingHeld || gEeprom.BATTERY_SAVE == 0 || gScanStateDir != SCAN_OFF || gCssBackgroundScan || gScreenToDisplay != DISPLAY_MAIN #ifdef ENABLE_FMRADIO || gFmRadioMode #endif #ifdef ENABLE_DTMF_CALLING || gDTMF_CallState != DTMF_CALL_STATE_NONE #endif #ifdef ENABLE_NOAA || (gIsNoaaMode && (IS_NOAA_CHANNEL(gEeprom.ScreenChannel[0]) || IS_NOAA_CHANNEL(gEeprom.ScreenChannel[1]))) #endif ) { gBatterySaveCountdown_10ms = battery_save_count_10ms; } else { FUNCTION_Select(FUNCTION_POWER_SAVE); } gSchedulePowerSave = false; } if (gPowerSaveCountdownExpired && gCurrentFunction == FUNCTION_POWER_SAVE #ifdef ENABLE_VOICE && gVoiceWriteIndex == 0 #endif ) { static bool goToSleep; // wake up, enable RX then go back to sleep if (gRxIdleMode) { BK4819_Conditional_RX_TurnOn_and_GPIO6_Enable(); #ifdef ENABLE_VOX if (gEeprom.VOX_SWITCH) BK4819_EnableVox(gEeprom.VOX1_THRESHOLD, gEeprom.VOX0_THRESHOLD); #endif if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF && gScanStateDir == SCAN_OFF && !gCssBackgroundScan) { // dual watch mode, toggle between the two VFO's DualwatchAlternate(); goToSleep = false; } FUNCTION_Init(); gPowerSave_10ms = power_save1_10ms; // come back here in a bit gRxIdleMode = false; // RX is awake } else if (gEeprom.DUAL_WATCH == DUAL_WATCH_OFF || gScanStateDir != SCAN_OFF || gCssBackgroundScan || goToSleep) { // dual watch mode off or scanning or rssi update request // go back to sleep gPowerSave_10ms = gEeprom.BATTERY_SAVE * 10; gRxIdleMode = true; goToSleep = false; BK4819_DisableVox(); BK4819_Sleep(); BK4819_ToggleGpioOut(BK4819_GPIO0_PIN28_RX_ENABLE, false); // Authentic device checked removed } else { // toggle between the two VFO's DualwatchAlternate(); gPowerSave_10ms = power_save1_10ms; goToSleep = true; } gPowerSaveCountdownExpired = false; } } // called every 10ms static void CheckKeys(void) { #ifdef ENABLE_DTMF_CALLING if(gSetting_KILLED){ return; } #endif #ifdef ENABLE_AIRCOPY if (gScreenToDisplay == DISPLAY_AIRCOPY && gAircopyState != AIRCOPY_READY){ return; } #endif // -------------------- PTT ------------------------ if (gPttIsPressed) { if (GPIO_CheckBit(&GPIOC->DATA, GPIOC_PIN_PTT) || SerialConfigInProgress()) { // PTT released or serial comms config in progress if (++gPttDebounceCounter >= 3 || SerialConfigInProgress()) // 30ms { // stop transmitting ProcessKey(KEY_PTT, false, false); gPttIsPressed = false; if (gKeyReading1 != KEY_INVALID) gPttWasReleased = true; } } else gPttDebounceCounter = 0; } else if (!GPIO_CheckBit(&GPIOC->DATA, GPIOC_PIN_PTT) && !SerialConfigInProgress()) { // PTT pressed if (++gPttDebounceCounter >= 3) // 30ms { // start transmitting boot_counter_10ms = 0; gPttDebounceCounter = 0; gPttIsPressed = true; ProcessKey(KEY_PTT, true, false); } } else gPttDebounceCounter = 0; // --------------------- OTHER KEYS ---------------------------- // scan the hardware keys KEY_Code_t Key = KEYBOARD_Poll(); if (Key != KEY_INVALID) // any key pressed boot_counter_10ms = 0; // cancel boot screen/beeps if any key pressed if (gKeyReading0 != Key) // new key pressed { if (gKeyReading0 != KEY_INVALID && Key != KEY_INVALID) ProcessKey(gKeyReading1, false, gKeyBeingHeld); // key pressed without releasing previous key gKeyReading0 = Key; gDebounceCounter = 0; return; } gDebounceCounter++; if (gDebounceCounter == key_debounce_10ms) // debounced new key pressed { if (Key == KEY_INVALID) //all non PTT keys released { if (gKeyReading1 != KEY_INVALID) // some button was pressed before { ProcessKey(gKeyReading1, false, gKeyBeingHeld); // process last button released event gKeyReading1 = KEY_INVALID; } } else // process new key pressed { gKeyReading1 = Key; ProcessKey(Key, true, false); } gKeyBeingHeld = false; return; } if (gDebounceCounter < key_repeat_delay_10ms || Key == KEY_INVALID) // the button is not held long enough for repeat yet, or not really pressed return; if (gDebounceCounter == key_repeat_delay_10ms) //initial key repeat with longer delay { if (Key != KEY_PTT) { gKeyBeingHeld = true; ProcessKey(Key, true, true); // key held event } } else //subsequent fast key repeats { if (Key == KEY_UP || Key == KEY_DOWN) // fast key repeats for up/down buttons { gKeyBeingHeld = true; if ((gDebounceCounter % key_repeat_10ms) == 0) ProcessKey(Key, true, true); // key held event } if (gDebounceCounter < 0xFFFF) return; gDebounceCounter = key_repeat_delay_10ms+1; } } void APP_TimeSlice10ms(void) { gNextTimeslice = false; gFlashLightBlinkCounter++; #ifdef ENABLE_BOOT_BEEPS if (boot_counter_10ms > 0 && (boot_counter_10ms % 25) == 0) { AUDIO_PlayBeep(BEEP_880HZ_40MS_OPTIONAL); } #endif #ifdef ENABLE_AM_FIX if (gRxVfo->Modulation == MODULATION_AM) { AM_fix_10ms(gEeprom.RX_VFO); } #endif #ifdef ENABLE_UART if (UART_IsCommandAvailable()) { __disable_irq(); UART_HandleCommand(); __enable_irq(); } #endif if (gReducedService) return; if (gCurrentFunction != FUNCTION_POWER_SAVE || !gRxIdleMode) CheckRadioInterrupts(); if (gCurrentFunction == FUNCTION_TRANSMIT) { // transmitting //#ifdef ENABLE_AUDIO_BAR if ( (gFlashLightBlinkCounter % (150 / 10)) == 0) // once every 150ms UI_DisplayAudioBar(); //#endif } if (gUpdateDisplay) { gUpdateDisplay = false; GUI_DisplayScreen(); } if (gUpdateStatus) UI_DisplayStatus(); // Skipping authentic device checks #ifdef ENABLE_FMRADIO if (gFmRadioMode && gFmRadioCountdown_500ms > 0) // 1of11 return; #endif FlashlightTimeSlice(); #ifdef ENABLE_VOX if (gVoxResumeCountdown > 0) gVoxResumeCountdown--; if (gVoxPauseCountdown > 0) gVoxPauseCountdown--; #endif if (gCurrentFunction == FUNCTION_TRANSMIT) { #ifdef ENABLE_ALARM if (gAlarmState == ALARM_STATE_TXALARM || gAlarmState == ALARM_STATE_SITE_ALARM) { uint16_t Tone; gAlarmRunningCounter++; gAlarmToneCounter++; Tone = 500 + (gAlarmToneCounter * 25); if (Tone > 1500) { Tone = 500; gAlarmToneCounter = 0; } BK4819_SetScrambleFrequencyControlWord(Tone); if (gEeprom.ALARM_MODE == ALARM_MODE_TONE && gAlarmRunningCounter == 512) { gAlarmRunningCounter = 0; if (gAlarmState == ALARM_STATE_TXALARM) { gAlarmState = ALARM_STATE_SITE_ALARM; RADIO_EnableCxCSS(); BK4819_SetupPowerAmplifier(0, 0); BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_PA_ENABLE, false); BK4819_Enable_AfDac_DiscMode_TxDsp(); BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, false); GUI_DisplayScreen(); } else { gAlarmState = ALARM_STATE_TXALARM; GUI_DisplayScreen(); BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, true); RADIO_SetTxParameters(); BK4819_TransmitTone(true, 500); SYSTEM_DelayMs(2); AUDIO_AudioPathOn(); gEnableSpeaker = true; gAlarmToneCounter = 0; } } } #endif // repeater tail tone elimination if (gRTTECountdown > 0) { if (--gRTTECountdown == 0) { //if (gCurrentFunction != FUNCTION_FOREGROUND) FUNCTION_Select(FUNCTION_FOREGROUND); gUpdateStatus = true; gUpdateDisplay = true; } } } #ifdef ENABLE_FMRADIO if (gFmRadioMode && gFM_RestoreCountdown_10ms > 0) { if (--gFM_RestoreCountdown_10ms == 0) { // switch back to FM radio mode FM_Start(); GUI_SelectNextDisplay(DISPLAY_FM); } } #endif SCANNER_TimeSlice10ms(); #ifdef ENABLE_AIRCOPY if (gScreenToDisplay == DISPLAY_AIRCOPY && gAircopyState == AIRCOPY_TRANSFER && gAirCopyIsSendMode == 1) { if (!AIRCOPY_SendMessage()) { GUI_DisplayScreen(); } } #endif CheckKeys(); } void cancelUserInputModes(void) { if (gDTMF_InputMode || gDTMF_InputBox_Index > 0) { DTMF_clear_input_box(); gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL; gRequestDisplayScreen = DISPLAY_MAIN; gUpdateDisplay = true; } if (gWasFKeyPressed || gKeyInputCountdown > 0 || gInputBoxIndex > 0) { gWasFKeyPressed = false; gInputBoxIndex = 0; gKeyInputCountdown = 0; gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL; gUpdateStatus = true; gUpdateDisplay = true; } } // this is called once every 500ms void APP_TimeSlice500ms(void) { gNextTimeslice_500ms = false; bool exit_menu = false; // Skipped authentic device check if (gKeypadLocked > 0) if (--gKeypadLocked == 0) gUpdateDisplay = true; if (gKeyInputCountdown > 0) { if (--gKeyInputCountdown == 0) { cancelUserInputModes(); if (gBeepToPlay != BEEP_NONE) { AUDIO_PlayBeep(gBeepToPlay); gBeepToPlay = BEEP_NONE; } } } if (gDTMF_RX_live_timeout > 0) { #ifdef ENABLE_RSSI_BAR if (center_line == CENTER_LINE_DTMF_DEC || center_line == CENTER_LINE_NONE) // wait till the center line is free for us to use before timing out #endif { if (--gDTMF_RX_live_timeout == 0) { if (gDTMF_RX_live[0] != 0) { memset(gDTMF_RX_live, 0, sizeof(gDTMF_RX_live)); gUpdateDisplay = true; } } } } if (gMenuCountdown > 0) if (--gMenuCountdown == 0) exit_menu = (gScreenToDisplay == DISPLAY_MENU); // exit menu mode #ifdef ENABLE_DTMF_CALLING if (gDTMF_RX_timeout > 0) if (--gDTMF_RX_timeout == 0) DTMF_clear_RX(); #endif #ifdef ENABLE_MDC1200 if (mdc1200_rx_ready_tick_500ms > 0) { if (--mdc1200_rx_ready_tick_500ms == 0) { if (center_line == CENTER_LINE_MDC1200) center_line = CENTER_LINE_NONE; gUpdateDisplay = true; } } #endif #ifdef ENABLE_FMRADIO if (gFmRadioCountdown_500ms > 0) { gFmRadioCountdown_500ms--; if (gFmRadioMode) // 1of11 return; } #endif if (gBacklightCountdown_500ms > 0 && !gAskToSave && !gCssBackgroundScan // don't turn off backlight if user is in backlight menu option && !(gScreenToDisplay == DISPLAY_MENU && (UI_MENU_GetCurrentMenuId() == MENU_ABR || UI_MENU_GetCurrentMenuId() == MENU_ABR_MAX)) && --gBacklightCountdown_500ms == 0 && gEeprom.BACKLIGHT_TIME < (ARRAY_SIZE(gSubMenu_BACKLIGHT) - 1) ) { BACKLIGHT_TurnOff(); } if (gReducedService) { BOARD_ADC_GetBatteryInfo(&gBatteryCurrentVoltage, &gBatteryCurrent); if (gBatteryCurrent > 500 || gBatteryCalibration[3] < gBatteryCurrentVoltage) { #ifdef ENABLE_OVERLAY overlay_FLASH_RebootToBootloader(); #else NVIC_SystemReset(); #endif } return; } gBatteryCheckCounter++; // Skipped authentic device check if (gCurrentFunction != FUNCTION_TRANSMIT) { if ((gBatteryCheckCounter & 1) == 0) { BOARD_ADC_GetBatteryInfo(&gBatteryVoltages[gBatteryVoltageIndex++], &gBatteryCurrent); if (gBatteryVoltageIndex > 3) gBatteryVoltageIndex = 0; BATTERY_GetReadings(true); } } // regular display updates (once every 2 sec) - if need be if ((gBatteryCheckCounter & 3) == 0) { if (gChargingWithTypeC ) gUpdateStatus = true; #ifdef ENABLE_SHOW_CHARGE_LEVEL if (gChargingWithTypeC) gUpdateDisplay = true; #endif } if (!gCssBackgroundScan && gScanStateDir == SCAN_OFF && !SCANNER_IsScanning() #ifdef ENABLE_FMRADIO && (gFM_ScanState == FM_SCAN_OFF || gAskToSave) #endif #ifdef ENABLE_AIRCOPY && gScreenToDisplay != DISPLAY_AIRCOPY #endif ) { if (exit_menu) { gMenuCountdown = 0; if (gEeprom.BACKLIGHT_TIME == 0) { BACKLIGHT_TurnOff(); } if (gInputBoxIndex > 0 || gDTMF_InputMode) { AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL); } /* if (SCANNER_IsScanning()) { BK4819_StopScan(); RADIO_ConfigureChannel(0, VFO_CONFIGURE_RELOAD); RADIO_ConfigureChannel(1, VFO_CONFIGURE_RELOAD); RADIO_SetupRegisters(true); } */ DTMF_clear_input_box(); gWasFKeyPressed = false; gInputBoxIndex = 0; gAskToSave = false; gAskToDelete = false; gUpdateStatus = true; gUpdateDisplay = true; GUI_DisplayType_t disp = DISPLAY_INVALID; #ifdef ENABLE_FMRADIO if (gFmRadioMode && ! FUNCTION_IsRx()) { disp = DISPLAY_FM; } #endif if (disp == DISPLAY_INVALID #ifndef ENABLE_NO_CODE_SCAN_TIMEOUT && !SCANNER_IsScanning() #endif ) { disp = DISPLAY_MAIN; } if (disp != DISPLAY_INVALID) { GUI_SelectNextDisplay(disp); } } } if (!gPttIsPressed && gVFOStateResumeCountdown_500ms > 0 && --gVFOStateResumeCountdown_500ms == 0) { RADIO_SetVfoState(VFO_STATE_NORMAL); #ifdef ENABLE_FMRADIO if (gFmRadioMode && !FUNCTION_IsRx()) { // switch back to FM radio mode FM_Start(); GUI_SelectNextDisplay(DISPLAY_FM); } #endif } BATTERY_TimeSlice500ms(); SCANNER_TimeSlice500ms(); UI_MAIN_TimeSlice500ms(); #ifdef ENABLE_DTMF_CALLING if (gCurrentFunction != FUNCTION_TRANSMIT) { if (gDTMF_DecodeRingCountdown_500ms > 0) { // make "ring-ring" sound gDTMF_DecodeRingCountdown_500ms--; AUDIO_PlayBeep(BEEP_880HZ_200MS); } } else { gDTMF_DecodeRingCountdown_500ms = 0; } if (gDTMF_CallState != DTMF_CALL_STATE_NONE && gCurrentFunction != FUNCTION_TRANSMIT && gCurrentFunction != FUNCTION_RECEIVE && gDTMF_auto_reset_time_500ms > 0 && --gDTMF_auto_reset_time_500ms == 0) { gUpdateDisplay = true; if (gDTMF_CallState == DTMF_CALL_STATE_RECEIVED && gEeprom.DTMF_auto_reset_time >= DTMF_HOLD_MAX) { gDTMF_CallState = DTMF_CALL_STATE_RECEIVED_STAY; // keep message on-screen till a key is pressed } else { gDTMF_CallState = DTMF_CALL_STATE_NONE; } } if (gDTMF_IsTx && gDTMF_TxStopCountdown_500ms > 0 && --gDTMF_TxStopCountdown_500ms == 0) { gDTMF_IsTx = false; gUpdateDisplay = true; } #endif } #if defined(ENABLE_ALARM) || defined(ENABLE_TX1750) static void ALARM_Off(void) { AUDIO_AudioPathOff(); gEnableSpeaker = false; if (gAlarmState == ALARM_STATE_TXALARM || gAlarmState == ALARM_STATE_TX1750) { RADIO_SendEndOfTransmission(); } gAlarmState = ALARM_STATE_OFF; #ifdef ENABLE_VOX gVoxResumeCountdown = 80; #endif SYSTEM_DelayMs(5); RADIO_SetupRegisters(true); if (gScreenToDisplay != DISPLAY_MENU) // 1of11 .. don't close the menu gRequestDisplayScreen = DISPLAY_MAIN; } #endif static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld) { if (Key == KEY_EXIT && !BACKLIGHT_IsOn() && gEeprom.BACKLIGHT_TIME > 0) { // just turn the light on for now so the user can see what's what BACKLIGHT_TurnOn(); gBeepToPlay = BEEP_NONE; return; } if (gCurrentFunction == FUNCTION_POWER_SAVE) FUNCTION_Select(FUNCTION_FOREGROUND); gBatterySaveCountdown_10ms = battery_save_count_10ms; if (!bKeyPressed) // key released { if (gFlagSaveVfo) { SETTINGS_SaveVfoIndices(); gFlagSaveVfo = false; } if (gFlagSaveSettings) { SETTINGS_SaveSettings(); gFlagSaveSettings = false; } #ifdef ENABLE_FMRADIO if (gFlagSaveFM) { SETTINGS_SaveFM(); gFlagSaveFM = false; } #endif if (gFlagSaveChannel) { SETTINGS_SaveChannel(gTxVfo->CHANNEL_SAVE, gEeprom.TX_VFO, gTxVfo, gFlagSaveChannel); gFlagSaveChannel = false; RADIO_ConfigureChannel(gEeprom.TX_VFO, VFO_CONFIGURE); RADIO_SetupRegisters(true); GUI_SelectNextDisplay(DISPLAY_MAIN); } #ifdef ENABLE_SIDEFUNCTIONS_SEND if (gFlagStopTX) { gFlagStopTX = false; RADIO_SetupRegisters(true); GUI_SelectNextDisplay(DISPLAY_MAIN); gEeprom.TX_VFO = gFlagLastVfo; gFlagReconfigureVfos = true; gUpdateDisplay = true; return; } #endif } else // key pressed or held { // const uint8_t s = BACKLIGHT_ON_TR_TXRX; const int m = UI_MENU_GetCurrentMenuId(); if ( //not when PTT and the backlight shouldn't turn on on TX /* !(Key == KEY_PTT && s != BACKLIGHT_ON_TR_TX && s != BACKLIGHT_ON_TR_TXRX) // not in the backlight menu &&*/ !(gScreenToDisplay == DISPLAY_MENU && ( m == MENU_ABR || m == MENU_ABR_MAX )) ) { BACKLIGHT_TurnOn(); } if (Key == KEY_EXIT && bKeyHeld) { // exit key held pressed // clear the live DTMF decoder if (gDTMF_RX_live[0] != 0) { memset(gDTMF_RX_live, 0, sizeof(gDTMF_RX_live)); gDTMF_RX_live_timeout = 0; gUpdateDisplay = true; } // cancel user input cancelUserInputModes(); if (gMonitor) ACTION_Monitor(); //turn off the monitor #ifdef ENABLE_SCAN_RANGES gScanRangeStart = 0; #endif } if (gScreenToDisplay == DISPLAY_MENU) // 1of11 gMenuCountdown = menu_timeout_500ms; #ifdef ENABLE_DTMF_CALLING if (gDTMF_DecodeRingCountdown_500ms > 0) { // cancel the ringing gDTMF_DecodeRingCountdown_500ms = 0; AUDIO_PlayBeep(BEEP_1KHZ_60MS_OPTIONAL); if (Key != KEY_PTT) { gPttWasReleased = true; return; } } #endif } bool lowBatPopup = gLowBattery && !gLowBatteryConfirmed && gScreenToDisplay == DISPLAY_MAIN; if ((gEeprom.KEY_LOCK || lowBatPopup) && gCurrentFunction != FUNCTION_TRANSMIT && Key != KEY_PTT) { // keyboard is locked or low battery popup // close low battery popup if(Key == KEY_EXIT && bKeyPressed && lowBatPopup) { gLowBatteryConfirmed = true; gUpdateDisplay = true; AUDIO_PlayBeep(BEEP_1KHZ_60MS_OPTIONAL); return; } if (Key == KEY_F) { // function/key-lock key if (!bKeyPressed) return; if (!bKeyHeld) { // keypad is locked, tell the user AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL); gKeypadLocked = 4; // 2 seconds gUpdateDisplay = true; return; } } // KEY_MENU has a special treatment here, because we want to pass hold event to ACTION_Handle // but we don't want it to complain when initial press happens // we want to react on realese instead // KEY_MENU has a special treatment here, because we want to pass hold event to ACTION_Handle // but we don't want it to complain when initial press happens // we want to react on realese instead else if (Key != KEY_SIDE1 && Key != KEY_SIDE2 && // pass side buttons !(Key == KEY_MENU && bKeyHeld)) // pass KEY_MENU held { if ((!bKeyPressed || bKeyHeld || (Key == KEY_MENU && bKeyPressed)) && // prevent released or held, prevent KEY_MENU pressed !(Key == KEY_MENU && !bKeyPressed)) // pass KEY_MENU released return; // keypad is locked, tell the user AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL); gKeypadLocked = 4; // 2 seconds gUpdateDisplay = true; return; } } if (Key <= KEY_9 || Key == KEY_F) { if (gScanStateDir != SCAN_OFF || gCssBackgroundScan) { // FREQ/CTCSS/DCS scanning if (bKeyPressed && !bKeyHeld) AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL); return; } } bool bFlag = false; if (Key == KEY_PTT) { // if(gEeprom.KEY_LOCK) // { // gKeypadLocked = 4; // 2 seconds // return; // } if (gPttWasPressed) { bFlag = bKeyHeld; if (!bKeyPressed) { bFlag = true; gPttWasPressed = false; } } } else if (gPttWasReleased) { if (bKeyHeld) bFlag = true; if (!bKeyPressed) { bFlag = true; gPttWasReleased = false; } } if (gWasFKeyPressed && (Key == KEY_PTT || Key == KEY_EXIT || Key == KEY_SIDE1 || Key == KEY_SIDE2)) { // cancel the F-key gWasFKeyPressed = false; gUpdateStatus = true; } if (bFlag) { goto Skip; } if (gCurrentFunction == FUNCTION_TRANSMIT) { #if defined(ENABLE_ALARM) || defined(ENABLE_TX1750) if (gAlarmState == ALARM_STATE_OFF) #endif { char Code; if (Key == KEY_PTT) { GENERIC_Key_PTT(bKeyPressed); goto Skip; } if (Key == KEY_SIDE2) { // transmit 1750Hz tone Code = 0xFE; } else { Code = DTMF_GetCharacter(Key - KEY_0); if (Code == 0xFF) goto Skip; // transmit DTMF keys } if (!bKeyPressed || bKeyHeld) { if (!bKeyPressed) { AUDIO_AudioPathOff(); gEnableSpeaker = false; BK4819_ExitDTMF_TX(false); if (gCurrentVfo->SCRAMBLING_TYPE == 0 || !gSetting_ScrambleEnable) BK4819_DisableScramble(); else BK4819_EnableScramble(gCurrentVfo->SCRAMBLING_TYPE - 1); } } else { if (gEeprom.DTMF_SIDE_TONE) { // user will here the DTMF tones in speaker AUDIO_AudioPathOn(); gEnableSpeaker = true; } BK4819_DisableScramble(); if (Code == 0xFE) BK4819_TransmitTone(gEeprom.DTMF_SIDE_TONE, 1750); else BK4819_PlayDTMFEx(gEeprom.DTMF_SIDE_TONE, Code); } } #if defined(ENABLE_ALARM) || defined(ENABLE_TX1750) else if ((!bKeyHeld && bKeyPressed) || (gAlarmState == ALARM_STATE_TX1750 && bKeyHeld && !bKeyPressed)) { ALARM_Off(); if (gEeprom.REPEATER_TAIL_TONE_ELIMINATION == 0) FUNCTION_Select(FUNCTION_FOREGROUND); else gRTTECountdown = gEeprom.REPEATER_TAIL_TONE_ELIMINATION * 10; if (Key == KEY_PTT) gPttWasPressed = true; else if (!bKeyHeld) gPttWasReleased = true; } #endif } else if (Key != KEY_SIDE1 && Key != KEY_SIDE2 && gScreenToDisplay != DISPLAY_INVALID) { ProcessKeysFunctions[gScreenToDisplay](Key, bKeyPressed, bKeyHeld); } else if (!SCANNER_IsScanning() #ifdef ENABLE_AIRCOPY && gScreenToDisplay != DISPLAY_AIRCOPY #endif ) { ACTION_Handle(Key, bKeyPressed, bKeyHeld); } else if (!bKeyHeld && bKeyPressed) { gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL; } Skip: if (gBeepToPlay != BEEP_NONE) { AUDIO_PlayBeep(gBeepToPlay); gBeepToPlay = BEEP_NONE; } if (gFlagAcceptSetting) { gMenuCountdown = menu_timeout_500ms; MENU_AcceptSetting(); gFlagRefreshSetting = true; gFlagAcceptSetting = false; } if (gRequestSaveSettings) { if (!bKeyHeld) SETTINGS_SaveSettings(); else gFlagSaveSettings = 1; gRequestSaveSettings = false; gUpdateStatus = true; } #ifdef ENABLE_FMRADIO if (gRequestSaveFM) { gRequestSaveFM = false; if (!bKeyHeld) SETTINGS_SaveFM(); else gFlagSaveFM = true; } #endif if (gRequestSaveVFO) { gRequestSaveVFO = false; if (!bKeyHeld) SETTINGS_SaveVfoIndices(); else gFlagSaveVfo = true; } if (gRequestSaveChannel > 0) { if (!bKeyHeld)// TODO: remove the gRequestSaveChannel, why use global variable for that?? { SETTINGS_SaveChannel(gTxVfo->CHANNEL_SAVE, gEeprom.TX_VFO, gTxVfo, gRequestSaveChannel); if (!SCANNER_IsScanning()) if (gVfoConfigureMode == VFO_CONFIGURE_NONE) // 'if' is so as we don't wipe out previously setting this variable elsewhere gVfoConfigureMode = VFO_CONFIGURE; } else { gFlagSaveChannel = gRequestSaveChannel; if (gRequestDisplayScreen == DISPLAY_INVALID) gRequestDisplayScreen = DISPLAY_MAIN; } gRequestSaveChannel = 0; } if (gVfoConfigureMode != VFO_CONFIGURE_NONE) { if (gFlagResetVfos) { RADIO_ConfigureChannel(0, gVfoConfigureMode); RADIO_ConfigureChannel(1, gVfoConfigureMode); } else RADIO_ConfigureChannel(gEeprom.TX_VFO, gVfoConfigureMode); if (gRequestDisplayScreen == DISPLAY_INVALID) gRequestDisplayScreen = DISPLAY_MAIN; gFlagReconfigureVfos = true; gVfoConfigureMode = VFO_CONFIGURE_NONE; gFlagResetVfos = false; } if (gFlagReconfigureVfos) { RADIO_SelectVfos(); #ifdef ENABLE_NOAA RADIO_ConfigureNOAA(); #endif RADIO_SetupRegisters(true); #ifdef ENABLE_DTMF_CALLING gDTMF_auto_reset_time_500ms = 0; gDTMF_CallState = DTMF_CALL_STATE_NONE; gDTMF_TxStopCountdown_500ms = 0; gDTMF_IsTx = false; #endif gVFO_RSSI_bar_level[0] = 0; gVFO_RSSI_bar_level[1] = 0; gFlagReconfigureVfos = false; if (gMonitor) ACTION_Monitor(); // 1of11 } if (gFlagRefreshSetting) { gFlagRefreshSetting = false; gMenuCountdown = menu_timeout_500ms; MENU_ShowCurrentSetting(); } if (gFlagPrepareTX) { RADIO_PrepareTX(); gFlagPrepareTX = false; } #ifdef ENABLE_VOICE if (gAnotherVoiceID != VOICE_ID_INVALID) { if (gAnotherVoiceID < 76) AUDIO_SetVoiceID(0, gAnotherVoiceID); AUDIO_PlaySingleVoice(false); gAnotherVoiceID = VOICE_ID_INVALID; } #endif GUI_SelectNextDisplay(gRequestDisplayScreen); gRequestDisplayScreen = DISPLAY_INVALID; gUpdateDisplay = true; }