Update .gitignore

Feature update v5

.gitignore

@@ -12,6 +12,7 @@ compile_commands.json
 k5_eeprom.raw
 
 /build
-/serialtool/__pycache__
+__pycache__/
 
-.DS_Store
+.DS_Store
+AGENTS.md

App/CMakeLists.txt

@@ -78,6 +78,7 @@ endif()
 target_compile_definitions(App INTERFACE 
     "AUTHOR_STRING=\"${AUTHOR_STRING}\""
     "VERSION_STRING=\"${VERSION_STRING}\""
+    "BUILD_COMMIT=\"${BUILD_COMMIT}\""
 )
 
 if(NOT SQL_TONE)
@@ -122,7 +123,7 @@ enable_feature(ENABLE_FMRADIO
     ui/fmradio.c
 )
 enable_feature(ENABLE_AIRCOPY
-    app/aircopy.c 
+    app/aircopy.c
     ui/aircopy.c
 )
 enable_feature(ENABLE_NOAA)
@@ -194,6 +195,10 @@ enable_feature(ENABLE_FEAT_F4HWN_RESUME_STATE)
 enable_feature(ENABLE_FEAT_F4HWN_NARROWER)
 enable_feature(ENABLE_FEAT_F4HWN_INV)
 enable_feature(ENABLE_FEAT_F4HWN_CTR)
+enable_feature(ENABLE_FEAT_F4HWN_SCAN_PROGRESS)
+enable_feature(ENABLE_FEAT_F4HWN_SCAN_FASTER)
+enable_feature(ENABLE_FEAT_F4HWN_SCAN_RSSI)
+enable_feature(ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE)
 enable_feature(ENABLE_FEAT_F4HWN_RESCUE_OPS)
 enable_feature(ENABLE_FEAT_F4HWN_VOL)
 enable_feature(ENABLE_FEAT_F4HWN_AUDIO)
@@ -203,6 +208,20 @@ enable_feature(ENABLE_FEAT_F4HWN_GMRS_FRS_MURS)
 enable_feature(ENABLE_FEAT_F4HWN_CA)
 enable_feature(ENABLE_FEAT_F4HWN_DEBUG)
 enable_feature(ENABLE_FEAT_F4HWN_MEM)
+enable_feature(ENABLE_FEAT_F4HWN_BEAM
+    app/beam.c
+)
+
+if(ENABLE_FEAT_F4HWN_BEAM AND NOT ENABLE_AIRCOPY)
+    message(FATAL_ERROR "ENABLE_FEAT_F4HWN_BEAM requires ENABLE_AIRCOPY (it reuses g_FSK_Buffer, AIRCOPY_Obfuscate and the FSK packet plumbing).")
+endif()
+enable_feature(ENABLE_FEAT_F4HWN_QRCODE)
+enable_feature(ENABLE_FEAT_F4HWN_LOGO)
+enable_feature(ENABLE_FEAT_F4HWN_LOGO_SAV)
+
+if(ENABLE_FEAT_F4HWN_LOGO_SAV AND NOT ENABLE_FEAT_F4HWN_LOGO)
+    message(FATAL_ERROR "ENABLE_FEAT_F4HWN_LOGO_SAV requires ENABLE_FEAT_F4HWN_LOGO.")
+endif()
 
 # ---- DEBUGGING ----
 

App/app/action.c

@@ -40,10 +40,14 @@
 #include "misc.h"
 #include "settings.h"
 #include "ui/inputbox.h"
+#include "ui/main.h"
 #include "ui/ui.h"
 #ifdef ENABLE_REGA
     #include "app/rega.h"
 #endif
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+    #include "app/beam.h"
+#endif
 
 #if defined(ENABLE_FMRADIO)
 static void ACTION_Scan_FM(bool bRestart);
@@ -131,6 +135,9 @@ void (*action_opt_table[])(void) = {
     [ACTION_OPT_REGA_ALARM] = &ACTION_RegaAlarm,
     [ACTION_OPT_REGA_TEST] = &ACTION_RegaTest,
 #endif
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+    [ACTION_OPT_BEAM] = &ACTION_Beam,
+#endif
 };
 
 static_assert(ARRAY_SIZE(action_opt_table) == ACTION_OPT_LEN);
@@ -212,7 +219,7 @@ void ACTION_Scan(bool bRestart)
     DTMF_clear_RX();
 #endif
     gDTMF_RX_live_timeout = 0;
-    memset(gDTMF_RX_live, 0, sizeof(gDTMF_RX_live));
+    DTMF_clear_input_box_memory();
 
     RADIO_SelectVfos();
 
@@ -237,15 +244,14 @@ void ACTION_Scan(bool bRestart)
 
         // channel mode. Keep scanning but toggle between scan lists
         RADIO_NextValidList(1);
+        UI_MAIN_NotifyScanProgressDataChanged();
 
         #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
             SETTINGS_WriteCurrentState();
         #endif
 
         // jump to the next channel
-        CHFRSCANNER_Start(false, gScanStateDir);
-        gScanPauseDelayIn_10ms = 1;
-        gScheduleScanListen    = false;
+        CHFRSCANNER_ManualResume(gScanStateDir);
     } else {
         #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
         if(gScanRangeStart == 0) // No ScanRange
@@ -343,22 +349,14 @@ void ACTION_Handle(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
             break;
     }
 
-    if (!bKeyHeld && bKeyPressed) // button pushed
-    {
+    if (bKeyHeld != bKeyPressed) { // button pushed or released after hold 
+                                   // (!bKeyHeld && bKeyPressed) or (bKeyHeld && !bKeyPressed)
         return;
     }
 
-    // held or released beyond this point
+    // held or released after short press
 
-    if(!(bKeyHeld && !bKeyPressed)) // don't beep on released after hold
-        gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
-
-    if (bKeyHeld && !bKeyPressed) // button released after hold
-    {
-        return;
-    }
-
-    // held or released after short press beyond this point
+    gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
     
 #ifdef ENABLE_FMRADIO
     if (gFmRadioMode) { // do not run these actions in FM radio mode
@@ -382,6 +380,9 @@ void ACTION_Handle(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
             case ACTION_OPT_POWER_HIGH:
             case ACTION_OPT_REMOVE_OFFSET:
         #endif
+    #endif
+    #ifdef ENABLE_FEAT_F4HWN_BEAM
+            case ACTION_OPT_BEAM:
     #endif
                 gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
                 return;
@@ -597,7 +598,7 @@ void ACTION_Wn(void)
 
     if (pVfo->Modulation == MODULATION_AM)
     {
-        BK4819_SetFilterBandwidth(BK4819_FILTER_BW_AM, true);
+        BK4819_SetFilterBandwidth(RADIO_GetAMFilterBandwidth(pVfo), true);
         return;
     }
 
@@ -660,26 +661,25 @@ void ACTION_Mute(void)
         BK1080_WriteRegister(BK1080_REG_05_SYSTEM_CONFIGURATION2, gMute ? 0x0A10 : 0x0A1F);
     #endif
     gEeprom.VOLUME_GAIN = gMute ? 0 : gEeprom.VOLUME_GAIN_BACKUP;
-    BK4819_WriteRegister(BK4819_REG_48,
-        (11u << 12)                |  // ??? .. 0 ~ 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)
+    BK4819_SetRxAudioGain();
 
     gUpdateStatus = true;
 }
 
 #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
+void ACTION_ToggleVfoSetting(bool *setting) {
+    *setting = !(*setting);
+    gVfoConfigureMode = VFO_CONFIGURE_RELOAD;
+}
+
 void ACTION_Power_High(void)
 {
-    gPowerHigh = !gPowerHigh;
-    gVfoConfigureMode = VFO_CONFIGURE_RELOAD;
+    ACTION_ToggleVfoSetting(&gPowerHigh);
 }
 
 void ACTION_Remove_Offset(void)
 {
-    gRemoveOffset = !gRemoveOffset;
-    gVfoConfigureMode = VFO_CONFIGURE_RELOAD;
+    ACTION_ToggleVfoSetting(&gRemoveOffset);
 }
 #endif
 #endif

App/app/aircopy.c

@@ -90,12 +90,14 @@ DECLARE_AIRCOPY_BANK(1)
 static const AIRCOPY_Segment_t AIRCOPY_Segments_Settings[] = {
     { 0xA000, 0xA170, AIRCOPY_WRITE_BYTES },
     { 0x880E, 0x886E, AIRCOPY_WRITE_BYTES },
+    { 0x9000, 0x90D6, AIRCOPY_WRITE_BYTES }, // VFO area (so scan-range source frequencies are replicated)
 };
 
+// total_blocks = ceil(0x170/64) + ceil(0x60/64) + ceil(0xD6/64) = 6 + 2 + 4 = 12
 static const AIRCOPY_TransferMap_t AIRCOPY_Map_Settings = {
     .segments = AIRCOPY_Segments_Settings,
-    .num_segments = 2,
-    .total_blocks = 8
+    .num_segments = 3,
+    .total_blocks = 12
 };
 
 // Finally
@@ -158,8 +160,10 @@ static inline const AIRCOPY_Segment_t *AIRCOPY_FindSegmentForOffset(uint16_t off
     return NULL;
 }
 
-static inline void AIRCOPY_CheckComplete(void)
+static inline void AIRCOPY_CheckComplete(uint16_t *num)
 {
+    *num = *num + 1;
+
     const AIRCOPY_TransferMap_t *map = AIRCOPY_GetCurrentMap();
     uint16_t done = gAirCopyBlockNumber + gErrorsDuringAirCopy;
 
@@ -172,9 +176,9 @@ static inline void AIRCOPY_CheckComplete(void)
     }
 }
 
-static inline void AIRCOPY_Obfuscation(void)
+void AIRCOPY_Obfuscate(unsigned int count)
 {
-    for (unsigned int i = 0; i < 34; i++) {
+    for (unsigned int i = 0; i < count; i++) {
         g_FSK_Buffer[i + 1] ^= Obfuscation[i % 8];
     }
 }
@@ -230,7 +234,7 @@ bool AIRCOPY_SendMessage(void)
 
     g_FSK_Buffer[34] = CRC_Calculate(&g_FSK_Buffer[1], 2 + 64);
 
-    AIRCOPY_Obfuscation();
+    AIRCOPY_Obfuscate(34);
 
     RADIO_SetTxParameters();
 
@@ -257,21 +261,18 @@ void AIRCOPY_StorePacket(void)
     BK4819_PrepareFSKReceive();
 
     if ((Status & 0x0010U) != 0 || g_FSK_Buffer[0] != 0xABCD || g_FSK_Buffer[35] != 0xDCBA) {
-        gErrorsDuringAirCopy++;
-
         BK4819_ResetFSK();           // <- important
         BK4819_PrepareFSKReceive();  // <- re-arm proprement
 
-        AIRCOPY_CheckComplete();
+        AIRCOPY_CheckComplete(&gErrorsDuringAirCopy);
         return;
     }
 
-    AIRCOPY_Obfuscation();
+    AIRCOPY_Obfuscate(34);
 
     uint16_t Crc = CRC_Calculate(&g_FSK_Buffer[1], 2 + 64);
     if (g_FSK_Buffer[34] != Crc) {
-        gErrorsDuringAirCopy++;
-        AIRCOPY_CheckComplete();
+        AIRCOPY_CheckComplete(&gErrorsDuringAirCopy);
         return;
     }
 
@@ -280,36 +281,18 @@ void AIRCOPY_StorePacket(void)
     const AIRCOPY_Segment_t *seg = AIRCOPY_FindSegmentForOffset(Offset);
     
     if (seg == NULL) {
-        gErrorsDuringAirCopy++;
-        AIRCOPY_CheckComplete();
+        AIRCOPY_CheckComplete(&gErrorsDuringAirCopy);
         return;
     }
 
-    if (seg->write_mode == AIRCOPY_WRITE_BYTES)
-    {
-        /* Raw bytes stream, written in 8-byte EEPROM chunks */
-        const uint8_t *p8 = (const uint8_t *)&g_FSK_Buffer[2];
+    const uint8_t *pData = (const uint8_t *)&g_FSK_Buffer[2];
 
-        for (unsigned int i = 0; i < 8; i++)
-        {
-            EEPROM_WriteBuffer(Offset + (i * 8), p8 + (i * 8));
-        }
-    }
-    else
+    for (unsigned int i = 0; i < 8; i++)
     {
-        /* Structured data path (kept as-is) */
-        const uint16_t *pData = &g_FSK_Buffer[2];
-
-        for (unsigned int i = 0; i < 8; i++)
-        {
-            EEPROM_WriteBuffer(Offset, pData);
-            pData += 4;
-            Offset += 8;
-        }
+        EEPROM_WriteBuffer(Offset + (i * 8), pData + (i * 8));
     }
 
-    gAirCopyBlockNumber++;
-    AIRCOPY_CheckComplete();
+    AIRCOPY_CheckComplete(&gAirCopyBlockNumber);
 }
 
 static void AIRCOPY_InitTransfer(bool isSendMode)

App/app/aircopy.h

@@ -106,5 +106,9 @@ void AIRCOPY_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld);
 
 const AIRCOPY_TransferMap_t* AIRCOPY_GetCurrentMap(void);
 
+// XOR-obfuscate `count` words of g_FSK_Buffer starting at index 1.
+// Self-inverse: applying twice restores the original buffer.
+void AIRCOPY_Obfuscate(unsigned int count);
+
 #endif // ENABLE_AIRCOPY
 #endif // APP_AIRCOPY_H

App/app/app.c

@@ -24,6 +24,9 @@
 #ifdef ENABLE_AIRCOPY
     #include "app/aircopy.h"
 #endif
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+    #include "app/beam.h"
+#endif
 #include "app/app.h"
 #include "app/chFrScanner.h"
 #include "app/dtmf.h"
@@ -69,11 +72,13 @@
     #include "sram-overlay.h"
 #endif
 #include "ui/battery.h"
+#include "ui/helper.h"
 #include "ui/inputbox.h"
 #include "ui/main.h"
 #include "ui/menu.h"
 #include "ui/status.h"
 #include "ui/ui.h"
+#include "ui/welcome.h"
 
 #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
     #include "screenshot.h"
@@ -83,6 +88,19 @@ static bool flagSaveVfo;
 static bool flagSaveSettings;
 static bool flagSaveChannel;
 
+#ifdef ENABLE_FEAT_F4HWN_SLEEP
+static KEY_Code_t gSleepWakeKey = KEY_INVALID;
+#endif
+
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+static bool gScreenSaverDisplayed;
+static uint8_t gScreenSaverTick;
+static uint16_t gMatrixRandom = 0xACE1;
+static uint8_t gMatrixHeads[32];
+static uint8_t gMatrixSpeeds[32];
+static KEY_Code_t gScreenSaverWakeKey = KEY_INVALID;
+#endif
+
 static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld);
 
 
@@ -107,11 +125,192 @@ static_assert(ARRAY_SIZE(ProcessKeysFunctions) == DISPLAY_N_ELEM-1);
 static_assert(ARRAY_SIZE(ProcessKeysFunctions) == DISPLAY_N_ELEM);
 #endif
 
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+static uint8_t ScreenSaverRandom(void)
+{
+    gMatrixRandom = (uint16_t)(gMatrixRandom * 2053u + 13849u);
+    return (uint8_t)(gMatrixRandom >> 8);
+}
+
+static void ScreenSaverSetPixel(uint8_t x, uint8_t y, bool fill)
+{
+    const uint8_t pattern = 1u << (y & 7u);
+    
+    uint8_t *target = (y < 8) ? &gStatusLine[x] : &gFrameBuffer[(y >> 3) - 1][x];
+
+    if (fill)
+        *target |= pattern;
+    else
+        *target &= (uint8_t)~pattern;
+}
+
+static void ScreenSaverDrawMatrixGlyph(uint8_t x, int16_t y, uint8_t glyph)
+{
+    static const uint8_t glyphs[][3] = {
+        {0x1F, 0x11, 0x1F},
+        {0x15, 0x1F, 0x15},
+        {0x1D, 0x15, 0x17},
+        {0x17, 0x15, 0x1D},
+        {0x1F, 0x04, 0x1F},
+        {0x1B, 0x15, 0x1B},
+        {0x0E, 0x11, 0x0E},
+        {0x11, 0x0A, 0x04}
+    };
+
+    for (uint8_t dx = 0; dx < 3; dx++) {
+        uint8_t pixels = glyphs[glyph & 7u][dx];
+        for (uint8_t dy = 0; dy < 5; dy++) {
+            const int16_t py = y + dy;
+            if ((pixels & (1u << dy)) && py >= 0 && py < LCD_HEIGHT)
+                ScreenSaverSetPixel(x + dx, (uint8_t)py, true);
+        }
+    }
+}
+
+static void ScreenSaverRenderMatrix(bool reset)
+{
+    if (reset) {
+        for (uint8_t i = 0; i < ARRAY_SIZE(gMatrixHeads); i++) {
+            gMatrixHeads[i]  = ScreenSaverRandom() % 112u;
+            gMatrixSpeeds[i] = 1u + (ScreenSaverRandom() % 3u);
+        }
+    } else {
+        for (uint8_t i = 0; i < ARRAY_SIZE(gMatrixHeads); i++) {
+            gMatrixHeads[i] += gMatrixSpeeds[i];
+            if (gMatrixHeads[i] > 112u)
+                gMatrixHeads[i] = ScreenSaverRandom() & 0x0Fu;
+        }
+    }
+
+    UI_StatusClear();
+    UI_DisplayClear();
+
+    for (uint8_t col = 0; col < ARRAY_SIZE(gMatrixHeads); col++) {
+        const uint8_t x = col * 4u;
+        for (uint8_t trail = 0; trail < 8; trail++) {
+            const int16_t y = (int16_t)gMatrixHeads[col] - ((int16_t)trail * 7);
+            const uint8_t glyph = (uint8_t)(col + trail + gMatrixHeads[col]);
+
+            if (trail == 0) {
+                ScreenSaverDrawMatrixGlyph(x, y, glyph);
+            } else if ((trail < 4) || ((glyph & 1u) != 0)) {
+                ScreenSaverDrawMatrixGlyph(x, y, glyph);
+            }
+        }
+    }
+
+    ST7565_BlitStatusLine();
+    ST7565_BlitFullScreen();
+}
+
+static void ScreenSaverScrollLogoLine(uint8_t *line)
+{
+    const uint8_t first = line[0];
+
+    memmove(line, line + 1, LCD_WIDTH - 1);
+    line[LCD_WIDTH - 1] = first;
+}
+
+static void ScreenSaverRenderLogoPlus(bool reset)
+{
+    if (reset) {
+        UI_DisplayLogo();
+        return;
+    }
+
+    ScreenSaverScrollLogoLine(gStatusLine);
+    for (uint8_t line = 0; line < FRAME_LINES; line++)
+        ScreenSaverScrollLogoLine(gFrameBuffer[line]);
+
+    ST7565_BlitStatusLine();
+    ST7565_BlitFullScreen();
+}
+
+static void ScreenSaverUpdateViewer(void)
+{
+#ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+    SCREENSHOT_Update(false);
+#endif
+}
+
+static bool ScreenSaverCanDisplay(void)
+{
+    if (gSetting_set_sav == SET_SAV_OFF ||
+        gEeprom.BACKLIGHT_TIME == 0 ||
+        gEeprom.BACKLIGHT_TIME >= 61 ||
+        gScreenSaverDisplayed ||
+        gCurrentFunction == FUNCTION_TRANSMIT ||
+        FUNCTION_IsRx() ||
+        gPttIsPressed
+#ifdef ENABLE_FMRADIO
+        || (gFM_ScanState != FM_SCAN_OFF && !gFM_FoundFrequency)
+#endif
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+        || gBeamActive
+#endif
+        )
+    {
+        return false;
+    }
+
+    if (gScreenToDisplay == DISPLAY_MAIN)
+        return true;
+
+#ifdef ENABLE_FMRADIO
+    if (gScreenToDisplay == DISPLAY_FM)
+        return true;
+#endif
+
+    return false;
+}
+
+static void ScreenSaverTryDisplay(void)
+{
+    if (!ScreenSaverCanDisplay())
+        return;
+
+    if (gSetting_set_sav == SET_SAV_LOGO)
+        UI_DisplayLogo();
+    else if (gSetting_set_sav == SET_SAV_LOGO_PLUS)
+        ScreenSaverRenderLogoPlus(true);
+    else if (gSetting_set_sav == SET_SAV_MATRIX)
+        ScreenSaverRenderMatrix(true);
+
+    gScreenSaverDisplayed = true;
+    gScreenSaverTick = 0;
+    gUpdateDisplay = false;
+    gUpdateStatus = false;
+    ScreenSaverUpdateViewer();
+}
+
+static void ScreenSaverExit(void)
+{
+    if (gScreenSaverDisplayed) {
+        gScreenSaverDisplayed = false;
+        gUpdateDisplay = true;
+        gUpdateStatus = true;
+    }
+}
+#endif
+
+bool APP_IsScreenSaverDisplayed(void)
+{
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+    return gScreenSaverDisplayed;
+#else
+    return false;
+#endif
+}
+
 static void CheckForIncoming(void)
 {
     if (!g_SquelchLost)
         return;          // squelch is closed
 
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+    ScreenSaverExit();
+#endif
+
     // squelch is open
 
     if (gScanStateDir == SCAN_OFF)
@@ -492,6 +691,10 @@ void APP_StartListening(FUNCTION_Type_t function)
 {
     const unsigned int vfo = gEeprom.RX_VFO;
 
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+    ScreenSaverExit();
+#endif
+
 #ifdef ENABLE_FEAT_F4HWN_RX_TX_TIMER
     gRxTimerCountdown_500ms = 7200;
 #endif
@@ -557,11 +760,7 @@ void APP_StartListening(FUNCTION_Type_t function)
         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)
+    BK4819_SetRxAudioGain();
 
 #ifdef ENABLE_VOICE
     if (gVoiceWriteIndex == 0)       // AM/FM RX mode will be set when the voice has finished
@@ -800,6 +999,25 @@ static void CheckRadioInterrupts(void)
             AIRCOPY_StorePacket();
         }
 #endif
+
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+        if ((interrupts.fskFifoAlmostFull || interrupts.fskRxFinied) &&
+            gBeamActive &&
+            gBeamMode == BEAM_MODE_RX &&
+            (gBeamStatus == BEAM_STATUS_RX_WAIT || gBeamStatus == BEAM_STATUS_ERROR))
+        {
+            const unsigned int wordsToRead = interrupts.fskRxFinied ? (36 - gFSKWriteIndex) : 4;
+            for (unsigned int i = 0; i < wordsToRead; i++) {
+                const uint16_t word = BK4819_ReadRegister(BK4819_REG_5F);
+                if (gFSKWriteIndex < 36)
+                    g_FSK_Buffer[gFSKWriteIndex++] = word;
+            }
+
+            gBeamRxWordCount = gFSKWriteIndex;
+            gUpdateDisplay = true;
+            BEAM_StorePacket();
+        }
+#endif
     }
 }
 
@@ -816,6 +1034,22 @@ void APP_EndTransmission(void)
     }
 }
 
+void APP_HandleEndTransmission(void) {
+    if (gFlagEndTransmission) {
+        FUNCTION_Select(FUNCTION_FOREGROUND);
+    }
+    else {
+        APP_EndTransmission();
+
+        if (gEeprom.REPEATER_TAIL_TONE_ELIMINATION == 0)
+            FUNCTION_Select(FUNCTION_FOREGROUND);
+        else
+            gRTTECountdown_10ms = gEeprom.REPEATER_TAIL_TONE_ELIMINATION * 10;
+    }
+
+    gFlagEndTransmission = false;
+}
+
 #ifdef ENABLE_VOX
 static void HandleVox(void)
 {
@@ -851,24 +1085,10 @@ static void HandleVox(void)
             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_10ms = gEeprom.REPEATER_TAIL_TONE_ELIMINATION * 10;
-            }
+            APP_HandleEndTransmission();
 
             gUpdateStatus        = true;
             gUpdateDisplay       = true;
-            gFlagEndTransmission = false;
         }
         return;
     }
@@ -996,7 +1216,7 @@ void APP_Update(void)
 
         APP_EndTransmission();
 
-        AUDIO_PlayBeep(BEEP_880HZ_60MS_DOUBLE_BEEP);
+        AUDIO_PlayBeep(BEEP_880HZ_60MS_TRIPLE_BEEP);
 
         RADIO_SetVfoState(VFO_STATE_TIMEOUT);
 
@@ -1046,6 +1266,9 @@ void APP_Update(void)
         && gScanStateDir == SCAN_OFF
         && !gPttIsPressed
         && gCurrentFunction != FUNCTION_POWER_SAVE
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+        && !gBeamActive
+#endif
 #ifdef ENABLE_VOICE
         && gVoiceWriteIndex == 0
 #endif
@@ -1124,7 +1347,11 @@ void APP_Update(void)
 
             if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF &&
                 gScanStateDir == SCAN_OFF &&
-                !gCssBackgroundScan)
+                !gCssBackgroundScan
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+                && !gBeamActive
+#endif
+            )
             {   // dual watch mode, toggle between the two VFO's
                 DualwatchAlternate();
                 goToSleep = false;
@@ -1135,7 +1362,11 @@ void APP_Update(void)
             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)
+        else if (
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+            !gBeamActive &&
+#endif
+        (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
 
@@ -1154,7 +1385,11 @@ void APP_Update(void)
             // Authentic device checked removed
 
         }
-        else {
+        else
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+        if (!gBeamActive)
+#endif
+        {
             // toggle between the two VFO's
             DualwatchAlternate();
             gPowerSave_10ms   = power_save1_10ms;
@@ -1381,6 +1616,36 @@ void APP_TimeSlice10ms(void)
 
     if (gUpdateDisplayCurrent) {
         gUpdateDisplay = false;
+    }
+
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+    bool screenSaverRendered = false;
+
+    if (gScreenSaverDisplayed) {
+        if (gUpdateDisplayCurrent) {
+            gUpdateDisplayCurrent = false;
+        } else if (gUpdateStatusCurrent) {
+            gUpdateStatusCurrent = false;
+            gUpdateStatus = false;
+        }
+
+        if (gSetting_set_sav == SET_SAV_MATRIX) {
+            if (++gScreenSaverTick >= 8u) {
+                gScreenSaverTick = 0;
+                ScreenSaverRenderMatrix(false);
+                screenSaverRendered = true;
+            }
+        } else if (gSetting_set_sav == SET_SAV_LOGO_PLUS) {
+            if (++gScreenSaverTick >= 16u) {
+                gScreenSaverTick = 0;
+                ScreenSaverRenderLogoPlus(false);
+                screenSaverRendered = true;
+            }
+        }
+    }
+#endif
+
+    if (gUpdateDisplayCurrent) {
         GUI_DisplayScreen();
     }
 
@@ -1389,7 +1654,11 @@ void APP_TimeSlice10ms(void)
     }
 
     #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
-    if (gUpdateDisplayCurrent || gUpdateStatusCurrent) {
+    if (gUpdateDisplayCurrent || gUpdateStatusCurrent
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+        || screenSaverRendered
+#endif
+        ) {
         SCREENSHOT_Update(false);
     }
     #endif
@@ -1437,8 +1706,7 @@ void APP_TimeSlice10ms(void)
                 if (gAlarmState == ALARM_STATE_TXALARM) {
                     gAlarmState = ALARM_STATE_SITE_ALARM;
 
-                    if(gEeprom.TAIL_TONE_ELIMINATION)
-                        RADIO_SendCssTail();
+                    RADIO_SendCssTail();
                     BK4819_SetupPowerAmplifier(0, 0);
                     BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_PA_ENABLE, false);
                     BK4819_Enable_AfDac_DiscMode_TxDsp();
@@ -1487,6 +1755,10 @@ void APP_TimeSlice10ms(void)
 
     SCANNER_TimeSlice10ms();
 
+#if defined(ENABLE_SCAN_RANGES) && defined(ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE) && ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE
+    CHFRSCANNER_UpdateCssDetection();
+#endif
+
 #ifdef ENABLE_AIRCOPY
     if (gScreenToDisplay == DISPLAY_AIRCOPY && gAircopyState == AIRCOPY_TRANSFER && gAirCopyIsSendMode == 1) {
         if (!AIRCOPY_SendMessage()) {
@@ -1529,12 +1801,27 @@ void APP_TimeSlice500ms(void)
         if (--gKeypadLocked == 0)
             gUpdateDisplay = true;
 
+#ifdef ENABLE_FEAT_F4HWN_RX_TX_TIMER
+    if (gSetting_set_tmr && (gCurrentFunction == FUNCTION_TRANSMIT || FUNCTION_IsRx())) {
+        const uint16_t timerCountdown = (gCurrentFunction == FUNCTION_TRANSMIT)
+            ? gTxTimerCountdown_500ms
+            : gRxTimerCountdown_500ms;
+
+        if ((timerCountdown & 1u) != 0u)
+            gUpdateStatus = true;
+    }
+#endif
+
     if (gKeyInputCountdown > 0)
     {
         if (--gKeyInputCountdown == 0)
         {
 
-            if (IS_MR_CHANNEL(gTxVfo->CHANNEL_SAVE) && (gInputBoxIndex > 0 && gInputBoxIndex < 4) && (!gFmRadioMode))
+            if (IS_MR_CHANNEL(gTxVfo->CHANNEL_SAVE) && (gInputBoxIndex > 0 && gInputBoxIndex < 4)
+#ifdef ENABLE_FMRADIO
+                && (!gFmRadioMode)
+#endif
+                )
             {
                 channelMoveSwitch();
 
@@ -1559,7 +1846,7 @@ void APP_TimeSlice500ms(void)
             {
                 if (gDTMF_RX_live[0] != 0)
                 {
-                    memset(gDTMF_RX_live, 0, sizeof(gDTMF_RX_live));
+                    DTMF_clear_input_box_memory();
                     gUpdateDisplay   = true;
                 }
             }
@@ -1596,22 +1883,33 @@ void APP_TimeSlice500ms(void)
         && gEeprom.BACKLIGHT_TIME < 61
     ) {
         BACKLIGHT_TurnOff();
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+        ScreenSaverTryDisplay();
+#endif
     }
 
 #ifdef ENABLE_FEAT_F4HWN_SLEEP
     if (gSleepModeCountdown_500ms == gSetting_set_off * 120 && gWakeUp) {
         //ST7565_Init();
         ST7565_FixInterfGlitch();
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+        ScreenSaverExit();
+#endif
         BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, false);
         gPowerSave_10ms = gEeprom.BATTERY_SAVE * 10;
         gWakeUp = false;
+        gUpdateDisplay = true;
+        gUpdateStatus = true;
     }
 
+    if(gCurrentFunction != FUNCTION_TRANSMIT && !FUNCTION_IsRx()
     #ifdef ENABLE_AIRCOPY
-    if(gCurrentFunction != FUNCTION_TRANSMIT && !FUNCTION_IsRx() && gScreenToDisplay != DISPLAY_AIRCOPY)
-    #else
-    if(gCurrentFunction != FUNCTION_TRANSMIT && !FUNCTION_IsRx())
+        && gScreenToDisplay != DISPLAY_AIRCOPY
     #endif
+    #ifdef ENABLE_FEAT_F4HWN_BEAM
+        && !gBeamActive
+    #endif
+    )
     {
         if (gSleepModeCountdown_500ms > 0 && --gSleepModeCountdown_500ms == 0) {
             gBacklightCountdown_500ms = 0;
@@ -1697,6 +1995,9 @@ void APP_TimeSlice500ms(void)
 #endif
 #ifdef ENABLE_AIRCOPY
         && gScreenToDisplay != DISPLAY_AIRCOPY
+#endif
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+        && !gBeamActive
 #endif
     ) {
         if (gEeprom.AUTO_KEYPAD_LOCK && gKeyLockCountdown > 0 && !gDTMF_InputMode
@@ -1771,6 +2072,17 @@ void APP_TimeSlice500ms(void)
 #endif
     }
 
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+    if (gBacklightCountdown_500ms == 0 &&
+        gEeprom.BACKLIGHT_TIME > 0 &&
+        gEeprom.BACKLIGHT_TIME < 61 &&
+        !gAskToSave &&
+        !gCssBackgroundScan)
+    {
+        ScreenSaverTryDisplay();
+    }
+#endif
+
     BATTERY_TimeSlice500ms();
     SCANNER_TimeSlice500ms();
     UI_MAIN_TimeSlice500ms();
@@ -1832,24 +2144,53 @@ static void ALARM_Off(void)
 
 static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 {
-    #ifdef ENABLE_FEAT_F4HWN_SLEEP
+#ifdef ENABLE_FEAT_F4HWN_SLEEP
+    if (gSleepWakeKey != KEY_INVALID) {
+        if (Key == gSleepWakeKey && !bKeyPressed)
+            gSleepWakeKey = KEY_INVALID;
+        return;
+    }
+
     if(gWakeUp)
     {
-        if(!bKeyPressed || Key == KEY_PTT)
+        if(bKeyPressed || Key == KEY_PTT)
         {
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+            ScreenSaverExit();
+#endif
             BACKLIGHT_TurnOn();
 
             if(Key != KEY_PTT)
             {
-                Key = KEY_INVALID;
+                gSleepWakeKey = Key;
+                gBeepToPlay = BEEP_NONE;
+                return;
             }
         }
-        else
+        else if(Key != KEY_PTT)
         {
+            Key = KEY_INVALID;
+        }
+    }
+#endif
+
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+    if (gScreenSaverWakeKey != KEY_INVALID) {
+        if (Key == gScreenSaverWakeKey && !bKeyPressed)
+            gScreenSaverWakeKey = KEY_INVALID;
+        return;
+    }
+
+    if (bKeyPressed && gScreenSaverDisplayed) {
+        ScreenSaverExit();
+        BACKLIGHT_TurnOn();
+        if (Key != KEY_PTT) {
+            gScreenSaverWakeKey = Key;
+            gBeepToPlay = BEEP_NONE;
             return;
         }
     }
-    #endif
+#endif
 
     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
@@ -1907,7 +2248,7 @@ static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
         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));
+                DTMF_clear_input_box_memory();
                 gDTMF_RX_live_timeout = 0;
                 gUpdateDisplay        = true;
             }
@@ -1943,12 +2284,10 @@ static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
     bool lowBatPopup = gLowBattery && !gLowBatteryConfirmed &&  gScreenToDisplay == DISPLAY_MAIN;
 
 #ifdef ENABLE_FEAT_F4HWN // Disable PTT if KEY_LOCK
-    bool lck_condition = false;
+    bool lck_condition = (gEeprom.KEY_LOCK || lowBatPopup) && gCurrentFunction != FUNCTION_TRANSMIT;
 
-    if(gSetting_set_lck)
-        lck_condition = (gEeprom.KEY_LOCK || lowBatPopup) && gCurrentFunction != FUNCTION_TRANSMIT;
-    else
-        lck_condition = (gEeprom.KEY_LOCK || lowBatPopup) && gCurrentFunction != FUNCTION_TRANSMIT && Key != KEY_PTT;
+    if(!gSetting_set_lck)
+        lck_condition = lck_condition && Key != KEY_PTT;
 
     if (lck_condition)
 #else
@@ -2089,7 +2428,8 @@ static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
             }
         }
 #if defined(ENABLE_ALARM) || defined(ENABLE_TX1750)
-        else if ((!bKeyHeld && bKeyPressed) || (gAlarmState == ALARM_STATE_TX1750 && bKeyHeld && !bKeyPressed)) {
+        // else if ((!bKeyHeld && bKeyPressed) || (gAlarmState == ALARM_STATE_TX1750 && bKeyHeld && !bKeyPressed)) {
+        else if ((bKeyHeld != bKeyPressed) && (gAlarmState == ALARM_STATE_TX1750 || bKeyPressed)) {
             ALARM_Off();
 
             if (gEeprom.REPEATER_TAIL_TONE_ELIMINATION == 0)
@@ -2104,12 +2444,21 @@ static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
         }
 #endif
     }
-    else if (gScreenToDisplay != DISPLAY_INVALID && (
+    else if (
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+            gBeamActive ||
+#endif
+            (gScreenToDisplay != DISPLAY_INVALID && (
             (Key != KEY_SIDE1 && Key != KEY_SIDE2)
 #ifdef ENABLE_FEAT_F4HWN // For F + SIDE1 or F + SIDE2
             || (gWasFKeyPressed && (Key == KEY_SIDE1 || Key == KEY_SIDE2))
 #endif
-    )) {
+    ))) {
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+        if (gBeamActive)
+            BEAM_ProcessKeys(Key, bKeyPressed, bKeyHeld);
+        else
+#endif
         ProcessKeysFunctions[gScreenToDisplay](Key, bKeyPressed, bKeyHeld);
     }
     else if (!SCANNER_IsScanning()

App/app/app.h

@@ -24,12 +24,13 @@
 #include "radio.h"
 
 void     APP_EndTransmission(void);
+void     APP_HandleEndTransmission(void);
 void     APP_StartListening(FUNCTION_Type_t function);
 uint32_t APP_SetFreqByStepAndLimits(VFO_Info_t *pInfo, int8_t direction, uint32_t lower, uint32_t upper);
 uint32_t APP_SetFrequencyByStep(VFO_Info_t *pInfo, int8_t direction);
 void     APP_Update(void);
 void     APP_TimeSlice10ms(void);
 void     APP_TimeSlice500ms(void);
+bool     APP_IsScreenSaverDisplayed(void);
 
 #endif
-

App/app/beam.c

@@ -0,0 +1,325 @@
+/* Copyright 2026 Armel F4HWN
+ * https://github.com/armel
+ *
+ * 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.
+ */
+
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+
+#include <assert.h>
+#include <string.h>
+
+#include "app/aircopy.h"
+#include "app/beam.h"
+#include "audio.h"
+#include "driver/bk4819.h"
+#include "driver/crc.h"
+#include "driver/st7565.h"
+#include "frequencies.h"
+#include "misc.h"
+#include "radio.h"
+#include "settings.h"
+#include "ui/main.h"
+#include "ui/ui.h"
+
+#define BEAM_PACKET_MAGIC   0xBEA5u
+#define BEAM_PACKET_VERSION 2u
+
+// One byte per field instead of bit-packing — payload still fits in 64 bytes,
+// and avoids costly shift/mask/store sequences on Cortex-M.
+typedef struct {
+    uint16_t magic;
+    uint8_t  version;
+    uint8_t  _pad;
+    uint32_t rx_frequency;
+    uint32_t tx_offset_frequency;
+    uint8_t  rx_code;
+    uint8_t  tx_code;
+    uint8_t  rx_codetype;
+    uint8_t  tx_codetype;
+    uint8_t  modulation;
+    uint8_t  tx_offset_direction;
+    uint8_t  tx_lock;
+    uint8_t  busy_channel_lock;
+    uint8_t  output_power;
+    uint8_t  channel_bandwidth;
+    uint8_t  frequency_reverse;
+    uint8_t  dtmf_ptt_id_mode;
+    uint8_t  dtmf_decoding_enable;
+    uint8_t  step_setting;
+    uint8_t  scrambling_type;
+    uint8_t  band;
+    uint8_t  scanlist;
+    uint8_t  compander;
+    char     name[16];
+} BEAM_Payload_t;
+
+static_assert(sizeof(BEAM_Payload_t) <= 64);
+
+BEAM_Mode_t   gBeamMode = BEAM_MODE_TX;
+BEAM_Status_t gBeamStatus = BEAM_STATUS_READY;
+uint16_t      gBeamCopiedChannel = 0xFFFFu;
+uint8_t       gBeamRxWordCount;
+bool          gBeamActive;
+
+static VFO_Info_t gBeamRadioVfo;
+
+static void BEAM_SetRadioToBeamFrequency(void)
+{
+    const uint16_t channel = FREQ_CHANNEL_FIRST + BAND6_400MHz;
+
+    RADIO_InitInfo(&gBeamRadioVfo, channel, DEFAULT_FREQ);
+    gBeamRadioVfo.CHANNEL_BANDWIDTH = BANDWIDTH_NARROW;
+    gBeamRadioVfo.OUTPUT_POWER = OUTPUT_POWER_LOW1;
+    RADIO_ConfigureSquelchAndOutputPower(&gBeamRadioVfo);
+
+    gRxVfo = &gBeamRadioVfo;
+    gTxVfo = &gBeamRadioVfo;
+    gCurrentVfo = gRxVfo;
+    RADIO_SetupRegisters(true);
+    BK4819_SetupAircopy();
+    BK4819_ResetFSK();
+}
+
+static void BEAM_SendPacket(void)
+{
+    memset(g_FSK_Buffer, 0, sizeof(g_FSK_Buffer));
+    g_FSK_Buffer[0] = 0xABCDu;
+    
+    BEAM_Payload_t * const payload = (BEAM_Payload_t *)&g_FSK_Buffer[2];
+    
+    const VFO_Info_t *vfo = &gEeprom.VfoInfo[gEeprom.TX_VFO];
+
+    payload->magic = BEAM_PACKET_MAGIC;
+    payload->version = BEAM_PACKET_VERSION;
+    payload->rx_frequency = vfo->freq_config_RX.Frequency;
+    payload->tx_offset_frequency = vfo->TX_OFFSET_FREQUENCY;
+    payload->rx_code = vfo->freq_config_RX.Code;
+    payload->tx_code = vfo->freq_config_TX.Code;
+    payload->rx_codetype = vfo->freq_config_RX.CodeType;
+    payload->tx_codetype = vfo->freq_config_TX.CodeType;
+    payload->modulation = vfo->Modulation;
+    payload->tx_offset_direction = vfo->TX_OFFSET_FREQUENCY_DIRECTION;
+    payload->tx_lock = vfo->TX_LOCK;
+    payload->busy_channel_lock = vfo->BUSY_CHANNEL_LOCK;
+    payload->output_power = vfo->OUTPUT_POWER;
+    payload->channel_bandwidth = vfo->CHANNEL_BANDWIDTH;
+    payload->frequency_reverse = vfo->FrequencyReverse;
+    payload->dtmf_ptt_id_mode = vfo->DTMF_PTT_ID_TX_MODE;
+#ifdef ENABLE_DTMF_CALLING
+    payload->dtmf_decoding_enable = vfo->DTMF_DECODING_ENABLE;
+#endif
+    payload->step_setting = vfo->STEP_SETTING;
+    payload->scrambling_type = vfo->SCRAMBLING_TYPE;
+    payload->band = vfo->Band;
+    payload->scanlist = vfo->SCANLIST_PARTICIPATION;
+    payload->compander = vfo->Compander;
+
+    if (IS_MR_CHANNEL(vfo->CHANNEL_SAVE)) {
+        SETTINGS_FetchChannelName(payload->name, vfo->CHANNEL_SAVE);
+    } else {
+        memcpy(payload->name, vfo->Name, sizeof(vfo->Name));
+    }
+
+    g_FSK_Buffer[34] = CRC_Calculate(&g_FSK_Buffer[1], 2 + 64);
+    g_FSK_Buffer[35] = 0xDCBAu;
+
+    AIRCOPY_Obfuscate(32);
+
+    // Show "SENDING" before the blocking FSK transmission so the user gets
+    // immediate visual feedback instead of a frozen "BEAM TX" screen.
+    gBeamStatus = BEAM_STATUS_TX_WAIT;
+    UI_DisplayMain();
+    ST7565_BlitFullScreen();
+
+    RADIO_SetTxParameters();
+    BK4819_SendFSKData(g_FSK_Buffer);
+    BK4819_SetupPowerAmplifier(0, 0);
+    BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_PA_ENABLE, false);
+
+    RADIO_SelectVfos();
+    RADIO_SetupRegisters(true);
+    gBeamStatus = BEAM_STATUS_TX_DONE;
+    gBeepToPlay = BEEP_880HZ_60MS_TRIPLE_BEEP;
+    gUpdateDisplay = true;
+}
+
+static void BEAM_SavePayloadToFirstFreeChannel(const BEAM_Payload_t *payload)
+{
+    uint16_t channel = 0xFFFFu;
+    
+    for (uint16_t c = MR_CHANNEL_FIRST; IS_MR_CHANNEL(c); c++) {
+        if (!RADIO_CheckValidChannel(c, false, 0)) {
+            channel = c;
+            break;
+        }
+    }
+
+    if (channel == 0xFFFFu) {
+        gBeamStatus = BEAM_STATUS_RX_FULL;
+        gUpdateDisplay = true;
+        return;
+    }
+
+    VFO_Info_t vfo;
+    RADIO_InitInfo(&vfo, channel, payload->rx_frequency);
+
+    // CRC + magic + version already validate the payload — no need to clamp fields.
+    vfo.TX_OFFSET_FREQUENCY = payload->tx_offset_frequency;
+    vfo.freq_config_RX.Code = payload->rx_code;
+    vfo.freq_config_TX.Code = payload->tx_code;
+    vfo.freq_config_RX.CodeType = payload->rx_codetype;
+    vfo.freq_config_TX.CodeType = payload->tx_codetype;
+    vfo.TX_OFFSET_FREQUENCY_DIRECTION = payload->tx_offset_direction;
+    vfo.Modulation = payload->modulation;
+    vfo.TX_LOCK = payload->tx_lock;
+    vfo.BUSY_CHANNEL_LOCK = payload->busy_channel_lock;
+    vfo.OUTPUT_POWER = payload->output_power;
+    vfo.CHANNEL_BANDWIDTH = payload->channel_bandwidth;
+    vfo.FrequencyReverse = payload->frequency_reverse;
+    vfo.DTMF_PTT_ID_TX_MODE = payload->dtmf_ptt_id_mode;
+#ifdef ENABLE_DTMF_CALLING
+    vfo.DTMF_DECODING_ENABLE = payload->dtmf_decoding_enable;
+#endif
+    vfo.STEP_SETTING = payload->step_setting;
+    vfo.StepFrequency = gStepFrequencyTable[vfo.STEP_SETTING];
+    vfo.SCRAMBLING_TYPE = payload->scrambling_type;
+    vfo.Band = payload->band;
+    vfo.SCANLIST_PARTICIPATION = payload->scanlist;
+    vfo.Compander = payload->compander;
+    
+    memcpy(vfo.Name, payload->name, sizeof(vfo.Name));
+    vfo.Name[sizeof(vfo.Name) - 1] = '\0';
+    
+    RADIO_ApplyOffset(&vfo);
+    RADIO_ConfigureSquelchAndOutputPower(&vfo);
+
+    SETTINGS_SaveChannel(channel, gEeprom.TX_VFO, &vfo, 3);
+    SETTINGS_SaveChannelName(channel, vfo.Name);
+
+    gBeamCopiedChannel = channel;
+    gBeamStatus = BEAM_STATUS_RX_SAVED;
+    gUpdateDisplay = true;
+    BACKLIGHT_TurnOn();
+    return;
+}
+
+static void BEAM_KeyMenu(void)
+{
+    BEAM_SetRadioToBeamFrequency();
+
+    if (gBeamMode == BEAM_MODE_TX) {
+        BEAM_SendPacket();
+    } else {
+        gBeamStatus = BEAM_STATUS_RX_WAIT;
+        gBeamCopiedChannel = 0xFFFFu;
+        gBeamRxWordCount = 0;
+        gFSKWriteIndex = 0;
+        BK4819_PrepareFSKReceive();
+    }
+}
+
+static void BEAM_KeyExit(void)
+{
+    BK4819_ResetFSK();
+
+    if (gBeamMode == BEAM_MODE_RX && gBeamCopiedChannel != 0xFFFFu) {
+        gEeprom.MrChannel[gEeprom.TX_VFO] = gBeamCopiedChannel;
+        gEeprom.ScreenChannel[gEeprom.TX_VFO] = gBeamCopiedChannel;
+        RADIO_ConfigureChannel(gEeprom.TX_VFO, VFO_CONFIGURE_RELOAD);
+    }
+    
+    RADIO_SelectVfos();
+    RADIO_SetupRegisters(true);
+
+    GUI_SelectNextDisplay(DISPLAY_MAIN);
+    gBeamActive = false;
+}
+
+void ACTION_Beam(void)
+{
+    gBeamMode = BEAM_MODE_TX;
+    gBeamStatus = BEAM_STATUS_READY;
+    gBeamCopiedChannel = 0xFFFFu;
+    gBeamRxWordCount = 0;
+    gBeamActive = true;
+    GUI_SelectNextDisplay(DISPLAY_MAIN);
+}
+
+void BEAM_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
+{
+    if (bKeyHeld || !bKeyPressed)
+        return;
+
+    if (Key != KEY_PTT)
+        gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
+
+    switch (Key) {
+    case KEY_UP:
+    case KEY_DOWN:
+        gBeamMode ^= 1; // (gBeamMode == BEAM_MODE_TX) ? BEAM_MODE_RX : BEAM_MODE_TX
+        gBeamStatus = BEAM_STATUS_READY;
+        gBeamRxWordCount = 0;
+        break;
+    case KEY_MENU:
+        BEAM_KeyMenu();
+        break;
+    case KEY_EXIT:
+        BEAM_KeyExit();
+        return;
+    case KEY_PTT:
+        break;
+    default:
+        gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
+        break;
+    }
+
+    gUpdateDisplay = true;
+}
+
+void BEAM_StorePacket(void)
+{
+    if (gFSKWriteIndex < 36)
+        return;
+
+    gBeamRxWordCount = gFSKWriteIndex;
+    gFSKWriteIndex = 0;
+
+    const uint16_t Status = BK4819_ReadRegister(BK4819_REG_0B);
+    BK4819_PrepareFSKReceive();
+
+    if ((Status & 0x0010U) != 0 || g_FSK_Buffer[0] != 0xABCDu || g_FSK_Buffer[35] != 0xDCBAu)
+        goto error;
+
+    AIRCOPY_Obfuscate(32);
+
+    if (g_FSK_Buffer[34] != CRC_Calculate(&g_FSK_Buffer[1], 2 + 64))
+        goto error;
+
+    BEAM_Payload_t * const payload = (BEAM_Payload_t *)&g_FSK_Buffer[2];
+
+    if (payload->magic != BEAM_PACKET_MAGIC || payload->version != BEAM_PACKET_VERSION)
+        goto error;
+
+    BEAM_SavePayloadToFirstFreeChannel(payload);
+    BK4819_ResetFSK();
+    return;
+
+error:
+    gBeamStatus = BEAM_STATUS_ERROR;
+    gBeamRxWordCount = 0;
+    gUpdateDisplay = true;
+    BACKLIGHT_TurnOn();
+}
+
+#endif // ENABLE_FEAT_F4HWN_BEAM

App/app/beam.h

@@ -0,0 +1,53 @@
+/* Copyright 2026 Armel F4HWN
+ * https://github.com/armel
+ *
+ * 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.
+ */
+
+#ifndef APP_BEAM_H
+#define APP_BEAM_H
+
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "driver/keyboard.h"
+
+typedef enum {
+    BEAM_MODE_TX = 0,
+    BEAM_MODE_RX
+} BEAM_Mode_t;
+
+typedef enum {
+    BEAM_STATUS_READY = 0,
+    BEAM_STATUS_TX_DONE,
+    BEAM_STATUS_RX_WAIT,
+    BEAM_STATUS_RX_SAVED,
+    BEAM_STATUS_RX_FULL,
+    BEAM_STATUS_ERROR,
+    BEAM_STATUS_TX_WAIT
+} BEAM_Status_t;
+
+extern BEAM_Mode_t   gBeamMode;
+extern BEAM_Status_t gBeamStatus;
+extern uint16_t      gBeamCopiedChannel;
+extern uint8_t       gBeamRxWordCount;
+extern bool          gBeamActive;
+
+void ACTION_Beam(void);
+void BEAM_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld);
+void BEAM_StorePacket(void);
+
+#endif // ENABLE_FEAT_F4HWN_BEAM
+#endif // APP_BEAM_H

App/app/breakout.c

@@ -25,9 +25,8 @@ static uint8_t blockAnim = 0;
 
 static bool isInitialized = false;
 bool isPaused = false;
-bool isBeep = false;
 
-uint8_t levelCountBreackout = 1;
+uint8_t levelCountBreakout = 1;
 
 uint16_t tone = 0;
 uint16_t score = 0;
@@ -42,115 +41,7 @@ Brick brick[BRICK_NUMBER];
 Racket racket;
 Ball ball;
 
-const uint8_t BITMAP_block[4][15] =
-{
-    {
-    0b00011110,
-    0b00110001,
-    0b00101001,
-    0b00100101,
-    0b00100011,
-    0b00110001,
-    0b00101001,
-    0b00100101,
-    0b00100011,
-    0b00110001,
-    0b00101001,
-    0b00100101,
-    0b00100011,
-    0b00110001,
-    0b00011110,
-    },
-    {
-    0b00011110,
-    0b00101001,
-    0b00100101,
-    0b00100011,
-    0b00110001,
-    0b00101001,
-    0b00100101,
-    0b00100011,
-    0b00110001,
-    0b00101001,
-    0b00100101,
-    0b00100011,
-    0b00110001,
-    0b00101001,
-    0b00011110,
-    },
-    {
-    0b00011110,
-    0b00100101,
-    0b00100011,
-    0b00110001,
-    0b00101001,
-    0b00100101,
-    0b00100011,
-    0b00110001,
-    0b00101001,
-    0b00100101,
-    0b00100011,
-    0b00110001,
-    0b00101001,
-    0b00100101,
-    0b00011110,
-    },
-    {
-    0b00011110,
-    0b00100011,
-    0b00110001,
-    0b00101001,
-    0b00100101,
-    0b00100011,
-    0b00110001,
-    0b00101001,
-    0b00100101,
-    0b00100011,
-    0b00110001,
-    0b00101001,
-    0b00100101,
-    0b00100011,
-    0b00011110,
-    }
-};
-
-const uint8_t BITMAP_blockOn[15] =
-{
-    0b00011110,
-    0b00111111,
-    0b00111111,
-    0b00111111,
-    0b00111111,
-    0b00111111,
-    0b00111111,
-    0b00111111,
-    0b00111111,
-    0b00111111,
-    0b00111111,
-    0b00111111,
-    0b00111111,
-    0b00111111,
-    0b00011110,
-};
-
-const uint8_t BITMAP_blockEmpty[15] =
-{
-    0b00000000,
-    0b00000000,
-    0b00000000,
-    0b00000000,
-    0b00000000,
-    0b00000000,
-    0b00000000,
-    0b00000000,
-    0b00000000,
-    0b00000000,
-    0b00000000,
-    0b00000000,
-    0b00000000,
-    0b00000000,
-    0b00000000,
-};
+static const uint8_t BRICK_ANIM_PATTERNS[4] = {0b00110001, 0b00101001, 0b00100101, 0b00100011};
 
 // Initialise seed
 void srand_custom(uint32_t seed) {
@@ -172,18 +63,16 @@ int randInt(int min, int max) {
 void reset(void)
 {
     ballCount = BALL_NUMBER;
-    levelCountBreackout = 1;
+    levelCountBreakout = 1;
     score = 0;
 }
 
 // PlayBeep
 void playBeep(uint16_t tone)
 {
-    BK4819_PlayTone(tone, true);    // 500 Hz ON
+    BK4819_PrepareToPlayTone(true);
     AUDIO_AudioPathOn();
-    BK4819_ExitTxMute();
-    SYSTEM_DelayMs(100);
-    BK4819_EnterTxMute();
+    BK4819_PlayToneRaw(tone, 100);
     AUDIO_AudioPathOff();
 }
 
@@ -191,10 +80,10 @@ void playBeep(uint16_t tone)
 void drawScore()
 {
     // Clean status line
-    memset(gStatusLine,  0, sizeof(gStatusLine));
+    UI_StatusClear();
 
     // Level
-    sprintf(str, "Level %02u", levelCountBreackout);
+    sprintf(str, "Level %02u", levelCountBreakout);
     GUI_DisplaySmallest(str, 0, 1, true, true);
 
     // Ball
@@ -206,6 +95,12 @@ void drawScore()
     GUI_DisplaySmallest(str, 88, 1, true, true);
 }
 
+// Render the ball
+void renderBall(bool state) {
+    UI_DrawRectangleBuffer(gFrameBuffer, ball.x, ball.y, ball.x + ball.w - 1, ball.y + ball.h - 1, state);
+    UI_DrawLineBuffer(gFrameBuffer, ball.x - 1, ball.y + 1, ball.x + ball.w, ball.y + 1, state);
+}
+
 // Init ball
 void initBall() {
     ball.x  = 62;
@@ -215,21 +110,25 @@ void initBall() {
     ball.dx = 0;
     ball.dy = 1;
 
-    UI_DrawRectangleBuffer(gFrameBuffer, ball.x, ball.y, ball.x + ball.w -1, ball.y + ball.h - 1, true);
-    UI_DrawLineBuffer(gFrameBuffer, ball.x - 1, ball.y + 1, ball.x + ball.w, ball.y + 1, true);
+    renderBall(true);
+}
+
+// Calculate the direction of the bounced ball
+void directionBall(int16_t x, uint8_t w, int8_t num) {
+    ball.dx = map(x + w - ball.x, 0, w, num, -num);
+    ball.dy *= -1;
 }
 
 // Draw ball
 void drawBall() {
-    UI_DrawRectangleBuffer(gFrameBuffer, ball.x, ball.y, ball.x + ball.w -1, ball.y + ball.h -1, false);
-    UI_DrawLineBuffer(gFrameBuffer, ball.x - 1, ball.y + 1, ball.x + ball.w, ball.y + 1, false);
+    renderBall(false);
 
     ball.x += ball.dx;
     ball.y += ball.dy;
 
     if (ball.y <= 0)  // Up
     {
-        ball.dx = map(randInt(0, 7), 0, 7, 3, -3);
+        ball.dx = randInt(-3, 3);
         ball.dy = 1;
     }
     else if (ball.x <= 2)  // Left
@@ -243,9 +142,7 @@ void drawBall() {
     // And now Down...
     if (ball.y == 47) {
         if (ball.x + 1 >= racket.x && ball.x - 1 <= racket.x + racket.w) {
-            ball.dx = map(racket.x + racket.w - ball.x, 0, racket.w, 3, -3);
-            ball.dy *= -1;
-            isBeep = true;
+            directionBall(racket.x, racket.w, 3);
             tone = 400;
         }
     } 
@@ -253,7 +150,6 @@ void drawBall() {
         ballCount--;
         UI_DisplayClear();
         drawScore();
-        isBeep = true;
         tone = 800;
         if (ballCount < 0) {
             reset();
@@ -261,15 +157,13 @@ void drawBall() {
             drawWall();
 
             isPaused = true;
-            UI_PrintStringSmallBold("GAME", 32, 0, 4);
-            UI_PrintStringSmallBold("OVER", 66, 0, 4);
+            UI_PrintStringSmallBold("GAME OVER", 0, LCD_WIDTH - 1, 4);
         }
         initRacket();
         initBall();
     }
 
-    UI_DrawRectangleBuffer(gFrameBuffer, ball.x, ball.y, ball.x + ball.w -1, ball.y + ball.h - 1, true);
-    UI_DrawLineBuffer(gFrameBuffer, ball.x - 1, ball.y + 1, ball.x + ball.w, ball.y + 1, true);
+    renderBall(true);
 }
 
 // Init wall
@@ -289,7 +183,6 @@ void initWall() {
         brick[i].y       = -8 + 8 * k;
         brick[i].w       = 14;
         brick[i].h       = 5;
-        brick[i].s       = randInt(0, 3);
         brick[i].destroy = false;
 
         j++;
@@ -302,6 +195,11 @@ void drawWall() {
 
     for (i = 0; i < BRICK_NUMBER; i++) {
         if (brick[i].destroy == false) {
+            uint8_t *fb_ptr = gFrameBuffer[brick[i].y / 8] + brick[i].x;
+
+            fb_ptr[0] = 0b00011110;
+            fb_ptr[14] = 0b00011110;
+
             if ((ball.x + 1 >= brick[i].x &&
                  ball.x - 1 <= brick[i].x + brick[i].w) &&
                 ((ball.y + 1 >= brick[i].y && 
@@ -309,32 +207,37 @@ void drawWall() {
                 brick[i].destroy = true;
                 score++;
 
-                ball.dx = map(brick[i].x + brick[i].w - ball.x, 0, brick[i].w, 2, -2);
-                ball.dy *= -1;
+                directionBall(brick[i].x, brick[i].w, 2);
 
                 BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, true);
-                memcpy(gFrameBuffer[brick[i].y / 8] + brick[i].x, BITMAP_blockOn, sizeof(BITMAP_blockOn));
+                memset(fb_ptr + 1, 0b00111111, 13);
                 ST7565_BlitLine(brick[i].y / 8);
                 playBeep(600);
-                memcpy(gFrameBuffer[brick[i].y / 8] + brick[i].x, BITMAP_blockEmpty, sizeof(BITMAP_blockEmpty));
+                memset(fb_ptr + 0, 0b00000000, 15);
                 ST7565_BlitLine(brick[i].y / 8);
                 BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, false);
 
                 if (score % BRICK_NUMBER == 0) {
-                    levelCountBreackout++;
+                    levelCountBreakout++;
                     ballCount++;
                     initWall();
                     return;
                 }
-            }
-
-            if (brick[i].destroy == false) {
-                memcpy(gFrameBuffer[brick[i].y / 8] + brick[i].x, BITMAP_block[(brick[i].s + blockAnim)  % 4], sizeof(BITMAP_block[(brick[i].s + blockAnim)  % 4]));
+            } else {
+                for(uint8_t k = 0; k < 13; k++) {
+                    fb_ptr[k + 1] = BRICK_ANIM_PATTERNS[(blockAnim + k) % 4];
+                }
             }
         }
     }
 }
 
+// Render the racket shape
+void renderRacket(int x, bool state) {
+    UI_DrawRectangleBuffer(gFrameBuffer, x + 1, racket.y, x + racket.w - 2, racket.y + racket.h, state);
+    UI_DrawLineBuffer(gFrameBuffer, x, racket.y + 1, x + racket.w - 1, racket.y + 1, state);
+}
+
 // Init racket
 void initRacket() {
     racket.w = 24;
@@ -343,18 +246,15 @@ void initRacket() {
     racket.h = 2;
     racket.p = racket.x;
 
-    UI_DrawRectangleBuffer(gFrameBuffer, racket.x + 1, racket.y, racket.x + racket.w - 2, racket.y + racket.h, true);
-    UI_DrawLineBuffer(gFrameBuffer, racket.x, racket.y + 1, racket.x + racket.w - 1, racket.y + 1, true);
+    renderRacket(racket.x, true);
 }
 
 // Draw racket
 void drawRacket() {
     if (racket.p != racket.x) {
-        UI_DrawRectangleBuffer(gFrameBuffer, racket.p + 1, racket.y, racket.p + racket.w - 2, racket.y + racket.h, false);
-        UI_DrawLineBuffer(gFrameBuffer, racket.p, racket.y + 1, racket.p + racket.w - 1, racket.y + 1, false);
+        renderRacket(racket.p, false);
         racket.p = racket.x;
-        UI_DrawRectangleBuffer(gFrameBuffer, racket.x + 1, racket.y, racket.x + racket.w - 2, racket.y + racket.h, true);
-        UI_DrawLineBuffer(gFrameBuffer, racket.x, racket.y + 1, racket.x + racket.w - 1, racket.y + 1, true);
+        renderRacket(racket.x, true);
     }
 }
 
@@ -382,7 +282,7 @@ static void OnKeyDown(uint8_t key)
         kbd.counter = 0;
         if(isPaused)
         {
-            UI_PrintStringSmallBold("PAUSE", 0, 128, 4);
+            UI_PrintStringSmallBold("PAUSE", 0, LCD_WIDTH - 1, 4);
         }
         break;
     case KEY_EXIT:
@@ -416,17 +316,13 @@ static bool HandleUserInput()
     if (kbd.current == KEY_INVALID)
         return true;
 
-    // Movement keys: dispatch on every tick while held
-    if (kbd.current == KEY_UP   || kbd.current == KEY_DOWN ||
-        kbd.current == KEY_4    || kbd.current == KEY_0)
-    {
-        OnKeyDown(kbd.current);
-        return true;
-    }
-
-    // Action keys (MENU, EXIT): dispatch only on rising edge
-    if (kbd.current != kbd.prev)
-    {
+    if (
+        // Movement keys: dispatch on every tick while held
+        (kbd.current == KEY_UP   || kbd.current == KEY_DOWN ||
+         kbd.current == KEY_4    || kbd.current == KEY_0)   ||
+        // Action keys (MENU, EXIT): dispatch only on rising edge
+        (kbd.current != kbd.prev)
+    ){
         OnKeyDown(kbd.current);
     }
 
@@ -441,62 +337,62 @@ static void Tick()
 
 // APP_RunBreakout
 void APP_RunBreakout(void) {
-        static uint8_t swap = 0;
+    static uint8_t swap = 0;
 
-        // Init seed
-        srand_custom(BK4819_ReadRegister(BK4819_REG_67) & 0x01FF * gBatteryVoltageAverage * gEeprom.VfoInfo[0].pRX->Frequency);
+    // Init seed
+    srand_custom(BK4819_ReadRegister(BK4819_REG_67) & 0x01FF * gBatteryVoltageAverage * gEeprom.VfoInfo[0].pRX->Frequency);
 
-        // Init led
-        BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, false);
+    // Init led
+    BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, false);
 
-        // Finish the brightness fade if it is in progress
-        BACKLIGHT_UpdateTickless();
+    // Finish the brightness fade if it is in progress
+    BACKLIGHT_UpdateTickless();
 
-        // Init game
-        UI_DisplayClear();
-        reset();
-        initWall();
-        initRacket();
-        initBall();
-        memset(gStatusLine,  0, sizeof(gStatusLine));
-        isInitialized = true;
+    // Init game
+    UI_DisplayClear();
+    reset();
+    initWall();
+    initRacket();
+    initBall();
+    UI_StatusClear();
+    isInitialized = true;
 
-        while(isInitialized)
+    while(isInitialized)
+    {
+        Tick();
+        if(!isPaused)
         {
-            Tick();
-            if(!isPaused)
+            if(swap == 0)
             {
-                if(swap == 0)
-                {
-                    blockAnim = (blockAnim + 1) % 4;
-                }
-                
-                swap = (swap + 1) % 4;
-
-                drawScore();
-                drawWall();
-                drawRacket();
-                drawBall();
-                   
-                if(isBeep)
-                {
-                    playBeep(tone);
-                    isBeep = false;
-                }
-                else
-                {
-                    SYSTEM_DelayMs(40 - MIN(levelCountBreackout - 1, 20)); // Add more fun...
-                }
+                blockAnim = (blockAnim + 1) % 4;
             }
+            
+            swap = (swap + 1) % 4;
 
-            ST7565_BlitStatusLine();  // Blank status line
-            ST7565_BlitFullScreen();
-
-            #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
-                if(isPaused || swap == 0)
-                {
-                    SCREENSHOT_Update(false);
-                }
-            #endif
+            drawScore();
+            drawWall();
+            drawRacket();
+            drawBall();
+                
+            if(tone != 0)
+            {
+                playBeep(tone);
+                tone = 0;
+            }
+            else
+            {
+                SYSTEM_DelayMs(40 - MIN(levelCountBreakout - 1, 20)); // Add more fun...
+            }
         }
-}
+
+        ST7565_BlitStatusLine();  // Blank status line
+        ST7565_BlitFullScreen();
+
+        #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+            if(isPaused || swap == 0)
+            {
+                SCREENSHOT_Update(false);
+            }
+        #endif
+    }
+}

App/app/breakout.h

@@ -49,7 +49,6 @@ typedef struct {
     uint8_t y;       // y
     uint8_t w;       // width
     uint8_t h;       // height
-    uint8_t s;       // style
     bool destroy;    // active, if true, check this button, else bypass
 } Brick;
 

App/app/chFrScanner.c

@@ -1,9 +1,17 @@
 
+#include <stddef.h>
+#include <string.h>
+
 #include "app/app.h"
 #include "app/chFrScanner.h"
+#include "audio.h"
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+#include "driver/systick.h"
+#endif
 #include "functions.h"
 #include "misc.h"
 #include "settings.h"
+#include "ui/main.h"
 //#include "debugging.h"
 
 int8_t            gScanStateDir;
@@ -13,6 +21,29 @@ bool              gScanPauseMode;
 #ifdef ENABLE_SCAN_RANGES
 uint32_t          gScanRangeStart;
 uint32_t          gScanRangeStop;
+
+#if defined(ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE) && ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE
+DCS_CodeType_t    gScanRangeCssType  = CODE_TYPE_OFF;
+uint8_t           gScanRangeCssCode  = 0xFF;
+static uint8_t    scanRangeCssCandidate = 0xFF;
+static uint8_t    scanRangeCssHitCount  = 0;
+#endif
+
+#define SCAN_RANGE_SKIP_MAX 32
+#if (SCAN_RANGE_SKIP_MAX & (SCAN_RANGE_SKIP_MAX - 1)) != 0
+    #error SCAN_RANGE_SKIP_MAX must be a power of two
+#endif
+
+typedef struct {
+    uint16_t sample[SCAN_RANGE_SKIP_MAX];
+    uint32_t start;
+    uint32_t stop;
+    uint16_t step;
+    uint8_t  count;
+    uint8_t  next;
+} ScanRangeSkipList_t;
+
+static ScanRangeSkipList_t scanRangeSkip;
 #endif
 
 typedef enum {
@@ -36,13 +67,685 @@ uint8_t             initialCROSS_BAND_RX_TX;
 
 static void NextFreqChannel(void);
 static void NextMemChannel(void);
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+static void ScanFastResetState(void);
+#endif
+
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+static bool ScanFastEnabled(void)
+{
+    return gSetting_set_scn;
+}
+#endif
+
+#ifdef ENABLE_SCAN_RANGES
+static void ScanRangeSkipClear(void)
+{
+    scanRangeSkip.count = 0;
+    scanRangeSkip.next = 0;
+}
+
+static void ScanRangeSkipSync(void)
+{
+    const uint16_t step = gRxVfo->StepFrequency;
+
+    if (scanRangeSkip.start == gScanRangeStart &&
+        scanRangeSkip.stop == gScanRangeStop &&
+        scanRangeSkip.step == step)
+    {
+        return;
+    }
+
+    ScanRangeSkipClear();
+    scanRangeSkip.start = gScanRangeStart;
+    scanRangeSkip.stop  = gScanRangeStop;
+    scanRangeSkip.step  = step;
+}
+
+static uint16_t ScanRangeSkipSampleForFrequency(uint32_t frequency)
+{
+    const uint16_t step = gRxVfo->StepFrequency;
+    if (!gScanRangeStart || step == 0 || frequency < gScanRangeStart || frequency > gScanRangeStop)
+        return 0;
+
+    const uint32_t sample = (frequency - gScanRangeStart) / step;
+    if (sample >= 0xFFFFu)
+        return 0;
+
+    return (uint16_t)(sample + 1);
+}
+
+static bool ScanRangeSkipContainsFrequency(uint32_t frequency)
+{
+    const uint16_t sample = ScanRangeSkipSampleForFrequency(frequency);
+    if (sample == 0)
+        return false;
+
+    for (uint8_t i = 0; i < scanRangeSkip.count; ++i)
+        if (scanRangeSkip.sample[i] == sample)
+            return true;
+
+    return false;
+}
+
+static uint32_t ScanRangeNextFrequency(void)
+{
+    uint32_t frequency;
+    uint8_t guard = SCAN_RANGE_SKIP_MAX + 1;
+
+    ScanRangeSkipSync();
+
+    do
+    {
+        frequency = APP_SetFreqByStepAndLimits(gRxVfo, gScanStateDir, gScanRangeStart, gScanRangeStop);
+        gRxVfo->freq_config_RX.Frequency = frequency;
+    } while (--guard && ScanRangeSkipContainsFrequency(frequency));
+
+    return frequency;
+}
+
+bool CHFRSCANNER_ExcludeCurrentScanRange(void)
+{
+    ScanRangeSkipSync();
+
+    uint16_t sample = ScanRangeSkipSampleForFrequency(lastFoundFrqOrChan);
+    if (sample == 0)
+        sample = ScanRangeSkipSampleForFrequency(gRxVfo->freq_config_RX.Frequency);
+
+    if (sample == 0)
+        return false;
+
+    for (uint8_t i = 0; i < scanRangeSkip.count; ++i)
+        if (scanRangeSkip.sample[i] == sample)
+            return true;
+
+    scanRangeSkip.sample[scanRangeSkip.next] = sample;
+    scanRangeSkip.next = (scanRangeSkip.next + 1) & (SCAN_RANGE_SKIP_MAX - 1);
+    if (scanRangeSkip.count < SCAN_RANGE_SKIP_MAX)
+        scanRangeSkip.count++;
+
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+    ScanFastResetState();
+#endif
+
+    return true;
+}
+
+bool CHFRSCANNER_HasScanRangeExcludedOrdinal(uint32_t first_ordinal, uint32_t last_ordinal)
+{
+    if (first_ordinal == 0)
+        first_ordinal = 1;
+    if (last_ordinal < first_ordinal)
+        return false;
+    if (first_ordinal > 0xFFFFu)
+        return false;
+    if (last_ordinal > 0xFFFFu)
+        last_ordinal = 0xFFFFu;
+
+    for (uint8_t i = 0; i < scanRangeSkip.count; ++i) {
+        const uint16_t sample = scanRangeSkip.sample[i];
+        if (sample >= first_ordinal && sample <= last_ordinal)
+            return true;
+    }
+
+    return false;
+}
+
+#if defined(ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE) && ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE
+void CHFRSCANNER_UpdateCssDetection(void)
+{
+    if (!gScanRangeStart || !FUNCTION_IsRx())
+    {
+        gScanRangeCssType    = CODE_TYPE_OFF;
+        gScanRangeCssCode    = 0xFF;
+        scanRangeCssCandidate = 0xFF;
+        scanRangeCssHitCount  = 0;
+        return;
+    }
+
+    uint32_t cdcssFreq;
+    uint16_t ctcssFreq;
+    const BK4819_CssScanResult_t result = BK4819_GetCxCSSScanResult(&cdcssFreq, &ctcssFreq);
+
+    if (result == BK4819_CSS_RESULT_CDCSS)
+    {
+        const uint8_t Code = DCS_GetCdcssCode(cdcssFreq);
+        if (Code != 0xFF && Code != gScanRangeCssCode)
+        {
+            gScanRangeCssType    = CODE_TYPE_DIGITAL;
+            gScanRangeCssCode    = Code;
+            scanRangeCssCandidate = 0xFF;
+            scanRangeCssHitCount  = 0;
+            gUpdateDisplay = true;
+        }
+    }
+    else if (result == BK4819_CSS_RESULT_CTCSS)
+    {
+        const uint8_t Code = DCS_GetCtcssCode(ctcssFreq);
+        if (Code != 0xFF)
+        {
+            if (Code == scanRangeCssCandidate)
+            {
+                if (++scanRangeCssHitCount >= 2 && Code != gScanRangeCssCode)
+                {
+                    gScanRangeCssType = CODE_TYPE_CONTINUOUS_TONE;
+                    gScanRangeCssCode = Code;
+                    gUpdateDisplay    = true;
+                }
+            }
+            else
+            {
+                scanRangeCssCandidate = Code;
+                scanRangeCssHitCount  = 1;
+            }
+        }
+    }
+}
+#endif
+#endif
+
+static void CHFRSCANNER_AbortActiveReception(void)
+{
+    if (!FUNCTION_IsRx())
+        return;
+
+    AUDIO_AudioPathOff();
+    gEnableSpeaker   = false;
+    gMonitor         = false;
+    gRxReceptionMode = RX_MODE_NONE;
+    gScanPauseMode   = false;
+
+    FUNCTION_Init();
+    FUNCTION_Select(FUNCTION_FOREGROUND);
+}
+
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+#define SCAN_FAST_PRECHECK_STEPS    6
+#define SCAN_FAST_RSSI_MARGIN       16
+#define SCAN_FAST_SQUELCH_MARGIN     8
+#define SCAN_FAST_WEAK_MARGIN        8
+#define SCAN_FAST_RECHECK_DELAY_US 350
+#define SCAN_FAST_FINE_STEP_LIMIT   250
+#define SCAN_FAST_FINE_REFINE_SPAN 1000
+#define SCAN_FAST_FINE_REFINE_MAX    80
+#define SCAN_FAST_FINE_RSSI_DROP      8
+#define SCAN_FAST_RSSI_MAX          65535u
+// Settle loop guard: at most this many 1us waits while the BK4819 glitch
+// indicator stays above SCAN_FAST_GLITCH_THRESHOLD. Caps the worst-case
+// settling time per step at ~50us before we read the RSSI anyway.
+#define SCAN_FAST_GLITCH_GUARD_MAX  50
+#define SCAN_FAST_GLITCH_THRESHOLD  200
+// HF/VHF boundary in Hz: BK4819_PickRXFilterPathBasedOnFrequency() switches
+// the front-end filter path here, so we only re-run that (relatively
+// expensive) call when we actually cross the boundary.
+#define SCAN_FAST_HF_VHF_BOUNDARY_HZ 28000000u
+
+typedef enum {
+    SCAN_FAST_DISABLED,
+    SCAN_FAST_QUIET_BATCH,
+    SCAN_FAST_CANDIDATE
+} scan_fast_result_t;
+
+static uint16_t scanFastReg30;
+static uint16_t scanFastNoiseFloor   = SCAN_FAST_RSSI_MAX;
+static uint32_t scanFastPrevFrequency;
+static bool     scanFastLastFullTuneCandidate;
+static VFO_Info_t scanFastDisplayVfo;
+static bool       scanFastDisplayVfoValid;
+#ifdef ENABLE_FEAT_F4HWN_SCAN_RSSI
+static uint16_t scanRssiSparkline[CHFRSCANNER_RSSI_SPARKLINE_WIDTH];
+static uint8_t  scanRssiSparklineWrite;
+static uint8_t  scanRssiSparklineCount;
+
+static void ScanRssiSparklineReset(void)
+{
+    memset(scanRssiSparkline, 0, sizeof(scanRssiSparkline));
+    scanRssiSparklineWrite = 0;
+    scanRssiSparklineCount = 0;
+}
+
+static void ScanRssiSparklinePush(uint16_t rssi)
+{
+    scanRssiSparkline[scanRssiSparklineWrite] = rssi;
+    scanRssiSparklineWrite++;
+    if (scanRssiSparklineWrite >= CHFRSCANNER_RSSI_SPARKLINE_WIDTH)
+        scanRssiSparklineWrite = 0;
+
+    if (scanRssiSparklineCount < CHFRSCANNER_RSSI_SPARKLINE_WIDTH)
+        scanRssiSparklineCount++;
+}
+
+bool CHFRSCANNER_HasScanRssiSparkline(void)
+{
+    return gScanStateDir != SCAN_OFF && scanRssiSparklineCount > 1;
+}
+
+uint8_t CHFRSCANNER_GetScanRssiSparklineLevel(uint8_t index)
+{
+    uint16_t minRssi = SCAN_FAST_RSSI_MAX;
+    uint16_t rssi = 0;
+    uint8_t oldest;
+
+    if (index >= CHFRSCANNER_RSSI_SPARKLINE_WIDTH || scanRssiSparklineCount == 0)
+        return 0;
+
+    if (index < CHFRSCANNER_RSSI_SPARKLINE_WIDTH - scanRssiSparklineCount)
+        return 0;
+
+    oldest = (uint8_t)((scanRssiSparklineWrite + CHFRSCANNER_RSSI_SPARKLINE_WIDTH - scanRssiSparklineCount)
+                       % CHFRSCANNER_RSSI_SPARKLINE_WIDTH);
+    index -= (uint8_t)(CHFRSCANNER_RSSI_SPARKLINE_WIDTH - scanRssiSparklineCount);
+
+    for (uint8_t i = 0; i < scanRssiSparklineCount; i++)
+    {
+        const uint16_t sample = scanRssiSparkline[(oldest + i) % CHFRSCANNER_RSSI_SPARKLINE_WIDTH];
+        if (sample != 0 && sample < minRssi)
+            minRssi = sample;
+    }
+
+    rssi = scanRssiSparkline[(oldest + index) % CHFRSCANNER_RSSI_SPARKLINE_WIDTH];
+    if (rssi == 0 || minRssi == SCAN_FAST_RSSI_MAX || rssi <= minRssi + 2)
+        return 0;
+
+    // 48 RSSI units ~= 24 dB. This keeps quiet jitter low while strong hits pop.
+    return (uint8_t)MIN(((uint32_t)(rssi - minRssi) * 5u + 24u) / 48u, 5u);
+}
+#endif
+
+static void ScanFastResetState(void)
+{
+    // Called on every scan (re)start, after a reception, and on each
+    // wraparound to the start of the channel list / range. The noise
+    // floor is re-warmed up from current conditions instead of carrying
+    // stale calibration into a later sweep.
+    scanFastNoiseFloor            = SCAN_FAST_RSSI_MAX;
+    scanFastPrevFrequency         = 0;
+    scanFastLastFullTuneCandidate = false;
+    scanFastDisplayVfoValid       = false;
+}
+
+static void ScanFastResetNoiseFloor(void)
+{
+    scanFastNoiseFloor = SCAN_FAST_RSSI_MAX;
+}
+
+static uint16_t ScanFastReadRssi(void)
+{
+    uint8_t guard = SCAN_FAST_GLITCH_GUARD_MAX;
+    while (guard-- && BK4819_GetGlitchIndicator() >= SCAN_FAST_GLITCH_THRESHOLD)
+    {
+        SYSTICK_DelayUs(1);
+    }
+
+    // Discard first read: after fast tuning the RSSI/AGC value may still be stale.
+    BK4819_GetRSSI();
+    return BK4819_GetRSSI();
+}
+
+static void ScanFastTune(uint32_t frequency)
+{
+    if (scanFastPrevFrequency == 0 ||
+        ((frequency < SCAN_FAST_HF_VHF_BOUNDARY_HZ) !=
+         (scanFastPrevFrequency < SCAN_FAST_HF_VHF_BOUNDARY_HZ)))
+    {
+        BK4819_PickRXFilterPathBasedOnFrequency(frequency);
+    }
+
+    scanFastPrevFrequency = frequency;
+    BK4819_SetFrequency(frequency);
+    BK4819_WriteRegister(BK4819_REG_30, 0);
+    BK4819_WriteRegister(BK4819_REG_30, scanFastReg30);
+}
+
+const VFO_Info_t *CHFRSCANNER_GetScanDisplayVfo(void)
+{
+    if (!ScanFastEnabled() || !scanFastDisplayVfoValid || gScanStateDir == SCAN_OFF || FUNCTION_IsRx())
+        return NULL;
+
+    return &scanFastDisplayVfo;
+}
+
+static bool ScanFastUpdateDisplayVfo(uint16_t channel, uint32_t *frequency, ModulationMode_t *modulation)
+{
+    ChannelScanDisplayInfo_t info;
+
+    if (!SETTINGS_FetchChannelScanDisplayInfo(channel, &info))
+    {
+        scanFastDisplayVfoValid = false;
+        return false;
+    }
+
+    scanFastDisplayVfo = gEeprom.VfoInfo[gEeprom.RX_VFO];
+
+    scanFastDisplayVfo.CHANNEL_SAVE = channel;
+    scanFastDisplayVfo.freq_config_RX = info.rx;
+    scanFastDisplayVfo.freq_config_TX = info.tx;
+    scanFastDisplayVfo.TX_OFFSET_FREQUENCY = info.offset;
+    scanFastDisplayVfo.StepFrequency = info.stepFrequency;
+    scanFastDisplayVfo.STEP_SETTING = info.stepSetting;
+    scanFastDisplayVfo.Modulation = info.modulation;
+    scanFastDisplayVfo.TX_OFFSET_FREQUENCY_DIRECTION = info.txOffsetFrequencyDirection;
+    scanFastDisplayVfo.OUTPUT_POWER = info.outputPower;
+    scanFastDisplayVfo.FrequencyReverse = info.frequencyReverse;
+    scanFastDisplayVfo.CHANNEL_BANDWIDTH = info.channelBandwidth;
+    scanFastDisplayVfo.BUSY_CHANNEL_LOCK = info.busyChannelLock;
+    scanFastDisplayVfo.TX_LOCK = info.txLock;
+#ifdef ENABLE_DTMF_CALLING
+    scanFastDisplayVfo.DTMF_DECODING_ENABLE = info.dtmfDecodingEnable;
+#endif
+    scanFastDisplayVfo.DTMF_PTT_ID_TX_MODE = info.dtmfPttIdTxMode;
+
+    if (!scanFastDisplayVfo.FrequencyReverse)
+    {
+        scanFastDisplayVfo.pRX = &scanFastDisplayVfo.freq_config_RX;
+        scanFastDisplayVfo.pTX = &scanFastDisplayVfo.freq_config_TX;
+    }
+    else
+    {
+        scanFastDisplayVfo.pRX = &scanFastDisplayVfo.freq_config_TX;
+        scanFastDisplayVfo.pTX = &scanFastDisplayVfo.freq_config_RX;
+    }
+
+    scanFastDisplayVfoValid = true;
+
+    if (frequency)
+        *frequency = info.rx.Frequency;
+    if (modulation)
+        *modulation = info.modulation;
+
+    return true;
+}
+
+static uint16_t ScanFastSaturatingAdd(uint16_t value, uint16_t add)
+{
+    return (value > SCAN_FAST_RSSI_MAX - add) ? SCAN_FAST_RSSI_MAX : (uint16_t)(value + add);
+}
+
+static uint16_t ScanFastSaturatingSub(uint16_t value, uint16_t sub)
+{
+    return (value > sub) ? (uint16_t)(value - sub) : 0;
+}
+
+static uint16_t ScanFastGetNoiseTrigger(void)
+{
+    return ScanFastSaturatingAdd(scanFastNoiseFloor, SCAN_FAST_RSSI_MARGIN);
+}
+
+static uint16_t ScanFastGetSquelchTrigger(void)
+{
+    return ScanFastSaturatingSub(gRxVfo->SquelchOpenRSSIThresh, SCAN_FAST_SQUELCH_MARGIN);
+}
+
+static bool ScanFastIsNearCandidate(uint16_t rssi)
+{
+    const uint16_t rssiWithMargin  = ScanFastSaturatingAdd(rssi, SCAN_FAST_WEAK_MARGIN);
+    const uint16_t squelchTrigger  = ScanFastGetSquelchTrigger();
+
+    if (scanFastNoiseFloor == SCAN_FAST_RSSI_MAX)
+        return gRxVfo->SquelchOpenRSSIThresh > 0 &&
+               rssiWithMargin >= gRxVfo->SquelchOpenRSSIThresh;
+
+    return rssiWithMargin >= ScanFastGetNoiseTrigger() &&
+           rssiWithMargin >= squelchTrigger;
+}
+
+static uint16_t ScanFastReadCandidateRssi(void)
+{
+    uint16_t rssi = ScanFastReadRssi();
+
+    if (ScanFastIsNearCandidate(rssi))
+    {
+        SYSTICK_DelayUs(SCAN_FAST_RECHECK_DELAY_US);
+
+        const uint16_t retryRssi = ScanFastReadRssi();
+        if (retryRssi > rssi)
+            rssi = retryRssi;
+    }
+
+    return rssi;
+}
+
+static bool ScanFastIsCandidate(uint16_t rssi)
+{
+    const uint16_t squelchTrigger = ScanFastGetSquelchTrigger();
+
+    if (scanFastNoiseFloor == SCAN_FAST_RSSI_MAX)
+    {
+        scanFastNoiseFloor = rssi;
+        return gRxVfo->SquelchOpenRSSIThresh > 0 &&
+               rssi >= gRxVfo->SquelchOpenRSSIThresh;
+    }
+
+    const uint16_t noiseTrigger   = ScanFastGetNoiseTrigger();
+    const uint16_t rssiWithMargin = ScanFastSaturatingAdd(rssi, SCAN_FAST_WEAK_MARGIN);
+
+    if ((rssi >= noiseTrigger && rssi >= squelchTrigger) ||
+        (rssiWithMargin >= noiseTrigger && rssiWithMargin >= squelchTrigger))
+    {
+        return true;
+    }
+
+    if (rssi < scanFastNoiseFloor)
+        scanFastNoiseFloor = rssi;
+    else
+        scanFastNoiseFloor = (uint16_t)((7u * scanFastNoiseFloor + rssi + 4u) >> 3);
+
+    return false;
+}
+
+static void ScanFastApplyChannelShape(ModulationMode_t modulation)
+{
+    const bool modulationChanged = gRxVfo->Modulation != modulation;
+    const bool bandwidthChanged  = gRxVfo->CHANNEL_BANDWIDTH != BANDWIDTH_WIDE;
+
+    if (!modulationChanged && !bandwidthChanged)
+        return;
+
+    gRxVfo->Modulation         = modulation;
+    gRxVfo->CHANNEL_BANDWIDTH  = BANDWIDTH_WIDE;
+
+    if (modulationChanged)
+        RADIO_SetModulation(modulation);
+
+    if (modulation == MODULATION_AM)
+    {
+        BK4819_SetFilterBandwidth(RADIO_GetAMFilterBandwidth(gRxVfo), true);
+    }
+    else
+    {
+#ifdef ENABLE_AM_FIX
+        BK4819_SetFilterBandwidth(BK4819_FILTER_BW_WIDE, true);
+#else
+        BK4819_SetFilterBandwidth(BK4819_FILTER_BW_WIDE, false);
+#endif
+    }
+
+    if (modulationChanged)
+    {
+        // AM and FM use different demod/AGC profiles, so their RSSI
+        // baselines are not directly comparable. Relearn the floor after
+        // crossing that boundary instead of treating the next FM block as
+        // a wall of candidates.
+        ScanFastResetNoiseFloor();
+    }
+}
+#endif
+
+#if defined(ENABLE_FEAT_F4HWN_SCAN_FASTER) && defined(ENABLE_SCAN_RANGES)
+static void ScanRangeFastRefineCandidate(uint16_t firstRssi)
+{
+    const uint16_t step = gRxVfo->StepFrequency;
+    if (step == 0 || step >= SCAN_FAST_FINE_STEP_LIMIT)
+        return;
+
+    uint16_t maxSteps = SCAN_FAST_FINE_REFINE_SPAN / step;
+    if (maxSteps == 0)
+        maxSteps = 1;
+    if (maxSteps > SCAN_FAST_FINE_REFINE_MAX)
+        maxSteps = SCAN_FAST_FINE_REFINE_MAX;
+
+    uint16_t bestRssi = firstRssi;
+    uint32_t bestFrequency = gRxVfo->freq_config_RX.Frequency;
+    uint8_t fallingSteps = 0;
+
+    for (uint16_t i = 0; i < maxSteps; ++i)
+    {
+        const uint32_t prevRxFrequency = gRxVfo->pRX->Frequency;
+
+        gRxVfo->freq_config_RX.Frequency = ScanRangeNextFrequency();
+        RADIO_ApplyOffset(gRxVfo);
+
+        const uint32_t freq = gRxVfo->pRX->Frequency;
+        if ((gScanStateDir > 0 && freq < prevRxFrequency) ||
+            (gScanStateDir < 0 && freq > prevRxFrequency))
+        {
+            break;
+        }
+
+        ScanFastTune(freq);
+
+        const uint16_t rssi = ScanFastReadRssi();
+        if (rssi > bestRssi)
+        {
+            bestRssi = rssi;
+            bestFrequency = gRxVfo->freq_config_RX.Frequency;
+            fallingSteps = 0;
+        }
+        else if (bestRssi > rssi && bestRssi - rssi >= SCAN_FAST_FINE_RSSI_DROP)
+        {
+            if (++fallingSteps >= 3)
+                break;
+        }
+    }
+
+    gRxVfo->freq_config_RX.Frequency = bestFrequency;
+    RADIO_ApplyOffset(gRxVfo);
+    ScanFastTune(gRxVfo->pRX->Frequency);
+}
+
+static scan_fast_result_t ScanRangeFastPrecheck(void)
+{
+    if (!gScanRangeStart)
+        return SCAN_FAST_DISABLED;
+
+    if (gRxVfo->SquelchOpenRSSIThresh == 0)
+        return SCAN_FAST_DISABLED;
+
+    // Mute AF DAC during the precheck sweep: avoids audio glitches and
+    // saves a few uA on each silent step. The bit is restored on the real
+    // tune by RADIO_SetupRegisters() in NextFreqChannel().
+    scanFastReg30 = BK4819_ReadRegister(BK4819_REG_30) & ~BK4819_REG_30_MASK_ENABLE_AF_DAC;
+
+    for (uint8_t i = 0; i < SCAN_FAST_PRECHECK_STEPS; ++i)
+    {
+        gRxVfo->freq_config_RX.Frequency = ScanRangeNextFrequency();
+        RADIO_ApplyOffset(gRxVfo);
+
+        const uint32_t freq = gRxVfo->pRX->Frequency;
+
+        // Detect wraparound: scanning forward but the new freq is lower
+        // than the previous one (or scanning backward but it's higher)
+        // means the range has wrapped from stop back to start. Reset the
+        // noise floor so the new pass re-warms up from current conditions.
+        if (scanFastPrevFrequency != 0 &&
+            ((gScanStateDir > 0 && freq < scanFastPrevFrequency) ||
+             (gScanStateDir < 0 && freq > scanFastPrevFrequency)))
+        {
+            ScanFastResetState();
+        }
+
+        ScanFastTune(freq);
+
+        const uint16_t rssi = ScanFastReadCandidateRssi();
+#ifdef ENABLE_FEAT_F4HWN_SCAN_RSSI
+        ScanRssiSparklinePush(rssi);
+#endif
+        if (ScanFastIsCandidate(rssi))
+        {
+            ScanRangeFastRefineCandidate(rssi);
+            return SCAN_FAST_CANDIDATE;
+        }
+    }
+
+    return SCAN_FAST_QUIET_BATCH;
+}
+#endif
+
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+static bool MemChannelFastPrecheck(uint16_t channel)
+{
+    uint32_t frequency;
+    ModulationMode_t modulation;
+
+    if (gRxVfo->SquelchOpenRSSIThresh == 0)
+    {
+        scanFastLastFullTuneCandidate = false;
+        return true;
+    }
+
+    if (!ScanFastUpdateDisplayVfo(channel, &frequency, &modulation))
+    {
+        scanFastLastFullTuneCandidate = false;
+        return true;
+    }
+
+    ScanFastApplyChannelShape(modulation);
+
+    // Mute AF DAC for the same reason as in ScanRangeFastPrecheck().
+    scanFastReg30 = BK4819_ReadRegister(BK4819_REG_30) & ~BK4819_REG_30_MASK_ENABLE_AF_DAC;
+    ScanFastTune(frequency);
+
+    const uint16_t rssi = ScanFastReadCandidateRssi();
+#ifdef ENABLE_FEAT_F4HWN_SCAN_RSSI
+    ScanRssiSparklinePush(rssi);
+#endif
+
+    if (ScanFastIsCandidate(rssi))
+    {
+        scanFastLastFullTuneCandidate = true;
+        return true;  // signal detected: let the full tune path follow
+    }
+
+    // No signal here: still mirror the probed frequency in the VFO so the
+    // status line (channel name + frequency) keeps in sync as we skip.
+    // RADIO_ConfigureChannel() will overwrite these values cleanly when a
+    // candidate is eventually retained.
+    scanFastLastFullTuneCandidate = false;
+    gRxVfo->freq_config_RX.Frequency = frequency;
+    return false;
+}
+
+static void AdvanceMemScanList(const bool enabled)
+{
+    if (enabled)
+        if (++currentScanList >= SCAN_NEXT_NUM)
+            currentScanList = SCAN_NEXT_CHAN_SCANLIST1;
+}
+
+static void SetMemScanProgressChannel(uint16_t channel)
+{
+    gEeprom.MrChannel[    gEeprom.RX_VFO] = channel;
+    gEeprom.ScreenChannel[gEeprom.RX_VFO] = channel;
+    gRxVfo->CHANNEL_SAVE = channel;
+}
+#endif
 
 #if defined(ENABLE_FEAT_F4HWN_RESUME_STATE) || defined(ENABLE_SCAN_RANGES)
     void CHFRSCANNER_ScanRange(void) {
-        gScanRangeStart = gScanRangeStart ? 0 : gTxVfo->pRX->Frequency;
+        if (gScanRangeStart) {
+            gScanRangeStart = 0;
+            return;
+        }
+
+        gScanRangeStart = gTxVfo->pRX->Frequency;
         gScanRangeStop = gEeprom.VfoInfo[!gEeprom.TX_VFO].freq_config_RX.Frequency;
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+        ScanFastResetState();
+#endif
         if(gScanRangeStart > gScanRangeStop)
             SWAP(gScanRangeStart, gScanRangeStop);
+
+        ScanRangeSkipSync();
     }
 #endif
 
@@ -55,16 +758,24 @@ void CHFRSCANNER_Start(const bool storeBackupSettings, const int8_t scan_directi
     }
     
     RADIO_SelectVfos();
+    CHFRSCANNER_AbortActiveReception();
 
     gNextMrChannel   = gRxVfo->CHANNEL_SAVE;
     currentScanList = SCAN_NEXT_CHAN_SCANLIST1;
     gScanStateDir    = scan_direction;
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+#ifdef ENABLE_FEAT_F4HWN_SCAN_RSSI
+    ScanRssiSparklineReset();
+#endif
+    ScanFastResetState();
+#endif
 
     if (IS_MR_CHANNEL(gNextMrChannel))
     {   
 
         if(!RADIO_CheckValidList(gEeprom.SCAN_LIST_DEFAULT)) {
             RADIO_NextValidList(1);
+            UI_MAIN_NotifyScanProgressDataChanged();
         }
 
         // channel mode
@@ -93,6 +804,16 @@ void CHFRSCANNER_Start(const bool storeBackupSettings, const int8_t scan_directi
     gScanPauseMode         = false;
 }
 
+void CHFRSCANNER_ManualResume(const int8_t scan_direction)
+{
+    CHFRSCANNER_Start(false, scan_direction);
+
+    gScanPauseDelayIn_10ms = (gRxVfo->SquelchOpenRSSIThresh == 0)
+        ? scan_pause_delay_in_3_10ms
+        : 1;
+    gScheduleScanListen    = false;
+}
+
 /*
 void CHFRSCANNER_ContinueScanning(void)
 {
@@ -119,6 +840,18 @@ void CHFRSCANNER_ContinueScanning(void)
 
 void CHFRSCANNER_ContinueScanning(void)
 {
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+    if (scanFastLastFullTuneCandidate &&
+        gCurrentFunction != FUNCTION_INCOMING &&
+        !g_SquelchLost)
+    {
+        // A rejected full-tune candidate is just a false RSSI hit. Keep the
+        // learned floor; resetting here can make the next channel blind when
+        // it is the real signal, especially while scanning down.
+        scanFastLastFullTuneCandidate = false;
+    }
+#endif
+
     if (gCurrentFunction == FUNCTION_INCOMING &&
         (IS_FREQ_CHANNEL(gNextMrChannel) || gCurrentCodeType == CODE_TYPE_OFF))
     {
@@ -136,6 +869,15 @@ void CHFRSCANNER_ContinueScanning(void)
 
 void CHFRSCANNER_Found(void)
 {
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+    // After a real reception the BK4819 AGC has shifted, biasing the next
+    // few RSSI readings high. Reset the precheck state so it warms up from
+    // the current noise floor instead of carrying stale calibration into
+    // the post-reception scan, which otherwise turns nearly every channel
+    // into a CANDIDATE and erases the speed gain.
+    ScanFastResetState();
+#endif
+
     if (gEeprom.SCAN_RESUME_MODE > 80) {
         if (!gScanPauseMode) {
             gScanPauseDelayIn_10ms = scan_pause_delay_in_5_10ms * (gEeprom.SCAN_RESUME_MODE - 80) * 5;
@@ -208,6 +950,9 @@ void CHFRSCANNER_Stop(void)
     }
     
     gScanStateDir = SCAN_OFF;
+#if defined(ENABLE_FEAT_F4HWN_SCAN_FASTER) && defined(ENABLE_FEAT_F4HWN_SCAN_RSSI)
+    ScanRssiSparklineReset();
+#endif
 
     const uint32_t chFr = gScanKeepResult ? lastFoundFrqOrChan : initialFrqOrChan;
     const bool channelChanged = chFr != initialFrqOrChan;
@@ -243,11 +988,46 @@ static void NextFreqChannel(void)
 {
 #ifdef ENABLE_SCAN_RANGES
     if(gScanRangeStart) {
-        gRxVfo->freq_config_RX.Frequency = APP_SetFreqByStepAndLimits(gRxVfo, gScanStateDir, gScanRangeStart, gScanRangeStop);
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+        if (ScanFastEnabled())
+        {
+            const scan_fast_result_t fastResult = ScanRangeFastPrecheck();
+
+            if (fastResult == SCAN_FAST_QUIET_BATCH)
+            {
+                scanFastLastFullTuneCandidate = false;
+                gScanPauseDelayIn_10ms = 1;
+                gUpdateDisplay = true;
+                return;
+            }
+
+            if (fastResult == SCAN_FAST_DISABLED)
+            {
+                scanFastLastFullTuneCandidate = false;
+                gRxVfo->freq_config_RX.Frequency = ScanRangeNextFrequency();
+            }
+            else
+            {
+                scanFastLastFullTuneCandidate = true;
+            }
+        }
+        else
+        {
+            scanFastLastFullTuneCandidate = false;
+            gRxVfo->freq_config_RX.Frequency = ScanRangeNextFrequency();
+        }
+#else
+        gRxVfo->freq_config_RX.Frequency = ScanRangeNextFrequency();
+#endif
     }
     else
+#endif
+    {
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+        scanFastLastFullTuneCandidate = false;
 #endif
         gRxVfo->freq_config_RX.Frequency = APP_SetFrequencyByStep(gRxVfo, gScanStateDir);
+    }
 
     RADIO_ApplyOffset(gRxVfo);
     RADIO_ConfigureSquelchAndOutputPower(gRxVfo);
@@ -348,23 +1128,58 @@ static void NextMemChannel(void)
     }
 
     if (!enabled || chan == 0xFFFF)
-    {       
+    {
+        const uint16_t searchStart = gNextMrChannel;
         chan = RADIO_FindNextChannel(gNextMrChannel + gScanStateDir, gScanStateDir, true, gEeprom.SCAN_LIST_DEFAULT);
         if (chan == 0xFFFF)
-        {   // no valid channel found
+        {   // no valid channel found -> wrapping back to the first channel
             chan = MR_CHANNEL_FIRST;
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+            // Wraparound: re-warm the precheck noise floor on the new pass
+            // so it tracks current RF conditions instead of an EMA that
+            // accumulated drift over the previous full sweep.
+            ScanFastResetState();
+#endif
         }
-        
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+        else if ((gScanStateDir > 0 && chan < searchStart) ||
+                 (gScanStateDir < 0 && chan > searchStart))
+        {
+            // RADIO_FindNextChannel() wraps internally, so 0xFFFF is not
+            // returned on a normal full-sweep wrap. Detect that transition
+            // here and restart the RSSI floor learning for the new pass.
+            ScanFastResetState();
+        }
+#endif
+
         gNextMrChannel = chan;
 
         //sprintf(str, "----> Chan %d\n", chan + 1);
         //LogUart(str);
     }
 
-    if (gNextMrChannel != prev_chan)
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+    SetMemScanProgressChannel(gNextMrChannel);
+
+    if (ScanFastEnabled() && !MemChannelFastPrecheck(gNextMrChannel))
     {
+        gScanPauseDelayIn_10ms = 1;
+        gUpdateDisplay = true;
+        AdvanceMemScanList(enabled);
+        return;
+    }
+#endif
+
+    if (gNextMrChannel != prev_chan
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+        || scanFastLastFullTuneCandidate
+#endif
+    )
+    {
+#ifndef ENABLE_FEAT_F4HWN_SCAN_FASTER
         gEeprom.MrChannel[    gEeprom.RX_VFO] = gNextMrChannel;
         gEeprom.ScreenChannel[gEeprom.RX_VFO] = gNextMrChannel;
+#endif
 
         RADIO_ConfigureChannel(gEeprom.RX_VFO, VFO_CONFIGURE_RELOAD);
         RADIO_SetupRegisters(true);
@@ -378,7 +1193,11 @@ static void NextMemChannel(void)
     gScanPauseDelayIn_10ms = scan_pause_delay_in_3_10ms;
 #endif
 
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+    AdvanceMemScanList(enabled);
+#else
     if (enabled)
         if (++currentScanList >= SCAN_NEXT_NUM)
             currentScanList = SCAN_NEXT_CHAN_SCANLIST1;  // back round we go
+#endif
 }

App/app/chFrScanner.h

@@ -4,6 +4,8 @@
 #include <stdbool.h>
 #include <stdint.h>
 
+#include "radio.h"
+
 // scan direction, if not equal SCAN_OFF indicates 
 // that we are in a process of scanning channels/frequencies
 extern int8_t            gScanStateDir;
@@ -13,12 +15,31 @@ extern bool              gScanPauseMode;
 #ifdef ENABLE_SCAN_RANGES
 extern uint32_t          gScanRangeStart;
 extern uint32_t          gScanRangeStop;
+#if defined(ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE) && ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE
+extern DCS_CodeType_t    gScanRangeCssType;
+extern uint8_t           gScanRangeCssCode;
+#endif
+
+bool CHFRSCANNER_ExcludeCurrentScanRange(void);
+bool CHFRSCANNER_HasScanRangeExcludedOrdinal(uint32_t first_ordinal, uint32_t last_ordinal);
+#if defined(ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE) && ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE
+void CHFRSCANNER_UpdateCssDetection(void);
+#endif
 #endif
 
 void CHFRSCANNER_Found(void);
 void CHFRSCANNER_Stop(void);
 void CHFRSCANNER_Start(const bool storeBackupSettings, const int8_t scan_direction);
+void CHFRSCANNER_ManualResume(const int8_t scan_direction);
 void CHFRSCANNER_ContinueScanning(void);
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+const VFO_Info_t *CHFRSCANNER_GetScanDisplayVfo(void);
+#ifdef ENABLE_FEAT_F4HWN_SCAN_RSSI
+bool CHFRSCANNER_HasScanRssiSparkline(void);
+uint8_t CHFRSCANNER_GetScanRssiSparklineLevel(uint8_t index);
+#define CHFRSCANNER_RSSI_SPARKLINE_WIDTH 24u
+#endif
+#endif
 
 #if defined(ENABLE_FEAT_F4HWN_RESUME_STATE) || defined(ENABLE_SCAN_RANGES)
     void CHFRSCANNER_ScanRange(void);
@@ -29,4 +50,4 @@ void CHFRSCANNER_ContinueScanning(void);
     extern uint32_t lastFoundFrqOrChanOld;
 #endif
 
-#endif
+#endif

App/app/dtmf.c

@@ -212,6 +212,10 @@ DTMF_CallMode_t DTMF_CheckGroupCall(const char *pMsg, const unsigned int size)
 }
 #endif
 
+void DTMF_clear_input_box_memory() {
+    memset(gDTMF_RX_live, 0, sizeof(gDTMF_RX_live));
+}
+
 void DTMF_clear_input_box(void)
 {
     memset(gDTMF_InputBox, 0, sizeof(gDTMF_InputBox));
@@ -470,7 +474,7 @@ void DTMF_Reply(void)
     if (pString == NULL)
         return;
 
-    Delay = (gEeprom.DTMF_PRELOAD_TIME < 200) ? 200 : gEeprom.DTMF_PRELOAD_TIME;
+    Delay = MAX(gEeprom.DTMF_PRELOAD_TIME, 200);
 
     if (gEeprom.DTMF_SIDE_TONE)
     {   // the user will also hear the transmitted tones

App/app/dtmf.h

@@ -82,6 +82,7 @@ extern DTMF_ReplyState_t gDTMF_ReplyState;
 
 bool DTMF_ValidateCodes(char *pCode, const unsigned int size);
 char DTMF_GetCharacter(const unsigned int code);
+void DTMF_clear_input_box_memory(void);
 void DTMF_clear_input_box(void);
 void DTMF_Append(const char code);
 void DTMF_Reply(void);

App/app/fm.c

@@ -40,7 +40,6 @@ volatile int8_t   gFM_ScanState;
 bool              gFM_AutoScan;
 uint8_t           gFM_ChannelPosition;
 bool              gFM_FoundFrequency;
-bool              gFM_AutoScan;
 uint16_t          gFM_RestoreCountdown_10ms;
 
 
@@ -95,6 +94,11 @@ int FM_ConfigureChannelState(void)
     return 0;
 }
 
+void FM_SetFrequency(void)
+{
+    BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/);
+}
+
 void FM_TurnOff(void)
 {
     gFmRadioMode              = false;
@@ -164,7 +168,12 @@ void FM_Tune(uint16_t Frequency, int8_t Step, bool bFlag)
 
     gFM_ScanState = Step;
 
-    BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/);
+    FM_SetFrequency();
+}
+
+void FM_AudioPathOn(void) {
+    AUDIO_AudioPathOn();
+    gEnableSpeaker = true;
 }
 
 void FM_PlayAndUpdate(void)
@@ -177,16 +186,15 @@ void FM_PlayAndUpdate(void)
     }
 
     FM_ConfigureChannelState();
-    BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/);
+    FM_SetFrequency();
     SETTINGS_SaveFM();
 
     gFmPlayCountdown_10ms = 0;
     gScheduleFM           = false;
     gAskToSave            = false;
 
-    AUDIO_AudioPathOn();
-
-    gEnableSpeaker   = true;
+    BACKLIGHT_TurnOn();
+    FM_AudioPathOn();
 }
 
 int FM_CheckFrequencyLock(uint16_t Frequency, uint16_t LowerLimit)
@@ -288,7 +296,7 @@ static void Key_DIGITS(KEY_Code_t Key, uint8_t state)
                 gAnotherVoiceID = (VOICE_ID_t)Key;
 #endif
                 gEeprom.FM_FrequencyPlaying = gEeprom.FM_SelectedFrequency;
-                BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/);
+                FM_SetFrequency();
                 gRequestSaveFM = true;
                 return;
             }
@@ -308,7 +316,7 @@ static void Key_DIGITS(KEY_Code_t Key, uint8_t state)
 #endif
                     gEeprom.FM_SelectedChannel = Channel;
                     gEeprom.FM_FrequencyPlaying = gFM_Channels[Channel];
-                    BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/);
+                    FM_SetFrequency();
                     gRequestSaveFM = true;
                     return;
                 }
@@ -363,7 +371,7 @@ static void Key_FUNC(KEY_Code_t Key, uint8_t state)
                 gEeprom.FM_IsMrMode = !gEeprom.FM_IsMrMode;
 
                 if (!FM_ConfigureChannelState()) {
-                    BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/);
+                    FM_SetFrequency();
                     gRequestSaveFM = true;
                 }
                 else
@@ -391,8 +399,14 @@ static void Key_FUNC(KEY_Code_t Key, uint8_t state)
 
 static void Key_EXIT(uint8_t state)
 {
-    if (state != BUTTON_EVENT_SHORT)
-        return;
+    if (gInputBoxIndex) {
+        if (state != BUTTON_EVENT_SHORT)
+            return;
+    } 
+    else {
+        if (state != BUTTON_EVENT_PRESSED)
+            return;
+    }
 
     gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
 
@@ -471,7 +485,7 @@ static void Key_MENU(uint8_t state)
                 gFM_Channels[gEeprom.FM_SelectedChannel] = 0xFFFF;
 
                 FM_ConfigureChannelState();
-                BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/);
+                FM_SetFrequency();
 
                 gRequestSaveFM = true;
             }
@@ -549,7 +563,7 @@ static void Key_UP_DOWN(uint8_t state, int8_t Step)
     gRequestSaveFM = true;
 
 Bail:
-    BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/);
+    FM_SetFrequency();
 
     gRequestDisplayScreen = DISPLAY_FM;
 }
@@ -603,20 +617,19 @@ void FM_Play(void)
             if (!gEeprom.FM_IsMrMode)
                 gEeprom.FM_SelectedFrequency = gEeprom.FM_FrequencyPlaying;
 
-            AUDIO_AudioPathOn();
-            gEnableSpeaker = true;
+            BACKLIGHT_TurnOn();
+            FM_AudioPathOn();
 
-            GUI_SelectNextDisplay(DISPLAY_FM);
-            return;
+            goto Display;
         }
 
         if (gFM_ChannelPosition < FM_CHANNELS_MAX)
             gFM_Channels[gFM_ChannelPosition++] = gEeprom.FM_FrequencyPlaying;
-
+        
         if (gFM_ChannelPosition >= FM_CHANNELS_MAX) {
             FM_PlayAndUpdate();
-            GUI_SelectNextDisplay(DISPLAY_FM);
-            return;
+
+            goto Display;
         }
     }
 
@@ -625,6 +638,7 @@ void FM_Play(void)
     else
         FM_Tune(gEeprom.FM_FrequencyPlaying, gFM_ScanState, false);
 
+Display:
     GUI_SelectNextDisplay(DISPLAY_FM);
 }
 
@@ -639,9 +653,8 @@ void FM_Start(void)
     // Disable UHF LNA, enable VHF LNA
     BK4819_PickRXFilterPathBasedOnFrequency(10320000); // 103.2 MHz < 280 MHz
 
-    AUDIO_AudioPathOn();
+    FM_AudioPathOn();
 
-    gEnableSpeaker       = true;
     gUpdateStatus        = true;
 
     #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE

App/app/generic.c

@@ -91,7 +91,7 @@ void GENERIC_Key_F(bool bKeyPressed, bool bKeyHeld)
             return;
         }
 #endif
-        gBeepToPlay     = BEEP_440HZ_500MS;
+        gBeepToPlay     = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
         gPttWasReleased = true;
     }
 }
@@ -103,20 +103,8 @@ void GENERIC_Key_PTT(bool bKeyPressed)
     if (!bKeyPressed || SerialConfigInProgress())
     {   // PTT released
         if (gCurrentFunction == FUNCTION_TRANSMIT) {    
-            // we are transmitting .. stop
-            if (gFlagEndTransmission) {
-                FUNCTION_Select(FUNCTION_FOREGROUND);
-            }
-            else {
-                APP_EndTransmission();
+            APP_HandleEndTransmission();
 
-                if (gEeprom.REPEATER_TAIL_TONE_ELIMINATION == 0)
-                    FUNCTION_Select(FUNCTION_FOREGROUND);
-                else
-                    gRTTECountdown_10ms = gEeprom.REPEATER_TAIL_TONE_ELIMINATION * 10;
-            }
-
-            gFlagEndTransmission = false;
 #ifdef ENABLE_VOX
             gVOX_NoiseDetected = false;
 #endif

App/app/main.c

@@ -44,6 +44,7 @@
 #include "radio.h"
 #include "settings.h"
 #include "ui/inputbox.h"
+#include "ui/main.h"
 #include "ui/ui.h"
 #include <stdlib.h>
 
@@ -261,34 +262,51 @@ static void processFKeyFunction(const KEY_Code_t Key, const bool beep)
             break;
 
         case KEY_7:
-#ifdef ENABLE_VOX
-            ACTION_Vox();
-//#else
-//          toggle_chan_scanlist();
+#ifdef ENABLE_FEAT_F4HWN_GAME
+            if (!beep) {
+                APP_RunBreakout();
+            } else {
 #endif
+#ifdef ENABLE_VOX
+                ACTION_Vox();
+//#else
+//              toggle_chan_scanlist();
+#endif
+#ifdef ENABLE_FEAT_F4HWN_GAME
+            }
+#endif
+
             break;
 
         case KEY_8:
-            gTxVfo->FrequencyReverse = gTxVfo->FrequencyReverse == false;
-            gRequestSaveChannel = 1;
+            if (!beep) {
+                ACTION_BackLightOnDemand(); 
+            }
+            else {
+                gTxVfo->FrequencyReverse = gTxVfo->FrequencyReverse == false;
+                gRequestSaveChannel = 1;
+            }
+
             break;
 
         case KEY_9:
-            if (RADIO_CheckValidChannel(gEeprom.CHAN_1_CALL, false, 0)) {
-                gEeprom.MrChannel[Vfo]     = gEeprom.CHAN_1_CALL;
-                gEeprom.ScreenChannel[Vfo] = gEeprom.CHAN_1_CALL;
+            if (!beep) {
+                ACTION_BackLight();
+            }
+            else {
+                if (RADIO_CheckValidChannel(gEeprom.CHAN_1_CALL, false, 0)) {
+                    gEeprom.MrChannel[Vfo]     = gEeprom.CHAN_1_CALL;
+                    gEeprom.ScreenChannel[Vfo] = gEeprom.CHAN_1_CALL;
 #ifdef ENABLE_VOICE
-                AUDIO_SetVoiceID(0, VOICE_ID_CHANNEL_MODE);
-                AUDIO_SetDigitVoice(1, gEeprom.CHAN_1_CALL + 1);
-                gAnotherVoiceID        = (VOICE_ID_t)0xFE;
+                    AUDIO_SetVoiceID(0, VOICE_ID_CHANNEL_MODE);
+                    AUDIO_SetDigitVoice(1, gEeprom.CHAN_1_CALL + 1);
+                    gAnotherVoiceID        = (VOICE_ID_t)0xFE;
 #endif
-                gRequestSaveVFO            = true;
-                gVfoConfigureMode          = VFO_CONFIGURE_RELOAD;
-                break;
+                    gRequestSaveVFO            = true;
+                    gVfoConfigureMode          = VFO_CONFIGURE_RELOAD;
+                }
             }
 
-            if (beep)
-                gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
             break;
 
 #ifdef ENABLE_FEAT_F4HWN // Set Squelch F + UP or Down and Step F + SIDE1 or F + SIDE2
@@ -299,15 +317,16 @@ static void processFKeyFunction(const KEY_Code_t Key, const bool beep)
 
                 if (gScanStateDir != SCAN_OFF) {
                     RADIO_NextValidList(isKeyUp ? 1 : -1);
+                    UI_MAIN_NotifyScanProgressDataChanged();
                 } else {
                     // Adjust squelch: UP increments, DOWN decrements
                     if (gSquelchLevelOriginal == 10)
                         gSquelchLevelOriginal =  gEeprom.SQUELCH_LEVEL;
 
                     if (isKeyUp) {
-                        gEeprom.SQUELCH_LEVEL = (gEeprom.SQUELCH_LEVEL < 9) ? gEeprom.SQUELCH_LEVEL + 1 : 9;
+                        if (gEeprom.SQUELCH_LEVEL < 9) gEeprom.SQUELCH_LEVEL++;
                     } else {
-                        gEeprom.SQUELCH_LEVEL = (gEeprom.SQUELCH_LEVEL > 0) ? gEeprom.SQUELCH_LEVEL - 1 : 0;
+                        if (gEeprom.SQUELCH_LEVEL > 0) gEeprom.SQUELCH_LEVEL--;
                     }
                     gVfoConfigureMode = VFO_CONFIGURE;
                 }
@@ -481,6 +500,7 @@ static void MAIN_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
             if (value == 0)
             {
                 gEeprom.SCAN_LIST_DEFAULT = MR_CHANNELS_LIST + 1;
+                UI_MAIN_NotifyScanProgressDataChanged();
             #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
                 SETTINGS_WriteCurrentState();
             #endif
@@ -499,6 +519,7 @@ static void MAIN_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
                     gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
                     RADIO_NextValidList(1);
                 }
+                UI_MAIN_NotifyScanProgressDataChanged();
 
             #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
                 SETTINGS_WriteCurrentState();
@@ -555,10 +576,10 @@ static void MAIN_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
                 return;
             }
             
-            gKeyInputCountdown = (gInputBoxIndex >= totalDigits) ? (key_input_timeout_500ms / 16) : (key_input_timeout_500ms / 3);
+            gKeyInputCountdown = key_input_timeout_500ms / (gInputBoxIndex >= totalDigits ? 16 : 3);
 
             if (gInputBoxIndex > totalDigits) {
-                gInputBoxIndex =  totalDigits;
+                gInputBoxIndex = totalDigits;
 
                 return;
             }
@@ -569,11 +590,8 @@ static void MAIN_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
             // convert to int
             uint32_t inputFreq = StrToUL(inputStr);
 
-            // how many zero to add
-            uint8_t zerosToAdd = totalDigits - inputLength;
-
             // add missing zero
-            for (uint8_t i = 0; i < zerosToAdd; i++) {
+            for (uint8_t i = 0; i < totalDigits - inputLength; i++) {
                 inputFreq *= 10;
             }
 
@@ -654,30 +672,6 @@ static void MAIN_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 
     HideFKeyIcon();
 
-    #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-        if(gEeprom.MENU_LOCK == true && Key != 2) {
-            return;
-        }
-    #endif
-
-    if(Key == 8)
-    {
-        ACTION_BackLightOnDemand();
-        return;
-    }
-    else if(Key == 9)
-    {
-        ACTION_BackLight();
-        return;
-    }
-    #ifdef ENABLE_FEAT_F4HWN_GAME
-    else if(Key == 7)
-    {
-        APP_RunBreakout();
-        return;
-    }
-    #endif
-
     processFKeyFunction(Key, false);
 }
 
@@ -758,15 +752,30 @@ static void MAIN_Key_MENU(bool bKeyPressed, bool bKeyHeld)
         if (bKeyPressed) { // long press MENU key
 
             #ifdef ENABLE_FEAT_F4HWN
-            // Exclude channel
+            // Exclude current scan entry
             if(gScanStateDir != SCAN_OFF)
             {
                 if(FUNCTION_IsRx() || gScanPauseDelayIn_10ms > 9)
                 {
+#ifdef ENABLE_SCAN_RANGES
+                    if(gScanRangeStart && !IS_MR_CHANNEL(gNextMrChannel))
+                    {
+                        if(CHFRSCANNER_ExcludeCurrentScanRange())
+                        {
+                            UI_MAIN_NotifyScanProgressDataChanged();
+                            lastFoundFrqOrChan = lastFoundFrqOrChanOld;
+                            CHFRSCANNER_ContinueScanning();
+                        }
+
+                        return;
+                    }
+#endif
+
                     ChannelAttributes_t *att = MR_GetChannelAttributes(lastFoundFrqOrChan);
                     att->exclude = true;
 
                     MR_SaveChannelAttributesToFlash(lastFoundFrqOrChan, att);
+                    UI_MAIN_NotifyScanProgressDataChanged();
 
                     gVfoConfigureMode = VFO_CONFIGURE;
                     gFlagResetVfos    = true;
@@ -941,12 +950,12 @@ static void MAIN_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
 
     uint16_t Channel = gEeprom.ScreenChannel[gEeprom.TX_VFO];
 
-    if (bKeyHeld || !bKeyPressed) { // key held or released
-        if (gInputBoxIndex > 0) {
-            gInputBoxIndex = 0;
-            gHasVfoBackup = false;
-        }
+    if (gInputBoxIndex > 0) {
+        gInputBoxIndex = 0;
+        gHasVfoBackup = false;
+    }
 
+    if (bKeyHeld || !bKeyPressed) { // key held or released
         if (!bKeyPressed) {
             if (!bKeyHeld || IS_FREQ_CHANNEL(Channel))
                 return;
@@ -1011,9 +1020,7 @@ static void MAIN_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
     }
 
     // jump to the next channel
-    CHFRSCANNER_Start(false, Direction);
-    gScanPauseDelayIn_10ms = 1;
-    gScheduleScanListen = false;
+    CHFRSCANNER_ManualResume(Direction);
 
     gPttWasReleased = true;
 }
@@ -1079,4 +1086,4 @@ void MAIN_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
                 gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
             break;
     }
-}
+}

App/app/menu.c

@@ -222,6 +222,13 @@ int MENU_GetLimits(uint8_t menu_id, int32_t *pMin, int32_t *pMax)
             *pMax = ARRAY_SIZE(gSubMenu_RX_TX) - 1;
             break;
 
+#if defined(ENABLE_FEAT_F4HWN) && defined(ENABLE_FEAT_F4HWN_LOGO_SAV)
+        case MENU_SET_SAV:
+            //*pMin = 0;
+            *pMax = SET_SAV_LEN - 1;
+            break;
+#endif
+
         #ifndef ENABLE_FEAT_F4HWN
             #ifdef ENABLE_AM_FIX
                 case MENU_AM_FIX:
@@ -426,6 +433,12 @@ int MENU_GetLimits(uint8_t menu_id, int32_t *pMin, int32_t *pMax)
             //*pMin = 0;
             *pMax = ARRAY_SIZE(gSubMenu_SET_MET) - 1;
             break;
+        #ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+        case MENU_SET_SCN:
+            //*pMin = 0;
+            *pMax = ARRAY_SIZE(gSubMenu_SET_SCN) - 1;
+            break;
+        #endif
         #ifdef ENABLE_FEAT_F4HWN_AUDIO
         case MENU_SET_AUD:
             //*pMin = 0;
@@ -457,6 +470,28 @@ int MENU_GetLimits(uint8_t menu_id, int32_t *pMin, int32_t *pMax)
         #endif
 #endif
 
+        case MENU_VOL: {
+            // SysInf paginates: 
+            // page 0 = identity, 
+            // page 1 = build date/time,
+            // page 2 = battery,
+            // +1 if F4HWN_MEM (Flash/SRAM), 
+            // +2 if F4HWN_QRCODE (Code QR + Wiki QR).
+            int32_t vol_max = 0;
+            #ifdef ENABLE_FEAT_F4HWN
+                vol_max += 2;
+            #endif
+            #ifdef ENABLE_FEAT_F4HWN_MEM
+                vol_max += 1;
+            #endif
+            #ifdef ENABLE_FEAT_F4HWN_QRCODE
+                vol_max += 2;
+            #endif
+            if (vol_max == 0) return -1;
+            *pMax = vol_max;
+            break;
+        }
+
         default:
             return -1;
     }
@@ -594,7 +629,7 @@ void MENU_AcceptSetting(void)
 
         case MENU_MEM_NAME:
             for (int i = 9; i >= 0; i--) {
-                if (edit[i] != ' ' && edit[i] != '_' && edit[i] != 0x00 && edit[i] != 0xff)
+                if (edit[i] != ' ' && edit[i] != 0x00 && edit[i] != 0xff)
                     break;
                 edit[i] = ' ';
             }
@@ -778,7 +813,7 @@ void MENU_AcceptSetting(void)
         case MENU_D_LIVE_DEC:
             gSetting_live_DTMF_decoder = gSubMenuSelection;
             gDTMF_RX_live_timeout = 0;
-            memset(gDTMF_RX_live, 0, sizeof(gDTMF_RX_live));
+            DTMF_clear_input_box_memory();
             if (!gSetting_live_DTMF_decoder)
                 BK4819_DisableDTMF();
             gFlagReconfigureVfos     = true;
@@ -967,6 +1002,11 @@ void MENU_AcceptSetting(void)
         case MENU_SET_GUI:
             gSetting_set_gui = gSubMenuSelection;
             break;
+        #ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+        case MENU_SET_SCN:
+            gSetting_set_scn = gSubMenuSelection;
+            break;
+        #endif
         #ifdef ENABLE_FEAT_F4HWN_AUDIO
         case MENU_SET_AUD:
             if(gTxVfo->Modulation == MODULATION_AM)
@@ -997,6 +1037,11 @@ void MENU_AcceptSetting(void)
         case MENU_SET_TMR:
             gSetting_set_tmr = gSubMenuSelection;
             break;
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+        case MENU_SET_SAV:
+            gSetting_set_sav = gSubMenuSelection;
+            break;
+#endif
         case MENU_TX_LOCK:
             gTxVfo->TX_LOCK = gSubMenuSelection;
             gRequestSaveChannel       = 1;
@@ -1030,6 +1075,11 @@ void MENU_ShowCurrentSetting(void)
             gSubMenuSelection = gEeprom.SQUELCH_LEVEL;
             break;
 
+        case MENU_VOL:
+            // SysInf is paginated; always start on page 0 (identity).
+            gSubMenuSelection = 0;
+            break;
+
         case MENU_STEP:
             gSubMenuSelection = FREQUENCY_GetSortedIdxFromStepIdx(gTxVfo->STEP_SETTING);
             break;
@@ -1426,6 +1476,11 @@ void MENU_ShowCurrentSetting(void)
         case MENU_SET_GUI:
             gSubMenuSelection = gSetting_set_gui;
             break;
+        #ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+        case MENU_SET_SCN:
+            gSubMenuSelection = gSetting_set_scn;
+            break;
+        #endif
         #ifdef ENABLE_FEAT_F4HWN_AUDIO
         case MENU_SET_AUD:
             if(gTxVfo->Modulation == MODULATION_AM)
@@ -1454,6 +1509,11 @@ void MENU_ShowCurrentSetting(void)
         case MENU_SET_TMR:
             gSubMenuSelection = gSetting_set_tmr;
             break;
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+        case MENU_SET_SAV:
+            gSubMenuSelection = gSetting_set_sav;
+            break;
+#endif
         case MENU_TX_LOCK:
             gSubMenuSelection = gTxVfo->TX_LOCK;
             break;
@@ -1464,6 +1524,29 @@ void MENU_ShowCurrentSetting(void)
     }
 }
 
+static KEY_Code_t edit_last_key = 255;
+static uint8_t edit_char_index = 0;
+
+static const char* const char_map[10] = {
+    " 0",                           // KEY_0
+    ".,-()@/\\+=*#<>[]~1",          // KEY_1
+    "abc2",                         // KEY_2
+    "def3",                         // KEY_3
+    "ghi4",                         // KEY_4
+    "jkl5",                         // KEY_5
+    "mno6",                         // KEY_6
+    "pqrs7",                        // KEY_7
+    "tuv8",                         // KEY_8
+    "wxyz9"                         // KEY_9
+};
+
+static bool MENU_IsEditingName() {
+    return !gCssBackgroundScan
+        && UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME
+        && gIsInSubMenu
+        && edit_index >= 0;
+}
+
 static void MENU_Key_0_to_9(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 {
     uint8_t  Offset;
@@ -1471,33 +1554,55 @@ static void MENU_Key_0_to_9(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
     int32_t  Max;
     uint16_t Value = 0;
 
-    if (bKeyHeld || !bKeyPressed)
+    if (!bKeyPressed)
         return;
 
     gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
 
     if (UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME && edit_index >= 0)
     {   // currently editing the channel name
+        if (edit_index >= 10)
+            return;
 
-        if (edit_index < 10)
+        uint8_t key_idx = Key - KEY_0;
+
+        if (bKeyHeld)
         {
-            if (Key <= KEY_9)
+            edit[edit_index] = '0' + key_idx;
+            edit_last_key = 255;
+            
+            gRequestDisplayScreen = DISPLAY_MENU;
+            return;
+        }
+
+        if (Key != edit_last_key)
+        {
+            edit_last_key = Key;
+            edit_char_index = 0;
+        }
+        else
+        {
+            edit_char_index++;
+            if (char_map[key_idx][edit_char_index] == '\0')
             {
-                edit[edit_index] = '0' + Key - KEY_0;
-
-                if (++edit_index >= 10)
-                {   // exit edit
-                    gFlagAcceptSetting  = false;
-                    gAskForConfirmation = 1;
-                }
-
-                gRequestDisplayScreen = DISPLAY_MENU;
+                edit_char_index = 0;
             }
         }
 
+        char c = char_map[key_idx][edit_char_index];
+        if (edit_is_uppercase && c >= 'a' && c <= 'z')
+        {
+            c -= 32;
+        }
+        edit[edit_index] = c;
+
+        gRequestDisplayScreen = DISPLAY_MENU;
         return;
     }
 
+    if (bKeyHeld)
+        return;
+
     INPUTBOX_Append(Key);
 
     gRequestDisplayScreen = DISPLAY_MENU;
@@ -1586,7 +1691,7 @@ static void MENU_Key_0_to_9(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
         gInputBoxIndex = 0;
 
         //Value = ((gInputBox[0] * 100) + (gInputBox[1] * 10) + gInputBox[2]) - 1;
-        Value = ((gInputBox[0] * 1000) + (gInputBox[1] * 100) + (gInputBox[2] * 10) + gInputBox[3]) - 1;
+        Value = (((gInputBox[0] * 10 + gInputBox[1]) * 10 + gInputBox[2]) * 10 + gInputBox[3]) - 1;
 
         if (IS_MR_CHANNEL(Value))
         {
@@ -1643,6 +1748,53 @@ static void MENU_Key_0_to_9(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 
 static void MENU_Key_EXIT(bool bKeyPressed, bool bKeyHeld)
 {
+    if (MENU_IsEditingName())
+    {
+        if (!bKeyPressed)
+        {
+            if (bKeyHeld)
+                return; // release after a long press, keep editing
+
+            if (edit_index == 0)
+                goto Skip;
+
+            if (edit_index > 0)
+            {   // step back one character while editing the channel name
+                edit_index--;
+                edit_last_key = 255;
+                gAskForConfirmation = 0;
+                gRequestDisplayScreen = DISPLAY_MENU;
+            }
+
+            return;
+        }
+
+        if (!bKeyHeld)
+        {   // wait to see if the user wants a short exit or a long backspace
+            gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
+            return;
+        }
+
+Skip:
+
+        /* Backlight related menus set full brightness. Set it back to the configured value,
+           just in case we are editing from one of them. */
+        BACKLIGHT_TurnOn();
+
+        gAskForConfirmation = 0;
+        gIsInSubMenu        = false;
+        gInputBoxIndex      = 0;
+        gFlagRefreshSetting = true;
+
+        #ifdef ENABLE_VOICE
+            gAnotherVoiceID = VOICE_ID_CANCEL;
+        #endif
+
+        gRequestDisplayScreen = DISPLAY_MENU;
+
+        return;
+    }
+
     if (bKeyHeld || !bKeyPressed)
         return;
 
@@ -1650,29 +1802,22 @@ static void MENU_Key_EXIT(bool bKeyPressed, bool bKeyHeld)
 
     if (!gCssBackgroundScan)
     {
-        /* Backlight related menus set full brightness. Set it back to the configured value,
-           just in case we are exiting from one of them. */
-        BACKLIGHT_TurnOn();
-
         if (gIsInSubMenu)
         {
             if (gInputBoxIndex == 0 || UI_MENU_GetCurrentMenuId() != MENU_OFFSET)
             {
-                gAskForConfirmation = 0;
-                gIsInSubMenu        = false;
-                gInputBoxIndex      = 0;
-                gFlagRefreshSetting = true;
-
-                #ifdef ENABLE_VOICE
-                    gAnotherVoiceID = VOICE_ID_CANCEL;
-                #endif
+                goto Skip;
             }
             else
+            {
+                /* Backlight related menus set full brightness. Set it back to the configured value,
+                   just in case we are exiting from one of them. */
+                BACKLIGHT_TurnOn();
+
                 gInputBox[--gInputBoxIndex] = 10;
+                gRequestDisplayScreen = DISPLAY_MENU;
+            }
 
-            // ***********************
-
-            gRequestDisplayScreen = DISPLAY_MENU;
             return;
         }
 
@@ -1703,9 +1848,9 @@ static void MENU_Key_EXIT(bool bKeyPressed, bool bKeyHeld)
 
 static void MENU_Key_MENU(const bool bKeyPressed, const bool bKeyHeld)
 {
-    if (bKeyHeld || !bKeyPressed)
+    if (!bKeyPressed || (bKeyHeld && (!MENU_IsEditingName() || gAskForConfirmation)))
         return;
-
+    
     gBeepToPlay           = BEEP_1KHZ_60MS_OPTIONAL;
     gRequestDisplayScreen = DISPLAY_MENU;
 
@@ -1751,12 +1896,18 @@ static void MENU_Key_MENU(const bool bKeyPressed, const bool bKeyHeld)
 
             SETTINGS_FetchChannelName(edit, gSubMenuSelection);
 
-            // pad the channel name out with '_'
-            edit_index = strlen(edit);
-            while (edit_index < 10)
-                edit[edit_index++] = '_';
-            edit[edit_index] = 0;
+            // pad the channel name out with ' '
+            size_t len = strlen(edit);
+            if (len < 10)
+            {
+                memset(edit + len, ' ', 10 - len);
+                edit[10] = '\0';
+            }
+
             edit_index = 0;  // 'edit_index' is going to be used as the cursor position
+            edit_last_key = 255;
+            edit_char_index = 0;
+            edit_is_uppercase = false;
 
             // make a copy so we can test for change when exiting the menu item
             memcpy(edit_original, edit, sizeof(edit_original));
@@ -1766,9 +1917,14 @@ static void MENU_Key_MENU(const bool bKeyPressed, const bool bKeyHeld)
         else
         if (edit_index >= 0 && edit_index < 10)
         {   // editing the channel name characters
+            edit_last_key = 255;
 
-            if (++edit_index < 10)
-                return; // next char
+            if (bKeyHeld) {
+                edit_index = 10;
+            }
+            else if (++edit_index < 10) {
+                return;
+            }
 
             // exit
             gFlagAcceptSetting  = false;
@@ -1844,7 +2000,7 @@ static void MENU_Key_MENU(const bool bKeyPressed, const bool bKeyHeld)
 
 static void MENU_Key_STAR(const bool bKeyPressed, const bool bKeyHeld)
 {
-    if (bKeyHeld || !bKeyPressed)
+    if (!bKeyPressed)
         return;
 
     gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
@@ -1854,13 +2010,8 @@ static void MENU_Key_STAR(const bool bKeyPressed, const bool bKeyHeld)
 
         if (edit_index < 10)
         {
-            edit[edit_index] = '-';
-
-            if (++edit_index >= 10)
-            {   // exit edit
-                gFlagAcceptSetting  = false;
-                gAskForConfirmation = 1;
-            }
+            edit[edit_index] = !bKeyHeld ? '-' : '*';
+            edit_last_key = 255;
 
             gRequestDisplayScreen = DISPLAY_MENU;
         }
@@ -1868,6 +2019,9 @@ static void MENU_Key_STAR(const bool bKeyPressed, const bool bKeyHeld)
         return;
     }
 
+    if (bKeyHeld)
+        return;
+
     RADIO_SelectVfos();
 
     #ifdef ENABLE_NOAA
@@ -1898,15 +2052,23 @@ static void MENU_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
     uint16_t Channel;
     bool    bCheckScanList;
 
+    if (!bKeyPressed)
+        return;
+
+    if (!bKeyHeld) {
+        gInputBoxIndex = 0;
+        gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
+    }
+
     if (!gEeprom.SET_NAV && gIsInSubMenu) {
         Direction = -Direction;
     }
 
     if (UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME && gIsInSubMenu && edit_index >= 0)
     {   // change the character
-        if (bKeyPressed && edit_index < 10 && Direction != 0)
+        if (edit_index < 10 && Direction != 0)
         {
-            const char   unwanted[] = "$%&!\"':;?^`|{}";
+            const char   unwanted[] = "$%&!\"':;?^`|{}_";
             char         c          = edit[edit_index] + Direction;
             unsigned int i          = 0;
             while (i < sizeof(unwanted) && c >= 32 && c <= 126)
@@ -1918,25 +2080,13 @@ static void MENU_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
                 }
             }
             edit[edit_index] = (c < 32) ? 126 : (c > 126) ? 32 : c;
+            edit_last_key = 255;
 
             gRequestDisplayScreen = DISPLAY_MENU;
         }
         return;
     }
 
-    if (!bKeyHeld)
-    {
-        if (!bKeyPressed)
-            return;
-
-        gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
-
-        gInputBoxIndex = 0;
-    }
-    else
-    if (!bKeyPressed)
-        return;
-
     if (SCANNER_IsScanning()) {
         return;
     }
@@ -2067,19 +2217,20 @@ void MENU_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
         case KEY_F:
             if (UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME && edit_index >= 0)
             {   // currently editing the channel name
-                if (!bKeyHeld && bKeyPressed)
+                if (!bKeyPressed)
+                    break;
+
+                gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
+
+                if (edit_index < 10)
                 {
-                    gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
-                    if (edit_index < 10)
-                    {
-                        edit[edit_index] = ' ';
-                        if (++edit_index >= 10)
-                        {   // exit edit
-                            gFlagAcceptSetting  = false;
-                            gAskForConfirmation = 1;
-                        }
-                        gRequestDisplayScreen = DISPLAY_MENU;
-                    }
+                    if (bKeyHeld)
+                        edit[edit_index] = '#';
+
+                    edit_is_uppercase = !edit_is_uppercase;
+                    edit_last_key = 255;
+
+                    gRequestDisplayScreen = DISPLAY_MENU;
                 }
                 break;
             }

App/app/scanner.c

@@ -62,7 +62,7 @@ static void SCANNER_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
             gInputBoxIndex = 0;
 
             // uint16_t chan = ((gInputBox[0] * 100) + (gInputBox[1] * 10) + gInputBox[2]) - 1;
-            uint16_t chan = ((gInputBox[0] * 1000) + (gInputBox[1] * 100) + (gInputBox[2] * 10) + gInputBox[3]) - 1;
+            uint16_t chan = (((gInputBox[0] * 10 + gInputBox[1]) * 10 + gInputBox[2]) * 10 + gInputBox[3]) - 1;
             if (IS_MR_CHANNEL(chan)) {
 #ifdef ENABLE_VOICE
                 gAnotherVoiceID = (VOICE_ID_t)Key;
@@ -243,16 +243,13 @@ static void SCANNER_Key_STAR(bool bKeyPressed, bool bKeyHeld)
     return;
 }
 
-static void SCANNER_Key_UP_DOWN(bool bKeyPressed, bool pKeyHeld, int8_t Direction)
+static void SCANNER_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
 {
-    if (pKeyHeld) {
-        if (!bKeyPressed)
-            return;
+    if (!bKeyPressed) {
+        return;
     }
-    else {
-        if (!bKeyPressed)
-            return;
 
+    if (!bKeyHeld) {
         gInputBoxIndex = 0;
         gBeepToPlay    = BEEP_1KHZ_60MS_OPTIONAL;
     }
@@ -266,7 +263,7 @@ static void SCANNER_Key_UP_DOWN(bool bKeyPressed, bool pKeyHeld, int8_t Directio
         gShowChPrefix         = RADIO_CheckValidChannel(gScanChannel, false, 0);
         gRequestDisplayScreen = DISPLAY_SCANNER;
     }
-    else
+    else if (!bKeyHeld)
         gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
 }
 
@@ -345,7 +342,7 @@ void SCANNER_Start(bool singleFreq)
         gScanFrequency = 0xFFFFFFFF;
 
         BK4819_PickRXFilterPathBasedOnFrequency(gScanFrequency);
-        BK4819_EnableFrequencyScan();
+        BK4819_SetFrequencyScan(true);
 
         gUpdateStatus = true;
     }
@@ -418,10 +415,10 @@ void SCANNER_TimeSlice10ms(void)
             else
                 scanHitCount = 0;
 
-            BK4819_DisableFrequencyScan();
+            BK4819_SetFrequencyScan(false);
 
             if (scanHitCount < 3) {
-                BK4819_EnableFrequencyScan();
+                BK4819_SetFrequencyScan(true);
             }
             else {
                 BK4819_SetScanFrequency(gScanFrequency);
@@ -509,8 +506,8 @@ void SCANNER_TimeSlice500ms(void)
     if (SCANNER_IsScanning() && gScannerSaveState == SCAN_SAVE_NO_PROMPT && gScanCssState < SCAN_CSS_STATE_FOUND) {
         gScanProgressIndicator++;
 #ifndef ENABLE_NO_CODE_SCAN_TIMEOUT
-        if (gScanProgressIndicator > 32) {
-            if (gScanCssState == SCAN_CSS_STATE_SCANNING && !gScanSingleFrequency)
+        if (gScanCssState == SCAN_CSS_STATE_SCANNING && gScanProgressIndicator > 32) {
+            if (!gScanSingleFrequency)
                 gScanCssState = SCAN_CSS_STATE_FOUND;
             else
                 gScanCssState = SCAN_CSS_STATE_FAILED;
@@ -528,4 +525,4 @@ void SCANNER_TimeSlice500ms(void)
 bool SCANNER_IsScanning(void)
 {
     return gCssBackgroundScan || (gScreenToDisplay == DISPLAY_SCANNER);
-}
+}

App/app/spectrum.h

@@ -42,7 +42,8 @@
 #include <stdint.h>
 #include <string.h>
 
-static const uint8_t DrawingEndY = 40;
+static const uint8_t DrawingEndY  = 40;
+static const uint8_t DrawingTopY  =  8;  // Reserve top 8px for frequency display (gFrameBuffer[0])
 
 static const uint8_t U8RssiMap[] = {
     121,
@@ -78,29 +79,35 @@ static const uint16_t scanStepValues[] = {
 static const uint16_t scanStepBWRegValues[] = {
     //     RX  RXw TX  BW
     // 0b0 000 000 001 01 1000
-    // 1
+    // 1    (S_STEP_0_01kHz, index 0)
     0b0000000001011000, // 6.25
-    // 10
+    // 10   (S_STEP_0_1kHz,  index 1)
     0b0000000001011000, // 6.25
-    // 50
+    // 50   (S_STEP_0_5kHz,  index 2)
     0b0000000001011000, // 6.25
-    // 100
+    // 100  (S_STEP_1_0kHz,  index 3)
     0b0000000001011000, // 6.25
-    // 250
+    // 250  (S_STEP_2_5kHz,  index 4)
     0b0000000001011000, // 6.25
-    // 500
+    // 500  (S_STEP_5_0kHz,  index 5)
     0b0010010001011000, // 6.25
-    // 625
+    // 625  (S_STEP_6_25kHz, index 6)
     0b0100100001011000, // 6.25
-    // 833
+    // 833  (S_STEP_8_33kHz, index 7)
     0b0110110001001000, // 6.25
-    // 1000
+    // 1000 (S_STEP_10_0kHz, index 8)
     0b0110110001001000, // 6.25
-    // 1250
+    // 1250 (S_STEP_12_5kHz, index 9)
     0b0111111100001000, // 6.25
-    // 2500
+    // 1500 (S_STEP_15_0kHz, index 10)
     0b0011011000101000, // 25
-    // 10000
+    // 2000 (S_STEP_20_0kHz, index 11)
+    0b0011011000101000, // 25
+    // 2500 (S_STEP_25_0kHz, index 12)
+    0b0011011000101000, // 25
+    // 5000 (S_STEP_50_0kHz, index 13)
+    0b0011011000101000, // 25
+    // 10000 (S_STEP_100_0kHz, index 14)
     0b0011011000101000, // 25
 };
 

App/app/uart.c

@@ -347,9 +347,9 @@ static void CMD_0514(uint32_t Port, const uint8_t *pBuffer)
 #endif
 
     gSerialConfigCountDown_500ms = 12; // 6 sec
-    
-    // turn the LCD backlight off
-    BACKLIGHT_TurnOff();
+
+    if (gEeprom.BACKLIGHT_TIME < 61) // backlight is set to be always on
+        BACKLIGHT_TurnOff();         // turn the LCD backlight off
 
     SendVersion(Port);
 }
@@ -593,8 +593,8 @@ static void CMD_052F(uint32_t Port, const uint8_t *pBuffer)
     }
 #endif
 
-    // turn the LCD backlight off
-    BACKLIGHT_TurnOff();
+    if (gEeprom.BACKLIGHT_TIME < 61) // backlight is set to be always on
+        BACKLIGHT_TurnOff();         // turn the LCD backlight off
 
     SendVersion(Port);
 }

App/audio.c

@@ -33,32 +33,32 @@
 #include "settings.h"
 #include "ui/ui.h"
 
+static const uint16_t BEEP_Classic_array[][3] = { /* Tone    Duration    Repeats  */                                     
+    [BEEP_NONE]                                   = {0,      0,          0      },
+    [BEEP_1KHZ_60MS_OPTIONAL]                     = {1000,   60,         1      },
+    [BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL]        = {500,    60,         2      },
+#ifdef ENABLE_DTMF_CALLING
+    [BEEP_880HZ_200MS]                            = {880,    200,        1      },
+    [BEEP_880HZ_500MS]                            = {880,    500,        1      },
+#endif
+#ifdef ENABLE_FEAT_F4HWN
+    [BEEP_400HZ_30MS]                             = {400,    30,         1      },
+    [BEEP_500HZ_30MS]                             = {500,    30,         1      },
+    [BEEP_600HZ_30MS]                             = {600,    30,         1      },
+#endif
+    [BEEP_880HZ_60MS_TRIPLE_BEEP]                 = {880,    60,         3      }
+};
 
 BEEP_Type_t gBeepToPlay = BEEP_NONE;
 
-static void AUDIO_PlayBeepPulse(void) {
-    BK4819_ExitTxMute();
-    SYSTEM_DelayMs(60);
-    BK4819_EnterTxMute();
-    SYSTEM_DelayMs(20);
-}
-
 void AUDIO_PlayBeep(BEEP_Type_t Beep)
 {
+    if (Beep == BEEP_NONE)
+        return;
 
-    if (Beep != BEEP_880HZ_60MS_DOUBLE_BEEP &&
-        Beep != BEEP_500HZ_60MS_DOUBLE_BEEP &&
-        Beep != BEEP_440HZ_500MS &&
-#ifdef ENABLE_DTMF_CALLING
-        Beep != BEEP_880HZ_200MS &&
-        Beep != BEEP_880HZ_500MS &&
-#endif
-#ifdef ENABLE_FEAT_F4HWN
-        Beep != BEEP_400HZ_30MS &&
-        Beep != BEEP_500HZ_30MS &&
-        Beep != BEEP_600HZ_30MS &&
-#endif
-       !gEeprom.BEEP_CONTROL)
+    if ((Beep == BEEP_1KHZ_60MS_OPTIONAL ||
+         Beep == BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL) &&
+         !gEeprom.BEEP_CONTROL)
         return;
         
     if (gCurrentFunction == FUNCTION_RECEIVE)
@@ -67,6 +67,9 @@ void AUDIO_PlayBeep(BEEP_Type_t Beep)
     if (gCurrentFunction == FUNCTION_MONITOR)
         return;
 
+    if (Beep >= ARRAY_SIZE(BEEP_Classic_array))
+        return;
+
 #ifdef ENABLE_FMRADIO
     if (gFmRadioMode)
         BK1080_Mute(true);
@@ -81,49 +84,14 @@ void AUDIO_PlayBeep(BEEP_Type_t Beep)
 
     uint16_t ToneConfig = BK4819_ReadRegister(BK4819_REG_71);
 
-    uint16_t ToneFrequency;
-    switch (Beep)
-    {
-        default:
-        case BEEP_NONE:
-            ToneFrequency = 220;
-            break;
-        case BEEP_1KHZ_60MS_OPTIONAL:
-            ToneFrequency = 1000;
-            break;
-        case BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL:
-        case BEEP_500HZ_60MS_DOUBLE_BEEP:
-            ToneFrequency = 500;
-            break;
-        case BEEP_440HZ_500MS:
-            ToneFrequency = 440;
-            break;
-        case BEEP_880HZ_60MS_DOUBLE_BEEP:
-#ifndef ENABLE_FEAT_F4HWN
-        case BEEP_880HZ_200MS:
-        case BEEP_880HZ_500MS:
-#endif
-            ToneFrequency = 880;
-            break;
 #ifdef ENABLE_FEAT_F4HWN
-        case BEEP_400HZ_30MS:
-            ToneFrequency = 400;
-            break;
-        case BEEP_500HZ_30MS:
-            ToneFrequency = 500;
-            break;
-        case BEEP_600HZ_30MS:
-            ToneFrequency = 600;
-            break;
-#endif
-    }
-
     if(Beep == BEEP_400HZ_30MS || Beep == BEEP_500HZ_30MS || Beep == BEEP_600HZ_30MS)
     {
         BK4819_WriteRegister(BK4819_REG_70, BK4819_REG_70_ENABLE_TONE1 | ((1 & 0x7f) << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN));
     }
+#endif
 
-    BK4819_PlayTone(ToneFrequency, true);
+    BK4819_PrepareToPlayTone(true);
 
     SYSTEM_DelayMs(2);
 
@@ -131,46 +99,12 @@ void AUDIO_PlayBeep(BEEP_Type_t Beep)
 
     SYSTEM_DelayMs(60);
 
-    uint16_t Duration;
-    switch (Beep)
-    {
-        case BEEP_880HZ_60MS_DOUBLE_BEEP:
-            AUDIO_PlayBeepPulse();
-            [[fallthrough]];
-        case BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL:
-        case BEEP_500HZ_60MS_DOUBLE_BEEP:
-            AUDIO_PlayBeepPulse();
-            [[fallthrough]];
-        case BEEP_1KHZ_60MS_OPTIONAL:
-            BK4819_ExitTxMute();
-            Duration = 60;
-            break;
-#ifdef ENABLE_FEAT_F4HWN
-        case BEEP_400HZ_30MS:
-        case BEEP_500HZ_30MS:
-        case BEEP_600HZ_30MS:
-            BK4819_ExitTxMute();
-            Duration = 30;
-            break;
-#endif
-        case BEEP_440HZ_500MS:
-#ifndef ENABLE_FEAT_F4HWN
-        case BEEP_880HZ_200MS:
-            BK4819_ExitTxMute();
-            Duration = 200;
-            break;
-        case BEEP_880HZ_500MS:
-#endif
-        default:
-            BK4819_ExitTxMute();
-            Duration = 500;
-            break;
+    for (uint8_t i = 0; i < BEEP_Classic_array[Beep][BEEP_REPEATS]; i++) {
+        BK4819_PlayToneRaw( BEEP_Classic_array[Beep][BEEP_TONE], 
+                            BEEP_Classic_array[Beep][BEEP_DURATION]);
+        SYSTEM_DelayMs(20);
     }
 
-    SYSTEM_DelayMs(Duration);
-    BK4819_EnterTxMute();
-    SYSTEM_DelayMs(20);
-
     AUDIO_AudioPathOff();
 
     SYSTEM_DelayMs(5);
@@ -185,7 +119,6 @@ void AUDIO_PlayBeep(BEEP_Type_t Beep)
         SYSTEM_DelayMs(10);
 #endif
 
-
     if (gEnableSpeaker)
         AUDIO_AudioPathOn();
 
@@ -200,7 +133,6 @@ void AUDIO_PlayBeep(BEEP_Type_t Beep)
 #ifdef ENABLE_VOX
     gVoxResumeCountdown = 80;
 #endif
-
 }
 
 #ifdef ENABLE_VOICE

App/audio.h

@@ -22,23 +22,28 @@
 
 #include "driver/gpio.h"
 
+enum {
+    BEEP_TONE = 0,
+    BEEP_DURATION,
+    BEEP_REPEATS
+};
+
+
 enum BEEP_Type_t
 {
     BEEP_NONE = 0,
     BEEP_1KHZ_60MS_OPTIONAL,
     BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL,
-    BEEP_440HZ_500MS,
 #ifdef ENABLE_DTMF_CALLING
     BEEP_880HZ_200MS,
     BEEP_880HZ_500MS,
 #endif
-    BEEP_500HZ_60MS_DOUBLE_BEEP,
 #ifdef ENABLE_FEAT_F4HWN
     BEEP_400HZ_30MS,
     BEEP_500HZ_30MS,
     BEEP_600HZ_30MS,
 #endif
-    BEEP_880HZ_60MS_DOUBLE_BEEP
+    BEEP_880HZ_60MS_TRIPLE_BEEP
 };
 
 typedef enum BEEP_Type_t BEEP_Type_t;

App/bitmaps.c

@@ -57,6 +57,21 @@ const uint8_t gFontLight[9] =
     0b00001100,
 };
 
+// Same bulb outline as gFontLight with the inner filament removed,
+// used when the manual backlight is currently off
+const uint8_t gFontLightOff[9] =
+{
+    0b00001100,
+    0b00010010,
+    0b00100001,
+    0b01100001,
+    0b01100001,
+    0b01100001,
+    0b00100001,
+    0b00010010,
+    0b00001100,
+};
+
 const uint8_t gFontMute[12] =
 {
     0b00011100,

App/bitmaps.h

@@ -12,6 +12,7 @@ extern const uint8_t gFontS[6];
 
 extern const uint8_t gFontKeyLock[9];
 extern const uint8_t gFontLight[9];
+extern const uint8_t gFontLightOff[9];
 extern const uint8_t gFontMute[12];
 
 extern const uint8_t gFontXB[2][6];

App/dcs.c

@@ -14,6 +14,7 @@
  *     limitations under the License.
  */
 
+#include <stddef.h>
 #include "dcs.h"
 #include "misc.h"
 
@@ -26,6 +27,12 @@ const uint16_t CTCSS_Options[50] = {
     2035, 2065, 2107, 2181, 2257, 2291, 2336, 2418, 2503, 2541
 };
 
+// Indices in CTCSS_Options for the 12 non-homologated tones.
+static const uint8_t CTCSS_ExtraIdx[12] = {
+     1, 26, 28, 30, 32, 34, 36, 38, 39, 41,
+    45, 49
+};
+
 const uint16_t DCS_Options[104] = {
     0x0013, 0x0015, 0x0016, 0x0019, 0x001A, 0x001E, 0x0023, 0x0027,
     0x0029, 0x002B, 0x002C, 0x0035, 0x0039, 0x003A, 0x003B, 0x003C,
@@ -42,6 +49,13 @@ const uint16_t DCS_Options[104] = {
     0x01C3, 0x01CA, 0x01D3, 0x01D9, 0x01DA, 0x01DC, 0x01E3, 0x01EC,
 };
 
+// Indices in DCS_Options for the 21 non-PMR446 DCS codes.
+static const uint8_t DCS_ExtraIdx[21] = {
+     5,  9, 19, 25, 34, 36, 41, 43, 44, 48,
+    50, 54, 56, 60, 71, 72, 73, 74, 75, 82,
+    83
+};
+
 static uint32_t DCS_CalculateGolay(uint32_t CodeWord)
 {
     unsigned int i;
@@ -108,3 +122,40 @@ uint8_t DCS_GetCtcssCode(int Code)
 
     return Result;
 }
+
+static uint8_t DCS_GetApprovedIndex(uint8_t Option, size_t options_size, size_t extraidx_size, const uint8_t *extraidx)
+{
+    unsigned int i;
+    unsigned int extra_pos = 0;
+    uint8_t approved_index = 0;
+
+    if (Option >= options_size)
+        return 0xFF;
+
+    for (i = 0; i < options_size; i++) {
+        const bool is_extra = extra_pos < extraidx_size &&
+                              i == extraidx[extra_pos];
+
+        if (is_extra) {
+            extra_pos++;
+            continue;
+        }
+
+        if (i == Option)
+            return approved_index;
+
+        approved_index++;
+    }
+
+    return 0xFF;
+}
+
+uint8_t DCS_GetCtcssApprovedIndex(uint8_t Option)
+{
+    return DCS_GetApprovedIndex(Option, ARRAY_SIZE(CTCSS_Options), ARRAY_SIZE(CTCSS_ExtraIdx), CTCSS_ExtraIdx);
+}
+
+uint8_t DCS_GetDcsApprovedIndex(uint8_t Option)
+{
+    return DCS_GetApprovedIndex(Option, ARRAY_SIZE(DCS_Options), ARRAY_SIZE(DCS_ExtraIdx), DCS_ExtraIdx);
+}

App/dcs.h

@@ -40,6 +40,7 @@ extern const uint16_t DCS_Options[104];
 uint32_t DCS_GetGolayCodeWord(DCS_CodeType_t CodeType, uint8_t Option);
 uint8_t DCS_GetCdcssCode(uint32_t Code);
 uint8_t DCS_GetCtcssCode(int Code);
+uint8_t DCS_GetCtcssApprovedIndex(uint8_t Option);
+uint8_t DCS_GetDcsApprovedIndex(uint8_t Option);
 
 #endif
-

App/driver/backlight.c

@@ -32,7 +32,9 @@
 #endif
 
 #define PWM_FREQ 4000
-#define DUTY_CYCLE_LEVELS 64
+// 32 levels keep every step of the value[] table distinct after
+// quantization while halving the DMA duty cycle buffer (128 bytes saved)
+#define DUTY_CYCLE_LEVELS 32
 
 #define DUTY_CYCLE_ON_VALUE GPIO_PIN_MASK(GPIO_PIN_BACKLIGHT)
 #define DUTY_CYCLE_OFF_VALUE (DUTY_CYCLE_ON_VALUE << 16)
@@ -56,8 +58,8 @@ static int16_t fadeStep = 0;
     const uint8_t value[] = {
         0,    // 0 off
         8,    // 1 visible in the dark
-        14,   // 2
-        22,   // 3
+        16,   // 2
+        24,   // 3
         32,   // 4
         48,   // 5
         72,   // 6
@@ -107,10 +109,15 @@ void BACKLIGHT_InitHardware()
 
 static void BACKLIGHT_Sound(void)
 {
-    if (gEeprom.POWER_ON_DISPLAY_MODE == POWER_ON_DISPLAY_MODE_SOUND || gEeprom.POWER_ON_DISPLAY_MODE == POWER_ON_DISPLAY_MODE_ALL)
+    if (gEeprom.POWER_ON_DISPLAY_MODE == POWER_ON_DISPLAY_MODE_SOUND ||
+        gEeprom.POWER_ON_DISPLAY_MODE == POWER_ON_DISPLAY_MODE_ALL
+#ifdef ENABLE_FEAT_F4HWN_LOGO
+        || gEeprom.POWER_ON_DISPLAY_MODE == POWER_ON_DISPLAY_MODE_LOGO
+#endif
+    )
     {
-        AUDIO_PlayBeep(BEEP_880HZ_60MS_DOUBLE_BEEP);
-        AUDIO_PlayBeep(BEEP_880HZ_60MS_DOUBLE_BEEP);
+        AUDIO_PlayBeep(BEEP_880HZ_60MS_TRIPLE_BEEP);
+        AUDIO_PlayBeep(BEEP_880HZ_60MS_TRIPLE_BEEP);
     }
 
     gK5startup = false;

App/driver/bk4819.h

@@ -105,7 +105,9 @@ void     BK4819_SetCompander(const unsigned int mode);
 void     BK4819_DisableVox(void);
 void     BK4819_DisableDTMF(void);
 void     BK4819_EnableDTMF(void);
+void     BK4819_PrepareToPlayTone(bool bTuningGainSwitch);
 void     BK4819_PlayTone(uint16_t Frequency, bool bTuningGainSwitch);
+void     BK4819_PlayToneRaw(const unsigned int tone_Hz, const unsigned int delay);
 void     BK4819_PlaySingleTone(const unsigned int tone_Hz, const unsigned int delay, const unsigned int level, const bool play_speaker);
 void     BK4819_EnterTxMute(void);
 void     BK4819_ExitTxMute(void);
@@ -147,11 +149,11 @@ uint8_t  BK4819_GetGlitchIndicator(void);
 uint8_t  BK4819_GetExNoiceIndicator(void);
 uint16_t BK4819_GetVoiceAmplitudeOut(void);
 uint8_t  BK4819_GetAfTxRx(void);
+void     BK4819_SetRxAudioGain(void);
 
 bool     BK4819_GetFrequencyScanResult(uint32_t *pFrequency);
 BK4819_CssScanResult_t BK4819_GetCxCSSScanResult(uint32_t *pCdcssFreq, uint16_t *pCtcssFreq);
-void     BK4819_DisableFrequencyScan(void);
-void     BK4819_EnableFrequencyScan(void);
+void     BK4819_SetFrequencyScan(bool enable);
 void     BK4819_SetScanFrequency(uint32_t Frequency);
 
 void     BK4819_Disable(void);

App/driver/bk4829.c

@@ -39,6 +39,16 @@ static const uint16_t FSK_RogerTable[7] = {0xF1A2, 0x7446, 0x61A4, 0x6544, 0x4E8
 
 static uint16_t gBK4819_GpioOutState;
 
+#define SHORT_DELAY()                                                          \
+  __asm volatile("nop\n nop\n nop\n nop\n nop\n"                               \
+                 "nop\n nop\n nop\n nop\n nop\n"                               \
+                 "nop\n nop\n nop\n nop\n nop\n"                               \
+                 "nop\n nop\n nop\n nop\n nop\n"                               \
+                 "nop\n nop\n nop\n nop\n nop\n"                               \
+                 "nop\n nop\n nop\n nop\n nop\n"                               \
+                 "nop\n nop\n nop\n nop\n nop\n"                               \
+                 "nop\n nop\n nop\n nop\n nop\n")
+
 bool gRxIdleMode;
 
 static inline void CS_Assert()
@@ -197,63 +207,78 @@ static uint16_t BK4819_ReadU16(void)
     uint16_t     Value;
 
     SDA_SetDir(false);
-    SYSTICK_DelayUs(1);
+    SHORT_DELAY();
     Value = 0;
     for (i = 0; i < 16; i++)
     {
         Value <<= 1;
         Value |= SDA_ReadInput();
         SCL_Set();
-        SYSTICK_DelayUs(1);
+        SHORT_DELAY();
         SCL_Reset();
-        SYSTICK_DelayUs(1);
+        SHORT_DELAY();
     }
     SDA_SetDir(true);
 
     return Value;
 }
 
+static uint16_t reg_30_cache = 0xFFFF;
+static uint16_t reg_47_cache = 0xFFFF;
+
 uint16_t BK4819_ReadRegister(BK4819_REGISTER_t Register)
 {
     uint16_t Value;
 
     CS_Release();
     SCL_Reset();
-
-    SYSTICK_DelayUs(1);
+    SHORT_DELAY();
 
     CS_Assert();
     BK4819_WriteU8(Register | 0x80);
     Value = BK4819_ReadU16();
     CS_Release();
-
-    SYSTICK_DelayUs(1);
+    SHORT_DELAY();
 
     SCL_Set();
     SDA_Set();
 
+    if (Register == BK4819_REG_30)
+        reg_30_cache = Value;
+    else if (Register == BK4819_REG_47)
+        reg_47_cache = Value;
+
     return Value;
 }
 
 void BK4819_WriteRegister(BK4819_REGISTER_t Register, uint16_t Data)
 {
+    if (Register == BK4819_REG_30)
+    {
+        if (Data == reg_30_cache)
+            return;
+        reg_30_cache = Data;
+    }
+    else if (Register == BK4819_REG_47)
+    {
+        if (Data == reg_47_cache)
+            return;
+        reg_47_cache = Data;
+    }
+
     CS_Release();
     SCL_Reset();
-
-    SYSTICK_DelayUs(1);
+    SHORT_DELAY();
 
     CS_Assert();
     BK4819_WriteU8(Register);
-
-    SYSTICK_DelayUs(1);
+    SHORT_DELAY();
 
     BK4819_WriteU16(Data);
-
-    SYSTICK_DelayUs(1);
+    SHORT_DELAY();
 
     CS_Release();
-
-    SYSTICK_DelayUs(1);
+    SHORT_DELAY();
 
     SCL_Set();
     SDA_Set();
@@ -271,14 +296,14 @@ void BK4819_WriteU8(uint8_t Data)
         else
             SDA_Set();
 
-        SYSTICK_DelayUs(1);
+        SHORT_DELAY();
         SCL_Set();
-        SYSTICK_DelayUs(1);
+        SHORT_DELAY();
 
         Data <<= 1;
 
         SCL_Reset();
-        SYSTICK_DelayUs(1);
+        SHORT_DELAY();
     }
 }
 
@@ -294,14 +319,14 @@ void BK4819_WriteU16(uint16_t Data)
         else
             SDA_Set();
 
-        SYSTICK_DelayUs(1);
+        SHORT_DELAY();
         SCL_Set();
 
         Data <<= 1;
 
-        SYSTICK_DelayUs(1);
+        SHORT_DELAY();
         SCL_Reset();
-        SYSTICK_DelayUs(1);
+        SHORT_DELAY();
     }
 }
 
@@ -1006,7 +1031,7 @@ void BK4819_EnableDTMF(void)
         (15u       << BK4819_REG_24_SHIFT_MAX_SYMBOLS));     // 0 ~ 15
 }
 
-void BK4819_PlayTone(uint16_t Frequency, bool bTuningGainSwitch)
+void BK4819_PrepareToPlayTone(bool bTuningGainSwitch)
 {
     uint16_t ToneConfig = BK4819_REG_70_ENABLE_TONE1;
 
@@ -1021,10 +1046,23 @@ void BK4819_PlayTone(uint16_t Frequency, bool bTuningGainSwitch)
 
     BK4819_WriteRegister(BK4819_REG_30, 0);
     BK4819_WriteRegister(BK4819_REG_30, BK4819_REG_30_ENABLE_AF_DAC | BK4819_REG_30_ENABLE_DISC_MODE | BK4819_REG_30_ENABLE_TX_DSP);
+}
+
+void BK4819_PlayTone(uint16_t Frequency, bool bTuningGainSwitch)
+{
+    BK4819_PrepareToPlayTone(bTuningGainSwitch);
 
     BK4819_WriteRegister(BK4819_REG_71, scale_freq(Frequency));
 }
 
+void BK4819_PlayToneRaw(const unsigned int tone_Hz, const unsigned int delay) {
+    BK4819_WriteRegister(BK4819_REG_71, scale_freq(tone_Hz));
+
+    BK4819_ExitTxMute();
+    SYSTEM_DelayMs(delay);
+    BK4819_EnterTxMute();
+}
+
 // level 0 ~ 127
 void BK4819_PlaySingleTone(const unsigned int tone_Hz, const unsigned int delay, const unsigned int level, const bool play_speaker)
 {
@@ -1044,11 +1082,7 @@ void BK4819_PlaySingleTone(const unsigned int tone_Hz, const unsigned int delay,
     BK4819_EnableTXLink();
     SYSTEM_DelayMs(50);
 
-    BK4819_WriteRegister(BK4819_REG_71, scale_freq(tone_Hz));
-
-    BK4819_ExitTxMute();
-    SYSTEM_DelayMs(delay);
-    BK4819_EnterTxMute();
+    BK4819_PlayToneRaw(tone_Hz, delay);
 
     if (play_speaker)
     {
@@ -1432,24 +1466,15 @@ void BK4819_GenTail(uint8_t Tail)
     //                          freq(Hz) * 20.64888 for XTAL 13M/26M or
     //                          freq(Hz)*20.97152 for XTAL 12.8M/19.2M/25.6M/38.4M
 
-    switch (Tail)
-    {
-        case 0: // 134.4Hz CTCSS Tail
-            BK4819_WriteRegister(BK4819_REG_52, 0x828F);   // 1 00 0 001010 001111
-            break;
-        case 1: // 120° phase shift
-            BK4819_WriteRegister(BK4819_REG_52, 0xA28F);   // 1 01 0 001010 001111
-            break;
-        case 2: // 180° phase shift
-            BK4819_WriteRegister(BK4819_REG_52, 0xC28F);   // 1 10 0 001010 001111
-            break;
-        case 3: // 240° phase shift
-            BK4819_WriteRegister(BK4819_REG_52, 0xE28F);   // 1 11 0 001010 001111
-            break;
-        case 4: // 55Hz tone freq
-            BK4819_WriteRegister(BK4819_REG_07, 0x046f);   // 0 00 0 010001 101111
-            break;
-    }
+    if (Tail <= 3)
+        // 0: 134.4Hz CTCSS Tail
+        // 1: 120° phase shift
+        // 2: 180° phase shift
+        // 3: 240° phase shift
+        BK4819_WriteRegister(BK4819_REG_52, 0x028F | (Tail << 13));
+    else if (Tail == 4)
+        // 4: 55Hz tone freq
+        BK4819_WriteRegister(BK4819_REG_07, 0x046F);
 }
 
 void BK4819_PlayCDCSSTail(void)
@@ -1531,6 +1556,14 @@ uint8_t BK4819_GetAfTxRx(void)
     return BK4819_ReadRegister(BK4819_REG_6F) & 0x003F;
 }
 
+void BK4819_SetRxAudioGain(void) {
+    BK4819_WriteRegister(BK4819_REG_48,
+        (11u << 12)                |     // ??? .. 0 ~ 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)
+}
+
 bool BK4819_GetFrequencyScanResult(uint32_t *pFrequency)
 {
     const uint16_t High     = BK4819_ReadRegister(BK4819_REG_0D);
@@ -1566,7 +1599,7 @@ BK4819_CssScanResult_t BK4819_GetCxCSSScanResult(uint32_t *pCdcssFreq, uint16_t
     return BK4819_CSS_RESULT_NOT_FOUND;
 }
 
-void BK4819_DisableFrequencyScan(void)
+void BK4819_SetFrequencyScan(bool enable)
 {
     // REG_32
     //
@@ -1582,32 +1615,10 @@ void BK4819_DisableFrequencyScan(void)
     //         1 = enable
     //         0 = disable
     //
-    BK4819_WriteRegister(BK4819_REG_32, // 0x0244);    // 00 0000100100010 0
+    BK4819_WriteRegister(BK4819_REG_32,
         (  0u << 14) |          // 0 frequency scan Time
         (290u <<  1) |          // ???
-        (  0u <<  0));          // 0 frequency scan enable
-}
-
-void BK4819_EnableFrequencyScan(void)
-{
-    // REG_32
-    //
-    // <15:14> 0 frequency scan time
-    //         0 = 0.2 sec
-    //         1 = 0.4 sec
-    //         2 = 0.8 sec
-    //         3 = 1.6 sec
-    //
-    // <13:1>  ???
-    //
-    // <0>     0 frequency scan enable
-    //         1 = enable
-    //         0 = disable
-    //
-    BK4819_WriteRegister(BK4819_REG_32, // 0x0245);   // 00 0000100100010 1
-        (  0u << 14) |          // 0 frequency scan time
-        (290u <<  1) |          // ???
-        (  1u <<  0));          // 1 frequency scan enable
+        (enable ? 1u : 0u));    // frequency scan (1: enable | 0: disable)
 }
 
 void BK4819_SetScanFrequency(uint32_t Frequency)
@@ -1671,7 +1682,7 @@ void BK4819_Disable(void)
 
 void BK4819_StopScan(void)
 {
-    BK4819_DisableFrequencyScan();
+    BK4819_SetFrequencyScan(false);
     BK4819_Disable();
 }
 
@@ -1765,17 +1776,8 @@ static void BK4819_PlayRogerNormal(void)
     BK4819_EnableTXLink();
     SYSTEM_DelayMs(50);
 
-    BK4819_WriteRegister(BK4819_REG_71, scale_freq(tone1_Hz));
-
-    BK4819_ExitTxMute();
-    SYSTEM_DelayMs(80);
-    BK4819_EnterTxMute();
-
-    BK4819_WriteRegister(BK4819_REG_71, scale_freq(tone2_Hz));
-
-    BK4819_ExitTxMute();
-    SYSTEM_DelayMs(80);
-    BK4819_EnterTxMute();
+    BK4819_PlayToneRaw(tone1_Hz, 80);
+    BK4819_PlayToneRaw(tone2_Hz, 80);
 
     BK4819_WriteRegister(BK4819_REG_70, 0x0000);
     BK4819_WriteRegister(BK4819_REG_30, 0xC1FE);   // 1 1 0000 0 1 1111 1 1 1 0

App/driver/eeprom_compat.c

@@ -59,13 +59,19 @@ static const AddrMapping_t ADDR_MAPPINGS[] = {
                                                 // MR FM * 128 Bytes (0x003000)             0x00A028 -> 0x00A0A8
                                                 // Settings * 80 Bytes (0x007000)           0x00A0A8 -> 0x00A0F8
                                                 // Settings * 56 Bytes (0x008000)           0x00A0F8 -> 0x00A130
-                                                // Settings Scanlist * 8 Bytes (0x009000)   0x00A130 -> 0x00A140
-                                                // Settings AES * 16 Bytes (0x00A000)       0x00A140 -> 0x00A150
+                                                // Settings Scanlist * 8 Bytes (0x009000)   0x00A130 -> 0x00A138
+                                                // Settings AES * 16 Bytes (0x00A000)       0x00A138 -> 0x00A148
+                                                // Settings Spectrum * 8 Bytes              0x00A148 -> 0x00A150
                                                 // Settings * 8 Bytes (0x00B000)            0x00A150 -> 0x00A158
                                                 // Settings F4HWN * 8 Bytes (0x00C000)      0x00A158 -> 0x00A160
                                                 // Settings Version * 16 Bytes              0x00A160 -> 0x00A170
 
     _MK_MAPPING(0x010000, 0x00B000, 0x00B200),  // Calibration 512 Bytes!!!
+
+    _MK_MAPPING(0x011000, 0x00C000, 0x00D000),  // Boot Logo sector (4 KB):
+                                                // [0x00..0x07] 8-byte header (reserved)
+                                                // [0x08..0x407] 128x64 monochrome bitmap, 1024 Bytes
+                                                // ST7565-native: 8 pages * 128 columns, column-major LSB-top
 };
 
 static void AddrTranslate(uint16_t EEPROM_Addr, uint16_t Size, uint32_t *PY25Q16_Addr_out, uint16_t *Size_out, bool *End_out);

App/font.c

@@ -362,7 +362,7 @@ const uint8_t gFontSmall[95-1][6] =
     {0x20, 0x40, 0x40, 0x3D, 0x00, 0x00},    // 'j'
     {0x00, 0x7F, 0x10, 0x28, 0x44, 0x00},    // 'k'
     {0x00, 0x00, 0x3F, 0x40, 0x00, 0x00},    // 'l'
-    {0x7C, 0x08, 0x10, 0x10, 0x08, 0x7C},    // 'm'
+    {0x7C, 0x04, 0x7C, 0x04, 0x78, 0x00},    // 'm'
     {0x7C, 0x04, 0x04, 0x04, 0x78, 0x00},    // 'n'
     {0x38, 0x44, 0x44, 0x44, 0x38, 0x00},    // 'o'
     {0x7C, 0x14, 0x14, 0x14, 0x08, 0x00},    // 'p'

App/functions.c

@@ -151,7 +151,7 @@ void FUNCTION_Transmit()
 
     // clear the DTMF RX live decoder buffer
     gDTMF_RX_live_timeout = 0;
-    memset(gDTMF_RX_live, 0, sizeof(gDTMF_RX_live));
+    DTMF_clear_input_box_memory();
 
 #if defined(ENABLE_FMRADIO)
     if (gFmRadioMode)

App/helper/battery.c

@@ -228,7 +228,7 @@ void BATTERY_TimeSlice500ms(void)
 
     if (lowBatteryCountdown < lowBatteryPeriod) {
         if (lowBatteryCountdown == lowBatteryPeriod-1 && !gChargingWithTypeC && !gLowBatteryConfirmed) {
-            AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP);
+            AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL);
         }
         return;
     }
@@ -241,7 +241,7 @@ void BATTERY_TimeSlice500ms(void)
 
     // not on charge
     if (!gLowBatteryConfirmed) {
-        AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP);
+        AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL);
 #ifdef ENABLE_VOICE
         AUDIO_SetVoiceID(0, VOICE_ID_LOW_VOLTAGE);
 #endif

App/helper/boot.c

@@ -73,12 +73,14 @@ BOOT_Mode_t BOOT_GetMode(void)
 
 void BOOT_ProcessMode(BOOT_Mode_t Mode)
 {
+    GUI_DisplayType_t display = DISPLAY_MAIN;
+
     if (Mode == BOOT_MODE_F_LOCK)
     {
         #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
             gEeprom.CURRENT_STATE = 0; // Don't resume is active...
         #endif 
-        GUI_SelectNextDisplay(DISPLAY_MENU);
+        display = DISPLAY_MENU;
     }
     #ifdef ENABLE_AIRCOPY
         else
@@ -119,11 +121,9 @@ void BOOT_ProcessMode(BOOT_Mode_t Mode)
                 gEeprom.CURRENT_STATE = 0; // Don't resume is active...
             #endif 
 
-            GUI_SelectNextDisplay(DISPLAY_AIRCOPY);
+            display = DISPLAY_AIRCOPY;
         }
     #endif
-    else
-    {
-        GUI_SelectNextDisplay(DISPLAY_MAIN);
-    }
+
+    GUI_SelectNextDisplay(display);
 }

App/main.c

@@ -157,11 +157,7 @@ void Main(void)
         #ifdef ENABLE_FEAT_F4HWN
             gEeprom.KEY_LOCK = 0;
             SETTINGS_SaveSettings();
-            gMenuCursor = MENU_ITEMS; 
-            
-            #ifdef ENABLE_NOAA
-                gMenuCursor += 1; // move to hidden section, fix me if change... !!!
-            #endif
+            gMenuCursor = UI_MENU_GetMenuIdx(FIRST_HIDDEN_MENU_ITEM);
             gSubMenuSelection = gSetting_F_LOCK;
         #endif
     }

App/misc.c

@@ -116,6 +116,10 @@ enum BacklightOnRxTx_t gSetting_backlight_on_tx_rx;
     bool          gWakeUp = false;
 #endif
 
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+    bool          gSetting_set_scn = 1;
+#endif
+
 #ifdef ENABLE_FEAT_F4HWN
     uint8_t       gSetting_set_pwr = 1;
     bool          gSetting_set_ptt = 0;
@@ -133,6 +137,9 @@ enum BacklightOnRxTx_t gSetting_backlight_on_tx_rx;
     #ifdef ENABLE_FEAT_F4HWN_NARROWER
         bool          gSetting_set_nfm = 0;
     #endif
+    #ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+        uint8_t       gSetting_set_sav = SET_SAV_OFF;
+    #endif
     bool          gSetting_set_tmr = 0;
     bool          gSetting_set_ptt_session;
     #ifdef ENABLE_FEAT_F4HWN_DEBUG
@@ -649,4 +656,4 @@ void MR_PrintCacheStats(void)
         
         return false;
     }
-#endif
+#endif

App/misc.h

@@ -39,8 +39,6 @@
 #define FM_CHANNELS_MAX 48
 #define MR_CHANNELS_MAX 1024
 #define MR_CHANNELS_LIST 24
-#define MENU_ITEMS 69
-
 // CACHE-BASED OPTIMIZATION: Only keep active channels in RAM
 // Full array stays in EEPROM, cache holds ~10 most-used channels
 #define MR_CHANNELS_CACHE_SIZE 10
@@ -178,7 +176,21 @@ extern enum BacklightOnRxTx_t gSetting_backlight_on_tx_rx;
     extern bool              gWakeUp;
 #endif
 
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+    extern bool              gSetting_set_scn;
+#endif
+
 #ifdef ENABLE_FEAT_F4HWN
+    #ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+        enum SET_SAV_t {
+            SET_SAV_OFF,
+            SET_SAV_LOGO,
+            SET_SAV_LOGO_PLUS,
+            SET_SAV_MATRIX,
+            SET_SAV_LEN
+        };
+    #endif
+
     extern uint8_t            gSetting_set_pwr;
     extern bool               gSetting_set_ptt;
     extern uint8_t            gSetting_set_tot;
@@ -195,6 +207,9 @@ extern enum BacklightOnRxTx_t gSetting_backlight_on_tx_rx;
     #ifdef ENABLE_FEAT_F4HWN_NARROWER
         extern bool               gSetting_set_nfm;
     #endif
+    #ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+        extern uint8_t            gSetting_set_sav;
+    #endif
     extern bool               gSetting_set_tmr;
     extern bool               gSetting_set_ptt_session;
     #ifdef ENABLE_FEAT_F4HWN_DEBUG
@@ -472,4 +487,4 @@ void FUNCTION_NOP();
 
 static inline bool SerialConfigInProgress() { return gSerialConfigCountDown_500ms != 0; }
 
-#endif
+#endif

App/radio.c

@@ -70,64 +70,45 @@ const char gModulationStr[MODULATION_UKNOWN][4] = {
     // Audio impression: fuller bass, more direct sound, while still keeping the 3 kHz top-end limit.
 
     static void AUDIO_ApplyFMProfile(uint8_t profile)
-    {
-        switch (profile)
-        {
-            default:
-            case 0: // FLAT
-                BK4819_WriteRegister(0x54, 0x9009);
-                BK4819_WriteRegister(0x55, 0x3200);
-                break;
+    {   //  | 0x54 || 0x55 |
+        static const uint16_t fm_profiles[][2] = {
+            {0x9009, 0x3200}, // 0: FLAT
+            {0x9009, 0x33A9}, // 1: CLEAN
+            {0x9009, 0x3600}, // 2: MID
+            {0x8546, 0x3AF0}, // 3: BOOST
+            {0x8566, 0x3D00}  // 4: MAX
+        };
 
-            case 1: // CLEAN
-                BK4819_WriteRegister(0x54, 0x9009);
-                BK4819_WriteRegister(0x55, 0x33A9);
-                break;
+        if (profile >= ARRAY_SIZE(fm_profiles))
+            profile = 0;
 
-            case 2: // MID
-                BK4819_WriteRegister(0x54, 0x9009);
-                BK4819_WriteRegister(0x55, 0x3600);
-                break;
-
-            case 3: // BOOST
-                BK4819_WriteRegister(0x54, 0x8546);
-                BK4819_WriteRegister(0x55, 0x3AF0);
-                break;
-
-            case 4: // MAX
-                BK4819_WriteRegister(0x54, 0x8566);
-                BK4819_WriteRegister(0x55, 0x3D00);
-                break;
-        }
+        BK4819_WriteRegister(0x54, fm_profiles[profile][0]);
+        BK4819_WriteRegister(0x55, fm_profiles[profile][1]);
     }
 
     static void AUDIO_ApplyAMProfile(uint8_t profile)
-    {
-        switch (profile)
-        {
-            default:
-            case 0: // SHARP (ALPHA test profile) - Narrow IF filter (REG54 bits[14:8]=0, bits[7:0]=9), low IF gain (REG55 bits[11:8]=1, ref=169)
-                    // Selective and crisp, best adjacent channel rejection, may sound harsh on strong signals
-                BK4819_WriteRegister(0x2b, 0x0300);
-                BK4819_WriteRegister(0x2f, 0x9990);
-                BK4819_WriteRegister(0x54, 0x9009);
-                BK4819_WriteRegister(0x55, 0x31A9);
-                break;
-            case 1: // STOCK - Narrow IF filter (REG54 bits[14:8]=0, bits[7:0]=9), moderate IF gain (REG55 bits[11:8]=4, ref=180)
-                    // Selective filter with balanced gain, punchy and detailed, good compromise between rejection and sensitivity
-                BK4819_WriteRegister(0x2b, 0x0500);
-                BK4819_WriteRegister(0x2f, 0x9990);
-                BK4819_WriteRegister(0x54, 0x9009);
-                BK4819_WriteRegister(0x55, 0x31A9);
-                break;
-            case 2: // OPEN (BRAVO test profile) - Medium-wide IF filter (REG54 bits[14:8]=8, bits[7:0]=70), high IF gain (REG55 bits[11:8]=8, ref=192)
-                    // Wide and pleasant, better sensitivity on weak signals, may struggle with adjacent channel interference
-                BK4819_WriteRegister(0x2b, 0x0300);
-                BK4819_WriteRegister(0x2f, 0x9990);
-                BK4819_WriteRegister(0x54, 0x8846);
-                BK4819_WriteRegister(0x55, 0x38C0);
-                break;
-        }
+    {   //  | 0x2b || 0x2f || 0x54 || 0x55 |
+        static const uint16_t am_profiles[][4] = {
+            // SHARP (ALPHA test profile) - Narrow IF filter (REG54 bits[14:8]=0, bits[7:0]=9), low IF gain (REG55 bits[11:8]=1, ref=169)
+            // Selective and crisp, best adjacent channel rejection, may sound harsh on strong signals
+            {0x0300, 0x9990, 0x9009, 0x31A9},
+
+            // STOCK - Narrow IF filter (REG54 bits[14:8]=0, bits[7:0]=9), moderate IF gain (REG55 bits[11:8]=4, ref=180)
+            // Selective filter with balanced gain, punchy and detailed, good compromise between rejection and sensitivity
+            {0x0500, 0x9990, 0x9009, 0x31A9},
+
+            // OPEN (BRAVO test profile) - Medium-wide IF filter (REG54 bits[14:8]=8, bits[7:0]=70), high IF gain (REG55 bits[11:8]=8, ref=192)
+            // Wide and pleasant, better sensitivity on weak signals, may struggle with adjacent channel interference
+            {0x0300, 0x9990, 0x8846, 0x38C0}
+        };
+
+        if (profile >= ARRAY_SIZE(am_profiles))
+            profile = 0;
+
+        BK4819_WriteRegister(0x2b, am_profiles[profile][0]);
+        BK4819_WriteRegister(0x2f, am_profiles[profile][1]);
+        BK4819_WriteRegister(0x54, am_profiles[profile][2]);
+        BK4819_WriteRegister(0x55, am_profiles[profile][3]);
     }
 
     static void AUDIO_ApplyUSBProfile(void)
@@ -252,6 +233,24 @@ void RADIO_InitInfo(VFO_Info_t *pInfo, const uint16_t ChannelSave, const uint32_
     RADIO_ConfigureSquelchAndOutputPower(pInfo);
 }
 
+void RADIO_ValidateAndSetCode(FREQ_Config_t *pFreq_Config, uint8_t tmp) {
+    switch (pFreq_Config->CodeType) {
+        default:
+        case CODE_TYPE_OFF:
+            pFreq_Config->CodeType = CODE_TYPE_OFF;
+            tmp = 0;
+            break;
+
+        case CODE_TYPE_CONTINUOUS_TONE:
+        case CODE_TYPE_DIGITAL:
+        case CODE_TYPE_REVERSE_DIGITAL:
+            if (tmp > ((pFreq_Config->CodeType == CODE_TYPE_CONTINUOUS_TONE ? ARRAY_SIZE(CTCSS_Options) : ARRAY_SIZE(DCS_Options)) - 1))
+                tmp = 0;
+            break;
+    }
+    pFreq_Config->Code = tmp;
+}
+
 void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure)
 {
     VFO_Info_t *pVfo = &gEeprom.VfoInfo[VFO];
@@ -325,7 +324,7 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure
     }
 
     pVfo->Band                    = band;
-    pVfo->SCANLIST_PARTICIPATION = bParticipation;
+    pVfo->SCANLIST_PARTICIPATION  = bParticipation;
     pVfo->CHANNEL_SAVE            = channel;
 
     uint32_t base;
@@ -370,49 +369,8 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure
         pVfo->freq_config_RX.CodeType = (data[2] >> 0) & 0x0F;
         pVfo->freq_config_TX.CodeType = (data[2] >> 4) & 0x0F;
 
-        tmp = data[0];
-        switch (pVfo->freq_config_RX.CodeType)
-        {
-            default:
-            case CODE_TYPE_OFF:
-                pVfo->freq_config_RX.CodeType = CODE_TYPE_OFF;
-                tmp = 0;
-                break;
-
-            case CODE_TYPE_CONTINUOUS_TONE:
-                if (tmp > (ARRAY_SIZE(CTCSS_Options) - 1))
-                    tmp = 0;
-                break;
-
-            case CODE_TYPE_DIGITAL:
-            case CODE_TYPE_REVERSE_DIGITAL:
-                if (tmp > (ARRAY_SIZE(DCS_Options) - 1))
-                    tmp = 0;
-                break;
-        }
-        pVfo->freq_config_RX.Code = tmp;
-
-        tmp = data[1];
-        switch (pVfo->freq_config_TX.CodeType)
-        {
-            default:
-            case CODE_TYPE_OFF:
-                pVfo->freq_config_TX.CodeType = CODE_TYPE_OFF;
-                tmp = 0;
-                break;
-
-            case CODE_TYPE_CONTINUOUS_TONE:
-                if (tmp > (ARRAY_SIZE(CTCSS_Options) - 1))
-                    tmp = 0;
-                break;
-
-            case CODE_TYPE_DIGITAL:
-            case CODE_TYPE_REVERSE_DIGITAL:
-                if (tmp > (ARRAY_SIZE(DCS_Options) - 1))
-                    tmp = 0;
-                break;
-        }
-        pVfo->freq_config_TX.Code = tmp;
+        RADIO_ValidateAndSetCode(&pVfo->freq_config_RX, data[0]);
+        RADIO_ValidateAndSetCode(&pVfo->freq_config_TX, data[1]);
 
         if (data[4] == 0xFF)
         {
@@ -552,17 +510,20 @@ void RADIO_ConfigureSquelchAndOutputPower(VFO_Info_t *pInfo)
     }
     else
     {   // squelch >= 1
-        Base += gEeprom.SQUELCH_LEVEL;                                        // my eeprom squelch-1
-                                                                              // VHF   UHF
-        PY25Q16_ReadBuffer(Base + 0x00, &pInfo->SquelchOpenRSSIThresh,    1);  //  50    10
-        PY25Q16_ReadBuffer(Base + 0x10, &pInfo->SquelchCloseRSSIThresh,   1);  //  40     5
-
-        PY25Q16_ReadBuffer(Base + 0x20, &pInfo->SquelchOpenNoiseThresh,   1);  //  65    90
-        PY25Q16_ReadBuffer(Base + 0x30, &pInfo->SquelchCloseNoiseThresh,  1);  //  70   100
-
-        PY25Q16_ReadBuffer(Base + 0x40, &pInfo->SquelchCloseGlitchThresh, 1);  //  90    90
-        PY25Q16_ReadBuffer(Base + 0x50, &pInfo->SquelchOpenGlitchThresh,  1);  // 100   100
+        Base += gEeprom.SQUELCH_LEVEL;           // my eeprom squelch-1
+                                                 // VHF   UHF
+        uint8_t *sq_ptrs[6] = {
+            &pInfo->SquelchOpenRSSIThresh,       //  50    10
+            &pInfo->SquelchCloseRSSIThresh,      //  40     5
+            &pInfo->SquelchOpenNoiseThresh,      //  65    90
+            &pInfo->SquelchCloseNoiseThresh,     //  70   100
+            &pInfo->SquelchCloseGlitchThresh,    //  90    90
+            &pInfo->SquelchOpenGlitchThresh      // 100   100
+        };
 
+        for(uint8_t i = 0; i < 6; i++) {
+            PY25Q16_ReadBuffer(Base + (i * 0x10), sq_ptrs[i], 1);
+        }
 
         uint16_t noise_open   = pInfo->SquelchOpenNoiseThresh;
         uint16_t noise_close  = pInfo->SquelchCloseNoiseThresh;
@@ -586,14 +547,14 @@ void RADIO_ConfigureSquelchAndOutputPower(VFO_Info_t *pInfo)
         if (glitch_close == glitch_open && glitch_close <= 253)
             glitch_close += 2;
 
-        pInfo->SquelchOpenRSSIThresh    = (rssi_open    > 255) ? 255 : rssi_open;
-        pInfo->SquelchCloseRSSIThresh   = (rssi_close   > 255) ? 255 : rssi_close;
-        pInfo->SquelchOpenGlitchThresh  = (glitch_open  > 255) ? 255 : glitch_open;
-        pInfo->SquelchCloseGlitchThresh = (glitch_close > 255) ? 255 : glitch_close;
+        pInfo->SquelchOpenRSSIThresh    = MIN(rssi_open,    255);
+        pInfo->SquelchCloseRSSIThresh   = MIN(rssi_close,   255);
+        pInfo->SquelchOpenGlitchThresh  = MIN(glitch_open,  255);
+        pInfo->SquelchCloseGlitchThresh = MIN(glitch_close, 255);
 #endif
 
-        pInfo->SquelchOpenNoiseThresh   = (noise_open   > 127) ? 127 : noise_open;
-        pInfo->SquelchCloseNoiseThresh  = (noise_close  > 127) ? 127 : noise_close;
+        pInfo->SquelchOpenNoiseThresh   = MIN(noise_open,   127);
+        pInfo->SquelchCloseNoiseThresh  = MIN(noise_close,  127);
     }
 
     // *******************************
@@ -624,30 +585,15 @@ void RADIO_ConfigureSquelchAndOutputPower(VFO_Info_t *pInfo)
     uint8_t Op = 0; // Low eeprom calibration data 
     uint8_t currentPower = pInfo->OUTPUT_POWER;
 
-    if(currentPower == OUTPUT_POWER_USER)
-    {
-        if(gSetting_set_pwr == 5)
-        {
-            Op = 1; // Mid eeprom calibration data
-        }
-        else if(gSetting_set_pwr == 6)
-        {
-            Op = 2; // High eeprom calibration data
-        }
+    if (currentPower == OUTPUT_POWER_USER)
         currentPower = gSetting_set_pwr;
-    }
     else
-    {
-        if (currentPower == OUTPUT_POWER_MID)
-        {
-            Op = 1; // Mid eeprom calibration data
-        }
-        else if(currentPower == OUTPUT_POWER_HIGH)
-        {
-            Op = 2; // High eeprom calibration data
-        }
         currentPower--;
-    }
+
+    if (currentPower == 5)
+        Op = 1; // Mid eeprom calibration data
+    else if (currentPower == 6)
+        Op = 2; // High eeprom calibration data
 
     PY25Q16_ReadBuffer(0x100D0 + (Band * 16) + (Op * 3), Txp, 3);
 
@@ -755,18 +701,11 @@ void RADIO_ApplyOffset(VFO_Info_t *pInfo)
 {
     uint32_t Frequency = pInfo->freq_config_RX.Frequency;
 
-    switch (pInfo->TX_OFFSET_FREQUENCY_DIRECTION)
-    {
-        case TX_OFFSET_FREQUENCY_DIRECTION_OFF:
-            break;
-        case TX_OFFSET_FREQUENCY_DIRECTION_ADD:
-            Frequency += pInfo->TX_OFFSET_FREQUENCY;
-            break;
-        case TX_OFFSET_FREQUENCY_DIRECTION_SUB:
-            Frequency -= pInfo->TX_OFFSET_FREQUENCY;
-            break;
-    }
-
+    if      (pInfo->TX_OFFSET_FREQUENCY_DIRECTION == TX_OFFSET_FREQUENCY_DIRECTION_ADD)
+        Frequency += pInfo->TX_OFFSET_FREQUENCY;
+    else if (pInfo->TX_OFFSET_FREQUENCY_DIRECTION == TX_OFFSET_FREQUENCY_DIRECTION_SUB)
+        Frequency -= pInfo->TX_OFFSET_FREQUENCY;
+    
     pInfo->freq_config_TX.Frequency = Frequency;
 }
 
@@ -790,6 +729,12 @@ void RADIO_SelectVfos(void)
     RADIO_SelectCurrentVfo();
 }
 
+BK4819_FilterBandwidth_t RADIO_GetAMFilterBandwidth(const VFO_Info_t *pVfo)
+{
+    // On BK4829, AM "wide" intentionally reuses the wider RF filter preset.
+    return (pVfo->CHANNEL_BANDWIDTH == BANDWIDTH_WIDE) ? BK4819_FILTER_BW_WIDE : BK4819_FILTER_BW_AM;
+}
+
 void RADIO_SetupRegisters(bool switchToForeground)
 {
     BK4819_FilterBandwidth_t Bandwidth = gRxVfo->CHANNEL_BANDWIDTH;
@@ -808,7 +753,7 @@ void RADIO_SetupRegisters(bool switchToForeground)
     BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, false);
 
     if (gRxVfo->Modulation == MODULATION_AM)
-        BK4819_SetFilterBandwidth(BK4819_FILTER_BW_AM, true);
+        BK4819_SetFilterBandwidth(RADIO_GetAMFilterBandwidth(gRxVfo), true);
     else
     {
         switch (Bandwidth)
@@ -860,6 +805,9 @@ void RADIO_SetupRegisters(bool switchToForeground)
     #endif
     BK4819_SetFrequency(Frequency);
 
+    // Keep the demodulator in sync when retuning without entering RX audio.
+    RADIO_SetModulation(gRxVfo->Modulation);
+
     BK4819_SetupSquelch(
         gRxVfo->SquelchOpenRSSIThresh,    gRxVfo->SquelchCloseRSSIThresh,
         gRxVfo->SquelchOpenNoiseThresh,   gRxVfo->SquelchCloseNoiseThresh,
@@ -872,12 +820,7 @@ void RADIO_SetupRegisters(bool switchToForeground)
 
     // AF RX Gain and DAC
     //BK4819_WriteRegister(BK4819_REG_48, 0xB3A8);  // 1011 00 111010 1000
-    BK4819_WriteRegister(BK4819_REG_48,
-        (11u << 12)                 |     // ??? .. 0 ~ 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)
-
+    BK4819_SetRxAudioGain();
 
     uint16_t InterruptMask = BK4819_REG_3F_SQUELCH_FOUND | BK4819_REG_3F_SQUELCH_LOST;
 
@@ -897,7 +840,7 @@ void RADIO_SetupRegisters(bool switchToForeground)
                     BK4819_SetCTCSSFrequency(SQL_TONE);
                     BK4819_SetTailDetection(SQL_TONE); // Default 550 = QS's 55Hz tone method
 
-                    InterruptMask = BK4819_REG_3F_CxCSS_TAIL | BK4819_REG_3F_SQUELCH_FOUND | BK4819_REG_3F_SQUELCH_LOST;
+                    InterruptMask |= BK4819_REG_3F_CxCSS_TAIL;
                     break;
 
                 case CODE_TYPE_CONTINUOUS_TONE:
@@ -909,24 +852,17 @@ void RADIO_SetupRegisters(bool switchToForeground)
                     //  BK4819_SetTailDetection(CTCSS_Options[Code]);
                     //#endif
 
-                    InterruptMask = 0
-                        | BK4819_REG_3F_CxCSS_TAIL
-                        | BK4819_REG_3F_CTCSS_FOUND
-                        | BK4819_REG_3F_CTCSS_LOST
-                        | BK4819_REG_3F_SQUELCH_FOUND
-                        | BK4819_REG_3F_SQUELCH_LOST;
-
+                    InterruptMask |= BK4819_REG_3F_CxCSS_TAIL
+                                  |  BK4819_REG_3F_CTCSS_FOUND
+                                  |  BK4819_REG_3F_CTCSS_LOST;
                     break;
 
                 case CODE_TYPE_DIGITAL:
                 case CODE_TYPE_REVERSE_DIGITAL:
                     BK4819_SetCDCSSCodeWord(DCS_GetGolayCodeWord(CodeType, Code));
-                    InterruptMask = 0
-                        | BK4819_REG_3F_CxCSS_TAIL
-                        | BK4819_REG_3F_CDCSS_FOUND
-                        | BK4819_REG_3F_CDCSS_LOST
-                        | BK4819_REG_3F_SQUELCH_FOUND
-                        | BK4819_REG_3F_SQUELCH_LOST;
+                    InterruptMask |= BK4819_REG_3F_CxCSS_TAIL
+                                  |  BK4819_REG_3F_CDCSS_FOUND
+                                  |  BK4819_REG_3F_CDCSS_LOST;
                     break;
             }
 
@@ -944,11 +880,8 @@ void RADIO_SetupRegisters(bool switchToForeground)
         else
         {
             BK4819_SetCTCSSFrequency(2625);
-            InterruptMask = 0
-                | BK4819_REG_3F_CTCSS_FOUND
-                | BK4819_REG_3F_CTCSS_LOST
-                | BK4819_REG_3F_SQUELCH_FOUND
-                | BK4819_REG_3F_SQUELCH_LOST;
+            InterruptMask |= BK4819_REG_3F_CTCSS_FOUND
+                          |  BK4819_REG_3F_CTCSS_LOST;
         }
     #endif
 
@@ -1107,26 +1040,25 @@ void RADIO_SetTxParameters(void)
 void RADIO_SetModulation(ModulationMode_t modulation)
 {
     #ifdef ENABLE_BYP_RAW_DEMODULATORS
-    // BYP on BK4829 uses full audio bypass profile.
-    if (modulation == MODULATION_BYP) {
-        BK4819_EnterBypass();
+    if (modulation == MODULATION_BYP || modulation == MODULATION_RAW) {
+        uint16_t reg_3d_val = 0x0000;
+
+        if (modulation == MODULATION_BYP) {
+            // BYP on BK4829 uses full audio bypass profile.
+            BK4819_EnterBypass();
+            reg_3d_val = 0x2AAB;
+        } else {
+            // RAW on BK4829 uses RX-only filter bypass profile.
+            BK4819_EnterRaw();
+            // reg_3d_val = 0x0000;
+        }
+
         BK4819_SetRegValue(afDacGainRegSpec, 0xF);
-        BK4819_WriteRegister(BK4819_REG_3D, 0x2AAB);
+        BK4819_WriteRegister(BK4819_REG_3D, reg_3d_val);
         RADIO_SetupAGC(false, false);
         return;
     }
 
-    // RAW on BK4829 uses RX-only filter bypass profile.
-    if (modulation == MODULATION_RAW) {
-        BK4819_EnterRaw();
-        BK4819_SetRegValue(afDacGainRegSpec, 0xF);
-        BK4819_WriteRegister(BK4819_REG_3D, 0x0000);
-        RADIO_SetupAGC(false, false);
-        return;
-    }
-    #endif
-
-    #ifdef ENABLE_BYP_RAW_DEMODULATORS
     // Ensure we always leave bypass / raw mode before applying normal modulation settings.
     BK4819_ExitBypass();
     #endif
@@ -1156,11 +1088,12 @@ void RADIO_SetModulation(ModulationMode_t modulation)
     // So for now we just keep it as is to maintain compatibility.
     //
 
+    uint16_t uVar1 = BK4819_ReadRegister(0x31);
+
     switch (modulation)
     {
         case MODULATION_AM:
         {
-            uint16_t uVar1 = BK4819_ReadRegister(0x31);
             BK4819_WriteRegister(0x31, uVar1 | 1); // AM Demodulation Enable
             BK4819_WriteRegister(0x42, 0x6f5c);
             BK4819_WriteRegister(0x2a, 0x7434);
@@ -1172,32 +1105,14 @@ void RADIO_SetModulation(ModulationMode_t modulation)
                 BK4819_WriteRegister(0x55, 0x31a9);
             #endif
 
-            BK4819_SetFilterBandwidth(BK4819_FILTER_BW_AM, true);
+            BK4819_SetFilterBandwidth(RADIO_GetAMFilterBandwidth(gRxVfo), true);
             break;
         }
 
         case MODULATION_USB:
-        {
-            uint16_t uVar1 = BK4819_ReadRegister(0x31);
-            BK4819_WriteRegister(0x31, uVar1 & 0xfffe); // AM Demodulation Disable
-            BK4819_WriteRegister(0x42, 0x6b5a);
-            BK4819_WriteRegister(0x2a, 0x7400);
-            BK4819_WriteRegister(0x2b, 0x0000);
-            BK4819_WriteRegister(0x2f, 0x9890);
-
-            #ifdef ENABLE_FEAT_F4HWN_AUDIO
-                AUDIO_ApplyUSBProfile();
-            #else
-                BK4819_WriteRegister(0x54, 0x9009);
-                BK4819_WriteRegister(0x55, 0x31a9);
-            #endif
-            break;
-        }
-
         case MODULATION_FM:
         default:
         {
-            uint16_t uVar1 = BK4819_ReadRegister(0x31);
             BK4819_WriteRegister(0x31, uVar1 & 0xfffe); // AM Demodulation Disable
             BK4819_WriteRegister(0x42, 0x6b5a);
             BK4819_WriteRegister(0x2a, 0x7400);
@@ -1205,7 +1120,10 @@ void RADIO_SetModulation(ModulationMode_t modulation)
             BK4819_WriteRegister(0x2f, 0x9890);
 
             #ifdef ENABLE_FEAT_F4HWN_AUDIO
-                AUDIO_ApplyFMProfile(gSetting_set_audio_fm);
+                if (modulation == MODULATION_USB)
+                    AUDIO_ApplyUSBProfile();
+                else
+                    AUDIO_ApplyFMProfile(gSetting_set_audio_fm);
             #else
                 BK4819_WriteRegister(0x54, 0x9009);
                 BK4819_WriteRegister(0x55, 0x31a9);
@@ -1284,16 +1202,12 @@ void RADIO_PrepareTX(void)
 
     RADIO_SelectCurrentVfo();
 
+    if(TX_freq_check(gCurrentVfo->pTX->Frequency) != 0
 #ifdef ENABLE_FEAT_F4HWN
-        if(TX_freq_check(gCurrentVfo->pTX->Frequency) != 0 && gCurrentVfo->TX_LOCK == true
-    #if defined(ENABLE_ALARM) || defined(ENABLE_TX1750)
-            && gAlarmState != ALARM_STATE_SITE_ALARM
-    #endif
-#else
-        if(TX_freq_check(gCurrentVfo->pTX->Frequency) != 0
-    #if defined(ENABLE_ALARM) || defined(ENABLE_TX1750)
-            && gAlarmState != ALARM_STATE_SITE_ALARM
-    #endif
+        && gCurrentVfo->TX_LOCK == true
+#endif
+#if defined(ENABLE_ALARM) || defined(ENABLE_TX1750)
+        && gAlarmState != ALARM_STATE_SITE_ALARM
 #endif
     ){
         // TX frequency not allowed
@@ -1397,17 +1311,19 @@ void RADIO_PrepareTX(void)
 
 void RADIO_SendCssTail(void)
 {
-    switch (gCurrentVfo->pTX->CodeType) {
-    case CODE_TYPE_DIGITAL:
-    case CODE_TYPE_REVERSE_DIGITAL:
-        BK4819_PlayCDCSSTail();
-        break;
-    default:
-        BK4819_PlayCTCSSTail();
-        break;
-    }
+    if (gEeprom.TAIL_TONE_ELIMINATION) {
+        switch (gCurrentVfo->pTX->CodeType) {
+        case CODE_TYPE_DIGITAL:
+        case CODE_TYPE_REVERSE_DIGITAL:
+            BK4819_PlayCDCSSTail();
+            break;
+        default:
+            BK4819_PlayCTCSSTail();
+            break;
+        }
 
-    SYSTEM_DelayMs(200);
+        SYSTEM_DelayMs(200);
+    }
 }
 
 void RADIO_SendEndOfTransmission(void)
@@ -1416,8 +1332,7 @@ void RADIO_SendEndOfTransmission(void)
     DTMF_SendEndOfTransmission();
 
     // send the CTCSS/DCS tail tone - allows the receivers to mute the usual FM squelch tail/crash
-    if(gEeprom.TAIL_TONE_ELIMINATION)
-        RADIO_SendCssTail();
+    RADIO_SendCssTail();
     RADIO_SetupRegisters(false);
 }
 
@@ -1427,7 +1342,6 @@ void RADIO_PrepareCssTX(void)
 
     SYSTEM_DelayMs(200);
 
-    if(gEeprom.TAIL_TONE_ELIMINATION)
-        RADIO_SendCssTail();
+    RADIO_SendCssTail();
     RADIO_SetupRegisters(true);
 }

App/radio.h

@@ -21,6 +21,7 @@
 #include <stdint.h>
 
 #include "dcs.h"
+#include "driver/bk4819.h"
 #include "frequencies.h"
 
 enum {
@@ -155,12 +156,14 @@ uint16_t RADIO_FindNextChannel(uint16_t ChNum, int8_t Direction, bool bCheckScan
 void     RADIO_InitInfo(VFO_Info_t *pInfo, const uint16_t ChannelSave, const uint32_t Frequency);
 void     RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure);
 void     RADIO_ConfigureSquelchAndOutputPower(VFO_Info_t *pInfo);
+void     RADIO_ValidateAndSetCode(FREQ_Config_t *pFreq_Config, uint8_t tmp);
 void     RADIO_ApplyOffset(VFO_Info_t *pInfo);
 void     RADIO_SelectVfos(void);
 void     RADIO_SetupRegisters(bool switchToForeground);
 #ifdef ENABLE_NOAA
     void RADIO_ConfigureNOAA(void);
 #endif
+BK4819_FilterBandwidth_t RADIO_GetAMFilterBandwidth(const VFO_Info_t *pVfo);
 void     RADIO_SetTxParameters(void);
 void     RADIO_SetupAGC(bool listeningAM, bool disable);
 void     RADIO_SetModulation(ModulationMode_t modulation);

App/scheduler.c

@@ -98,6 +98,38 @@ void SysTick_Handler(void)
         if (gCurrentFunction != FUNCTION_MONITOR && gCurrentFunction != FUNCTION_TRANSMIT)
             DECREMENT_AND_TRIGGER(gScanPauseDelayIn_10ms, gScheduleScanListen);
 
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+    // Scan stall watchdog: if the scan-resume countdown has expired
+    // (gScanPauseDelayIn_10ms == 0) but no resume was actually scheduled
+    // (gScheduleScanListen == false) and no real reception is happening
+    // (squelch closed -> green LED off, not in RX/TX/MONITOR), the scan
+    // loop is stuck. Force a resume after this many 10ms ticks. The
+    // gScanPauseDelayIn_10ms == 0 guard ensures we never override the
+    // user-configured ScnRev (SCAN_RESUME_MODE) pause: while that pause
+    // is decrementing, the watchdog stays asleep.
+    #define SCAN_FAST_STALL_WATCHDOG_10ms  25   // 250 ms
+    static uint16_t scanFastStallCounter;
+
+    if (gSetting_set_scn
+        && gScanStateDir != SCAN_OFF
+        && gScanPauseDelayIn_10ms == 0
+        && !gScheduleScanListen
+        && !g_SquelchLost
+        && gCurrentFunction != FUNCTION_RECEIVE
+        && gCurrentFunction != FUNCTION_TRANSMIT
+        && gCurrentFunction != FUNCTION_MONITOR)
+    {
+        if (++scanFastStallCounter >= SCAN_FAST_STALL_WATCHDOG_10ms) {
+            scanFastStallCounter = 0;
+            gScheduleScanListen  = true;
+        }
+    }
+    else
+    {
+        scanFastStallCounter = 0;
+    }
+#endif
+
     DECREMENT_AND_TRIGGER(gTailNoteEliminationCountdown_10ms, gFlagTailNoteEliminationComplete);
 
 #ifdef ENABLE_VOICE

App/screenshot.c

@@ -22,12 +22,32 @@
 #include "driver/keyboard.h"
 
 // SRAM optimization: minimize static allocations
-// - previousFrame: 1024 bytes (REQUIRED - need to compare for delta)
-// - No currentFrame or deltaFrame static buffers
-static uint8_t previousFrame[1024] = {0};
+// - previousHash: one fingerprint per 8-byte chunk instead of a full
+//   1024-byte copy of the previous frame (chunks are only compared,
+//   never retransmitted from history). A 16-bit fingerprint keeps the
+//   collision odds at ~1/65536 per chunk, so a stale chunk slipping
+//   through is rare; the forcedBlock rotation repairs that residual
+//   within at most 128 frames.
+// Stack optimization: chunks are computed on demand straight from
+// gStatusLine/gFrameBuffer instead of building the whole 1024-byte
+// frame on the stack. Changed chunks are tracked in a 16-byte bitmap.
+// Peak stack drops from ~1.3 KB to ~40 bytes, at the cost of
+// transforming each transmitted chunk twice (negligible next to the
+// blocking UART transfer).
+static uint16_t previousHash[128];
 static uint8_t forcedBlock = 0;
 static uint8_t keepAlive = 3;
 
+// FNV-1a over one 8-byte chunk, folded to 16 bits
+static uint16_t SCREENSHOT_Hash(const uint8_t *data)
+{
+    uint32_t h = 2166136261u;
+    for (uint8_t i = 0; i < 8; i++) {
+        h = (h ^ data[i]) * 16777619u;
+    }
+    return (uint16_t)(h ^ (h >> 16));
+}
+
 void SCREENSHOT_ParseInput(void)
 {
     if (SCREENSHOT_IsLocked())
@@ -52,26 +72,35 @@ static void SCREENSHOT_Send(const uint8_t *buf, uint16_t len)
     }
 }
 
-void SCREENSHOT_Line(uint8_t *src, uint8_t *dest, uint16_t *idx) {
-    for (uint8_t b = 0; b < 8; b++) {
-        for (uint8_t i = 0; i < 128; i += 8) {
-            uint8_t acc = 0;
-            for (uint8_t k = 0; k < 8; k++) {
-                if (src[i + k] & (1 << b)) acc |= (1 << k);
-            }
-            dest[(*idx)++] = gSetting_set_inv ? ~acc : acc;
+enum {
+    SCREENSHOT_CHUNK_SIZE = 8,
+    SCREENSHOT_CHUNKS_PER_LINE = 16,
+    SCREENSHOT_HALF_LINE_COLUMNS = LCD_WIDTH / 2,
+};
+
+// Compute one 8-byte output chunk directly from the display buffers.
+// Frame layout: per line (status + 7 frame lines), 8 bit layers of
+// 16 bytes each. Each bit layer is split into two 64-column chunks.
+static void SCREENSHOT_Chunk(uint8_t chunkIdx, uint8_t *dest)
+{
+    const uint8_t chunkInLine = chunkIdx % SCREENSHOT_CHUNKS_PER_LINE;
+    const uint8_t line = chunkIdx / SCREENSHOT_CHUNKS_PER_LINE;
+    const uint8_t bit = chunkInLine / 2;
+    const uint8_t columnBase = (chunkInLine % 2) * SCREENSHOT_HALF_LINE_COLUMNS;
+    const uint8_t *src = (line == 0 ? gStatusLine : gFrameBuffer[line - 1])
+                         + columnBase;
+
+    for (uint8_t j = 0; j < SCREENSHOT_CHUNK_SIZE; j++) {
+        uint8_t acc = 0;
+        for (uint8_t k = 0; k < SCREENSHOT_CHUNK_SIZE; k++) {
+            if (src[j * SCREENSHOT_CHUNK_SIZE + k] & (1 << bit)) acc |= (1 << k);
         }
+        dest[j] = gSetting_set_inv ? ~acc : acc;
     }
 }
 
 void SCREENSHOT_Update(bool force)
 {
-    // Build frame in a temporary stack buffer
-    // This is 1024 bytes but it's temporary and gets freed after the function
-    uint8_t frameBuffer[1024];
-    uint16_t index = 0;
-    uint8_t acc = 0;
-    uint8_t bitCount = 0;
     static bool wasConnected = false;
 
     if (SCREENSHOT_IsLocked())
@@ -93,36 +122,19 @@ void SCREENSHOT_Update(bool force)
         wasConnected = true;
     }
 
-    // ==== BUILD FRAME ONCE ====
-    // Status line: 8 bit layers × 128 columns
-    SCREENSHOT_Line(gStatusLine, frameBuffer, &index);
-
-    // Frame buffer: 7 lines × 8 bit layers × 128 columns
-    for (uint8_t l = 0; l < 7; l++) {
-        SCREENSHOT_Line(gFrameBuffer[l], frameBuffer, &index);
-    }
-
-    if (bitCount > 0)
-        frameBuffer[index++] = acc;
-
-    if (index != 1024)
-        return;
-
     // ==== FIRST PASS: Count changed chunks ====
     uint16_t deltaLen = 0;
-    uint8_t changedChunks[128];  // List of changed chunk indices
-    uint8_t changedCount = 0;
+    uint8_t changedBitmap[16] = {0};  // 1 bit per chunk
+    uint8_t chunk[9];                 // [0] = index, [1..8] = payload
 
-    for (uint8_t chunk = 0; chunk < 128; chunk++) {
-        uint8_t *cur = &frameBuffer[chunk * 8];
-        uint8_t *prev = &previousFrame[chunk * 8];
+    for (uint8_t chunkIdx = 0; chunkIdx < 128; chunkIdx++) {
+        SCREENSHOT_Chunk(chunkIdx, &chunk[1]);
 
-        bool changed = memcmp(cur, prev, 8) != 0;
-        bool isForced = (chunk == forcedBlock);
-        bool fullUpdate = force;
+        bool changed = SCREENSHOT_Hash(&chunk[1]) != previousHash[chunkIdx];
+        bool isForced = (chunkIdx == forcedBlock);
 
-        if (changed || isForced || fullUpdate) {
-            changedChunks[changedCount++] = chunk;
+        if (changed || isForced || force) {
+            changedBitmap[chunkIdx >> 3] |= 1 << (chunkIdx & 7);
             deltaLen += 9;
         }
     }
@@ -153,22 +165,22 @@ void SCREENSHOT_Update(bool force)
     SCREENSHOT_Send(header, 5);
 
     // ==== SECOND PASS: Send only changed chunks ====
-    uint8_t chunk[9];
-    
-    for (uint8_t i = 0; i < changedCount; i++) {
-        uint8_t chunkIdx = changedChunks[i];
-        uint8_t *cur = &frameBuffer[chunkIdx * 8];
-        uint8_t *prev = &previousFrame[chunkIdx * 8];
+    for (uint8_t chunkIdx = 0; chunkIdx < 128; chunkIdx++) {
+        if (!(changedBitmap[chunkIdx >> 3] & (1 << (chunkIdx & 7))))
+            continue;
 
         chunk[0] = chunkIdx;
-        memcpy(&chunk[1], cur, 8);
-        
+        SCREENSHOT_Chunk(chunkIdx, &chunk[1]);
+
         SCREENSHOT_Send(chunk, 9);
-        
-        // Update previousFrame for next comparison
-        memcpy(prev, cur, 8);
+
+        // Update the fingerprint only once the chunk is actually sent,
+        // so chunks skipped by an early return stay marked as changed.
+        // Hashing the recomputed payload also keeps the fingerprint in
+        // sync if the display buffer changed between the two passes.
+        previousHash[chunkIdx] = SCREENSHOT_Hash(&chunk[1]);
     }
 
     uint8_t end = 0x0A;
     SCREENSHOT_Send(&end, 1);
-}
+}

App/settings.c

@@ -30,6 +30,23 @@
 
 EEPROM_Config_t gEeprom = { 0 };
 
+// Load a DTMF code from EEPROM, falling back to default_val if invalid.
+static void SETTINGS_LoadEepromDtmf(uint32_t addr, char *dest, size_t size, const char *default_val)
+{
+    uint8_t buf[16];
+
+    if (size > sizeof(buf))
+        size = sizeof(buf);
+
+    PY25Q16_ReadBuffer(addr, buf, size);
+
+    if (DTMF_ValidateCodes((char *)buf, size)) {
+        memcpy(dest, buf, size);
+    } else {
+        strcpy(dest, default_val);
+    }
+}
+
 void SETTINGS_InitEEPROM(void)
 {
     uint8_t Data[16] = {0};
@@ -218,9 +235,12 @@ gEeprom.FreqChannel[1]   = IS_FREQ_CHANNEL(Data16[5]) ? Data16[5] : (FREQ_CHANNE
 
         gEeprom.FM_Band = fmCfg.band;
         //gEeprom.FM_Space = fmCfg.space;
+
+        uint16_t freqLoLimit = BK1080_GetFreqLoLimit(gEeprom.FM_Band);
+
         gEeprom.FM_SelectedFrequency = 
-            (fmCfg.selFreq >= BK1080_GetFreqLoLimit(gEeprom.FM_Band) && fmCfg.selFreq <= BK1080_GetFreqHiLimit(gEeprom.FM_Band)) ? 
-                fmCfg.selFreq : BK1080_GetFreqLoLimit(gEeprom.FM_Band);
+            (fmCfg.selFreq >= freqLoLimit && fmCfg.selFreq <= BK1080_GetFreqHiLimit(gEeprom.FM_Band)) ? 
+                fmCfg.selFreq : freqLoLimit;
             
         gEeprom.FM_SelectedChannel = fmCfg.selChn;
         gEeprom.FM_IsMrMode        = fmCfg.isMrMode;
@@ -294,51 +314,25 @@ gEeprom.FreqChannel[1]   = IS_FREQ_CHANNEL(Data16[5]) ? Data16[5] : (FREQ_CHANNE
     PY25Q16_ReadBuffer(0x00A0A8 + 0x48, Data, 8);
     gEeprom.DTMF_CODE_PERSIST_TIME  = (Data[0] < 101) ? Data[0] * 10 : 100;
     gEeprom.DTMF_CODE_INTERVAL_TIME = (Data[1] < 101) ? Data[1] * 10 : 100;
+
 #ifdef ENABLE_DTMF_CALLING
     gEeprom.PERMIT_REMOTE_KILL      = (Data[2] <   2) ? Data[2] : true;
 
     // 0EE0..0EE7
-
-    PY25Q16_ReadBuffer(0x00A0F8, Data, sizeof(gEeprom.ANI_DTMF_ID));
-    if (DTMF_ValidateCodes((char *)Data, sizeof(gEeprom.ANI_DTMF_ID))) {
-        memcpy(gEeprom.ANI_DTMF_ID, Data, sizeof(gEeprom.ANI_DTMF_ID));
-    } else {
-        strcpy(gEeprom.ANI_DTMF_ID, "123");
-    }
-
+    SETTINGS_LoadEepromDtmf(0x00A0F8, gEeprom.ANI_DTMF_ID, sizeof(gEeprom.ANI_DTMF_ID), "123");
 
     // 0EE8..0EEF
-    PY25Q16_ReadBuffer(0x00A0F8 + 0x8, Data, sizeof(gEeprom.KILL_CODE));
-    if (DTMF_ValidateCodes((char *)Data, sizeof(gEeprom.KILL_CODE))) {
-        memcpy(gEeprom.KILL_CODE, Data, sizeof(gEeprom.KILL_CODE));
-    } else {
-        strcpy(gEeprom.KILL_CODE, "ABCD9");
-    }
+    SETTINGS_LoadEepromDtmf(0x00A0F8 + 0x08, gEeprom.KILL_CODE, sizeof(gEeprom.KILL_CODE), "ABCD9");
 
     // 0EF0..0EF7
-    PY25Q16_ReadBuffer(0x00A0F8 + 0x10, Data, sizeof(gEeprom.REVIVE_CODE));
-    if (DTMF_ValidateCodes((char *)Data, sizeof(gEeprom.REVIVE_CODE))) {
-        memcpy(gEeprom.REVIVE_CODE, Data, sizeof(gEeprom.REVIVE_CODE));
-    } else {
-        strcpy(gEeprom.REVIVE_CODE, "9DCBA");
-    }
+    SETTINGS_LoadEepromDtmf(0x00A0F8 + 0x10, gEeprom.REVIVE_CODE, sizeof(gEeprom.REVIVE_CODE), "9DCBA");
 #endif
 
     // 0EF8..0F07
-    PY25Q16_ReadBuffer(0x00A0F8 + 0x18, Data, sizeof(gEeprom.DTMF_UP_CODE));
-    if (DTMF_ValidateCodes((char *)Data, sizeof(gEeprom.DTMF_UP_CODE))) {
-        memcpy(gEeprom.DTMF_UP_CODE, Data, sizeof(gEeprom.DTMF_UP_CODE));
-    } else {
-        strcpy(gEeprom.DTMF_UP_CODE, "12345");
-    }
+    SETTINGS_LoadEepromDtmf(0x00A0F8 + 0x18, gEeprom.DTMF_UP_CODE, sizeof(gEeprom.DTMF_UP_CODE), "12345");
 
     // 0F08..0F17
-    PY25Q16_ReadBuffer(0x00A0F8 + 0x28, Data, sizeof(gEeprom.DTMF_DOWN_CODE));
-    if (DTMF_ValidateCodes((char *)Data, sizeof(gEeprom.DTMF_DOWN_CODE))) {
-        memcpy(gEeprom.DTMF_DOWN_CODE, Data, sizeof(gEeprom.DTMF_DOWN_CODE));
-    } else {
-        strcpy(gEeprom.DTMF_DOWN_CODE, "54321");
-    }
+    SETTINGS_LoadEepromDtmf(0x00A0F8 + 0x28, gEeprom.DTMF_DOWN_CODE, sizeof(gEeprom.DTMF_DOWN_CODE), "54321");
 
     // 0F18..0F1F
     PY25Q16_ReadBuffer(0x00A130, Data, 8);
@@ -460,8 +454,20 @@ gEeprom.FreqChannel[1]   = IS_FREQ_CHANNEL(Data16[5]) ? Data16[5] : (FREQ_CHANNE
         // 1FF0..0x1FF7
         // TODO: address TBD
         PY25Q16_ReadBuffer(0x00A158, Data, 8);
+        const uint8_t set_ptt_scn_sav = Data[7] & 0x0F;
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+        const bool set_ptt_scn_sav_valid = set_ptt_scn_sav < (SET_SAV_LEN << 2);
+#else
+        const bool set_ptt_scn_sav_valid = set_ptt_scn_sav < 4;
+#endif
         gSetting_set_pwr = (((Data[7] & 0xF0) >> 4) < 7) ? ((Data[7] & 0xF0) >> 4) : 0;
-        gSetting_set_ptt = (((Data[7] & 0x0F)) < 2) ? ((Data[7] & 0x0F)) : 0;
+        gSetting_set_ptt = set_ptt_scn_sav_valid ? (set_ptt_scn_sav & 0x01) : 0;
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+        gSetting_set_scn = set_ptt_scn_sav_valid ? ((set_ptt_scn_sav & 0x02) == 0) : 1;
+#endif
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+        gSetting_set_sav = set_ptt_scn_sav_valid ? ((set_ptt_scn_sav >> 2) & 0x03) : SET_SAV_OFF;
+#endif
 
         gSetting_set_tot = (((Data[6] & 0xF0) >> 4) < 4) ? ((Data[6] & 0xF0) >> 4) : 0;
         gSetting_set_eot = (((Data[6] & 0x0F)) < 4) ? ((Data[6] & 0x0F)) : 0;
@@ -501,10 +507,6 @@ gEeprom.FreqChannel[1]   = IS_FREQ_CHANNEL(Data16[5]) ? Data16[5] : (FREQ_CHANNE
         gSetting_set_off = (Data[4] >> 1) > 120 ? 60 : (Data[4] >> 1); 
 #endif
 
-        // Warning
-        // Be aware, Data[3] is use by Spectrum
-        // Warning
-
         // And set special session settings for actions
         gSetting_set_ptt_session = gSetting_set_ptt;
         gEeprom.KEY_LOCK_PTT = gSetting_set_lck;
@@ -589,6 +591,124 @@ uint32_t SETTINGS_FetchChannelFrequency(const uint16_t channel)
     return info.frequency;
 }
 
+bool SETTINGS_FetchChannelScanInfo(const uint16_t channel, uint32_t *frequency, ModulationMode_t *modulation)
+{
+    struct
+    {
+        uint32_t frequency;
+        uint32_t offset;
+        uint8_t  settings[4];
+    } __attribute__((packed)) info;
+
+    PY25Q16_ReadBuffer(channel * 16, &info, sizeof(info));
+
+    if (frequency)
+        *frequency = info.frequency;
+
+    if (modulation)
+    {
+        uint8_t mode = info.settings[3] >> 4;
+        if (mode >= MODULATION_UKNOWN)
+            mode = MODULATION_FM;
+        *modulation = (ModulationMode_t)mode;
+    }
+
+    return info.frequency != 0 && info.frequency != 0xFFFFFFFF;
+}
+
+bool SETTINGS_FetchChannelScanDisplayInfo(const uint16_t channel, ChannelScanDisplayInfo_t *info)
+{
+    if (info == NULL)
+        return false;
+
+    struct
+    {
+        uint32_t frequency;
+        uint32_t offset;
+        uint8_t  data[8];
+    } __attribute__((packed)) raw;
+
+    PY25Q16_ReadBuffer(channel * 16, &raw, sizeof(raw));
+
+    if (raw.frequency == 0 || raw.frequency == 0xFFFFFFFF)
+        return false;
+
+    memset(info, 0, sizeof(*info));
+
+    info->rx.Frequency = raw.frequency;
+    info->tx.Frequency = raw.frequency;
+    info->offset       = (raw.offset >= _1GHz_in_KHz) ? (_1GHz_in_KHz / 100) : raw.offset;
+
+    info->rx.CodeType = (raw.data[2] >> 0) & 0x0F;
+    info->tx.CodeType = (raw.data[2] >> 4) & 0x0F;
+    RADIO_ValidateAndSetCode(&info->rx, raw.data[0]);
+    RADIO_ValidateAndSetCode(&info->tx, raw.data[1]);
+
+    uint8_t tmp = raw.data[3] & 0x0F;
+    if (tmp > TX_OFFSET_FREQUENCY_DIRECTION_SUB)
+        tmp = TX_OFFSET_FREQUENCY_DIRECTION_OFF;
+    info->txOffsetFrequencyDirection = tmp;
+
+    tmp = raw.data[3] >> 4;
+    if (tmp >= MODULATION_UKNOWN)
+        tmp = MODULATION_FM;
+    info->modulation = (ModulationMode_t)tmp;
+
+    tmp = raw.data[6];
+    if (tmp >= STEP_N_ELEM)
+        tmp = STEP_12_5kHz;
+    info->stepSetting   = (STEP_Setting_t)tmp;
+    info->stepFrequency = gStepFrequencyTable[tmp];
+
+    if (raw.data[4] == 0xFF)
+    {
+        info->frequencyReverse = false;
+        info->channelBandwidth = BANDWIDTH_WIDE;
+        info->outputPower      = OUTPUT_POWER_LOW1;
+        info->busyChannelLock  = false;
+        info->txLock           = true;
+    }
+    else
+    {
+        const uint8_t d4 = raw.data[4];
+        info->frequencyReverse = !!((d4 >> 0) & 1u);
+        info->channelBandwidth = !!((d4 >> 1) & 1u);
+        info->outputPower      =   ((d4 >> 2) & 7u);
+        info->busyChannelLock  = !!((d4 >> 5) & 1u);
+        info->txLock           = !!((d4 >> 6) & 1u);
+    }
+
+    switch (info->txOffsetFrequencyDirection)
+    {
+        case TX_OFFSET_FREQUENCY_DIRECTION_ADD:
+            info->tx.Frequency = raw.frequency + info->offset;
+            break;
+        case TX_OFFSET_FREQUENCY_DIRECTION_SUB:
+            info->tx.Frequency = raw.frequency - info->offset;
+            break;
+        default:
+            break;
+    }
+
+    if (raw.data[5] == 0xFF)
+    {
+#ifdef ENABLE_DTMF_CALLING
+        info->dtmfDecodingEnable = false;
+#endif
+        info->dtmfPttIdTxMode = PTT_ID_OFF;
+    }
+    else
+    {
+#ifdef ENABLE_DTMF_CALLING
+        info->dtmfDecodingEnable = (raw.data[5] >> 0) & 1u;
+#endif
+        const uint8_t pttId = (raw.data[5] >> 1) & 7u;
+        info->dtmfPttIdTxMode = pttId < ARRAY_SIZE(gSubMenu_PTT_ID) ? pttId : PTT_ID_OFF;
+    }
+
+    return true;
+}
+
 void SETTINGS_FetchChannelName(char *s, const uint16_t channel)
 {
     if (s == NULL)
@@ -1019,7 +1139,16 @@ void SETTINGS_SaveSettings(void)
 
     State[5] = ((tmp << 4) | (gSetting_set_ctr & 0x0F));
     State[6] = ((gSetting_set_tot << 4) | (gSetting_set_eot & 0x0F));
-    State[7] = ((gSetting_set_pwr << 4) | (gSetting_set_ptt & 0x0F));
+    uint8_t set_ptt_scn_sav = gSetting_set_ptt & 0x01;
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+    if (!gSetting_set_scn)
+        set_ptt_scn_sav |= 0x02;
+#endif
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+    set_ptt_scn_sav |= (gSetting_set_sav & 0x03) << 2;
+#endif
+
+    State[7] = ((gSetting_set_pwr << 4) | set_ptt_scn_sav);
 
     gEeprom.KEY_LOCK_PTT = gSetting_set_lck;
 

App/settings.h

@@ -34,7 +34,10 @@ enum POWER_OnDisplayMode_t {
 #endif
     POWER_ON_DISPLAY_MODE_MESSAGE,
     POWER_ON_DISPLAY_MODE_VOLTAGE,
-    POWER_ON_DISPLAY_MODE_NONE
+#ifdef ENABLE_FEAT_F4HWN_LOGO
+    POWER_ON_DISPLAY_MODE_LOGO,
+#endif
+    POWER_ON_DISPLAY_MODE_NONE,
 };
 typedef enum POWER_OnDisplayMode_t POWER_OnDisplayMode_t;
 
@@ -127,6 +130,9 @@ enum ACTION_OPT_t {
 #ifdef ENABLE_REGA
     ACTION_OPT_REGA_ALARM,
     ACTION_OPT_REGA_TEST,
+#endif
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+    ACTION_OPT_BEAM,
 #endif
     ACTION_OPT_LEN
 };
@@ -307,9 +313,30 @@ typedef struct {
 
 extern EEPROM_Config_t gEeprom;
 
+typedef struct {
+    FREQ_Config_t    rx;
+    FREQ_Config_t    tx;
+    uint32_t         offset;
+    uint16_t         stepFrequency;
+    STEP_Setting_t   stepSetting;
+    ModulationMode_t modulation;
+    uint8_t          txOffsetFrequencyDirection;
+    uint8_t          outputPower;
+    bool             frequencyReverse;
+    uint8_t          channelBandwidth;
+    uint8_t          busyChannelLock;
+    uint8_t          txLock;
+#ifdef ENABLE_DTMF_CALLING
+    uint8_t          dtmfDecodingEnable;
+#endif
+    PTT_ID_t         dtmfPttIdTxMode;
+} ChannelScanDisplayInfo_t;
+
 void     SETTINGS_InitEEPROM(void);
 void     SETTINGS_LoadCalibration(void);
 uint32_t SETTINGS_FetchChannelFrequency(const uint16_t channel);
+bool     SETTINGS_FetchChannelScanInfo(const uint16_t channel, uint32_t *frequency, ModulationMode_t *modulation);
+bool     SETTINGS_FetchChannelScanDisplayInfo(const uint16_t channel, ChannelScanDisplayInfo_t *info);
 void     SETTINGS_FetchChannelName(char *s, const uint16_t channel);
 void     SETTINGS_FactoryReset(bool bIsAll);
 #ifdef ENABLE_FMRADIO

App/ui/aircopy.c

@@ -37,9 +37,8 @@ static int get_bit(uint8_t* array, int bit_index) {
 
 void UI_DisplayAircopy(void)
 {
-    char String[16] = { 0 };
-    char *pPrintStr = { 0 };
-    uint16_t percent;
+    char String[16];
+    char *pPrintStr;
 
     UI_DisplayClear();
 
@@ -60,15 +59,13 @@ void UI_DisplayAircopy(void)
         // show the remaining 2 small frequency digits
         UI_PrintStringSmallNormal(String + 7, 97, 0, 3);
         String[7] = 0;
-        // show the main large frequency digits
-        UI_DisplayFrequency(String, 16, 2, false);
     } else {
         const char *ascii = INPUTBOX_GetAscii();
         sprintf(String, "%.3s.%.3s", ascii, ascii + 3);
-        UI_DisplayFrequency(String, 16, 2, false);
     }
 
-    memset(String, 0, sizeof(String));
+    // show the main large frequency digits
+    UI_DisplayFrequency(String, 16, 2, false);
 
     // Get the current map and calculate percentage based on its total blocks
     const AIRCOPY_TransferMap_t *currentMap = AIRCOPY_GetCurrentMap();
@@ -78,47 +75,44 @@ void UI_DisplayAircopy(void)
     if (doneBlocks > currentMap->total_blocks)
         doneBlocks = currentMap->total_blocks;
 
-    percent = (doneBlocks * 10000) / currentMap->total_blocks;
-
-    if (gAirCopyIsSendMode == 0) {
-        sprintf(String, "RCV:%02u.%02u%% E:%d", percent / 100, percent % 100, gErrorsDuringAirCopy);
-    } else if (gAirCopyIsSendMode == 1) {
-        sprintf(String, "SND:%02u.%02u%%", percent / 100, percent % 100);
-    }
-
-    // Draw gauge
-    if(gAircopyStep != 0)
-    {
-        UI_PrintString(String, 2, 127, 5, 8);
-
-        gFrameBuffer[4][1] = 0x3c;
-        gFrameBuffer[4][2] = 0x42;
-
-        for(uint8_t i = 1; i <= AIRCOPY_BAR_WIDTH + 2; i++)
-        {
-            gFrameBuffer[4][2 + i] = 0x81;
-        }
-
-        gFrameBuffer[4][125] = 0x42;
-        gFrameBuffer[4][126] = 0x3c;
-    }
-    
     // Draw memory selection
-    if(gAircopyState == AIRCOPY_READY)
+    if (gAircopyState == AIRCOPY_READY) 
     {
         doneBlocks = 0;
 
-        memset(gFrameBuffer[5], 0, 128);
-        memset(gFrameBuffer[6], 0, 128);
-
         if(gAircopyCurrentMapIndex < AIRCOPY_NUM_BANKS) {   
-            sprintf(String, "MEM %03u - %03u%", (gAircopyCurrentMapIndex * 128) + 1, (gAircopyCurrentMapIndex + 1) * 128);
-        }
-        else
-        {
-            sprintf(String, "Settings");            
+            sprintf(String, "MEM %03u - %03u", (gAircopyCurrentMapIndex * 128) + 1, (gAircopyCurrentMapIndex + 1) * 128);
+        } else {
+            strcpy(String, "Settings");            
         }
         UI_PrintString(String, 2, 127, 5, 8);
+    } 
+    else 
+    {
+        uint16_t percent = (doneBlocks * 10000) / currentMap->total_blocks;
+
+        if (gAirCopyIsSendMode == 0) {
+            sprintf(String, "RCV:%02u.%02u%% E:%d", percent / 100, percent % 100, gErrorsDuringAirCopy);
+        } else {
+            sprintf(String, "SND:%02u.%02u%%", percent / 100, percent % 100);
+        }
+
+        // Draw gauge
+        if(gAircopyStep != 0)
+        {
+            UI_PrintString(String, 2, 127, 5, 8);
+
+            gFrameBuffer[4][1] = 0x3c;
+            gFrameBuffer[4][2] = 0x42;
+
+            for(uint8_t i = 1; i <= AIRCOPY_BAR_WIDTH + 2; i++)
+            {
+                gFrameBuffer[4][2 + i] = 0x81;
+            }
+
+            gFrameBuffer[4][125] = 0x42;
+            gFrameBuffer[4][126] = 0x3c;
+        }
     }
 
     if (doneBlocks > 0)
@@ -131,19 +125,12 @@ void UI_DisplayAircopy(void)
             lErrorsDuringAirCopy = gErrorsDuringAirCopy;
         }
 
-        const AIRCOPY_TransferMap_t *currentMap = AIRCOPY_GetCurrentMap();
-
-        uint16_t total = currentMap->total_blocks;
-        uint16_t done  = gAirCopyBlockNumber + gErrorsDuringAirCopy;
-        
-        if (done > total) done = total;
+        uint16_t b = 0;
+        uint16_t fraction_accumulator = 0;
 
         for (uint8_t col = 0; col < AIRCOPY_BAR_WIDTH; col++)
         {
-            /* Map column [0..BAR_WIDTH-1] to block [0..total-1] */
-            uint16_t b = (uint16_t)((col * (uint32_t)total) / AIRCOPY_BAR_WIDTH);
-
-            bool processed = (b < done);
+            bool processed = (b < doneBlocks);
             bool error     = processed && get_bit(crc, b);
 
             if (!processed)
@@ -152,8 +139,14 @@ void UI_DisplayAircopy(void)
                 gFrameBuffer[4][col + 4] = 0x81;   // error gap (intentional hole)
             else
                 gFrameBuffer[4][col + 4] = 0xBD;   // ok filled
-        }
 
+            // DDA/Bresenham algorythm
+            fraction_accumulator += currentMap->total_blocks;
+            while (fraction_accumulator >= AIRCOPY_BAR_WIDTH) {
+                fraction_accumulator -= AIRCOPY_BAR_WIDTH;
+                b++;
+            }
+        }
     }
 
     ST7565_BlitFullScreen();

App/ui/fmradio.c

@@ -31,7 +31,7 @@
 
 void UI_DisplayFM(void)
 {
-    char String[16] = {0};
+    char String[16];
     char *pPrintStr = String;
     UI_DisplayClear();
 
@@ -80,7 +80,6 @@ void UI_DisplayFM(void)
 
     UI_PrintString(pPrintStr, 0, 127, 3, 10); // memory, vfo, scan
 
-    memset(String, 0, sizeof(String));
     if (gAskToSave || (gEeprom.FM_IsMrMode && gInputBoxIndex > 0)) {
         UI_GenerateChannelString(String, gFM_ChannelPosition);
     } else if (gAskToDelete) {

App/ui/helper.c

@@ -40,6 +40,8 @@ void UI_GenerateChannelString(char *pString, const uint16_t Channel)
     pString[2] = '-';
     for (i = 0; i < 2; i++)
         pString[i + 3] = (gInputBox[i] == 10) ? '-' : gInputBox[i] + '0';
+
+    pString[5] = 0;
 }
 
 void UI_GenerateChannelStringEx(char *pString, const bool bShowPrefix, const uint16_t ChannelNumber)
@@ -323,6 +325,23 @@ static void sort(int16_t *a, int16_t *b)
       }
     }
 
+    void GUI_DisplaySmallestInverse(const char *pString, uint8_t x, uint8_t Line,
+                                bool statusbar, bool fill, uint8_t end)
+    {
+        // First draw the string normally
+        GUI_DisplaySmallest(pString, x, (Line * 8) + 1, statusbar, fill);
+
+        // Now invert the framebuffer/statusline bits for the rendered area
+        uint8_t start = (x - 2);
+        uint8_t *buffer = statusbar ? gStatusLine : gFrameBuffer[Line];
+
+        buffer[start] ^= 0x3E;
+        for (uint8_t i = start + 1; i < end; i++) {
+            buffer[i] ^= 0x7F;
+        }
+        buffer[end] ^= 0x3E;
+    }
+
     void UI_DisplayUnlockKeyboard(uint8_t shift) {
         if (gEeprom.KEY_LOCK && gKeypadLocked > 0)
         {   // tell user how to unlock the keyboard
@@ -406,3 +425,8 @@ void UI_DisplayClear()
 {
     memset(gFrameBuffer, 0, sizeof(gFrameBuffer));
 }
+
+void UI_StatusClear()
+{
+    memset(gStatusLine, 0, sizeof(gStatusLine));
+}

App/ui/helper.h

@@ -38,6 +38,7 @@ void UI_DrawPixelBuffer(uint8_t (*buffer)[128], uint8_t x, uint8_t y, bool black
     void PutPixel(uint8_t x, uint8_t y, bool fill);
     void PutPixelStatus(uint8_t x, uint8_t y, bool fill);
     void GUI_DisplaySmallest(const char *pString, uint8_t x, uint8_t y, bool statusbar, bool fill);
+    void GUI_DisplaySmallestInverse(const char *pString, uint8_t x, uint8_t Line, bool statusbar, bool fill, uint8_t endX);
     void UI_DisplayUnlockKeyboard(uint8_t shift);
     bool IsEmptyName(const char *name, uint8_t len);
 #endif
@@ -45,5 +46,6 @@ void UI_DrawLineBuffer(uint8_t (*buffer)[128], int16_t x1, int16_t y1, int16_t x
 void UI_DrawRectangleBuffer(uint8_t (*buffer)[128], int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool black);
 
 void UI_DisplayClear();
+void UI_StatusClear();
 
 #endif

App/ui/inputbox.c

@@ -41,4 +41,19 @@ const char* INPUTBOX_GetAscii()
         inputBoxAscii[i] = (c==10)? '-' : '0' + c;
     }
     return inputBoxAscii;
+}
+
+const char* INPUTBOX_GetAsciiAlignRight() {
+    int targetPos = 7;
+
+    for (int i = 7; i >= 0; i--) {
+        if (gInputBox[i] != 10) {
+            inputBoxAscii[targetPos--] = '0' + gInputBox[i];
+        }
+    }
+
+    while(targetPos >= 0)
+        inputBoxAscii[targetPos--] = '-';
+
+    return inputBoxAscii;
 }

App/ui/inputbox.h

@@ -25,7 +25,9 @@ extern char    gInputBox[8];
 extern uint8_t gInputBoxIndex;
 
 void INPUTBOX_Append(const KEY_Code_t Digit);
+
 const char* INPUTBOX_GetAscii();
+const char* INPUTBOX_GetAsciiAlignRight();
 
 #endif
 

App/ui/lock.c

@@ -34,7 +34,7 @@ static void Render(void)
     unsigned int i;
     char         String[7];
 
-    memset(gStatusLine,  0, sizeof(gStatusLine));
+    UI_StatusClear();
     UI_DisplayClear();
 
     UI_PrintString("PASSWORD", 0, 127, 1, 10);
@@ -80,16 +80,7 @@ void UI_DisplayLock(void)
 
                     switch (Key)
                     {
-                        case KEY_0:
-                        case KEY_1:
-                        case KEY_2:
-                        case KEY_3:
-                        case KEY_4:
-                        case KEY_5:
-                        case KEY_6:
-                        case KEY_7:
-                        case KEY_8:
-                        case KEY_9:
+                        case KEY_0...KEY_9:
                             INPUTBOX_Append(Key - KEY_0);
 
                             if (gInputBoxIndex < 6)   // 6 frequency digits

App/ui/main.c

@@ -17,8 +17,14 @@
 #include <string.h>
 #include <stdlib.h>  // abs()
 
+#include "app/app.h"
 #include "app/chFrScanner.h"
 #include "app/dtmf.h"
+
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+    #include "app/beam.h"
+#endif
+
 #ifdef ENABLE_AM_FIX
     #include "am_fix.h"
 #endif
@@ -60,6 +66,70 @@ center_line_t center_line = CENTER_LINE_NONE;
     }
 #endif
 
+#ifdef ENABLE_FEAT_F4HWN_SCAN_PROGRESS
+#define SCAN_PROGRESS_MR_CHANNEL_BYTES ((MR_CHANNELS_MAX + 7u) / 8u)
+
+static bool     gScanProgressSessionActive;
+static bool     gScanProgressSessionIsMemory;
+static uint8_t  gScanProgressSessionScanList;
+static uint32_t gScanProgressSessionRangeStart;
+static uint32_t gScanProgressSessionRangeStop;
+static uint32_t gScanProgressSessionStep;
+static uint16_t gScanProgressMemoryTotal;
+static uint8_t  gScanProgressMemoryMap[SCAN_PROGRESS_MR_CHANNEL_BYTES];
+static uint8_t  gScanProgressMemoryExcludeOrdinalMap[SCAN_PROGRESS_MR_CHANNEL_BYTES];
+static bool     gScanProgressPrevResetVfosFlag;
+static bool     gScanProgressForceRebuild;
+static uint16_t gScanProgressLastMemoryIndex;
+static uint8_t  gScanProgressPriorityState;
+#define SCAN_PROGRESS_PRIORITY_LABEL_MASK 0x03u
+#define SCAN_PROGRESS_PRIORITY_SEEN_SHIFT 2
+#define SCAN_PROGRESS_PRIORITY_SEEN_MASK  0x1cu
+#define SCAN_PROGRESS_PRIORITY_HOLD_SHIFT 5
+#define SCAN_PROGRESS_PRIORITY_HOLD_MASK  0xe0u
+#define SCAN_PROGRESS_PRIORITY_HOLD_FRAMES 6
+#endif
+
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+static void UI_MAIN_DrawBeamLine(void)
+{
+    const char *text;
+#ifdef ENABLE_FEAT_F4HWN
+    const unsigned int line = isMainOnly() ? 5 : 3;
+#else
+    const unsigned int line = 3;
+#endif
+
+    switch (gBeamStatus) {
+    case BEAM_STATUS_TX_WAIT:
+        text = "SENDING";
+        break;
+    case BEAM_STATUS_TX_DONE:
+        text = "SENT";
+        break;
+    case BEAM_STATUS_RX_WAIT:
+        text = "WAITING";
+        break;
+    case BEAM_STATUS_RX_SAVED:
+        text = "RECEIVED";
+        break;
+    case BEAM_STATUS_RX_FULL:
+        text = "MEM FULL";
+        break;
+    case BEAM_STATUS_ERROR:
+        text = "ERROR";
+        break;
+    case BEAM_STATUS_READY:
+    default:
+        text = (gBeamMode == BEAM_MODE_TX) ? "BEAM TX" : "BEAM RX";
+        break;
+    }
+
+    memset(gFrameBuffer[line], 0, LCD_WIDTH);
+    UI_PrintStringSmallBold(text, 2, 127, line);
+}
+#endif
+
 const char *VfoStateStr[] = {
        [VFO_STATE_NORMAL]="",
        [VFO_STATE_BUSY]="BUSY",
@@ -70,6 +140,482 @@ const char *VfoStateStr[] = {
        [VFO_STATE_VOLTAGE_HIGH]="VOLT HIGH"
 };
 
+#if defined(ENABLE_FEAT_F4HWN_SCAN_FASTER) && defined(ENABLE_FEAT_F4HWN_SCAN_RSSI)
+static uint8_t UI_MAIN_GetScanRssiSparklineMask(uint8_t previousLevel, uint8_t level)
+{
+    uint8_t mask = 0;
+    const uint8_t bottom = 5;
+
+    if (level == 0)
+        return (uint8_t)(1u << bottom);
+
+    const uint8_t top = bottom + 1 - level;
+    uint8_t bridgeTop = top;
+    uint8_t bridgeBottom = top;
+
+    if (previousLevel > 0)
+    {
+        const uint8_t previousTop = bottom + 1 - previousLevel;
+        if (previousTop < bridgeTop)
+            bridgeTop = previousTop;
+        else if (previousTop > bridgeBottom)
+            bridgeBottom = previousTop;
+    }
+
+    // Solid crest line with a small vertical bridge to avoid broken diagonals.
+    for (uint8_t y = bridgeTop; y <= bridgeBottom; y++)
+        mask |= (uint8_t)(1u << y);
+
+    return mask;
+}
+
+static void UI_MAIN_DrawScanRssiSparkline(uint8_t line)
+{
+    uint8_t *p_line = gFrameBuffer[line];
+    const uint8_t x0 = 7;
+    uint8_t level[CHFRSCANNER_RSSI_SPARKLINE_WIDTH];
+
+    if (!CHFRSCANNER_HasScanRssiSparkline())
+        return;
+
+    for (uint8_t i = 0; i < CHFRSCANNER_RSSI_SPARKLINE_WIDTH; i++)
+        level[i] = CHFRSCANNER_GetScanRssiSparklineLevel(i);
+
+    for (uint8_t i = 0; i < CHFRSCANNER_RSSI_SPARKLINE_WIDTH; i++)
+    {
+        const uint8_t previousRaw = (i > 0) ? level[i - 1] : 0;
+        const uint8_t nextRaw = (i + 1 < CHFRSCANNER_RSSI_SPARKLINE_WIDTH) ? level[i + 1] : 0;
+        uint8_t displayLevel = (uint8_t)((previousRaw + 2u * level[i] + nextRaw + 2u) >> 2);
+        uint8_t previousLevel = previousRaw;
+
+        if (level[i] == 0 && previousRaw == 0 && nextRaw == 0)
+            displayLevel = 0;
+        else if (displayLevel == 0)
+            displayLevel = 1;
+
+        if (i > 0)
+        {
+            const uint8_t previousPreviousRaw = (i > 1) ? level[i - 2] : 0;
+            previousLevel = (uint8_t)((previousPreviousRaw + 2u * previousRaw + level[i] + 2u) >> 2);
+        }
+
+        const uint8_t mask = UI_MAIN_GetScanRssiSparklineMask(previousLevel, displayLevel);
+        p_line[x0 + i] = (p_line[x0 + i] & 0x80) | mask;
+    }
+}
+#endif
+
+#ifdef ENABLE_FEAT_F4HWN_SCAN_PROGRESS
+static void ScanProgress_ResetSession(void)
+{
+    gScanProgressSessionActive = false;
+    gScanProgressMemoryTotal   = 0;
+    gScanProgressPrevResetVfosFlag = false;
+    gScanProgressForceRebuild = false;
+    gScanProgressLastMemoryIndex = 0;
+    gScanProgressPriorityState = 0;
+}
+
+void UI_MAIN_NotifyScanProgressDataChanged(void)
+{
+    gScanProgressForceRebuild = true;
+    gUpdateStatus = true;
+}
+
+static inline void ScanProgress_SetBit(uint8_t *map, uint16_t ch)
+{
+    map[ch >> 3] |= (uint8_t)(1u << (ch & 7));
+}
+
+static inline bool ScanProgress_GetBit(const uint8_t *map, uint16_t ch)
+{
+    return ((map[ch >> 3] >> (ch & 7)) & 1u) != 0;
+}
+
+static uint8_t ScanProgress_GetActiveScanList(void)
+{
+    const uint8_t max_scan_list = MR_CHANNELS_LIST + 1;
+    uint8_t scan_list = gEeprom.SCAN_LIST_DEFAULT;
+
+    if (scan_list == 0 || scan_list > max_scan_list)
+        scan_list = max_scan_list;
+
+    return scan_list;
+}
+
+static bool ScanProgress_ChannelBelongsToList(uint16_t channel, const ChannelAttributes_t *att, uint8_t scan_list)
+{
+    if (!IS_MR_CHANNEL(channel))
+        return false;
+
+    if (att->band > BAND7_470MHz)
+        return false;
+
+    if (scan_list > MR_CHANNELS_LIST && att->scanlist != 0)
+        return true;
+
+    if (scan_list > 0 && att->scanlist == (MR_CHANNELS_LIST + 1))
+        return true;
+
+    if (scan_list == 0 || scan_list != att->scanlist)
+        return false;
+
+    if (gEeprom.SCAN_LIST_ENABLED) {
+        const uint16_t priority1 = gEeprom.SCANLIST_PRIORITY_CH[0];
+        const uint16_t priority2 = gEeprom.SCANLIST_PRIORITY_CH[1];
+        if (priority1 == channel || priority2 == channel)
+            return false;
+    }
+
+    return true;
+}
+
+static void ScanProgress_RebuildMemoryMap(uint8_t scan_list)
+{
+    uint16_t ordinal = 0;
+
+    memset(gScanProgressMemoryMap, 0, sizeof(gScanProgressMemoryMap));
+    memset(gScanProgressMemoryExcludeOrdinalMap, 0, sizeof(gScanProgressMemoryExcludeOrdinalMap));
+    gScanProgressMemoryTotal = 0;
+
+    for (uint16_t ch = MR_CHANNEL_FIRST; IS_MR_CHANNEL(ch); ch++) {
+        const ChannelAttributes_t *att = MR_GetChannelAttributes(ch);
+
+        if (att == NULL || !ScanProgress_ChannelBelongsToList(ch, att, scan_list))
+            continue;
+
+        ScanProgress_SetBit(gScanProgressMemoryMap, ch);
+        ordinal++;
+
+        if (att->exclude) {
+            ScanProgress_SetBit(gScanProgressMemoryExcludeOrdinalMap, (uint16_t)(ordinal - 1));
+        }
+
+        gScanProgressMemoryTotal++;
+    }
+}
+
+static uint16_t ScanProgress_GetMemoryOrdinal(uint16_t channel)
+{
+    uint16_t ordinal = 0;
+
+    for (uint16_t ch = MR_CHANNEL_FIRST; IS_MR_CHANNEL(ch); ch++) {
+        if (!ScanProgress_GetBit(gScanProgressMemoryMap, ch))
+            continue;
+
+        ordinal++;
+        if (ch == channel)
+            return ordinal;
+    }
+
+    return 0;
+}
+
+static bool ScanProgress_IsForward(void)
+{
+    return gScanStateDir != SCAN_REV;
+}
+
+static bool ScanProgress_BucketHasExcludedOrdinal(uint32_t first_ordinal, uint32_t last_ordinal)
+{
+    if (first_ordinal == 0)
+        first_ordinal = 1;
+    if (last_ordinal > gScanProgressMemoryTotal)
+        last_ordinal = gScanProgressMemoryTotal;
+    if (first_ordinal > last_ordinal)
+        return false;
+
+    for (uint32_t ordinal = first_ordinal; ordinal <= last_ordinal; ordinal++) {
+        if (ScanProgress_GetBit(gScanProgressMemoryExcludeOrdinalMap, (uint16_t)(ordinal - 1)))
+            return true;
+    }
+
+    return false;
+}
+
+static void ScanProgress_DrawGaugeLine(uint8_t line, uint32_t current_index, uint32_t total, uint8_t width, bool memory_mode, bool range_mode, uint8_t extra_left_offset)
+{
+    const bool forward = ScanProgress_IsForward();
+
+    const uint8_t gauge_left = (uint8_t)(width * 8 + 9 + extra_left_offset);
+    const uint8_t gauge_right = 126;
+    const uint8_t fill_start = gauge_left + 2;
+    const uint8_t fill_end = gauge_right - 2;
+    const uint8_t fill_cols = fill_end - fill_start + 1;
+    uint32_t head_col;
+
+    if (total == 0)
+        total = 1;
+    if (current_index == 0)
+        current_index = 1;
+    else if (current_index > total)
+        current_index = total;
+
+    head_col = (total <= 1) ? (fill_cols - 1) : ((current_index - 1) * (fill_cols - 1)) / (total - 1);
+    head_col = MIN(head_col, fill_cols - 1);
+
+    gFrameBuffer[line][gauge_left] = 0x0c;
+    gFrameBuffer[line][gauge_left + 1] = 0x12;
+    gFrameBuffer[line][gauge_right - 1] = 0x12;
+    gFrameBuffer[line][gauge_right] = 0x0c;
+
+    for (uint8_t col = 0; col < fill_cols; col++) {
+        const uint32_t first_ordinal = ((uint32_t)col * total) / fill_cols + 1;
+        uint32_t last_ordinal = ((uint32_t)(col + 1) * total) / fill_cols;
+        const bool processed = forward ? (col <= head_col) : (col >= head_col);
+        bool excluded = false;
+        uint8_t pixel = 0x21;
+
+        if (last_ordinal < first_ordinal)
+            last_ordinal = first_ordinal;
+
+        if (memory_mode)
+            excluded = ScanProgress_BucketHasExcludedOrdinal(first_ordinal, last_ordinal);
+#ifdef ENABLE_SCAN_RANGES
+        else if (range_mode)
+            excluded = CHFRSCANNER_HasScanRangeExcludedOrdinal(first_ordinal, last_ordinal);
+#endif
+
+        if (processed && !excluded) {
+            pixel = 0x2d;
+        } else if (excluded) {
+            pixel = 0x21;
+        }
+
+        gFrameBuffer[line][fill_start + col] = pixel;
+    }
+}
+
+static inline uint8_t ScanProgress_DecimalDigits(uint32_t value)
+{
+    return sprintf(NULL, "%u", value);
+}
+
+static void ScanProgress_FormatIndex(char *out, size_t out_size, uint32_t current_index, uint32_t total, uint8_t width)
+{
+    snprintf(out, out_size, "%0*u/%u",
+             width, (unsigned int)current_index,
+             (unsigned int)total);
+}
+
+static uint8_t ScanProgress_NextPriorityLabel(uint8_t current_label, uint8_t state_mask)
+{
+    for (uint8_t i = 0; i < 3; i++) {
+        current_label++;
+        if (current_label > 2)
+            current_label = 0;
+
+        if ((state_mask & (1u << current_label)) != 0)
+            return current_label;
+    }
+
+    return 0;
+}
+
+static uint8_t ScanProgress_GetPriorityLabel(void)
+{
+    return gScanProgressPriorityState & SCAN_PROGRESS_PRIORITY_LABEL_MASK;
+}
+
+static uint8_t ScanProgress_GetPrioritySeenMask(void)
+{
+    return (gScanProgressPriorityState & SCAN_PROGRESS_PRIORITY_SEEN_MASK) >> SCAN_PROGRESS_PRIORITY_SEEN_SHIFT;
+}
+
+static uint8_t ScanProgress_GetPriorityHoldFrames(void)
+{
+    return (gScanProgressPriorityState & SCAN_PROGRESS_PRIORITY_HOLD_MASK) >> SCAN_PROGRESS_PRIORITY_HOLD_SHIFT;
+}
+
+static void ScanProgress_SetPriorityFields(uint8_t label, uint8_t seen_mask, uint8_t hold_frames)
+{
+    gScanProgressPriorityState =
+        (uint8_t)(label & SCAN_PROGRESS_PRIORITY_LABEL_MASK) |
+        (uint8_t)((seen_mask << SCAN_PROGRESS_PRIORITY_SEEN_SHIFT) & SCAN_PROGRESS_PRIORITY_SEEN_MASK) |
+        (uint8_t)((hold_frames << SCAN_PROGRESS_PRIORITY_HOLD_SHIFT) & SCAN_PROGRESS_PRIORITY_HOLD_MASK);
+}
+
+static bool ScanProgress_BuildRangeIndex(uint32_t *current_index_out, uint32_t *total_out)
+{
+#ifdef ENABLE_SCAN_RANGES
+    uint32_t step = gScanProgressSessionStep ? gScanProgressSessionStep : 1;
+    uint32_t total = ((gScanProgressSessionRangeStop - gScanProgressSessionRangeStart) / step) + 1;
+    uint32_t current_freq = gRxVfo->freq_config_RX.Frequency;
+    uint32_t current_abs;
+
+    if (gScanProgressSessionRangeStart == 0 || gScanProgressSessionRangeStop < gScanProgressSessionRangeStart || current_index_out == NULL || total_out == NULL)
+        return false;
+
+    if (total == 0)
+        total = 1;
+
+    if (current_freq < gScanProgressSessionRangeStart)
+        current_freq = gScanProgressSessionRangeStart;
+    else if (current_freq > gScanProgressSessionRangeStop)
+        current_freq = gScanProgressSessionRangeStop;
+
+    current_abs = ((current_freq - gScanProgressSessionRangeStart) / step) + 1;
+    if (current_abs > total)
+        current_abs = total;
+
+    *current_index_out = current_abs;
+    *total_out = total;
+
+    return true;
+#else
+    (void)current_index_out;
+    (void)total_out;
+    return false;
+#endif
+}
+
+static bool UI_DrawScanProgress(void)
+{
+    bool show_memory = IS_MR_CHANNEL(gNextMrChannel);
+    bool show_range = false;
+    bool show_priority_label = false;
+    uint8_t priority_now = 0;
+    const char *priority_label = "  ";
+    char text[24];
+    uint8_t line;
+    uint32_t current_index = 1;
+    uint32_t total = 1;
+
+#ifdef ENABLE_SCAN_RANGES
+    show_range = !show_memory && gScanRangeStart != 0;
+#endif
+
+    if (!show_memory && !show_range) {
+        ScanProgress_ResetSession();
+        return false;
+    }
+
+    if (show_memory) {
+        const uint8_t scan_list = ScanProgress_GetActiveScanList();
+        const bool reset_vfos_edge = gFlagResetVfos && !gScanProgressPrevResetVfosFlag;
+        const bool force_rebuild = !gScanProgressSessionActive ||
+                                   !gScanProgressSessionIsMemory ||
+                                   gScanProgressSessionScanList != scan_list ||
+                                   reset_vfos_edge ||
+                                   gScanProgressForceRebuild;
+
+        gScanProgressPrevResetVfosFlag = gFlagResetVfos;
+
+        if (force_rebuild) {
+            gScanProgressSessionActive       = true;
+            gScanProgressSessionIsMemory     = true;
+            gScanProgressSessionScanList     = scan_list;
+            ScanProgress_RebuildMemoryMap(scan_list);
+            gScanProgressForceRebuild = false;
+            gScanProgressLastMemoryIndex = 0;
+        }
+
+        if (gScanProgressMemoryTotal == 0)
+            return false;
+
+        show_priority_label = gEeprom.SCAN_LIST_ENABLED &&
+                              (gEeprom.SCANLIST_PRIORITY_CH[0] < MR_CHANNELS_MAX ||
+                               gEeprom.SCANLIST_PRIORITY_CH[1] < MR_CHANNELS_MAX);
+
+        if (show_priority_label) {
+            if (gEeprom.SCANLIST_PRIORITY_CH[0] < MR_CHANNELS_MAX &&
+                gRxVfo->CHANNEL_SAVE == gEeprom.SCANLIST_PRIORITY_CH[0])
+                priority_now = 1;
+            else if (gEeprom.SCANLIST_PRIORITY_CH[1] < MR_CHANNELS_MAX &&
+                     gRxVfo->CHANNEL_SAVE == gEeprom.SCANLIST_PRIORITY_CH[1])
+                priority_now = 2;
+        }
+
+        current_index = ScanProgress_GetMemoryOrdinal(gRxVfo->CHANNEL_SAVE);
+        if (priority_now != 0 || current_index == 0) {
+            // Keep the last known normal index during priority channel hops so
+            // the gauge does not flicker between the list and priority slots.
+            current_index = gScanProgressLastMemoryIndex ? gScanProgressLastMemoryIndex : 1;
+        } else {
+            gScanProgressLastMemoryIndex = current_index;
+        }
+        total = gScanProgressMemoryTotal;
+    } else {
+#ifdef ENABLE_SCAN_RANGES
+        const uint32_t range_start = gScanRangeStart;
+        const uint32_t range_stop = gScanRangeStop;
+        const uint32_t step = gRxVfo->StepFrequency;
+
+        if (!gScanProgressSessionActive ||
+            gScanProgressSessionIsMemory ||
+            gScanProgressSessionRangeStart != range_start ||
+            gScanProgressSessionRangeStop != range_stop ||
+            gScanProgressSessionStep != step)
+        {
+            gScanProgressSessionActive      = true;
+            gScanProgressSessionIsMemory    = false;
+            gScanProgressSessionRangeStart  = range_start;
+            gScanProgressSessionRangeStop   = range_stop;
+            gScanProgressSessionStep        = step;
+        }
+
+        if (!ScanProgress_BuildRangeIndex(&current_index, &total))
+            return false;
+#else
+        return false;
+#endif
+    }
+
+    if (show_priority_label) {
+        uint8_t priority_state_label = ScanProgress_GetPriorityLabel();
+        uint8_t priority_state_seen_mask = ScanProgress_GetPrioritySeenMask();
+        uint8_t priority_state_hold_frames = ScanProgress_GetPriorityHoldFrames();
+
+        priority_state_seen_mask |= (uint8_t)(1u << priority_now);
+
+        if (priority_state_hold_frames > 0)
+            priority_state_hold_frames--;
+
+        if (priority_state_hold_frames == 0) {
+            priority_state_label = ScanProgress_NextPriorityLabel(priority_state_label,
+                                                                  priority_state_seen_mask);
+            priority_state_seen_mask = 0;
+            priority_state_hold_frames = SCAN_PROGRESS_PRIORITY_HOLD_FRAMES;
+        }
+
+        ScanProgress_SetPriorityFields(priority_state_label, priority_state_seen_mask, priority_state_hold_frames);
+
+        if (priority_state_label != 0)
+            priority_label = (priority_state_label == 1) ? "P1" : "P2";
+    } else {
+        gScanProgressPriorityState = 0;
+    }
+
+    const uint8_t width = ScanProgress_DecimalDigits(total);
+
+    ScanProgress_FormatIndex(text, sizeof(text), current_index, total, width);
+
+    uint8_t extra_offset = 0;
+
+#ifdef ENABLE_FEAT_F4HWN
+    line = isMainOnly() ? 5 : 3;
+    const uint8_t text_y = isMainOnly() ? 41 : 25;
+    GUI_DisplaySmallest(text, 2, text_y, false, true);
+
+    if (show_priority_label) {
+        const uint8_t priority_x = (uint8_t)(width * 8 + 11);
+        for (uint8_t x = 0; x < 7; x++)
+            for (uint8_t y = 0; y < 6; y++)
+                PutPixel(priority_x + x, text_y + y, false);
+        GUI_DisplaySmallest(priority_label, priority_x, text_y, false, true);
+        extra_offset = 11;
+    }
+#else
+    line = 3;
+    UI_PrintStringSmallNormal(text, 2, 0, line);
+#endif
+
+    ScanProgress_DrawGaugeLine(line, current_index, total, width, show_memory, show_range, extra_offset);
+
+    return true;
+}
+#endif
+
 // ----------------------------------------
 
 static void DrawSmallPowerBars(uint8_t *p, unsigned int level)
@@ -365,6 +911,8 @@ void UI_DisplayAudioScope(void)
 void DisplayRSSIBar(const bool now)
 {
 #if defined(ENABLE_RSSI_BAR)
+    if (APP_IsScreenSaverDisplayed())
+        return;
 
     const unsigned int txt_width    = 7 * 8;                 // 8 text chars
     const unsigned int bar_x        = 2 + txt_width + 4;     // X coord of bar graph
@@ -411,13 +959,17 @@ void DisplayRSSIBar(const bool now)
                 p_line0[i] = (p_line0[i] & 0x80) | BITMAP_VFO_Empty[i];
         }
 
-        ST7565_BlitLine(RxLine);
+        ST7565_DrawLine(0, RxLine + 1, p_line0, sizeof(BITMAP_VFO_Default));
     }
+
 #else
     const unsigned int line = 3;
 #endif
     uint8_t           *p_line        = gFrameBuffer[line];
     char               str[16];
+#ifdef ENABLE_FEAT_F4HWN
+    uint8_t            oldLine[LCD_WIDTH];
+#endif
 
 #ifndef ENABLE_FEAT_F4HWN
     const char plus[] = {
@@ -442,8 +994,15 @@ void DisplayRSSIBar(const bool now)
         )
         return;     // display is in use
 
+#ifdef ENABLE_FEAT_F4HWN
+    if (now) {
+        memcpy(oldLine, p_line, LCD_WIDTH);
+        memset(p_line, 0, LCD_WIDTH);
+    }
+#else
     if (now)
         memset(p_line, 0, LCD_WIDTH);
+#endif
 
 #ifdef ENABLE_FEAT_F4HWN
     int16_t rssi_dBm =
@@ -482,6 +1041,7 @@ void DisplayRSSIBar(const bool now)
         overS9dBm  = (uint8_t)MIN(rssi_dBm - (-93), 40);
         overS9Bars = overS9dBm / 10;
     }
+    const int16_t display_rssi_dBm = (rssi_dBm > -53) ? -53 : rssi_dBm;
 #else
     const int16_t s0_dBm   = -gEeprom.S0_LEVEL;                  // S0 .. base level
     const int16_t rssi_dBm =
@@ -500,12 +1060,12 @@ void DisplayRSSIBar(const bool now)
 #ifdef ENABLE_FEAT_F4HWN
     if (gSetting_set_gui)
     {
-        sprintf(str, "%3d", rssi_dBm);
+        sprintf(str, "%3d", display_rssi_dBm);
         UI_PrintStringSmallNormal(str, LCD_WIDTH + 8, 0, line - 1);
     }
     else
     {
-        sprintf(str, "% 4d %s", rssi_dBm, "dBm");
+        sprintf(str, "% 4d %s", display_rssi_dBm, "dBm");
         if(isMainOnly())
             GUI_DisplaySmallest(str, 2, 41, false, true);
         else
@@ -532,8 +1092,13 @@ void DisplayRSSIBar(const bool now)
     UI_PrintStringSmallNormal(str, 2, 0, line);
 #endif
     DrawLevelBar(bar_x, line, s_level + overS9Bars, 13);
+#ifdef ENABLE_FEAT_F4HWN
+    if (now && memcmp(oldLine, p_line, LCD_WIDTH) != 0)
+        ST7565_BlitLine(line);
+#else
     if (now)
         ST7565_BlitLine(line);
+#endif
 #else
     int16_t rssi = BK4819_GetRSSI();
     uint8_t Level;
@@ -664,12 +1229,41 @@ void UI_MAIN_TimeSlice500ms(void)
 
 // ----------------------------------------
 
+static void UI_FormatFrequency(uint32_t freq, char *buffer) {
+    sprintf(buffer, "%3u.%05u", freq / 100000, freq % 100000);
+}
+
+#if defined(ENABLE_SCAN_RANGES) && defined(ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE) && ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE
+static void UI_PrintScanRangeCss(char *String, uint8_t LabelX, uint8_t ValueX, uint8_t Line)
+{
+    if (gScanRangeCssType == CODE_TYPE_CONTINUOUS_TONE)
+    {
+        strcpy(String, "CTCSS");
+        UI_PrintStringSmallNormalInverse(String, LabelX, 0, Line);
+        sprintf(String, "%u.%uHz", CTCSS_Options[gScanRangeCssCode] / 10, CTCSS_Options[gScanRangeCssCode] % 10);
+    }
+    else
+    {
+        strcpy(String, "DCS");
+        UI_PrintStringSmallNormalInverse(String, LabelX, 0, Line);
+        sprintf(String, "D%03o%c", DCS_Options[gScanRangeCssCode], gScanRangeCssType == CODE_TYPE_REVERSE_DIGITAL ? 'I' : 'N');
+    }
+
+    UI_PrintStringSmallNormal(String, ValueX, 0, Line);
+}
+#endif
+
 void UI_DisplayMain(void)
 {
     char               String[22];
 
     center_line = CENTER_LINE_NONE;
 
+#ifdef ENABLE_FEAT_F4HWN_SCAN_PROGRESS
+    if (gScanStateDir == SCAN_OFF)
+        ScanProgress_ResetSession();
+#endif
+
     // clear the screen
     UI_DisplayClear();
 
@@ -751,12 +1345,17 @@ void UI_DisplayMain(void)
                         shift = 3;
                     }
 
-                    UI_PrintString("ScnRng", 5, 0, line + shift, 8);
-                    sprintf(String, "%3u.%05u", gScanRangeStart / 100000, gScanRangeStart % 100000);
+                    UI_PrintString("ScnRng", 7, 0, line + shift, 8);
+                    UI_FormatFrequency(gScanRangeStart, String);
                     UI_PrintStringSmallNormal(String, 56, 0, line + shift);
-                    sprintf(String, "%3u.%05u", gScanRangeStop / 100000, gScanRangeStop % 100000);
+                    UI_FormatFrequency(gScanRangeStop, String);
                     UI_PrintStringSmallNormal(String, 56, 0, line + shift + 1);
 
+#if defined(ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE) && ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE
+                    if (!isMainOnly() && gScanRangeCssCode != 0xFF)
+                        UI_PrintScanRangeCss(String, 6, 48, line + 2);
+#endif
+
                     if (!isMainOnly())
                         continue;
                 }
@@ -765,11 +1364,17 @@ void UI_DisplayMain(void)
                     gScanRangeStart = 0;
                 }
 #else
-                UI_PrintString("ScnRng", 5, 0, line, 8);
-                sprintf(String, "%3u.%05u", gScanRangeStart / 100000, gScanRangeStart % 100000);
+                UI_PrintString("ScnRng", 7, 0, line, 8);
+                UI_FormatFrequency(gScanRangeStart, String);
                 UI_PrintStringSmallNormal(String, 56, 0, line);
-                sprintf(String, "%3u.%05u", gScanRangeStop / 100000, gScanRangeStop % 100000);
+                UI_FormatFrequency(gScanRangeStop, String);
                 UI_PrintStringSmallNormal(String, 56, 0, line + 1);
+
+#if defined(ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE) && ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE
+                if (gScanRangeCssCode != 0xFF)
+                    UI_PrintScanRangeCss(String, 2, 44, line + 2);
+#endif
+
                 continue;
 #endif
             }
@@ -850,14 +1455,6 @@ void UI_DisplayMain(void)
 
         uint32_t frequency = gEeprom.VfoInfo[vfo_num].pRX->Frequency;
 
-        if(TX_freq_check(frequency) != 0 && gEeprom.VfoInfo[vfo_num].TX_LOCK == true && !FUNCTION_IsRx())
-        {
-            if(isMainOnly())
-                memcpy(p_line0 + 25, BITMAP_VFO_Lock, sizeof(BITMAP_VFO_Lock));
-            else
-                memcpy(p_line0 + 25, BITMAP_VFO_Lock, sizeof(BITMAP_VFO_Lock));
-        }
-
         if (gCurrentFunction == FUNCTION_TRANSMIT)
         {   // transmitting
 
@@ -941,6 +1538,17 @@ void UI_DisplayMain(void)
 #endif
         }
 
+#if defined(ENABLE_FEAT_F4HWN_SCAN_FASTER) && defined(ENABLE_FEAT_F4HWN_SCAN_RSSI)
+        if (vfo_num == gEeprom.RX_VFO && gScanStateDir != SCAN_OFF && !FUNCTION_IsRx())
+            UI_MAIN_DrawScanRssiSparkline(line);
+#endif
+
+        if((gScanStateDir == SCAN_OFF || vfo_num != gEeprom.RX_VFO) && TX_freq_check(frequency) != 0 && gEeprom.VfoInfo[vfo_num].TX_LOCK == true)
+        {
+            if (!FUNCTION_IsRx() || RxOnVfofrequency != frequency)
+                memcpy(p_line0 + 24, BITMAP_VFO_Lock, sizeof(BITMAP_VFO_Lock));
+        }
+
         if (IS_MR_CHANNEL(gEeprom.ScreenChannel[vfo_num]))
         {   // channel mode
             const unsigned int x = 1;
@@ -948,7 +1556,7 @@ void UI_DisplayMain(void)
             if (!inputting || gScanStateDir != SCAN_OFF)
                 sprintf(String, "%04u", gEeprom.ScreenChannel[vfo_num] + 1);
             else
-                sprintf(String, "%.4s", INPUTBOX_GetAscii());  // show the input text
+                sprintf(String, "%.4s", INPUTBOX_GetAsciiAlignRight() + 4);  // show the input text
 
             //if (gSetting_set_gui) {
                 UI_PrintStringSmallNormalInverse(String, x, 0, line + 1);
@@ -1067,29 +1675,22 @@ void UI_DisplayMain(void)
 
                 const ChannelAttributes_t* att = MR_GetChannelAttributes(gEeprom.ScreenChannel[vfo_num]);
 
+                const char *displayStr;
+                uint8_t xStart = 113; // 3-char name aligned left
 
                 if(att->exclude == false)
                 {
                     // show the scan list assigment symbols
-                    const ChannelAttributes_t* att = MR_GetChannelAttributes(gEeprom.ScreenChannel[vfo_num]);
-
                     uint8_t countList = att->scanlist;
                     if(countList > MR_CHANNELS_LIST + 1) {
                         countList = 0;
                     }
 
-                    const char *displayStr;
-                    uint8_t xStart, xDisplay;
-
                     if (countList == MR_CHANNELS_LIST + 1) {
                         displayStr = "ALL";
-                        xStart = 113;
-                        xDisplay = 115;
                     } 
                     else if (countList == 0) {
                         displayStr = "OFF";
-                        xStart = 113;
-                        xDisplay = 115;
                     } 
                     else {
                         // List 1 to MR_CHANNELS_LIST
@@ -1099,41 +1700,31 @@ void UI_DisplayMain(void)
                         if (IsEmptyName(name, sizeof(gListName[0]))) {
                             sprintf(String, "%02d", countList);
                             xStart = 117;  // 2-digit number aligned right
-                            xDisplay = 119;
                         } 
                         else {
                             sprintf(String, "%.3s", name);
-                            xStart = 113;  // 3-char name aligned left
-                            xDisplay = 115;
                         }
                         displayStr = String;
                     }
-
-                    GUI_DisplaySmallest(displayStr, xDisplay, line == 0 ? 1 : 33, false, true);
-
-                    gFrameBuffer[line][xStart] ^= 0x3E;
-                    for (uint8_t x = xStart + 1; x < 127; x++) {
-                        gFrameBuffer[line][x] ^= 0x7F;
-                    }
-                    gFrameBuffer[line][127] ^= 0x3E;
-
                 }
                 else
                 {
-                    const char *displayStr = "EX";
-
-                    uint8_t xStart = 117;
-                    uint8_t xDisplay = 119;
-                    
-                    GUI_DisplaySmallest(displayStr, xDisplay, line == 0 ? 1 : 33, false, true);
-
-                    gFrameBuffer[line][xStart] ^= 0x3E;
-                    for (uint8_t x = xStart + 1; x < 127; x++) {
-                        gFrameBuffer[line][x] ^= 0x7F;
-                    }
-                    gFrameBuffer[line][127] ^= 0x3E;
+                    displayStr = "EX";
+                    xStart = 117;
                 }
 
+#ifdef ENABLE_FEAT_F4HWN
+                GUI_DisplaySmallestInverse(displayStr, xStart + 2, line, false, true, 127);  
+#else
+                GUI_DisplaySmallest(displayStr, xStart + 2, line == 0 ? 1 : 33, false, true);
+
+                gFrameBuffer[line][xStart] ^= 0x3E;
+                for (uint8_t x = xStart + 1; x < 127; x++) {
+                    gFrameBuffer[line][x] ^= 0x7F;
+                }
+                gFrameBuffer[line][127] ^= 0x3E;
+#endif
+
                 #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
                 {
                     }
@@ -1151,7 +1742,7 @@ void UI_DisplayMain(void)
                 switch (gEeprom.CHANNEL_DISPLAY_MODE)
                 {
                     case MDF_FREQUENCY: // show the channel frequency
-                        sprintf(String, "%3u.%05u", frequency / 100000, frequency % 100000);
+                        UI_FormatFrequency(frequency, String);
 #ifdef ENABLE_BIG_FREQ
                         if(frequency < _1GHz_in_KHz) {
                             // show the remaining 2 small frequency digits
@@ -1211,7 +1802,7 @@ void UI_DisplayMain(void)
 #ifdef ENABLE_FEAT_F4HWN
                             if (isMainOnly())
                             {
-                                sprintf(String, "%3u.%05u", frequency / 100000, frequency % 100000);
+                                UI_FormatFrequency(frequency, String);
                                 if(frequency < _1GHz_in_KHz) {
                                     // show the remaining 2 small frequency digits
                                     UI_PrintStringSmallNormal(String + 7, 113, 0, line + 4);
@@ -1241,7 +1832,7 @@ void UI_DisplayMain(void)
             }
             else
             {   // frequency mode
-                sprintf(String, "%3u.%05u", frequency / 100000, frequency % 100000);
+                UI_FormatFrequency(frequency, String);
 
 #ifdef ENABLE_BIG_FREQ
                 if(frequency < _1GHz_in_KHz) {
@@ -1321,6 +1912,11 @@ void UI_DisplayMain(void)
 
         String[0] = '\0';
         const VFO_Info_t *vfoInfo = &gEeprom.VfoInfo[vfo_num];
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+        const VFO_Info_t *scanDisplayVfo = CHFRSCANNER_GetScanDisplayVfo();
+        if (vfo_num == gEeprom.RX_VFO && scanDisplayVfo != NULL)
+            vfoInfo = scanDisplayVfo;
+#endif
 
         // show the modulation symbol
         const char * s = "";
@@ -1510,10 +2106,12 @@ void UI_DisplayMain(void)
 #endif
 
 #if ENABLE_FEAT_F4HWN
+        const uint8_t displayBandwidth = vfoInfo->CHANNEL_BANDWIDTH;
+
         #ifdef ENABLE_FEAT_F4HWN_NARROWER
             bool narrower = 0;
 
-            if(vfoInfo->CHANNEL_BANDWIDTH == BANDWIDTH_NARROW && gSetting_set_nfm == 1)
+            if(displayBandwidth == BANDWIDTH_NARROW && gSetting_set_nfm == 1)
             {
                 narrower = 1;
             }
@@ -1521,23 +2119,23 @@ void UI_DisplayMain(void)
             if (gSetting_set_gui)
             {
                 const char *bandWidthNames[] = {"W", "N", "N+"};
-                UI_PrintStringSmallNormal(bandWidthNames[vfoInfo->CHANNEL_BANDWIDTH + narrower], LCD_WIDTH + 80, 0, line + 1);
+                UI_PrintStringSmallNormal(bandWidthNames[displayBandwidth + narrower], LCD_WIDTH + 80, 0, line + 1);
             }
             else
             {
                 const char *bandWidthNames[] = {"WIDE", "NAR", "NAR+"};
-                GUI_DisplaySmallest(bandWidthNames[vfoInfo->CHANNEL_BANDWIDTH + narrower], 91, line == 0 ? 17 : 49, false, true);
+                GUI_DisplaySmallest(bandWidthNames[displayBandwidth + narrower], 91, line == 0 ? 17 : 49, false, true);
             }
         #else
             if (gSetting_set_gui)
             {
                 const char *bandWidthNames[] = {"W", "N"};
-                UI_PrintStringSmallNormal(bandWidthNames[vfoInfo->CHANNEL_BANDWIDTH], LCD_WIDTH + 80, 0, line + 1);
+                UI_PrintStringSmallNormal(bandWidthNames[displayBandwidth], LCD_WIDTH + 80, 0, line + 1);
             }
             else
             {
                 const char *bandWidthNames[] = {"WIDE", "NAR"};
-                GUI_DisplaySmallest(bandWidthNames[vfoInfo->CHANNEL_BANDWIDTH], 91, line == 0 ? 17 : 49, false, true);
+                GUI_DisplaySmallest(bandWidthNames[displayBandwidth], 91, line == 0 ? 17 : 49, false, true);
             }
         #endif
 #else
@@ -1605,11 +2203,31 @@ void UI_DisplayMain(void)
     UI_MAIN_PrintAGC(false);
 #endif
 
+#if defined(ENABLE_SCAN_RANGES) && defined(ENABLE_FEAT_F4HWN) && defined(ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE) && ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE
+    if (isMainOnly() && gScanRangeStart && gScanRangeCssCode != 0xFF)
+        UI_PrintScanRangeCss(String, 2, 46, 6);
+#endif
+
     if (center_line == CENTER_LINE_NONE)
     {   // we're free to use the middle line
 
         const bool rx = FUNCTION_IsRx();
 
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+        if (gBeamActive) {
+            center_line = CENTER_LINE_BEAM;
+            UI_MAIN_DrawBeamLine();
+        }
+        else
+#endif
+#ifdef ENABLE_FEAT_F4HWN_SCAN_PROGRESS
+        if (!rx && gScanStateDir != SCAN_OFF && gKeypadLocked == 0)
+        {
+            center_line = CENTER_LINE_SCAN_PROGRESS;
+            UI_DrawScanProgress();
+        }
+        else
+#endif
 #ifdef ENABLE_FEAT_F4HWN_AUDIO_SCOPE
         if (gSetting_mic_bar && gCurrentFunction == FUNCTION_TRANSMIT) {
             // Reserve the line so no other element overwrites it.
@@ -1728,13 +2346,18 @@ void UI_DisplayMain(void)
     if (isMainOnly() && !gDTMF_InputMode)
     {
         sprintf(String, "VFO %s", activeTxVFO ? "B" : "A");
-        GUI_DisplaySmallest(String, 107, 50, false, true);
+
+#ifdef ENABLE_FEAT_F4HWN
+        GUI_DisplaySmallestInverse(String, 107, 6, false, true, 127);
+#else
+        GUI_DisplaySmallest(String, 107, 49, false, true);
 
         gFrameBuffer[6][105] ^= 0x7C;
         for (uint8_t x = 106; x < 127; x++) {
             gFrameBuffer[6][x] ^= 0xFE;
         }
         gFrameBuffer[6][127] ^= 0x7C;
+#endif
 
         /*
         UI_PrintStringSmallBold(String, 92, 0, 6);

App/ui/main.h

@@ -22,12 +22,16 @@
 enum center_line_t {
     CENTER_LINE_NONE = 0,
     CENTER_LINE_IN_USE,
+    CENTER_LINE_SCAN_PROGRESS,
     CENTER_LINE_AUDIO_BAR,
     CENTER_LINE_AUDIO_SCOPE,
     CENTER_LINE_RSSI,
     CENTER_LINE_AM_FIX_DATA,
     CENTER_LINE_DTMF_DEC,
-    CENTER_LINE_CHARGE_DATA
+    CENTER_LINE_CHARGE_DATA,
+#ifdef ENABLE_FEAT_F4HWN_BEAM
+    CENTER_LINE_BEAM
+#endif
 };
 
 enum Vfo_txtr_mode{
@@ -49,6 +53,12 @@ void UI_DisplayAudioScope(void);
 void UI_MAIN_TimeSlice500ms(void);
 void UI_DisplayMain(void);
 
+#ifdef ENABLE_FEAT_F4HWN_SCAN_PROGRESS
+void UI_MAIN_NotifyScanProgressDataChanged(void);
+#else
+static inline void UI_MAIN_NotifyScanProgressDataChanged(void) {}
+#endif
+
 #ifdef ENABLE_AGC_SHOW_DATA
 void UI_MAIN_PrintAGC(bool force);
 #endif

App/ui/menu.c

@@ -27,6 +27,7 @@
 #include "../driver/eeprom.h"
 #include "../driver/st7565.h"
 #include "../external/printf/printf.h"
+#include "../font.h"
 #include "../frequencies.h"
 #include "../helper/battery.h"
 #include "../misc.h"
@@ -40,6 +41,7 @@
 #include "inputbox.h"
 #include "menu.h"
 #include "ui.h"
+#include "welcome.h"
 
 
 const t_menu_item MenuList[] =
@@ -166,6 +168,12 @@ const t_menu_item MenuList[] =
 #ifdef ENABLE_NOAA
     {"SetNWR",      MENU_NOAA_S    },
 #endif
+#ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+    {"SetScn",      MENU_SET_SCN       },
+#endif
+#ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+    {"SetSav",      MENU_SET_SAV       },
+#endif
 #endif
     // hidden menu items from here on
     // enabled if pressing both the PTT and upper side button at power-on
@@ -192,7 +200,7 @@ const t_menu_item MenuList[] =
 
 const uint8_t FIRST_HIDDEN_MENU_ITEM = MENU_F_LOCK;
 
-const char gSubMenu_TXP[][6] =
+const char* const gSubMenu_TXP[] =
 {
     "USER",
     "LOW 1",
@@ -204,29 +212,26 @@ const char gSubMenu_TXP[][6] =
     "HIGH"
 };
 
-const char gSubMenu_SFT_D[][4] =
+const char* const gSubMenu_SFT_D[] =
 {
     "OFF",
     "+",
     "-"
 };
 
-const char gSubMenu_W_N[][7] =
+const char* const gSubMenu_W_N[] =
 {
     "WIDE",
     "NARROW"
 };
 
-const char gSubMenu_OFF_ON[][4] =
+const char* const gSubMenu_OFF_ON[] =
 {
     "OFF",
     "ON"
 };
 
-const char gSubMenu_NA[4] =
-{
-    "N/A"
-};
+const char* gSubMenu_NA = "N/A";
 
 const char* const gSubMenu_RXMode[] =
 {
@@ -237,7 +242,7 @@ const char* const gSubMenu_RXMode[] =
 };
 
 #ifdef ENABLE_VOICE
-    const char gSubMenu_VOICE[][4] =
+    const char* const gSubMenu_VOICE[] =
     {
         "OFF",
         "CHI",
@@ -254,7 +259,7 @@ const char* const gSubMenu_MDF[] =
 };
 
 #ifdef ENABLE_ALARM
-    const char gSubMenu_AL_MOD[][5] =
+    const char* const gSubMenu_AL_MOD[] =
     {
         "SITE",
         "TONE"
@@ -262,7 +267,7 @@ const char* const gSubMenu_MDF[] =
 #endif
 
 #ifdef ENABLE_DTMF_CALLING
-const char gSubMenu_D_RSP[][11] =
+const char* const gSubMenu_D_RSP[] =
 {
     "DO\nNOTHING",
     "RING",
@@ -280,7 +285,7 @@ const char* const gSubMenu_PTT_ID[] =
     "APOLLO\nQUINDAR"
 };
 
-const char gSubMenu_PONMSG[][8] =
+const char* const gSubMenu_PONMSG[] =
 {
 #ifdef ENABLE_FEAT_F4HWN
     "ALL",
@@ -290,23 +295,36 @@ const char gSubMenu_PONMSG[][8] =
 #endif
     "MESSAGE",
     "VOLTAGE",
+#ifdef ENABLE_FEAT_F4HWN_LOGO
+    "LOGO",
+#endif
     "NONE"
 };
 
-const char gSubMenu_ROGER[][6] =
+#if defined(ENABLE_FEAT_F4HWN) && defined(ENABLE_FEAT_F4HWN_LOGO_SAV)
+const char* const gSubMenu_SET_SAV[] =
+{
+    "OFF",
+    "LOGO",
+    "LOGO+",
+    "MATRIX"
+};
+#endif
+
+const char* const gSubMenu_ROGER[] =
 {
     "OFF",
     "ROGER",
     "MDC"
 };
 
-const char gSubMenu_RESET[][4] =
+const char* const gSubMenu_RESET[] =
 {
     "VFO",
     "ALL"
 };
 
-const char * const gSubMenu_F_LOCK[] =
+const char* const gSubMenu_F_LOCK[] =
 {
     "DEFAULT+\n137-174\n400-470",
     "FCC HAM\n144-148\n420-450",
@@ -327,7 +345,7 @@ const char * const gSubMenu_F_LOCK[] =
     "UNLOCK\nALL",
 };
 
-const char gSubMenu_RX_TX[][6] =
+const char* const gSubMenu_RX_TX[] =
 {
     "OFF",
     "TX",
@@ -335,14 +353,14 @@ const char gSubMenu_RX_TX[][6] =
     "TX/RX"
 };
 
-const char gSubMenu_BAT_TXT[][8] =
+const char* const gSubMenu_BAT_TXT[] =
 {
     "NONE",
     "VOLTAGE",
     "PERCENT"
 };
 
-const char gSubMenu_BATTYP[][12] =
+const char* const gSubMenu_BATTYP[] =
 {
     "1600mAh K5",
     "2200mAh K5",
@@ -351,14 +369,14 @@ const char gSubMenu_BATTYP[][12] =
     "2500mAh K1"
 };
 
-const char gSubMenu_SET_NAV[][17] =
+const char* const gSubMenu_SET_NAV[] =
 {
     "LEFT\nRIGHT\nUV-K1",
     "UP\nDOWN\nUV-K5(8)",
 };
 
 #ifndef ENABLE_FEAT_F4HWN
-const char gSubMenu_SCRAMBLER[][7] =
+const char* const gSubMenu_SCRAMBLER[] =
 {
     "OFF",
     "2600Hz",
@@ -375,7 +393,7 @@ const char gSubMenu_SCRAMBLER[][7] =
 #endif
 
 #ifdef ENABLE_FEAT_F4HWN
-    const char gSubMenu_SET_PWR[][6] =
+    const char* const gSubMenu_SET_PWR[] =
     {
         "< 20m",
         "125m",
@@ -386,13 +404,13 @@ const char gSubMenu_SCRAMBLER[][7] =
         "5"
     };
 
-    const char gSubMenu_SET_PTT[][8] =
+    const char* const gSubMenu_SET_PTT[] =
     {
         "CLASSIC",
         "ONEPUSH"
     };
 
-    const char gSubMenu_SET_TOT[][7] =  // Use by SET_EOT too
+    const char* const gSubMenu_SET_TOT[] =  
     {
         "OFF",
         "SOUND",
@@ -400,20 +418,28 @@ const char gSubMenu_SCRAMBLER[][7] =
         "ALL"
     };
 
-    const char gSubMenu_SET_LCK[][9] =
+    const char* const gSubMenu_SET_LCK[] =
     {
         "KEYS",
         "KEYS+PTT"
     };
 
-    const char gSubMenu_SET_MET[][8] =
+    const char* const gSubMenu_SET_MET[] =
     {
         "TINY",
         "CLASSIC"
     };
 
+    #ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+        const char* const gSubMenu_SET_SCN[] =
+        {
+            "NORMAL",
+            "FAST"
+        };
+    #endif
+
     #ifdef ENABLE_FEAT_F4HWN_AUDIO
-        const char gSubMenu_SET_AUD_FM[][6] =
+        const char* const gSubMenu_SET_AUD_FM[] =
         {
             "FLAT",
             "CLEAN",
@@ -422,7 +448,7 @@ const char gSubMenu_SCRAMBLER[][7] =
             "MAX"
         };
 
-        const char gSubMenu_SET_AUD_AM[][6] =
+        const char* const gSubMenu_SET_AUD_AM[] =
         {
             "SHARP",
             "STOCK",
@@ -431,7 +457,7 @@ const char gSubMenu_SCRAMBLER[][7] =
     #endif
 
     #ifdef ENABLE_FEAT_F4HWN_NARROWER
-        const char gSubMenu_SET_NFM[][9] =
+        const char* const gSubMenu_SET_NFM[] =
         {
             "NARROW",
             "NARROWER"
@@ -439,7 +465,7 @@ const char gSubMenu_SCRAMBLER[][7] =
     #endif
 
     #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-        const char gSubMenu_SET_KEY[][9] =
+        const char* const gSubMenu_SET_KEY[] =
         {
             "KEY_MENU",
             "KEY_UP",
@@ -480,7 +506,7 @@ const t_sidefunction gSubMenu_SIDEFUNCTIONS[] =
     {"VFO\nMEM",        ACTION_OPT_VFO_MR},
     {"MODE",            ACTION_OPT_SWITCH_DEMODUL},
 #ifdef ENABLE_BLMIN_TMP_OFF
-    {"BLMIN\nTMP OFF",  ACTION_OPT_BLMIN_TMP_OFF},      //BackLight Minimum Temporay OFF
+    {"BLMIN\nTMP OFF",  ACTION_OPT_BLMIN_TMP_OFF},      //BackLight Minimum Temporary OFF
 #endif
 #ifdef ENABLE_FEAT_F4HWN
     {"RX MODE",         ACTION_OPT_RXMODE},
@@ -495,6 +521,9 @@ const t_sidefunction gSubMenu_SIDEFUNCTIONS[] =
         {"POWER\nHIGH",    ACTION_OPT_POWER_HIGH},
         {"REMOVE\nOFFSET",  ACTION_OPT_REMOVE_OFFSET},
     #endif
+    #ifdef ENABLE_FEAT_F4HWN_BEAM
+        {"BEAM",            ACTION_OPT_BEAM},
+    #endif
 #endif
 };
 
@@ -523,6 +552,64 @@ int32_t gSubMenuSelection;
 char    edit_original[17]; // a copy of the text before editing so that we can easily test for changes/difference
 char    edit[17];
 int     edit_index;
+bool    edit_is_uppercase = false;
+
+static void UI_MENU_DrawTopRightRoundedBadge(const char *text, const uint8_t line, const bool center_in_area, const uint8_t area_x1, const uint8_t area_x2)
+{
+    const size_t length = strlen(text);
+    const size_t char_pitch = ARRAY_SIZE(gFontSmall[0]) + 1u;
+    const size_t text_width = length * char_pitch;
+    const size_t capsule_span = text_width + 1u; // matches UI_PrintStringSmallNormalInverse x_end computation
+    uint8_t text_x;
+
+    if (length == 0 || line == 0 || line >= FRAME_LINES) {
+        return;
+    }
+
+    if (center_in_area && area_x2 > area_x1 + 2u) {
+        const uint8_t min_x = area_x1 + 1u;
+        uint8_t max_x;
+        const uint8_t area_width = area_x2 - area_x1 + 1u;
+
+        if (capsule_span >= area_width) {
+            text_x = min_x;
+        } else {
+            text_x = (uint8_t)(area_x1 + ((area_width - capsule_span) / 2u));
+        }
+
+        if (area_x2 > capsule_span) {
+            max_x = (uint8_t)(area_x2 - capsule_span);
+        } else {
+            max_x = min_x;
+        }
+
+        if (max_x < min_x) {
+            max_x = min_x;
+        }
+        if (text_x < min_x) {
+            text_x = min_x;
+        } else if (text_x > max_x) {
+            text_x = max_x;
+        }
+    } else {
+        if (capsule_span >= (LCD_WIDTH - 3u)) {
+            text_x = 1u;
+        } else {
+            const uint8_t global_shift_right = 1u;
+            const uint8_t base_text_x = (uint8_t)(LCD_WIDTH - capsule_span - 3u);
+            const uint8_t max_text_x  = (uint8_t)(LCD_WIDTH - capsule_span - 1u);
+            const uint16_t shifted_x = (uint16_t)base_text_x + global_shift_right;
+
+            if (shifted_x > max_text_x) {
+                text_x = max_text_x;
+            } else {
+                text_x = (uint8_t)shifted_x;
+            }
+        }
+    }
+
+    UI_PrintStringSmallNormalInverse(text, text_x, 0, line);
+}
 
 void UI_DisplayMenu(void)
 {
@@ -531,6 +618,9 @@ void UI_DisplayMenu(void)
     const unsigned int menu_item_x2    = LCD_WIDTH - 1;
     unsigned int       i;
     char               String[64];  // bigger cuz we can now do multi-line in one string (use '\n' char)
+    char               top_right_badge[16];
+
+    const int m = UI_MENU_GetCurrentMenuId();
 
 #ifdef ENABLE_DTMF_CALLING
     char               Contact[16];
@@ -578,57 +668,56 @@ void UI_DisplayMenu(void)
 #else
     {   // new menu layout .. experimental & unfinished
         const int menu_index = gMenuCursor;  // current selected menu item
-        i = 1;
+        const int menu_count = (int)gMenuListCount;
 
-        if (!gIsInSubMenu) {
-            while (i < 2)
-            {   // leading menu items - small text
-                const int k = menu_index + i - 2;
-                if (k < 0)
-                    UI_PrintStringSmallNormal(MenuList[gMenuListCount + k].name, 0, 0, i);  // wrap-a-round
-                else if (k >= 0 && k < (int)gMenuListCount)
-                    UI_PrintStringSmallNormal(MenuList[k].name, 0, 0, i);
-                i++;
-            }
+        if (menu_index >= 0 && menu_index < menu_count) 
+        {
+            if (!gIsInSubMenu) 
+            {
+                // leading menu items - small text
+                int prev_index = menu_index - 1;
+                if (prev_index < 0) {
+                    prev_index = menu_count - 1;
+                }
+                UI_PrintStringSmallNormal(MenuList[prev_index].name, 0, 0, 1);
 
-            // current menu item - keep big n fat
-            if (menu_index >= 0 && menu_index < (int)gMenuListCount)
+                // current menu item - keep big n fat
                 UI_PrintString(MenuList[menu_index].name, 0, 0, 2, 8);
-            i++;
 
-            while (i < 4)
-            {   // trailing menu item - small text
-                const int k = menu_index + i - 2;
-                if (k >= 0 && k < (int)gMenuListCount)
-                    UI_PrintStringSmallNormal(MenuList[k].name, 0, 0, 1 + i);
-                else if (k >= (int)gMenuListCount)
-                    UI_PrintStringSmallNormal(MenuList[gMenuListCount - k].name, 0, 0, 1 + i);  // wrap-a-round
-                i++;
+                // trailing menu item - small text
+                int next_index = menu_index + 1;
+                if (next_index >= menu_count) {
+                    next_index = 0;
+                }
+                UI_PrintStringSmallNormal(MenuList[next_index].name, 0, 0, 4);
+
+
+                // draw the menu index number/count
+    #ifndef ENABLE_FEAT_F4HWN
+                sprintf(String, "%2u.%u", 1 + menu_index, menu_count);
+                UI_PrintStringSmallNormal(String, 2, 0, 6);
+    #endif
+            }
+            else
+            {   
+                // current menu item
+//              strcat(String, ":");
+                UI_PrintString(MenuList[menu_index].name, 0, 0, 0, 8);
+//              UI_PrintStringSmallNormal(String, 0, 0, 0);
             }
 
-            // draw the menu index number/count
-#ifndef ENABLE_FEAT_F4HWN
-            sprintf(String, "%2u.%u", 1 + gMenuCursor, gMenuListCount);
-            UI_PrintStringSmallNormal(String, 2, 0, 6);
-#endif
+    #ifdef ENABLE_FEAT_F4HWN
+            sprintf(String, "%02u/%u", 1 + menu_index, menu_count);
+            UI_PrintStringSmallNormal(String, 6, 0, 6);
+    #endif
         }
-        else if (menu_index >= 0 && menu_index < (int)gMenuListCount)
-        {   // current menu item
-//          strcat(String, ":");
-            UI_PrintString(MenuList[menu_index].name, 0, 0, 0, 8);
-//          UI_PrintStringSmallNormal(String, 0, 0, 0);
-        }
-
-#ifdef ENABLE_FEAT_F4HWN
-        sprintf(String, "%02u/%u", 1 + gMenuCursor, gMenuListCount);
-        UI_PrintStringSmallNormal(String, 6, 0, 6);
-#endif
     }
 #endif
 
     // **************
 
-    memset(String, 0, sizeof(String));
+    String[0] = '\0';
+    top_right_badge[0] = '\0';
 
     bool already_printed = false;
 
@@ -644,7 +733,7 @@ void UI_DisplayMenu(void)
         uint8_t gaugeMax = 0;
     //#endif
 
-    switch (UI_MENU_GetCurrentMenuId())
+    switch (m)
     {
         case MENU_SQL:
             sprintf(String, "%d", gSubMenuSelection);
@@ -842,6 +931,12 @@ void UI_DisplayMenu(void)
             strcpy(String, gSubMenu_OFF_ON[gSubMenuSelection]);
             break;
 
+#if defined(ENABLE_FEAT_F4HWN) && defined(ENABLE_FEAT_F4HWN_LOGO_SAV)
+        case MENU_SET_SAV:
+            strcpy(String, gSubMenu_SET_SAV[gSubMenuSelection]);
+            break;
+#endif
+
         case MENU_MEM_CH:
         case MENU_1_CALL:
         case MENU_DEL_CH:
@@ -865,7 +960,7 @@ void UI_DisplayMenu(void)
                 {   // show the frequency so that the user knows the channels frequency
                     const uint32_t frequency = SETTINGS_FetchChannelFrequency(gSubMenuSelection);
                     sprintf(String, "%u.%05u", frequency / 100000, frequency % 100000);
-                    UI_PrintString(String, menu_item_x1, menu_item_x2, 4, 8);
+                    UI_PrintString(String, menu_item_x1, menu_item_x2, 5, 8);
                 }
 
                 SETTINGS_FetchChannelName(String, gSubMenuSelection);
@@ -899,15 +994,34 @@ void UI_DisplayMenu(void)
                 {   // show the channel name being edited
                     //UI_PrintString(edit, menu_item_x1, 0, 2, 8);
                     UI_PrintString(edit, menu_item_x1, menu_item_x2, 2, 8);
-                    if (edit_index < 10)
-                        //UI_PrintString("^", menu_item_x1 + (8 * edit_index), 0, 4, 8);  // show the cursor
-                        UI_PrintString("^", menu_item_x1 - 1 + (8 * edit_index),0, 4, 8); // show the cursor
+                    if (edit_index < 10) {
+                        // UI_PrintString("^", menu_item_x1 - 1 + (8 * edit_index),0, 4, 8); // show the cursor
+                        uint8_t x = menu_item_x1 - 1;
+                        for (uint8_t i = 0; i < 10; i++) 
+                        {
+                            if (i != edit_index) 
+                            {
+                                if (edit[i] != 'g' && edit[i] != 'j')
+                                {
+                                    UI_DrawLineBuffer(gFrameBuffer, x, 29, x + 6, 29, 1);
+                                }
+                            }
+                            else 
+                            {
+                                UI_DrawLineBuffer(gFrameBuffer, x + 2, 30, x + 4, 30, 1);
+                                UI_DrawPixelBuffer(gFrameBuffer, x + 3, 29, 1);
+                            }
+                            x += 8;
+                        }
+                        
+                        UI_PrintStringSmallNormal(edit_is_uppercase ? "ABC" : "abc", 77, 0, 4);
+                    }
                 }
 
                 if (!gAskForConfirmation)
                 {   // show the frequency so that the user knows the channels frequency
                     sprintf(String, "%u.%05u", frequency / 100000, frequency % 100000);
-                    UI_PrintString(String, menu_item_x1, menu_item_x2, 4 + (gIsInSubMenu && edit_index >= 0), 8);
+                    UI_PrintString(String, menu_item_x1, menu_item_x2, 5, 8);
                 }
             }
 
@@ -978,7 +1092,7 @@ void UI_DisplayMenu(void)
         case MENU_S_LIST:
             if (gSubMenuSelection == MR_CHANNELS_LIST + 1)
                 strcpy(String, "ALL");
-            else if (gSubMenuSelection == 0 && UI_MENU_GetCurrentMenuId() == MENU_LIST_CH)
+            else if (gSubMenuSelection == 0 && m == MENU_LIST_CH)
                 strcpy(String, "OFF");
             else {
                 const char *name = gListName[gSubMenuSelection - 1];
@@ -1003,11 +1117,19 @@ void UI_DisplayMenu(void)
             break;
 #endif
         case MENU_UPCODE:
-            sprintf(String, "%.8s\n%.8s", gEeprom.DTMF_UP_CODE, gEeprom.DTMF_UP_CODE + 8);
+            if (gEeprom.DTMF_UP_CODE[8] != '\0' && gEeprom.DTMF_UP_CODE[8] != 0xFF) {
+                sprintf(String, "%.8s\n%.8s", gEeprom.DTMF_UP_CODE, gEeprom.DTMF_UP_CODE + 8);
+            } else {
+                sprintf(String, "%.8s", gEeprom.DTMF_UP_CODE);
+            }
             break;
 
         case MENU_DWCODE:
-            sprintf(String, "%.8s\n%.8s", gEeprom.DTMF_DOWN_CODE, gEeprom.DTMF_DOWN_CODE + 8);
+            if (gEeprom.DTMF_DOWN_CODE[8] != '\0' && gEeprom.DTMF_DOWN_CODE[8] != 0xFF) {
+                sprintf(String, "%.8s\n%.8s", gEeprom.DTMF_DOWN_CODE, gEeprom.DTMF_DOWN_CODE + 8);
+            } else {
+                sprintf(String, "%.8s", gEeprom.DTMF_DOWN_CODE);
+            }
             break;
 
 #ifdef ENABLE_DTMF_CALLING
@@ -1049,18 +1171,98 @@ void UI_DisplayMenu(void)
             strcpy(String, gSubMenu_ROGER[gSubMenuSelection]);
             break;
 
-        case MENU_VOL:
+        case MENU_VOL: {
+            // SysInf is paginated. Pages appear in this order, only when their
+            // feature flag is enabled:
+            //   0          -> identity
+            //   next       -> Build date/time         (ENABLE_FEAT_F4HWN)
+            //   next       -> Battery                 (ENABLE_FEAT_F4HWN)
+            //   next       -> Flash / SRAM usage      (ENABLE_FEAT_F4HWN_MEM)
+            //   next, +1   -> CODE / WIKI QR codes    (ENABLE_FEAT_F4HWN_QRCODE)
+            // In non-F4HWN builds, page 0 keeps the old battery-voltage display.
+            const uint8_t page = (uint8_t)gSubMenuSelection;
+            uint8_t       p    = 0;
+
+            if (page == p++) {
+                // Page 0: firmware identity.
 #ifdef ENABLE_FEAT_F4HWN
-            sprintf(String, "%s\n%s",
-                AUTHOR_STRING_2,
-                VERSION_STRING_2
-            );
+                sprintf(String, "%s\n%s", AUTHOR_STRING_2, VERSION_STRING_2);
+                UI_PrintStringSmallNormal(Edition, menu_item_x1 - 1, menu_item_x2, 6);
 #else
-            sprintf(String, "%u.%02uV\n%u%%",
-                gBatteryVoltageAverage / 100, gBatteryVoltageAverage % 100,
-                BATTERY_VoltsToPercent(gBatteryVoltageAverage));
+                sprintf(String, "%u.%02uV\n%u%%",
+                    gBatteryVoltageAverage / 100, gBatteryVoltageAverage % 100,
+                    BATTERY_VoltsToPercent(gBatteryVoltageAverage));
+#endif
+                break;
+            }
+#ifdef ENABLE_FEAT_F4HWN
+            if (page == p++) {
+                strcpy(top_right_badge, "BUILD");
+                UI_PrintStringSmallNormal(BuildDate, menu_item_x1 - 1, menu_item_x2, 3);
+                UI_PrintStringSmallNormal(BuildTime, menu_item_x1 - 1, menu_item_x2, 4);
+                UI_PrintStringSmallNormal(BuildCommit, menu_item_x1 - 1, menu_item_x2, 6);
+
+                already_printed = true;
+                break;
+            }
+
+            if (page == p++) {
+                char val[16];
+
+                strcpy(top_right_badge, "BATTERY");
+
+                sprintf(val, "%u.%02uV %u%%",
+                    gBatteryVoltageAverage / 100, gBatteryVoltageAverage % 100,
+                    BATTERY_VoltsToPercent(gBatteryVoltageAverage));
+                UI_PrintStringSmallNormal(val, menu_item_x1 - 1, menu_item_x2, 3);
+
+                UI_PrintStringSmallNormal(gSubMenu_BATTYP[gEeprom.BATTERY_TYPE], menu_item_x1 - 1, menu_item_x2, 5);
+
+                already_printed = true;
+                break;
+            }
+#endif
+#ifdef ENABLE_FEAT_F4HWN_MEM
+            if (page == p++) {
+                uint16_t flash_pct = 0;
+                uint16_t ram_pct   = 0;
+                UI_GetMemPercents(&flash_pct, &ram_pct);
+
+                char val[16];
+
+                // MEMORY title capsule centered in right zone, fb line 1.
+                strcpy(top_right_badge, "MEMORY");
+
+                // Flash + SRAM values stacked below, normal small font, with a fb-line of breathing space.
+                sprintf(val, "FLASH %u.%u%%",
+                        (unsigned)(flash_pct / 100), (unsigned)((flash_pct / 10) % 10));
+                UI_PrintStringSmallNormal(val, menu_item_x1 - 1, menu_item_x2, 3);
+
+                sprintf(val, "SRAM  %u.%u%%",
+                        (unsigned)(ram_pct / 100), (unsigned)((ram_pct / 10) % 10));
+                UI_PrintStringSmallNormal(val, menu_item_x1 - 1, menu_item_x2, 5);
+
+                already_printed = true;
+                break;
+            }
+#endif
+#ifdef ENABLE_FEAT_F4HWN_QRCODE
+            // Right zone: x=49..127 (79 px). QR centered at x=72..104.
+            // Capsule label above QR (small-font Inverse style at fb line 1).
+            if (page == p || page == p + 1) {
+                const bool is_wiki = (page == (p + 1));
+
+                strcpy(top_right_badge, is_wiki ? "WIKI" : "CODE");
+                UI_DrawQRCode(is_wiki, 72, 28);
+                
+                already_printed = true;
+                break;
+            }
+
+            p += 2; 
 #endif
             break;
+        }
 
         case MENU_RESET:
             strcpy(String, gSubMenu_RESET[gSubMenuSelection]);
@@ -1187,19 +1389,25 @@ void UI_DisplayMenu(void)
             strcpy(String, gSubMenu_SET_MET[gSubMenuSelection]); // Same as SET_MET
             break;
 
+        #ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+            case MENU_SET_SCN:
+                strcpy(String, gSubMenu_SET_SCN[gSubMenuSelection]);
+                break;
+        #endif
+
         #ifdef ENABLE_FEAT_F4HWN_AUDIO
             case MENU_SET_AUD:
                 if(gTxVfo->Modulation == MODULATION_AM) {
                     strcpy(String, gSubMenu_SET_AUD_AM[gSubMenuSelection]);
-                    UI_PrintStringSmallNormal("AM", 114, 0, 0);
+                    strcpy(top_right_badge, "AM");
                 }
                 else if (gTxVfo->Modulation == MODULATION_USB) {
                     strcpy(String, "USB");
-                    UI_PrintStringSmallNormal("USB", 108, 0, 0);
+                    strcpy(top_right_badge, "USB");
                 }
                 else {
                     strcpy(String, gSubMenu_SET_AUD_FM[gSubMenuSelection]);
-                    UI_PrintStringSmallNormal("FM", 114, 0, 0);
+                    strcpy(top_right_badge, "FM");
                 }
                 break;
         #endif
@@ -1227,11 +1435,7 @@ void UI_DisplayMenu(void)
                     //#endif
                 }
                 // gEeprom.VOLUME_GAIN = gSubMenuSelection;
-                BK4819_WriteRegister(BK4819_REG_48,
-                    (11u << 12)                |     // ??? .. 0 ~ 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)
+                BK4819_SetRxAudioGain();
                 break;
         #endif
 
@@ -1259,7 +1463,7 @@ void UI_DisplayMenu(void)
         unsigned int len   = strlen(String);
         bool         small = false;
 
-        if (len > 0)
+        if (String[0] != '\0')
         {
             // count number of lines
             for (i = 0; i < len; i++)
@@ -1288,23 +1492,6 @@ void UI_DisplayMenu(void)
 
             y = (small ? 3 : 2) - (lines / 2); 
 
-            // only for SysInf
-            if(UI_MENU_GetCurrentMenuId() == MENU_VOL)
-            {
-                sprintf(edit, "%u.%02uV %u%%",
-                    gBatteryVoltageAverage / 100, gBatteryVoltageAverage % 100,
-                    BATTERY_VoltsToPercent(gBatteryVoltageAverage)
-                );
-
-                UI_PrintStringSmallNormal(edit, 54, 127, 1);
-
-                #ifdef ENABLE_FEAT_F4HWN
-                    UI_PrintStringSmallNormal(Edition, 54, 127, 6);
-                #endif
-
-                y = 2;
-            }
-
             // draw the text lines
             for (i = 0; i < len && lines > 0; lines--)
             {
@@ -1326,16 +1513,16 @@ void UI_DisplayMenu(void)
         }
     }
 
-    if (UI_MENU_GetCurrentMenuId() == MENU_S_PRI_CH_1 || UI_MENU_GetCurrentMenuId() == MENU_S_PRI_CH_2)
+    if (m == MENU_S_PRI_CH_1 || m == MENU_S_PRI_CH_2)
     {
 
     }
 
-    if ((UI_MENU_GetCurrentMenuId() == MENU_R_CTCS || UI_MENU_GetCurrentMenuId() == MENU_R_DCS) && gCssBackgroundScan)
+    if ((m == MENU_R_CTCS || m == MENU_R_DCS) && gCssBackgroundScan)
         UI_PrintString("SCAN", menu_item_x1, menu_item_x2, 4, 8);
 
 #ifdef ENABLE_DTMF_CALLING
-    if (UI_MENU_GetCurrentMenuId() == MENU_D_LIST && gIsDtmfContactValid) {
+    if (m == MENU_D_LIST && gIsDtmfContactValid) {
         Contact[11] = 0;
         memcpy(&gDTMF_ID, Contact + 8, 4);
         sprintf(String, "ID:%4s", gDTMF_ID);
@@ -1343,22 +1530,41 @@ void UI_DisplayMenu(void)
     }
 #endif
 
-    if (UI_MENU_GetCurrentMenuId() == MENU_R_CTCS ||
-        UI_MENU_GetCurrentMenuId() == MENU_T_CTCS ||
-        UI_MENU_GetCurrentMenuId() == MENU_R_DCS  ||
-        UI_MENU_GetCurrentMenuId() == MENU_T_DCS
-#ifdef ENABLE_DTMF_CALLING
-        || UI_MENU_GetCurrentMenuId() == MENU_D_LIST
-#endif
-    ) {
-        sprintf(String, "%03d", gSubMenuSelection);
-        UI_PrintStringSmallNormal(String, 107, 0, 0);
+    const bool is_ctcs = (m == MENU_R_CTCS || m == MENU_T_CTCS);
+    const bool is_dcs  = (m == MENU_R_DCS  || m == MENU_T_DCS);
+
+    if (is_ctcs || is_dcs) {
+        if (gSubMenuSelection == 0) {
+            strcpy(top_right_badge, is_ctcs ? "00/00" : "000/00");
+        } else {
+            const uint8_t approved_index = is_ctcs ? 
+                DCS_GetCtcssApprovedIndex(gSubMenuSelection - 1) : 
+                DCS_GetDcsApprovedIndex(gSubMenuSelection - 1);
+                
+            const uint8_t width = is_ctcs ? 2 : 3;
+
+            if (approved_index != 0xFF) {
+                sprintf(top_right_badge, "%0*u/%02u", width, (unsigned)gSubMenuSelection, (unsigned)approved_index + 1);
+            } else {
+                sprintf(top_right_badge, "%0*u/--", width, (unsigned)gSubMenuSelection);
+            }
+        }
     }
 
-    if ((UI_MENU_GetCurrentMenuId() == MENU_RESET    ||
-         UI_MENU_GetCurrentMenuId() == MENU_MEM_CH   ||
-         UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME ||
-         UI_MENU_GetCurrentMenuId() == MENU_DEL_CH) && gAskForConfirmation)
+#ifdef ENABLE_DTMF_CALLING
+    if (m == MENU_D_LIST) {
+        sprintf(top_right_badge, "%03d", gSubMenuSelection);
+    }
+#endif
+
+    if (top_right_badge[0] != '\0') {
+        UI_MENU_DrawTopRightRoundedBadge(top_right_badge, 1, true, menu_item_x1, menu_item_x2);
+    }
+
+    if ((m == MENU_RESET    ||
+         m == MENU_MEM_CH   ||
+         m == MENU_MEM_NAME ||
+         m == MENU_DEL_CH) && gAskForConfirmation)
     {   // display confirmation
         char *pPrintStr = (gAskForConfirmation == 1) ? "SURE?" : "WAIT!";
         UI_PrintString(pPrintStr, menu_item_x1, menu_item_x2, 5, 8);

App/ui/menu.h

@@ -23,7 +23,7 @@
 #include "audio.h"     // VOICE_ID_t
 #include "settings.h"
 
-typedef struct {
+typedef struct __attribute__((packed)) {
     const char  name[7];    // menu display area only has room for 6 characters
     uint8_t     menu_id;
 } t_menu_item;
@@ -137,6 +137,9 @@ enum
     MENU_SET_MET,
     MENU_SET_GUI,
     MENU_SET_TMR,
+    #ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+        MENU_SET_SCN,
+    #endif
     #ifdef ENABLE_FEAT_F4HWN_NARROWER
         MENU_SET_NFM,
     #endif
@@ -160,69 +163,88 @@ enum
     MENU_F2SHRT,
     MENU_F2LONG,
     MENU_MLONG,
-    MENU_BATTYP
+    MENU_BATTYP,
+#if defined(ENABLE_FEAT_F4HWN) && defined(ENABLE_FEAT_F4HWN_LOGO_SAV)
+    MENU_SET_SAV
+#endif
 };
 
 extern const uint8_t FIRST_HIDDEN_MENU_ITEM;
 extern const t_menu_item MenuList[];
 
-extern const char        gSubMenu_TXP[8][6];
-extern const char        gSubMenu_SFT_D[3][4];
-extern const char        gSubMenu_W_N[2][7];
-extern const char        gSubMenu_OFF_ON[2][4];
-extern const char        gSubMenu_NA[4];
-extern const char        gSubMenu_TOT[11][7];
-extern const char* const gSubMenu_RXMode[4];
+extern const char* const            gSubMenu_TXP[8];
+extern const char* const            gSubMenu_SFT_D[3];
+extern const char* const            gSubMenu_W_N[2];
+extern const char* const            gSubMenu_OFF_ON[2];
+extern const char*                  gSubMenu_NA;
+extern const char* const            gSubMenu_TOT[11];
+extern const char* const            gSubMenu_RXMode[4];
 
 #ifdef ENABLE_VOICE
-    extern const char    gSubMenu_VOICE[3][4];
+    extern const char* const        gSubMenu_VOICE[3];
 #endif
-extern const char* const gSubMenu_MDF[4];
+extern const char* const            gSubMenu_MDF[4];
 #ifdef ENABLE_ALARM
-    extern const char    gSubMenu_AL_MOD[2][5];
+    extern const char* const        gSubMenu_AL_MOD[2];
 #endif
 #ifdef ENABLE_DTMF_CALLING
-extern const char        gSubMenu_D_RSP[4][11];
+extern const char* const            gSubMenu_D_RSP[4];
 #endif
 
 #ifdef ENABLE_FEAT_F4HWN
-    extern const char    gSubMenu_SET_PWR[7][6];
-    extern const char    gSubMenu_SET_PTT[2][8];
-    extern const char    gSubMenu_SET_TOT[4][7];
-    extern const char    gSubMenu_SET_LCK[2][9];
-    extern const char    gSubMenu_SET_MET[2][8];
+    extern const char* const        gSubMenu_SET_PWR[7];
+    extern const char* const        gSubMenu_SET_PTT[2];
+    extern const char* const        gSubMenu_SET_TOT[4];
+    extern const char* const        gSubMenu_SET_LCK[2];
+    extern const char* const        gSubMenu_SET_MET[2];
+    #ifdef ENABLE_FEAT_F4HWN_SCAN_FASTER
+        extern const char* const    gSubMenu_SET_SCN[2];
+    #endif
     #ifdef ENABLE_FEAT_F4HWN_NARROWER
-        extern const char    gSubMenu_SET_NFM[2][9];
+        extern const char* const    gSubMenu_SET_NFM[2];
     #endif
     #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-        extern const char gSubMenu_SET_KEY[][9];
+        extern const char* const    gSubMenu_SET_KEY[5];
     #endif
     #ifdef ENABLE_FEAT_F4HWN_AUDIO
-        extern const char    gSubMenu_SET_AUD_FM[5][6];
-        extern const char    gSubMenu_SET_AUD_AM[3][6];
+        extern const char* const    gSubMenu_SET_AUD_FM[5];
+        extern const char* const    gSubMenu_SET_AUD_AM[3];
+    #endif
+    #ifdef ENABLE_FEAT_F4HWN_LOGO_SAV
+        extern const char* const    gSubMenu_SET_SAV[];
     #endif
 #endif
 
 extern const char* const gSubMenu_PTT_ID[5];
 #ifdef ENABLE_FEAT_F4HWN
-    extern const char        gSubMenu_PONMSG[5][8];
+    #ifdef ENABLE_FEAT_F4HWN_LOGO
+        extern const char* const    gSubMenu_PONMSG[6];
+    #else
+        extern const char* const    gSubMenu_PONMSG[5];
+    #endif
 #else
-    extern const char        gSubMenu_PONMSG[4][8];
+    extern const char* const        gSubMenu_PONMSG[4];
 #endif
-extern const char        gSubMenu_ROGER[3][6];
-extern const char        gSubMenu_RESET[2][4];
-extern const char* const gSubMenu_F_LOCK[F_LOCK_LEN];
-extern const char        gSubMenu_RX_TX[4][6];
-extern const char        gSubMenu_BAT_TXT[3][8];
-extern const char        gSubMenu_BATTYP[5][12];
+
+extern const char* const            gSubMenu_ROGER[3];
+extern const char* const            gSubMenu_RESET[2];
+extern const char* const            gSubMenu_F_LOCK[F_LOCK_LEN];
+extern const char* const            gSubMenu_RX_TX[4];
+extern const char* const            gSubMenu_BAT_TXT[3];
+extern const char* const            gSubMenu_BATTYP[5];
+extern const char* const            gSubMenu_SET_NAV[2];
 
 #ifndef ENABLE_FEAT_F4HWN
-    extern const char        gSubMenu_SCRAMBLER[11][7];
+    extern const char* const        gSubMenu_SCRAMBLER[11];
 #endif
 
-typedef struct {char* name; uint8_t id;} t_sidefunction;
+typedef struct /* __attribute__((packed)) */ {
+    const char* name; 
+    uint8_t     id;
+} t_sidefunction;
+
 extern const uint8_t         gSubMenu_SIDEFUNCTIONS_size;
-extern const t_sidefunction gSubMenu_SIDEFUNCTIONS[];
+extern const t_sidefunction  gSubMenu_SIDEFUNCTIONS[];
                          
 extern bool              gIsInSubMenu;
                          
@@ -233,6 +255,7 @@ extern int32_t           gSubMenuSelection;
 extern char              edit_original[17];
 extern char              edit[17];
 extern int               edit_index;
+extern bool              edit_is_uppercase;
 
 void UI_DisplayMenu(void);
 int UI_MENU_GetCurrentMenuId();

App/ui/scanner.c

@@ -26,58 +26,56 @@
 
 void UI_DisplayScanner(void)
 {
-    char  String[16] = {0};
+    char String[16];
     char *pPrintStr = String;
-    bool bCentered;
-    uint8_t Start;
 
     UI_DisplayClear();
 
-    if (gScanSingleFrequency || (gScanCssState != SCAN_CSS_STATE_OFF && gScanCssState != SCAN_CSS_STATE_FAILED)) {
-        sprintf(String, "FREQ:%u.%05u", gScanFrequency / 100000, gScanFrequency % 100000);
+    // 1st line
+    if (gScannerSaveState == SCAN_SAVE_CHANNEL) {
+        pPrintStr = "Save?";
+    } else if (gScannerSaveState == SCAN_SAVE_CHAN_SEL) {
+        strcpy(String, "Save:");
+        UI_GenerateChannelStringEx(String + 5, gShowChPrefix, gScanChannel);
         pPrintStr = String;
+    } else if ((gScanCssState < SCAN_CSS_STATE_FOUND) && ((gScanProgressIndicator & 1u) != 0)) {
+        pPrintStr = "";
+    } else if (gScanCssState == SCAN_CSS_STATE_OFF) {
+        pPrintStr = "Search Freq";
+    } else if (gScanCssState == SCAN_CSS_STATE_SCANNING) {
+        pPrintStr = "Search Tone";
+    } else if (gScanCssState == SCAN_CSS_STATE_FOUND) {
+        pPrintStr = "Scan Complete";
     } else {
-        pPrintStr = "FREQ:**.*****";
+        pPrintStr = "Scan Failed";
     }
 
     UI_PrintString(pPrintStr, 2, 0, 1, 8);
 
-    if (gScanCssState < SCAN_CSS_STATE_FOUND || !gScanUseCssResult) {
-        pPrintStr = "CTC:******";
+    // 2nd line
+    if (gScanSingleFrequency || (gScanCssState != SCAN_CSS_STATE_OFF && gScanCssState != SCAN_CSS_STATE_FAILED)) {
+        sprintf(String, "Freq:%u.%05u", gScanFrequency / 100000, gScanFrequency % 100000);
+        pPrintStr = String;
+    } else {
+        pPrintStr = "Freq:---.-----";
+    }
+
+    UI_PrintString(pPrintStr, 2, 0, 3, 8);
+
+    // 3rd line
+    if (gScanCssState < SCAN_CSS_STATE_FOUND) {
+        pPrintStr = "Tone:---";
+    } else if (!gScanUseCssResult) {
+        pPrintStr = "Tone:None";
     } else if (gScanCssResultType == CODE_TYPE_CONTINUOUS_TONE) {
-        sprintf(String, "CTC:%u.%uHz", CTCSS_Options[gScanCssResultCode] / 10, CTCSS_Options[gScanCssResultCode] % 10);
+        sprintf(String, "CTCSS:%u.%uHz", CTCSS_Options[gScanCssResultCode] / 10, CTCSS_Options[gScanCssResultCode] % 10);
         pPrintStr = String;
     } else {
         sprintf(String, "DCS:D%03oN", DCS_Options[gScanCssResultCode]);
         pPrintStr = String;
     }
-
-    UI_PrintString(pPrintStr, 2, 0, 3, 8);
-    memset(String, 0, sizeof(String));
-    if (gScannerSaveState == SCAN_SAVE_CHANNEL) {
-        pPrintStr = "SAVE?";
-        Start     = 0;
-        bCentered = 1;
-    } else {
-        Start     = 2;
-        bCentered = 0;
-
-        if (gScannerSaveState == SCAN_SAVE_CHAN_SEL) {
-            strcpy(String, "SAVE:");
-            UI_GenerateChannelStringEx(String + 5, gShowChPrefix, gScanChannel);
-            pPrintStr = String;
-        } else if (gScanCssState < SCAN_CSS_STATE_FOUND) {
-            strcpy(String, "SCAN");
-            memset(String + 4, '.', (gScanProgressIndicator & 7) + 1);
-            pPrintStr = String;
-        } else if (gScanCssState == SCAN_CSS_STATE_FOUND) {
-            pPrintStr = "SCAN CMP.";
-        } else {
-            pPrintStr = "SCAN FAIL.";
-        }
-    }
-
-    UI_PrintString(pPrintStr, Start, bCentered ? 127 : 0, 5, 8);
+ 
+    UI_PrintString(pPrintStr, 2, 0, 5, 8);
 
     ST7565_BlitFullScreen();
 }

App/ui/status.c

@@ -16,6 +16,7 @@
 
 #include <string.h>
 
+#include "app/app.h"
 #include "app/chFrScanner.h"
 #ifdef ENABLE_FMRADIO
     #include "app/fm.h"
@@ -43,26 +44,35 @@ static void convertTime(uint8_t *line, uint8_t type)
     uint8_t m = t / 60;
     uint8_t s = t - (m * 60); // Replace modulo with subtraction for efficiency
 
-    gStatusLine[0] = gStatusLine[7] = gStatusLine[14] = 0x00; // Quick fix on display (on scanning I, II, etc.)
-
     char str[6];
     sprintf(str, "%02u:%02u", m, s);
     UI_PrintStringSmallBufferNormal(str, line);
-
-    gUpdateStatus = true;
 }
 #endif
 #endif
 
 void UI_DisplayStatus()
 {
-    char str[8] = "";
-
     gUpdateStatus = false;
-    memset(gStatusLine, 0, sizeof(gStatusLine));
+
+    if (APP_IsScreenSaverDisplayed())
+        return;
+
+    UI_StatusClear();
 
     uint8_t     *line = gStatusLine;
     unsigned int x    = 0;
+    unsigned int x1   = 0;
+
+    char str[8] = "";
+
+#if defined(ENABLE_FEAT_F4HWN_RX_TX_TIMER) && !defined(ENABLE_FEAT_F4HWN_DEBUG)
+    bool isTransmit = gCurrentFunction == FUNCTION_TRANSMIT;
+    if (gSetting_set_tmr && (isTransmit || FUNCTION_IsRx())) {
+        convertTime(line, !isTransmit);
+        x += 39;
+    } else {
+#endif
 
 #ifdef ENABLE_NOAA
     // NOAA indicator
@@ -82,7 +92,7 @@ void UI_DisplayStatus()
     x += 8;
 #endif
 
-    unsigned int x1 = x;
+    x1 = x;
 
 #ifdef ENABLE_DTMF_CALLING
     if (gSetting_KILLED) {
@@ -94,13 +104,12 @@ void UI_DisplayStatus()
     { // SCAN indicator
         if (gScanStateDir != SCAN_OFF || SCANNER_IsScanning()) {
             if (IS_MR_CHANNEL(gNextMrChannel) && !SCANNER_IsScanning()) { // channel mode
-
                 uint8_t end = 0;
 
                 if(gEeprom.SCAN_LIST_DEFAULT == MR_CHANNELS_LIST + 1)
                 {
-                    sprintf(str, gEeprom.SCAN_LIST_ENABLED ? "%s+" : "%s", "ALL");
-                    end = gEeprom.SCAN_LIST_ENABLED ? 18 : 14;
+                    strcpy(str, "ALL");
+                    end = 14;
                 }
                 else
                 {
@@ -108,15 +117,22 @@ void UI_DisplayStatus()
 
                     // Check if name is valid
                     if (!IsEmptyName(name, sizeof(gListName[0]))) {
-                        sprintf(str, "%.3s%s", name, gEeprom.SCAN_LIST_ENABLED ? "+" : "");
-                        end = gEeprom.SCAN_LIST_ENABLED ? 18 : 14;
-                    } 
-                    else {
-                        sprintf(str, "%02d%s", gEeprom.SCAN_LIST_DEFAULT, gEeprom.SCAN_LIST_ENABLED ? "+" : "");
-                        end = gEeprom.SCAN_LIST_ENABLED ? 14 : 10;
+                        sprintf(str, "%.3s", name);
+                        end = 14;
+                    } else {
+                        sprintf(str, "%02d", gEeprom.SCAN_LIST_DEFAULT);
+                        end = 10;
                     }
                 }
 
+                if (gEeprom.SCAN_LIST_ENABLED) {
+                    strcat(str, "+");
+                    end += 4;
+                }
+
+#ifdef ENABLE_FEAT_F4HWN
+                GUI_DisplaySmallestInverse(str, 2, 0, true, true, end);
+#else
                 GUI_DisplaySmallest(str, 2, 1, true, true);
 
                 gStatusLine[0] ^= 0x3E;
@@ -125,6 +141,7 @@ void UI_DisplayStatus()
                     gStatusLine[x] ^= 0x7F;
                 }
                 gStatusLine[end] ^= 0x3E;
+#endif
             }
             else {  // frequency mode
                 memcpy(line + x + 1, gFontS, sizeof(gFontS));
@@ -154,49 +171,49 @@ void UI_DisplayStatus()
         #endif
 
         if(!SCANNER_IsScanning()) {
-        #ifdef ENABLE_FEAT_F4HWN_RX_TX_TIMER
-            if(gCurrentFunction == FUNCTION_TRANSMIT && gSetting_set_tmr == true)
-            {
-                convertTime(line, 0);
-            }
-            else if(FUNCTION_IsRx() && gSetting_set_tmr == true)
-            {
-                convertTime(line, 1);
-            }
-            else
-        #endif
-            {
-                if(!gAirCopyBootMode) {
-                    #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-                    if(gEeprom.MENU_LOCK == true) {
-                        memcpy(line + x + 2, gFontRO, sizeof(gFontRO));
+            if(!gAirCopyBootMode) {
+                const void *src = NULL;    // Pointer to the font/bitmap to copy
+                size_t sSize = 0;          // Size of the font/bitmap
+                uint8_t sOff = 2;          // Offset relative to the reference position
+
+                #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
+                    if (gEeprom.MENU_LOCK) {
+                        src = gFontRO;
+                        sSize = sizeof(gFontRO);
+                    } else 
+                #endif
+                {
+                    uint8_t xb = (gEeprom.CROSS_BAND_RX_TX != CROSS_BAND_OFF);
+
+                    if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF) {
+                        if (gDualWatchActive) { // DWR - dual watch + respond
+                            src = gFontDWR;
+                            sOff = xb ? 2 : 0;
+                            sSize = sizeof(gFontDWR) - (xb ? 5 : 0);
+                        } else {
+                            src = gFontHold;
+                            sOff = 3;
+                            sSize = sizeof(gFontHold);
+                        }
+                    } else {
+                        src   = xb ? gFontXB         : gFontMO;          // XB - crossband
+                        sSize = xb ? sizeof(gFontXB) : sizeof(gFontMO);  // MO - main only
                     }
-                    else
-                    {
-                    #endif
-                        uint8_t dw = (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF) + (gEeprom.CROSS_BAND_RX_TX != CROSS_BAND_OFF) * 2;
-                        if(dw == 1 || dw == 3) { // DWR - dual watch + respond
-                            if(gDualWatchActive)
-                                memcpy(line + x + (dw==1?0:2), gFontDWR, sizeof(gFontDWR) - (dw==1?0:5));
-                            else
-                                memcpy(line + x + 3, gFontHold, sizeof(gFontHold));
-                        }
-                        else if(dw == 2) { // XB - crossband
-                            memcpy(line + x + 2, gFontXB, sizeof(gFontXB));
-                        }
-                        else
-                        {
-                            memcpy(line + x + 2, gFontMO, sizeof(gFontMO));
-                        }
-                    #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-                    }
-                    #endif
+                }
+
+                // Perform the memcpy if a source was selected
+                if (src) {
+                    memcpy(line + x + sOff, src, sSize);
                 }
             }
         }
         x += sizeof(gFontDWR) + 3;
     #endif
 
+#if defined(ENABLE_FEAT_F4HWN_RX_TX_TIMER) && !defined(ENABLE_FEAT_F4HWN_DEBUG)
+    }
+#endif
+
 #ifdef ENABLE_VOX
     // VOX indicator
     if (gEeprom.VOX_SWITCH) {
@@ -243,7 +260,10 @@ void UI_DisplayStatus()
         }
     #endif
     else if (gBackLight) {
-        src = gFontLight;
+        // Distinguish the manual backlight sub-state: BACKLIGHT_TIME == 0
+        // means the light is currently off (hollow bulb), otherwise it is
+        // forced on (bulb with filament). Both glyphs share the same size.
+        src = (gEeprom.BACKLIGHT_TIME == 0) ? gFontLightOff : gFontLight;
         size = sizeof(gFontLight);
     }
     #ifdef ENABLE_FEAT_F4HWN_CHARGING_C
@@ -272,7 +292,7 @@ void UI_DisplayStatus()
             break;
 
         case 1:    // voltage
-            const uint16_t voltage = (gBatteryVoltageAverage <= 999) ? gBatteryVoltageAverage : 999; // limit to 9.99V
+            const uint16_t voltage = MIN(gBatteryVoltageAverage, 999); // limit to 9.99V
             sprintf(str, "%u.%02u", voltage / 100, voltage % 100);
             break;
 

App/ui/welcome.c

@@ -33,6 +33,80 @@
     #include "screenshot.h"
 #endif
 
+#ifdef ENABLE_FEAT_F4HWN_LOGO
+// Boot logo storage in PY25Q16 external flash, aligned on a 4 KB sector,
+// placed past the calibration zone (0x010000-0x010200).
+//
+// Layout inside the sector starting at LOGO_FLASH_ADDR:
+//   [0x00..0x07] : 8-byte header (reserved for future magic/version/flags)
+//   [0x08..0x407]: 128x64 monochrome bitmap (1024 B)
+//                  ST7565-native: 8 pages * 128 columns, column-major LSB-top
+#define LOGO_FLASH_ADDR     0x011000
+#define LOGO_HEADER_SIZE    8
+#define LOGO_BITMAP_ADDR    (LOGO_FLASH_ADDR + LOGO_HEADER_SIZE)
+
+static void UI_LoadLogo(void)
+{
+    // Skip 8-byte header, then read 128x64 bitmap (1024 B):
+    // page 0 -> gStatusLine, pages 1..7 -> gFrameBuffer.
+    PY25Q16_ReadBuffer(LOGO_BITMAP_ADDR, gStatusLine, sizeof(gStatusLine));
+    PY25Q16_ReadBuffer(LOGO_BITMAP_ADDR + sizeof(gStatusLine), gFrameBuffer, sizeof(gFrameBuffer));
+}
+
+void UI_DisplayLogo(void)
+{
+    UI_LoadLogo();
+    ST7565_BlitStatusLine();
+    ST7565_BlitFullScreen();
+}
+#endif
+
+#ifdef ENABLE_FEAT_F4HWN_QRCODE
+// QR code (version 4, 33x33 modules, EC level L) encoding:
+// https://github.com/armel/uv-k1-k5v3-firmware-custom
+// Stored in framebuffer column-major format: 5 fb-lines x 33 columns.
+// Each byte packs 8 vertical pixels (bit 0 = top). Last fb-line uses
+// only bit 0 (row 32); bits 1..7 are always 0.
+//
+// static const uint8_t BITMAP_QR_GitHub[5][33] = {
+//     { 0x7F, 0x41, 0x5D, 0x5D, 0x5D, 0x41, 0x7F, 0x00, 0x6A, 0xB8, 0xCB, 0xA0, 0x6D, 0x07, 0xCB, 0x1F, 0xD2, 0x18, 0x59, 0x15, 0x79, 0x86, 0xCE, 0x15, 0x43, 0x00, 0x7F, 0x41, 0x5D, 0x5D, 0x5D, 0x41, 0x7F },
+//     { 0x87, 0xA3, 0x69, 0xC3, 0x19, 0x0E, 0x55, 0x1F, 0x43, 0x11, 0x16, 0xC1, 0x5A, 0x0E, 0x96, 0x3E, 0xA5, 0x15, 0x06, 0x2A, 0xFE, 0xCE, 0xCA, 0x3A, 0x70, 0xD9, 0xEA, 0xF5, 0x5C, 0x15, 0x8A, 0x67, 0x22 },
+//     { 0xE0, 0x0B, 0x1D, 0x28, 0xF5, 0x87, 0x55, 0xEB, 0xA8, 0x11, 0xA3, 0xC1, 0x5A, 0x0E, 0x96, 0x3E, 0xA5, 0x15, 0x84, 0x2B, 0x72, 0xE8, 0xE9, 0x23, 0x11, 0xCD, 0xE6, 0xC1, 0x91, 0xE6, 0x88, 0x77, 0x22 },
+//     { 0xFD, 0x04, 0x75, 0x75, 0x75, 0x04, 0xFD, 0x01, 0xF7, 0xE0, 0xD6, 0xC1, 0x5A, 0x0E, 0x96, 0x3E, 0xA5, 0x37, 0x22, 0x2B, 0xEA, 0xAA, 0xA7, 0x8D, 0x5F, 0x31, 0x55, 0xB1, 0x3F, 0xCE, 0xCA, 0x2C, 0x2B },
+//     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00 }
+// };
+
+static const uint8_t BITMAP_QR_GitHub_Compressed[137] = {
+    0x7F, 0x41, 0x5D, 0x5D, 0x5D, 0x41, 0x7F, 0x00, 0x6A, 0xB8, 0xCB, 0xA0, 0x6D, 0x07, 0xCB, 0x1F, 0xD2, 0x18, 0x59, 0x15, 0x79, 0x86, 0xCE, 0x15, 0x43, 0x00, 0x7F, 0x41, 0x5D, 0x5D, 0x5D, 0x41, 0x7F,
+    0x87, 0xA3, 0x69, 0xC3, 0x19, 0x0E, 0x55, 0x1F, 0x43, 0x11, 0x16, 0xC1, 0x5A, 0x0E, 0x96, 0x3E, 0xA5, 0x15, 0x06, 0x2A, 0xFE, 0xCE, 0xCA, 0x3A, 0x70, 0xD9, 0xEA, 0xF5, 0x5C, 0x15, 0x8A, 0x67, 0x22,
+    0xE0, 0x0B, 0x1D, 0x28, 0xF5, 0x87, 0x55, 0xEB, 0xA8, 0x11, 0xA3, 0xC1, 0x5A, 0x0E, 0x96, 0x3E, 0xA5, 0x15, 0x84, 0x2B, 0x72, 0xE8, 0xE9, 0x23, 0x11, 0xCD, 0xE6, 0xC1, 0x91, 0xE6, 0x88, 0x77, 0x22,
+    0xFD, 0x04, 0x75, 0x75, 0x75, 0x04, 0xFD, 0x01, 0xF7, 0xE0, 0xD6, 0xC1, 0x5A, 0x0E, 0x96, 0x3E, 0xA5, 0x37, 0x22, 0x2B, 0xEA, 0xAA, 0xA7, 0x8D, 0x5F, 0x31, 0x55, 0xB1, 0x3F, 0xCE, 0xCA, 0x2C, 0x2B,
+    0x7F, 0x09, 0x8C, 0xA3, 0x00
+};
+
+
+// QR code (version 4, 33x33 modules, EC level L) encoding:
+// https://github.com/armel/uv-k1-k5v3-firmware-custom/wiki
+// Stored in framebuffer column-major format: 5 fb-lines x 33 columns.
+// Last fb-line uses only bit 0 (row 32); bits 1..7 are always 0.
+//
+// static const uint8_t BITMAP_QR_GitHub_Wiki[5][33] = {
+//     { 0x7F, 0x41, 0x5D, 0x5D, 0x5D, 0x41, 0x7F, 0x00, 0x6A, 0x0F, 0x74, 0x0E, 0xD2, 0xB0, 0x74, 0xB1, 0x6D, 0x18, 0x59, 0x15, 0x79, 0x86, 0xCE, 0x15, 0x43, 0x00, 0x7F, 0x41, 0x5D, 0x5D, 0x5D, 0x41, 0x7F },
+//     { 0xCD, 0x5D, 0x83, 0x65, 0xE7, 0xC6, 0x55, 0xBD, 0x6B, 0x3F, 0xA9, 0x1C, 0xA5, 0xE0, 0x69, 0xE3, 0x4A, 0x15, 0x06, 0x2A, 0xFE, 0xCE, 0xCA, 0x3A, 0x70, 0xD9, 0xEA, 0xF5, 0x5C, 0x15, 0x8A, 0x67, 0x22 },
+//     { 0xFF, 0x25, 0xAE, 0xB6, 0x30, 0xF8, 0x55, 0xDD, 0x07, 0xB6, 0xC2, 0x1C, 0xA5, 0xE0, 0x69, 0xC4, 0x66, 0x15, 0x84, 0x2B, 0x72, 0xE8, 0xE9, 0x23, 0x11, 0xCD, 0xE6, 0xC1, 0x91, 0xE6, 0x88, 0x77, 0x22 },
+//     { 0xFD, 0x04, 0x74, 0x74, 0x74, 0x05, 0xFD, 0x01, 0xF7, 0xAE, 0x81, 0x1C, 0xA5, 0xE0, 0x69, 0x54, 0xFE, 0x37, 0x22, 0x2B, 0xEA, 0xAA, 0xA7, 0x8D, 0x5F, 0x31, 0x55, 0xB1, 0x3F, 0xCE, 0xCA, 0x24, 0x33 },
+//     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00 }
+// };
+
+static const uint8_t BITMAP_QR_GitHub_Wiki_Compressed[137] = {
+    0x7F, 0x41, 0x5D, 0x5D, 0x5D, 0x41, 0x7F, 0x00, 0x6A, 0x0F, 0x74, 0x0E, 0xD2, 0xB0, 0x74, 0xB1, 0x6D, 0x18, 0x59, 0x15, 0x79, 0x86, 0xCE, 0x15, 0x43, 0x00, 0x7F, 0x41, 0x5D, 0x5D, 0x5D, 0x41, 0x7F,
+    0xCD, 0x5D, 0x83, 0x65, 0xE7, 0xC6, 0x55, 0xBD, 0x6B, 0x3F, 0xA9, 0x1C, 0xA5, 0xE0, 0x69, 0xE3, 0x4A, 0x15, 0x06, 0x2A, 0xFE, 0xCE, 0xCA, 0x3A, 0x70, 0xD9, 0xEA, 0xF5, 0x5C, 0x15, 0x8A, 0x67, 0x22,
+    0xFF, 0x25, 0xAE, 0xB6, 0x30, 0xF8, 0x55, 0xDD, 0x07, 0xB6, 0xC2, 0x1C, 0xA5, 0xE0, 0x69, 0xC4, 0x66, 0x15, 0x84, 0x2B, 0x72, 0xE8, 0xE9, 0x23, 0x11, 0xCD, 0xE6, 0xC1, 0x91, 0xE6, 0x88, 0x77, 0x22,
+    0xFD, 0x04, 0x74, 0x74, 0x74, 0x05, 0xFD, 0x01, 0xF7, 0xAE, 0x81, 0x1C, 0xA5, 0xE0, 0x69, 0x54, 0xFE, 0x37, 0x22, 0x2B, 0xEA, 0xAA, 0xA7, 0x8D, 0x5F, 0x31, 0x55, 0xB1, 0x3F, 0xCE, 0xCA, 0x24, 0x33,
+    0x7F, 0x53, 0x8E, 0xA3, 0x00
+};
+#endif
+
 #ifdef ENABLE_FEAT_F4HWN_MEM
 // Linker symbols (provided by the linker script)
 extern uint8_t _sdata;          // Start of .data in RAM
@@ -88,11 +162,62 @@ static inline uint16_t pct_x100(uint32_t used, uint32_t total)
 {
     return (uint16_t)((used * 10000u) / total); // 7559 => 75.59%
 }
+
+void UI_GetMemPercents(uint16_t *flash_pct_x100, uint16_t *ram_pct_x100)
+{
+    uint32_t ram_used   = 0;
+    uint32_t flash_used = 0;
+    build_usage(&ram_used, &flash_used);
+    if (flash_pct_x100) *flash_pct_x100 = pct_x100(flash_used, FLASH_SIZE_BYTES);
+    if (ram_pct_x100)   *ram_pct_x100   = pct_x100(ram_used,   RAM_SIZE_BYTES);
+}
+#endif
+
+#ifdef ENABLE_FEAT_F4HWN_QRCODE
+// Set a single pixel at LCD-physical (x, y). y=0..7 maps to gStatusLine,
+// y=8..63 maps to gFrameBuffer (line = (y-8)/8, bit = (y-8)%8).
+static void QR_SetPixel(uint8_t x, uint8_t y)
+{
+    if (x >= 128 || y >= 64) return;
+    if (y < 8) {
+        gStatusLine[x] |= (uint8_t)(1u << y);
+    } else {
+        const uint8_t fb_y = (uint8_t)(y - 8u);
+        gFrameBuffer[fb_y >> 3][x] |= (uint8_t)(1u << (fb_y & 7u));
+    }
+}
+
+// Render a square QR bitmap stored in framebuffer column-major format
+// (size cols × ceil(size/8) fb-lines, row-major in memory).
+static void QR_Draw(const uint8_t *bitmap, uint8_t size, uint8_t origin_x, uint8_t origin_y)
+{
+    for (uint8_t qy = 0; qy < size; qy++) {
+        for (uint8_t qx = 0; qx < size; qx++) {
+            // const uint16_t idx = (uint16_t)(qy >> 3) * (uint16_t)size + (uint16_t)qx;
+            // if ((bitmap[idx] >> (qy & 7u)) & 1u) {
+            if (qy < 32 ?
+                ((bitmap[(uint16_t)(qy >> 3) * (uint16_t)size + (uint16_t)qx] >> (qy & 7u)) & 1u) : 
+                ((bitmap[132 + (qx >> 3)] >> (qx & 7u)) & 1u)) {
+                QR_SetPixel((uint8_t)(origin_x + qx),
+                            (uint8_t)(origin_y + qy));
+            }
+        }
+    }
+}
+
+void UI_DrawQRCode(bool wiki, uint8_t origin_x, uint8_t origin_y)
+{
+//  QR_Draw(wiki ? (const uint8_t *)BITMAP_QR_GitHub_Wiki
+//               : (const uint8_t *)BITMAP_QR_GitHub,
+    QR_Draw(wiki ? (const uint8_t *)BITMAP_QR_GitHub_Wiki_Compressed
+                 : (const uint8_t *)BITMAP_QR_GitHub_Compressed,
+            33, origin_x, origin_y);
+}
 #endif
 
 void UI_DisplayReleaseKeys(void)
 {
-    memset(gStatusLine,  0, sizeof(gStatusLine));
+    UI_StatusClear();
 #if defined(ENABLE_FEAT_F4HWN_CTR) || defined(ENABLE_FEAT_F4HWN_INV)
         ST7565_ContrastAndInv();
 #endif
@@ -107,12 +232,7 @@ void UI_DisplayReleaseKeys(void)
 
 void UI_DisplayWelcome(void)
 {
-    char WelcomeString0[16];
-    char WelcomeString1[16];
-    char WelcomeString2[16];
-    char WelcomeString3[32];
-
-    memset(gStatusLine,  0, sizeof(gStatusLine));
+    UI_StatusClear();
 
 #if defined(ENABLE_FEAT_F4HWN_CTR) || defined(ENABLE_FEAT_F4HWN_INV)
         ST7565_ContrastAndInv();
@@ -122,16 +242,27 @@ void UI_DisplayWelcome(void)
 #ifdef ENABLE_FEAT_F4HWN
     ST7565_BlitStatusLine();
     ST7565_BlitFullScreen();
-    
+
     if (gEeprom.POWER_ON_DISPLAY_MODE == POWER_ON_DISPLAY_MODE_NONE || gEeprom.POWER_ON_DISPLAY_MODE == POWER_ON_DISPLAY_MODE_SOUND) {
         ST7565_FillScreen(0x00);
+        return;
+    }
 #else
     if (gEeprom.POWER_ON_DISPLAY_MODE == POWER_ON_DISPLAY_MODE_NONE || gEeprom.POWER_ON_DISPLAY_MODE == POWER_ON_DISPLAY_MODE_FULL_SCREEN) {
         ST7565_FillScreen(0xFF);
+        return;
+    }
 #endif
-    } else {
-        memset(WelcomeString0, 0, sizeof(WelcomeString0));
-        memset(WelcomeString1, 0, sizeof(WelcomeString1));
+#ifdef ENABLE_FEAT_F4HWN_LOGO
+    else if (gEeprom.POWER_ON_DISPLAY_MODE == POWER_ON_DISPLAY_MODE_LOGO) {
+        UI_LoadLogo();
+    }
+#endif
+    else {
+        char WelcomeString0[16];
+        char WelcomeString1[16];
+        char WelcomeString2[16];
+        char WelcomeString3[32];
 
         // 0x0EB0
         PY25Q16_ReadBuffer(0x00A0C8, WelcomeString0, 16);
@@ -193,6 +324,7 @@ void UI_DisplayWelcome(void)
         gFrameBuffer[4][108] ^= 0x7F;
         UI_DrawLineBuffer(gFrameBuffer, 109, 35, 127, 35, 1);
 
+        /*
         #ifdef ENABLE_FEAT_F4HWN_MEM
             uint32_t ram_used   = 0;
             uint32_t flash_used = 0;
@@ -210,6 +342,7 @@ void UI_DisplayWelcome(void)
             GUI_DisplaySmallest(WelcomeString3, 5, 1, true, true);
             ST7565_BlitStatusLine();
         #endif
+        */
 
         sprintf(WelcomeString3, "%s Edition", Edition);
         UI_PrintStringSmallNormal(WelcomeString3, 0, 127, 6);
@@ -217,12 +350,12 @@ void UI_DisplayWelcome(void)
 #else
         UI_PrintStringSmallNormal(Version, 0, 127, 6);
 #endif
-
-        //ST7565_BlitStatusLine();  // blank status line : I think it's useless
-        ST7565_BlitFullScreen();
-
-        #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
-            SCREENSHOT_Update(true);
-        #endif
     }
-}
+
+    ST7565_BlitStatusLine();
+    ST7565_BlitFullScreen();
+
+    #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+        SCREENSHOT_Update(true);
+    #endif
+}

App/ui/welcome.h

@@ -17,8 +17,25 @@
 #ifndef UI_WELCOME_H
 #define UI_WELCOME_H
 
+#include <stdbool.h>
+#include <stdint.h>
+
 void UI_DisplayReleaseKeys(void);
 void UI_DisplayWelcome(void);
 
+#ifdef ENABLE_FEAT_F4HWN_LOGO
+void UI_DisplayLogo(void);
 #endif
 
+#ifdef ENABLE_FEAT_F4HWN_QRCODE
+// Draw the embedded GitHub QR code (V4, 33x33) at (origin_x, origin_y).
+// `wiki` selects the wiki URL bitmap, otherwise the repo URL bitmap.
+void UI_DrawQRCode(bool wiki, uint8_t origin_x, uint8_t origin_y);
+#endif
+
+#ifdef ENABLE_FEAT_F4HWN_MEM
+// Compute current FLASH and SRAM usage as percentages × 100 (e.g. 7559 = 75.59%).
+void UI_GetMemPercents(uint16_t *flash_pct_x100, uint16_t *ram_pct_x100);
+#endif
+
+#endif

App/version.c

@@ -8,6 +8,9 @@
 #ifdef ENABLE_FEAT_F4HWN
     const char Version[]      = AUTHOR_STRING_2 " " VERSION_STRING_2;
     const char Edition[]      = EDITION_STRING;
+    const char BuildDate[]    = __DATE__;
+    const char BuildTime[]    = __TIME__;
+    const char BuildCommit[]  = BUILD_COMMIT;
 #else
     const char Version[]      = AUTHOR_STRING VER;
 #endif

App/version.h

@@ -24,4 +24,7 @@ extern const char UART_Version[];
 
 #ifdef ENABLE_FEAT_F4HWN
 extern const char Edition[];
+extern const char BuildDate[];
+extern const char BuildTime[];
+extern const char BuildCommit[];
 #endif

CMakeLists.txt

@@ -19,6 +19,21 @@ message("Build type: " ${CMAKE_BUILD_TYPE})
 
 enable_language(C ASM)
 
+find_package(Git QUIET)
+set(BUILD_COMMIT "unknown")
+if(GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" rev-parse --short HEAD
+        WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+        OUTPUT_VARIABLE BUILD_COMMIT
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        ERROR_QUIET
+    )
+    if(NOT BUILD_COMMIT)
+        set(BUILD_COMMIT "unknown")
+    endif()
+endif()
+
 if(ENABLE_FEAT_F4HWN)
     if(NOT AUTHOR_STRING_1)
         set(AUTHOR_STRING_1 "EGZUMER")

CMakePresets.json

@@ -34,7 +34,7 @@
                 "ENABLE_BOOT_BEEPS": false,
                 "ENABLE_SHOW_CHARGE_LEVEL": false,
                 "ENABLE_REVERSE_BAT_SYMBOL": false,
-                "ENABLE_NO_CODE_SCAN_TIMEOUT": true,
+                "ENABLE_NO_CODE_SCAN_TIMEOUT": false,
                 "ENABLE_SQUELCH_MORE_SENSITIVE": true,
                 "ENABLE_FASTER_CHANNEL_SCAN": true,
                 "ENABLE_RSSI_BAR": true,
@@ -66,12 +66,20 @@
                 "ENABLE_FEAT_F4HWN_GMRS_FRS_MURS": false,
                 "ENABLE_FEAT_F4HWN_CA": true,
                 "ENABLE_FEAT_F4HWN_DEBUG": false,
+                "ENABLE_FEAT_F4HWN_QRCODE": false,
                 "ENABLE_FEAT_F4HWN_MEM": false,
+                "ENABLE_FEAT_F4HWN_SCAN_PROGRESS": false,
+                "ENABLE_FEAT_F4HWN_SCAN_FASTER": false,
+                "ENABLE_FEAT_F4HWN_SCAN_RSSI": false,
+                "ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE": false,
+                "ENABLE_FEAT_F4HWN_BEAM": false,
+                "ENABLE_FEAT_F4HWN_LOGO": false,
+                "ENABLE_FEAT_F4HWN_LOGO_SAV": false,
                 "ENABLE_AGC_SHOW_DATA": false,
                 "ENABLE_UART_RW_BK_REGS": false,
                 "ENABLE_SWD": false,
                 "VERSION_STRING_1": "v0.22",
-                "VERSION_STRING_2": "v5.3.1"
+                "VERSION_STRING_2": "v5.6.0"
             }
         },
         {
@@ -191,6 +199,15 @@
                 "ENABLE_FEAT_F4HWN_VOL": true,
                 "ENABLE_FEAT_F4HWN_AUDIO": true,
                 "ENABLE_FEAT_F4HWN_AUDIO_SCOPE": true,
+                "ENABLE_FEAT_F4HWN_SCAN_PROGRESS": true,
+                "ENABLE_FEAT_F4HWN_SCAN_FASTER": true,
+                "ENABLE_FEAT_F4HWN_SCAN_RSSI": true,
+                "ENABLE_FEAT_F4HWN_SCAN_SUBAUDIBLE": true,
+                "ENABLE_FEAT_F4HWN_BEAM": true,
+                "ENABLE_FEAT_F4HWN_QRCODE": true,
+                "ENABLE_FEAT_F4HWN_MEM": true,
+                "ENABLE_FEAT_F4HWN_LOGO": true,
+                "ENABLE_FEAT_F4HWN_LOGO_SAV": true,
                 "ENABLE_SWD": true,
                 "EDITION_STRING": "Fusion",
                 "TARGET": "f4hwn.fusion"
@@ -227,4 +244,4 @@
             "configurePreset": "Fusion"
         }
     ]
-}
+}

README.md

@@ -31,9 +31,9 @@ Anyway, have fun.
 > _FR - CE FIRMWARE N'A PAS DE VÉRITABLE CERVEAU. VEUILLEZ UTILISER LE VÔTRE. Utilisez ce firmware à vos risques et périls. Il n'y a absolument aucune garantie qu'il fonctionnera d'une manière ou d'une autre sur votre (vos) radio(s), il peut même bousiller votre (vos) radio(s), dans ce cas, vous devrez acheter une autre radio. Quoi qu'il en soit, amusez-vous bien._
 
 > [!NOTE]
-> EN - About Chirp, as many others firmwares, you need to use a dedicated driver available on [this repository](https://github.com/armel/uv-k5-chirp-driver). 
+> EN - About CHIRP, as with many other firmwares, you need to use a dedicated driver. The matching CHIRP driver is now bundled with each release of this repository, so you can download the firmware and its driver together from the [Releases page](https://github.com/armel/uv-k1-k5v3-firmware-custom/releases).
 >
-> _FR - A propos de Chirp, comme beaucoup d'autres firmwares, vous devez utiliser un pilote dédié disponible sur [ce dépôt](https://github.com/armel/uv-k5-chirp-driver)._
+> _FR - A propos de CHIRP, comme pour beaucoup d'autres firmwares, vous devez utiliser un pilote dédié. Le driver CHIRP correspondant est désormais fourni avec chaque release de ce dépôt, ce qui permet de récupérer ensemble le firmware et son pilote depuis la page des [Releases](https://github.com/armel/uv-k1-k5v3-firmware-custom/releases)._
 
 > [!CAUTION]
 > EN - I recommend to backup your calibration data with [uvtools2](https://armel.github.io/uvtools2/) just after flashing this firmware. It's a good reflex to have. 
@@ -42,7 +42,7 @@ Anyway, have fun.
 
 # Donations
 
-Special thanks to Jean-Cyrille F6IWW (3 times), Fabrice 14RC123, David F4BPP, Olivier 14RC206, Frédéric F4ESO, Stéphane F5LGW (2 times), Jorge Ornelas (4 times), Laurent F4AXK, Christophe Morel, Clayton W0LED, Pierre Antoine F6FWB, Jean-Claude 14FRS3306, Thierry F4GVO, Eric F1NOU, PricelessToolkit, Ady M6NYJ, Tom McGovern (4 times), Joseph Roth, Pierre-Yves Colin, Frank DJ7FG, Marcel Testaz, Brian Frobisher, Yannick F4JFO, Paolo Bussola, Dirk DL8DF, Levente Szőke (2 times), Bernard-Michel Herrera, Jérôme Saintespes, Paul Davies, RS (3 times), Johan F4WAT, Robert Wörle, Rafael Sundorf, Paul Harker, Peter Fintl, Pascal F4ICR (2 times), Mike DL2MF (3 times), Eric KI1C (2 times), Phil G0ELM, Jérôme Lambert, Eliot Vedel, Alfonso EA7KDF, Jean-François F1EVM, Robert DC1RDB (2 times), Ian KE2CHJ, Daryl VK3AWA, Roberto Brunelli, Robert Boardman, Stephen Oliver, Nicolas F4INE, William Bruno, Daniel OK2VLK, Tayler Chew, Peter DL7RFP, Philippe Kopp, Rune LA6YMA, Jeremy Luna, Steef Wagenaar (2 times), Zhuo BG7SGA, Jamie M0JLB, Antoine LIBERT, Vince K0DKR, Julia DF7JA, Ken 2E0UMK, Victor TI2SYS, Tobi DG9LAY, Deaglan K4DFQ, Catherine PALMER and Brian WA6JFK for their [donations](https://www.paypal.com/paypalme/F4HWN). That’s so kind of them. Thanks so much 🙏🏻
+Special thanks to Jean-Cyrille F6IWW (3 times), Fabrice 14RC123, David F4BPP, Olivier 14RC206, Frédéric F4ESO, Stéphane F5LGW (2 times), Jorge Ornelas (4 times), Laurent F4AXK, Christophe Morel, Clayton W0LED, Pierre Antoine F6FWB, Jean-Claude 14FRS3306, Thierry F4GVO, Eric F1NOU, PricelessToolkit, Ady M6NYJ, Tom McGovern (4 times), Joseph Roth, Pierre-Yves Colin, Frank DJ7FG, Marcel Testaz, Brian Frobisher, Yannick F4JFO, Paolo Bussola, Dirk DL8DF, Levente Szőke (2 times), Bernard-Michel Herrera, Jérôme Saintespes, Paul Davies, RS (3 times), Johan F4WAT, Robert Wörle, Rafael Sundorf, Paul Harker, Peter Fintl, Pascal F4ICR (2 times), Mike DL2MF (3 times), Eric KI1C (2 times), Phil G0ELM, Jérôme Lambert, Eliot Vedel, Alfonso EA7KDF, Jean-François F1EVM, Robert DC1RDB (2 times), Ian KE2CHJ, Daryl VK3AWA, Roberto Brunelli, Robert Boardman, Stephen Oliver, Nicolas F4INE, William Bruno, Daniel OK2VLK, Tayler Chew, Peter DL7RFP, Philippe Kopp, Rune LA6YMA, Jeremy Luna, Steef Wagenaar (2 times), Zhuo BG7SGA, Jamie M0JLB, Antoine LIBERT, Vince K0DKR, Julia DF7JA, Ken 2E0UMK, Victor TI2SYS, Tobi DG9LAY, Deaglan K4DFQ, Catherine PALMER, Brian WA6JFK, Stéphane Hintzy, Roger F1HCN, Marcin Kusaj and Flavio Cottarelli for their [donations](https://www.paypal.com/paypalme/F4HWN). That’s so kind of them. Thanks so much 🙏🏻
 
 ## Table of Contents
 
@@ -57,12 +57,15 @@ Special thanks to Jean-Cyrille F6IWW (3 times), Fabrice 14RC123, David F4BPP, Ol
 
 ## Main features and improvements from F4HWN:
 
-* several firmware versions:
-    * Bandscope (with spectrum analyzer made by Fagci),
-    * Broadcast (with commercial FM radio support),
-    * Basic (with spectrum analyzer and commercial FM radios support, but without certain functions such as Vox, Aircopy, etc.),
-    * RescueOps (specifically designed for first responders: firefighters, sea rescue, mountain rescue),
-    * Game (with a small breakout game),
+* Fusion is now the reference edition of the project:
+    * all-in-one firmware for UV-K1 and UV-K5 V3,
+    * spectrum analyzer made by Fagci,
+    * commercial FM radio support,
+    * Vox and Aircopy support,
+    * screenshots and K5Viewer support,
+    * advanced RX audio profiles and Audio Scope,
+    * first-responder oriented options,
+    * small breakout game,
 * improve default power settings level: 
     * Low1 to Low5 (<~20mW, ~125mW, ~250mW, ~500mW, ~1W), 
     * Mid ~2W, 
@@ -92,6 +95,8 @@ Special thanks to Jean-Cyrille F6IWW (3 times), Fabrice 14RC123, David F4BPP, Ol
     * improve keyboard frequency input,
     * add percent and gauge to Air Copy,
     * improve audio bar,
+    * add backlight fading,
+    * add Audio Scope on TX,
     * and more...
 * new menu entries and changes:
     * add SetPwr menu to set User power (<20mW, 125mW, 250mW, 500mW, 1W, 2W or 5W),
@@ -103,10 +108,13 @@ Special thanks to Jean-Cyrille F6IWW (3 times), Fabrice 14RC123, David F4BPP, Ol
     * add SetMet menu to set s-meter style (Classic or Tiny),
     * add SetLck menu to set what is locked (Keys or Keys + PTT),
     * add SetGUI menu to set font size on the VFO baseline (Classic or Tiny),
+    * add SetRxA menu to select RX audio profiles,
     * add TXLock menu to open TX on channel,
     * add SetTmr menu to set RX and TX timers (Off or On),
     * add SetOff menu to set the delay before the transceiver goes into deep sleep (Off or 1 minute to 2 hours),
     * add SetNFM menu to set Narrow width (12.5kHz or 6.25kHz),
+    * add SetVol menu to adjust RX audio volume,
+    * add SetScn menu to set Scan mode
     * rename BatVol menu (52/63) to SysInf, which displays the firmware version in addition to the battery status,
     * improve PonMsg menu,
     * improve BackLt menu,
@@ -116,6 +124,7 @@ Special thanks to Jean-Cyrille F6IWW (3 times), Fabrice 14RC123, David F4BPP, Ol
     * add HAM CA F Lock band (for Canadian zone),
     * add PMR 446 F Lock band,
     * add FRS/GMRS/MURS F Lock band,
+    * add SetNav hidden menu to select the navigation layout according to the radio model,
     * remove blink and SOS functionality, 
     * remove AM Fix menu (AM Fix is ENABLED by default),
     * add support of 3500mAh battery,
@@ -124,18 +133,18 @@ Special thanks to Jean-Cyrille F6IWW (3 times), Fabrice 14RC123, David F4BPP, Ol
     * change font and bitmaps,
     * move USB icon to left of battery information,
     * add RX and TX timers,
-* improve lists and scan lists options:
-    * add new list 3,
-    * add new list 0 (channel without list...),
-    * add new scan lists options,
-        * scan list 0 (all channels without list),
-        * scan list 1,
-        * scan list 2,
-        * scan list 3,
-        * scan lists [1, 2, 3],
-        * scan all (all channels with or without list),
-    * add scan list shortcuts,
-* add resume mode on startup (scan, bandscope and broadcast FM),
+* improve channel scanning:
+    * support up to 24 scan lists,
+    * each memory channel can be assigned to `OFF`, to one list (`01` to `24`), or to `ALL`,
+    * `ALL` scans every channel except those set to `OFF`,
+    * named scan lists are shown in the UI and status bar when available,
+    * if the selected scan list is empty or invalid, the firmware automatically jumps to the next valid one,
+    * very fast scan mode (around 150 freq/s),
+    * frequencies exclusions,
+* add resume mode on startup (scan, spectrum analyzer and FM radio),
+* improve VFO persistence and restore behavior:
+    * save the Squelch level adjusted with F + UP or F + DOWN,
+    * restore the full VFO state on long press of EXIT,
 * new actions:
     * RX MODE,
     * MAIN ONLY,
@@ -143,23 +152,26 @@ Special thanks to Jean-Cyrille F6IWW (3 times), Fabrice 14RC123, David F4BPP, Ol
     * WIDE NARROW,
     * 1750Hz,
     * MUTE,
-    * POWER HIGH (RescueOps),
-    * REMOVE OFFSET (RescueOps),
+    * POWER HIGH,
+    * REMOVE OFFSET,
+    * BEAM,
 * new key combinations:
     * add the F + UP or F + DOWN key combination to dynamically change the Squelch level,
     * add the F + F1 or F + F2 key combination to dynamically change the Step,
     * add F + 8 to quickly switch backlight between BLMin and BLMax on demand (this bypass BackLt strategy),
     * add F + 9 to return to BackLt strategy,
-    * add long press on MENU, in * SCAN mode, to temporarily exclude a memory channel,
-    * add short press on [0, 1, 2, 3, 4 or 5], in * SCAN mode, to dynamically change scan list.
+    * add long press on MENU, in * SCAN mode, to exclude the current memory channel,
+    * add direct scan list selection while scanning with two digits (`00` = `ALL`, `01` to `24` = scan list).
 * many fix:
     * squelch, 
     * s-meter,
     * DTMF overlaying, 
-    * scan list 2 ignored, 
     * scan range limit,
     * clean display on startup,
     * no more PWM noise,
+    * K5Viewer/serial key handling,
+    * spectrum freeze on USB-C unplug,
+    * Audio Scope behavior in OnePush mode and after DTMF/1750,
     * and more...
 * enabled AIR COPY
 * disabled ENABLE_DTMF_CALLING,
@@ -167,7 +179,7 @@ Special thanks to Jean-Cyrille F6IWW (3 times), Fabrice 14RC123, David F4BPP, Ol
 * remove 200Tx, 350Tx and 500Tx,
 * unlock TX on all bands needs only to be repeat 3 times,
 * code refactoring and many memory optimization,
-* displays the live screen of the Quansheng K5 on your computer via a USB-to-Serial cable,
+* stream the live screen of the Quansheng K5 to K5Viewer and capture screenshots over a USB-to-Serial cable,
 * and more...
 
 ## Main features from Egzumer:
@@ -203,7 +215,7 @@ Special thanks to Jean-Cyrille F6IWW (3 times), Fabrice 14RC123, David F4BPP, Ol
 
  ## Manual
 
-Up to date manual is available in the [Wiki section](https://github.com/armel/uv-k5-firmware-custom/wiki)
+Up to date manual is available in the [Wiki section](https://github.com/armel/uv-k1-k5v3-firmware-custom/wiki)
 
 ## Radio performance
 
@@ -211,21 +223,21 @@ Please note that the Quansheng UV-Kx radios are not professional quality transce
 performance is strictly limited. The RX front end has no track-tuned band pass filtering
 at all, and so are wide band/wide open to any and all signals over a large frequency range.
 
-Using the radio in high intensity RF environments will most likely make reception anything but
-easy (AM mode will suffer far more than FM ever will), the receiver simply doesn't have a
-great dynamic range, which results in distorted AM audio with stronger RX'ed signals.
-There is nothing more anyone can do in firmware/software to improve that, once the RX gain
-adjustment I do (AM fix) reaches the hardwares limit, your AM RX audio will be all but
-non-existent (just like Quansheng's firmware).
-On the other hand, FM RX audio will/should be fine.
+Using the radio in high intensity RF environments will most likely make reception difficult,
+especially in AM mode. The receiver simply does not have a great dynamic range, so stronger
+signals can easily cause distortion, desensitization and poor AM audio.
+This is fundamentally a hardware limitation: firmware can improve behavior at the margins, but
+it cannot overcome the front-end design of the radio.
+In practice, AM reception will degrade first and most severely, while FM reception is generally
+more tolerant and should remain more usable.
 
 But, they are nice toys for the price, fun to play with.
 
 ## Compiling and Building from Docker
 
-This project provides a Docker-based build system to compile all firmware editions for the UV-K1 and UV-K5 V3. Everything is handled through the `compile-with-docker.sh` helper script.
+This project provides a Docker-based build system to compile the Fusion firmware for the UV-K1 and UV-K5 V3. Everything is handled through the `compile-with-docker.sh` helper script.
 
-All build outputs are generated inside the `build/<Preset>` directory, according to the CMake presets defined in `CMakePresets.json`.
+The documented build output is generated inside `build/Fusion`, using the CMake presets defined in `CMakePresets.json`.
 
 ### Prerequisites
 
@@ -238,40 +250,25 @@ The script `compile-with-docker.sh` performs the following actions:
 
 1. Builds the Docker image (`uvk1-uvk5v3`) if it does not already exist.
 2. Removes any previous `build` directory to ensure a clean configuration.
-3. Runs CMake using the selected preset inside the Docker container.
-4. Builds the firmware and outputs `.elf`, `.bin` and `.hex` files for the chosen edition.
+3. Runs CMake using the `Fusion` preset inside the Docker container.
+4. Builds the firmware and outputs `.elf`, `.bin` and `.hex` files.
 
 ### Usage
 
 ```bash
-./compile-with-docker.sh <Preset> [extra CMake options]
+./compile-with-docker.sh Fusion [extra CMake options]
 ```
 
-### Available Presets
+### Documented Preset
 
-- **Custom**
-- **Bandscope**
-- **Broadcast**
-- **Basic**
-- **RescueOps**
-- **Game**
 - **Fusion**
-- **All** (builds all editions sequentially)
 
 ### Examples
 
-Build a single edition:
+Build Fusion:
 
 ```bash
 ./compile-with-docker.sh Fusion
-./compile-with-docker.sh Bandscope
-./compile-with-docker.sh Broadcast
-```
-
-Build everything:
-
-```bash
-./compile-with-docker.sh All
 ```
 
 ### Passing Additional CMake Options
@@ -282,15 +279,14 @@ These are forwarded directly to `cmake --preset` inside the container.
 Examples:
 
 ```bash
-./compile-with-docker.sh Bandscope -DENABLE_SPECTRUM=ON
-./compile-with-docker.sh Broadcast -DENABLE_FEAT_F4HWN_GAME=ON -DENABLE_NOAA=ON
-./compile-with-docker.sh Bandscope -DSQL_TONE=600
+./compile-with-docker.sh Fusion -DENABLE_SPECTRUM=ON
+./compile-with-docker.sh Fusion -DENABLE_FEAT_F4HWN_GAME=ON -DENABLE_NOAA=ON
+./compile-with-docker.sh Fusion -DSQL_TONE=600
 ```
 
 ### Notes
 
 - The first run may take a few minutes while Docker builds the base image.
-- Running with `All` will build every firmware variant in sequence.
 - Each build runs inside Docker, so your host environment remains clean.
 
 ## Flashing the Firmware with UVTools2
@@ -342,6 +338,7 @@ Click `Restore Calibration Data` and wait until the process fully completes.
 Many thanks to various people:
 
 * [Muzkr](https://github.com/muzkr)
+* [Mrkusypl](https://github.com/mrkusypl)
 * [Andrej](https://github.com/Tunas1337)
 * [Egzumer](https://github.com/egzumer)
 * [OneOfEleven](https://github.com/OneOfEleven)

tools/serialtool/_fwcodec.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2026
+#
+# Licensed under the MIT License (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at the root of this repository.
+#
+#     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.
+#
+
+from binascii import crc_hqx
+from itertools import cycle
+
+
+# Quansheng stock updater pack format:
+# - raw firmware split at 0x2000
+# - 16-byte ASCII version field inserted there
+# - XOR obfuscation with the table below
+# - CRC16/XMODEM appended at the end
+OBFUSCATION = bytes(
+    [
+        0x47, 0x22, 0xC0, 0x52, 0x5D, 0x57, 0x48, 0x94, 0xB1, 0x60, 0x60, 0xDB, 0x6F, 0xE3, 0x4C, 0x7C,
+        0xD8, 0x4A, 0xD6, 0x8B, 0x30, 0xEC, 0x25, 0xE0, 0x4C, 0xD9, 0x00, 0x7F, 0xBF, 0xE3, 0x54, 0x05,
+        0xE9, 0x3A, 0x97, 0x6B, 0xB0, 0x6E, 0x0C, 0xFB, 0xB1, 0x1A, 0xE2, 0xC9, 0xC1, 0x56, 0x47, 0xE9,
+        0xBA, 0xF1, 0x42, 0xB6, 0x67, 0x5F, 0x0F, 0x96, 0xF7, 0xC9, 0x3C, 0x84, 0x1B, 0x26, 0xE1, 0x4E,
+        0x3B, 0x6F, 0x66, 0xE6, 0xA0, 0x6A, 0xB0, 0xBF, 0xC6, 0xA5, 0x70, 0x3A, 0xBA, 0x18, 0x9E, 0x27,
+        0x1A, 0x53, 0x5B, 0x71, 0xB1, 0x94, 0x1E, 0x18, 0xF2, 0xD6, 0x81, 0x02, 0x22, 0xFD, 0x5A, 0x28,
+        0x91, 0xDB, 0xBA, 0x5D, 0x64, 0xC6, 0xFE, 0x86, 0x83, 0x9C, 0x50, 0x1C, 0x73, 0x03, 0x11, 0xD6,
+        0xAF, 0x30, 0xF4, 0x2C, 0x77, 0xB2, 0x7D, 0xBB, 0x3F, 0x29, 0x28, 0x57, 0x22, 0xD6, 0x92, 0x8B,
+    ]
+)
+
+VERSION_OFFSET = 0x2000
+VERSION_SIZE = 16
+CRC_SIZE = 2
+
+
+def _vector_table_looks_valid(image: bytes) -> bool:
+    if len(image) < 8:
+        return False
+
+    stack_pointer = int.from_bytes(image[0:4], "little")
+    reset_vector = int.from_bytes(image[4:8], "little")
+
+    return (stack_pointer & 0xFFF00000) == 0x20000000 and (reset_vector & 0xFFF00000) == 0x08000000
+
+
+def is_raw_image(image: bytes) -> bool:
+    return _vector_table_looks_valid(image)
+
+
+def has_valid_vendor_crc(image: bytes) -> bool:
+    if len(image) < CRC_SIZE:
+        return False
+
+    expected_crc = crc_hqx(image[:-CRC_SIZE], 0)
+    actual_crc = int.from_bytes(image[-CRC_SIZE:], "little")
+
+    return expected_crc == actual_crc
+
+
+def is_packed_image(image: bytes) -> bool:
+    if len(image) <= VERSION_OFFSET + VERSION_SIZE + CRC_SIZE:
+        return False
+
+    if is_raw_image(image):
+        return False
+
+    return has_valid_vendor_crc(image)
+
+
+def decode_packed_image(image: bytes) -> tuple[bytes, str]:
+    if not is_packed_image(image):
+        raise ValueError("not a packed Quansheng firmware image")
+
+    decoded = bytes(a ^ b for a, b in zip(image[:-CRC_SIZE], cycle(OBFUSCATION)))
+    version_bytes = decoded[VERSION_OFFSET:VERSION_OFFSET + VERSION_SIZE]
+    version = version_bytes.split(b"\x00", 1)[0].decode("ascii", errors="replace")
+
+    raw = decoded[:VERSION_OFFSET] + decoded[VERSION_OFFSET + VERSION_SIZE:]
+    if not is_raw_image(raw):
+        raise ValueError("decoded firmware does not look like a raw MCU image")
+
+    return raw, version

tools/serialtool/cli.py

@@ -17,14 +17,11 @@
 
 
 import argparse
-import serial
 import signal
 from time import sleep
 import os
 
-import _prog as pp
-import _dump as dd
-import _restore as rr
+import _fwcodec as fc
 
 
 def load_image(file: str) -> bytes:
@@ -42,7 +39,9 @@ def load_image(file: str) -> bytes:
     return a
 
 
-def main_dump(args, ser: serial.Serial):
+def main_dump(args, ser):
+
+    import _dump as dd
 
     dump_file: str = args.file
 
@@ -73,7 +72,10 @@ def main_dump(args, ser: serial.Serial):
         sleep(0)
 
 
-def main_restore(args, ser: serial.Serial):
+def main_restore(args, ser):
+
+    import _dump as dd
+    import _restore as rr
 
     dump_file: str = args.file
 
@@ -105,7 +107,9 @@ def main_restore(args, ser: serial.Serial):
         sleep(0)
 
 
-def main_flash(args, ser: serial.Serial):
+def main_flash(args, ser):
+
+    import _prog as pp
 
     bl_ver: str = args.bl_ver
     fw_file: str = args.file
@@ -139,6 +143,56 @@ def main_flash(args, ser: serial.Serial):
         sleep(0)
 
 
+def get_raw_output_path(file: str) -> str:
+
+    root, ext = os.path.splitext(file)
+    if ext:
+        file_name = "{}.raw{}".format(os.path.basename(root), ext)
+        candidate = "{}.raw{}".format(root, ext)
+    else:
+        file_name = os.path.basename(file) + ".raw.bin"
+        candidate = file + ".raw.bin"
+
+    out_dir = os.path.dirname(candidate) or "."
+    if os.access(out_dir, os.W_OK):
+        return candidate
+
+    return os.path.join(os.getcwd(), file_name)
+
+
+def main_decode(args):
+
+    fw_file: str = args.file
+    out_file: str = args.output or get_raw_output_path(fw_file)
+
+    try:
+        fw_image = load_image(fw_file)
+        if 0 == len(fw_image):
+            print("Invalid firmware image: {}: empty file".format(fw_file))
+            return
+    except Exception as e:
+        print("Cannot load firmware image '{}': {}".format(fw_file, e))
+        return
+
+    if fc.is_raw_image(fw_image):
+        print("Firmware image already looks raw")
+        raw_image = fw_image
+        version = None
+    else:
+        try:
+            raw_image, version = fc.decode_packed_image(fw_image)
+        except Exception as e:
+            print("Cannot decode firmware image '{}': {}".format(fw_file, e))
+            return
+
+    with open(out_file, "wb") as fd:
+        fd.write(raw_image)
+
+    print("Raw firmware image written: {}, size = {}".format(out_file, len(raw_image)))
+    if version:
+        print("Packed version field: {}".format(version))
+
+
 def main():
 
     # Usage:
@@ -146,6 +200,7 @@ def main():
     # serialtool.py .. flash [--bl-ver <ver>] <file>
     # serialtool.py .. dump {--config | --calib [| --all]} file
     # serialtool.py .. restore {--config | --calib [| --all]} file
+    # serialtool.py decode <packed.bin> [raw.bin]
     ap = argparse.ArgumentParser(description="UV-K5 V2 serial tool")
 
     # TODO: have to add option to each of subcommands ??
@@ -198,14 +253,31 @@ def main():
     )
     ap_restore.add_argument("file", help="input dump file")
 
+    ap_decode = sp.add_parser(
+        "decode", help="decode a packed Quansheng stock firmware into a raw image"
+    )
+    ap_decode.add_argument("file", help="input firmware image file")
+    ap_decode.add_argument(
+        "output",
+        nargs="?",
+        help="output raw firmware image file (default: <input>.raw.bin)",
+    )
+
     args = ap.parse_args()
-    port: str = args.port
     sub_name: str = args.subcommand
 
     print(ap.description)
     # print("Press Ctrl-C to quit")
 
+    if "decode" == sub_name:
+        main_decode(args)
+        return
+
+    port: str = args.port
+
     try:
+        import serial
+
         ser = serial.Serial(port, baudrate=38400, timeout=0.0001, write_timeout=None)
     except Exception as e:
         print("Cannot open port '{}': {}".format(port, e))