Merge pull request #250 from armel/feature_update_v5

Feature update v5

.gitignore

@@ -7,8 +7,11 @@ firmware
 .cache
 compile_commands.json
 .vscode
+.claude
 /docs
 k5_eeprom.raw
 
 /build
-/serialtool/__pycache__
+/serialtool/__pycache__
+
+.DS_Store

App/CMakeLists.txt

@@ -157,19 +157,16 @@ enable_feature(ENABLE_BOOT_BEEPS)
 enable_feature(ENABLE_SHOW_CHARGE_LEVEL)
 enable_feature(ENABLE_REVERSE_BAT_SYMBOL)
 enable_feature(ENABLE_NO_CODE_SCAN_TIMEOUT)
-enable_feature(ENABLE_AM_FIX
-    am_fix.c
-)
 enable_feature(ENABLE_SQUELCH_MORE_SENSITIVE)
 enable_feature(ENABLE_FASTER_CHANNEL_SCAN)
 enable_feature(ENABLE_RSSI_BAR)
 enable_feature(ENABLE_AUDIO_BAR)
+enable_feature(ENABLE_FEAT_F4HWN_AUDIO_SCOPE)
 enable_feature(ENABLE_COPY_CHAN_TO_VFO)
 enable_feature(ENABLE_REDUCE_LOW_MID_TX_POWER)
 enable_feature(ENABLE_BYP_RAW_DEMODULATORS)
 enable_feature(ENABLE_BLMIN_TMP_OFF)
 enable_feature(ENABLE_SCAN_RANGES)
-enable_feature(ENABLE_NAVIG_LEFT_RIGHT)
 
 # ---- CONTRIB MODS ----
 
@@ -199,15 +196,16 @@ enable_feature(ENABLE_FEAT_F4HWN_INV)
 enable_feature(ENABLE_FEAT_F4HWN_CTR)
 enable_feature(ENABLE_FEAT_F4HWN_RESCUE_OPS)
 enable_feature(ENABLE_FEAT_F4HWN_VOL)
-enable_feature(ENABLE_FEAT_F4HWN_RESET_CHANNEL)
+enable_feature(ENABLE_FEAT_F4HWN_AUDIO)
+enable_feature(ENABLE_FEAT_F4HWN_RESET_VFO)
 enable_feature(ENABLE_FEAT_F4HWN_PMR)
 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)
 
 # ---- DEBUGGING ----
 
-enable_feature(ENABLE_AM_FIX_SHOW_DATA)
 enable_feature(ENABLE_AGC_SHOW_DATA)
 enable_feature(ENABLE_UART_RW_BK_REGS)
 

App/app/action.c

@@ -114,6 +114,12 @@ void (*action_opt_table[])(void) = {
     //#else
     //    [ACTION_OPT_MUTE] = &FUNCTION_NOP,
     //#endif
+    #ifdef ENABLE_FEAT_F4HWN_AUDIO
+        [ACTION_OPT_RXA] = &ACTION_RxA,
+    #else
+        [ACTION_OPT_RXA] = &FUNCTION_NOP,
+    #endif
+
     #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
         [ACTION_OPT_POWER_HIGH] = &ACTION_Power_High,
         [ACTION_OPT_REMOVE_OFFSET] = &ACTION_Remove_Offset,
@@ -230,7 +236,8 @@ void ACTION_Scan(bool bRestart)
         }
 
         // channel mode. Keep scanning but toggle between scan lists
-        gEeprom.SCAN_LIST_DEFAULT = (gEeprom.SCAN_LIST_DEFAULT + 1) % 6;
+        RADIO_NextValidList(1);
+
         #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
             SETTINGS_WriteCurrentState();
         #endif
@@ -283,6 +290,8 @@ void ACTION_SwitchDemodul(void)
 
 void ACTION_Handle(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 {
+    HideFKeyIcon();
+
     if (gScreenToDisplay == DISPLAY_MAIN && gDTMF_InputMode){
          // entering DTMF code
 
@@ -312,19 +321,23 @@ void ACTION_Handle(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
         return;
     }
 
-    enum ACTION_OPT_t funcShort = ACTION_OPT_NONE;
-    enum ACTION_OPT_t funcLong  = ACTION_OPT_NONE;
+    enum ACTION_OPT_t func = ACTION_OPT_NONE;
     switch(Key) {
         case KEY_SIDE1:
-            funcShort = gEeprom.KEY_1_SHORT_PRESS_ACTION;
-            funcLong  = gEeprom.KEY_1_LONG_PRESS_ACTION;
+            if (bKeyHeld)
+                func = gEeprom.KEY_1_LONG_PRESS_ACTION;
+            else
+                func = gEeprom.KEY_1_SHORT_PRESS_ACTION;
             break;
         case KEY_SIDE2:
-            funcShort = gEeprom.KEY_2_SHORT_PRESS_ACTION;
-            funcLong  = gEeprom.KEY_2_LONG_PRESS_ACTION;
+            if (bKeyHeld)
+                func = gEeprom.KEY_2_LONG_PRESS_ACTION;
+            else
+                func = gEeprom.KEY_2_SHORT_PRESS_ACTION;
             break;
         case KEY_MENU:
-            funcLong  = gEeprom.KEY_M_LONG_PRESS_ACTION;
+            if (bKeyHeld)
+                func = gEeprom.KEY_M_LONG_PRESS_ACTION;
             break;
         default:
             break;
@@ -340,17 +353,46 @@ void ACTION_Handle(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
     if(!(bKeyHeld && !bKeyPressed)) // don't beep on released after hold
         gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
 
-    if (bKeyHeld || bKeyPressed) // held
+    if (bKeyHeld && !bKeyPressed) // button released after hold
     {
-        funcShort = funcLong;
-
-        if (!bKeyPressed) //ignore release if held
-            return;
+        return;
     }
 
     // held or released after short press beyond this point
+    
+#ifdef ENABLE_FMRADIO
+    if (gFmRadioMode) { // do not run these actions in FM radio mode
+        switch (func) {
+            case ACTION_OPT_POWER:
+            case ACTION_OPT_MONITOR:
+            case ACTION_OPT_A_B:
+            case ACTION_OPT_VFO_MR:
+            case ACTION_OPT_SWITCH_DEMODUL:
+    #ifdef ENABLE_VOX
+            case ACTION_OPT_VOX:
+    #endif
+    #ifdef ENABLE_FEAT_F4HWN
+            case ACTION_OPT_RXMODE:
+            case ACTION_OPT_MAINONLY:
+            case ACTION_OPT_WN:
+        #ifdef ENABLE_FEAT_F4HWN_AUDIO
+            case ACTION_OPT_RXA:
+        #endif
+        #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
+            case ACTION_OPT_POWER_HIGH:
+            case ACTION_OPT_REMOVE_OFFSET:
+        #endif
+    #endif
+                gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
+                return;
 
-    action_opt_table[funcShort]();
+            default:
+                break;
+        }
+    }
+#endif
+
+    action_opt_table[func]();
 }
 
 
@@ -496,17 +538,13 @@ void ACTION_RxMode(void)
 {
     static bool cycle = 0;
 
-    switch(cycle) {
-        case 0:
-            gEeprom.DUAL_WATCH = !gEeprom.DUAL_WATCH;
-            cycle = 1;
-            break;
-        case 1:
-            gEeprom.CROSS_BAND_RX_TX = !gEeprom.CROSS_BAND_RX_TX;
-            cycle = 0;
-            break;
+    if (cycle) {
+        gEeprom.CROSS_BAND_RX_TX = !gEeprom.CROSS_BAND_RX_TX;
+    } else {
+        gEeprom.DUAL_WATCH = !gEeprom.DUAL_WATCH;
     }
 
+    cycle = !cycle;
     ACTION_Update();
 }
 
@@ -516,81 +554,66 @@ void ACTION_MainOnly(void)
     static uint8_t dw = 0;
     static uint8_t cb = 0;
 
-    switch(cycle) {
-        case 0:
-            dw = gEeprom.DUAL_WATCH;
-            cb = gEeprom.CROSS_BAND_RX_TX;
+    if (cycle) {
+        gEeprom.DUAL_WATCH = dw;
+        gEeprom.CROSS_BAND_RX_TX = cb;
+    } else {
+        dw = gEeprom.DUAL_WATCH;
+        cb = gEeprom.CROSS_BAND_RX_TX;
 
-            gEeprom.DUAL_WATCH = 0;
-            gEeprom.CROSS_BAND_RX_TX = 0;
-            cycle = 1;
-            break;
-        case 1:
-            gEeprom.DUAL_WATCH = dw;
-            gEeprom.CROSS_BAND_RX_TX = cb;
-            cycle = 0;
-            break;
+        gEeprom.DUAL_WATCH = 0;
+        gEeprom.CROSS_BAND_RX_TX = 0;
     }
 
+    cycle = !cycle;
     ACTION_Update();
 }
 
+#ifdef ENABLE_FEAT_F4HWN_AUDIO
+void ACTION_RxA(void)
+{
+    if(gRxVfo->Modulation == MODULATION_AM)
+        gSetting_set_audio_am = (gSetting_set_audio_am + 1) % 3;
+    else if (gRxVfo->Modulation == MODULATION_FM)
+        gSetting_set_audio_fm = (gSetting_set_audio_fm + 1) % 5;
+
+    RADIO_SetModulation(gRxVfo->Modulation);
+}
+#endif
+
 void ACTION_Ptt(void)
 {
     gSetting_set_ptt_session = !gSetting_set_ptt_session;
+
+    ACTION_Update();
 }
 
 void ACTION_Wn(void)
 {
+    const bool isRx = FUNCTION_IsRx();
+    VFO_Info_t *pVfo = isRx ? gRxVfo : gTxVfo;
+
+    pVfo->CHANNEL_BANDWIDTH = !pVfo->CHANNEL_BANDWIDTH;
+
+    if (pVfo->Modulation == MODULATION_AM)
+    {
+        BK4819_SetFilterBandwidth(BK4819_FILTER_BW_AM, true);
+        return;
+    }
+
+    uint8_t bw = pVfo->CHANNEL_BANDWIDTH;
+
     #ifdef ENABLE_FEAT_F4HWN_NARROWER
-        bool narrower = 0;
-        if (FUNCTION_IsRx())
+        if (isRx && bw == BANDWIDTH_NARROW && gSetting_set_nfm == 1)
         {
-            gRxVfo->CHANNEL_BANDWIDTH = (gRxVfo->CHANNEL_BANDWIDTH == 0) ? 1: 0;
-            if(gRxVfo->CHANNEL_BANDWIDTH == BANDWIDTH_NARROW && gSetting_set_nfm == 1)
-            {
-                narrower = 1;
-            }
-
-            #ifdef ENABLE_AM_FIX
-                BK4819_SetFilterBandwidth(gRxVfo->CHANNEL_BANDWIDTH + narrower, true);
-            #else
-                BK4819_SetFilterBandwidth(gRxVfo->CHANNEL_BANDWIDTH + narrower, false);
-            #endif
+            bw++; 
         }
-        else
-        {
-            gTxVfo->CHANNEL_BANDWIDTH = (gTxVfo->CHANNEL_BANDWIDTH == 0) ? 1: 0;
-            if(gTxVfo->CHANNEL_BANDWIDTH == BANDWIDTH_NARROW && gSetting_set_nfm == 1)
-            {
-                narrower = 1;
-            }
+    #endif
 
-            #ifdef ENABLE_AM_FIX
-                BK4819_SetFilterBandwidth(gTxVfo->CHANNEL_BANDWIDTH, true);
-            #else
-                BK4819_SetFilterBandwidth(gTxVfo->CHANNEL_BANDWIDTH, false);
-            #endif
-        }
+    #ifdef ENABLE_AM_FIX
+        BK4819_SetFilterBandwidth(bw, true);
     #else
-        if (FUNCTION_IsRx())
-        {
-            gRxVfo->CHANNEL_BANDWIDTH = (gRxVfo->CHANNEL_BANDWIDTH == 0) ? 1: 0;
-            #ifdef ENABLE_AM_FIX
-                BK4819_SetFilterBandwidth(gRxVfo->CHANNEL_BANDWIDTH, true);
-            #else
-                BK4819_SetFilterBandwidth(gRxVfo->CHANNEL_BANDWIDTH, false);
-            #endif
-        }
-        else
-        {
-            gTxVfo->CHANNEL_BANDWIDTH = (gTxVfo->CHANNEL_BANDWIDTH == 0) ? 1: 0;
-            #ifdef ENABLE_AM_FIX
-                BK4819_SetFilterBandwidth(gTxVfo->CHANNEL_BANDWIDTH, true);
-            #else
-                BK4819_SetFilterBandwidth(gTxVfo->CHANNEL_BANDWIDTH, false);
-            #endif
-        }
+        BK4819_SetFilterBandwidth(bw, false);
     #endif
 }
 
@@ -627,38 +650,36 @@ void ACTION_BackLightOnDemand(void)
     BACKLIGHT_TurnOn();
 }
 
-    //#if !defined(ENABLE_SPECTRUM) || !defined(ENABLE_FMRADIO)
-    void ACTION_Mute(void)
-    {
-        // Toggle mute state
-        gMute = !gMute;
+void ACTION_Mute(void)
+{
+    // Toggle mute state
+    gMute = !gMute;
 
-        // Update the registers
-        #ifdef ENABLE_FMRADIO
-            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)
-
-        gUpdateStatus = true;
-    }
-    //#endif
-
-    #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-    void ACTION_Power_High(void)
-    {
-        gPowerHigh = !gPowerHigh;
-        gVfoConfigureMode = VFO_CONFIGURE_RELOAD;
-    }
-
-    void ACTION_Remove_Offset(void)
-    {
-        gRemoveOffset = !gRemoveOffset;
-        gVfoConfigureMode = VFO_CONFIGURE_RELOAD;
-    }
+    // Update the registers
+    #ifdef ENABLE_FMRADIO
+        BK1080_WriteRegister(BK1080_REG_05_SYSTEM_CONFIGURATION2, gMute ? 0x0A10 : 0x0A1F);
     #endif
-#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)
+
+    gUpdateStatus = true;
+}
+
+#ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
+void ACTION_Power_High(void)
+{
+    gPowerHigh = !gPowerHigh;
+    gVfoConfigureMode = VFO_CONFIGURE_RELOAD;
+}
+
+void ACTION_Remove_Offset(void)
+{
+    gRemoveOffset = !gRemoveOffset;
+    gVfoConfigureMode = VFO_CONFIGURE_RELOAD;
+}
+#endif
+#endif

App/app/action.h

@@ -42,9 +42,10 @@ void ACTION_SwitchDemodul(void);
     void ACTION_Wn(void);
     void ACTION_BackLightOnDemand(void);
     void ACTION_BackLight(void);
-    //#if !defined(ENABLE_SPECTRUM) || !defined(ENABLE_FMRADIO)
     void ACTION_Mute(void);
-    //#endif
+    #ifdef ENABLE_FEAT_F4HWN_AUDIO
+        void ACTION_RxA(void);
+    #endif
     #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
         void ACTION_Power_High(void);
         void ACTION_Remove_Offset(void);

App/app/aircopy.c

@@ -16,10 +16,6 @@
 
 #ifdef ENABLE_AIRCOPY
 
-//#if !defined(ENABLE_OVERLAY)
-//  #include "ARMCM0.h"
-//#endif
-
 #include "app/aircopy.h"
 #include "audio.h"
 #include "driver/bk4819.h"
@@ -31,6 +27,8 @@
 #include "ui/helper.h"
 #include "ui/inputbox.h"
 #include "ui/ui.h"
+#include "settings.h"
+#include <stddef.h>
 
 #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
 #include "screenshot.h"
@@ -41,10 +39,99 @@ static const uint16_t Obfuscation[8] = { 0x6C16, 0xE614, 0x912E, 0x400D, 0x3521,
 AIRCOPY_State_t gAircopyState;
 uint16_t gAirCopyBlockNumber;
 uint16_t gErrorsDuringAirCopy;
-uint8_t gAirCopyIsSendMode;
+bool     gAirCopyIsSendMode;
 
 uint16_t g_FSK_Buffer[36];
 
+// ============================================================================
+// Transfer Maps Definition
+// ============================================================================
+
+#define AIRCOPY_BANK_SEGMENTS(bank)                     \
+{                                                       \
+    { 0x0000 + (bank)*0x0800, 0x0000 + (bank)*0x0800 + 0x0800, AIRCOPY_WRITE_STRUCT }, \
+    { 0x4000 + (bank)*0x0800, 0x4000 + (bank)*0x0800 + 0x0800, AIRCOPY_WRITE_STRUCT }, \
+    { 0x8000 + (bank)*0x0100, 0x8000 + (bank)*0x0100 + 0x0100, AIRCOPY_WRITE_BYTES  }, \
+}
+
+#define AIRCOPY_STD_MAP(seg_array) \
+{                                  \
+    .segments = seg_array,         \
+    .num_segments = 3,             \
+    .total_blocks = 68             \
+}
+
+// total_blocks = 68 (blocs of 64 bytes) because (16 bytes + 16 bytes + 2 bytes) * 128 = 4352 / 64 = 68
+
+#define DECLARE_AIRCOPY_BANK(n)                                     \
+    static const AIRCOPY_Segment_t AIRCOPY_Segments_Bank##n[] =     \
+        AIRCOPY_BANK_SEGMENTS(n);                                   \
+                                                                    \
+    static const AIRCOPY_TransferMap_t AIRCOPY_Map_Bank##n =        \
+        AIRCOPY_STD_MAP(AIRCOPY_Segments_Bank##n);
+
+DECLARE_AIRCOPY_BANK(0)
+DECLARE_AIRCOPY_BANK(1)
+#if AIRCOPY_NUM_BANKS >= 4 // if 512 MR CHANNEL
+    DECLARE_AIRCOPY_BANK(2)
+    DECLARE_AIRCOPY_BANK(3)
+#endif
+#if AIRCOPY_NUM_BANKS >= 6 // if 758 MR CHANNEL
+    DECLARE_AIRCOPY_BANK(4)
+    DECLARE_AIRCOPY_BANK(5)
+#endif
+#if AIRCOPY_NUM_BANKS >= 8 // if 1024 MR CHANNEL
+    DECLARE_AIRCOPY_BANK(6)
+    DECLARE_AIRCOPY_BANK(7)
+#endif
+
+// For settings only
+
+static const AIRCOPY_Segment_t AIRCOPY_Segments_Settings[] = {
+    { 0xA000, 0xA170, AIRCOPY_WRITE_BYTES },
+    { 0x880E, 0x886E, AIRCOPY_WRITE_BYTES },
+};
+
+static const AIRCOPY_TransferMap_t AIRCOPY_Map_Settings = {
+    .segments = AIRCOPY_Segments_Settings,
+    .num_segments = 2,
+    .total_blocks = 8
+};
+
+// Finally
+
+static const AIRCOPY_TransferMap_t *AIRCOPY_AvailableMaps[] = {
+    &AIRCOPY_Map_Bank0,
+    &AIRCOPY_Map_Bank1,
+    #if AIRCOPY_NUM_BANKS >= 4 // if 512 MR CHANNEL
+        &AIRCOPY_Map_Bank2,
+        &AIRCOPY_Map_Bank3,
+    #endif
+    #if AIRCOPY_NUM_BANKS >= 6 // if 758 MR CHANNEL
+        &AIRCOPY_Map_Bank4,
+        &AIRCOPY_Map_Bank5,
+    #endif
+    #if AIRCOPY_NUM_BANKS >= 8 // if 1024 MR CHANNEL
+        &AIRCOPY_Map_Bank6,
+        &AIRCOPY_Map_Bank7,
+    #endif
+    &AIRCOPY_Map_Settings,
+};
+
+#define AIRCOPY_NUM_MAPS (sizeof(AIRCOPY_AvailableMaps) / sizeof(AIRCOPY_AvailableMaps[0]))
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+const AIRCOPY_TransferMap_t* AIRCOPY_GetCurrentMap(void)
+{
+    if (gAircopyCurrentMapIndex >= AIRCOPY_NUM_MAPS) {
+        gAircopyCurrentMapIndex = 0;
+    }
+    return AIRCOPY_AvailableMaps[gAircopyCurrentMapIndex];
+}
+
 static void AIRCOPY_clear()
 {
     for (uint8_t i = 0; i < 15; i++)
@@ -52,13 +139,55 @@ static void AIRCOPY_clear()
         crc[i] = 0;
     }
     #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
-        getScreenShot(true);
+        SCREENSHOT_Update(true);
     #endif
 }
 
+static inline const AIRCOPY_Segment_t *AIRCOPY_FindSegmentForOffset(uint16_t off)
+{
+    const AIRCOPY_TransferMap_t *map = AIRCOPY_GetCurrentMap();
+
+    for (uint16_t i = 0; i < map->num_segments; i++)
+    {
+        const AIRCOPY_Segment_t *seg = &map->segments[i];
+
+        if (off >= seg->start_offset && off < seg->end_offset)
+            return seg;
+    }
+
+    return NULL;
+}
+
+static inline void AIRCOPY_CheckComplete(void)
+{
+    const AIRCOPY_TransferMap_t *map = AIRCOPY_GetCurrentMap();
+    uint16_t done = gAirCopyBlockNumber + gErrorsDuringAirCopy;
+
+    if (done >= map->total_blocks)
+    {
+        gAircopyState = AIRCOPY_COMPLETE;
+#ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+        SCREENSHOT_Update(false);
+#endif
+    }
+}
+
+static inline void AIRCOPY_Obfuscation(void)
+{
+    for (unsigned int i = 0; i < 34; i++) {
+        g_FSK_Buffer[i + 1] ^= Obfuscation[i % 8];
+    }
+}
+
+// ============================================================================
+// Send/Receive Functions
+// ============================================================================
+
 bool AIRCOPY_SendMessage(void)
 {
     static uint8_t gAircopySendCountdown = 1;
+    static uint16_t CurrentOffset = 0;
+    static uint16_t CurrentSegmentIndex = 0;
 
     if (gAircopyState != AIRCOPY_TRANSFER) {
         return 1;
@@ -68,23 +197,40 @@ bool AIRCOPY_SendMessage(void)
         return 1;
     }
 
-    g_FSK_Buffer[1] = (gAirCopyBlockNumber & 0x3FF) << 6;
+    const AIRCOPY_TransferMap_t *map = AIRCOPY_GetCurrentMap();
 
-    EEPROM_ReadBuffer(g_FSK_Buffer[1], &g_FSK_Buffer[2], 64);
+    // Initialize on first call
+    if (gAirCopyBlockNumber == 0) {
+        CurrentSegmentIndex = 0;
+        CurrentOffset = map->segments[0].start_offset;
+    }
+
+    // Advance to next segment if current is done
+    while (CurrentSegmentIndex < map->num_segments &&
+           CurrentOffset >= map->segments[CurrentSegmentIndex].end_offset)
+    {
+        CurrentSegmentIndex++;
+        if (CurrentSegmentIndex < map->num_segments) {
+            CurrentOffset = map->segments[CurrentSegmentIndex].start_offset;
+        }
+    }
+
+    // Check if transfer is complete
+    if (CurrentSegmentIndex >= map->num_segments) {
+        gAircopyState = AIRCOPY_COMPLETE;
+        #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+            SCREENSHOT_Update(false);
+        #endif
+        return 0;
+    }
+
+    // Send data from current offset
+    g_FSK_Buffer[1] = CurrentOffset;
+    EEPROM_ReadBuffer(CurrentOffset, &g_FSK_Buffer[2], 64);
 
     g_FSK_Buffer[34] = CRC_Calculate(&g_FSK_Buffer[1], 2 + 64);
 
-    for (unsigned int i = 0; i < 34; i++) {
-        g_FSK_Buffer[i + 1] ^= Obfuscation[i % 8];
-    }
-
-    if (++gAirCopyBlockNumber >= 0x78) {
-        gAircopyState = AIRCOPY_COMPLETE;
-        #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
-            getScreenShot(false);
-        #endif
-        //NVIC_SystemReset();
-    }
+    AIRCOPY_Obfuscation();
 
     RADIO_SetTxParameters();
 
@@ -92,6 +238,8 @@ bool AIRCOPY_SendMessage(void)
     BK4819_SetupPowerAmplifier(0, 0);
     BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_PA_ENABLE, false);
 
+    CurrentOffset += 64;
+    gAirCopyBlockNumber++;
     gAircopySendCountdown = 30;
 
     return 0;
@@ -108,57 +256,83 @@ void AIRCOPY_StorePacket(void)
     uint16_t Status = BK4819_ReadRegister(BK4819_REG_0B);
     BK4819_PrepareFSKReceive();
 
-    // Doc says bit 4 should be 1 = CRC OK, 0 = CRC FAIL, but original firmware checks for FAIL.
-
     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();
         return;
     }
 
-    for (unsigned int i = 0; i < 34; i++) {
-        g_FSK_Buffer[i + 1] ^= Obfuscation[i % 8];
-    }
+    AIRCOPY_Obfuscation();
 
     uint16_t Crc = CRC_Calculate(&g_FSK_Buffer[1], 2 + 64);
     if (g_FSK_Buffer[34] != Crc) {
         gErrorsDuringAirCopy++;
+        AIRCOPY_CheckComplete();
         return;
     }
 
     uint16_t Offset = g_FSK_Buffer[1];
 
-    if (Offset >= 0x1E00) {
+    const AIRCOPY_Segment_t *seg = AIRCOPY_FindSegmentForOffset(Offset);
+    
+    if (seg == NULL) {
         gErrorsDuringAirCopy++;
+        AIRCOPY_CheckComplete();
         return;
     }
 
-    const uint16_t *pData = &g_FSK_Buffer[2];
-    for (unsigned int i = 0; i < 8; i++) {
-        EEPROM_WriteBuffer(Offset, pData);
-        pData += 4;
-        Offset += 8;
-    }
+    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];
 
-    if (Offset == 0x1E00) {
-        gAircopyState = AIRCOPY_COMPLETE;
-        #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
-            getScreenShot(false);
-        #endif
+        for (unsigned int i = 0; i < 8; i++)
+        {
+            EEPROM_WriteBuffer(Offset + (i * 8), p8 + (i * 8));
+        }
+    }
+    else
+    {
+        /* 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;
+        }
     }
 
     gAirCopyBlockNumber++;
+    AIRCOPY_CheckComplete();
 }
 
-static void AIRCOPY_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
+static void AIRCOPY_InitTransfer(bool isSendMode)
 {
-    if (bKeyHeld || !bKeyPressed) {
-        return;
-    }
+    gAircopyStep = 1;
+    gFSKWriteIndex = 0;
+    gAirCopyBlockNumber = 0;
+    gInputBoxIndex = 0;
+    gAirCopyIsSendMode = isSendMode;
 
+    AIRCOPY_clear();
+    
+    gAircopyState = AIRCOPY_TRANSFER;
+}
+
+// ============================================================================
+// Key Processing
+// ============================================================================
+
+static void AIRCOPY_Key_DIGITS(KEY_Code_t Key)
+{
     INPUTBOX_Append(Key);
 
-    gRequestDisplayScreen = DISPLAY_AIRCOPY;
-
     if (gInputBoxIndex < 6) {
 #ifdef ENABLE_VOICE
         gAnotherVoiceID = (VOICE_ID_t)Key;
@@ -193,82 +367,79 @@ static void AIRCOPY_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
         BK4819_ResetFSK();
         return;
     }
-
-    gRequestDisplayScreen = DISPLAY_AIRCOPY;
 }
 
-static void AIRCOPY_Key_EXIT(bool bKeyPressed, bool bKeyHeld)
+static void AIRCOPY_Key_EXIT()
 {
-    if (bKeyHeld || !bKeyPressed) {
-        return;
-    }
-
     if (gInputBoxIndex == 0) {
-        gAircopyStep = 1;
-        gFSKWriteIndex = 0;
-        gAirCopyBlockNumber = 0;
-        gInputBoxIndex = 0;
+        AIRCOPY_InitTransfer(0); // Mode: Receive
         gErrorsDuringAirCopy = lErrorsDuringAirCopy = 0;
-        gAirCopyIsSendMode = 0;
-
-        AIRCOPY_clear();
 
         BK4819_PrepareFSKReceive();
-
-        gAircopyState = AIRCOPY_TRANSFER;
+        
     } else {
         gInputBox[--gInputBoxIndex] = 10;
     }
-
-    gRequestDisplayScreen = DISPLAY_AIRCOPY;
 }
 
-static void AIRCOPY_Key_MENU(bool bKeyPressed, bool bKeyHeld)
+static void AIRCOPY_Key_MENU()
 {
-    if (bKeyHeld || !bKeyPressed) {
-        return;
-    }
-
-    gAircopyStep = 1;
-    gFSKWriteIndex = 0;
-    gAirCopyBlockNumber = 0;
-    gInputBoxIndex = 0;
-    gAirCopyIsSendMode = 1;
+    AIRCOPY_InitTransfer(1); // Mode: Send
+    
     g_FSK_Buffer[0] = 0xABCD;
     g_FSK_Buffer[1] = 0;
     g_FSK_Buffer[35] = 0xDCBA;
+}
 
-    AIRCOPY_clear();
+static void AIRCOPY_Key_UP_DOWN(int8_t Direction)
+{
+    if (!gEeprom.SET_NAV) {
+        Direction = -Direction;
+    }
 
-    GUI_DisplayScreen();
-
-    gAircopyState = AIRCOPY_TRANSFER;
+    switch(Direction)
+    {
+        case 1:
+            gAircopyCurrentMapIndex = (gAircopyCurrentMapIndex + 1) % AIRCOPY_NUM_MAPS;
+            break;
+        case -1:
+            gAircopyCurrentMapIndex = (gAircopyCurrentMapIndex + AIRCOPY_NUM_MAPS - 1) % AIRCOPY_NUM_MAPS;
+            break;
+    }
 }
 
 void AIRCOPY_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_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:
-        AIRCOPY_Key_DIGITS(Key, bKeyPressed, bKeyHeld);
+    case KEY_0...KEY_9:
+        AIRCOPY_Key_DIGITS(Key);
         break;
     case KEY_MENU:
-        AIRCOPY_Key_MENU(bKeyPressed, bKeyHeld);
+        AIRCOPY_Key_MENU();
         break;
     case KEY_EXIT:
-        AIRCOPY_Key_EXIT(bKeyPressed, bKeyHeld);
+        AIRCOPY_Key_EXIT();
+        break;
+    case KEY_UP:
+    case KEY_DOWN:
+        AIRCOPY_Key_UP_DOWN(Key == KEY_UP ? 1 : -1);
+        break;
+    case KEY_PTT:
         break;
     default:
+        gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
         break;
     }
+
+    gRequestDisplayScreen = DISPLAY_AIRCOPY;
 }
 
-#endif
+#endif

App/app/aircopy.h

@@ -21,26 +21,90 @@
 
 #include "driver/keyboard.h"
 
-enum AIRCOPY_State_t
-{
+// ============================================================================
+// General definitions
+// ============================================================================
+
+#define AIRCOPY_BLOCK_SIZE           0x0040u  // 64 bytes per AirCopy block
+#define AIRCOPY_CHANNELS_PER_BANK    128
+#define AIRCOPY_NUM_BANKS            MR_CHANNELS_MAX / AIRCOPY_CHANNELS_PER_BANK
+#define AIRCOPY_CHANNEL_SIZE         16       // bytes per channel (freq/name)
+#define AIRCOPY_BANK_SIZE_BYTES      0x1080u  // 0x800 (Freq) + 0x800 (Name) + 0x80 (Attr)
+#define AIRCOPY_BAR_WIDTH            120      // Visible width of the progress gauge
+
+// ============================================================================
+// Segment write mode
+// ============================================================================
+
+/*
+ * Defines how a segment must be written to EEPROM.
+ *
+ * - STRUCT: structured data (frequencies, names)
+ * - BYTES : raw byte stream (attributes, settings, etc.)
+ */
+typedef enum {
+    AIRCOPY_WRITE_STRUCT = 0,
+    AIRCOPY_WRITE_BYTES  = 1,
+} AIRCOPY_WriteMode_t;
+
+// ============================================================================
+// Transfer segment structure
+// ============================================================================
+
+/*
+ * Describes a contiguous EEPROM region involved in AirCopy.
+ * The write_mode defines how the RX side must write the data.
+ */
+typedef struct {
+    uint16_t start_offset;
+    uint16_t end_offset;
+    AIRCOPY_WriteMode_t write_mode;
+} AIRCOPY_Segment_t;
+
+// ============================================================================
+// Transfer map structure
+// ============================================================================
+
+/*
+ * A transfer map is a collection of segments describing
+ * one complete AirCopy operation (bank, settings, etc.).
+ */
+typedef struct {
+    const AIRCOPY_Segment_t *segments;
+    uint16_t num_segments;
+    uint16_t total_blocks;
+} AIRCOPY_TransferMap_t;
+
+// ============================================================================
+// AirCopy state
+// ============================================================================
+
+typedef enum {
     AIRCOPY_READY = 0,
     AIRCOPY_TRANSFER,
     AIRCOPY_COMPLETE
-};
+} AIRCOPY_State_t;
 
-typedef enum AIRCOPY_State_t AIRCOPY_State_t;
+// ============================================================================
+// Globals
+// ============================================================================
 
 extern AIRCOPY_State_t gAircopyState;
 extern uint16_t        gAirCopyBlockNumber;
 extern uint16_t        gErrorsDuringAirCopy;
-extern uint8_t         gAirCopyIsSendMode;
+extern bool            gAirCopyIsSendMode;
 
 extern uint16_t        g_FSK_Buffer[36];
 
+// ============================================================================
+// API
+// ============================================================================
+
 bool AIRCOPY_SendMessage(void);
 void AIRCOPY_StorePacket(void);
 void AIRCOPY_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld);
 
-#endif
+const AIRCOPY_TransferMap_t* AIRCOPY_GetCurrentMap(void);
 
-#endif
+#endif // ENABLE_AIRCOPY
+#endif // APP_AIRCOPY_H

App/app/app.c

@@ -273,18 +273,9 @@ static void HandleReceive(void)
             break;
 
         case CODE_TYPE_CONTINUOUS_TONE:
-            if (gFoundCTCSS && gFoundCTCSSCountdown_10ms == 0)
-            {
-                gFoundCTCSS = false;
-                gFoundCDCSS = false;
-                Mode        = END_OF_RX_MODE_END;
-                goto Skip;
-            }
-            break;
-
         case CODE_TYPE_DIGITAL:
         case CODE_TYPE_REVERSE_DIGITAL:
-            if (gFoundCDCSS && gFoundCDCSSCountdown_10ms == 0)
+            if ((gFoundCTCSS && gFoundCTCSSCountdown_10ms == 0) || (gFoundCDCSS && gFoundCDCSSCountdown_10ms == 0))
             {
                 gFoundCTCSS = false;
                 gFoundCDCSS = false;
@@ -544,7 +535,17 @@ void APP_StartListening(FUNCTION_Type_t function)
         gEeprom.DUAL_WATCH != DUAL_WATCH_OFF)
     {   // not scanning, dual watch is enabled
 
-        gDualWatchCountdown_10ms = dual_watch_count_after_2_10ms;
+        //gDualWatchCountdown_10ms = dual_watch_count_after_2_10ms;
+
+        const bool isMainTxDualRx =
+        (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF) &&
+        (gEeprom.CROSS_BAND_RX_TX != CROSS_BAND_OFF);
+
+        // Use a short hold only for MAIN TX DUAL RX, keep legacy hold otherwise
+        gDualWatchCountdown_10ms = isMainTxDualRx
+            ? dual_watch_count_after_2_10ms / 4 // Short timer = 420 / 4 ...
+            : dual_watch_count_after_2_10ms;
+
         gScheduleDualWatch       = false;
 
         // when crossband is active only the main VFO should be used for TX
@@ -891,6 +892,12 @@ static void HandleVox(void)
 
 void APP_Update(void)
 {
+#ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+    // Parse incoming packets on every tick so serial keys are never missed,
+    // regardless of whether the screen needs redrawing.
+    SCREENSHOT_ParseInput();
+#endif
+
 #ifdef ENABLE_VOICE
     if (gFlagPlayQueuedVoice) {
             AUDIO_PlayQueuedVoice();
@@ -1133,14 +1140,7 @@ void APP_Update(void)
             // go back to sleep
 
 #ifdef ENABLE_FEAT_F4HWN_SLEEP
-            if(gWakeUp)
-            {
-                gPowerSave_10ms = gEeprom.BATTERY_SAVE * 200; // deep sleep now indexed on BatSav
-            }
-            else
-            {
-                gPowerSave_10ms = gEeprom.BATTERY_SAVE * 10;
-            }
+            gPowerSave_10ms = gEeprom.BATTERY_SAVE * (gWakeUp ? 200 : 10); // deep sleep now indexed on BatSav
 #else
             gPowerSave_10ms = gEeprom.BATTERY_SAVE * 10;
 #endif
@@ -1165,8 +1165,21 @@ void APP_Update(void)
     }
 }
 
+void StopTransmitting(void) {
+    ProcessKey(KEY_PTT, false, false);
+    gPttIsPressed = false;
+    if (gKeyReading1 != KEY_INVALID)
+        gPttWasReleased = true;
+
+    #ifdef ENABLE_FEAT_F4HWN
+        #if defined(ENABLE_FEAT_F4HWN_CTR) || defined(ENABLE_FEAT_F4HWN_INV)
+        ST7565_ContrastAndInv();
+        #endif
+    #endif
+}
+
 // called every 10ms
-static void CheckKeys(void)
+void CheckKeys(void)
 {
 #ifdef ENABLE_DTMF_CALLING
     if(gSetting_KILLED){
@@ -1181,75 +1194,63 @@ static void CheckKeys(void)
 #endif
 
 // -------------------- PTT ------------------------
+    const bool serialConfigInProgress = SerialConfigInProgress();
+
+#ifdef ENABLE_FEAT_F4HWN
+    const bool isPressed = GPIO_IsPttPressed() && !serialConfigInProgress;
+#else
+    const bool isPressed = !GPIO_CheckBit(&GPIOC->DATA, GPIOC_PIN_PTT) && !serialConfigInProgress;
+#endif
+
 #ifdef ENABLE_FEAT_F4HWN
     if (gSetting_set_ptt_session)
     {
-        if (GPIO_IsPttPressed() && !SerialConfigInProgress() && gPttOnePushCounter == 0)
-        {   // PTT pressed
-            if (++gPttDebounceCounter >= 3)     // 30ms
-            {   // start transmitting
-                boot_counter_10ms   = 0;
+        if ((isPressed && (gPttOnePushCounter == 0 || gPttOnePushCounter == 2)) ||
+            (!isPressed && (gPttOnePushCounter == 1 || gPttOnePushCounter == 3)) ||
+            serialConfigInProgress) 
+        {
+            if (++gPttDebounceCounter >= 3 || (serialConfigInProgress && gPttOnePushCounter > 0))
+            {
                 gPttDebounceCounter = 0;
-                gPttIsPressed       = true;
-                gPttOnePushCounter = 1;
-                ProcessKey(KEY_PTT, true, false);
+                
+                if (gPttOnePushCounter == 0)
+                {   // start transmitting
+                    boot_counter_10ms   = 0;
+                    gPttIsPressed       = true;
+                    gPttOnePushCounter = 1;
+                    ProcessKey(KEY_PTT, true, false);
+                } 
+                else if (gPttOnePushCounter == 3 || serialConfigInProgress)
+                {   // stop transmitting
+                    StopTransmitting();
+                    gPttOnePushCounter = 0;
+                } 
+                else
+                    gPttOnePushCounter++;
             }
-        }
-        else if ((!GPIO_IsPttPressed() || SerialConfigInProgress()) && gPttOnePushCounter == 1)
-        {   
-            // PTT released or serial comms config in progress
-            if (++gPttDebounceCounter >= 3 || SerialConfigInProgress())     // 30ms
-            {   // stop transmitting
-                gPttOnePushCounter = 2;
-            }
-        }
-        else if (GPIO_IsPttPressed() && !SerialConfigInProgress() && gPttOnePushCounter == 2)
-        {   // PTT pressed again            
-            if (++gPttDebounceCounter >= 3 || SerialConfigInProgress())     // 30ms
-            {   // stop transmitting
-                gPttOnePushCounter = 3;
-            }
-        }
-        else if ((!GPIO_IsPttPressed() || SerialConfigInProgress()) && gPttOnePushCounter == 3)
-        {   // PTT released or serial comms config in progress
-            if (++gPttDebounceCounter >= 3 || SerialConfigInProgress())     // 30ms
-            {   // stop transmitting
-                ProcessKey(KEY_PTT, false, false);
-                gPttIsPressed = false;
-                if (gKeyReading1 != KEY_INVALID)
-                    gPttWasReleased = true;
-                gPttOnePushCounter = 0;
-                #if defined(ENABLE_FEAT_F4HWN_CTR) || defined(ENABLE_FEAT_F4HWN_INV)
-                ST7565_ContrastAndInv();
-                #endif
-            }
-        }
+        } 
         else
             gPttDebounceCounter = 0;
 
         //gDebug = gPttOnePushCounter;
-    }
-    else
+    } 
+    else 
+#endif
     {
         if (gPttIsPressed)
         {
-            if (!GPIO_IsPttPressed() || SerialConfigInProgress())
+            if (!isPressed)
             {   // PTT released or serial comms config in progress
-                if (++gPttDebounceCounter >= 3 || SerialConfigInProgress())     // 30ms
+                if (++gPttDebounceCounter >= 3 || serialConfigInProgress)   // 30ms
                 {   // stop transmitting
-                    ProcessKey(KEY_PTT, false, false);
-                    gPttIsPressed = false;
-                    if (gKeyReading1 != KEY_INVALID)
-                        gPttWasReleased = true;
-                    #if defined(ENABLE_FEAT_F4HWN_CTR) || defined(ENABLE_FEAT_F4HWN_INV)
-                    ST7565_ContrastAndInv();
-                    #endif
+                    gPttDebounceCounter = 0;
+                    StopTransmitting();
                 }
-            }
-            else
+            } 
+            else 
                 gPttDebounceCounter = 0;
         }
-        else if (GPIO_IsPttPressed() && !SerialConfigInProgress())
+        else if (isPressed)
         {   // PTT pressed
             if (++gPttDebounceCounter >= 3)     // 30ms
             {   // start transmitting
@@ -1259,38 +1260,9 @@ static void CheckKeys(void)
                 ProcessKey(KEY_PTT, true, false);
             }
         }
-        else
-            gPttDebounceCounter = 0;        
-    }
-#else
-    if (gPttIsPressed)
-    {
-        if (GPIO_CheckBit(&GPIOC->DATA, GPIOC_PIN_PTT) || SerialConfigInProgress())
-        {   // PTT released or serial comms config in progress
-            if (++gPttDebounceCounter >= 3 || SerialConfigInProgress())     // 30ms
-            {   // stop transmitting
-                ProcessKey(KEY_PTT, false, false);
-                gPttIsPressed = false;
-                if (gKeyReading1 != KEY_INVALID)
-                    gPttWasReleased = true;
-            }
-        }
         else
             gPttDebounceCounter = 0;
     }
-    else if (!GPIO_CheckBit(&GPIOC->DATA, GPIOC_PIN_PTT) && !SerialConfigInProgress())
-    {   // PTT pressed
-        if (++gPttDebounceCounter >= 3)     // 30ms
-        {   // start transmitting
-            boot_counter_10ms   = 0;
-            gPttDebounceCounter = 0;
-            gPttIsPressed       = true;
-            ProcessKey(KEY_PTT, true, false);
-        }
-    }
-    else
-        gPttDebounceCounter = 0;
-#endif
 
 // --------------------- OTHER KEYS ----------------------------
 
@@ -1363,6 +1335,11 @@ static void CheckKeys(void)
 void APP_TimeSlice10ms(void)
 {
     gNextTimeslice = false;
+
+    SETTINGS_SaveVfoIndicesFlush();
+
+    BACKLIGHT_Update();
+
     gFlashLightBlinkCounter++;
 
 #ifdef ENABLE_AM_FIX
@@ -1387,12 +1364,18 @@ void APP_TimeSlice10ms(void)
 
     if (gCurrentFunction == FUNCTION_TRANSMIT)
     {   // transmitting
-#ifdef ENABLE_AUDIO_BAR
+#if defined(ENABLE_AUDIO_BAR) && !defined(ENABLE_FEAT_F4HWN_AUDIO_SCOPE)
         if (gSetting_mic_bar && (gFlashLightBlinkCounter % (150 / 10)) == 0) // once every 150ms
             UI_DisplayAudioBar();
 #endif
     }
 
+#ifdef ENABLE_FEAT_F4HWN_AUDIO_SCOPE
+    if (gSetting_mic_bar && (gFlashLightBlinkCounter % (20 / 10)) == 0) // once every 20ms
+        // Sample audio amplitude and refresh display during TX only (FM RX has no usable audio register)
+        UI_DisplayAudioScope();
+#endif
+
     bool gUpdateDisplayCurrent = gUpdateDisplay;
     bool gUpdateStatusCurrent  = gUpdateStatus;
 
@@ -1407,7 +1390,7 @@ void APP_TimeSlice10ms(void)
 
     #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
     if (gUpdateDisplayCurrent || gUpdateStatusCurrent) {
-        getScreenShot(false);
+        SCREENSHOT_Update(false);
     }
     #endif
 
@@ -1520,18 +1503,16 @@ void cancelUserInputModes(void)
     if (gDTMF_InputMode || gDTMF_InputBox_Index > 0)
     {
         DTMF_clear_input_box();
-        gBeepToPlay           = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
         gRequestDisplayScreen = DISPLAY_MAIN;
         gUpdateDisplay        = true;
     }
 
     if (gWasFKeyPressed || gKeyInputCountdown > 0 || gInputBoxIndex > 0)
     {
-        gWasFKeyPressed     = false;
+        HideFKeyIcon();
+
         gInputBoxIndex      = 0;
         gKeyInputCountdown  = 0;
-        gBeepToPlay         = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
-        gUpdateStatus       = true;
         gUpdateDisplay      = true;
     }
 }
@@ -1553,18 +1534,17 @@ void APP_TimeSlice500ms(void)
         if (--gKeyInputCountdown == 0)
         {
 
-            if (IS_MR_CHANNEL(gTxVfo->CHANNEL_SAVE) && (gInputBoxIndex == 1 || gInputBoxIndex == 2))
+            if (IS_MR_CHANNEL(gTxVfo->CHANNEL_SAVE) && (gInputBoxIndex > 0 && gInputBoxIndex < 4) && (!gFmRadioMode))
             {
                 channelMoveSwitch();
 
                 if (gBeepToPlay == BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL) {
                     AUDIO_PlayBeep(gBeepToPlay);
                 }
-
-                SETTINGS_SaveVfoIndices();
             }
 
             cancelUserInputModes();
+            gHasVfoBackup = false;
         }
     }
 
@@ -1607,9 +1587,11 @@ void APP_TimeSlice500ms(void)
     }
 #endif
 
+    const int m = UI_MENU_GetCurrentMenuId();
+
     if (gBacklightCountdown_500ms > 0 && !gAskToSave && !gCssBackgroundScan
         // don't turn off backlight if user is in backlight menu option
-        && !(gScreenToDisplay == DISPLAY_MENU && (UI_MENU_GetCurrentMenuId() == MENU_ABR || UI_MENU_GetCurrentMenuId() == MENU_ABR_MAX))
+        && !(gScreenToDisplay == DISPLAY_MENU && (m == MENU_ABR || m == MENU_ABR_MAX || m == MENU_ABR_MIN))
         && --gBacklightCountdown_500ms == 0
         && gEeprom.BACKLIGHT_TIME < 61
     ) {
@@ -1727,8 +1709,10 @@ void APP_TimeSlice500ms(void)
         if (exit_menu) {
             gMenuCountdown = 0;
 
-            if (gEeprom.BACKLIGHT_TIME == 0) {
-                BACKLIGHT_TurnOff();
+            const int m = UI_MENU_GetCurrentMenuId();
+
+            if (gScreenToDisplay == DISPLAY_MENU && (m == MENU_ABR || m == MENU_ABR_MAX || m == MENU_ABR_MIN)) {
+                BACKLIGHT_TurnOn();
             }
 
             if (gInputBoxIndex > 0 || gDTMF_InputMode) {
@@ -1746,13 +1730,12 @@ void APP_TimeSlice500ms(void)
 */
             DTMF_clear_input_box();
 
-            gWasFKeyPressed  = false;
+            HideFKeyIcon();
             gInputBoxIndex   = 0;
 
             gAskToSave       = false;
             gAskToDelete     = false;
 
-            gUpdateStatus    = true;
             gUpdateDisplay   = true;
 
             GUI_DisplayType_t disp = DISPLAY_INVALID;
@@ -1931,6 +1914,7 @@ static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 
             // cancel user input
             cancelUserInputModes();
+            gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
 
             if (gMonitor)
                 ACTION_Monitor(); //turn off the monitor
@@ -2043,8 +2027,7 @@ static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
     if (gWasFKeyPressed && (Key == KEY_PTT || Key == KEY_EXIT || Key == KEY_SIDE1 || Key == KEY_SIDE2)) { 
 #endif
         // cancel the F-key
-        gWasFKeyPressed = false;
-        gUpdateStatus   = true;
+        HideFKeyIcon();
     }
 
     if (bFlag) {
@@ -2121,18 +2104,14 @@ static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
         }
 #endif
     }
+    else if (gScreenToDisplay != DISPLAY_INVALID && (
+            (Key != KEY_SIDE1 && Key != KEY_SIDE2)
 #ifdef ENABLE_FEAT_F4HWN // For F + SIDE1 or F + SIDE2
-    else if (gWasFKeyPressed && (Key == KEY_SIDE1 || Key == KEY_SIDE2)) {
-        ProcessKeysFunctions[gScreenToDisplay](Key, bKeyPressed, bKeyHeld);
-    }
-    else if (Key != KEY_SIDE1 && Key != KEY_SIDE2 && gScreenToDisplay != DISPLAY_INVALID) {
-        ProcessKeysFunctions[gScreenToDisplay](Key, bKeyPressed, bKeyHeld);
-    }
-#else
-    else if (Key != KEY_SIDE1 && Key != KEY_SIDE2 && gScreenToDisplay != DISPLAY_INVALID) {
-        ProcessKeysFunctions[gScreenToDisplay](Key, bKeyPressed, bKeyHeld);
-    }
+            || (gWasFKeyPressed && (Key == KEY_SIDE1 || Key == KEY_SIDE2))
 #endif
+    )) {
+        ProcessKeysFunctions[gScreenToDisplay](Key, bKeyPressed, bKeyHeld);
+    }
     else if (!SCANNER_IsScanning()
 #ifdef ENABLE_AIRCOPY
             && gScreenToDisplay != DISPLAY_AIRCOPY
@@ -2187,7 +2166,7 @@ Skip:
     }
 
     if (gRequestSaveChannel > 0) { // TODO: remove the gRequestSaveChannel, why use global variable for that??
-        if ((!bKeyHeld && !bKeyPressed) || UI_MENU_GetCurrentMenuId())
+        if ((!bKeyHeld && !bKeyPressed) || (UI_MENU_GetCurrentMenuId() != 0 && gScreenToDisplay == DISPLAY_MENU) || gScreenToDisplay == DISPLAY_SCANNER)
         {
             SETTINGS_SaveChannel(gTxVfo->CHANNEL_SAVE, gEeprom.TX_VFO, gTxVfo, gRequestSaveChannel);
 

App/app/breakout.c

@@ -401,50 +401,35 @@ static void OnKeyDown(uint8_t key)
     }
 }
 
-
-// Key 
-static KEY_Code_t GetKey()
-{
-    KEY_Code_t btn = KEYBOARD_Poll();
-    if (btn == KEY_INVALID && GPIO_IsPttPressed())
-    {
-        btn = KEY_PTT;
-    }
-    return btn;
-}
-
 // HandleUserInput 
 static bool HandleUserInput()
 {
-    // Store previous key state
+#ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+    // Parse incoming packets on every tick so serial keys are never missed,
+    // regardless of whether the screen needs redrawing.
+    SCREENSHOT_ParseInput();
+#endif
+
     kbd.prev = kbd.current;
-    
-    // Get the current key
-    kbd.current = GetKey();
-    
-    // Detect valid key press continuation (same key still pressed)
-    if (kbd.current != KEY_INVALID && kbd.current == kbd.prev)
-    {
-        kbd.counter = 1;
-    }
-    else
-    {
-        kbd.counter = 0;
-    }
-    
-    // Process the key if counter indicates it should be handled
-    if (kbd.counter == 1)
+    kbd.current = KEYBOARD_GetKey();
+
+    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);
-        
-        // Special handling for MENU key
-        if(kbd.current == KEY_MENU)
-        {
-            kbd.counter = 0;
-            SYSTEM_DelayMs(250);
-        }
+        return true;
     }
-    
+
+    // Action keys (MENU, EXIT): dispatch only on rising edge
+    if (kbd.current != kbd.prev)
+    {
+        OnKeyDown(kbd.current);
+    }
+
     return true;
 }
 
@@ -452,7 +437,6 @@ static bool HandleUserInput()
 static void Tick()
 {
     HandleUserInput();
-    HandleUserInput();
 }
 
 // APP_RunBreakout
@@ -465,6 +449,9 @@ void APP_RunBreakout(void) {
         // Init led
         BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, false);
 
+        // Finish the brightness fade if it is in progress
+        BACKLIGHT_UpdateTickless();
+
         // Init game
         UI_DisplayClear();
         reset();
@@ -482,11 +469,6 @@ void APP_RunBreakout(void) {
                 if(swap == 0)
                 {
                     blockAnim = (blockAnim + 1) % 4;
-
-                    // For screenshot
-                    #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
-                        getScreenShot(false);
-                    #endif
                 }
                 
                 swap = (swap + 1) % 4;
@@ -509,5 +491,12 @@ void APP_RunBreakout(void) {
 
             ST7565_BlitStatusLine();  // Blank status line
             ST7565_BlitFullScreen();
+
+            #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+                if(isPaused || swap == 0)
+                {
+                    SCREENSHOT_Update(false);
+                }
+            #endif
         }
 }

App/app/chFrScanner.c

@@ -37,6 +37,15 @@ uint8_t             initialCROSS_BAND_RX_TX;
 static void NextFreqChannel(void);
 static void NextMemChannel(void);
 
+#if defined(ENABLE_FEAT_F4HWN_RESUME_STATE) || defined(ENABLE_SCAN_RANGES)
+    void CHFRSCANNER_ScanRange(void) {
+        gScanRangeStart = gScanRangeStart ? 0 : gTxVfo->pRX->Frequency;
+        gScanRangeStop = gEeprom.VfoInfo[!gEeprom.TX_VFO].freq_config_RX.Frequency;
+        if(gScanRangeStart > gScanRangeStop)
+            SWAP(gScanRangeStart, gScanRangeStop);
+    }
+#endif
+
 void CHFRSCANNER_Start(const bool storeBackupSettings, const int8_t scan_direction)
 {
     if (storeBackupSettings) {
@@ -52,7 +61,13 @@ void CHFRSCANNER_Start(const bool storeBackupSettings, const int8_t scan_directi
     gScanStateDir    = scan_direction;
 
     if (IS_MR_CHANNEL(gNextMrChannel))
-    {   // channel mode
+    {   
+
+        if(!RADIO_CheckValidList(gEeprom.SCAN_LIST_DEFAULT)) {
+            RADIO_NextValidList(1);
+        }
+
+        // channel mode
         if (storeBackupSettings) {
             initialFrqOrChan = gRxVfo->CHANNEL_SAVE;
             lastFoundFrqOrChan = initialFrqOrChan;
@@ -249,12 +264,12 @@ static void NextFreqChannel(void)
 
 static void NextMemChannel(void)
 {
-    static unsigned int prev_mr_chan = 0;
-    const bool          enabled      = (gEeprom.SCAN_LIST_DEFAULT > 0 && gEeprom.SCAN_LIST_DEFAULT < 4) ? gEeprom.SCAN_LIST_ENABLED[gEeprom.SCAN_LIST_DEFAULT - 1] : true;
-    const int           chan1        = (gEeprom.SCAN_LIST_DEFAULT > 0 && gEeprom.SCAN_LIST_DEFAULT < 4) ? gEeprom.SCANLIST_PRIORITY_CH1[gEeprom.SCAN_LIST_DEFAULT - 1] : -1;
-    const int           chan2        = (gEeprom.SCAN_LIST_DEFAULT > 0 && gEeprom.SCAN_LIST_DEFAULT < 4) ? gEeprom.SCANLIST_PRIORITY_CH2[gEeprom.SCAN_LIST_DEFAULT - 1] : -1;
-    const unsigned int  prev_chan    = gNextMrChannel;
-    unsigned int        chan         = 0;
+    static uint16_t prev_mr_chan = 0;
+    const bool      enabled      = (gEeprom.SCAN_LIST_DEFAULT > 0 && gEeprom.SCAN_LIST_DEFAULT <= MR_CHANNELS_LIST + 1) ? gEeprom.SCAN_LIST_ENABLED : true;
+    const int16_t   chan1        = (gEeprom.SCAN_LIST_DEFAULT > 0 && gEeprom.SCAN_LIST_DEFAULT <= MR_CHANNELS_LIST + 1 && gEeprom.SCANLIST_PRIORITY_CH[0] != MR_CHANNELS_MAX) ? gEeprom.SCANLIST_PRIORITY_CH[0] : -1;
+    const int16_t   chan2        = (gEeprom.SCAN_LIST_DEFAULT > 0 && gEeprom.SCAN_LIST_DEFAULT <= MR_CHANNELS_LIST + 1 && gEeprom.SCANLIST_PRIORITY_CH[1] != MR_CHANNELS_MAX) ? gEeprom.SCANLIST_PRIORITY_CH[1] : -1;
+    const uint16_t  prev_chan    = gNextMrChannel;
+    uint16_t        chan         = 0;
 
     //char str[64] = "";
 
@@ -327,15 +342,15 @@ static void NextMemChannel(void)
             case SCAN_NEXT_CHAN_MR:
                 currentScanList = SCAN_NEXT_CHAN_MR;
                 gNextMrChannel   = prev_mr_chan;
-                chan             = 0xff;
+                chan             = 0xFFFF;
                 break;
         }
     }
 
-    if (!enabled || chan == 0xff)
+    if (!enabled || chan == 0xFFFF)
     {       
         chan = RADIO_FindNextChannel(gNextMrChannel + gScanStateDir, gScanStateDir, true, gEeprom.SCAN_LIST_DEFAULT);
-        if (chan == 0xFF)
+        if (chan == 0xFFFF)
         {   // no valid channel found
             chan = MR_CHANNEL_FIRST;
         }

App/app/chFrScanner.h

@@ -20,6 +20,10 @@ void CHFRSCANNER_Stop(void);
 void CHFRSCANNER_Start(const bool storeBackupSettings, const int8_t scan_direction);
 void CHFRSCANNER_ContinueScanning(void);
 
+#if defined(ENABLE_FEAT_F4HWN_RESUME_STATE) || defined(ENABLE_SCAN_RANGES)
+    void CHFRSCANNER_ScanRange(void);
+#endif
+
 #ifdef ENABLE_FEAT_F4HWN
     extern uint32_t lastFoundFrqOrChan;
     extern uint32_t lastFoundFrqOrChanOld;

App/app/common.c

@@ -3,6 +3,7 @@
 #include "functions.h"
 #include "misc.h"
 #include "settings.h"
+#include "ui/inputbox.h"
 #include "ui/ui.h"
 
 void COMMON_KeypadLockToggle() 
@@ -29,6 +30,11 @@ void COMMON_SwitchVFOs()
 #endif
     gEeprom.TX_VFO ^= 1;
 
+    if (gInputBoxIndex > 0) {
+        gInputBoxIndex = 0;
+        gHasVfoBackup = false;
+    }
+
     if (gEeprom.CROSS_BAND_RX_TX != CROSS_BAND_OFF)
         gEeprom.CROSS_BAND_RX_TX = gEeprom.TX_VFO + 1;
     if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF)
@@ -49,6 +55,11 @@ void COMMON_SwitchVFOMode()
     if (gEeprom.VFO_OPEN)
 #endif
     {
+        if (gInputBoxIndex > 0) {
+            gInputBoxIndex = 0;
+            gHasVfoBackup = false;
+        }
+
         if (IS_MR_CHANNEL(gTxVfo->CHANNEL_SAVE))
         {   // swap to frequency mode
             gEeprom.ScreenChannel[gEeprom.TX_VFO] = gEeprom.FreqChannel[gEeprom.TX_VFO];
@@ -60,8 +71,8 @@ void COMMON_SwitchVFOMode()
             return;
         }
 
-        uint8_t Channel = RADIO_FindNextChannel(gEeprom.MrChannel[gEeprom.TX_VFO], 1, false, 0);
-        if (Channel != 0xFF)
+        uint16_t Channel = RADIO_FindNextChannel(gEeprom.MrChannel[gEeprom.TX_VFO], 1, false, 0);
+        if (Channel != 0xFFFF)
         {   // swap to channel mode
             gEeprom.ScreenChannel[gEeprom.TX_VFO] = Channel;
             #ifdef ENABLE_VOICE

App/app/flashlight.c

@@ -51,20 +51,26 @@ static inline void Flashlight_Toggle(){ GPIO_TogglePin(GPIO_PIN_FLASHLIGHT); }
 
     void ACTION_FlashLight(void)
     {
-        switch (gFlashLightState) {
-            case FLASHLIGHT_OFF:
-                gFlashLightState++;
-                Flashlight_TurnOn();
-                break;
-            case FLASHLIGHT_ON:
-            case FLASHLIGHT_BLINK:
-                gFlashLightState++;
-                break;
-            case FLASHLIGHT_SOS:
-            default:
-                gFlashLightState = 0;
-                Flashlight_TurnOff();
+        // switch (gFlashLightState) {
+        //     case FLASHLIGHT_OFF:
+        //         Flashlight_TurnOn();
+        //         break;
+        //     case FLASHLIGHT_ON:
+        //     case FLASHLIGHT_BLINK:
+        //         break;
+        //     case FLASHLIGHT_SOS:
+        //     default:
+        //         Flashlight_TurnOff();
+        // }
+
+        if(gFlashLightState == FLASHLIGHT_OFF) {
+            Flashlight_TurnOn();
         }
+        else if (gFlashLightState == FLASHLIGHT_SOS) {
+            Flashlight_TurnOff();
+        }
+
+        gFlashLightState = (gFlashLightState + 1) % 4;
     }
 #else
     void ACTION_FlashLight(void)

App/app/fm.c

@@ -23,6 +23,7 @@
 #include "app/generic.h"
 #include "audio.h"
 #include "driver/bk1080.h"
+#include "driver/bk4819.h"
 #include "driver/py25q16.h"
 #include "driver/gpio.h"
 #include "functions.h"
@@ -31,11 +32,7 @@
 #include "ui/inputbox.h"
 #include "ui/ui.h"
 
-#ifndef ARRAY_SIZE
-    #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
-#endif
-
-uint16_t          gFM_Channels[20];
+uint16_t          gFM_Channels[FM_CHANNELS_MAX];
 bool              gFmRadioMode;
 uint8_t           gFmRadioCountdown_500ms;
 volatile uint16_t gFmPlayCountdown_10ms;
@@ -109,6 +106,10 @@ void FM_TurnOff(void)
 
     BK1080_Init0();
 
+    // Enable relevant LNA based on VFO frequency
+    BK4819_PickRXFilterPathBasedOnFrequency(gRxVfo->freq_config_RX.Frequency);
+
+
     gUpdateStatus  = true;
 
     #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
@@ -119,10 +120,27 @@ void FM_TurnOff(void)
 
 void FM_EraseChannels(void)
 {
-    PY25Q16_SectorErase(0x003000);
+    //PY25Q16_SectorErase(0x003000);
+    
+    uint8_t clearBuf[128];
+    memset(clearBuf, 0xFF, sizeof(clearBuf));
+    PY25Q16_WriteBuffer(0x00A028, clearBuf, sizeof(clearBuf), false);
+
     memset(gFM_Channels, 0xFF, sizeof(gFM_Channels));
 }
 
+uint16_t FM_WrapFrequency(uint16_t Frequency) {
+    const uint16_t freqLoLimit = BK1080_GetFreqLoLimit(gEeprom.FM_Band);
+    const uint16_t freqHiLimit = BK1080_GetFreqHiLimit(gEeprom.FM_Band);
+
+    if (Frequency < freqLoLimit)
+        return freqHiLimit;
+    else if (Frequency > freqHiLimit)
+        return freqLoLimit;
+
+    return Frequency;
+}
+
 void FM_Tune(uint16_t Frequency, int8_t Step, bool bFlag)
 {
     AUDIO_AudioPathOff();
@@ -139,10 +157,7 @@ void FM_Tune(uint16_t Frequency, int8_t Step, bool bFlag)
 
     if (!bFlag) {
         Frequency += Step;
-        if (Frequency < BK1080_GetFreqLoLimit(gEeprom.FM_Band))
-            Frequency = BK1080_GetFreqHiLimit(gEeprom.FM_Band);
-        else if (Frequency > BK1080_GetFreqHiLimit(gEeprom.FM_Band))
-            Frequency = BK1080_GetFreqLoLimit(gEeprom.FM_Band);
+        Frequency = FM_WrapFrequency(Frequency);
 
         gEeprom.FM_FrequencyPlaying = Frequency;
     }
@@ -176,65 +191,45 @@ void FM_PlayAndUpdate(void)
 
 int FM_CheckFrequencyLock(uint16_t Frequency, uint16_t LowerLimit)
 {
-    int ret = -1;
-
-    const uint16_t Test2 = BK1080_ReadRegister(BK1080_REG_07);
-
-    // This is supposed to be a signed value, but above function is unsigned
+    const uint16_t Test2     = BK1080_ReadRegister(BK1080_REG_07);
     const uint16_t Deviation = BK1080_REG_07_GET_FREQD(Test2);
 
-    if (BK1080_REG_07_GET_SNR(Test2) <= 2) {
-        BK1080_FrequencyDeviation = Deviation;
-        BK1080_BaseFrequency      = Frequency;
+    // Helper macro to update globals and return
+    #define RETURN(val) \
+        do { \
+            BK1080_FrequencyDeviation = Deviation; \
+            BK1080_BaseFrequency      = Frequency; \
+            return (val); \
+        } while (0)
 
-        return ret;
-    }
+    if (BK1080_REG_07_GET_SNR(Test2) <= 2)
+        RETURN(-1);
 
     const uint16_t Status = BK1080_ReadRegister(BK1080_REG_10);
+    if ((Status & BK1080_REG_10_MASK_AFCRL) != BK1080_REG_10_AFCRL_NOT_RAILED ||
+        BK1080_REG_10_GET_RSSI(Status) < 10)
+        RETURN(-1);
 
-    if ((Status & BK1080_REG_10_MASK_AFCRL) != BK1080_REG_10_AFCRL_NOT_RAILED || BK1080_REG_10_GET_RSSI(Status) < 10) {
-        BK1080_FrequencyDeviation = Deviation;
-        BK1080_BaseFrequency      = Frequency;
+    if (Deviation >= 280 && Deviation <= 3815)
+        RETURN(-1);
 
-        return ret;
-    }
-
-    //if (Deviation > -281 && Deviation < 280)
-    if (Deviation >= 280 && Deviation <= 3815) {
-        BK1080_FrequencyDeviation = Deviation;
-        BK1080_BaseFrequency      = Frequency;
-
-        return ret;
-    }
-
-    // not BLE(less than or equal)
+    // Scanning upward: previous deviation was negative (bit 11 set) or near zero
     if (Frequency > LowerLimit && (Frequency - BK1080_BaseFrequency) == 1) {
-        if (BK1080_FrequencyDeviation & 0x800 || (BK1080_FrequencyDeviation < 20))
-        {
-            BK1080_FrequencyDeviation = Deviation;
-            BK1080_BaseFrequency      = Frequency;
-
-            return ret;
-        }
+        if (BK1080_FrequencyDeviation & 0x800 || BK1080_FrequencyDeviation < 20)
+            RETURN(-1);
     }
 
-    // not BLT(less than)
-
+    // Scanning downward: previous deviation was positive or saturated high
     if (Frequency >= LowerLimit && (BK1080_BaseFrequency - Frequency) == 1) {
-        if ((BK1080_FrequencyDeviation & 0x800) == 0 || (BK1080_FrequencyDeviation > 4075))
-        {
-            BK1080_FrequencyDeviation = Deviation;
-            BK1080_BaseFrequency      = Frequency;
-
-            return ret;
-        }
+        if ((BK1080_FrequencyDeviation & 0x800) == 0 || BK1080_FrequencyDeviation > 4075)
+            RETURN(-1);
     }
 
-    ret = 0;
+    #undef RETURN
+
     BK1080_FrequencyDeviation = Deviation;
     BK1080_BaseFrequency      = Frequency;
-
-    return ret;
+    return 0;
 }
 
 static void Key_DIGITS(KEY_Code_t Key, uint8_t state)
@@ -262,6 +257,7 @@ static void Key_DIGITS(KEY_Code_t Key, uint8_t state)
         }
 
         INPUTBOX_Append(Key);
+        gKeyInputCountdown = key_input_timeout_500ms;
 
         gRequestDisplayScreen = DISPLAY_FM;
 
@@ -277,6 +273,8 @@ static void Key_DIGITS(KEY_Code_t Key, uint8_t state)
                 uint32_t Frequency;
 
                 gInputBoxIndex = 0;
+                gKeyInputCountdown = 1;
+
                 Frequency = StrToUL(INPUTBOX_GetAscii());
 
                 if (Frequency < BK1080_GetFreqLoLimit(gEeprom.FM_Band) || BK1080_GetFreqHiLimit(gEeprom.FM_Band) < Frequency) {
@@ -299,6 +297,8 @@ static void Key_DIGITS(KEY_Code_t Key, uint8_t state)
             uint8_t Channel;
 
             gInputBoxIndex = 0;
+            gKeyInputCountdown = 1;
+            
             Channel = ((gInputBox[0] * 10) + gInputBox[1]) - 1;
 
             if (State == STATE_MR_MODE) {
@@ -313,7 +313,7 @@ static void Key_DIGITS(KEY_Code_t Key, uint8_t state)
                     return;
                 }
             }
-            else if (Channel < 20) {
+            else if (Channel < FM_CHANNELS_MAX) {
 #ifdef ENABLE_VOICE
                 gAnotherVoiceID = (VOICE_ID_t)Key;
 #endif
@@ -341,8 +341,7 @@ static void Key_FUNC(KEY_Code_t Key, uint8_t state)
         bool autoScan = gWasFKeyPressed || (state == BUTTON_EVENT_HELD);
 
         gBeepToPlay           = BEEP_1KHZ_60MS_OPTIONAL;
-        gWasFKeyPressed       = false;
-        gUpdateStatus         = true;
+        HideFKeyIcon();
         gRequestDisplayScreen = DISPLAY_FM;
 
         switch (Key) {
@@ -371,6 +370,14 @@ static void Key_FUNC(KEY_Code_t Key, uint8_t state)
                     gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
                 break;
 
+            case KEY_8:
+                ACTION_BackLightOnDemand();
+                break;
+
+            case KEY_9:
+                ACTION_BackLight();
+                break;
+
             case KEY_STAR:
                 ACTION_Scan(autoScan);
                 break;
@@ -401,6 +408,7 @@ static void Key_EXIT(uint8_t state)
         }
         else {
             gInputBox[--gInputBoxIndex] = 10;
+            gKeyInputCountdown = key_input_timeout_500ms;
 
             if (gInputBoxIndex) {
                 if (gInputBoxIndex != 1) {
@@ -432,14 +440,25 @@ static void Key_EXIT(uint8_t state)
 
 static void Key_MENU(uint8_t state)
 {
-    if (state != BUTTON_EVENT_SHORT)
+    if (state == BUTTON_EVENT_HELD) {
+        ACTION_Handle(KEY_MENU, true, true);
         return;
-
+    }
+    else if (state != BUTTON_EVENT_SHORT) {
+        return;
+    }
 
     gRequestDisplayScreen = DISPLAY_FM;
     gBeepToPlay           = BEEP_1KHZ_60MS_OPTIONAL;
 
+    HideFKeyIcon();
+
     if (gFM_ScanState == FM_SCAN_OFF) {
+        if (gInputBoxIndex) {
+            gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
+            return;
+        }
+
         if (!gEeprom.FM_IsMrMode) {
             if (gAskToSave) {
                 gFM_Channels[gFM_ChannelPosition] = gEeprom.FM_FrequencyPlaying;
@@ -476,6 +495,8 @@ static void Key_MENU(uint8_t state)
 
 static void Key_UP_DOWN(uint8_t state, int8_t Step)
 {
+    HideFKeyIcon();
+
     if (state == BUTTON_EVENT_PRESSED) {
         if (gInputBoxIndex) {
             gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
@@ -487,9 +508,13 @@ static void Key_UP_DOWN(uint8_t state, int8_t Step)
         return;
     }
 
+    if (!gEeprom.SET_NAV) {
+        Step = -Step;
+    }
+
     if (gAskToSave) {
         gRequestDisplayScreen = DISPLAY_FM;
-        gFM_ChannelPosition   = NUMBER_AddWithWraparound(gFM_ChannelPosition, Step, 0, 19);
+        gFM_ChannelPosition   = NUMBER_AddWithWraparound(gFM_ChannelPosition, Step, 0, FM_CHANNELS_MAX - 1);
         return;
     }
 
@@ -515,10 +540,7 @@ static void Key_UP_DOWN(uint8_t state, int8_t Step)
     else {
         uint16_t Frequency = gEeprom.FM_SelectedFrequency + Step;
 
-        if (Frequency < BK1080_GetFreqLoLimit(gEeprom.FM_Band))
-            Frequency = BK1080_GetFreqHiLimit(gEeprom.FM_Band);
-        else if (Frequency > BK1080_GetFreqHiLimit(gEeprom.FM_Band))
-            Frequency = BK1080_GetFreqLoLimit(gEeprom.FM_Band);
+        Frequency = FM_WrapFrequency(Frequency);
 
         gEeprom.FM_FrequencyPlaying  = Frequency;
         gEeprom.FM_SelectedFrequency = gEeprom.FM_FrequencyPlaying;
@@ -547,18 +569,8 @@ void FM_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
             Key_MENU(state);
             break;
         case KEY_UP:
-            #ifdef ENABLE_NAVIG_LEFT_RIGHT
-                Key_UP_DOWN(state, -1);
-            #else
-                Key_UP_DOWN(state, 1);
-            #endif
-            break;
         case KEY_DOWN:
-            #ifdef ENABLE_NAVIG_LEFT_RIGHT
-                Key_UP_DOWN(state, 1);
-            #else
-                Key_UP_DOWN(state, -1);
-            #endif
+            Key_UP_DOWN(state, Key == KEY_UP ? 1 : -1);
             break;
         case KEY_EXIT:
             Key_EXIT(state);
@@ -569,9 +581,14 @@ void FM_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
         case KEY_PTT:
             GENERIC_Key_PTT(bKeyPressed);
             break;
-        default:
-            if (!bKeyHeld && bKeyPressed)
+        case KEY_SIDE1:
+        case KEY_SIDE2:
+            if (state != BUTTON_EVENT_PRESSED) {
                 gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
+                HideFKeyIcon();
+            }
+            break;
+        default:
             break;
     }
 }
@@ -593,10 +610,10 @@ void FM_Play(void)
             return;
         }
 
-        if (gFM_ChannelPosition < 20)
+        if (gFM_ChannelPosition < FM_CHANNELS_MAX)
             gFM_Channels[gFM_ChannelPosition++] = gEeprom.FM_FrequencyPlaying;
 
-        if (gFM_ChannelPosition >= 20) {
+        if (gFM_ChannelPosition >= FM_CHANNELS_MAX) {
             FM_PlayAndUpdate();
             GUI_SelectNextDisplay(DISPLAY_FM);
             return;
@@ -619,6 +636,8 @@ void FM_Start(void)
     gFM_RestoreCountdown_10ms = 0;
 
     BK1080_Init(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/);
+    // Disable UHF LNA, enable VHF LNA
+    BK4819_PickRXFilterPathBasedOnFrequency(10320000); // 103.2 MHz < 280 MHz
 
     AUDIO_AudioPathOn();
 

App/app/fm.h

@@ -20,6 +20,7 @@
 #ifdef ENABLE_FMRADIO
 
 #include "driver/keyboard.h"
+#include "misc.h"
 
 #define FM_CHANNEL_UP   0x01
 #define FM_CHANNEL_DOWN 0xFF
@@ -28,7 +29,7 @@ enum {
     FM_SCAN_OFF = 0U,
 };
 
-extern uint16_t          gFM_Channels[20];
+extern uint16_t          gFM_Channels[FM_CHANNELS_MAX];
 extern bool              gFmRadioMode;
 extern uint8_t           gFmRadioCountdown_500ms;
 extern volatile uint16_t gFmPlayCountdown_10ms;

App/app/generic.c

@@ -39,7 +39,7 @@
 
 void GENERIC_Key_F(bool bKeyPressed, bool bKeyHeld)
 {
-    if (gInputBoxIndex > 0) {
+    if (gInputBoxIndex > 0 || gScreenToDisplay == DISPLAY_MENU) {
         if (!bKeyHeld && bKeyPressed) // short pressed
             gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
         return;

App/app/main.c

@@ -47,6 +47,31 @@
 #include "ui/ui.h"
 #include <stdlib.h>
 
+// Full VFO backup for restore on EXIT
+static VFO_Info_t gVfoBackup;
+static uint16_t   gScreenChannelBackup = 0;
+static uint16_t   gFreqChannelBackup = 0;
+
+static void VFO_RestoreBackup(void) {
+    if (gHasVfoBackup) {
+        const uint8_t Vfo = gEeprom.TX_VFO;
+
+        // Restore indices
+        gEeprom.ScreenChannel[Vfo] = gScreenChannelBackup;
+        gEeprom.FreqChannel[Vfo] = gFreqChannelBackup;
+
+        // Restore full VFO
+        memcpy(gTxVfo, &gVfoBackup, sizeof(VFO_Info_t));
+
+        // Save and apply
+        SETTINGS_SaveVfoIndices();
+        RADIO_ConfigureSquelchAndOutputPower(gTxVfo);
+        RADIO_SetupRegisters(true);
+
+        gHasVfoBackup = false;
+    }
+}
+
 static void toggle_chan_scanlist(void)
 {   // toggle the selected channels scanlist setting
 
@@ -55,31 +80,33 @@ static void toggle_chan_scanlist(void)
 
     if(!IS_MR_CHANNEL(gTxVfo->CHANNEL_SAVE)) {
 #ifdef ENABLE_SCAN_RANGES
-        gScanRangeStart = gScanRangeStart ? 0 : gTxVfo->pRX->Frequency;
-        gScanRangeStop = gEeprom.VfoInfo[!gEeprom.TX_VFO].freq_config_RX.Frequency;
-        if(gScanRangeStart > gScanRangeStop)
-            SWAP(gScanRangeStart, gScanRangeStop);
+        CHFRSCANNER_ScanRange();
 #endif
         return;
     }
     
+    ChannelAttributes_t *att = MR_GetChannelAttributes(gTxVfo->CHANNEL_SAVE);
+
     // Remove exclude
-    if(gMR_ChannelExclude[gTxVfo->CHANNEL_SAVE] == true)
+    if(att->exclude == true)
     {
-        gMR_ChannelExclude[gTxVfo->CHANNEL_SAVE] = false;
-        return;
+        att->exclude = false;
+        MR_SaveChannelAttributesToFlash(gTxVfo->CHANNEL_SAVE, att);
+    } 
+    else 
+    {
+        uint8_t scanlist = gTxVfo->SCANLIST_PARTICIPATION;
+
+        scanlist++;
+
+        if (scanlist > MR_CHANNELS_LIST + 1)
+            scanlist = 0;
+
+        gTxVfo->SCANLIST_PARTICIPATION = scanlist;
+
+        SETTINGS_UpdateChannel(gTxVfo->CHANNEL_SAVE, gTxVfo, true, true, true);
     }
 
-    uint8_t scanTmp = gTxVfo->SCANLIST1_PARTICIPATION | (gTxVfo->SCANLIST2_PARTICIPATION << 1) | (gTxVfo->SCANLIST3_PARTICIPATION << 2);
-
-    scanTmp = (scanTmp++ < 7) ? scanTmp: 0;
-
-    gTxVfo->SCANLIST1_PARTICIPATION = (scanTmp >> 0) & 0x01;
-    gTxVfo->SCANLIST2_PARTICIPATION = (scanTmp >> 1) & 0x01;
-    gTxVfo->SCANLIST3_PARTICIPATION = (scanTmp >> 2) & 0x01;
-
-    SETTINGS_UpdateChannel(gTxVfo->CHANNEL_SAVE, gTxVfo, true, true, true);
-
     gVfoConfigureMode = VFO_CONFIGURE;
     gFlagResetVfos    = true;
 }
@@ -88,16 +115,14 @@ static void processFKeyFunction(const KEY_Code_t Key, const bool beep)
 {
     uint8_t Vfo = gEeprom.TX_VFO;
 
-#ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-    if(gEeprom.MENU_LOCK == true) {
-        if(Key == 2) { // Enable A/B only
-            gVfoConfigureMode     = VFO_CONFIGURE;
-            COMMON_SwitchVFOs();
-            if (beep)
-                gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
-        }
+    if (beep)
+        gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
 
-        return; // prevent F function if MENU LOCK is true
+#ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
+    if(gEeprom.MENU_LOCK == true && Key != 2) {
+        HideFKeyIcon();
+
+        return;
     }
 #endif
 
@@ -105,8 +130,6 @@ static void processFKeyFunction(const KEY_Code_t Key, const bool beep)
         gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
         return;
     }
-    
-    gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
 
     switch (Key) {
         case KEY_0:
@@ -117,9 +140,7 @@ static void processFKeyFunction(const KEY_Code_t Key, const bool beep)
 
         case KEY_1:
             if (!IS_FREQ_CHANNEL(gTxVfo->CHANNEL_SAVE)) {
-                gWasFKeyPressed = false;
-                gUpdateStatus   = true;
-                gBeepToPlay     = BEEP_1KHZ_60MS_OPTIONAL;
+                HideFKeyIcon();
 
 #ifdef ENABLE_COPY_CHAN_TO_VFO
                 if (!gEeprom.VFO_OPEN || gCssBackgroundScan) {
@@ -183,9 +204,6 @@ static void processFKeyFunction(const KEY_Code_t Key, const bool beep)
 
             gRequestDisplayScreen      = DISPLAY_MAIN;
 
-            if (beep)
-                gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
-
             break;
 
         case KEY_2:
@@ -193,8 +211,6 @@ static void processFKeyFunction(const KEY_Code_t Key, const bool beep)
                 gVfoConfigureMode     = VFO_CONFIGURE;
             #endif
             COMMON_SwitchVFOs();
-            if (beep)
-                gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
             break;
 
         case KEY_3:
@@ -202,26 +218,21 @@ static void processFKeyFunction(const KEY_Code_t Key, const bool beep)
                 gVfoConfigureMode     = VFO_CONFIGURE;
             #endif
             COMMON_SwitchVFOMode();
-            if (beep)
-                gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
 
             break;
 
         case KEY_4:
-            gWasFKeyPressed          = false;
+            HideFKeyIcon();
 
             gBackup_CROSS_BAND_RX_TX  = gEeprom.CROSS_BAND_RX_TX;
-            gEeprom.CROSS_BAND_RX_TX = CROSS_BAND_OFF;
-            gUpdateStatus            = true;        
-            if (beep)
-                gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
+            gEeprom.CROSS_BAND_RX_TX = CROSS_BAND_OFF;     
 
             SCANNER_Start(false);
             gRequestDisplayScreen = DISPLAY_SCANNER;
             break;
 
         case KEY_5:
-            if(beep) {
+            if(!beep) {
 #ifdef ENABLE_NOAA
                 if (!IS_NOAA_CHANNEL(gTxVfo->CHANNEL_SAVE)) {
                     gEeprom.ScreenChannel[Vfo] = gEeprom.NoaaChannel[gEeprom.TX_VFO];
@@ -282,47 +293,53 @@ static void processFKeyFunction(const KEY_Code_t Key, const bool beep)
 
 #ifdef ENABLE_FEAT_F4HWN // Set Squelch F + UP or Down and Step F + SIDE1 or F + SIDE2
         case KEY_UP:
-            gEeprom.SQUELCH_LEVEL = (gEeprom.SQUELCH_LEVEL < 9) ? gEeprom.SQUELCH_LEVEL + 1: 9;
-            gVfoConfigureMode     = VFO_CONFIGURE;
-            gWasFKeyPressed = false;
-            break;
         case KEY_DOWN:
-            gEeprom.SQUELCH_LEVEL = (gEeprom.SQUELCH_LEVEL > 0) ? gEeprom.SQUELCH_LEVEL - 1: 0;
-            gVfoConfigureMode     = VFO_CONFIGURE;
-            gWasFKeyPressed = false;
-            break;
+            {
+                bool isKeyUp = (Key == KEY_UP);
 
+                if (gScanStateDir != SCAN_OFF) {
+                    RADIO_NextValidList(isKeyUp ? 1 : -1);
+                } 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;
+                    } else {
+                        gEeprom.SQUELCH_LEVEL = (gEeprom.SQUELCH_LEVEL > 0) ? gEeprom.SQUELCH_LEVEL - 1 : 0;
+                    }
+                    gVfoConfigureMode = VFO_CONFIGURE;
+                }
+
+                gWasFKeyPressed = false;
+
+                break;
+            }
         case KEY_SIDE1:
-            uint8_t a = FREQUENCY_GetSortedIdxFromStepIdx(gTxVfo->STEP_SETTING);
-            if (a < STEP_N_ELEM - 1)
-            {
-                gTxVfo->STEP_SETTING = FREQUENCY_GetStepIdxFromSortedIdx(a + 1);
-            }
-            if (IS_FREQ_CHANNEL(gTxVfo->CHANNEL_SAVE))
-            {
-                gRequestSaveChannel = 1;
-            }
-            gVfoConfigureMode     = VFO_CONFIGURE;
-            gWasFKeyPressed = false;
-            break;
         case KEY_SIDE2:
-            uint8_t b = FREQUENCY_GetSortedIdxFromStepIdx(gTxVfo->STEP_SETTING);
-            if (b > 0)
             {
-                gTxVfo->STEP_SETTING = FREQUENCY_GetStepIdxFromSortedIdx(b - 1);
+                bool isKeySide1 = (Key == KEY_SIDE1);
+                uint8_t idx = FREQUENCY_GetSortedIdxFromStepIdx(gTxVfo->STEP_SETTING);
+
+                if ((isKeySide1 && idx < STEP_N_ELEM - 1) || (!isKeySide1 && idx > 0)) 
+                {
+                    gTxVfo->STEP_SETTING = FREQUENCY_GetStepIdxFromSortedIdx(idx + (isKeySide1 ? 1 : -1));
+                    
+                    if (IS_FREQ_CHANNEL(gTxVfo->CHANNEL_SAVE)) {
+                        gRequestSaveChannel = 1;
+                    }
+                    gVfoConfigureMode = VFO_CONFIGURE;
+                }
+                
+                gWasFKeyPressed = false;
+
+                break;
             }
-            if (IS_FREQ_CHANNEL(gTxVfo->CHANNEL_SAVE))
-            {
-                gRequestSaveChannel = 1;
-            }
-            gVfoConfigureMode     = VFO_CONFIGURE;
-            gWasFKeyPressed = false;
-            break;
 #endif
 
         default:
-            gUpdateStatus   = true;
-            gWasFKeyPressed = false;
+            HideFKeyIcon();
 
             if (beep)
                 gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
@@ -348,8 +365,8 @@ void channelMove(uint16_t Channel)
         gAnotherVoiceID        = (VOICE_ID_t)Key;
     #endif
 
-    gEeprom.MrChannel[Vfo]     = (uint8_t)Channel;
-    gEeprom.ScreenChannel[Vfo] = (uint8_t)Channel;
+    gEeprom.MrChannel[Vfo]     = (uint16_t)Channel;
+    gEeprom.ScreenChannel[Vfo] = (uint16_t)Channel;
     //gRequestSaveVFO            = true;
     gVfoConfigureMode          = VFO_CONFIGURE_RELOAD;
 
@@ -359,6 +376,8 @@ void channelMove(uint16_t Channel)
 #endif
 
     RADIO_ConfigureChannel(gEeprom.TX_VFO, gVfoConfigureMode);
+
+    SETTINGS_SaveVfoIndices();
     
     return;
 }
@@ -386,21 +405,17 @@ void channelMoveSwitch(void) {
             Channel = (Channel * 10) + gInputBox[i];
         }
 
-        if ((Channel == 0) && (gInputBoxIndex != 3)) {
+        if ((Channel == 0) && (gInputBoxIndex != 4)) {
             return;
         }
 
-        if (gInputBoxIndex == 3) {
+        if (gInputBoxIndex == 4) {
             gInputBoxIndex = 0;
             gKeyInputCountdown = 1;
-
-            channelMove(Channel - 1);
-            SETTINGS_SaveVfoIndices();
-            
-            return;
         }
 
         channelMove(Channel - 1);
+        SETTINGS_SaveVfoIndices();
     }
 }
 
@@ -414,10 +429,9 @@ static void MAIN_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
                     gRequestDisplayScreen = DISPLAY_MAIN;
                 }
 
-                gWasFKeyPressed = false;
-                gUpdateStatus   = true;
+                HideFKeyIcon();
 
-                processFKeyFunction(Key, false);
+                processFKeyFunction(Key, true);
             }
         }
         return;
@@ -432,8 +446,15 @@ static void MAIN_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
     if (!gWasFKeyPressed) { // F-key wasn't pressed
 
         if (gScanStateDir != SCAN_OFF){
+            /*
             switch(Key) {
-                case KEY_0...KEY_5:
+                case KEY_0:
+                    gEeprom.SCAN_LIST_DEFAULT = MR_CHANNELS_LIST + 1;
+                    #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
+                        SETTINGS_WriteCurrentState();
+                    #endif
+                    break;
+                case KEY_1...KEY_9:
                     gEeprom.SCAN_LIST_DEFAULT = Key;
                     #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
                         SETTINGS_WriteCurrentState();
@@ -443,9 +464,60 @@ static void MAIN_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
                     break;
             }
             return;
+            */
+
+            INPUTBOX_Append(Key);
+
+            /* Wait until exactly two digits are entered */
+            if (gInputBoxIndex < 2)
+                return;
+
+            /* Two digits entered */
+            gInputBoxIndex = 0;
+
+            uint8_t value = (gInputBox[0] * 10) + gInputBox[1];
+
+            /* 00 = ALL scan lists */
+            if (value == 0)
+            {
+                gEeprom.SCAN_LIST_DEFAULT = MR_CHANNELS_LIST + 1;
+            #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
+                SETTINGS_WriteCurrentState();
+            #endif
+                return;
+            }
+
+            /* 01 .. MR_CHANNELS_LIST */
+            if (value <= MR_CHANNELS_LIST)
+            {
+                gEeprom.SCAN_LIST_DEFAULT = value;
+
+                if (!RADIO_CheckValidList(value))
+                {
+                    /* Requested scan list is empty or invalid:
+                        jump to the next valid scan list */
+                    gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
+                    RADIO_NextValidList(1);
+                }
+
+            #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
+                SETTINGS_WriteCurrentState();
+            #endif
+            }
+
+            return;
         }
 
         const uint8_t Vfo = gEeprom.TX_VFO;
+
+        // Save full VFO state BEFORE first digit
+        if (gInputBoxIndex == 0 && IS_FREQ_CHANNEL(gTxVfo->CHANNEL_SAVE)) {
+            memcpy(&gVfoBackup, gTxVfo, sizeof(VFO_Info_t));
+            gScreenChannelBackup = gEeprom.ScreenChannel[Vfo];
+            gFreqChannelBackup = gEeprom.FreqChannel[Vfo];
+            gHasVfoBackup = true;
+        }
+
         INPUTBOX_Append(Key);
         gKeyInputCountdown = key_input_timeout_500ms;
 
@@ -483,7 +555,13 @@ 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 = (gInputBoxIndex >= totalDigits) ? (key_input_timeout_500ms / 16) : (key_input_timeout_500ms / 3);
+
+            if (gInputBoxIndex > totalDigits) {
+                gInputBoxIndex =  totalDigits;
+
+                return;
+            }
 
             const char *inputStr = INPUTBOX_GetAscii();
             uint8_t inputLength = gInputBoxIndex;
@@ -552,6 +630,7 @@ static void MAIN_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
                 }
 
                 gInputBoxIndex = 0;
+                gHasVfoBackup = false;
 
                 uint8_t Channel = (gInputBox[0] * 10) + gInputBox[1];
                 if (Channel >= 1 && Channel <= ARRAY_SIZE(NoaaFrequencyTable)) {
@@ -573,8 +652,13 @@ static void MAIN_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
         return;
     }
 
-    gWasFKeyPressed = false;
-    gUpdateStatus   = true;
+    HideFKeyIcon();
+
+    #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
+        if(gEeprom.MENU_LOCK == true && Key != 2) {
+            return;
+        }
+    #endif
 
     if(Key == 8)
     {
@@ -589,79 +673,80 @@ static void MAIN_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
     #ifdef ENABLE_FEAT_F4HWN_GAME
     else if(Key == 7)
     {
-        #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-            if(gEeprom.MENU_LOCK == true) {
-                return;
-            }
-        #endif
         APP_RunBreakout();
         return;
     }
     #endif
 
-    processFKeyFunction(Key, true);
+    processFKeyFunction(Key, false);
 }
 
 static void MAIN_Key_EXIT(bool bKeyPressed, bool bKeyHeld)
 {
     if (!bKeyHeld && bKeyPressed) { // exit key pressed
-        gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
+        gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;  // beep when key is pressed
+        return;                                 // don't use the key till it's released
+    }
 
-#ifdef ENABLE_DTMF_CALLING
-        if (gDTMF_CallState != DTMF_CALL_STATE_NONE && gCurrentFunction != FUNCTION_TRANSMIT)
-        {   // clear CALL mode being displayed
-            gDTMF_CallState = DTMF_CALL_STATE_NONE;
-            gUpdateDisplay  = true;
-            return;
-        }
-#endif
-
-#ifdef ENABLE_FMRADIO
-        if (!gFmRadioMode)
-#endif
-        {
-            if (gScanStateDir == SCAN_OFF) {
-                if (gInputBoxIndex == 0)
-                    return;
-                gInputBox[--gInputBoxIndex] = 10;
-
-                gKeyInputCountdown = key_input_timeout_500ms;
-
-#ifdef ENABLE_VOICE
-                if (gInputBoxIndex == 0)
-                    gAnotherVoiceID = VOICE_ID_CANCEL;
-#endif
-            }
-            else {
-                gScanKeepResult = false;
-                CHFRSCANNER_Stop();
-
-#ifdef ENABLE_VOICE
-                gAnotherVoiceID = VOICE_ID_SCANNING_STOP;
-#endif
-            }
+    if (bKeyHeld) { // exit key held down
+        if (bKeyPressed) {
+            // Restore full VFO state on long press EXIT
+            VFO_RestoreBackup();
 
             gRequestDisplayScreen = DISPLAY_MAIN;
-            return;
         }
 
-#ifdef ENABLE_FMRADIO
-        ACTION_FM();
-#endif
         return;
     }
 
-    if (bKeyHeld && bKeyPressed) { // exit key held down
-        if (gInputBoxIndex > 0 || gDTMF_InputBox_Index > 0 || gDTMF_InputMode)
-        {   // cancel key input mode (channel/frequency entry)
-            gDTMF_InputMode       = false;
-            gDTMF_InputBox_Index  = 0;
-            memset(gDTMF_String, 0, sizeof(gDTMF_String));
-            gInputBoxIndex        = 0;
-            gRequestDisplayScreen = DISPLAY_MAIN;
-            gBeepToPlay           = BEEP_1KHZ_60MS_OPTIONAL;
-        }
+#ifdef ENABLE_DTMF_CALLING
+    if (gDTMF_CallState != DTMF_CALL_STATE_NONE && gCurrentFunction != FUNCTION_TRANSMIT)
+    {   // clear CALL mode being displayed
+        gDTMF_CallState = DTMF_CALL_STATE_NONE;
+        gUpdateDisplay  = true;
+        return;
     }
+#endif
+
+#ifdef ENABLE_FMRADIO
+    if (!gFmRadioMode)
+#endif
+    {
+        if (gScanStateDir == SCAN_OFF) {
+            if (gInputBoxIndex == 0)
+                return;
+            gInputBox[--gInputBoxIndex] = 10;
+
+            // Restore full VFO state when back to 0
+            if (gInputBoxIndex == 0)
+                VFO_RestoreBackup();
+
+            gKeyInputCountdown = key_input_timeout_500ms;
+            channelMoveSwitch();
+
+#ifdef ENABLE_VOICE
+            if (gInputBoxIndex == 0)
+                gAnotherVoiceID = VOICE_ID_CANCEL;
+#endif
+        }
+        else {
+            gScanKeepResult = false;
+            gInputBoxIndex = 0;
+            CHFRSCANNER_Stop();
+
+#ifdef ENABLE_VOICE
+            gAnotherVoiceID = VOICE_ID_SCANNING_STOP;
+#endif
+        }
+
+        gRequestDisplayScreen = DISPLAY_MAIN;
+        return;
+    }
+
+#ifdef ENABLE_FMRADIO
+    ACTION_FM();
+#endif
+    return;
 }
 
 static void MAIN_Key_MENU(bool bKeyPressed, bool bKeyHeld)
@@ -673,12 +758,15 @@ static void MAIN_Key_MENU(bool bKeyPressed, bool bKeyHeld)
         if (bKeyPressed) { // long press MENU key
 
             #ifdef ENABLE_FEAT_F4HWN
-            // Exclude work with list 1, 2, 3 or all list
+            // Exclude channel
             if(gScanStateDir != SCAN_OFF)
             {
                 if(FUNCTION_IsRx() || gScanPauseDelayIn_10ms > 9)
                 {
-                    gMR_ChannelExclude[gTxVfo->CHANNEL_SAVE] = true;
+                    ChannelAttributes_t *att = MR_GetChannelAttributes(lastFoundFrqOrChan);
+                    att->exclude = true;
+
+                    MR_SaveChannelAttributesToFlash(lastFoundFrqOrChan, att);
 
                     gVfoConfigureMode = VFO_CONFIGURE;
                     gFlagResetVfos    = true;
@@ -700,7 +788,6 @@ static void MAIN_Key_MENU(bool bKeyPressed, bool bKeyHeld)
                     gRequestDisplayScreen = DISPLAY_MAIN;
                 }
 
-                gWasFKeyPressed = false;
                 gUpdateStatus   = true;
 
                 ACTION_Handle(KEY_MENU, bKeyPressed, bKeyHeld);
@@ -711,6 +798,9 @@ static void MAIN_Key_MENU(bool bKeyPressed, bool bKeyHeld)
     }
 
     if (!bKeyPressed && !gDTMF_InputMode) { // menu key released
+        gKeyInputCountdown = 1;
+        channelMoveSwitch();
+
         const bool bFlag = !gInputBoxIndex;
         gInputBoxIndex   = 0;
 
@@ -721,7 +811,11 @@ static void MAIN_Key_MENU(bool bKeyPressed, bool bKeyHeld)
             }
 
             #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-            if(gEeprom.MENU_LOCK == false) {
+                if(gEeprom.MENU_LOCK == true) {
+                    HideFKeyIcon();
+
+                    return;
+                }
             #endif
 
             gFlagRefreshSetting = true;
@@ -729,10 +823,6 @@ static void MAIN_Key_MENU(bool bKeyPressed, bool bKeyHeld)
             #ifdef ENABLE_VOICE
                 gAnotherVoiceID   = VOICE_ID_MENU;
             #endif
-
-            #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-            }
-            #endif
         }
         else {
             gRequestDisplayScreen = DISPLAY_MAIN;
@@ -742,13 +832,6 @@ static void MAIN_Key_MENU(bool bKeyPressed, bool bKeyHeld)
 
 static void MAIN_Key_STAR(bool bKeyPressed, bool bKeyHeld)
 {
-
-#ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-    if(gEeprom.MENU_LOCK == true) {
-        return; // prevent F function if MENU LOCK is true
-    }
-#endif
-
     if (gCurrentFunction == FUNCTION_TRANSMIT)
         return;
     
@@ -758,6 +841,19 @@ static void MAIN_Key_STAR(bool bKeyPressed, bool bKeyHeld)
         return;
     }
 
+    if (!bKeyHeld && bKeyPressed) { // star key pressed
+        gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;  // beep when key is pressed
+        return;                                 // don't use the key till it's released
+    }
+
+    #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
+        if(gEeprom.MENU_LOCK == true) {
+            HideFKeyIcon();
+
+            return; // prevent F function if MENU LOCK is true
+        }
+    #endif
+
     if (bKeyHeld && !gWasFKeyPressed){ // long press
         if (!bKeyPressed) // released
             return; 
@@ -780,12 +876,6 @@ static void MAIN_Key_STAR(bool bKeyPressed, bool bKeyHeld)
         gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
         return;
     }
-
-    if (bKeyPressed) { // just pressed
-        return;
-    }
-    
-    // just released
     
     if (!gWasFKeyPressed) // pressed without the F-key
     {   
@@ -798,7 +888,6 @@ static void MAIN_Key_STAR(bool bKeyPressed, bool bKeyHeld)
 #endif      
         )
         {   // start entering a DTMF string
-            gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
             memcpy(gDTMF_InputBox, gDTMF_String, MIN(sizeof(gDTMF_InputBox), sizeof(gDTMF_String) - 1));
             gDTMF_InputBox_Index  = 0;
             gDTMF_InputMode       = true;
@@ -834,18 +923,13 @@ static void MAIN_Key_STAR(bool bKeyPressed, bool bKeyHeld)
 
 static void MAIN_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
 {
+    if (!gEeprom.SET_NAV) {
+        Direction = -Direction;
+    }
 
 #ifdef ENABLE_FEAT_F4HWN // Set Squelch F + UP or Down
     if(gWasFKeyPressed) {
-        switch(Direction)
-        {
-            case 1:
-                processFKeyFunction(KEY_UP, false);
-                break;
-            case -1:
-                processFKeyFunction(KEY_DOWN, false);
-                break;
-        }
+        processFKeyFunction(Direction == 1 ? KEY_UP : KEY_DOWN, true);
         return;
     }
 #endif
@@ -855,11 +939,13 @@ static void MAIN_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
     gPowerHigh = false;
 #endif
 
-    uint8_t Channel = gEeprom.ScreenChannel[gEeprom.TX_VFO];
+    uint16_t Channel = gEeprom.ScreenChannel[gEeprom.TX_VFO];
 
     if (bKeyHeld || !bKeyPressed) { // key held or released
-        if (gInputBoxIndex > 0)
-            return; // leave if input box active
+        if (gInputBoxIndex > 0) {
+            gInputBoxIndex = 0;
+            gHasVfoBackup = false;
+        }
 
         if (!bKeyPressed) {
             if (!bKeyHeld || IS_FREQ_CHANNEL(Channel))
@@ -873,10 +959,6 @@ static void MAIN_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
         }
     }
     else { // short pressed
-        if (gInputBoxIndex > 0) {
-            gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
-            return;
-        }
         gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
     }
 
@@ -885,7 +967,7 @@ static void MAIN_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
         if (!IS_NOAA_CHANNEL(Channel))
 #endif
         {
-            uint8_t Next;
+            uint16_t Next;
             if (IS_FREQ_CHANNEL(Channel)) { // step/down in frequency
                 const uint32_t frequency = APP_SetFrequencyByStep(gTxVfo, Direction);
 
@@ -901,7 +983,7 @@ static void MAIN_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
             }
 
             Next = RADIO_FindNextChannel(Channel + Direction, Direction, false, 0);
-            if (Next == 0xFF)
+            if (Next == 0xFFFF)
                 return;
             if (Channel == Next)
                 return;
@@ -977,18 +1059,8 @@ void MAIN_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
             MAIN_Key_MENU(bKeyPressed, bKeyHeld);
             break;
         case KEY_UP:
-            #ifdef ENABLE_NAVIG_LEFT_RIGHT
-                MAIN_Key_UP_DOWN(bKeyPressed, bKeyHeld, -1);            
-            #else
-                MAIN_Key_UP_DOWN(bKeyPressed, bKeyHeld, 1);
-            #endif
-            break;
         case KEY_DOWN:
-            #ifdef ENABLE_NAVIG_LEFT_RIGHT
-                MAIN_Key_UP_DOWN(bKeyPressed, bKeyHeld, 1);
-            #else
-                MAIN_Key_UP_DOWN(bKeyPressed, bKeyHeld, -1);
-            #endif
+            MAIN_Key_UP_DOWN(bKeyPressed, bKeyHeld, Key == KEY_UP ? 1 : -1);
             break;
         case KEY_EXIT:
             MAIN_Key_EXIT(bKeyPressed, bKeyHeld);
@@ -1007,4 +1079,4 @@ void MAIN_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
                 gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
             break;
     }
-}
+}

App/app/menu.c

@@ -34,6 +34,7 @@
 #include "helper/battery.h"
 #include "misc.h"
 #include "settings.h"
+#include "../driver/st7565.h"
 #if defined(ENABLE_OVERLAY)
     #include "sram-overlay.h"
 #endif
@@ -41,9 +42,6 @@
 #include "ui/menu.h"
 #include "ui/ui.h"
 
-#ifndef ARRAY_SIZE
-    #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
-#endif
 
 uint8_t gUnlockAllTxConfCnt;
 
@@ -234,9 +232,6 @@ int MENU_GetLimits(uint8_t menu_id, int32_t *pMin, int32_t *pMax)
         #endif
         case MENU_BCL:
         case MENU_BEEP:
-        case MENU_S_ADD1:
-        case MENU_S_ADD2:
-        case MENU_S_ADD3:
         case MENU_STE:
         case MENU_D_ST:
 #ifdef ENABLE_DTMF_CALLING
@@ -257,6 +252,7 @@ int MENU_GetLimits(uint8_t menu_id, int32_t *pMin, int32_t *pMax)
 #endif
 #ifdef ENABLE_FEAT_F4HWN
         case MENU_SET_TMR:
+        case MENU_S_PRI:
 #endif
             //*pMin = 0;
             *pMax = ARRAY_SIZE(gSubMenu_OFF_ON) - 1;
@@ -299,11 +295,10 @@ int MENU_GetLimits(uint8_t menu_id, int32_t *pMin, int32_t *pMax)
             *pMax = MR_CHANNEL_LAST;
             break;
 
-        case MENU_SLIST1:
-        case MENU_SLIST2:
-        case MENU_SLIST3:
-            *pMin = -1;
-            *pMax = MR_CHANNEL_LAST;
+        case MENU_S_PRI_CH_1:
+        case MENU_S_PRI_CH_2:
+            //*pMin = 0;
+            *pMax = MR_CHANNEL_LAST + 2;
             break;
 
         case MENU_SAVE:
@@ -313,12 +308,17 @@ int MENU_GetLimits(uint8_t menu_id, int32_t *pMin, int32_t *pMax)
 
         case MENU_MIC:
             //*pMin = 0;
-            *pMax = 4;
+            *pMax = 8;
+            break;
+
+        case MENU_LIST_CH:
+            //*pMin = 0;
+            *pMax = MR_CHANNELS_LIST + 1;
             break;
 
         case MENU_S_LIST:
-            //*pMin = 0;
-            *pMax = 5;
+            *pMin = 1;
+            *pMax = MR_CHANNELS_LIST + 1;
             break;
 
 #ifdef ENABLE_DTMF_CALLING
@@ -371,6 +371,11 @@ int MENU_GetLimits(uint8_t menu_id, int32_t *pMin, int32_t *pMax)
             *pMax = 4;
             break;
 
+        case MENU_SET_NAV:
+            //*pMin = 0;
+            *pMax = 1;
+            break;
+
         case MENU_F1SHRT:
         case MENU_F1LONG:
         case MENU_F2SHRT:
@@ -399,19 +404,19 @@ int MENU_GetLimits(uint8_t menu_id, int32_t *pMin, int32_t *pMax)
             //*pMin = 0;
             *pMax = ARRAY_SIZE(gSubMenu_SET_TOT) - 1;
             break;
-#ifdef ENABLE_FEAT_F4HWN_CTR
+        #ifdef ENABLE_FEAT_F4HWN_CTR
         case MENU_SET_CTR:
             *pMin = 1;
             *pMax = 15;
             break;
-#endif
+        #endif
         case MENU_TX_LOCK:
-#ifdef ENABLE_FEAT_F4HWN_INV
+        #ifdef ENABLE_FEAT_F4HWN_INV
         case MENU_SET_INV:
             //*pMin = 0;
             *pMax = ARRAY_SIZE(gSubMenu_OFF_ON) - 1;
             break;
-#endif
+        #endif
         case MENU_SET_LCK:
             //*pMin = 0;
             *pMax = ARRAY_SIZE(gSubMenu_SET_LCK) - 1;
@@ -421,6 +426,17 @@ 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_AUDIO
+        case MENU_SET_AUD:
+            //*pMin = 0;
+            if(gTxVfo->Modulation == MODULATION_AM)
+                *pMax = ARRAY_SIZE(gSubMenu_SET_AUD_AM) - 1;
+            else if (gTxVfo->Modulation == MODULATION_USB)
+                *pMax = 0;
+            else
+                *pMax = ARRAY_SIZE(gSubMenu_SET_AUD_FM) - 1;
+            break;
+        #endif
         #ifdef ENABLE_FEAT_F4HWN_NARROWER
             case MENU_SET_NFM:
                 //*pMin = 0;
@@ -469,6 +485,9 @@ void MENU_AcceptSetting(void)
         case MENU_SQL:
             gEeprom.SQUELCH_LEVEL = gSubMenuSelection;
             gVfoConfigureMode     = VFO_CONFIGURE;
+            #ifdef ENABLE_FEAT_F4HWN
+                gSquelchLevelOriginal = 10;
+            #endif
             break;
 
         case MENU_STEP:
@@ -583,6 +602,14 @@ void MENU_AcceptSetting(void)
             SETTINGS_SaveChannelName(gSubMenuSelection, edit);
             return;
 
+        case MENU_S_PRI_CH_1:
+            gEeprom.SCANLIST_PRIORITY_CH[0] = gSubMenuSelection;
+            break;
+
+        case MENU_S_PRI_CH_2:
+            gEeprom.SCANLIST_PRIORITY_CH[1] = gSubMenuSelection;
+            break;
+
         case MENU_SAVE:
             gEeprom.BATTERY_SAVE = gSubMenuSelection;
             break;
@@ -661,22 +688,8 @@ void MENU_AcceptSetting(void)
             gKeyLockCountdown        = gEeprom.AUTO_KEYPAD_LOCK * 30; // 15 seconds step
             break;
 
-        case MENU_S_ADD1:
-            gTxVfo->SCANLIST1_PARTICIPATION = gSubMenuSelection;
-            SETTINGS_UpdateChannel(gTxVfo->CHANNEL_SAVE, gTxVfo, true, false, true);
-            gVfoConfigureMode = VFO_CONFIGURE;
-            gFlagResetVfos    = true;
-            return;
-
-        case MENU_S_ADD2:
-            gTxVfo->SCANLIST2_PARTICIPATION = gSubMenuSelection;
-            SETTINGS_UpdateChannel(gTxVfo->CHANNEL_SAVE, gTxVfo, true, false, true);
-            gVfoConfigureMode = VFO_CONFIGURE;
-            gFlagResetVfos    = true;
-            return;
-
-        case MENU_S_ADD3:
-            gTxVfo->SCANLIST3_PARTICIPATION = gSubMenuSelection;
+        case MENU_LIST_CH:
+            gTxVfo->SCANLIST_PARTICIPATION = gSubMenuSelection;
             SETTINGS_UpdateChannel(gTxVfo->CHANNEL_SAVE, gTxVfo, true, false, true);
             gVfoConfigureMode = VFO_CONFIGURE;
             gFlagResetVfos    = true;
@@ -718,6 +731,10 @@ void MENU_AcceptSetting(void)
             gEeprom.SCAN_LIST_DEFAULT = gSubMenuSelection;
             break;
 
+        case MENU_S_PRI:
+            gEeprom.SCAN_LIST_ENABLED = gSubMenuSelection;
+            break;
+
         #ifdef ENABLE_ALARM
             case MENU_AL_MOD:
                 gEeprom.ALARM_MODE = gSubMenuSelection;
@@ -877,11 +894,11 @@ void MENU_AcceptSetting(void)
         #endif
 
         case MENU_BATCAL:
-        {                                                                // voltages are averages between discharge curves of 1600 and 2200 mAh
+        {                                                                   // voltages are averages between discharge curves of 1600 and 2200 mAh
             // gBatteryCalibration[0] = (520ul * gSubMenuSelection) / 760;  // 5.20V empty, blinking above this value, reduced functionality below
             // gBatteryCalibration[1] = (689ul * gSubMenuSelection) / 760;  // 6.89V,  ~5%, 1 bars above this value
             // gBatteryCalibration[2] = (724ul * gSubMenuSelection) / 760;  // 7.24V, ~17%, 2 bars above this value
-            gBatteryCalibration[3] =          gSubMenuSelection;         // 7.6V,  ~29%, 3 bars above this value
+            gBatteryCalibration[3] =          gSubMenuSelection;            // 7.6V,  ~29%, 3 bars above this value
             // gBatteryCalibration[4] = (771ul * gSubMenuSelection) / 760;  // 7.71V, ~65%, 4 bars above this value
             // gBatteryCalibration[5] = 2300;
             SETTINGS_SaveBatteryCalibration(gBatteryCalibration);
@@ -892,6 +909,10 @@ void MENU_AcceptSetting(void)
             gEeprom.BATTERY_TYPE = gSubMenuSelection;
             break;
 
+        case MENU_SET_NAV:
+            gEeprom.SET_NAV = gSubMenuSelection;
+            break;
+
         case MENU_F1SHRT:
         case MENU_F1LONG:
         case MENU_F2SHRT:
@@ -929,11 +950,11 @@ void MENU_AcceptSetting(void)
         case MENU_SET_EOT:
             gSetting_set_eot = gSubMenuSelection;
             break;
-#ifdef ENABLE_FEAT_F4HWN_CTR
+        #ifdef ENABLE_FEAT_F4HWN_CTR
         case MENU_SET_CTR:
             gSetting_set_ctr = gSubMenuSelection;
             break;
-#endif
+        #endif
         case MENU_SET_INV:
             gSetting_set_inv = gSubMenuSelection;
             break;
@@ -946,6 +967,16 @@ void MENU_AcceptSetting(void)
         case MENU_SET_GUI:
             gSetting_set_gui = gSubMenuSelection;
             break;
+        #ifdef ENABLE_FEAT_F4HWN_AUDIO
+        case MENU_SET_AUD:
+            if(gTxVfo->Modulation == MODULATION_AM)
+                gSetting_set_audio_am = gSubMenuSelection;
+            else if (gTxVfo->Modulation == MODULATION_FM)
+                gSetting_set_audio_fm = gSubMenuSelection;
+
+            RADIO_SetModulation(gTxVfo->Modulation);
+            break;
+        #endif
         #ifdef ENABLE_FEAT_F4HWN_NARROWER
             case MENU_SET_NFM:
                 gSetting_set_nfm = gSubMenuSelection;
@@ -1163,16 +1194,8 @@ void MENU_ShowCurrentSetting(void)
             gSubMenuSelection = gEeprom.AUTO_KEYPAD_LOCK;
             break;
 
-        case MENU_S_ADD1:
-            gSubMenuSelection = gTxVfo->SCANLIST1_PARTICIPATION;
-            break;
-
-        case MENU_S_ADD2:
-            gSubMenuSelection = gTxVfo->SCANLIST2_PARTICIPATION;
-            break;
-
-        case MENU_S_ADD3:
-            gSubMenuSelection = gTxVfo->SCANLIST3_PARTICIPATION;
+        case MENU_LIST_CH:
+            gSubMenuSelection = gTxVfo->SCANLIST_PARTICIPATION;
             break;
 
         case MENU_STE:
@@ -1205,10 +1228,16 @@ void MENU_ShowCurrentSetting(void)
             gSubMenuSelection = gEeprom.SCAN_LIST_DEFAULT;
             break;
 
-        case MENU_SLIST1:
-        case MENU_SLIST2:
-        case MENU_SLIST3:
-            gSubMenuSelection = RADIO_FindNextChannel(0, 1, true, UI_MENU_GetCurrentMenuId() - MENU_SLIST1 + 1);
+        case MENU_S_PRI:
+            gSubMenuSelection = gEeprom.SCAN_LIST_ENABLED;
+            break;
+
+        case MENU_S_PRI_CH_1:
+            gSubMenuSelection = gEeprom.SCANLIST_PRIORITY_CH[0];
+            break;
+
+        case MENU_S_PRI_CH_2:
+            gSubMenuSelection = gEeprom.SCANLIST_PRIORITY_CH[1];
             break;
 
         #ifdef ENABLE_ALARM
@@ -1333,6 +1362,10 @@ void MENU_ShowCurrentSetting(void)
             gSubMenuSelection = gEeprom.BATTERY_TYPE;
             break;
 
+        case MENU_SET_NAV:
+            gSubMenuSelection = gEeprom.SET_NAV;
+            break;
+
         case MENU_F1SHRT:
         case MENU_F1LONG:
         case MENU_F2SHRT:
@@ -1376,11 +1409,11 @@ void MENU_ShowCurrentSetting(void)
         case MENU_SET_EOT:
             gSubMenuSelection = gSetting_set_eot;
             break;
-#ifdef ENABLE_FEAT_F4HWN_CTR
+        #ifdef ENABLE_FEAT_F4HWN_CTR
         case MENU_SET_CTR:
             gSubMenuSelection = gSetting_set_ctr;
             break;
-#endif
+        #endif
         case MENU_SET_INV:
             gSubMenuSelection = gSetting_set_inv;
             break;
@@ -1393,6 +1426,16 @@ void MENU_ShowCurrentSetting(void)
         case MENU_SET_GUI:
             gSubMenuSelection = gSetting_set_gui;
             break;
+        #ifdef ENABLE_FEAT_F4HWN_AUDIO
+        case MENU_SET_AUD:
+            if(gTxVfo->Modulation == MODULATION_AM)
+                gSubMenuSelection = gSetting_set_audio_am;
+            else if (gTxVfo->Modulation == MODULATION_USB)
+                gSubMenuSelection = 0;
+            else
+                gSubMenuSelection = gSetting_set_audio_fm;
+            break;
+        #endif
         #ifdef ENABLE_FEAT_F4HWN_NARROWER
             case MENU_SET_NFM:
                 gSubMenuSelection = gSetting_set_nfm;
@@ -1521,13 +1564,17 @@ static void MENU_Key_0_to_9(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
         return;
     }
 
-    if (UI_MENU_GetCurrentMenuId() == MENU_MEM_CH ||
-        UI_MENU_GetCurrentMenuId() == MENU_DEL_CH ||
-        UI_MENU_GetCurrentMenuId() == MENU_1_CALL ||
-        UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME)
-    {   // enter 3-digit channel number
+    const int m = UI_MENU_GetCurrentMenuId();
 
-        if (gInputBoxIndex < 3)
+    if (m == MENU_MEM_CH ||
+        m == MENU_DEL_CH ||
+        m == MENU_1_CALL ||
+        m == MENU_S_PRI_CH_1 ||
+        m == MENU_S_PRI_CH_2 ||
+        m == MENU_MEM_NAME)
+    {   // enter 4-digit channel number
+
+        if (gInputBoxIndex < 4)
         {
             #ifdef ENABLE_VOICE
                 gAnotherVoiceID   = (VOICE_ID_t)Key;
@@ -1538,7 +1585,8 @@ 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] * 100) + (gInputBox[1] * 10) + gInputBox[2]) - 1;
+        Value = ((gInputBox[0] * 1000) + (gInputBox[1] * 100) + (gInputBox[2] * 10) + gInputBox[3]) - 1;
 
         if (IS_MR_CHANNEL(Value))
         {
@@ -1663,19 +1711,21 @@ static void MENU_Key_MENU(const bool bKeyPressed, const bool bKeyHeld)
 
     if (!gIsInSubMenu)
     {
+        const int m = UI_MENU_GetCurrentMenuId();
+
         #ifdef ENABLE_VOICE
-            if (UI_MENU_GetCurrentMenuId() != MENU_SCR)
+            if (m != MENU_SCR)
                 gAnotherVoiceID = MenuList[gMenuCursor].voice_id;
         #endif
-        if (UI_MENU_GetCurrentMenuId() == MENU_UPCODE 
-            || UI_MENU_GetCurrentMenuId() == MENU_DWCODE 
+        if (m == MENU_UPCODE 
+            || m == MENU_DWCODE 
 #ifdef ENABLE_DTMF_CALLING 
-            || UI_MENU_GetCurrentMenuId() == MENU_ANI_ID
+            || m == MENU_ANI_ID
 #endif
             )
             return;
         #if 1
-            if (UI_MENU_GetCurrentMenuId() == MENU_DEL_CH || UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME)
+            if (m == MENU_DEL_CH || m == MENU_MEM_NAME)
                 if (!RADIO_CheckValidChannel(gSubMenuSelection, false, 0))
                     return;  // invalid channel
         #endif
@@ -1683,7 +1733,7 @@ static void MENU_Key_MENU(const bool bKeyPressed, const bool bKeyHeld)
         gAskForConfirmation = 0;
         gIsInSubMenu        = true;
 
-//      if (UI_MENU_GetCurrentMenuId() != MENU_D_LIST)
+//      if (m != MENU_D_LIST)
         {
             gInputBoxIndex      = 0;
             edit_index          = -1;
@@ -1734,10 +1784,12 @@ static void MENU_Key_MENU(const bool bKeyPressed, const bool bKeyHeld)
 
     if (gIsInSubMenu)
     {
-        if (UI_MENU_GetCurrentMenuId() == MENU_RESET  ||
-            UI_MENU_GetCurrentMenuId() == MENU_MEM_CH ||
-            UI_MENU_GetCurrentMenuId() == MENU_DEL_CH ||
-            UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME)
+        const int m = UI_MENU_GetCurrentMenuId();
+
+        if (m == MENU_RESET  ||
+            m == MENU_MEM_CH ||
+            m == MENU_DEL_CH ||
+            m == MENU_MEM_NAME)
         {
             switch (gAskForConfirmation)
             {
@@ -1750,7 +1802,7 @@ static void MENU_Key_MENU(const bool bKeyPressed, const bool bKeyHeld)
 
                     UI_DisplayMenu();
 
-                    if (UI_MENU_GetCurrentMenuId() == MENU_RESET)
+                    if (m == MENU_RESET)
                     {
                         #ifdef ENABLE_VOICE
                             AUDIO_SetVoiceID(0, VOICE_ID_CONFIRM);
@@ -1824,7 +1876,8 @@ static void MENU_Key_STAR(const bool bKeyPressed, const bool bKeyHeld)
         if (gRxVfo->Modulation ==  MODULATION_FM)
     #endif
     {
-        if ((UI_MENU_GetCurrentMenuId() == MENU_R_CTCS || UI_MENU_GetCurrentMenuId() == MENU_R_DCS) && gIsInSubMenu)
+        const int m = UI_MENU_GetCurrentMenuId();
+        if ((m == MENU_R_CTCS || m == MENU_R_DCS) && gIsInSubMenu)
         {   // scan CTCSS or DCS to find the tone/code of the incoming signal
             if (!SCANNER_IsScanning())
                 MENU_StartCssScan();
@@ -1842,9 +1895,13 @@ static void MENU_Key_STAR(const bool bKeyPressed, const bool bKeyHeld)
 static void MENU_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
 {
     uint8_t VFO;
-    uint8_t Channel;
+    uint16_t Channel;
     bool    bCheckScanList;
 
+    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)
@@ -1892,9 +1949,11 @@ static void MENU_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
 
         gRequestDisplayScreen = DISPLAY_MENU;
 
-        if (UI_MENU_GetCurrentMenuId() != MENU_ABR
-            && UI_MENU_GetCurrentMenuId() != MENU_ABR_MIN
-            && UI_MENU_GetCurrentMenuId() != MENU_ABR_MAX
+        const int m = UI_MENU_GetCurrentMenuId();
+
+        if (m != MENU_ABR 
+            && m != MENU_ABR_MIN 
+            && m != MENU_ABR_MAX 
             && gEeprom.BACKLIGHT_TIME == 0) // backlight always off and not in the backlight menu
         {
             BACKLIGHT_TurnOff();
@@ -1920,79 +1979,84 @@ static void MENU_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
     }
 
     VFO = 0;
+    
+    const int m = UI_MENU_GetCurrentMenuId();
 
-    switch (UI_MENU_GetCurrentMenuId())
+    switch (m)
     {
         case MENU_DEL_CH:
         case MENU_1_CALL:
+        case MENU_S_PRI_CH_1:
+        case MENU_S_PRI_CH_2:            
         case MENU_MEM_NAME:
             bCheckScanList = false;
             break;
 
-        case MENU_SLIST3:
-            bCheckScanList = true;
-            VFO = 3;
-            break;
-        case MENU_SLIST2:
-            bCheckScanList = true;
-            VFO = 2;
-            break;
-        case MENU_SLIST1:
-            bCheckScanList = true;
-            VFO = 1;
-            break;
-
         default:
             MENU_ClampSelection(Direction);
             gRequestDisplayScreen = DISPLAY_MENU;
             return;
     }
 
-    Channel = RADIO_FindNextChannel(gSubMenuSelection + Direction, Direction, bCheckScanList, VFO);
-    if (Channel != 0xFF)
-        gSubMenuSelection = Channel;
+    if(m == MENU_S_PRI_CH_1 || m == MENU_S_PRI_CH_2)
+    {
+        static int16_t last;
 
-    gRequestDisplayScreen = DISPLAY_MENU;
+        if(gSubMenuSelection == MR_CHANNELS_MAX) {
+            if(Direction > 0)
+            {
+                gSubMenuSelection = -1;
+                last = -1;
+            }
+            else if(Direction < 0)
+            {
+                gSubMenuSelection = MR_CHANNELS_MAX;
+                last = MR_CHANNELS_MAX;
+            }
+        }
+
+        Channel = RADIO_FindNextChannel(gSubMenuSelection + Direction, Direction, bCheckScanList, VFO);
+        if (Channel != 0xFFFF)
+            gSubMenuSelection = Channel;
+
+        if(Direction > 0 && gSubMenuSelection < last)
+        {
+            gSubMenuSelection = MR_CHANNELS_MAX;
+        }
+        else if(Direction < 0 && gSubMenuSelection > last)
+        {
+            gSubMenuSelection = MR_CHANNELS_MAX;           
+        }
+        else
+        {
+            last = Channel;
+        }
+
+        gRequestDisplayScreen = DISPLAY_MENU;
+    }
+    else
+    {
+        Channel = RADIO_FindNextChannel(gSubMenuSelection + Direction, Direction, bCheckScanList, VFO);
+        if (Channel != 0xFFFF)
+            gSubMenuSelection = Channel;
+
+        gRequestDisplayScreen = DISPLAY_MENU;
+    }
 }
 
 void MENU_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 {
     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:
             MENU_Key_0_to_9(Key, bKeyPressed, bKeyHeld);
             break;
         case KEY_MENU:
             MENU_Key_MENU(bKeyPressed, bKeyHeld);
             break;
         case KEY_UP:
-            #ifdef ENABLE_NAVIG_LEFT_RIGHT
-                if(gIsInSubMenu)
-                    MENU_Key_UP_DOWN(bKeyPressed, bKeyHeld, -1);
-                else
-                    MENU_Key_UP_DOWN(bKeyPressed, bKeyHeld, 1);
-            #else
-                MENU_Key_UP_DOWN(bKeyPressed, bKeyHeld, 1);
-            #endif
-            break;
         case KEY_DOWN:
-            #ifdef ENABLE_NAVIG_LEFT_RIGHT
-                if(gIsInSubMenu)
-                    MENU_Key_UP_DOWN(bKeyPressed, bKeyHeld, 1);
-                else
-                    MENU_Key_UP_DOWN(bKeyPressed, bKeyHeld, -1);
-            #else
-                MENU_Key_UP_DOWN(bKeyPressed, bKeyHeld, -1);
-            #endif
+            MENU_Key_UP_DOWN(bKeyPressed, bKeyHeld, Key == KEY_UP ? 1 : -1);
             break;
         case KEY_EXIT:
             MENU_Key_EXIT(bKeyPressed, bKeyHeld);
@@ -2033,11 +2097,13 @@ void MENU_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 
     if (gScreenToDisplay == DISPLAY_MENU)
     {
-        if (UI_MENU_GetCurrentMenuId() == MENU_VOL ||
+        const int m = UI_MENU_GetCurrentMenuId();
+
+        if (m == MENU_VOL ||
             #ifdef ENABLE_F_CAL_MENU
-                UI_MENU_GetCurrentMenuId() == MENU_F_CALI ||
+                m == MENU_F_CALI ||
             #endif
-            UI_MENU_GetCurrentMenuId() == MENU_BATCAL)
+            m == MENU_BATCAL)
         {
             gMenuCountdown = menu_timeout_long_500ms;
         }

App/app/scanner.c

@@ -32,7 +32,7 @@ DCS_CodeType_t    gScanCssResultType;
 uint8_t           gScanCssResultCode;
 bool              gScanSingleFrequency; // scan CTCSS/DCS codes for current frequency
 SCAN_SaveState_t  gScannerSaveState;
-uint8_t           gScanChannel;
+uint16_t          gScanChannel;
 uint32_t          gScanFrequency;
 SCAN_CssState_t   gScanCssState;
 uint8_t           gScanProgressIndicator;
@@ -52,7 +52,7 @@ static void SCANNER_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 
             gRequestDisplayScreen = DISPLAY_SCANNER;
 
-            if (gInputBoxIndex < 3) {
+            if (gInputBoxIndex < 4) {
 #ifdef ENABLE_VOICE
                 gAnotherVoiceID = (VOICE_ID_t)Key;
 #endif
@@ -61,13 +61,14 @@ 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] * 100) + (gInputBox[1] * 10) + gInputBox[2]) - 1;
+            uint16_t chan = ((gInputBox[0] * 1000) + (gInputBox[1] * 100) + (gInputBox[2] * 10) + gInputBox[3]) - 1;
             if (IS_MR_CHANNEL(chan)) {
 #ifdef ENABLE_VOICE
                 gAnotherVoiceID = (VOICE_ID_t)Key;
 #endif
                 gShowChPrefix = RADIO_CheckValidChannel(chan, false, 0);
-                gScanChannel  = (uint8_t)chan;
+                gScanChannel  = chan;
                 return;
             }
         }
@@ -207,7 +208,7 @@ static void SCANNER_Key_MENU(bool bKeyPressed, bool bKeyHeld)
                 gTxVfo->freq_config_TX.Code     = gScanCssResultCode;
             }
 
-            uint8_t chan;
+            uint16_t chan;
             if (IS_MR_CHANNEL(gTxVfo->CHANNEL_SAVE)) {
                 chan = gScanChannel;
                 gEeprom.MrChannel[gEeprom.TX_VFO] = chan;
@@ -256,6 +257,10 @@ static void SCANNER_Key_UP_DOWN(bool bKeyPressed, bool pKeyHeld, int8_t Directio
         gBeepToPlay    = BEEP_1KHZ_60MS_OPTIONAL;
     }
 
+    if (!gEeprom.SET_NAV) {
+        Direction = -Direction;
+    }
+
     if (gScannerSaveState == SCAN_SAVE_CHAN_SEL) {
         gScanChannel          = NUMBER_AddWithWraparound(gScanChannel, Direction, 0, MR_CHANNEL_LAST);
         gShowChPrefix         = RADIO_CheckValidChannel(gScanChannel, false, 0);
@@ -275,10 +280,8 @@ void SCANNER_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
             SCANNER_Key_MENU(bKeyPressed, bKeyHeld);
             break;
         case KEY_UP:
-            SCANNER_Key_UP_DOWN(bKeyPressed, bKeyHeld,  1);
-            break;
         case KEY_DOWN:
-            SCANNER_Key_UP_DOWN(bKeyPressed, bKeyHeld, -1);
+            SCANNER_Key_UP_DOWN(bKeyPressed, bKeyHeld, Key == KEY_UP ? 1 : -1);
             break;
         case KEY_EXIT:
             SCANNER_Key_EXIT(bKeyPressed, bKeyHeld);

App/app/scanner.h

@@ -40,7 +40,7 @@ extern DCS_CodeType_t    gScanCssResultType;
 extern uint8_t           gScanCssResultCode;
 extern bool              gScanSingleFrequency;
 extern SCAN_SaveState_t  gScannerSaveState;
-extern uint8_t           gScanChannel;
+extern uint16_t          gScanChannel;
 extern uint32_t          gScanFrequency;
 extern SCAN_CssState_t   gScanCssState;
 extern uint8_t           gScanProgressIndicator;

App/app/spectrum.c

@@ -103,8 +103,8 @@ RegisterSpec registerSpecs[] = {
     {},
     {"LNAs", BK4819_REG_13, 8, 0b11, 1},
     {"LNA", BK4819_REG_13, 5, 0b111, 1},
-    {"VGA", BK4819_REG_13, 0, 0b111, 1},
-    {"BPF", BK4819_REG_3D, 0, 0xFFFF, 0x2aaa},
+    {"PGA", BK4819_REG_13, 0, 0b111, 1},
+    //{"BPF", BK4819_REG_3D, 0, 0xFFFF, 0x2aaa},
     // {"MIX", 0x13, 3, 0b11, 1}, // TODO: hidden
 };
 
@@ -112,7 +112,7 @@ RegisterSpec registerSpecs[] = {
 const int8_t LNAsOptions[] = {-19, -16, -11, 0};
 const int8_t LNAOptions[] = {-24, -19, -14, -9, -6, -4, -2, 0};
 const int8_t VGAOptions[] = {-33, -27, -21, -15, -9, -6, -3, 0};
-const char *BPFOptions[] = {"8.46", "7.25", "6.35", "5.64", "5.08", "4.62", "4.23"};
+//const char *BPFOptions[] = {"8.46", "7.25", "6.35", "5.64", "5.08", "4.62", "4.23"};
 #endif
 
 uint16_t statuslineUpdateTimer = 0;
@@ -121,7 +121,7 @@ uint16_t statuslineUpdateTimer = 0;
 static void LoadSettings()
 {
     uint8_t Data[8] = {0};
-    PY25Q16_ReadBuffer(0x00c000, Data, sizeof(Data));
+    PY25Q16_ReadBuffer(0x00A158, Data, sizeof(Data));
 
     settings.scanStepIndex = ((Data[3] & 0xF0) >> 4);
 
@@ -148,11 +148,11 @@ static void LoadSettings()
 static void SaveSettings()
 {
     uint8_t Data[8] = {0};
-    PY25Q16_ReadBuffer(0x00c000, Data, sizeof(Data));
+    PY25Q16_ReadBuffer(0x00A158, Data, sizeof(Data));
 
     Data[3] = (settings.scanStepIndex << 4) | (settings.stepsCount << 2) | settings.listenBw;
 
-    PY25Q16_WriteBuffer(0x00c000, Data, sizeof(Data), true);
+    PY25Q16_WriteBuffer(0x00A158, Data, sizeof(Data), false);
 }
 #endif
 
@@ -183,8 +183,10 @@ static uint16_t GetRegMenuValue(uint8_t st)
 
 void LockAGC()
 {
-    RADIO_SetupAGC(settings.modulationType == MODULATION_AM, lockAGC);
-    lockAGC = true;
+    //RADIO_SetupAGC(settings.modulationType == MODULATION_AM, lockAGC);
+    RADIO_SetupAGC(false, lockAGC);
+    //lockAGC = true;
+    lockAGC = false;
 }
 
 static void SetRegMenuValue(uint8_t st, bool add)
@@ -268,16 +270,6 @@ static void GUI_DisplaySmallest(const char *pString, uint8_t x, uint8_t y,
 
 // Utility functions
 
-static KEY_Code_t GetKey()
-{
-    KEY_Code_t btn = KEYBOARD_Poll();
-    if (btn == KEY_INVALID && GPIO_IsPttPressed())
-    {
-        btn = KEY_PTT;
-    }
-    return btn;
-}
-
 static int clamp(int v, int min, int max)
 {
     return v <= min ? min : (v >= max ? max : v);
@@ -504,7 +496,9 @@ static void ToggleRX(bool on)
     #endif
     isListening = on;
 
-    RADIO_SetupAGC(settings.modulationType == MODULATION_AM, lockAGC);
+    //RADIO_SetupAGC(settings.modulationType == MODULATION_AM, lockAGC);
+    RADIO_SetupAGC(false, lockAGC);
+
     BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, on);
 
     ToggleAudio(on);
@@ -783,11 +777,13 @@ static void ToggleBacklight()
     settings.backlightState = !settings.backlightState;
     if (settings.backlightState)
     {
-        BACKLIGHT_TurnOn();
+        // BACKLIGHT_TurnOn();
+        BACKLIGHT_SetBrightness(gEeprom.BACKLIGHT_MAX);
     }
     else
     {
-        BACKLIGHT_TurnOff();
+        // BACKLIGHT_TurnOff();
+        BACKLIGHT_SetBrightness(gEeprom.BACKLIGHT_MIN);
     }
 }
 
@@ -950,16 +946,16 @@ uint8_t Rssi2Y(uint16_t rssi)
                 // Total width units = (bars - 1) full bars + 2 half bars = bars
                 // First bar: half width, middle bars: full width, last bar: half width
                 // Scale: 128 pixels / (bars - 1) = pixels per full bar
-                uint16_t fullWidth = 128 * 2 / (bars - 1);  // x2 for precision
+                uint16_t fullWidth = (128 << 8) / (bars - 1);  // x256 for precision
                 
                 if (i == 0)
                 {
-                    x = fullWidth / 4;  // half of half (because fullWidth is x2)
+                    x = fullWidth / (2 << 8);  // half of /256 (because fullWidth is x256)
                 }
                 else
                 {
                     // Position = half + (i-1) full bars + current bar
-                    x = fullWidth / 4 + (uint16_t)i * fullWidth / 2;
+                    x = fullWidth / (2 << 8) + (uint16_t)i * fullWidth / (1 << 8);
                     if (i == bars - 1) x = 128;  // Last bar ends at screen edge
                 }
             }
@@ -1181,54 +1177,49 @@ static void DrawArrow(uint8_t x)
 
 static void OnKeyDown(uint8_t key)
 {
+    bool nav = gEeprom.SET_NAV;
+    bool isTrue = false;
+
     switch (key)
     {
     case KEY_3:
-        UpdateDBMax(true);
-        break;
+        isTrue = true;
+        [[fallthrough]];
     case KEY_9:
-        UpdateDBMax(false);
+        UpdateDBMax(isTrue);
         break;
     case KEY_1:
-        UpdateScanStep(true);
-        break;
+        isTrue = true;
+        [[fallthrough]];
     case KEY_7:
-        UpdateScanStep(false);
+        UpdateScanStep(isTrue);
         break;
     case KEY_2:
-        UpdateFreqChangeStep(true);
-        break;
+        isTrue = true;
+        [[fallthrough]];
     case KEY_8:
-        UpdateFreqChangeStep(false);
+        UpdateFreqChangeStep(isTrue);
         break;
     case KEY_UP:
-#ifdef ENABLE_SCAN_RANGES
-        if (!gScanRangeStart)
-#endif
-#ifdef ENABLE_NAVIG_LEFT_RIGHT
-            UpdateCurrentFreq(false);
-#else
-            UpdateCurrentFreq(true);
-#endif
-        break;
+        nav = !nav;
+        [[fallthrough]];
     case KEY_DOWN:
 #ifdef ENABLE_SCAN_RANGES
-        if (!gScanRangeStart)
+        if (!gScanRangeStart) {
 #endif
-#ifdef ENABLE_NAVIG_LEFT_RIGHT
-            UpdateCurrentFreq(true);
-#else
-            UpdateCurrentFreq(false);
+        UpdateCurrentFreq(!nav);
+#ifdef ENABLE_SCAN_RANGES
+        }
 #endif
         break;
     case KEY_SIDE1:
         Blacklist();
         break;
     case KEY_STAR:
-        UpdateRssiTriggerLevel(true);
-        break;
+        isTrue = true;
+        [[fallthrough]];
     case KEY_F:
-        UpdateRssiTriggerLevel(false);
+        UpdateRssiTriggerLevel(isTrue);
         break;
     case KEY_5:
 #ifdef ENABLE_SCAN_RANGES
@@ -1281,21 +1272,10 @@ static void OnKeyDownFreqInput(uint8_t key)
 {
     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:
     case KEY_STAR:
-        UpdateFreqInput(key);
-        break;
     case KEY_EXIT:
-        if (freqInputIndex == 0)
+        if (freqInputIndex == 0 && key == KEY_EXIT)
         {
             SetState(previousState);
             break;
@@ -1326,52 +1306,32 @@ static void OnKeyDownFreqInput(uint8_t key)
 
 void OnKeyDownStill(KEY_Code_t key)
 {
+    bool nav = gEeprom.SET_NAV;
+    bool isTrue = false;
+
     switch (key)
     {
     case KEY_3:
-        UpdateDBMax(true);
-        break;
+        isTrue = true;
+        [[fallthrough]];
     case KEY_9:
-        UpdateDBMax(false);
+        UpdateDBMax(isTrue);
         break;
     case KEY_UP:
-        if (menuState)
-
-#ifdef ENABLE_NAVIG_LEFT_RIGHT
-        {
-            SetRegMenuValue(menuState, false);
-            break;
-        }
-        UpdateCurrentFreqStill(false);
-#else
-        {
-            SetRegMenuValue(menuState, true);
-            break;
-        }
-        UpdateCurrentFreqStill(true);
-#endif
-        break;
+        nav = !nav;
+        [[fallthrough]];
     case KEY_DOWN:
-        if (menuState)
-#ifdef ENABLE_NAVIG_LEFT_RIGHT
-        {
-            SetRegMenuValue(menuState, true);
+        if (menuState) {
+            SetRegMenuValue(menuState, !nav);
             break;
         }
-        UpdateCurrentFreqStill(true);
-#else
-        {
-            SetRegMenuValue(menuState, false);
-            break;
-        }
-        UpdateCurrentFreqStill(false);
-#endif
+        UpdateCurrentFreqStill(!nav);
         break;
     case KEY_STAR:
-        UpdateRssiTriggerLevel(true);
-        break;
+        isTrue = true;
+        [[fallthrough]];
     case KEY_F:
-        UpdateRssiTriggerLevel(false);
+        UpdateRssiTriggerLevel(isTrue);
         break;
     case KEY_5:
         FreqInput();
@@ -1394,14 +1354,7 @@ void OnKeyDownStill(KEY_Code_t key)
         BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, true); */
         break;
     case KEY_MENU:
-        if (menuState == ARRAY_SIZE(registerSpecs) - 1)
-        {
-            menuState = 1;
-        }
-        else
-        {
-            menuState++;
-        }
+        menuState = (menuState == ARRAY_SIZE(registerSpecs) - 1) ? 1 : menuState + 1;
         redrawScreen = true;
         break;
     case KEY_EXIT:
@@ -1432,7 +1385,7 @@ static void RenderStatus()
 static void RenderSpectrum()
 {
     DrawTicks();
-    DrawArrow(128u * peak.i / GetStepsCount());
+    DrawArrow(128u * peak.i / (GetStepsCount() - 1));
     DrawSpectrum();
     DrawRssiTriggerLevel();
     DrawF(peak.f);
@@ -1484,9 +1437,9 @@ static void RenderStill()
     uint8_t offset = PAD_LEFT;
     uint8_t row = 4;
 
-    for (int i = 0, idx = 1; idx <= 4; ++i, ++idx)
+    for (int i = 0, idx = 1; idx <= 3; ++i, ++idx)
     {
-        if (idx == 5)
+        if (idx == 4)
         {
             row += 2;
             i = 0;
@@ -1517,10 +1470,12 @@ static void RenderStill()
         {
             sprintf(String, "%ddB", VGAOptions[GetRegMenuValue(idx)]);
         }
+        /*
         else if(idx == 4)
         {
             sprintf(String, "%skHz", BPFOptions[(GetRegMenuValue(idx) / 0x2aaa)]);
         }
+        */
 #else
         sprintf(String, "%u", GetRegMenuValue(idx));
 #endif
@@ -1552,7 +1507,7 @@ static void Render()
 static bool HandleUserInput()
 {
     kbd.prev = kbd.current;
-    kbd.current = GetKey();
+    kbd.current = KEYBOARD_GetKey();
 
     if (kbd.current != KEY_INVALID && kbd.current == kbd.prev)
     {
@@ -1611,7 +1566,7 @@ static void UpdateScan()
 {
     Scan();
 
-    if (scanInfo.i < scanInfo.measurementsCount)
+    if (scanInfo.i + 1 < scanInfo.measurementsCount)
     {
         NextScanStep();
         return;
@@ -1702,16 +1657,23 @@ static void UpdateListening()
 
 static void Tick()
 {
-#ifdef ENABLE_AM_FIX
+#ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+    // Parse incoming packets on every tick so serial keys are never missed,
+    // regardless of whether the screen needs redrawing.
+    SCREENSHOT_ParseInput();
+#endif
+
     if (gNextTimeslice)
     {
         gNextTimeslice = false;
+#ifdef ENABLE_AM_FIX
         if (settings.modulationType == MODULATION_AM && !lockAGC)
         {
             AM_fix_10ms(vfo); // allow AM_Fix to apply its AGC action
         }
-    }
 #endif
+        BACKLIGHT_Update();
+    }
 
 #ifdef ENABLE_SCAN_RANGES
     if (gNextTimeslice_500ms)
@@ -1771,7 +1733,7 @@ static void Tick()
         Render();
         // For screenshot
         #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
-            getScreenShot(false);
+            SCREENSHOT_Update(false);
         #endif
         redrawScreen = false;
     }
@@ -1779,6 +1741,8 @@ static void Tick()
 
 void APP_RunSpectrum()
 {
+    settings.backlightState = gEeprom.BACKLIGHT_TIME == 0 ? false : true;
+
     // TX here coz it always? set to active VFO
     vfo = gEeprom.TX_VFO;
 #ifdef ENABLE_FEAT_F4HWN_SPECTRUM
@@ -1841,4 +1805,6 @@ void APP_RunSpectrum()
     {
         Tick();
     }
+
+    BACKLIGHT_TurnOn();
 }

App/app/uart.c

@@ -677,14 +677,26 @@ bool UART_IsCommandAvailable(uint32_t Port)
         return false;
     }
 
-    while (1)
+    // Limit iterations to prevent long loops when buffer is full of non-command data
+    uint16_t maxIterations = ReadBufSize + 1;
+
+    while (maxIterations--)
     {
         if ((*pReadPointer) == DmaLength)
             return false;
 
-        while ((*pReadPointer) != DmaLength && ReadBuf[*pReadPointer] != 0xABU)
+        // Find 0xAB with iteration limit
+        uint16_t searchLimit = ReadBufSize;
+        while ((*pReadPointer) != DmaLength && ReadBuf[*pReadPointer] != 0xABU && searchLimit--)
             *pReadPointer = DMA_INDEX((*pReadPointer), 1, ReadBufSize);
 
+        if (searchLimit == 0)
+        {
+            // Too many bytes without finding 0xAB - sync to current position and exit
+            *pReadPointer = DmaLength;
+            return false;
+        }
+
         if ((*pReadPointer) == DmaLength)
             return false;
 
@@ -702,6 +714,13 @@ bool UART_IsCommandAvailable(uint32_t Port)
         *pReadPointer = DMA_INDEX(*pReadPointer, 1, ReadBufSize);
     }
 
+    if (maxIterations == 0)
+    {
+        // Safety: too many outer loop iterations
+        *pReadPointer = DmaLength;
+        return false;
+    }
+
     Index = DMA_INDEX(*pReadPointer, 2, ReadBufSize);
     Size  = (ReadBuf[DMA_INDEX(Index, 1, ReadBufSize)] << 8) | ReadBuf[Index];
 
@@ -847,4 +866,4 @@ void UART_HandleCommand(uint32_t Port)
     #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
         gUART_LockScreenshot = 20; // lock screenshot
     #endif
-}
+}

App/audio.c

@@ -36,6 +36,13 @@
 
 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)
 {
 
@@ -53,12 +60,7 @@ void AUDIO_PlayBeep(BEEP_Type_t Beep)
 #endif
        !gEeprom.BEEP_CONTROL)
         return;
-
-#ifdef ENABLE_AIRCOPY
-    if (gScreenToDisplay == DISPLAY_AIRCOPY)
-        return;
-#endif
-
+        
     if (gCurrentFunction == FUNCTION_RECEIVE)
         return;
 
@@ -133,17 +135,11 @@ void AUDIO_PlayBeep(BEEP_Type_t Beep)
     switch (Beep)
     {
         case BEEP_880HZ_60MS_DOUBLE_BEEP:
-            BK4819_ExitTxMute();
-            SYSTEM_DelayMs(60);
-            BK4819_EnterTxMute();
-            SYSTEM_DelayMs(20);
+            AUDIO_PlayBeepPulse();
             [[fallthrough]];
         case BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL:
         case BEEP_500HZ_60MS_DOUBLE_BEEP:
-            BK4819_ExitTxMute();
-            SYSTEM_DelayMs(60);
-            BK4819_EnterTxMute();
-            SYSTEM_DelayMs(20);
+            AUDIO_PlayBeepPulse();
             [[fallthrough]];
         case BEEP_1KHZ_60MS_OPTIONAL:
             BK4819_ExitTxMute();
@@ -182,11 +178,19 @@ void AUDIO_PlayBeep(BEEP_Type_t Beep)
     SYSTEM_DelayMs(5);
     BK4819_WriteRegister(BK4819_REG_71, ToneConfig);
 
+#ifdef ENABLE_FMRADIO
+    const bool isFmRadio = gFmRadioMode;
+    
+    if (isFmRadio)
+        SYSTEM_DelayMs(10);
+#endif
+
+
     if (gEnableSpeaker)
         AUDIO_AudioPathOn();
 
 #ifdef ENABLE_FMRADIO
-    if (gFmRadioMode)
+    if (isFmRadio)
         BK1080_Mute(false);
 #endif
 

App/bitmaps.c

@@ -157,26 +157,18 @@ const uint8_t BITMAP_USB_C[9] =
     };
 #endif
 
-const uint8_t BITMAP_Antenna[5] =
-{
-    0b00000011,
-    0b00000101,
-    0b01111111,
-    0b00000101,
-    0b00000011
-};
-
 const uint8_t BITMAP_VFO_Lock[7] =
 {
-    0b01111100,
-    0b01000110,
-    0b01000101,
-    0b01000101,
-    0b01000101,
-    0b01000110,
-    0b01111100,
+    0b00111100,
+    0b00100110,
+    0b00100101,
+    0b00100101,
+    0b00100101,
+    0b00100110,
+    0b00111100,
 };
 
+/*
 const uint8_t BITMAP_VFO_Default[7] =
 {
     0b01111111,
@@ -198,108 +190,41 @@ const uint8_t BITMAP_VFO_NotDefault[7] =
     0b00010100,
     0b00001000
 };
+*/
 
-const uint8_t BITMAP_ScanList0[7] =
-{   // '0' symbol
-    0b01111111,
-    0b01111111,
-    0b01000011,
-    0b01011101,
-    0b01100001,
-    0b01111111,
-    0b01111111
-};
-
-const uint8_t BITMAP_ScanList1[7] =
-{   // '1' symbol
-    0b01111111,
-    0b01111111,
-    0b01111011,
-    0b01000001,
-    0b01111111,
-    0b01111111,
-    0b01111111
-};
-
-const uint8_t BITMAP_ScanList2[7] =
-{   // '2' symbol
-    0b01111111,
-    0b01111111,
-    0b01001101,
-    0b01010101,
-    0b01011011,
-    0b01111111,
-    0b01111111
-};
-
-const uint8_t BITMAP_ScanList3[7] =
-{   // '3' symbol
-    0b01111111,
-    0b01111111,
-    0b01011101,
-    0b01010101,
-    0b01101011,
-    0b01111111,
-    0b01111111
-};
-
-const uint8_t BITMAP_ScanListE[7] =
-{   // 'E' symbol
-    0b01111111,
-    0b01111111,
-    0b01000001,
-    0b01010101,
-    0b01010101,
-    0b01111111,
-    0b01111111
-};
-
-const uint8_t BITMAP_ScanList123[19] =
+// Compact arrow
+const uint8_t BITMAP_VFO_Default[7] =
 {
-    // '123' symbol
-    0b01111111,
-    0b01111111,
-    0b01111011,
-    0b01000001,
-    0b01111111,
-    0b01111111,
-    0b01111111,
-    0b01111111,
-    0b01001101,
-    0b01010101,
-    0b01011011,
-    0b01111111,
-    0b01111111,
-    0b01111111,
-    0b01011101,
-    0b01010101,
-    0b01101011,
-    0b01111111,
-    0b01111111
+    0b00111110,
+    0b00111110,
+    0b00011100,
+    0b00011100,
+    0b00001000,
+    0b00001000,
+    0b00000000
 };
 
-const uint8_t BITMAP_ScanListAll[19] =
+// Compact empty arrow
+const uint8_t BITMAP_VFO_NotDefault[7] =
 {
-    // 'All' symbol
-    0b01111111,
-    0b01111111,
-    0b01000011,
-    0b01110101,
-    0b01000011,
-    0b01111111,
-    0b01111111,
-    0b01111111,
-    0b01000001,
-    0b01011111,
-    0b01011111,
-    0b01111111,
-    0b01111111,
-    0b01111111,
-    0b01000001,
-    0b01011111,
-    0b01011111,
-    0b01111111,
-    0b01111111
+    0b00100010,
+    0b00100010,
+    0b00010100,
+    0b00010100,
+    0b00001000,
+    0b00001000,
+    0b00000000
+};
+
+const uint8_t BITMAP_VFO_Empty[7] =
+{
+    0b00000000,
+    0b00000000,
+    0b00000000,
+    0b00000000,
+    0b00000000,
+    0b00000000,
+    0b00000000
 };
 
 const uint8_t BITMAP_compand[6] =

App/bitmaps.h

@@ -35,17 +35,10 @@ extern const uint8_t BITMAP_NotReady[7];
     extern const uint8_t gFontVox[2][6];
 #endif
 
-extern const uint8_t BITMAP_Antenna[5];
 extern const uint8_t BITMAP_VFO_Default[7];
 extern const uint8_t BITMAP_VFO_NotDefault[7];
+extern const uint8_t BITMAP_VFO_Empty[7];
 extern const uint8_t BITMAP_VFO_Lock[7];
-extern const uint8_t BITMAP_ScanList0[7];
-extern const uint8_t BITMAP_ScanList1[7];
-extern const uint8_t BITMAP_ScanList2[7];
-extern const uint8_t BITMAP_ScanList3[7];
-extern const uint8_t BITMAP_ScanList123[19];
-extern const uint8_t BITMAP_ScanListAll[19];
-extern const uint8_t BITMAP_ScanListE[7];
 extern const uint8_t BITMAP_PowerUser[3];
 extern const uint8_t BITMAP_compand[6];
 

App/dcs.c

@@ -15,10 +15,7 @@
  */
 
 #include "dcs.h"
-
-#ifndef ARRAY_SIZE
-    #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
-#endif
+#include "misc.h"
 
 // CTCSS Hz * 10
 const uint16_t CTCSS_Options[50] = {

App/driver/backlight.c

@@ -31,7 +31,7 @@
     #include "misc.h"
 #endif
 
-#define PWM_FREQ 240
+#define PWM_FREQ 4000
 #define DUTY_CYCLE_LEVELS 64
 
 #define DUTY_CYCLE_ON_VALUE GPIO_PIN_MASK(GPIO_PIN_BACKLIGHT)
@@ -44,10 +44,28 @@ static uint32_t dutyCycle[DUTY_CYCLE_LEVELS];
 
 // this is decremented once every 500ms
 uint16_t gBacklightCountdown_500ms = 0;
+bool gUpdateBacklight = false;
 bool backlightOn;
 
+static uint8_t currentIndex = 0;
+static int16_t currentBrightness = 0;
+static int16_t targetBrightness = 0;
+static int16_t fadeStep = 0;
+
 #ifdef ENABLE_FEAT_F4HWN
-    const uint8_t value[] = {0, 3, 6, 9, 15, 24, 38, 62, 100, 159, 255};
+    const uint8_t value[] = {
+        0,    // 0 off
+        8,    // 1 visible in the dark
+        14,   // 2
+        22,   // 3
+        32,   // 4
+        48,   // 5
+        72,   // 6
+        104,  // 7
+        150,  // 8
+        200,  // 9
+        255   // 10 max
+    };
 #endif
 
 #ifdef ENABLE_FEAT_F4HWN_SLEEP
@@ -79,7 +97,7 @@ void BACKLIGHT_InitHardware()
                               | LL_DMA_MEMORY_INCREMENT     //
                               | LL_DMA_PDATAALIGN_WORD      //
                               | LL_DMA_MDATAALIGN_WORD      //
-                              | LL_DMA_PRIORITY_LOW         //
+                              | LL_DMA_PRIORITY_HIGH        //
     );
 
     LL_DMA_SetMemoryAddress(DMA1, DMA_CHANNEL, (uint32_t)dutyCycle);
@@ -98,6 +116,12 @@ static void BACKLIGHT_Sound(void)
     gK5startup = false;
 }
 
+void BACKLIGHT_UpdateTickless(void) {
+    while(gUpdateBacklight) {
+        BACKLIGHT_Update();
+        SYSTEM_DelayMs(10);
+    }
+}
 
 void BACKLIGHT_TurnOn(void)
 {
@@ -122,27 +146,23 @@ void BACKLIGHT_TurnOn(void)
 
     backlightOn = true;
 
-#ifdef ENABLE_FEAT_F4HWN
-    if(gK5startup == true) {
-        #if defined(ENABLE_FMRADIO) && defined(ENABLE_SPECTRUM)
-            BACKLIGHT_SetBrightness(gEeprom.BACKLIGHT_MAX);
-        #else
-            for(uint8_t i = 0; i <= gEeprom.BACKLIGHT_MAX; i++)
-            {
-                BACKLIGHT_SetBrightness(i);
-                SYSTEM_DelayMs(50);
-            }
-        #endif
-
-        BACKLIGHT_Sound();
-    }
-    else
-    {
-        BACKLIGHT_SetBrightness(gEeprom.BACKLIGHT_MAX);
-    }
-#else
     BACKLIGHT_SetBrightness(gEeprom.BACKLIGHT_MAX);
+
+#ifdef ENABLE_FEAT_F4HWN
+    if(gK5startup == true)
+#else
+    static bool startup = true;
+    
+    if(startup)
 #endif
+    {
+        BACKLIGHT_UpdateTickless();
+#ifdef ENABLE_FEAT_F4HWN
+        BACKLIGHT_Sound();
+#else
+        startup = false;
+#endif
+    }
 
     switch (gEeprom.BACKLIGHT_TIME) {
         default:
@@ -178,18 +198,11 @@ bool BACKLIGHT_IsOn()
     return backlightOn;
 }
 
-static uint8_t currentBrightness = 0;
-
-void BACKLIGHT_SetBrightness(uint8_t brigtness)
+static void BACKLIGHT_SetHardwareBrightness(uint8_t brightness)
 {
     // printf("BL: %d\n", brigtness);
 
-    if (currentBrightness == brigtness)
-    {
-        return;
-    }
-
-    if (0 == brigtness)
+    if (0 == brightness)
     {
         LL_TIM_DisableCounter(TIMx);
         LL_DMA_DisableChannel(DMA1, DMA_CHANNEL);
@@ -198,7 +211,7 @@ void BACKLIGHT_SetBrightness(uint8_t brigtness)
     }
     else
     {
-        const uint32_t level = (uint32_t)(value[brigtness]) * DUTY_CYCLE_LEVELS / 255;
+        const uint32_t level = (uint32_t)(brightness) * DUTY_CYCLE_LEVELS / 255;
         if (level >= DUTY_CYCLE_LEVELS)
         {
             LL_TIM_DisableCounter(TIMx);
@@ -219,11 +232,45 @@ void BACKLIGHT_SetBrightness(uint8_t brigtness)
             }
         }
     }
+}
 
-    currentBrightness = brigtness;
+void BACKLIGHT_Update(void)
+{
+    if (gUpdateBacklight) {
+        currentBrightness += fadeStep;
+
+        if ((fadeStep > 0 && currentBrightness >= targetBrightness) || 
+            (fadeStep < 0 && currentBrightness <= targetBrightness)) {
+            currentBrightness = targetBrightness;
+            gUpdateBacklight = false;
+        }
+
+        BACKLIGHT_SetHardwareBrightness((uint8_t)currentBrightness);
+    }
+}
+
+void BACKLIGHT_SetBrightness(uint8_t targetIndex)
+{
+    if (currentIndex == targetIndex) {
+        return;
+    }
+
+    currentIndex = targetIndex;
+    targetBrightness = value[targetIndex];
+
+    int16_t diff = targetBrightness - currentBrightness;
+
+    if (diff == 0) {
+        gUpdateBacklight = false;
+        return;
+    }
+    
+    fadeStep = diff > 0 ? -(-diff >> 4) : diff >> 4;
+
+    gUpdateBacklight = true;
 }
 
 uint8_t BACKLIGHT_GetBrightness(void)
 {
-    return currentBrightness;
+    return currentIndex;
 }

App/driver/backlight.h

@@ -40,10 +40,12 @@ typedef enum {
 #endif
 
 void BACKLIGHT_InitHardware();
+void BACKLIGHT_UpdateTickless(void);
 void BACKLIGHT_TurnOn();
 void BACKLIGHT_TurnOff();
 bool BACKLIGHT_IsOn();
 void BACKLIGHT_SetBrightness(uint8_t brigtness);
+void BACKLIGHT_Update(void);
 uint8_t BACKLIGHT_GetBrightness(void);
 
 #endif

App/driver/bk1080.c

@@ -20,10 +20,6 @@
 #include "driver/system.h"
 #include "misc.h"
 
-#ifndef ARRAY_SIZE
-    #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
-#endif
-
 static const uint16_t BK1080_RegisterTable[] =
 {
     0x0008, 0x1080, 0x0201, 0x0000, 0x40C0, 0x0A1F, 0x002E, 0x02FF,

App/driver/bk4819-regs.h

@@ -163,7 +163,7 @@ typedef enum BK4819_GPIO_PIN_t BK4819_GPIO_PIN_t;
 #define BK4819_REG_02_SHIFT_SQUELCH_LOST        2
 #define BK4819_REG_02_SHIFT_FSK_RX_SYNC         1
 
-#define BK4819_REG_02_MASK_FSK_TX_FINISHED      (1U << BK4819_REG_02_SHIFT_FSK_TX)
+#define BK4819_REG_02_MASK_FSK_TX_FINISHED      (1U << BK4819_REG_02_SHIFT_FSK_TX_FINISHED)
 #define BK4819_REG_02_MASK_FSK_FIFO_ALMOST_EMPTY    (1U << BK4819_REG_02_SHIFT_FSK_FIFO_ALMOST_EMPTY)
 #define BK4819_REG_02_MASK_FSK_RX_FINISHED      (1U << BK4819_REG_02_SHIFT_FSK_RX_FINISHED)
 #define BK4819_REG_02_MASK_FSK_FIFO_ALMOST_FULL     (1U << BK4819_REG_02_SHIFT_FSK_FIFO_ALMOST_FULL)

App/driver/bk4819.c

@@ -19,6 +19,7 @@
 #include <stdio.h>
 
 #include "settings.h"
+#include "misc.h"
 
 #include "audio.h"
 
@@ -28,10 +29,6 @@
 #include "driver/systick.h"
 
 
-#ifndef ARRAY_SIZE
-    #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
-#endif
-
 #define PIN_CSN GPIO_MAKE_PIN(GPIOF, LL_GPIO_PIN_9)
 #define PIN_SCL GPIO_MAKE_PIN(GPIOB, LL_GPIO_PIN_8)
 #define PIN_SDA GPIO_MAKE_PIN(GPIOB, LL_GPIO_PIN_9)

App/driver/bk4819.h

@@ -48,7 +48,8 @@ enum BK4819_FilterBandwidth_t
 {
     BK4819_FILTER_BW_WIDE = 0,
     BK4819_FILTER_BW_NARROW,
-    BK4819_FILTER_BW_NARROWER
+    BK4819_FILTER_BW_NARROWER,
+    BK4819_FILTER_BW_AM
 };
 
 typedef enum BK4819_FilterBandwidth_t BK4819_FilterBandwidth_t;
@@ -115,6 +116,10 @@ void     BK4819_TurnsOffTones_TurnsOnRX(void);
 #endif
 void     BK4819_ResetFSK(void);
 void     BK4819_Idle(void);
+#ifdef ENABLE_BYP_RAW_DEMODULATORS
+void     BK4819_EnterBypass(void);
+void     BK4819_EnterRaw(void);
+#endif
 void     BK4819_ExitBypass(void);
 void     BK4819_PrepareTransmit(void);
 void     BK4819_TxOn_Beep(void);

App/driver/bk4829.c

@@ -19,6 +19,7 @@
 #include <stdio.h>
 
 #include "settings.h"
+#include "misc.h"
 
 #include "audio.h"
 
@@ -27,11 +28,6 @@
 #include "driver/system.h"
 #include "driver/systick.h"
 
-
-#ifndef ARRAY_SIZE
-    #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
-#endif
-
 #define PIN_CSN GPIO_MAKE_PIN(GPIOF, LL_GPIO_PIN_9)
 #define PIN_SCL GPIO_MAKE_PIN(GPIOB, LL_GPIO_PIN_8)
 #define PIN_SDA GPIO_MAKE_PIN(GPIOB, LL_GPIO_PIN_9)
@@ -177,7 +173,7 @@ void BK4819_Init(void)
 
     BK4819_WriteRegister(0x73, 0x4691);
     BK4819_WriteRegister(0x77, 0x88EF);
-    BK4819_WriteRegister(BK4819_REG_19, 0x104E);
+    BK4819_WriteRegister(BK4819_REG_19, 0x1041);
     BK4819_WriteRegister(BK4819_REG_28, 0x0B40);
     BK4819_WriteRegister(BK4819_REG_29, 0xAA00);
     BK4819_WriteRegister(0x2A, 0x6600);
@@ -338,45 +334,9 @@ void BK4819_SetAGC(bool enable)
 
 void BK4819_InitAGC(bool amModulation)
 {
-    // REG_10, REG_11, REG_12 REG_13, REG_14
-    //
-    // Rx AGC Gain Table[]. (Index Max->Min is 3,2,1,0,-1)
-    //
-    // <15:10> ???
-    //
-    // <9:8>   LNA Gain Short
-    //         3 =   0dB  <<<       1o11                read from spectrum          reference manual
-    //         2 =                  -24dB               -19                          -11
-    //         1 =                  -30dB               -24                          -16
-    //         0 =                  -33dB               -28                          -19
-    //
-    // <7:5>   LNA Gain
-    //         7 =   0dB
-    //         6 =  -2dB
-    //         5 =  -4dB
-    //         4 =  -6dB
-    //         3 =  -9dB
-    //         2 = -14dB <<<
-    //         1 = -19dB
-    //         0 = -24dB
-    //
-    // <4:3>   MIXER Gain
-    //         3 =   0dB <<<
-    //         2 =  -3dB
-    //         1 =  -6dB
-    //         0 =  -8dB
-    //
-    // <2:0>   PGA Gain
-    //         7 =   0dB
-    //         6 =  -3dB <<<
-    //         5 =  -6dB
-    //         4 =  -9dB
-    //         3 = -15dB
-    //         2 = -21dB
-    //         1 = -27dB
-    //         0 = -33dB
-    //
 
+    /*
+    // Old strategy
     BK4819_WriteRegister(BK4819_REG_13, 0x03BE);  // 0x03BE / 000000 11 101 11 110 /  -7dB
     BK4819_WriteRegister(BK4819_REG_12, 0x037B);  // 0x037B / 000000 11 011 11 011 / -24dB
     BK4819_WriteRegister(BK4819_REG_11, 0x027B);  // 0x027B / 000000 10 011 11 011 / -43dB
@@ -391,7 +351,21 @@ void BK4819_InitAGC(bool amModulation)
     }
 
     BK4819_WriteRegister(BK4819_REG_7B, 0x8420);
+    */
 
+    // New strategy
+    // Keep the runtime AGC profile aligned with the stock BK4829 firmware
+    // until modulation-specific AGC changes are proven on hardware.
+
+    (void)amModulation;
+
+    BK4819_WriteRegister(BK4819_REG_10, 0x0318);
+    BK4819_WriteRegister(BK4819_REG_11, 0x033A);
+    BK4819_WriteRegister(BK4819_REG_12, 0x03DB);
+    BK4819_WriteRegister(BK4819_REG_13, 0x03DF);
+    BK4819_WriteRegister(BK4819_REG_14, 0x0210);
+    BK4819_WriteRegister(BK4819_REG_49, 0x2AB2);
+    BK4819_WriteRegister(BK4819_REG_7B, 0x73DC);
 }
 
 int8_t BK4819_GetRxGain_dB(void)
@@ -629,102 +603,91 @@ void BK4819_EnableVox(uint16_t VoxEnableThreshold, uint16_t VoxDisableThreshold)
 
 void BK4819_SetFilterBandwidth(const BK4819_FilterBandwidth_t Bandwidth, const bool weak_no_different)
 {
-    // REG_43
-    // <15>    0 ???
+    (void)weak_no_different;
+
+    // REG_43 on BK4829, per BK4829 Registers Table.
     //
-    // <14:12> 4 RF filter bandwidth
-    //         0 = 1.7  kHz
-    //         1 = 2.0  kHz
-    //         2 = 2.5  kHz
-    //         3 = 3.0  kHz
-    //         4 = 3.75 kHz
-    //         5 = 4.0  kHz
-    //         6 = 4.25 kHz
-    //         7 = 4.5  kHz
-    // if <5> == 1, RF filter bandwidth * 2
+    // <14:12> RF filter bandwidth (Apass = 0.1dB)
+    //         000 = 2.0 kHz
+    //         001 = 2.5 kHz
+    //         010 = 3.0 kHz
+    //         011 = 3.5 kHz
+    //         100 = 4.0 kHz
+    //         101 = 4.5 kHz
+    //         110 = 5.0 kHz
+    //         111 = 5.5 kHz
+    // if REG_43<5> == 1, RF filter bandwidth *= 2
     //
-    // <11:9>  0 RF filter bandwidth when signal is weak
-    //         0 = 1.7  kHz
-    //         1 = 2.0  kHz
-    //         2 = 2.5  kHz
-    //         3 = 3.0  kHz
-    //         4 = 3.75 kHz
-    //         5 = 4.0  kHz
-    //         6 = 4.25 kHz
-    //         7 = 4.5  kHz
-    // if <5> == 1, RF filter bandwidth * 2
+    // <11:9> RF filter bandwidth when signal is weak (Apass = 0.1dB)
+    //         000 = 2.0 kHz
+    //         001 = 2.5 kHz
+    //         010 = 3.0 kHz
+    //         011 = 3.5 kHz
+    //         100 = 4.0 kHz
+    //         101 = 4.5 kHz
+    //         110 = 5.0 kHz
+    //         111 = 5.5 kHz
+    // if REG_43<5> == 1, RF filter bandwidth *= 2
     //
-    // <8:6>   1 AFTxLPF2 filter Band Width
-    //         1 = 2.5  kHz (for 12.5k channel space)
-    //         2 = 2.75 kHz
-    //         0 = 3.0  kHz (for 25k   channel space)
-    //         3 = 3.5  kHz
-    //         4 = 4.5  kHz
-    //         5 = 4.25 kHz
-    //         6 = 4.0  kHz
-    //         7 = 3.75 kHz
+    // <8:6> AF Tx LPF2 filter bandwidth (Apass = 1dB)
+    //         100 = 5.5 kHz
+    //         101 = 5.0 kHz
+    //         110 = 4.5 kHz
+    //         111 = 4.0 kHz
+    //         000 = 3.0 kHz
+    //         001 = 2.5 kHz
+    //         010 = 2.75 kHz
+    //         011 = 3.5 kHz
     //
-    // <5:4>   0 BW Mode Selection
-    //         0 = 12.5k
-    //         1 =  6.25k
-    //         2 = 25k/20k
+    // <5:4> BW mode selection
+    //         00 = 12.5k
+    //         01 =  6.25k
+    //         10 = 25k/20k
     //
-    // <3>     1 ???
+    // <2> gain after FM demodulation
+    //         0 = 0 dB
+    //         1 = 6 dB
     //
-    // <2>     0 Gain after FM Demodulation
-    //         0 = 0dB
-    //         1 = 6dB
-    //
-    // <1:0>   0 ???
+    // <3> and <1:0> remain undocumented here.
 
     uint16_t val = 0;
     switch (Bandwidth)
     {
         case BK4819_FILTER_BW_WIDE: // 25kHz
-            // if (weak_no_different) {
-            //     // make the RX bandwidth the same with weak signals
-            //     val = 0x3628; // Old value 0x49a8 < v3.6
-            // } else {
-            //     // with weak RX signals the RX bandwidth is reduced
-            //     val = 0x3428; // Old value 0x45a8 < v3.6
-            // }
+            // 0x3028 = (0b011 << 12) | (0b000 << 9) | (0b000 << 6) |
+            //          (0b10 << 4)  | (1 << 3)
+            //        = RF 3.5 kHz and weak-RF 2.0 kHz, both doubled because
+            //          bit<5> is set in 25k/20k mode => RF 7.0 kHz, weak-RF
+            //          4.0 kHz, AF Tx LPF2 3.0 kHz, FM gain 0 dB.
             val = 0x3028;
             break;
 
         case BK4819_FILTER_BW_NARROW:   // 12.5kHz
-            // if (weak_no_different) {
-            //     // make the RX bandwidth the same with weak signals
-            //     val = 0x3648; // Old value 0x4808 < v3.6
-            // } else {
-            //     // with weak RX signals the RX bandwidth is reduced
-            //     val = 0x3448; // Old value 0x4408 < v3.6
-            // }
+            // 0x4048 = (0b100 << 12) | (0b000 << 9) | (0b001 << 6) |
+            //          (0b00 << 4)  | (1 << 3)
+            //        = RF 4.0 kHz, weak-RF 2.0 kHz, AF Tx LPF2 2.5 kHz,
+            //          12.5k mode, FM gain 0 dB.
             val = 0x4048;
             break;
 
         case BK4819_FILTER_BW_NARROWER: // 6.25kHz
-            // if (weak_no_different) {
-            //     // make the RX bandwidth the same with weak signals
-            //     val = 0x1348; // Old value 0x3658 < v3.6
-            // } else {
-            //     // with weak RX signals the RX bandwidth is reduced
-            //     val = 0x1148; // Old value 0x3658 < v3.6
-            // }
+            // 0x205C = (0b010 << 12) | (0b000 << 9) | (0b001 << 6) |
+            //          (0b01 << 4)  | (1 << 3)     | (1 << 2)
+            //        = RF 3.0 kHz, weak-RF 2.0 kHz, AF Tx LPF2 2.5 kHz,
+            //          6.25k mode, FM gain +6 dB.
             val = 0x205C;
             break;
 
-        /*
-        case BK4819_FILTER_BW_AM:   // 8.33kHz
-            // if (weak_no_different) {
-            //     // make the RX bandwidth the same with weak signals
-            //     val = 0x4858;
-            // } else {
-            //     // with weak RX signals the RX bandwidth is reduced
-            //     val = 0x4458;
-            // }
+        case BK4819_FILTER_BW_AM:   // Stock AM preset
+            // 0x345C = (0b011 << 12) | (0b010 << 9) | (0b001 << 6) |
+            //          (0b01 << 4)  | (1 << 3)     | (1 << 2)
+            //        = RF 3.5 kHz, weak-RF 3.0 kHz, AF Tx LPF2 2.5 kHz,
+            //          6.25k mode, bit<2> set. The "8.33kHz AM" label used in
+            //          the codebase is functional/empirical; it does not come
+            //          directly from the BW mode bits of REG_43.
             val = 0x345C;
             break;
-        */
+
         default:
             val = 0x5C;
             break;
@@ -803,21 +766,20 @@ void BK4819_SetupSquelch(
     // <13:11> 5 Squelch = open  Delay Setting
     //         0 ~ 7
     //
-    // <10:9>  7 Squelch = close Delay Setting
+    // <10:9>  3 Squelch = close Delay Setting
     //         0 ~ 3
     //
-    // <8>     0 ???
+    // <8>     1 ???
     //
     // <7:0>   8 Glitch threshold for Squelch = open
     //         0 ~ 255
     //
-    BK4819_WriteRegister(BK4819_REG_4E,  // 01 101 11 1 00000000
-
-        // original (*)
-    (1u << 14) |                  //  1 ???
-    (5u << 11) |                  // *5  squelch = open  delay .. 0 ~ 7
-    (6u <<  9) |                  // *3  squelch = close delay .. 0 ~ 3
-    SquelchOpenGlitchThresh);     //  0 ~ 255
+    BK4819_WriteRegister(BK4819_REG_4E,
+    (1u << 14) |                  // 1 ???
+    (5u << 11) |                  // 5 squelch = open  delay .. 0 ~ 7
+    (3u <<  9) |                  // 3 squelch = close delay .. 0 ~ 3
+    (1u <<  8) |                  // 1 ??? (matches stock BK4829)
+    SquelchOpenGlitchThresh);     // 0 ~ 255
 
 
     // REG_4F
@@ -1160,45 +1122,62 @@ void BK4819_Idle(void)
     BK4819_WriteRegister(BK4819_REG_30, 0x0000);
 }
 
+#ifdef ENABLE_BYP_RAW_DEMODULATORS
+void BK4819_EnterBypass(void)
+{
+    // Keep AF output on normal path (REG_47 mode 0x1 is documented on BK4829).
+    BK4819_SetAF(BK4819_AF_FM);
+
+    // Bypass all AF filters (Rx + Tx) as recommended for digital bypass mode.
+    // REG_2B:
+    //  bit10: Disable AF Rx HPF300
+    //  bit 9: Disable AF Rx LPF3K
+    //  bit 8: Disable AF Rx de-emphasis
+    //  bit 2: Disable AF Tx HPF300
+    //  bit 1: Disable AF Tx LPF1
+    //  bit 0: Disable AF Tx pre-emphasis
+    uint16_t reg2b = BK4819_ReadRegister(BK4819_REG_2B);
+    reg2b |= (1u << 10) | (1u << 9) | (1u << 8) | (1u << 2) | (1u << 1) | (1u << 0);
+    BK4819_WriteRegister(BK4819_REG_2B, reg2b);
+
+    // Keep AGC/AFC behavior aligned with FM-like bypass experiments.
+    BK4819_SetRegValue(afcDisableRegSpec, false);
+}
+
+void BK4819_EnterRaw(void)
+{
+    // Keep AF output on a documented mode.
+    BK4819_SetAF(BK4819_AF_FM);
+
+    // RAW profile: bypass RX AF filters only, keep TX filter path unchanged.
+    // REG_2B:
+    //  bit10: Disable AF Rx HPF300
+    //  bit 9: Disable AF Rx LPF3K
+    //  bit 8: Disable AF Rx de-emphasis
+    uint16_t reg2b = BK4819_ReadRegister(BK4819_REG_2B);
+    reg2b |= (1u << 10) | (1u << 9) | (1u << 8);
+    reg2b &= ~((1u << 2) | (1u << 1) | (1u << 0));
+    BK4819_WriteRegister(BK4819_REG_2B, reg2b);
+
+    // RAW profile keeps AFC disabled to preserve discriminator-like behavior.
+    BK4819_SetRegValue(afcDisableRegSpec, true);
+}
+#endif
+
 void BK4819_ExitBypass(void)
 {
     BK4819_SetAF(BK4819_AF_MUTE);
 
-    // REG_7E
-    //
-    // <15>    0 AGC fix mode
-    //         1 = fix
-    //         0 = auto
-    //
-    // <14:12> 3 AGC fix index
-    //         3 ( 3) = max
-    //         2 ( 2)
-    //         1 ( 1)
-    //         0 ( 0)
-    //         7 (-1)
-    //         6 (-2)
-    //         5 (-3)
-    //         4 (-4) = min
-    //
-    // <11:6>  0 ???
-    //
-    // <5:3>   5 DC filter band width for Tx (MIC In)
-    //         0 ~ 7
-    //         0 = bypass DC filter
-    //
-    // <2:0>   6 DC filter band width for Rx (I.F In)
-    //         0 ~ 7
-    //         0 = bypass DC filter
-    //
+#ifdef ENABLE_BYP_RAW_DEMODULATORS
+    // Restore normal AF filters.
+    uint16_t reg2b = BK4819_ReadRegister(BK4819_REG_2B);
+    reg2b &= ~((1u << 10) | (1u << 9) | (1u << 8) | (1u << 2) | (1u << 1) | (1u << 0));
+    BK4819_WriteRegister(BK4819_REG_2B, reg2b);
+#endif
 
+    // Keep existing REG_7E logic from your current implementation.
     uint16_t regVal = BK4819_ReadRegister(BK4819_REG_7E);
-
-    // 0x302E / 0 011 000000 101 110
-    BK4819_WriteRegister(BK4819_REG_7E, (regVal & ~(0b111 << 3))
-
-        | (5u <<  3)       // 5  DC Filter band width for Tx (MIC In)
-
-    );
+    BK4819_WriteRegister(BK4819_REG_7E, (regVal & ~(0b111 << 3)) | (5u << 3));
 }
 
 void BK4819_PrepareTransmit(void)

App/driver/eeprom_compat.c

@@ -38,30 +38,34 @@ typedef struct
 #define _MK_MAPPING(PY25Q16_Addr, EEPROM_From, EEPROM_To) {PY25Q16_Addr, EEPROM_From, EEPROM_To - EEPROM_From}
 
 static const AddrMapping_t ADDR_MAPPINGS[] = {
-    // Sorted by EEPROM addr
-    _MK_MAPPING(0x000000, 0x0000, 0x0c80),  //
-    _MK_MAPPING(0x001000, 0x0c80, 0x0d60),  //
-    _MK_MAPPING(0x002000, 0x0d60, 0x0e30),  //
-    _MK_MAPPING(HOLE_ADDR, 0x0e30, 0x0e40), //
-    _MK_MAPPING(0x003000, 0x0e40, 0x0e68),  //
-    _MK_MAPPING(HOLE_ADDR, 0x0e68, 0x0e70), //
-    _MK_MAPPING(0x004000, 0x0e70, 0x0e80),  //
-    _MK_MAPPING(0x005000, 0x0e80, 0x0e88),  //
-    _MK_MAPPING(0x006000, 0x0e88, 0x0e90),  //
-    _MK_MAPPING(0x007000, 0x0e90, 0x0ee0),  //
-    _MK_MAPPING(0x008000, 0x0ee0, 0x0f18),  //
-    _MK_MAPPING(0x009000, 0x0f18, 0x0f20),  //
-    _MK_MAPPING(HOLE_ADDR, 0x0f20, 0x0f30), //
-    _MK_MAPPING(0x00a000, 0x0f30, 0x0f40),  //
-    _MK_MAPPING(0x00b000, 0x0f40, 0x0f48),  //
-    _MK_MAPPING(HOLE_ADDR, 0x0f48, 0x0f50), //
-    _MK_MAPPING(0x00e000, 0x0f50, 0x1bd0),  //
-    _MK_MAPPING(HOLE_ADDR, 0x1bd0, 0x1c00), //
-    _MK_MAPPING(0x00f000, 0x1c00, 0x1d00),  //
-    _MK_MAPPING(HOLE_ADDR, 0x1d00, 0x1e00), //
-    _MK_MAPPING(0x010000, 0x1e00, 0x1f90),  //
-    _MK_MAPPING(HOLE_ADDR, 0x1f90, 0x1ff0), //
-    _MK_MAPPING(0x00c000, 0x1ff0, 0x2000),  //
+    _MK_MAPPING(0x000000, 0x000000, 0x001000),  // 256 MR Freq * 16 Bytes (ex 0x000000)
+    _MK_MAPPING(0x001000, 0x001000, 0x002000),  // 256 MR Freq * 16 Bytes
+    _MK_MAPPING(0x002000, 0x002000, 0x003000),  // 256 MR Freq * 16 Bytes
+    _MK_MAPPING(0x003000, 0x003000, 0x004000),  // 256 MR Freq * 16 Bytes
+
+    _MK_MAPPING(0x004000, 0x004000, 0x005000),  // 256 MR Name * 16 Bytes (ex 0x00e000)
+    _MK_MAPPING(0x005000, 0x005000, 0x006000),  // 256 MR Name * 16 Bytes
+    _MK_MAPPING(0x006000, 0x006000, 0x007000),  // 256 MR Name * 16 Bytes
+    _MK_MAPPING(0x007000, 0x007000, 0x008000),  // 256 MR Name * 16 Bytes
+
+    _MK_MAPPING(0x008000, 0x008000, 0x00886E),  // 1024 MR  + 7 VFO Attributes * 2 Bytes (ex 0x002000) 0x008000 -> 0x00880E
+                                                // List name * 4 Bytes 0x00880E -> 0x00886E
+
+    _MK_MAPPING(0x009000, 0x009000, 0x0090D6),  // 14 VFO * 16 Bytes (ex 0x001000)
+
+    _MK_MAPPING(0x00A000, 0x00A000, 0x00A170),  // Settings * 16 Bytes (ex 0x004000)        0x00A000 -> 0x00A010
+                                                // Settings * 16 Bytes (ex 0x005000)        0x00A010 -> 0x00A020
+                                                // Settings FM * 8 Bytes (0x006000)         0x00A020 -> 0x00A028
+                                                // 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 * 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!!!
 };
 
 static void AddrTranslate(uint16_t EEPROM_Addr, uint16_t Size, uint32_t *PY25Q16_Addr_out, uint16_t *Size_out, bool *End_out);

App/driver/i2c.c

@@ -22,6 +22,11 @@
 #define PIN_SCL     GPIO_MAKE_PIN(GPIOF, LL_GPIO_PIN_5)
 #define PIN_SDA     GPIO_MAKE_PIN(GPIOF, LL_GPIO_PIN_6)
 
+// CRITICAL FIX: Define I2C timeout to prevent infinite hangs
+// If I2C slave doesn't respond, timeout after this many iterations
+// 255 iterations × 1µs = 255µs, plus we add safety margin
+#define I2C_ACK_TIMEOUT_ITERATIONS 255
+
 static inline void SCL_Set()
 {
     GPIO_SetOutputPin(PIN_SCL);
@@ -141,11 +146,24 @@ int I2C_Write(uint8_t Data)
     SCL_Set();
     SYSTICK_DelayUs(1);
 
-    for (i = 0; i < 255; i++) {
+    // CRITICAL FIX #1: Add timeout to ACK check
+    // Original: for (i = 0; i < 255; i++)
+    // Problem: If I2C slave doesn't respond, waits 255 iterations = 255µs spin-wait
+    // If slave broken/disconnected: loops forever with no break condition
+    //
+    // Solution: Keep iteration limit but add explicit timeout check
+    // If slave doesn't pull SDA low within 255 iterations, return error
+    // This prevents indefinite hangs while still being conservative
+    
+    for (i = 0; i < I2C_ACK_TIMEOUT_ITERATIONS; i++) {
         if (!SDA_IsSet()) {
             ret = 0;
             break;
         }
+        // CRITICAL FIX #2: Small delay between ACK checks
+        // This prevents CPU from spinning 255 times at full speed
+        // Also gives slave time to respond
+        SYSTICK_DelayUs(1);
     }
 
     SCL_Reset();
@@ -178,11 +196,17 @@ int I2C_WriteBuffer(const void *pBuffer, uint8_t Size)
     uint8_t i;
 
     for (i = 0; i < Size; i++) {
+        // CRITICAL FIX #3: Check return value of I2C_Write
+        // Original: if (I2C_Write(*pData++) < 0)
+        // This detects if ACK timeout occurred
+        // If slave not responding, return error immediately instead of continuing
         if (I2C_Write(*pData++) < 0) {
+            // I2C slave not responding (ACK timeout)
+            // Return error instead of continuing to write more bytes
+            // This prevents cascading timeouts
             return -1;
         }
     }
 
     return 0;
-}
-
+}

App/driver/keyboard.c

@@ -27,6 +27,84 @@ KEY_Code_t gKeyReading1     = KEY_INVALID;
 uint16_t   gDebounceCounter = 0;
 bool       gWasFKeyPressed  = false;
 
+#ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+// Short press: hold key for SERIAL_KEY_SHORT_POLLS calls.
+// Must exceed key_debounce_10ms (2) to trigger ProcessKey(key, true, false).
+#define SERIAL_KEY_SHORT_POLLS  5
+
+// Long press: hold key for SERIAL_KEY_LONG_POLLS calls.
+// Must exceed key_repeat_delay_10ms (40) to trigger ProcessKey(key, true, true).
+#define SERIAL_KEY_LONG_POLLS   45
+
+// Packet types for serial key injection (K5Viewer → radio)
+#define SERIAL_KEY_TYPE         0x03
+#define SERIAL_KEY_TYPE_LONG    0x04
+
+volatile KEY_Code_t gKeyFromSerial      = KEY_INVALID;
+static   uint8_t    gSerialKeyHoldCount = 0;
+static   uint8_t    gSerialKeyLong      = 0;  // 0 = short press, 1 = long press
+
+// Inject a short or long press from serial (UART or VCP).
+// KEY_PTT is explicitly blocked — PTT release cannot be guaranteed over serial.
+static inline void KEYBOARD_InjectKey(uint8_t keyCode, bool keyLong)
+{
+    if (keyCode < KEY_INVALID && keyCode != KEY_PTT) {
+        gKeyFromSerial      = (KEY_Code_t)keyCode;
+        gSerialKeyHoldCount = 0;
+        gSerialKeyLong      = keyLong;
+    }
+}
+
+bool KEYBOARD_ProcessProtocolByte(ParseState_t *state, uint8_t b)
+{
+    bool connected = false;
+
+    switch (*state)
+    {
+        case STATE_IDLE:
+            if      (b == 0x55) *state = STATE_KA_1;
+            else if (b == 0xAA) *state = STATE_KEY_1;
+            break;
+            
+        case STATE_KA_1:
+            *state = (b == 0xAA) ? STATE_KA_2 : STATE_IDLE;
+            break;
+            
+        case STATE_KA_2:
+            *state = (b == 0x00) ? STATE_KA_3 : STATE_IDLE;
+            break;
+            
+        case STATE_KA_3:
+            if (b == 0x00) connected = true;
+            *state = STATE_IDLE;
+            break;
+            
+        case STATE_KEY_1:
+            *state = (b == 0x55) ? STATE_KEY_2 : STATE_IDLE;
+            break;
+            
+        case STATE_KEY_2:
+            if      (b == SERIAL_KEY_TYPE)      *state = STATE_KEY_3;
+            else if (b == SERIAL_KEY_TYPE_LONG) *state = STATE_KEY_3L;
+            else                                *state = STATE_IDLE;
+            break;
+            
+        case STATE_KEY_3:
+        case STATE_KEY_3L:
+            KEYBOARD_InjectKey(b, *state == STATE_KEY_3L);
+            connected = true;
+            *state = STATE_IDLE;
+            break;
+
+        default:
+            *state = STATE_IDLE;
+            break;
+    }
+
+    return connected;
+}
+#endif
+
 #define GPIOx               GPIOB
 #define PIN_MASK_COLS       (LL_GPIO_PIN_6 | LL_GPIO_PIN_5 | LL_GPIO_PIN_4 | LL_GPIO_PIN_3)
 #define PIN_COLS            GPIO_MAKE_PIN(GPIOx, PIN_MASK_COLS)
@@ -78,38 +156,80 @@ static const KEY_Code_t keyboard[5][4] = {
 
 KEY_Code_t KEYBOARD_Poll(void)
 {
+#ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+    // Serial-injected key: hold it for SHORT or LONG polls depending on press type,
+    // so the debounce counter in app.c reaches the right threshold:
+    //   - Short: key_debounce_10ms (2)  → ProcessKey(key, true, false)
+    //   - Long:  key_repeat_delay_10ms (40) → ProcessKey(key, true, true)
+    // Once the hold count is exhausted we clear it — next call returns KEY_INVALID,
+    // which triggers the release path in app.c naturally.
+    if (gKeyFromSerial != KEY_INVALID) {
+        KEY_Code_t injected  = gKeyFromSerial;
+        uint8_t    threshold = gSerialKeyLong ? SERIAL_KEY_LONG_POLLS : SERIAL_KEY_SHORT_POLLS;
+        if (++gSerialKeyHoldCount >= threshold) {
+            gKeyFromSerial      = KEY_INVALID;
+            gSerialKeyHoldCount = 0;
+            gSerialKeyLong      = 0;
+        }
+        return injected;
+    }
+#endif
+
     KEY_Code_t Key = KEY_INVALID;
 
-    //  if (!GPIO_CheckBit(&GPIOC->DATA, GPIOC_PIN_PTT))
-    //      return KEY_PTT;
-
-    // *****************
-
+    // Scan all 5 columns - never break early to avoid GPIO state issues
     for (unsigned int j = 0; j < 5; j++)
     {
         uint32_t reg;
-        unsigned int i;
-        unsigned int k;
+        uint32_t match_count = 0;  // Count consecutive matching reads
 
-        // Set all high
+        // Set all columns high first
         GPIO_SetOutputPin(PIN_COLS);
 
-        // Clear the pin we are selecting
+        // Clear the specific column we are selecting
         if (j > 0)
-            GPIO_ResetOutputPin(PIN_COL(j - 1));
-
-        // Read all 4 GPIO pins at once .. with de-noise, max of 8 sample loops
-        for (i = 0, k = 0, reg = 0; i < 3 && k < 8; i++, k++)
         {
-            SYSTICK_DelayUs(1);
-            uint32_t reg2 = read_rows();
-            i *= reg == reg2;
-            reg = reg2;
+            GPIO_ResetOutputPin(PIN_COL(j - 1));
         }
 
-        if (i < 3)
-            break; // noise is too bad
+        // Debounce: Read rows multiple times and look for stable reads
+        // CRITICAL FIX #1: Proper debounce logic (replaces confusing i *= syntax)
+        // CRITICAL FIX #2: Increased delay from 1µs to 10µs for real keyboard bounce capture
+        // CRITICAL FIX #3: Clear match_count if reads differ (noise detection)
+        reg = 0;
+        for (unsigned int k = 0; k < 8; k++)
+        {
+            SYSTICK_DelayUs(10);  // FIX #2: Increased from 1µs to 10µs
+            uint32_t reg2 = read_rows();
+            
+            // FIX #3: Clear match counter if values don't match
+            if (reg2 != reg)
+            {
+                match_count = 0;
+                reg = reg2;
+            }
+            else
+            {
+                match_count++;
+            }
+            
+            // Success: We have 3 consecutive matching reads = stable signal
+            if (match_count >= 2)
+            {
+                break;  // Debounce complete for this column
+            }
+        }
 
+        // FIX #1: Do NOT break on noise - continue scanning all columns
+        // Only skip key detection if debounce failed, but GPIO state is cleaned
+        if (match_count < 2)
+        {
+            // Debounce failed (too much noise), but continue to next column
+            // This prevents GPIO from staying in invalid state and blocking other columns
+            continue;
+        }
+
+        // Debounce successful, check which row is pressed in this column
         for (unsigned int i = 0; i < 4; i++)
         {
             if (!(reg & PIN_MASK_ROW(i)))
@@ -120,8 +240,29 @@ KEY_Code_t KEYBOARD_Poll(void)
         }
 
         if (Key != KEY_INVALID)
-            break;
+        {
+            break;  // Found a valid key, stop scanning
+        }
     }
 
+    // CRITICAL FIX #4: Always clean up GPIO state - set all columns high at end
+    // This ensures GPIO pins are in a known state even if function exited early due to noise
+    GPIO_SetOutputPin(PIN_COLS);
+
     return Key;
 }
+
+KEY_Code_t KEYBOARD_GetKey(void)
+{
+    KEY_Code_t btn = KEYBOARD_Poll();
+    if (btn == KEY_INVALID && GPIO_IsPttPressed())
+    {
+        btn = KEY_PTT;
+    }
+    return btn;
+}
+
+void HideFKeyIcon(void) {
+    gWasFKeyPressed       = false;
+    gUpdateStatus         = true;
+}

App/driver/keyboard.h

@@ -45,12 +45,32 @@ enum KEY_Code_e {
 };
 typedef enum KEY_Code_e KEY_Code_t;
 
+typedef enum {
+    STATE_IDLE = 0,
+    STATE_KA_1,
+    STATE_KA_2,
+    STATE_KA_3,
+    STATE_KEY_1,
+    STATE_KEY_2,
+    STATE_KEY_3,
+    STATE_KEY_3L,
+} ParseState_t;
+
 extern KEY_Code_t gKeyReading0;
 extern KEY_Code_t gKeyReading1;
 extern uint16_t   gDebounceCounter;
 extern bool       gWasFKeyPressed;
 
-KEY_Code_t KEYBOARD_Poll(void);
+#ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+// Serial-injected key (written by UART/VCP parser, consumed by KEYBOARD_Poll).
+extern volatile KEY_Code_t gKeyFromSerial;
 
+bool KEYBOARD_ProcessProtocolByte(ParseState_t *state, uint8_t b);
 #endif
 
+KEY_Code_t KEYBOARD_Poll(void);
+KEY_Code_t KEYBOARD_GetKey(void);
+
+void HideFKeyIcon(void);
+
+#endif

App/driver/py25q16.c

@@ -25,6 +25,7 @@
 #include "driver/system.h"
 #include "driver/systick.h"
 #include "external/printf/printf.h"
+#include "misc.h"
 
 // #define DEBUG
 
@@ -39,7 +40,7 @@
 
 static uint32_t SectorCacheAddr = 0x1000000;
 static uint8_t SectorCache[SECTOR_SIZE];
-static uint8_t BlackHole[1];
+static uint8_t BlackHole[4] __attribute__((aligned(4)));
 static volatile bool TC_Flag;
 
 static inline void CS_Assert()
@@ -226,20 +227,20 @@ void PY25Q16_Init()
 
 void PY25Q16_ReadBuffer(uint32_t Address, void *pBuffer, uint32_t Size)
 {
-#ifdef DEBUG
-    printf("spi flash read: %06x %ld\n", Address, Size);
-#endif
     CS_Assert();
 
-    SPI_WriteByte(0x03); // Fast read
-    WriteAddr(Address);
+    SPI_WriteByte(0x03);      // Send read command
+    WriteAddr(Address);        // Send address (3 bytes)
 
-    if (Size >= 16)
+    // CRITICAL: Flush RX FIFO before DMA to remove residual data
+    while (LL_SPI_RX_FIFO_EMPTY != LL_SPI_GetRxFIFOLevel(SPIx))
     {
-        SPI_ReadBuf((uint8_t *)pBuffer, Size);
+        LL_SPI_ReceiveData8(SPIx);  // Read and discard
     }
-    else
-    {
+
+    if (Size >= 16) {
+        SPI_ReadBuf((uint8_t *)pBuffer, Size);
+    } else {
         for (uint32_t i = 0; i < Size; i++)
         {
             ((uint8_t *)(pBuffer))[i] = SPI_WriteByte(0xff);
@@ -254,6 +255,11 @@ void PY25Q16_WriteBuffer(uint32_t Address, const void *pBuffer, uint32_t Size, b
 #ifdef DEBUG
     printf("spi flash write: %06x %ld %d\n", Address, Size, Append);
 #endif
+
+    //#ifdef ENABLE_FEAT_F4HWN_DEBUG
+    //    gDebug++;
+    //#endif
+
     uint32_t SecIndex = Address / SECTOR_SIZE;
     uint32_t SecAddr = SecIndex * SECTOR_SIZE;
     uint32_t SecOffset = Address % SECTOR_SIZE;
@@ -261,6 +267,9 @@ void PY25Q16_WriteBuffer(uint32_t Address, const void *pBuffer, uint32_t Size, b
 
     while (Size)
     {
+        // CRITICAL FIX #1: Wait for flash ready before processing each sector
+        WaitWIP();
+
         if (Size < SecSize)
         {
             SecSize = Size;
@@ -289,6 +298,10 @@ void PY25Q16_WriteBuffer(uint32_t Address, const void *pBuffer, uint32_t Size, b
             if (Erase)
             {
                 SectorErase(SecAddr);
+
+                // CRITICAL FIX #2: Erase takes ~300ms, must complete before program starts
+                WaitWIP();
+
                 if (Append)
                 {
                     SectorProgram(SecAddr, SectorCache, SecOffset + SecSize);
@@ -313,6 +326,9 @@ void PY25Q16_WriteBuffer(uint32_t Address, const void *pBuffer, uint32_t Size, b
         SecOffset = 0;
         SecSize = SECTOR_SIZE;
     } // while
+
+    // CRITICAL FIX #3: Ensure all writes complete before function returns
+    WaitWIP();
 }
 
 void PY25Q16_SectorErase(uint32_t Address)
@@ -454,11 +470,20 @@ void DMA1_Channel4_5_6_7_IRQHandler()
         LL_DMA_DisableIT_TC(DMA1, CHANNEL_RD);
         LL_DMA_ClearFlag_TC4(DMA1);
 
-        while (LL_SPI_TX_FIFO_EMPTY != LL_SPI_GetTxFIFOLevel(SPIx))
+        // Wait a tiny bit for SPI to finish
+        SYSTICK_DelayUs(10);  // ← ADD THIS
+
+        uint32_t timeout = 10000;
+        
+        while ((LL_SPI_TX_FIFO_EMPTY != LL_SPI_GetTxFIFOLevel(SPIx)) && timeout--)
             ;
-        while (LL_SPI_IsActiveFlag_BSY(SPIx))
+        
+        timeout = 10000;
+        while (LL_SPI_IsActiveFlag_BSY(SPIx) && timeout--)
             ;
-        while (LL_SPI_RX_FIFO_EMPTY != LL_SPI_GetRxFIFOLevel(SPIx))
+        
+        timeout = 10000;
+        while ((LL_SPI_RX_FIFO_EMPTY != LL_SPI_GetRxFIFOLevel(SPIx)) && timeout--)
             ;
 
         LL_SPI_DisableDMAReq_TX(SPIx);
@@ -466,4 +491,4 @@ void DMA1_Channel4_5_6_7_IRQHandler()
 
         TC_Flag = true;
     }
-}
+}

App/driver/st7565.c

@@ -24,6 +24,7 @@
 #include "driver/st7565.h"
 #include "driver/system.h"
 #include "misc.h"
+#include "screenshot.h"
 
 #define SPIx SPI1
 
@@ -163,6 +164,9 @@ void ST7565_DrawLine(const unsigned int Column, const unsigned int Line, const u
     void ST7565_BlitLine(unsigned line)
     {
         ST7565_BlitScreen(line + 1);
+        #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+            SCREENSHOT_Update(true);  // Force immediate capture
+        #endif
     }
 
     void ST7565_BlitStatusLine(void)

App/driver/systick.c

@@ -13,39 +13,44 @@
  *     See the License for the specific language governing permissions and
  *     limitations under the License.
  */
-
 #include "py32f0xx.h"
 #include "systick.h"
 #include "misc.h"
-
 // 0x20000324
 static uint32_t gTickMultiplier;
-
 void SYSTICK_Init(void)
 {
-    SysTick_Config(480000);
-    gTickMultiplier = 48;
+    SysTick_Config(SystemCoreClock / 100); // 10 ms (1/100 sec) systick interrupt
+    gTickMultiplier = SystemCoreClock / 1000000;
 
     NVIC_SetPriority(SysTick_IRQn, 0);
 }
-
 void SYSTICK_DelayUs(uint32_t Delay)
 {
     const uint32_t ticks = Delay * gTickMultiplier;
     uint32_t elapsed_ticks = 0;
     uint32_t Start = SysTick->LOAD;
     uint32_t Previous = SysTick->VAL;
-    do {
-        uint32_t Current;
-
-        do {
-            Current = SysTick->VAL;
-        } while (Current == Previous);
-
-        uint32_t Delta = ((Current < Previous) ? - Current : Start - Current);
-
-        elapsed_ticks += Delta + Previous;
-
+    
+    // FIX: Simplified loop - removed inner "wait for change" loop
+    while (elapsed_ticks < ticks)
+    {
+        uint32_t Current = SysTick->VAL;
+        
+        // FIX: Corrected wraparound detection (was: "Current < Previous - 10")
+        if (Current < Previous)
+        {
+            // Normal countdown case
+            uint32_t Delta = Previous - Current;
+            elapsed_ticks += Delta;
+        }
+        else if (Current > Previous)
+        {
+            // Wraparound case: SysTick went 0 → LOAD → Current
+            uint32_t Delta = Previous + (Start - Current);
+            elapsed_ticks += Delta;
+        }
+        
         Previous = Current;
-    } while (elapsed_ticks < ticks);
-}
+    }
+}

App/driver/uart.c

@@ -22,11 +22,19 @@
 #include "py32f071_ll_dma.h"
 #include "py32f071_ll_gpio.h"
 #include "py32f071_ll_usart.h"
-#include "driver/uart.h"
+
+#ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+#include "driver/keyboard.h"
+#endif
 
 #define USARTx USART1
 #define DMA_CHANNEL LL_DMA_CHANNEL_2
 
+// CRITICAL FIX: Define UART TX timeout
+// If UART TX buffer doesn't clear within this many iterations, skip byte and continue
+// Prevents permanent freeze if UART is stuck
+#define UART_TX_TIMEOUT_ITERATIONS 10000
+
 static bool UART_IsLogEnabled;
 uint8_t UART_DMA_Buffer[256];
 
@@ -111,9 +119,27 @@ void UART_Send(const void *pBuffer, uint32_t Size)
 
     for (i = 0; i < Size; i++)
     {
-        while (!LL_USART_IsActiveFlag_TXE(USARTx))
-            ;
-        LL_USART_TransmitData8(USARTx, pData[i]);
+        // CRITICAL FIX: Add timeout to UART TX busy-wait
+        // Original: while (!LL_USART_IsActiveFlag_TXE(USARTx)) ;
+        // Problem: If UART TX stuck or disconnected, this is infinite loop
+        // Result: Radio freeze for 100ms+ while trying to send one character
+        //
+        // Solution: Add iteration counter timeout
+        // If TXE flag doesn't set within timeout iterations, skip byte and continue
+        // This caps maximum freeze at ~10ms per UART_Send() call
+        
+        uint32_t timeout = UART_TX_TIMEOUT_ITERATIONS;
+        while (!LL_USART_IsActiveFlag_TXE(USARTx) && timeout > 0)
+        {
+            timeout--;
+        }
+        
+        // Send byte only if TXE flag is set
+        // If timeout occurred, skip this byte and continue
+        if (timeout > 0)
+        {
+            LL_USART_TransmitData8(USARTx, pData[i]);
+        }
     }
 }
 
@@ -126,12 +152,26 @@ void UART_LogSend(const void *pBuffer, uint32_t Size)
 
 #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
     bool UART_IsCableConnected(void) {
-        for (size_t i = 0; i < sizeof(UART_DMA_Buffer); i++) {
-            if (UART_DMA_Buffer[i] == 0x55) {
-                UART_DMA_Buffer[i] = 0x00;  // Clear only the matched byte
-                return true;
-            }
+        static uint8_t     read_ptr = 0;
+        static ParseState_t state   = STATE_IDLE;
+
+        bool connected = false;
+
+        // DMA write position: NbData counts DOWN from 256
+        uint8_t write_ptr = (uint8_t)(sizeof(UART_DMA_Buffer) - 
+                                       LL_DMA_GetDataLength(DMA1, DMA_CHANNEL));
+
+        uint8_t processed = 0;
+        while (read_ptr != write_ptr && processed < sizeof(UART_DMA_Buffer))
+        {
+            uint8_t b = UART_DMA_Buffer[read_ptr++];
+            // read_ptr wraps naturally at 256 since it's uint8_t
+            processed++;
+
+            if(KEYBOARD_ProcessProtocolByte(&state, b))
+                connected = true;
         }
-        return false;
+
+        return connected;
     }
-#endif
+#endif

App/driver/vcp.c

@@ -18,6 +18,10 @@
 #include "usb_config.h"
 #include "py32f071_ll_bus.h"
 
+#ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+#include "driver/keyboard.h"
+#endif
+
 uint8_t VCP_RxBuf[VCP_RX_BUF_SIZE];
 volatile uint32_t VCP_RxBufPointer = 0;
 
@@ -37,3 +41,52 @@ void VCP_Init()
     NVIC_SetPriority(USBD_IRQn, 3);
     NVIC_EnableIRQ(USBD_IRQn);
 }
+
+#ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+bool VCP_ScreenshotPing(void)
+{
+    // State machine for parsing incoming packets:
+    //   Keepalive:       0x55 0xAA 0x00 0x00  → viewer alive
+    //   Short key press: 0xAA 0x55 0x03 <key> → inject short press
+    //   Long key press:  0xAA 0x55 0x04 <key> → inject long press
+    //
+    // State transitions:
+    //   IDLE  → 0x55 → KA_1
+    //   KA_1  → 0xAA → KA_2       (else IDLE)
+    //   KA_2  → 0x00 → KA_3       (else IDLE)
+    //   KA_3  → 0x00 → keepalive OK, IDLE
+    //
+    //   IDLE   → 0xAA → KEY_1
+    //   KEY_1  → 0x55 → KEY_2     (else IDLE)
+    //   KEY_2  → 0x03 → KEY_3     (short press, else check long)
+    //   KEY_2  → 0x04 → KEY_3L    (long press, else IDLE)
+    //   KEY_3  → <b>  → KEYBOARD_InjectKey(b, false), IDLE
+    //   KEY_3L → <b>  → KEYBOARD_InjectKey(b, true), IDLE
+
+    static uint8_t      read_ptr = 0;
+    static ParseState_t state    = STATE_IDLE;
+
+    bool     connected = false;
+    uint8_t  write_ptr = VCP_RxBufPointer;  // snapshot once — ISR may update concurrently
+
+    // Cap bytes processed per call to VCP_RX_BUF_SIZE.
+    // Prevents unbounded loop if the ISR write pointer laps read_ptr
+    // (buffer overflow / corrupted state), which would freeze the firmware.
+    uint32_t processed = 0;
+
+    while (read_ptr != write_ptr && processed < VCP_RX_BUF_SIZE)
+    {
+        uint8_t b = VCP_RxBuf[read_ptr];
+
+        read_ptr++;
+        if (read_ptr >= VCP_RX_BUF_SIZE)
+            read_ptr = 0;
+        processed++;
+
+        if(KEYBOARD_ProcessProtocolByte(&state, b))
+            connected = true;
+    }
+
+    return connected;
+}
+#endif // ENABLE_FEAT_F4HWN_SCREENSHOT

App/driver/vcp.h

@@ -19,6 +19,7 @@
 
 #include <stdint.h>
 #include <string.h>
+#include <stdbool.h>
 #include "usb_config.h"
 
 #define VCP_RX_BUF_SIZE 256
@@ -28,6 +29,10 @@ extern volatile uint32_t VCP_RxBufPointer;
 
 void VCP_Init();
 
+#ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+bool VCP_ScreenshotPing(void);
+#endif
+
 static inline void VCP_Send(const uint8_t *Buf, uint32_t Size)
 {
     cdc_acm_data_send_with_dtr(Buf, Size);

App/font.c

@@ -491,7 +491,7 @@ const uint8_t gFontSmall[95-1][6] =
         {0x03, 0x00, 0x03}, //  34 - quotedbl
         {0x1f, 0x0a, 0x1f}, //  35 - numbersign
         {0x0a, 0x1f, 0x05}, //  36 - dollar
-        {0x09, 0x04, 0x12}, //  37 - percent
+        {0x19, 0x04, 0x13}, //  37 - percent
         {0x0f, 0x17, 0x1c}, //  38 - ampersand
         {0x00, 0x03, 0x00}, //  39 - quotesingle
         {0x00, 0x0e, 0x11}, //  40 - parenleft

App/frequencies.c

@@ -163,11 +163,8 @@ int32_t TX_freq_check(const uint32_t Frequency)
 {   // return '0' if TX frequency is allowed
     // otherwise return '-1'
 
-    if (Frequency < frequencyBandTable[0].lower || Frequency > frequencyBandTable[BAND_N_ELEM - 1].upper)
-        return -1;  // not allowed outside this range
-
-    if (Frequency >= BX4819_band1.upper && Frequency < BX4819_band2.lower)
-        return -1;  // BX chip does not work in this range
+    if (RX_freq_check(Frequency))
+        return -1;
 
     switch (gSetting_F_LOCK)
     {
@@ -280,10 +277,10 @@ int32_t RX_freq_check(const uint32_t Frequency)
     // otherwise return '-1'
 
     if (Frequency < frequencyBandTable[0].lower || Frequency > frequencyBandTable[BAND_N_ELEM - 1].upper)
-        return -1;
+        return -1;  // not allowed outside this range
 
     if (Frequency >= BX4819_band1.upper && Frequency < BX4819_band2.lower)
-        return -1;
+        return -1;  // BX chip does not work in this range
 
-    return 0;   // OK frequency
+    return 0;  // OK frequency
 }

App/frequencies.h

@@ -20,6 +20,7 @@
 #include <stdint.h>
 
 #define _1GHz_in_KHz 100000000
+#define DEFAULT_FREQ 43450000 // Use for Reset and Aircopy
 
 typedef struct {
     const uint32_t lower;

App/functions.c

@@ -118,14 +118,7 @@ void FUNCTION_Foreground(const FUNCTION_Type_t PreviousFunction)
 
 void FUNCTION_PowerSave() {
     #ifdef ENABLE_FEAT_F4HWN_SLEEP
-        if(gWakeUp)
-        {
-            gPowerSave_10ms = gEeprom.BATTERY_SAVE * 200; // deep sleep now indexed on BatSav
-        }
-        else
-        {
-            gPowerSave_10ms = gEeprom.BATTERY_SAVE * 10;
-        }
+        gPowerSave_10ms = gEeprom.BATTERY_SAVE * (gWakeUp ? 200 : 10); // deep sleep now indexed on BatSav
     #else
         gPowerSave_10ms = gEeprom.BATTERY_SAVE * 10;
     #endif

App/helper/boot.c

@@ -61,8 +61,10 @@ BOOT_Mode_t BOOT_GetMode(void)
             return BOOT_MODE_F_LOCK;
 
         #ifdef ENABLE_AIRCOPY
-            if (Keys[0] == KEY_SIDE2)
+            if (Keys[0] == KEY_SIDE2) {
+                gAirCopyBootMode = true;
                 return BOOT_MODE_AIRCOPY;
+            }
         #endif
     }
 
@@ -95,7 +97,7 @@ void BOOT_ProcessMode(BOOT_Mode_t Mode)
             gEeprom.KEY_2_LONG_PRESS_ACTION  = ACTION_OPT_NONE;
             gEeprom.KEY_M_LONG_PRESS_ACTION  = ACTION_OPT_NONE;
 
-            RADIO_InitInfo(gRxVfo, FREQ_CHANNEL_LAST - 1, 43400000); // LPD
+            RADIO_InitInfo(gRxVfo, FREQ_CHANNEL_LAST - 1, DEFAULT_FREQ); // LPD
 
             gRxVfo->CHANNEL_BANDWIDTH        = BANDWIDTH_NARROW;
             gRxVfo->OUTPUT_POWER             = OUTPUT_POWER_LOW1;

App/main.c

@@ -157,18 +157,11 @@ void Main(void)
         #ifdef ENABLE_FEAT_F4HWN
             gEeprom.KEY_LOCK = 0;
             SETTINGS_SaveSettings();
-            #ifndef ENABLE_VOX
-                gMenuCursor = 67; // move to hidden section, fix me if change... !!! Remove VOX and Mic Bar
-            #else
-                gMenuCursor = 68; // move to hidden section, fix me if change... !!!
-            #endif
-
+            gMenuCursor = MENU_ITEMS; 
+            
             #ifdef ENABLE_NOAA
                 gMenuCursor += 1; // move to hidden section, fix me if change... !!!
             #endif
-            #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-                gMenuCursor += 1; // move to hidden section, fix me if change... !!!
-            #endif
             gSubMenuSelection = gSetting_F_LOCK;
         #endif
     }
@@ -262,7 +255,7 @@ void Main(void)
 
 #ifdef ENABLE_VOICE
         {
-            uint8_t Channel;
+            uint16_t Channel;
 
             AUDIO_SetVoiceID(0, VOICE_ID_WELCOME);
 
@@ -284,77 +277,38 @@ void Main(void)
 #endif
     }
 
-    /*
     #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
-    if(gEeprom.CURRENT_STATE == 2 || gEeprom.CURRENT_STATE == 5)
-    {
-            gScanRangeStart = gScanRangeStart ? 0 : gTxVfo->pRX->Frequency;
-            gScanRangeStop = gEeprom.VfoInfo[!gEeprom.TX_VFO].freq_config_RX.Frequency;
-            if(gScanRangeStart > gScanRangeStop)
-            {
-                SWAP(gScanRangeStart, gScanRangeStop);
-            }
-    }
-    switch (gEeprom.CURRENT_STATE) {
-        case 1:
-            gEeprom.SCAN_LIST_DEFAULT = gEeprom.CURRENT_LIST;
-            CHFRSCANNER_Start(true, SCAN_FWD);
-            break;
+        if (gEeprom.CURRENT_STATE == 2 || gEeprom.CURRENT_STATE == 5)
+            CHFRSCANNER_ScanRange();
 
-        case 2:
-            CHFRSCANNER_Start(true, SCAN_FWD);
-            break;
+        switch (gEeprom.CURRENT_STATE) {
+            case 1:
+                gEeprom.SCAN_LIST_DEFAULT = gEeprom.CURRENT_LIST;
+                CHFRSCANNER_Start(true, SCAN_FWD);
+                break;
 
-        #ifdef ENABLE_FMRADIO
-        case 3:
-            ACTION_FM();
-            GUI_SelectNextDisplay(gRequestDisplayScreen);
-            break;
-        #endif
+            case 2:
+                CHFRSCANNER_Start(true, SCAN_FWD);
+                break;
 
-        #ifdef ENABLE_SPECTRUM
-        case 4:
-            APP_RunSpectrum();
-            break;
-        case 5:
-            APP_RunSpectrum();
-            break;
-        #endif
+            #ifdef ENABLE_FMRADIO
+                case 3:
+                    ACTION_FM();
+                    GUI_SelectNextDisplay(gRequestDisplayScreen);
+                    break;
+            #endif
 
-        default:
-            // No action for CURRENT_STATE == 0 or other unexpected values
-            break;
-    }
-    #endif
-    */
+            #ifdef ENABLE_SPECTRUM
+                case 4:
+                case 5:
+                    APP_RunSpectrum();
+                    break;
+            #endif
 
-    #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
-        if (gEeprom.CURRENT_STATE == 2 || gEeprom.CURRENT_STATE == 5) {
-            gScanRangeStart = gScanRangeStart ? 0 : gTxVfo->pRX->Frequency;
-            gScanRangeStop = gEeprom.VfoInfo[!gEeprom.TX_VFO].freq_config_RX.Frequency;
-            if (gScanRangeStart > gScanRangeStop) {
-                SWAP(gScanRangeStart, gScanRangeStop);
-            }
+            default:
+                // No action for CURRENT_STATE == 0 or other unexpected values
+                break;
         }
-
-        if (gEeprom.CURRENT_STATE == 1) {
-            gEeprom.SCAN_LIST_DEFAULT = gEeprom.CURRENT_LIST;
-        }
-
-        if (gEeprom.CURRENT_STATE == 1 || gEeprom.CURRENT_STATE == 2) {
-            CHFRSCANNER_Start(true, SCAN_FWD);
-        }
-        #ifdef ENABLE_FMRADIO
-        else if (gEeprom.CURRENT_STATE == 3) {
-            ACTION_FM();
-            GUI_SelectNextDisplay(gRequestDisplayScreen);
-        }
-        #endif
-        #ifdef ENABLE_SPECTRUM
-        else if (gEeprom.CURRENT_STATE == 4 || gEeprom.CURRENT_STATE == 5) {
-            APP_RunSpectrum();
-        }
-        #endif
     #endif
         
     while (true) {

App/misc.c

@@ -18,6 +18,7 @@
 
 #include "misc.h"
 #include "settings.h"
+#include "driver/py25q16.h"
 
 const uint8_t     fm_radio_countdown_500ms         =  2000 / 500;  // 2 seconds
 const uint16_t    fm_play_countdown_scan_10ms      =   100 / 10;   // 100ms
@@ -86,7 +87,7 @@ const uint16_t    NOAA_countdown_3_10ms            =   200 / 10;   // 200ms
 
 const uint32_t    gDefaultAesKey[4]                = {0x4AA5CC60, 0x0312CC5F, 0xFFD2DABB, 0x6BBA7F92};
 
-const uint8_t     gMicGain_dB2[5]                  = {3, 8, 16, 24, 31};
+const uint8_t     gMicGain_dB2[9]                  = {3, 8, 16, 24, 32, 40, 48, 56, 63}; // BK4819 {3, 8, 16, 24, 31};
 
 #ifndef ENABLE_FEAT_F4HWN
     bool              gSetting_350TX;
@@ -125,13 +126,17 @@ enum BacklightOnRxTx_t gSetting_backlight_on_tx_rx;
     bool          gSetting_set_lck = false;
     bool          gSetting_set_met = 0;
     bool          gSetting_set_gui = 0;
+    #ifdef ENABLE_FEAT_F4HWN_AUDIO
+        uint8_t       gSetting_set_audio_fm = 0;
+        uint8_t       gSetting_set_audio_am = 0;
+    #endif
     #ifdef ENABLE_FEAT_F4HWN_NARROWER
         bool          gSetting_set_nfm = 0;
     #endif
     bool          gSetting_set_tmr = 0;
     bool          gSetting_set_ptt_session;
     #ifdef ENABLE_FEAT_F4HWN_DEBUG
-        uint8_t       gDebug;
+        int16_t   gDebug;
     #endif
     uint8_t       gDW = 0;
     uint8_t       gCB = 0;
@@ -139,10 +144,13 @@ enum BacklightOnRxTx_t gSetting_backlight_on_tx_rx;
     uint8_t       crc[15] = { 0 };
     uint8_t       lErrorsDuringAirCopy = 0;
     uint8_t       gAircopyStep = 0;
+    uint8_t       gAircopyCurrentMapIndex = 0;
+    bool          gAirCopyBootMode = 0;
     #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
         bool          gPowerHigh = false;
         bool          gRemoveOffset = false;
     #endif
+    int8_t dBmCorrTable[7] = {-15, -16, -10, -4, -7, -6, -1};
 #endif
 
 #ifdef ENABLE_AUDIO_BAR
@@ -163,8 +171,13 @@ uint16_t          gEEPROM_RSSI_CALIB[7][4];
 uint16_t          gEEPROM_1F8A;
 uint16_t          gEEPROM_1F8C;
 
-ChannelAttributes_t gMR_ChannelAttributes[FREQ_CHANNEL_LAST + 1];
-bool                gMR_ChannelExclude[FREQ_CHANNEL_LAST + 1];
+// 
+// Cache-Based Architecture: channel attributes moved to Flash
+// Cache holds only active channels in RAM (instead of all!)
+//
+
+MR_ChannelCache_t gMR_ChannelAttributes_Cache[MR_CHANNELS_CACHE_SIZE] = {0};
+ChannelAttributes_t gMR_ChannelAttributes_Current = {0};
 
 volatile uint16_t gBatterySaveCountdown_10ms = battery_save_count_10ms;
 
@@ -191,7 +204,8 @@ volatile bool     gTxTimeoutReached;
         volatile uint16_t gRxTimerCountdown_500ms;
     #endif
     #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
-         volatile uint8_t  gUART_LockScreenshot = 0; // lock screenshot if Chirp is used
+        volatile uint8_t  gUART_LockScreenshot = 0; // lock screenshot if Chirp is used
+        bool gUSB_ScreenshotEnabled = false;
     #endif
 #endif
 
@@ -229,12 +243,13 @@ volatile uint16_t gScanPauseDelayIn_10ms;
 uint16_t          gMenuCountdown;
 bool              gPttWasReleased;
 bool              gPttWasPressed;
+bool              gHasVfoBackup;
 uint8_t           gKeypadLocked;
 bool              gFlagReconfigureVfos;
 uint8_t           gVfoConfigureMode;
 bool              gFlagResetVfos;
 bool              gRequestSaveVFO;
-uint8_t           gRequestSaveChannel;
+uint16_t          gRequestSaveChannel;
 bool              gRequestSaveSettings;
 #ifdef ENABLE_FMRADIO
     bool          gRequestSaveFM;
@@ -262,7 +277,7 @@ bool              g_SquelchLost;
 volatile uint16_t gFlashLightBlinkCounter;
 
 bool              gFlagEndTransmission;
-uint8_t           gNextMrChannel;
+uint16_t          gNextMrChannel;
 ReceptionMode_t   gRxReceptionMode;
 
 bool              gRxVfoIsActive;
@@ -280,7 +295,7 @@ uint8_t           gFSKWriteIndex;
 
 #ifdef ENABLE_NOAA
     bool          gIsNoaaMode;
-    uint8_t       gNoaaChannel;
+    uint8_t      gNoaaChannel;
 #endif
 
 bool              gUpdateDisplay;
@@ -316,8 +331,14 @@ uint8_t           gIsLocked = 0xFF;
     bool          gMute = false;
     uint8_t       gBacklightTimeOriginal;
     uint8_t       gBacklightBrightnessOld;
+    uint8_t       gSquelchLevelOriginal = 10;
     uint8_t       gPttOnePushCounter = 0;
     uint32_t      gBlinkCounter = 0;
+
+    uint16_t gVfoSaveCountdown_10ms = 0;
+    bool gScheduleVfoSave = false;
+    bool gVfoStateChanged = false;
+    char    gListName[MR_CHANNELS_LIST][4];
 #endif
 
 inline void FUNCTION_NOP() { ; }
@@ -347,3 +368,285 @@ unsigned long StrToUL(const char * str)
     }
     return ul;
 }
+
+// 
+// Cache-Based Channel Attributes Implementation
+// 
+//
+// This replaces the huge array (~ 2,000 bytes in RAM) with a smart cache system
+// that keeps only active channels in RAM and loads others from Flash on demand.
+//
+// SRAM Savings: ~ 2,000 bytes (84% reduction!)
+// 
+
+// Flash address where channel attributes start
+// NOTE: Verify this matches your Flash layout!
+
+#define FLASH_CHANNEL_ATTR_BASE 0x8000
+
+// Each channel takes 2 bytes (ChannelAttributes_t is uint16_t)
+#define FLASH_CHANNEL_ATTR_SIZE 2
+
+// Cache hit/miss statistics (optional, for debugging)
+
+#ifdef ENABLE_FEAT_F4HWN_DEBUG
+    static uint32_t cache_hits = 0;
+    static uint32_t cache_misses = 0;
+#endif
+
+// 
+// Internal Helper Functions
+// 
+
+// Find cache entry for given channel
+// Returns index if found, -1 if not found
+
+static int MR_FindInCache(uint16_t channel_id)
+{
+    for (int i = 0; i < MR_CHANNELS_CACHE_SIZE; i++) {
+        if (gMR_ChannelAttributes_Cache[i].channel_id == channel_id) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+// Find oldest entry in cache (for eviction - LRU)
+static int MR_FindOldestCacheEntry(void)
+{
+    int oldest_index = 0;
+    uint32_t oldest_time = gMR_ChannelAttributes_Cache[0].access_time;
+    
+    for (int i = 1; i < MR_CHANNELS_CACHE_SIZE; i++) {
+        if (gMR_ChannelAttributes_Cache[i].access_time < oldest_time) {
+            oldest_time = gMR_ChannelAttributes_Cache[i].access_time;
+            oldest_index = i;
+        }
+    }
+    
+    return oldest_index;
+}
+
+// Find empty cache slot
+// Returns index if found, -1 if cache is full
+static int MR_FindEmptyCacheSlot(void)
+{
+    for (int i = 0; i < MR_CHANNELS_CACHE_SIZE; i++) {
+        if (gMR_ChannelAttributes_Cache[i].channel_id == 0xFFFF) {
+            return i;
+        }
+    }
+    return -1;  // Cache is full, need to evict
+}
+
+// Get current time (for LRU eviction)
+static uint32_t GetCurrentTime(void)
+{
+    // Using gBlinkCounter which increments continuously
+    extern uint32_t gBlinkCounter;
+    return gBlinkCounter;
+}
+
+// 
+// Public API Functions
+// ════════════════════════════════════════════════════════════════════════════
+
+// Load channel attributes from Flash
+void MR_LoadChannelAttributesFromFlash(uint16_t channel_id, ChannelAttributes_t* attributes)
+{
+    // CRITICAL: Validate channel_id
+    if (channel_id >= (MR_CHANNELS_MAX + 7)) {
+        attributes->__val = 0;
+        return;
+    }
+    
+    // Calculate Flash address
+    uint32_t flash_addr = FLASH_CHANNEL_ATTR_BASE + (channel_id * sizeof(ChannelAttributes_t));
+    
+    // Read 2 bytes from Flash
+    PY25Q16_ReadBuffer(flash_addr, attributes, sizeof(ChannelAttributes_t));
+}
+
+// Save channel attributes to Flash
+void MR_SaveChannelAttributesToFlash(uint16_t channel_id, const ChannelAttributes_t* attributes)
+{
+    // CRITICAL: Validate channel_id
+    if (channel_id >= (MR_CHANNELS_MAX + 7)) {
+        return;
+    }
+    
+    // Calculate Flash address
+    uint16_t flash_addr = FLASH_CHANNEL_ATTR_BASE + (channel_id * FLASH_CHANNEL_ATTR_SIZE);
+    
+    // Write 2 bytes to Flash
+    PY25Q16_WriteBuffer(flash_addr, attributes, sizeof(ChannelAttributes_t), false);
+}
+
+// Get channel attributes (from cache or Flash)
+// This is the main function used by the rest of the code
+ChannelAttributes_t* MR_GetChannelAttributes(uint16_t channel_id)
+{
+    // Input validation
+    if (channel_id >= (MR_CHANNELS_MAX + 7)) {
+        return NULL;
+    }
+    
+    // Check cache first (FAST PATH)
+    int cache_index = MR_FindInCache(channel_id);
+    
+    if (cache_index >= 0) {
+        // CACHE HIT
+        #ifdef ENABLE_FEAT_F4HWN_DEBUG
+            cache_hits++;
+        #endif
+        
+        // Update access time for LRU
+        gMR_ChannelAttributes_Cache[cache_index].access_time = GetCurrentTime();
+        
+        return &gMR_ChannelAttributes_Cache[cache_index].attributes;
+    }
+    
+    // CACHE MISS - Load from Flash
+    #ifdef ENABLE_FEAT_F4HWN_DEBUG
+        cache_misses++;
+    #endif
+    
+    // Find slot for new entry
+    int slot = MR_FindEmptyCacheSlot();
+    
+    if (slot < 0) {
+        // Cache is full, evict oldest entry
+        slot = MR_FindOldestCacheEntry();
+    }
+    
+    // Load from Flash into cache slot
+    MR_LoadChannelAttributesFromFlash(channel_id, &gMR_ChannelAttributes_Cache[slot].attributes);
+    
+    // Store channel_id in cache
+    gMR_ChannelAttributes_Cache[slot].channel_id = channel_id;
+    
+    // Set access time
+    gMR_ChannelAttributes_Cache[slot].access_time = GetCurrentTime();
+    
+    return &gMR_ChannelAttributes_Cache[slot].attributes;
+}
+
+// Set channel attributes (updates both cache and Flash)
+void MR_SetChannelAttributes(uint16_t channel_id, const ChannelAttributes_t* attributes)
+{
+    // Input validation
+    if (channel_id >= (MR_CHANNELS_MAX + 7) || !attributes) {
+        return;
+    }
+    
+    // CRITICAL FIX: WRITE-PROTECT - Prevent Flash wear
+    // Before writing, check if data already exists and is identical
+    ChannelAttributes_t flash_version;
+    MR_LoadChannelAttributesFromFlash(channel_id, &flash_version);
+    
+    // Compare current Flash data with new data
+    if (memcmp(&flash_version, attributes, sizeof(ChannelAttributes_t)) == 0) {
+        // But still update cache for consistency
+        int cache_index = MR_FindInCache(channel_id);
+        if (cache_index >= 0) {
+            gMR_ChannelAttributes_Cache[cache_index].attributes = *attributes;
+            gMR_ChannelAttributes_Cache[cache_index].access_time = GetCurrentTime();
+        }
+        return;  // Early exit - no Flash write needed
+    }
+    
+    // Data has changed - write to Flash
+    MR_SaveChannelAttributesToFlash(channel_id, attributes);
+    
+    // Update cache if entry exists
+    int cache_index = MR_FindInCache(channel_id);
+    
+    if (cache_index >= 0) {
+        // Entry in cache, update it
+        gMR_ChannelAttributes_Cache[cache_index].attributes = *attributes;
+        gMR_ChannelAttributes_Cache[cache_index].access_time = GetCurrentTime();
+    } else {
+        // Not in cache, add it
+        int slot = MR_FindEmptyCacheSlot();
+        
+        if (slot < 0) {
+            // Cache full, evict oldest
+            slot = MR_FindOldestCacheEntry();
+        }
+        
+        gMR_ChannelAttributes_Cache[slot].channel_id = channel_id;
+        gMR_ChannelAttributes_Cache[slot].attributes = *attributes;
+        gMR_ChannelAttributes_Cache[slot].access_time = GetCurrentTime();
+    }
+}
+
+// Invalidate entire cache (call after loading Flash backup)
+void MR_InvalidateChannelAttributesCache(void)
+{
+    for (int i = 0; i < MR_CHANNELS_CACHE_SIZE; i++) {
+        gMR_ChannelAttributes_Cache[i].channel_id = 0xFFFF;  // Mark as empty
+        gMR_ChannelAttributes_Cache[i].access_time = 0;
+    }
+}
+
+// Initialize cache (call from settings.c boot sequence)
+void MR_InitChannelAttributesCache(void)
+{
+    // Clear cache
+    MR_InvalidateChannelAttributesCache();
+    
+    // Pre-load commonly used channels (VFO A, VFO B, channel 0)
+    // This speeds up first access
+    uint16_t channels_to_preload[] = {0, 1, 2};
+    
+    for (int i = 0; i < ARRAY_SIZE(channels_to_preload); i++) {
+        if (channels_to_preload[i] < (MR_CHANNELS_MAX + 7)) {
+            MR_GetChannelAttributes(channels_to_preload[i]);
+        }
+    }
+}
+
+// 
+// Debugging / Statistics (optional, for development)
+// 
+
+#ifdef ENABLE_FEAT_F4HWN_DEBUG
+
+uint32_t MR_GetCacheHits(void)
+{
+    return cache_hits;
+}
+
+uint32_t MR_GetCacheMisses(void)
+{
+    return cache_misses;
+}
+
+float MR_GetCacheHitRate(void)
+{
+    uint32_t total = cache_hits + cache_misses;
+    if (total == 0) return 0.0f;
+    return (float)cache_hits / (float)total * 100.0f;
+}
+
+void MR_PrintCacheStats(void)
+{
+    // This would print cache statistics (requires UART_Printf)
+    // Uncomment if you want debug output:
+    // UART_Printf("Cache Stats: Hits=%u Misses=%u Rate=%.1f%%\n", 
+    //    cache_hits, cache_misses, MR_GetCacheHitRate());
+}
+
+#endif
+
+#ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
+    bool SCREENSHOT_IsLocked(void) 
+    {
+        if (gUART_LockScreenshot > 0) {
+            gUART_LockScreenshot--;
+            return true;
+        }
+        
+        return false;
+    }
+#endif

App/misc.h

@@ -36,18 +36,28 @@
     #define SWAP(a, b) ({ __typeof__ (a) _c = (a);  a = b; b = _c; })
 #endif
 
-#define IS_MR_CHANNEL(x)       ((x) <= MR_CHANNEL_LAST)
+#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
+
+
+#define IS_MR_CHANNEL(x)       ((x) >= MR_CHANNEL_FIRST && (x) <= MR_CHANNEL_LAST)
 #define IS_FREQ_CHANNEL(x)     ((x) >= FREQ_CHANNEL_FIRST && (x) <= FREQ_CHANNEL_LAST)
 #define IS_VALID_CHANNEL(x)    ((x) < LAST_CHANNEL)
 #define IS_NOAA_CHANNEL(x)     ((x) >= NOAA_CHANNEL_FIRST && (x) <= NOAA_CHANNEL_LAST)
 
 enum {
     MR_CHANNEL_FIRST   = 0,
-    MR_CHANNEL_LAST    = 199u,
-    FREQ_CHANNEL_FIRST = 200u,
-    FREQ_CHANNEL_LAST  = 206u,
-    NOAA_CHANNEL_FIRST = 207u,
-    NOAA_CHANNEL_LAST  = 216u,
+    MR_CHANNEL_LAST    = MR_CHANNELS_MAX - 1,
+    FREQ_CHANNEL_FIRST = MR_CHANNELS_MAX,
+    FREQ_CHANNEL_LAST  = MR_CHANNELS_MAX + 6,
+    NOAA_CHANNEL_FIRST = MR_CHANNELS_MAX + 7,
+    NOAA_CHANNEL_LAST  = MR_CHANNELS_MAX + 16,
     LAST_CHANNEL
 };
 
@@ -138,7 +148,7 @@ extern const uint16_t        scan_pause_delay_in_7_10ms;
 //extern const uint16_t        gMax_bat_v;
 //extern const uint16_t        gMin_bat_v;
 
-extern const uint8_t         gMicGain_dB2[5];
+extern const uint8_t         gMicGain_dB2[9];
 
 #ifndef ENABLE_FEAT_F4HWN
 extern bool                  gSetting_350TX;
@@ -178,13 +188,17 @@ extern enum BacklightOnRxTx_t gSetting_backlight_on_tx_rx;
     extern bool               gSetting_set_lck;
     extern bool               gSetting_set_met;
     extern bool               gSetting_set_gui;
+    #ifdef ENABLE_FEAT_F4HWN_AUDIO
+        extern uint8_t            gSetting_set_audio_fm;
+        extern uint8_t            gSetting_set_audio_am;
+    #endif
     #ifdef ENABLE_FEAT_F4HWN_NARROWER
         extern bool               gSetting_set_nfm;
     #endif
     extern bool               gSetting_set_tmr;
     extern bool               gSetting_set_ptt_session;
     #ifdef ENABLE_FEAT_F4HWN_DEBUG
-        extern uint8_t            gDebug;
+        extern int16_t        gDebug;
     #endif
     extern uint8_t            gDW;
     extern uint8_t            gCB;
@@ -192,10 +206,13 @@ extern enum BacklightOnRxTx_t gSetting_backlight_on_tx_rx;
     extern uint8_t            crc[15];
     extern uint8_t            lErrorsDuringAirCopy;
     extern uint8_t            gAircopyStep;
+    extern uint8_t            gAircopyCurrentMapIndex;
+    extern bool               gAirCopyBootMode;
     #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
         extern bool               gPowerHigh;
         extern bool               gRemoveOffset;
     #endif
+    extern int8_t dBmCorrTable[7];
 #endif
 
 #ifdef ENABLE_AUDIO_BAR
@@ -219,18 +236,66 @@ extern uint16_t              gEEPROM_1F8C;
 
 typedef union {
     struct {
-        uint8_t
-            band : 3,
+        uint16_t
+            band :      3,
             compander : 2,
-            scanlist1 : 1,
-            scanlist2 : 1,
-            scanlist3 : 1;
+            unused_1 :  1,
+            unused_2 :  1,
+            exclude :   1,
+            scanlist :  8;
     };
-    uint8_t __val;
+    uint16_t __val;
 } ChannelAttributes_t;
 
-extern ChannelAttributes_t   gMR_ChannelAttributes[207];
-extern bool                  gMR_ChannelExclude[207];
+// 
+// Cache-Based Architecture
+// 
+//
+// Instead of keeping all 1038 channel attributes in RAM (~ 2,000 bytes),
+// we now keep only the active ones in a small cache (40 bytes).
+//
+// The full array remains in Flash and is loaded on-demand.
+//
+// SRAM Savings: ~ 2,000 bytes (84% reduction!)
+// 
+
+// Cache entry structure
+typedef struct {
+    uint16_t channel_id;                    // Which channel this is
+    ChannelAttributes_t attributes;         // The actual attributes
+    uint32_t access_time;                   // For LRU eviction (optional)
+} MR_ChannelCache_t;
+
+// The cache (small, stays in RAM)
+extern MR_ChannelCache_t gMR_ChannelAttributes_Cache[MR_CHANNELS_CACHE_SIZE];
+
+// REMOVED: extern ChannelAttributes_t gMR_ChannelAttributes[MR_CHANNELS_MAX + 7];
+// This now stays in Flash, not in RAM
+
+// 
+// Cache Access Functions (See misc.c for implementation)
+// 
+
+// Get channel attributes (from cache or Flash)
+// Returns pointer to attributes, loads from Flash if not in cache
+
+void MR_InitChannelAttributesCache(void);
+
+ChannelAttributes_t* MR_GetChannelAttributes(uint16_t channel_id);
+
+// Set channel attributes (updates both cache and Flasf)
+void MR_SetChannelAttributes(uint16_t channel_id, const ChannelAttributes_t* attributes);
+
+// Invalidate cache (on Flash clear)
+void MR_InvalidateChannelAttributesCache(void);
+
+// Load channel attributes from Flash directly (internal use)
+void MR_LoadChannelAttributesFromFlash(uint16_t channel_id, ChannelAttributes_t* attributes);
+
+// Save channel attributes to Flash directly (internal use)
+void MR_SaveChannelAttributesToFlash(uint16_t channel_id, const ChannelAttributes_t* attributes);
+
+extern ChannelAttributes_t   gMR_ChannelAttributes_Current;  // Current VFO attributes (for speed)
 
 extern volatile uint16_t     gBatterySaveCountdown_10ms;
 
@@ -258,6 +323,9 @@ extern volatile bool         gTxTimeoutReached;
     #endif
     #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
         extern volatile uint8_t  gUART_LockScreenshot; // lock screenshot if Chirp is used
+        extern bool gUSB_ScreenshotEnabled;
+
+        bool SCREENSHOT_IsLocked(void);
     #endif
 #endif
 
@@ -301,11 +369,12 @@ extern AlarmState_t          gAlarmState;
 extern uint16_t              gMenuCountdown;
 extern bool                  gPttWasReleased;
 extern bool                  gPttWasPressed;
+extern bool                  gHasVfoBackup;
 extern bool                  gFlagReconfigureVfos;
 extern uint8_t               gVfoConfigureMode;
 extern bool                  gFlagResetVfos;
 extern bool                  gRequestSaveVFO;
-extern uint8_t               gRequestSaveChannel;
+extern uint16_t              gRequestSaveChannel;
 extern bool                  gRequestSaveSettings;
 #ifdef ENABLE_FMRADIO
     extern bool              gRequestSaveFM;
@@ -336,7 +405,7 @@ extern bool                  g_SquelchLost;
 extern volatile uint16_t     gFlashLightBlinkCounter;
 
 extern bool                  gFlagEndTransmission;
-extern uint8_t               gNextMrChannel;
+extern uint16_t              gNextMrChannel;
 extern ReceptionMode_t       gRxReceptionMode;
 
  //TRUE when dual watch is momentarly suspended and RX_VFO is locked to either last TX or RX
@@ -385,8 +454,15 @@ extern volatile uint8_t      boot_counter_10ms;
     extern bool                  gMute;
     extern uint8_t               gBacklightTimeOriginal;
     extern uint8_t               gBacklightBrightnessOld;
+    extern uint8_t               gSquelchLevelOriginal;
     extern uint8_t               gPttOnePushCounter;
     extern uint32_t              gBlinkCounter;
+
+    extern uint16_t gVfoSaveCountdown_10ms;
+    extern bool gScheduleVfoSave;
+    extern bool gVfoStateChanged;
+
+    extern char gListName[MR_CHANNELS_LIST][4];
 #endif
 
 int32_t NUMBER_AddWithWraparound(int32_t Base, int32_t Add, int32_t LowerLimit, int32_t UpperLimit);
@@ -396,4 +472,4 @@ void FUNCTION_NOP();
 
 static inline bool SerialConfigInProgress() { return gSerialConfigCountDown_500ms != 0; }
 
-#endif
+#endif

App/radio.c

@@ -53,68 +53,166 @@ const char gModulationStr[MODULATION_UKNOWN][4] = {
 #endif
 };
 
+#ifdef ENABLE_FEAT_F4HWN_AUDIO
+
+    // About BK4819_WriteRegister(0x2b, val) experimentation...
+    //
+    // 0x000: 300 Hz high-pass filter enabled, 3 kHz low-pass filter enabled, de-emphasis enabled.
+    // Audio impression: the most "classic radio" tuning, more filtered and smoother.
+    //
+    // 0x300: 300 Hz high-pass filter enabled, 3 kHz low-pass filter disabled, de-emphasis disabled.
+    // Audio impression: clearer, brighter, and more open, while still cutting low frequencies.
+    //
+    // 0x400: 300 Hz high-pass filter disabled, 3 kHz low-pass filter enabled, de-emphasis enabled.
+    // Audio impression: fuller low end, but still softened by de-emphasis and upper-frequency limiting.
+    //
+    // 0x500: 300 Hz high-pass filter disabled, 3 kHz low-pass filter enabled, de-emphasis disabled.
+    // 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;
+
+            case 1: // CLEAN
+                BK4819_WriteRegister(0x54, 0x9009);
+                BK4819_WriteRegister(0x55, 0x33A9);
+                break;
+
+            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;
+        }
+    }
+
+    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;
+        }
+    }
+
+    static void AUDIO_ApplyUSBProfile(void)
+    {
+        BK4819_WriteRegister(0x54, 0x9009);
+        BK4819_WriteRegister(0x55, 0x31A9);
+    }
+#endif
+
+bool RADIO_CheckValidList(uint8_t scanList)
+{
+    if(scanList == MR_CHANNELS_LIST + 1)
+        return true;
+
+    for (uint16_t i = 0; IS_MR_CHANNEL(i); i++) {
+        const ChannelAttributes_t* att = MR_GetChannelAttributes(i);
+        if(att->scanlist == scanList && att->exclude == false)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+void RADIO_NextValidList(int8_t direction)
+{
+    uint8_t startList = gEeprom.SCAN_LIST_DEFAULT;
+    uint8_t attempts = 0;
+    const uint8_t MAX_VALUE = MR_CHANNELS_LIST + 1;  // 25 (1-24 lists + ALL)
+    
+    do {
+        if (direction > 0) {
+            // Forward: 1 → 2 → ... → 25 → 1
+            gEeprom.SCAN_LIST_DEFAULT = (gEeprom.SCAN_LIST_DEFAULT % MAX_VALUE) + 1;
+        } else {
+            // Backward: 25 → 24 → ... → 1 → 25
+            gEeprom.SCAN_LIST_DEFAULT = ((gEeprom.SCAN_LIST_DEFAULT - 2 + MAX_VALUE) % MAX_VALUE) + 1;
+        }
+        attempts++;
+        
+        if (RADIO_CheckValidList(gEeprom.SCAN_LIST_DEFAULT))
+            return;
+            
+    } while (gEeprom.SCAN_LIST_DEFAULT != startList && attempts < MAX_VALUE);
+    
+    // Safety fallback: switch to ALL mode
+    if (!RADIO_CheckValidList(gEeprom.SCAN_LIST_DEFAULT)) {
+        gEeprom.SCAN_LIST_DEFAULT = MAX_VALUE;  // ALL (25)
+    }
+}
+
 bool RADIO_CheckValidChannel(uint16_t channel, bool checkScanList, uint8_t scanList)
 {
+    const ChannelAttributes_t* att = MR_GetChannelAttributes(channel);
+
     // return true if the channel appears valid
     if (!IS_MR_CHANNEL(channel))
         return false;
-
-    const ChannelAttributes_t att = gMR_ChannelAttributes[channel];
-
-    if (checkScanList && gMR_ChannelExclude[channel] == true)
+    if (checkScanList && att->exclude == true)
         return false;
-
-    if (att.band > BAND7_470MHz)
+    if (att->band > BAND7_470MHz)
         return false;
-
-    if (!checkScanList || scanList > 4)
+    if (!checkScanList || (scanList > MR_CHANNELS_LIST && att->scanlist != 0) || (scanList > 0 && att->scanlist == MR_CHANNELS_LIST + 1))
         return true;
-
-    /*
-    if(scanList == 0 && (att.scanlist1 == 1 || att.scanlist2 == 1 || att.scanlist3 == 1))
-    {
+    if ((scanList == 0) || (scanList != att->scanlist)) {
         return false;
     }
-    else if(scanList == 1 && att.scanlist1 != 1)
-    {
-        return false;
-    }
-    else if(scanList == 2 && att.scanlist2 != 1)
-    {
-        return false;
-    }
-    else if(scanList == 3 && att.scanlist3 != 1)
-    {
-        return false;
-    }
-    else if(scanList == 4 && (att.scanlist1 == 0 && att.scanlist2 == 0 && att.scanlist3 == 0))
-    {
-        return false;
-    }
-    */
-
-    if ((scanList == 0 && (att.scanlist1 == 1 || att.scanlist2 == 1 || att.scanlist3 == 1)) ||
-        (scanList == 1 && att.scanlist1 != 1) ||
-        (scanList == 2 && att.scanlist2 != 1) ||
-        (scanList == 3 && att.scanlist3 != 1) ||
-        (scanList == 4 && (att.scanlist1 == 0 && att.scanlist2 == 0 && att.scanlist3 == 0))) {
-        return false;
-    }
-
-    //return true;
-
-    // I don't understand what this code is for...
     
-    const uint8_t PriorityCh1 = gEeprom.SCANLIST_PRIORITY_CH1[scanList - 1];
-    const uint8_t PriorityCh2 = gEeprom.SCANLIST_PRIORITY_CH2[scanList - 1];
-
-    return PriorityCh1 != channel && PriorityCh2 != channel;
+    // Exclude priority channels ONLY if SCAN_LIST_ENABLED is active
+    // Otherwise, treat them as normal channels in the list
+    if (gEeprom.SCAN_LIST_ENABLED)
+    {
+        const uint16_t PriorityCh1 = gEeprom.SCANLIST_PRIORITY_CH[0];
+        const uint16_t PriorityCh2 = gEeprom.SCANLIST_PRIORITY_CH[1];
+        if (PriorityCh1 == channel || PriorityCh2 == channel)
+            return false;  // Excluded because it's a priority channel and they are enabled
+    }
+    
+    return true;
 }
 
-uint8_t RADIO_FindNextChannel(uint8_t Channel, int8_t Direction, bool bCheckScanList, uint8_t VFO)
+uint16_t RADIO_FindNextChannel(uint16_t Channel, int8_t Direction, bool bCheckScanList, uint8_t VFO)
 {
-    for (unsigned int i = 0; IS_MR_CHANNEL(i); i++, Channel += Direction) {
-        if (Channel == 0xFF) {
+    for (uint16_t i = 0; IS_MR_CHANNEL(i); i++, Channel += Direction) {
+        if (Channel == 0xFFFF) {
             Channel = MR_CHANNEL_LAST;
         } else if (!IS_MR_CHANNEL(Channel)) {
             Channel = MR_CHANNEL_FIRST;
@@ -125,17 +223,15 @@ uint8_t RADIO_FindNextChannel(uint8_t Channel, int8_t Direction, bool bCheckScan
         }
     }
 
-    return 0xFF;
+    return 0xFFFF;
 }
 
-void RADIO_InitInfo(VFO_Info_t *pInfo, const uint8_t ChannelSave, const uint32_t Frequency)
+void RADIO_InitInfo(VFO_Info_t *pInfo, const uint16_t ChannelSave, const uint32_t Frequency)
 {
     memset(pInfo, 0, sizeof(*pInfo));
 
     pInfo->Band                     = FREQUENCY_GetBand(Frequency);
-    pInfo->SCANLIST1_PARTICIPATION  = false;
-    pInfo->SCANLIST2_PARTICIPATION  = false;
-    pInfo->SCANLIST3_PARTICIPATION  = false;
+    pInfo->SCANLIST_PARTICIPATION   = 0;
     pInfo->STEP_SETTING             = STEP_12_5kHz;
     pInfo->StepFrequency            = gStepFrequencyTable[pInfo->STEP_SETTING];
     pInfo->CHANNEL_SAVE             = ChannelSave;
@@ -168,7 +264,7 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure
             gEeprom.ScreenChannel[VFO] = FREQ_CHANNEL_FIRST + BAND6_400MHz;
     }
 
-    uint8_t channel = gEeprom.ScreenChannel[VFO];
+    uint16_t channel = gEeprom.ScreenChannel[VFO];
 
     if (IS_VALID_CHANNEL(channel)) {
 #ifdef ENABLE_NOAA
@@ -188,7 +284,7 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure
 
         if (IS_MR_CHANNEL(channel)) {
             channel = RADIO_FindNextChannel(channel, RADIO_CHANNEL_UP, false, VFO);
-            if (channel == 0xFF) {
+            if (channel == 0xFFFF) {
                 channel                    = gEeprom.FreqChannel[VFO];
                 gEeprom.ScreenChannel[VFO] = gEeprom.FreqChannel[VFO];
             }
@@ -201,50 +297,42 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure
     else
         channel = FREQ_CHANNEL_LAST - 1;
 
-    ChannelAttributes_t att = gMR_ChannelAttributes[channel];
-    if (att.__val == 0xFF) { // invalid/unused channel
+    ChannelAttributes_t* att = MR_GetChannelAttributes(channel);
+    if (att->__val == 0xFFFF) { // invalid/unused channel
         if (IS_MR_CHANNEL(channel)) {
             channel                    = gEeprom.FreqChannel[VFO];
             gEeprom.ScreenChannel[VFO] = channel;
         }
 
-        uint8_t bandIdx = channel - FREQ_CHANNEL_FIRST;
+        uint16_t bandIdx = channel - FREQ_CHANNEL_FIRST;
         RADIO_InitInfo(pVfo, channel, frequencyBandTable[bandIdx].lower);
         return;
     }
 
-    uint8_t band = att.band;
+    uint8_t band = att->band;
     if (band > BAND7_470MHz) {
         band = BAND6_400MHz;
     }
 
-    bool bParticipation1;
-    bool bParticipation2;
-    bool bParticipation3;
+    uint8_t bParticipation;
 
     if (IS_MR_CHANNEL(channel)) {
-        bParticipation1 = att.scanlist1;
-        bParticipation2 = att.scanlist2;
-        bParticipation3 = att.scanlist3;
+        bParticipation = att->scanlist;
     }
     else {
         band = channel - FREQ_CHANNEL_FIRST;
-        bParticipation1 = true;
-        bParticipation2 = true;
-        bParticipation3 = true;
+        bParticipation = MR_CHANNELS_LIST + 1;
     }
 
     pVfo->Band                    = band;
-    pVfo->SCANLIST1_PARTICIPATION = bParticipation1;
-    pVfo->SCANLIST2_PARTICIPATION = bParticipation2;
-    pVfo->SCANLIST3_PARTICIPATION = bParticipation3;
+    pVfo->SCANLIST_PARTICIPATION = bParticipation;
     pVfo->CHANNEL_SAVE            = channel;
 
     uint32_t base;
     if (IS_MR_CHANNEL(channel))
         base = channel * 16;
     else
-        base = 0x001000 + ((channel - FREQ_CHANNEL_FIRST) * 32) + (VFO * 16);
+        base = 0x009000 + ((channel - FREQ_CHANNEL_FIRST) * 32) + (VFO * 16);
 
     if (configure == VFO_CONFIGURE_RELOAD || IS_FREQ_CHANNEL(channel))
     {
@@ -424,7 +512,7 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure
             pConfig->Frequency = 43300000;
     }
 
-    pVfo->Compander = att.compander;
+    pVfo->Compander = att->compander;
 
     #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
     if(gRemoveOffset)
@@ -513,7 +601,7 @@ void RADIO_ConfigureSquelchAndOutputPower(VFO_Info_t *pInfo)
 
     Band = FREQUENCY_GetBand(pInfo->pTX->Frequency);
 
-    // my eeprom calibration data 
+    // my eeprom calibration data on UV-K5 (V1)
     //
     // 1ED0 32 32 32 64 64 64 8c 8c 8c ff ff ff ff ff ff ff  50 MHz
     // 1EE0 32 32 32 64 64 64 8c 8c 8c ff ff ff ff ff ff ff 108 MHz
@@ -523,6 +611,15 @@ void RADIO_ConfigureSquelchAndOutputPower(VFO_Info_t *pInfo)
     // 1F20 5f 5f 5f 69 69 69 87 87 87 ff ff ff ff ff ff ff 400 MHz
     // 1F30 32 32 32 64 64 64 8c 8c 8c ff ff ff ff ff ff ff 470 MHz
 
+    // my eeprom calibration data on UV-K1
+    //      32 32 32 64 64 64 8c 8c 8c ff ff ff ff ff ff ff  50 MHz
+    //      32 32 32 64 64 64 8c 8c 8c ff ff ff ff ff ff ff 108 MHz
+    //      4b 4b 4b 78 78 78 96 96 96 ff ff ff ff ff ff ff 137 MHz
+    //      32 32 32 64 64 64 8c 8c 8c ff ff ff ff ff ff ff 174 MHz
+    //      5a 5a 5a 64 64 64 a0 a0 a0 ff ff ff ff ff ff ff 350 MHz
+    //      4b 4b 4b 78 78 78 96 96 96 ff ff ff ff ff ff ff 400 MHz
+    //      32 32 32 64 64 64 94 8c 8c ff ff ff ff ff ff ff 470 MHz
+
     uint8_t Txp[3];
     uint8_t Op = 0; // Low eeprom calibration data 
     uint8_t currentPower = pInfo->OUTPUT_POWER;
@@ -602,7 +699,17 @@ void RADIO_ConfigureSquelchAndOutputPower(VFO_Info_t *pInfo)
     }
     */
 
-    static const uint8_t dividers[6] = { 25, 19, 13, 10, 7, 4};
+    //static const uint8_t dividers[6] = { 25, 19, 13, 10, 7, 4}; // For UV-K5 V1
+
+    static const uint8_t dividers_band2[6] = { 20, 15, 10, 8, 6, 4 };
+    static const uint8_t dividers_band5[6] = { 25, 19, 13, 9, 6, 4 }; // Need to improve measure...
+
+    const uint8_t *dividers;
+
+    if (Band == 2)  // VHF
+        dividers = dividers_band2;
+    else // UHF
+        dividers = dividers_band5;
 
     for (uint8_t p = 0; p < 3; p++)
     {
@@ -612,7 +719,8 @@ void RADIO_ConfigureSquelchAndOutputPower(VFO_Info_t *pInfo)
         }
         else // case 6
         {
-            Txp[p] += 30;
+            // Txp[p] += 30; // For UV-K5 V1
+            Txp[p] += 24;
         }
     }
 #else
@@ -699,21 +807,26 @@ void RADIO_SetupRegisters(bool switchToForeground)
 
     BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, false);
 
-    switch (Bandwidth)
+    if (gRxVfo->Modulation == MODULATION_AM)
+        BK4819_SetFilterBandwidth(BK4819_FILTER_BW_AM, true);
+    else
     {
-        default:
-            Bandwidth = BK4819_FILTER_BW_WIDE;
-            [[fallthrough]];
-        case BK4819_FILTER_BW_WIDE:
-        case BK4819_FILTER_BW_NARROW:
-        case BK4819_FILTER_BW_NARROWER:
-            #ifdef ENABLE_AM_FIX
-//              BK4819_SetFilterBandwidth(Bandwidth, gRxVfo->Modulation == MODULATION_AM && gSetting_AM_fix);
-                BK4819_SetFilterBandwidth(Bandwidth, true);
-            #else
-                BK4819_SetFilterBandwidth(Bandwidth, false);
-            #endif
-            break;
+        switch (Bandwidth)
+        {
+            default:
+                Bandwidth = BK4819_FILTER_BW_WIDE;
+                [[fallthrough]];
+            case BK4819_FILTER_BW_WIDE:
+            case BK4819_FILTER_BW_NARROW:
+            case BK4819_FILTER_BW_NARROWER:
+                #ifdef ENABLE_AM_FIX
+    //              BK4819_SetFilterBandwidth(Bandwidth, gRxVfo->Modulation == MODULATION_AM && gSetting_AM_fix);
+                    BK4819_SetFilterBandwidth(Bandwidth, true);
+                #else
+                    BK4819_SetFilterBandwidth(Bandwidth, false);
+                #endif
+                break;
+        }
     }
 
     BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, false);
@@ -733,8 +846,8 @@ void RADIO_SetupRegisters(bool switchToForeground)
     }
     BK4819_WriteRegister(BK4819_REG_3F, 0);
 
-    // mic gain 0.5dB/step 0 to 31
-    BK4819_WriteRegister(BK4819_REG_7D, 0xE940 | (gEeprom.MIC_SENSITIVITY_TUNING & 0x1f));
+    // mic gain 0.5dB/step 0 to 63
+    BK4819_WriteRegister(BK4819_REG_7D, 0xE940 | (gEeprom.MIC_SENSITIVITY_TUNING & 0x3f));
 
     uint32_t Frequency;
     #ifdef ENABLE_NOAA
@@ -864,6 +977,7 @@ void RADIO_SetupRegisters(bool switchToForeground)
     InterruptMask |= BK4819_REG_3F_DTMF_5TONE_FOUND;
 
     RADIO_SetupAGC(gRxVfo->Modulation == MODULATION_AM, false);
+    //RADIO_SetupAGC(false, false);
 
     // enable/disable BK4819 selected interrupts
     BK4819_WriteRegister(BK4819_REG_3F, InterruptMask);
@@ -992,6 +1106,31 @@ 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();
+        BK4819_SetRegValue(afDacGainRegSpec, 0xF);
+        BK4819_WriteRegister(BK4819_REG_3D, 0x2AAB);
+        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
+
     BK4819_AF_Type_t mod;
     switch(modulation) {
         default:
@@ -1005,45 +1144,74 @@ void RADIO_SetModulation(ModulationMode_t modulation)
             mod = BK4819_AF_BASEBAND2;
             break;
 
-#ifdef ENABLE_BYP_RAW_DEMODULATORS
-        case MODULATION_BYP:
-            mod = BK4819_AF_UNKNOWN3;
-            break;
-        case MODULATION_RAW:
-            mod = BK4819_AF_BASEBAND1;
-            break;
-#endif
     }
 
     BK4819_SetAF(mod);
 
-    // HACK, FIXME:
+    // 
     // What follows is a direct copy of the AM enable/disable code from
     // the original UV-K1 firmware. It is not clear why these specific register
     // values are used for AM all of a sudden instead of the AF setting like on
     // the BK4819, nor what exactly they do.
     // So for now we just keep it as is to maintain compatibility.
     //
-    if (modulation != MODULATION_AM)
+
+    switch (modulation)
     {
-        uint16_t uVar1 = BK4819_ReadRegister(0x31);
-        BK4819_WriteRegister(0x31,uVar1 & 0xfffffffe);
-        BK4819_WriteRegister(0x42,0x6b5a);
-        BK4819_WriteRegister(0x43, 0x3028);
-        BK4819_WriteRegister(0x2a,0x7400);
-        BK4819_WriteRegister(0x2b,0);
-        BK4819_WriteRegister(0x2f,0x9890);
-        //BK4819_WriteRegister(0x48, 0xb3a8); // set AF RX gain and DAC settings
-    }
-    else
-    {
-        uint16_t uVar1 = BK4819_ReadRegister(0x31);
-        BK4819_WriteRegister(0x31,uVar1 | 1);
-        BK4819_WriteRegister(0x42,0x6f5c);
-        BK4819_WriteRegister(0x43, 0x347c);
-        BK4819_WriteRegister(0x2a,0x7434);
-        BK4819_WriteRegister(0x2b,0x600);
-        BK4819_WriteRegister(0x2f,0x9990);
+        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);
+
+            #ifdef ENABLE_FEAT_F4HWN_AUDIO
+                AUDIO_ApplyAMProfile(gSetting_set_audio_am);
+            #else
+                BK4819_WriteRegister(0x54, 0x9009);
+                BK4819_WriteRegister(0x55, 0x31a9);
+            #endif
+
+            BK4819_SetFilterBandwidth(BK4819_FILTER_BW_AM, 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);
+            BK4819_WriteRegister(0x2b, 0x0000);
+            BK4819_WriteRegister(0x2f, 0x9890);
+
+            #ifdef ENABLE_FEAT_F4HWN_AUDIO
+                AUDIO_ApplyFMProfile(gSetting_set_audio_fm);
+            #else
+                BK4819_WriteRegister(0x54, 0x9009);
+                BK4819_WriteRegister(0x55, 0x31a9);
+            #endif
+            break;
+        }
     }
     
     BK4819_SetRegValue(afDacGainRegSpec, 0xF);
@@ -1055,30 +1223,22 @@ void RADIO_SetModulation(ModulationMode_t modulation)
 
 void RADIO_SetupAGC(bool listeningAM, bool disable)
 {
-    static uint8_t lastSettings;
+    static uint8_t lastSettings = 0xFF;
     uint8_t newSettings = (listeningAM << 1) | disable;
-    if(lastSettings == newSettings)
+    if (lastSettings == newSettings)
         return;
     lastSettings = newSettings;
 
-
-    if(!listeningAM) { // if not actively listening AM we don't need any AM specific regulation
-        BK4819_SetAGC(!disable);
-        BK4819_InitAGC(false);
-    }
-    else {
 #ifdef ENABLE_AM_FIX
-        if(gSetting_AM_fix) { // if AM fix active lock AGC so AM-fix can do it's job
-            BK4819_SetAGC(0);
-            AM_fix_enable(!disable);
-        }
-        else
-#endif
-        {
-            BK4819_SetAGC(!disable);
-            BK4819_InitAGC(true);
-        }
+    if (listeningAM && gSetting_AM_fix) {
+        BK4819_SetAGC(0);
+        AM_fix_enable(!disable);
+        return;
     }
+#endif
+
+    BK4819_SetAGC(!disable);
+    BK4819_InitAGC(listeningAM);
 }
 
 void RADIO_SetVfoState(VfoState_t State)
@@ -1152,6 +1312,12 @@ void RADIO_PrepareTX(void)
         // over voltage .. this is being a pain
         State = VFO_STATE_VOLTAGE_HIGH;
     }
+#ifdef ENABLE_BYP_RAW_DEMODULATORS
+    else if (gCurrentVfo->Modulation == MODULATION_BYP || gCurrentVfo->Modulation == MODULATION_RAW) {
+        // BYP/RAW are receive-only modes.
+        State = VFO_STATE_TX_DISABLE;
+    }
+#endif
 #ifndef ENABLE_TX_WHEN_AM
     else if (gCurrentVfo->Modulation != MODULATION_FM) {
         // not allowed to TX if in AM mode

App/radio.h

@@ -95,7 +95,7 @@ typedef struct VFO_Info_t
     uint32_t       TX_OFFSET_FREQUENCY;
     uint16_t       StepFrequency;
 
-    uint8_t        CHANNEL_SAVE;
+    uint16_t        CHANNEL_SAVE;
 
     uint8_t        TX_OFFSET_FREQUENCY_DIRECTION;
 
@@ -115,11 +115,9 @@ typedef struct VFO_Info_t
     uint8_t        SCRAMBLING_TYPE;
     uint8_t        CHANNEL_BANDWIDTH;
 
-    uint8_t        SCANLIST1_PARTICIPATION;
-    uint8_t        SCANLIST2_PARTICIPATION;
-    uint8_t        SCANLIST3_PARTICIPATION;
+    uint8_t        SCANLIST_PARTICIPATION;
 
-    uint8_t        Band;
+    uint16_t        Band;
 #ifdef ENABLE_DTMF_CALLING
     uint8_t        DTMF_DECODING_ENABLE;
 #endif
@@ -150,9 +148,11 @@ extern DCS_CodeType_t gCurrentCodeType;
 
 extern VfoState_t     VfoState[2];
 
+bool     RADIO_CheckValidList(uint8_t scanList);
+void     RADIO_NextValidList(int8_t direction);
 bool     RADIO_CheckValidChannel(uint16_t channel, bool checkScanList, uint8_t scanList);
-uint8_t  RADIO_FindNextChannel(uint8_t ChNum, int8_t Direction, bool bCheckScanList, uint8_t RadioNum);
-void     RADIO_InitInfo(VFO_Info_t *pInfo, const uint8_t ChannelSave, const uint32_t Frequency);
+uint16_t RADIO_FindNextChannel(uint16_t ChNum, int8_t Direction, bool bCheckScanList, uint8_t RadioNum);
+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_ApplyOffset(VFO_Info_t *pInfo);

App/scheduler.c

@@ -55,6 +55,7 @@ void SysTick_Handler(void)
         gNextTimeslice_500ms = true;
 
 #ifdef ENABLE_FEAT_F4HWN
+        DECREMENT_AND_TRIGGER(gVfoSaveCountdown_10ms, gScheduleVfoSave);
         DECREMENT_AND_TRIGGER(gTxTimerCountdownAlert_500ms - ALERT_TOT * 2, gTxTimeoutReachedAlert);
         #ifdef ENABLE_FEAT_F4HWN_RX_TX_TIMER
             DECREMENT(gRxTimerCountdown_500ms);

App/screenshot.c

@@ -18,106 +18,157 @@
 #include "driver/st7565.h"
 #include "screenshot.h"
 #include "misc.h"
+#include "driver/vcp.h"
+#include "driver/keyboard.h"
 
-void getScreenShot(bool force)
+// 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};
+static uint8_t forcedBlock = 0;
+static uint8_t keepAlive = 3;
+
+void SCREENSHOT_ParseInput(void)
 {
-    static uint8_t previousFrame[1024] = {0}; // Last transmitted frame
-    static uint8_t forcedBlock = 0;           // Block forced for refresh on each frame
-    static uint8_t keepAlive = 10;            // Keepalive counter
+    if (SCREENSHOT_IsLocked())
+        return;
 
-    // Use a single buffer to reduce stack usage
-    static uint8_t currentFrame[1024];        // Current frame
-    static uint8_t deltaFrame[128 * 9];       // Delta frame buffer
+    if (UART_IsCableConnected()) {
+        keepAlive = 15;
+        gUSB_ScreenshotEnabled = false;
+    }
+    else if (VCP_ScreenshotPing()) {
+        keepAlive = 15;
+        gUSB_ScreenshotEnabled = true;
+    }
+}
+
+static void SCREENSHOT_Send(const uint8_t *buf, uint16_t len)
+{
+    if (gUSB_ScreenshotEnabled) {
+        cdc_acm_data_send_with_dtr(buf, len);
+    } else {
+        UART_Send(buf, 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;
+        }
+    }
+}
+
+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 (gUART_LockScreenshot > 0) // Lock screenshot if Chirp is in used
-    {
-        gUART_LockScreenshot--;
+    if (SCREENSHOT_IsLocked())
         return;
-    }
-
-    if (UART_IsCableConnected()) {
-        keepAlive = 10;
-    }
 
     if (keepAlive > 0) {
-        if (--keepAlive == 0) return;
-    }
-    else
-    {
+        if (--keepAlive == 0) {
+            // Connection just lost → reset state for next reconnection
+            wasConnected = false;
+            return;
+        }
+    } else {
         return;
     }
 
-    // Build current frame from status line (first 8 lines)
-    for (uint8_t b = 0; b < 8; b++) {
-        for (uint8_t i = 0; i < 128; i++) {
-            uint8_t bit = (gStatusLine[i] >> b) & 0x01;
-            acc |= (bit << bitCount++);
-            if (bitCount == 8) {
-                currentFrame[index++] = acc;
-                acc = 0;
-                bitCount = 0;
-            }
-        }
+    // Connection is alive — detect reconnection and force full frame
+    if (!wasConnected) {
+        force = true;
+        wasConnected = true;
     }
 
-    // Build remaining part of the frame (7 * 8 lines)
+    // ==== 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++) {
-        for (uint8_t b = 0; b < 8; b++) {
-            for (uint8_t i = 0; i < 128; i++) {
-                uint8_t bit = (gFrameBuffer[l][i] >> b) & 0x01;
-                acc |= (bit << bitCount++);
-                if (bitCount == 8) {
-                    currentFrame[index++] = acc;
-                    acc = 0;
-                    bitCount = 0;
-                }
-            }
-        }
+        SCREENSHOT_Line(gFrameBuffer[l], frameBuffer, &index);
     }
 
     if (bitCount > 0)
-        currentFrame[index++] = acc;
+        frameBuffer[index++] = acc;
 
     if (index != 1024)
-        return; // Frame size mismatch, abort
+        return;
 
-    // Generate delta frame
+    // ==== FIRST PASS: Count changed chunks ====
     uint16_t deltaLen = 0;
+    uint8_t changedChunks[128];  // List of changed chunk indices
+    uint8_t changedCount = 0;
 
-    for (uint8_t block = 0; block < 128; block++) {
-        uint8_t *cur = &currentFrame[block * 8];
-        uint8_t *prev = &previousFrame[block * 8];
+    for (uint8_t chunk = 0; chunk < 128; chunk++) {
+        uint8_t *cur = &frameBuffer[chunk * 8];
+        uint8_t *prev = &previousFrame[chunk * 8];
 
-        bool changed    = memcmp(cur, prev, 8) != 0;
-        bool isForced   = (block == forcedBlock);
+        bool changed = memcmp(cur, prev, 8) != 0;
+        bool isForced = (chunk == forcedBlock);
         bool fullUpdate = force;
 
         if (changed || isForced || fullUpdate) {
-            deltaFrame[deltaLen++] = block;
-            memcpy(&deltaFrame[deltaLen], cur, 8);
-            deltaLen += 8;
-
-            memcpy(prev, cur, 8); // Update stored frame
+            changedChunks[changedCount++] = chunk;
+            deltaLen += 9;
         }
     }
 
     forcedBlock = (forcedBlock + 1) % 128;
 
     if (deltaLen == 0)
-        return; // No update needed
+        return;
 
-    // Send the delta frame over UART
+    // Skip transmission if a key is currently pressed
+    // UART_Send is blocking - would freeze the main loop and lose keypresses
+    if (gKeyReading0 != KEY_INVALID)
+        return;
+
+    // ==== Send version marker (for backward compatibility detection) ====
+    // New format: sends 0xFF before header
+    // Old format: doesn't exist, so viewers can differentiate
+    uint8_t versionMarker = 0xFF;
+    SCREENSHOT_Send(&versionMarker, 1);
+
+    // ==== Send header ====
     uint8_t header[5] = {
         0xAA, 0x55, 0x02,
         (uint8_t)(deltaLen >> 8),
         (uint8_t)(deltaLen & 0xFF)
     };
 
-    UART_Send(header, 5);
-    UART_Send(deltaFrame, deltaLen);
+    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];
+
+        chunk[0] = chunkIdx;
+        memcpy(&chunk[1], cur, 8);
+        
+        SCREENSHOT_Send(chunk, 9);
+        
+        // Update previousFrame for next comparison
+        memcpy(prev, cur, 8);
+    }
+
     uint8_t end = 0x0A;
-    UART_Send(&end, 1);
+    SCREENSHOT_Send(&end, 1);
 }

App/screenshot.h

@@ -17,6 +17,7 @@
 #ifndef SCREENSHOT_H
 #define SCREENSHOT_H
 
-void getScreenShot(bool force);
+void SCREENSHOT_Update(bool force);
+void SCREENSHOT_ParseInput(void);
 
 #endif

App/settings.c

@@ -28,25 +28,102 @@
 #include "settings.h"
 #include "ui/menu.h"
 
-#ifdef ENABLE_FEAT_F4HWN_RESET_CHANNEL
-static const uint32_t gDefaultFrequencyTable[] =
-{
-    14500000,    //
-    14550000,    //
-    43300000,    //
-    43320000,    //
-    43350000     //
-};
-#endif
-
 EEPROM_Config_t gEeprom = { 0 };
 
 void SETTINGS_InitEEPROM(void)
 {
     uint8_t Data[16] = {0};
+
+    //
+    // Version check
+    // Read stored version from EEPROM and compare with VERSION_STRING_2
+    // 
+    {
+        char storedVersion[16] = {0};
+        PY25Q16_ReadBuffer(0x00A160, storedVersion, sizeof(storedVersion));
+
+        // Compare with current version
+        if (strncmp(storedVersion, VERSION_STRING_2, sizeof(storedVersion)) != 0)
+        {
+            // Different version: new install or firmware update
+
+            // 1. Write new version to EEPROM
+            char newVersion[16] = {0};
+            strncpy(newVersion, VERSION_STRING_2, sizeof(newVersion));
+            PY25Q16_WriteBuffer(0x00A160, newVersion, sizeof(newVersion), false);
+
+            // 2. Reset sensitive parameters (MENU_LOCK, etc.)
+            uint8_t configByte[8] = {0};
+            PY25Q16_ReadBuffer(0x00A000, configByte, sizeof(configByte));
+
+            configByte[4] &= (uint8_t)~0x01;  // KEY_LOCK = 0
+            configByte[4] &= (uint8_t)~0x02;  // MENU_LOCK = 0
+            configByte[4] &= (uint8_t)~0x3C;  // SET_KEY = 0
+            //configByte[4] &= (uint8_t)~0x40;  // SET_NAV = 0
+
+            PY25Q16_WriteBuffer(0x00A000, configByte, sizeof(configByte), false);
+
+            // 3. Reset display inversion (SET_INV = 0)
+            uint8_t displayByte[8] = {0};
+            PY25Q16_ReadBuffer(0x00A158, displayByte, sizeof(displayByte));
+
+            displayByte[5] &= (uint8_t)~0x10;  // Clear bit 4 (SET_INV)
+
+            PY25Q16_WriteBuffer(0x00A158, displayByte, sizeof(displayByte), false);
+
+            // 4. Reset logo lines (clear to null for strlen() == 0)
+
+            char logoLines[32];
+            PY25Q16_ReadBuffer(0x00A0C8, logoLines, sizeof(logoLines));
+
+            bool needsWrite = false;
+
+            for (int line = 0; line < 2; line++) {
+                int offset = line * 16;
+                
+                for (int i = 0; i < 16; i++) {
+                    char c = logoLines[offset + i];
+                    if (c == 0) {
+                        break;
+                    }
+                    if (c < 0x20 || c > 0x7E) {
+                        memset(logoLines + offset, 0, 16);
+                        needsWrite = true;
+                        break;
+                    }
+                }
+            }
+
+            if (needsWrite) {
+                PY25Q16_WriteBuffer(0x00A0C8, logoLines, sizeof(logoLines), false);
+            }
+
+            // 5. Reset dBmCorrTable
+            int8_t buf[7];
+            PY25Q16_ReadBuffer(0x00A0B9, (uint8_t *)buf, 7);
+
+            needsWrite = true;
+            for (uint8_t i = 0; i < 7; i++) {
+                if ((uint8_t)buf[i] != 0xFF) {
+                    needsWrite = false;
+                    break;
+                }
+            }
+
+            if (needsWrite) {
+                for (uint8_t i = 0; i < 7; i++)
+                    buf[i] = dBmCorrTable[i];
+                PY25Q16_WriteBuffer(0x00A0B9, buf, 7, false);
+            }
+        }
+    }
+
     // 0E70..0E77
-    PY25Q16_ReadBuffer(0x004000, Data, 8);
-    gEeprom.CHAN_1_CALL          = IS_MR_CHANNEL(Data[0]) ? Data[0] : MR_CHANNEL_FIRST;
+    PY25Q16_ReadBuffer(0x00A000, Data, 8);
+    #ifdef ENABLE_FEAT_F4HWN_AUDIO
+        gSetting_set_audio_fm = ((Data[0] & 0x0F) < 5) ? (Data[0] & 0x0F) : 0;
+        gSetting_set_audio_am = (((Data[0] >> 4) & 0x0F) < 3) ? ((Data[0] >> 4) & 0x0F) : 0;
+    #endif
     gEeprom.SQUELCH_LEVEL        = (Data[1] < 10) ? Data[1] : 1;
     gEeprom.TX_TIMEOUT_TIMER     = (Data[2] > 4 && Data[2] < 180) ? Data[2] : 11;
     #ifdef ENABLE_NOAA
@@ -56,6 +133,7 @@ void SETTINGS_InitEEPROM(void)
         gEeprom.KEY_LOCK = (Data[4] & 0x01) != 0;
         gEeprom.MENU_LOCK = (Data[4] & 0x02) != 0;
         gEeprom.SET_KEY = ((Data[4] >> 2) & 0x0F) > 4 ? 0 : (Data[4] >> 2) & 0x0F;
+        gEeprom.SET_NAV = (Data[4] & 0x40) != 0;
     #else
         gEeprom.KEY_LOCK             = (Data[4] <  2) ? Data[4] : false;
     #endif
@@ -63,10 +141,10 @@ void SETTINGS_InitEEPROM(void)
         gEeprom.VOX_SWITCH       = (Data[5] <  2) ? Data[5] : false;
         gEeprom.VOX_LEVEL        = (Data[6] < 10) ? Data[6] : 1;
     #endif
-    gEeprom.MIC_SENSITIVITY      = (Data[7] <  5) ? Data[7] : 4;
+    gEeprom.MIC_SENSITIVITY      = (Data[7] <  9) ? Data[7] : 4;
 
     // 0E78..0E7F
-    PY25Q16_ReadBuffer(0x004008, Data, 8);
+    PY25Q16_ReadBuffer(0x00A008, Data, 8);
     gEeprom.BACKLIGHT_MAX         = (Data[0] & 0xF) <= 10 ? (Data[0] & 0xF) : 10;
     gEeprom.BACKLIGHT_MIN         = (Data[0] >> 4) < gEeprom.BACKLIGHT_MAX ? (Data[0] >> 4) : 0;
 #ifdef ENABLE_BLMIN_TMP_OFF
@@ -80,20 +158,23 @@ void SETTINGS_InitEEPROM(void)
     #ifdef ENABLE_FEAT_F4HWN_NARROWER
         gEeprom.TAIL_TONE_ELIMINATION = Data[6] & 0x01;
         gSetting_set_nfm = (Data[6] >> 1) & 0x01;
+        #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
+            gEeprom.VFO_OPEN = ((Data[6] >> 2) & 0x01) != 0 ? true : true;
+        #endif
     #else
         gEeprom.TAIL_TONE_ELIMINATION = (Data[6] < 2) ? Data[6] : false;
     #endif
 
     #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
-        gEeprom.VFO_OPEN = Data[7] & 0x01;
-        gEeprom.CURRENT_STATE = (Data[7] >> 1) & 0x07;
-        gEeprom.CURRENT_LIST = (Data[7] >> 4) & 0x07;
+        gEeprom.CURRENT_STATE =  Data[7]        & 0x07;   // bits 0..2
+        gEeprom.CURRENT_LIST  = (Data[7] >> 3)  & 0x1F;   // bits 3..7
     #else
         gEeprom.VFO_OPEN              = (Data[7] < 2) ? Data[7] : true;
     #endif
 
     // 0E80..0E87
-    PY25Q16_ReadBuffer(0x005000, Data, 8);
+    /*    
+    PY25Q16_ReadBuffer(0x00A010, Data, 8);
     gEeprom.ScreenChannel[0]   = IS_VALID_CHANNEL(Data[0]) ? Data[0] : (FREQ_CHANNEL_FIRST + BAND6_400MHz);
     gEeprom.ScreenChannel[1]   = IS_VALID_CHANNEL(Data[3]) ? Data[3] : (FREQ_CHANNEL_FIRST + BAND6_400MHz);
     gEeprom.MrChannel[0]       = IS_MR_CHANNEL(Data[1])    ? Data[1] : MR_CHANNEL_FIRST;
@@ -104,6 +185,24 @@ void SETTINGS_InitEEPROM(void)
     gEeprom.NoaaChannel[0] = IS_NOAA_CHANNEL(Data[6])  ? Data[6] : NOAA_CHANNEL_FIRST;
     gEeprom.NoaaChannel[1] = IS_NOAA_CHANNEL(Data[7])  ? Data[7] : NOAA_CHANNEL_FIRST;
 #endif
+    */
+
+// 0x00A010 .. 0x00A01F
+uint16_t Data16[8];
+
+PY25Q16_ReadBuffer(0x00A010, Data16, sizeof(Data16));
+
+gEeprom.ScreenChannel[0] = IS_VALID_CHANNEL(Data16[0]) ? Data16[0] : (FREQ_CHANNEL_FIRST + BAND6_400MHz);
+gEeprom.MrChannel[0]     = IS_MR_CHANNEL(Data16[1]) ? Data16[1] : MR_CHANNEL_FIRST;
+gEeprom.FreqChannel[0]   = IS_FREQ_CHANNEL(Data16[2]) ? Data16[2] : (FREQ_CHANNEL_FIRST + BAND6_400MHz);
+gEeprom.ScreenChannel[1] = IS_VALID_CHANNEL(Data16[3]) ? Data16[3] : (FREQ_CHANNEL_FIRST + BAND6_400MHz);
+gEeprom.MrChannel[1]     = IS_MR_CHANNEL(Data16[4]) ? Data16[4] : MR_CHANNEL_FIRST;
+gEeprom.FreqChannel[1]   = IS_FREQ_CHANNEL(Data16[5]) ? Data16[5] : (FREQ_CHANNEL_FIRST + BAND6_400MHz);
+
+#ifdef ENABLE_NOAA
+    gEeprom.NoaaChannel[0]   = IS_NOAA_CHANNEL(Data16[6]) ? Data16[6] : NOAA_CHANNEL_FIRST;
+    gEeprom.NoaaChannel[1]   = IS_NOAA_CHANNEL(Data16[7]) ? Data16[7] : NOAA_CHANNEL_FIRST;
+#endif
 
 #ifdef ENABLE_FMRADIO
     {   // 0E88..0E8F
@@ -115,7 +214,7 @@ void SETTINGS_InitEEPROM(void)
             uint8_t  band:2;
             //uint8_t  space:2;
         } __attribute__((packed)) fmCfg;
-        PY25Q16_ReadBuffer(0x006000, &fmCfg, 4);
+        PY25Q16_ReadBuffer(0x00A020, &fmCfg, 4);
 
         gEeprom.FM_Band = fmCfg.band;
         //gEeprom.FM_Space = fmCfg.space;
@@ -128,12 +227,12 @@ void SETTINGS_InitEEPROM(void)
     }
 
     // 0E40..0E67
-    PY25Q16_ReadBuffer(0x003000, gFM_Channels, sizeof(gFM_Channels));
+    PY25Q16_ReadBuffer(0x00A028, gFM_Channels, sizeof(gFM_Channels));
     FM_ConfigureChannelState();
 #endif
 
     // 0E90..0E97
-    PY25Q16_ReadBuffer(0x007000, Data, 8);
+    PY25Q16_ReadBuffer(0x00A0A8, Data, 8);
     gEeprom.BEEP_CONTROL                 = Data[0] & 1;
     gEeprom.KEY_M_LONG_PRESS_ACTION      = ((Data[0] >> 1) < ACTION_OPT_LEN) ? (Data[0] >> 1) : ACTION_OPT_NONE;
     gEeprom.KEY_1_SHORT_PRESS_ACTION     = (Data[1] < ACTION_OPT_LEN) ? Data[1] : ACTION_OPT_MONITOR;
@@ -150,28 +249,25 @@ void SETTINGS_InitEEPROM(void)
 
     // 0E98..0E9F
     #ifdef ENABLE_PWRON_PASSWORD
-        PY25Q16_ReadBuffer(0x007000 + 0x8, Data, 8);
+        PY25Q16_ReadBuffer(0x00A0A8 + 0x8, Data, 8);
         memcpy(&gEeprom.POWER_ON_PASSWORD, Data, 4);
     #endif
 
     // 0EA0..0EA7
-    PY25Q16_ReadBuffer(0x007000 + 0x10, Data, 8);
+    PY25Q16_ReadBuffer(0x00A0A8 + 0x10, Data, 8);
     #ifdef ENABLE_VOICE
     gEeprom.VOICE_PROMPT = (Data[0] < 3) ? Data[0] : VOICE_PROMPT_ENGLISH;
     #endif
     #ifdef ENABLE_RSSI_BAR
-        if((Data[1] < 200 && Data[1] > 90) && (Data[2] < Data[1]-9 && Data[1] < 160  && Data[2] > 50)) {
-            gEeprom.S0_LEVEL = Data[1];
-            gEeprom.S9_LEVEL = Data[2];
-        }
-        else {
-            gEeprom.S0_LEVEL = 130;
-            gEeprom.S9_LEVEL = 76;
+        for (uint8_t i = 0; i < 7; i++) {
+            int8_t val = (int8_t)Data[i + 1];
+            if (val >= -64 && val <= 64)
+                dBmCorrTable[i] = val;
         }
     #endif
 
     // 0EA8..0EAF
-    PY25Q16_ReadBuffer(0x007000 + 0x18, Data, 8);
+    PY25Q16_ReadBuffer(0x00A0A8 + 0x18, Data, 8);
     #ifdef ENABLE_ALARM
         gEeprom.ALARM_MODE                 = (Data[0] <  2) ? Data[0] : true;
     #endif
@@ -181,7 +277,7 @@ void SETTINGS_InitEEPROM(void)
     gEeprom.BATTERY_TYPE                   = (Data[4] < BATTERY_TYPE_UNKNOWN) ? Data[4] : BATTERY_TYPE_1600_MAH;
 
     // 0ED0..0ED7
-    PY25Q16_ReadBuffer(0x007000 + 0x40, Data, 8);
+    PY25Q16_ReadBuffer(0x00A0A8 + 0x40, Data, 8);
     gEeprom.DTMF_SIDE_TONE               = (Data[0] <   2) ? Data[0] : true;
 
 #ifdef ENABLE_DTMF_CALLING
@@ -195,7 +291,7 @@ void SETTINGS_InitEEPROM(void)
     gEeprom.DTMF_HASH_CODE_PERSIST_TIME  = (Data[7] < 101) ? Data[7] * 10 : 100;
 
     // 0ED8..0EDF
-    PY25Q16_ReadBuffer(0x007000 + 0x48, Data, 8);
+    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
@@ -203,7 +299,7 @@ void SETTINGS_InitEEPROM(void)
 
     // 0EE0..0EE7
 
-    PY25Q16_ReadBuffer(0x008000, Data, sizeof(gEeprom.ANI_DTMF_ID));
+    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 {
@@ -212,7 +308,7 @@ void SETTINGS_InitEEPROM(void)
 
 
     // 0EE8..0EEF
-    PY25Q16_ReadBuffer(0x008000 + 0x8, Data, sizeof(gEeprom.KILL_CODE));
+    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 {
@@ -220,7 +316,7 @@ void SETTINGS_InitEEPROM(void)
     }
 
     // 0EF0..0EF7
-    PY25Q16_ReadBuffer(0x008000 + 0x10, Data, sizeof(gEeprom.REVIVE_CODE));
+    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 {
@@ -229,7 +325,7 @@ void SETTINGS_InitEEPROM(void)
 #endif
 
     // 0EF8..0F07
-    PY25Q16_ReadBuffer(0x008000 + 0x18, Data, sizeof(gEeprom.DTMF_UP_CODE));
+    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 {
@@ -237,7 +333,7 @@ void SETTINGS_InitEEPROM(void)
     }
 
     // 0F08..0F17
-    PY25Q16_ReadBuffer(0x008000 + 0x28, Data, sizeof(gEeprom.DTMF_DOWN_CODE));
+    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 {
@@ -245,40 +341,28 @@ void SETTINGS_InitEEPROM(void)
     }
 
     // 0F18..0F1F
-    PY25Q16_ReadBuffer(0x009000, Data, 8);
-    gEeprom.SCAN_LIST_DEFAULT = (Data[0] < 6) ? Data[0] : 0;  // we now have 'all' channel scan option
+    PY25Q16_ReadBuffer(0x00A130, Data, 8);
 
-    // Fake data
-    /*
-    gEeprom.SCAN_LIST_ENABLED[0] = 0;
-    gEeprom.SCAN_LIST_ENABLED[1] = 0;
-    gEeprom.SCAN_LIST_ENABLED[2] = 0;
+    gEeprom.SCAN_LIST_DEFAULT =
+            (((Data[0] & 0x7F) >= 1) && ((Data[0] & 0x7F) <= (MR_CHANNELS_LIST + 1)))
+                ? (Data[0] & 0x7F)
+                : 1;
+    gEeprom.SCAN_LIST_ENABLED = (Data[0] >> 7) & 0x01;
 
-    gEeprom.SCANLIST_PRIORITY_CH1[0] =  0;
-    gEeprom.SCANLIST_PRIORITY_CH2[0] =  2;
+    gEeprom.SCANLIST_PRIORITY_CH[0] =
+            (uint16_t)Data[1] |
+            ((uint16_t)Data[2] << 8);
 
-    gEeprom.SCANLIST_PRIORITY_CH1[1] =  14;
-    gEeprom.SCANLIST_PRIORITY_CH2[1] =  15;
+    gEeprom.SCANLIST_PRIORITY_CH[1] =
+            (uint16_t)Data[3] |
+            ((uint16_t)Data[4] << 8);
 
-    gEeprom.SCANLIST_PRIORITY_CH1[2] =  40;
-    gEeprom.SCANLIST_PRIORITY_CH2[2] =  41;
-    */
-
-    // Fix me probably after Chirp update...
-    for (unsigned int i = 0; i < 3; i++)
-    {
-        gEeprom.SCAN_LIST_ENABLED[i] = (Data[1] >> i) & 1;
-    }
-
-    for (unsigned int i = 0; i < 3; i++)
-    {
-        const unsigned int j = 1 + (i * 2);
-        gEeprom.SCANLIST_PRIORITY_CH1[i] =  Data[j + 1];
-        gEeprom.SCANLIST_PRIORITY_CH2[i] =  Data[j + 2];
-    }
+    gEeprom.CHAN_1_CALL =
+            (uint16_t)Data[5] |
+            ((uint16_t)Data[6] << 8);
 
     // 0F40..0F47
-    PY25Q16_ReadBuffer(0x00b000, Data, 8);
+    PY25Q16_ReadBuffer(0x00A150, Data, 8);
     gSetting_F_LOCK            = (Data[0] < F_LOCK_LEN) ? Data[0] : F_LOCK_DEF;
 #ifndef ENABLE_FEAT_F4HWN
     gSetting_350TX             = (Data[1] < 2) ? Data[1] : false;  // was true
@@ -317,34 +401,65 @@ void SETTINGS_InitEEPROM(void)
     }
 
     // 0D60..0E27
-    PY25Q16_ReadBuffer(0x002000, gMR_ChannelAttributes, sizeof(gMR_ChannelAttributes));
-    for(uint16_t i = 0; i < sizeof(gMR_ChannelAttributes); i++) {
-        ChannelAttributes_t *att = &gMR_ChannelAttributes[i];
-        if(att->__val == 0xff){
+    /*
+    PY25Q16_ReadBuffer(0x008000, gMR_ChannelAttributes, sizeof(gMR_ChannelAttributes));
+    uint16_t count = ARRAY_SIZE(gMR_ChannelAttributes);
+
+    for (uint16_t i = 0; i < count; i++) {
+        ChannelAttributes_t *att = MR_GetChannelAttributes(i);
+
+        if (att->__val == 0xFFFF) {
             att->__val = 0;
             att->band = 0x7;
         }
-        gMR_ChannelExclude[i] = false;
+        else
+        {
+            att->exclude = 0;
+        }
+    }
+    */
+
+    // Init list name
+    PY25Q16_ReadBuffer(0x00880E, gListName, sizeof(gListName));
+
+    // Init attr cache
+    MR_InitChannelAttributesCache();
+
+    // Load and check channel
+    for (uint16_t i = 0; i < MR_CHANNELS_MAX + 7; i++) {
+        ChannelAttributes_t *att = MR_GetChannelAttributes(i);
+        
+        if (att != NULL) {
+            if (att->__val == 0xFFFF) {
+                att->__val = 0;
+                att->band = 0x7;
+                MR_SetChannelAttributes(i, att);  // ⭐ IMPORTANT: Sauvegarder!
+            }
+            else {
+                att->exclude = 0;
+                MR_SetChannelAttributes(i, att);  // ⭐ IMPORTANT: Sauvegarder!
+            }
+        }
     }
 
-        // 0F30..0F3F
-        PY25Q16_ReadBuffer(0x00a000, gCustomAesKey, sizeof(gCustomAesKey));
-        bHasCustomAesKey = false;
-        #ifndef ENABLE_FEAT_F4HWN
-            for (unsigned int i = 0; i < ARRAY_SIZE(gCustomAesKey); i++)
+    // 0F30..0F3F
+    PY25Q16_ReadBuffer(0x00A138, gCustomAesKey, sizeof(gCustomAesKey));
+    bHasCustomAesKey = false;
+    #ifndef ENABLE_FEAT_F4HWN
+        for (unsigned int i = 0; i < ARRAY_SIZE(gCustomAesKey); i++)
+        {
+            if (gCustomAesKey[i] != 0xFFFFFFFFu)
             {
-                if (gCustomAesKey[i] != 0xFFFFFFFFu)
-                {
-                    bHasCustomAesKey = true;
-                    return;
-                }
+                bHasCustomAesKey = true;
+                return;
             }
-        #endif
+        }
+    #endif
 
     #ifdef ENABLE_FEAT_F4HWN
         // 1FF0..0x1FF7
         // TODO: address TBD
-        PY25Q16_ReadBuffer(0x00c000, Data, 8);
+        PY25Q16_ReadBuffer(0x00A158, Data, 8);
         gSetting_set_pwr = (((Data[7] & 0xF0) >> 4) < 7) ? ((Data[7] & 0xF0) >> 4) : 0;
         gSetting_set_ptt = (((Data[7] & 0x0F)) < 2) ? ((Data[7] & 0x0F)) : 0;
 
@@ -461,7 +576,7 @@ void SETTINGS_LoadCalibration(void)
     }
 }
 
-uint32_t SETTINGS_FetchChannelFrequency(const int channel)
+uint32_t SETTINGS_FetchChannelFrequency(const uint16_t channel)
 {
     struct
     {
@@ -474,7 +589,7 @@ uint32_t SETTINGS_FetchChannelFrequency(const int channel)
     return info.frequency;
 }
 
-void SETTINGS_FetchChannelName(char *s, const int channel)
+void SETTINGS_FetchChannelName(char *s, const uint16_t channel)
 {
     if (s == NULL)
         return;
@@ -488,7 +603,7 @@ void SETTINGS_FetchChannelName(char *s, const int channel)
         return;
 
     // 0x0F50
-    PY25Q16_ReadBuffer(0x00e000 + (channel * 16), s, 10);
+    PY25Q16_ReadBuffer(0x004000 + (channel * 16), s, 10);
 
     int i;
     for (i = 0; i < 10; i++)
@@ -503,92 +618,72 @@ void SETTINGS_FetchChannelName(char *s, const int channel)
 
 void SETTINGS_FactoryReset(bool bIsAll)
 {
-    // 0000 - 0c80
-    PY25Q16_SectorErase(0);
-    // 0c80 - 0d60
-    PY25Q16_SectorErase(0x001000);
+    // PY25Q16_SectorErase(0x000000);
+    // PY25Q16_SectorErase(0x001000);
+    // PY25Q16_SectorErase(0x002000);
+    // PY25Q16_SectorErase(0x003000);
+    // PY25Q16_SectorErase(0x004000);
+    // PY25Q16_SectorErase(0x005000);
+    // PY25Q16_SectorErase(0x006000);
+    // PY25Q16_SectorErase(0x007000);
+    // PY25Q16_SectorErase(0x008000);
+    // PY25Q16_SectorErase(0x009000);
+
+    for (uint32_t addr = 0x000000; addr <= 0x009000; addr += 0x1000) {
+        PY25Q16_SectorErase(addr);
+    }
+    
     // 0d60 - 0e30
     if (bIsAll)
     {
-        PY25Q16_SectorErase(0x002000);
-    }
-    // 0e40 - 0e68
-    if (bIsAll)
-    {
-        PY25Q16_SectorErase(0x003000);
-    }
-    // 0e70 - 0e80
-    PY25Q16_SectorErase(0x004000);
-    // 0e80 - 0e88
-    PY25Q16_SectorErase(0x005000);
-    // 0e88 - 0e90
-    if (bIsAll)
-    {
-        PY25Q16_SectorErase(0x006000);
-    }
-    // 0e90 - 0ee0
-    do
-    {
-        uint8_t Buf[0x50];
-        memset(Buf, 0xff, 0x50);
-        // 0EA0 - 0EA8 : keep
-        PY25Q16_ReadBuffer(0x007000 + 0x10, Buf + 0x10, 8);
-        // 0EB0 - 0ED0 : keep
-        PY25Q16_ReadBuffer(0x007000 + 0x20, Buf + 0x20, 0x20);
-        PY25Q16_WriteBuffer(0x007000, Buf, 0x50, true);
-    } while (0);
-    // 0ee0 - 0f18 : keep
-    // 0f18 - 0f20
-    if (bIsAll)
-    {
-        PY25Q16_SectorErase(0x009000);
-    }
-    // 0f30 - 0f40 : keep
-    // 0f40 - 0f48 : keep
-    // 0f50 - 1bd0
-    if (bIsAll)
-    {
-        PY25Q16_SectorErase(0x00e000);
-    }
-    // 1c00 - 1d00 : keep
-
-    if (bIsAll)
-    {
-        RADIO_InitInfo(gRxVfo, FREQ_CHANNEL_FIRST + BAND6_400MHz, 43350000);
-
-        #ifdef ENABLE_FEAT_F4HWN_RESET_CHANNEL
-            // set the first few memory channels
-            for (i = 0; i < ARRAY_SIZE(gDefaultFrequencyTable); i++)
-            {
-                const uint32_t Frequency   = gDefaultFrequencyTable[i];
-                gRxVfo->freq_config_RX.Frequency = Frequency;
-                gRxVfo->freq_config_TX.Frequency = Frequency;
-                gRxVfo->Band               = FREQUENCY_GetBand(Frequency);
-                SETTINGS_SaveChannel(MR_CHANNEL_FIRST + i, 0, gRxVfo, 2);
-            }
-        #endif
-
-        #ifdef ENABLE_FEAT_F4HWN
-            PY25Q16_SectorErase(0x00c000);
-        #endif
+        PY25Q16_SectorErase(0x00A000);
     }
 
     // Prevent reset to restart in RO mode...
     #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-        {
-            uint8_t buf[0x10];
+        // Bloc 0x0E70..0x0E7F -> offset 0x00A000
+        uint8_t Data8[0x10];
+        PY25Q16_ReadBuffer(0x00A000, Data8, sizeof(Data8));
 
-            // Bloc 0x0E70..0x0E7F -> offset 0x004000
-            PY25Q16_ReadBuffer(0x004000, buf, sizeof(buf));
+        // MENU_LOCK & KEY_LOCK to 0
 
-            // bit 1 = MENU_LOCK => on le force à 0
-            buf[4] &= (uint8_t)~0x02;
+        Data8[4] &= (uint8_t)~0x01;
+        Data8[4] &= (uint8_t)~0x02;
 
-            PY25Q16_WriteBuffer(0x004000, buf, sizeof(buf), true);
+        // SET_KEY to 0
+        Data8[4] &= (uint8_t)~0x3C;  // Clear bits 2-5 (SET_KEY)
 
-            // cohérence RAM
-            gEeprom.MENU_LOCK = 0;
-        }
+        // SET_NAV to false
+        Data8[4] &= (uint8_t)~0x40;  // Clear bit 6 (SET_NAV) for UV-K1 by default
+
+        #ifdef ENABLE_FEAT_F4HWN_RESET_VFO
+            Data8[7] = (1 & 0x01);
+        #endif
+
+        PY25Q16_WriteBuffer(0x00A000, Data8, sizeof(Data8), false);
+
+        // cohérence RAM
+        gEeprom.MENU_LOCK = 0;
+    #endif
+
+    // Reset VFO for the first time...
+    #ifdef ENABLE_FEAT_F4HWN_RESET_VFO
+        RADIO_InitInfo(&gEeprom.VfoInfo[0], FREQ_CHANNEL_FIRST + BAND3_137MHz, 14550000);
+        RADIO_InitInfo(&gEeprom.VfoInfo[1], FREQ_CHANNEL_FIRST + BAND6_400MHz, 43350000);
+
+        gEeprom.ScreenChannel[0] = FREQ_CHANNEL_FIRST + BAND3_137MHz;
+        gEeprom.ScreenChannel[1] = FREQ_CHANNEL_FIRST + BAND6_400MHz;
+        gEeprom.MrChannel[0]     = MR_CHANNEL_FIRST;
+        gEeprom.MrChannel[1]     = MR_CHANNEL_FIRST;
+        gEeprom.FreqChannel[0]   = FREQ_CHANNEL_FIRST + BAND3_137MHz;
+        gEeprom.FreqChannel[1]   = FREQ_CHANNEL_FIRST + BAND6_400MHz;
+        
+        SETTINGS_SaveChannel(FREQ_CHANNEL_FIRST + BAND3_137MHz, 0, &gEeprom.VfoInfo[0], 2);
+        SETTINGS_SaveChannel(FREQ_CHANNEL_FIRST + BAND6_400MHz, 1, &gEeprom.VfoInfo[1], 2);
+
+        gVfoStateChanged = true;
+        gScheduleVfoSave = true;
+        SETTINGS_SaveVfoIndicesFlush();
     #endif
 }
 
@@ -613,35 +708,47 @@ void SETTINGS_SaveFM(void)
         fmCfg.band     = gEeprom.FM_Band;
         // fmCfg.space    = gEeprom.FM_Space;
         // 0E88
-        PY25Q16_WriteBuffer(0x006000, fmCfg.__raw, 8, true);
+        PY25Q16_WriteBuffer(0x00A020, fmCfg.__raw, 8, false);
 
         // 0E40
-        PY25Q16_WriteBuffer(0x003000, gFM_Channels, sizeof(gFM_Channels), true);
+        PY25Q16_WriteBuffer(0x00A028, gFM_Channels, sizeof(gFM_Channels), false);
     }
 #endif
 
 void SETTINGS_SaveVfoIndices(void)
 {
-    uint8_t State[8];
+    gVfoStateChanged = true;
+    gVfoSaveCountdown_10ms = 2;
+}
 
-    #ifndef ENABLE_NOAA
-        // 0x0E80
-        PY25Q16_ReadBuffer(0x005000, State, sizeof(State));
-    #endif
+void SETTINGS_SaveVfoIndicesFlush(void)
+{
+    if (gScheduleVfoSave) {
+        gScheduleVfoSave = false;
+        
+        if (gVfoStateChanged) {
+            gVfoStateChanged = false;
+            uint16_t Data16[8];
 
-    State[0] = gEeprom.ScreenChannel[0];
-    State[1] = gEeprom.MrChannel[0];
-    State[2] = gEeprom.FreqChannel[0];
-    State[3] = gEeprom.ScreenChannel[1];
-    State[4] = gEeprom.MrChannel[1];
-    State[5] = gEeprom.FreqChannel[1];
-    #ifdef ENABLE_NOAA
-        State[6] = gEeprom.NoaaChannel[0];
-        State[7] = gEeprom.NoaaChannel[1];
-    #endif
+            #ifndef ENABLE_NOAA
+                PY25Q16_ReadBuffer(0x00A010, Data16, sizeof(Data16));
+            #endif
 
-    // 0x0E80
-    PY25Q16_WriteBuffer(0x005000, State, 8, true);
+            Data16[0] = gEeprom.ScreenChannel[0];
+            Data16[1] = gEeprom.MrChannel[0];
+            Data16[2] = gEeprom.FreqChannel[0];
+            Data16[3] = gEeprom.ScreenChannel[1];
+            Data16[4] = gEeprom.MrChannel[1];
+            Data16[5] = gEeprom.FreqChannel[1];
+
+        #ifdef ENABLE_NOAA
+            Data16[6] = gEeprom.NoaaChannel[0];
+            Data16[7] = gEeprom.NoaaChannel[1];
+        #endif
+
+            PY25Q16_WriteBuffer(0x00A010, Data16, sizeof(Data16), false);
+        }
+    }
 }
 
 void SETTINGS_SaveSettings(void)
@@ -657,8 +764,15 @@ void SETTINGS_SaveSettings(void)
 
     // 0x0E70
     State = SecBuf;
-    State[0] = gEeprom.CHAN_1_CALL;
-    State[1] = gEeprom.SQUELCH_LEVEL;
+    #ifdef ENABLE_FEAT_F4HWN_AUDIO
+        State[0] = (gSetting_set_audio_fm & 0x0F) | ((gSetting_set_audio_am & 0x0F) << 4);
+    #endif
+    #ifdef ENABLE_FEAT_F4HWN
+        if (gSquelchLevelOriginal < 10)
+            State[1] = gSquelchLevelOriginal;
+        else
+    #endif
+        State[1] = gEeprom.SQUELCH_LEVEL;
     State[2] = gEeprom.TX_TIMEOUT_TIMER;
     #ifdef ENABLE_NOAA
         State[3] = gEeprom.NOAA_AUTO_SCAN;
@@ -667,7 +781,11 @@ void SETTINGS_SaveSettings(void)
     #endif
 
     #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-        State[4] = (gEeprom.KEY_LOCK ? 0x01 : 0) | (gEeprom.MENU_LOCK ? 0x02 :0) | ((gEeprom.SET_KEY & 0x0F) << 2);
+        State[4] =
+            (gEeprom.KEY_LOCK        ? 0x01 : 0) |
+            (gEeprom.MENU_LOCK       ? 0x02 : 0) |
+            ((gEeprom.SET_KEY & 0x0F) << 2)      |
+            (gEeprom.SET_NAV  ? 0x40 : 0);
     #else
         State[4] = gEeprom.KEY_LOCK;
     #endif
@@ -708,24 +826,30 @@ void SETTINGS_SaveSettings(void)
     #endif
 
     #ifdef ENABLE_FEAT_F4HWN_NARROWER
-        State[6] = (gEeprom.TAIL_TONE_ELIMINATION & 0x01) | ((gSetting_set_nfm & 0x03) << 1);
+        State[6] =
+            (gEeprom.TAIL_TONE_ELIMINATION & 0x01) |
+            ((gSetting_set_nfm & 0x01) << 1)
+        #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
+          | ((gEeprom.VFO_OPEN & 0x01) << 2)
+        #endif
+    ;
     #else
         State[6] = gEeprom.TAIL_TONE_ELIMINATION;
     #endif
 
     #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
-        State[7] = (gEeprom.VFO_OPEN & 0x01) | ((gEeprom.CURRENT_STATE & 0x07) << 1) | ((gEeprom.SCAN_LIST_DEFAULT & 0x07) << 4);
+        State[7] = (gEeprom.CURRENT_STATE & 0x07) | ((gEeprom.SCAN_LIST_DEFAULT & 0x1F) << 3);
     #else
         State[7] = gEeprom.VFO_OPEN;
     #endif
 
-    PY25Q16_WriteBuffer(0x004000, SecBuf, 0x10, true);
+    PY25Q16_WriteBuffer(0x00A000, SecBuf, 0x10, false);
 
     // -------------------------
     //  0e90 - 0ee0
 
     // memset(SecBuf, 0xff, 0x50);
-    PY25Q16_ReadBuffer(0x007000, SecBuf, 0x50);
+    PY25Q16_ReadBuffer(0x00A0A8, SecBuf, 0x50);
 
     // 0x0E90
     State = SecBuf;
@@ -788,35 +912,29 @@ void SETTINGS_SaveSettings(void)
     State[2] = gEeprom.PERMIT_REMOTE_KILL;
 #endif
 
-    PY25Q16_WriteBuffer(0x007000, SecBuf, 0x50, true);
+    PY25Q16_WriteBuffer(0x00A0A8, SecBuf, 0x50, false);
 
     // -------------------------
     // 0f18 - 0f20
 
-    memset(SecBuf, 0xff, 0x8);
+    memset(SecBuf, 0xff, 0x08);
 
     // 0x0F18
     State = SecBuf;
-    State[0] = gEeprom.SCAN_LIST_DEFAULT;
 
-    tmp = 0;
+    State[0] = (gEeprom.SCAN_LIST_DEFAULT & 0x7F)
+        | ((gEeprom.SCAN_LIST_ENABLED & 0x01) << 7);
 
-    if (gEeprom.SCAN_LIST_ENABLED[0] == 1)
-        tmp = tmp | (1 << 0);
-    if (gEeprom.SCAN_LIST_ENABLED[1] == 1)
-        tmp = tmp | (1 << 1);
-    if (gEeprom.SCAN_LIST_ENABLED[2] == 1)
-        tmp = tmp | (1 << 2);
+    State[1] = (uint8_t)(gEeprom.SCANLIST_PRIORITY_CH[0] & 0xFF);
+    State[2] = (uint8_t)(gEeprom.SCANLIST_PRIORITY_CH[0] >> 8);
 
-    State[1] = tmp;
-    State[2] = gEeprom.SCANLIST_PRIORITY_CH1[0];
-    State[3] = gEeprom.SCANLIST_PRIORITY_CH2[0];
-    State[4] = gEeprom.SCANLIST_PRIORITY_CH1[1];
-    State[5] = gEeprom.SCANLIST_PRIORITY_CH2[1];
-    State[6] = gEeprom.SCANLIST_PRIORITY_CH1[2];
-    State[7] = gEeprom.SCANLIST_PRIORITY_CH2[2];
+    State[3] = (uint8_t)(gEeprom.SCANLIST_PRIORITY_CH[1] & 0xFF);
+    State[4] = (uint8_t)(gEeprom.SCANLIST_PRIORITY_CH[1] >> 8);
 
-    PY25Q16_WriteBuffer(0x009000, SecBuf, 8, true);
+    State[5] = (uint8_t)(gEeprom.CHAN_1_CALL & 0xFF);
+    State[6] = (uint8_t)(gEeprom.CHAN_1_CALL >> 8);
+
+    PY25Q16_WriteBuffer(0x00A130, SecBuf, 0x08, false);
 
     // ---------------------
     // 0f40 - 0f48
@@ -856,7 +974,7 @@ void SETTINGS_SaveSettings(void)
     #endif
     State[7] = (State[7] & ~(3u << 6)) | ((gSetting_backlight_on_tx_rx & 3u) << 6);
 
-    PY25Q16_WriteBuffer(0x00b000, SecBuf, 8, true);
+    PY25Q16_WriteBuffer(0x00A150, SecBuf, 8, false);
 
     // ------------------
 
@@ -864,7 +982,7 @@ void SETTINGS_SaveSettings(void)
     // 0x1FF0
     State = SecBuf;
     // TODO: TBD
-    PY25Q16_ReadBuffer(0x00c000, State, 8);
+    PY25Q16_ReadBuffer(0x00A158, State, 8);
 
     //memset(State, 0xFF, sizeof(State));
 
@@ -905,7 +1023,7 @@ void SETTINGS_SaveSettings(void)
 
     gEeprom.KEY_LOCK_PTT = gSetting_set_lck;
 
-    PY25Q16_WriteBuffer(0x00c000, SecBuf, 8, true);
+    PY25Q16_WriteBuffer(0x00A158, SecBuf, 8, false);
 #endif
 
 #ifdef ENABLE_FEAT_F4HWN_VOL
@@ -913,7 +1031,7 @@ void SETTINGS_SaveSettings(void)
 #endif
 }
 
-void SETTINGS_SaveChannel(uint8_t Channel, uint8_t VFO, const VFO_Info_t *pVFO, uint8_t Mode)
+void SETTINGS_SaveChannel(uint16_t Channel, uint8_t VFO, const VFO_Info_t *pVFO, uint8_t Mode)
 {
 #ifdef ENABLE_NOAA
     if (IS_NOAA_CHANNEL(Channel))
@@ -925,7 +1043,7 @@ void SETTINGS_SaveChannel(uint8_t Channel, uint8_t VFO, const VFO_Info_t *pVFO,
 
     if (IS_FREQ_CHANNEL(Channel)) { // it's a VFO, not a channel
         // 0x0C80
-        OffsetVFO  = (VFO == 0) ? 0x001000 : 0x001010;
+        OffsetVFO  = (VFO == 0) ? 0x009000 : 0x009010;
         OffsetVFO += (Channel - FREQ_CHANNEL_FIRST) * 32;
     }
 
@@ -990,16 +1108,16 @@ void SETTINGS_SaveBatteryCalibration(const uint16_t * batteryCalibration)
     PY25Q16_WriteBuffer(0x010000 + 0x140, batteryCalibration, 12, false);
 }
 
-void SETTINGS_SaveChannelName(uint8_t channel, const char * name)
+void SETTINGS_SaveChannelName(uint16_t channel, const char * name)
 {
     uint16_t offset = channel * 16;
     uint8_t buf[16] = {0};
     memcpy(buf, name, MIN(strlen(name), 10u));
     // 0x0F50
-    PY25Q16_WriteBuffer(0x00e000 + offset, buf, 0x10, false);
+    PY25Q16_WriteBuffer(0x004000 + offset, buf, 0x10, false);
 }
 
-void SETTINGS_UpdateChannel(uint8_t channel, const VFO_Info_t *pVFO, bool keep, bool check, bool save)
+void SETTINGS_UpdateChannel(uint16_t channel, const VFO_Info_t *pVFO, bool keep, bool check, bool save)
 {
 #ifdef ENABLE_NOAA
     if (!IS_NOAA_CHANNEL(channel))
@@ -1009,20 +1127,22 @@ void SETTINGS_UpdateChannel(uint8_t channel, const VFO_Info_t *pVFO, bool keep,
         ChannelAttributes_t  att = {
             .band = 0x7,
             .compander = 0,
-            .scanlist1 = 0,
-            .scanlist2 = 0,
-            .scanlist3 = 0,
+            .unused_1 = 0,
+            .unused_2 = 0,
+            .exclude = 0,
+            .scanlist = 0,
             };        // default attributes
 
         // 0x0D60
-        PY25Q16_ReadBuffer(0x002000 + channel, &state, 1);
+        PY25Q16_ReadBuffer(0x008000 + (channel * 2), &state, 2);
 
         if (keep) {
             att.band = pVFO->Band;
-            att.scanlist1 = pVFO->SCANLIST1_PARTICIPATION;
-            att.scanlist2 = pVFO->SCANLIST2_PARTICIPATION;
-            att.scanlist3 = pVFO->SCANLIST3_PARTICIPATION;
             att.compander = pVFO->Compander;
+            att.unused_1 = 0;
+            att.unused_2 = 0;
+            att.exclude = 0;
+            att.scanlist = pVFO->SCANLIST_PARTICIPATION;
             if (check && state.__val == att.__val)
                 return; // no change in the attributes
         }
@@ -1034,13 +1154,13 @@ void SETTINGS_UpdateChannel(uint8_t channel, const VFO_Info_t *pVFO, bool keep,
 #endif
         if(save)
         {
-            uint8_t buf[224];
-            PY25Q16_ReadBuffer(0x002000, buf, sizeof(buf));
+            uint16_t buf[MR_CHANNELS_MAX + 24];
+            PY25Q16_ReadBuffer(0x008000, buf, sizeof(buf));
             buf[channel] = state.__val;
-            PY25Q16_WriteBuffer(0x002000, buf, sizeof(buf), true);
+            PY25Q16_WriteBuffer(0x008000, buf, sizeof(buf), false);
         }
 
-        gMR_ChannelAttributes[channel] = att;
+        MR_SetChannelAttributes(channel, &att);
 
         if (IS_MR_CHANNEL(channel)) {   // it's a memory channel
             if (!keep) {
@@ -1057,7 +1177,7 @@ void SETTINGS_WriteBuildOptions(void)
 
 #ifdef ENABLE_FEAT_F4HWN
     // 0x1FF0
-    PY25Q16_ReadBuffer(0x00c000, State, sizeof(State));
+    PY25Q16_ReadBuffer(0x00A158, State, sizeof(State));
 #endif
     
 State[0] = 0
@@ -1110,18 +1230,37 @@ State[1] = 0
     | (1 << 6)
 #endif
 ;
-    PY25Q16_WriteBuffer(0x00c000, State, sizeof(State), true);
+    PY25Q16_WriteBuffer(0x00A158, State, sizeof(State), false);
 }
 
 #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
     void SETTINGS_WriteCurrentState(void)
     {
-        uint8_t State[0x10];
-        // 0x0E78
-        PY25Q16_ReadBuffer(0x004000, State, sizeof(State));
-        //State[11] = (gEeprom.CURRENT_STATE << 4) | (gEeprom.BATTERY_SAVE & 0x0F);
-        State[15] = (gEeprom.VFO_OPEN & 0x01) | ((gEeprom.CURRENT_STATE & 0x07) << 1) | ((gEeprom.SCAN_LIST_DEFAULT & 0x07) << 4);
-        PY25Q16_WriteBuffer(0x004000, State, sizeof(State), true);
+        uint8_t State[0x08];
+
+        PY25Q16_ReadBuffer(0x00A008, State, sizeof(State));
+        State[7] =
+            (gEeprom.CURRENT_STATE & 0x07) |
+            ((gEeprom.SCAN_LIST_DEFAULT & 0x1F) << 3);
+        PY25Q16_WriteBuffer(0x00A008, State, sizeof(State), false);
+
+        //
+
+        PY25Q16_ReadBuffer(0x00A130, State, sizeof(State));
+
+        State[0] = (gEeprom.SCAN_LIST_DEFAULT & 0x7F)
+            | ((gEeprom.SCAN_LIST_ENABLED & 0x01) << 7);
+
+        State[1] = (uint8_t)(gEeprom.SCANLIST_PRIORITY_CH[0] & 0xFF);
+        State[2] = (uint8_t)(gEeprom.SCANLIST_PRIORITY_CH[0] >> 8);
+
+        State[3] = (uint8_t)(gEeprom.SCANLIST_PRIORITY_CH[1] & 0xFF);
+        State[4] = (uint8_t)(gEeprom.SCANLIST_PRIORITY_CH[1] >> 8);
+
+        State[5] = (uint8_t)(gEeprom.CHAN_1_CALL & 0xFF);
+        State[6] = (uint8_t)(gEeprom.CHAN_1_CALL >> 8);
+
+        PY25Q16_WriteBuffer(0x00A130, State, sizeof(State), false);
     }
 #endif
 
@@ -1137,32 +1276,44 @@ State[1] = 0
 #endif
 
 #ifdef ENABLE_FEAT_F4HWN
+
 void SETTINGS_ResetTxLock(void)
 {
-    // TODO: This is expensive operation!
+    // This is an expensive operation: full scan of all MR channels
 
-#define SETTINGS_ResetTxLock_BATCH 10
+    #define CHANNEL_SIZE               16
+    #define TXLOCK_BYTE_OFFSET         12
+    #define TXLOCK_BIT                 6
+    #define SETTINGS_ResetTxLock_BATCH 32
 
-    uint8_t Buf[0xc80 / SETTINGS_ResetTxLock_BATCH];
-    const uint32_t BatchSize = 0xc80 / SETTINGS_ResetTxLock_BATCH;
-    const uint32_t BatchChCnt = BatchSize / 0x10;
+    const uint32_t TotalBytes  = MR_CHANNELS_MAX * CHANNEL_SIZE;   // 1024 * 16 = 16 384
+    const uint32_t BatchSize   = TotalBytes / SETTINGS_ResetTxLock_BATCH; // 16 384 / 32 = 512
+    const uint32_t BatchChCnt  = BatchSize / CHANNEL_SIZE;         // 32 channels per batch
 
-    for (uint32_t i = 0; i < SETTINGS_ResetTxLock_BATCH; i++)
+    uint8_t Buf[BatchSize];
+
+    for (uint32_t batch = 0; batch < SETTINGS_ResetTxLock_BATCH; batch++)
     {
-        uint32_t Offset = i * BatchSize;
-        PY25Q16_ReadBuffer(0 + Offset, Buf, sizeof(Buf));
+        uint32_t Offset = batch * BatchSize;
 
-        uint8_t *State;
-        for (uint8_t channel = 0; channel < BatchChCnt; channel++)
+        PY25Q16_ReadBuffer(Offset, Buf, BatchSize);
+
+        for (uint32_t ch = 0; ch < BatchChCnt; ch++)
         {
-            uint16_t OffsetVFO = channel * 16;
-            State = Buf + OffsetVFO;
-            State[4] |= (1 << 6);
+            uint32_t off = ch * CHANNEL_SIZE;
+            Buf[off + TXLOCK_BYTE_OFFSET] |= (1 << TXLOCK_BIT);
         }
 
-        PY25Q16_WriteBuffer(0 + Offset, Buf, sizeof(Buf), false);
+        PY25Q16_WriteBuffer(Offset, Buf, BatchSize, false);
     }
 
-#undef SETTINGS_ResetTxLock_BATCH
+    RADIO_ConfigureChannel(0, VFO_CONFIGURE_RELOAD);
+    RADIO_ConfigureChannel(1, VFO_CONFIGURE_RELOAD);
+
+    #undef SETTINGS_ResetTxLock_BATCH
+    #undef CHANNEL_SIZE
+    #undef TXLOCK_BYTE_OFFSET
+    #undef TXLOCK_BIT
 }
+
 #endif

App/settings.h

@@ -118,6 +118,7 @@ enum ACTION_OPT_t {
     ACTION_OPT_WN,
     ACTION_OPT_BACKLIGHT,
     ACTION_OPT_MUTE,
+    ACTION_OPT_RXA,
     #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
         ACTION_OPT_POWER_HIGH,
         ACTION_OPT_REMOVE_OFFSET,
@@ -162,11 +163,11 @@ enum CHANNEL_DisplayMode_t {
 typedef enum CHANNEL_DisplayMode_t CHANNEL_DisplayMode_t;
 
 typedef struct {
-    uint8_t               ScreenChannel[2]; // current channels set in the radio (memory or frequency channels)
-    uint8_t               FreqChannel[2]; // last frequency channels used
-    uint8_t               MrChannel[2]; // last memory channels used
+    uint16_t               ScreenChannel[2]; // current channels set in the radio (memory or frequency channels)
+    uint16_t               FreqChannel[2]; // last frequency channels used
+    uint16_t               MrChannel[2]; // last memory channels used
 #ifdef ENABLE_NOAA
-    uint8_t           NoaaChannel[2];
+    uint16_t           NoaaChannel[2];
 #endif
 
     // The actual VFO index (0-upper/1-lower) that is now used for RX, 
@@ -194,6 +195,7 @@ typedef struct {
     bool                  KEY_LOCK;
 #ifdef ENABLE_FEAT_F4HWN
     bool                  KEY_LOCK_PTT;
+    bool                  SET_NAV;
 #endif
 #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
     bool                  MENU_LOCK;
@@ -214,9 +216,8 @@ typedef struct {
     uint8_t               BACKLIGHT_TIME;
     uint8_t               SCAN_RESUME_MODE;
     uint8_t               SCAN_LIST_DEFAULT;
-    bool                  SCAN_LIST_ENABLED[3];
-    uint8_t               SCANLIST_PRIORITY_CH1[3];
-    uint8_t               SCANLIST_PRIORITY_CH2[3];
+    bool                  SCAN_LIST_ENABLED;
+    uint16_t              SCANLIST_PRIORITY_CH[6];
 //#ifdef ENABLE_FEAT_F4HWN_RESUME_STATE // Fix me !!! What the hell is this?
     uint8_t               CURRENT_STATE;
     uint8_t               CURRENT_LIST;
@@ -241,7 +242,7 @@ typedef struct {
     uint8_t               KEY_2_LONG_PRESS_ACTION;
     uint8_t               MIC_SENSITIVITY;
     uint8_t               MIC_SENSITIVITY_TUNING;
-    uint8_t               CHAN_1_CALL;
+    uint16_t              CHAN_1_CALL;
 #ifdef ENABLE_DTMF_CALLING
     char                  ANI_DTMF_ID[8];
     char                  KILL_CODE[8];
@@ -308,18 +309,19 @@ extern EEPROM_Config_t gEeprom;
 
 void     SETTINGS_InitEEPROM(void);
 void     SETTINGS_LoadCalibration(void);
-uint32_t SETTINGS_FetchChannelFrequency(const int channel);
-void     SETTINGS_FetchChannelName(char *s, const int channel);
+uint32_t SETTINGS_FetchChannelFrequency(const uint16_t channel);
+void     SETTINGS_FetchChannelName(char *s, const uint16_t channel);
 void     SETTINGS_FactoryReset(bool bIsAll);
 #ifdef ENABLE_FMRADIO
     void SETTINGS_SaveFM(void);
 #endif
 void SETTINGS_SaveVfoIndices(void);
+void SETTINGS_SaveVfoIndicesFlush(void);
 void SETTINGS_SaveSettings(void);
-void SETTINGS_SaveChannelName(uint8_t channel, const char * name);
-void SETTINGS_SaveChannel(uint8_t Channel, uint8_t VFO, const VFO_Info_t *pVFO, uint8_t Mode);
+void SETTINGS_SaveChannelName(uint16_t channel, const char * name);
+void SETTINGS_SaveChannel(uint16_t Channel, uint8_t VFO, const VFO_Info_t *pVFO, uint8_t Mode);
 void SETTINGS_SaveBatteryCalibration(const uint16_t * batteryCalibration);
-void SETTINGS_UpdateChannel(uint8_t channel, const VFO_Info_t *pVFO, bool keep, bool check, bool save);
+void SETTINGS_UpdateChannel(uint16_t channel, const VFO_Info_t *pVFO, bool keep, bool check, bool save);
 void SETTINGS_WriteBuildOptions(void);
 #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
     void SETTINGS_WriteCurrentState(void);

App/ui/aircopy.c

@@ -70,7 +70,15 @@ void UI_DisplayAircopy(void)
 
     memset(String, 0, sizeof(String));
 
-    percent = (gAirCopyBlockNumber * 10000) / 120;
+    // Get the current map and calculate percentage based on its total blocks
+    const AIRCOPY_TransferMap_t *currentMap = AIRCOPY_GetCurrentMap();
+
+    uint16_t doneBlocks = gAirCopyBlockNumber + gErrorsDuringAirCopy;
+
+    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);
@@ -86,7 +94,7 @@ void UI_DisplayAircopy(void)
         gFrameBuffer[4][1] = 0x3c;
         gFrameBuffer[4][2] = 0x42;
 
-        for(uint8_t i = 1; i <= 122; i++)
+        for(uint8_t i = 1; i <= AIRCOPY_BAR_WIDTH + 2; i++)
         {
             gFrameBuffer[4][2 + i] = 0x81;
         }
@@ -94,26 +102,61 @@ void UI_DisplayAircopy(void)
         gFrameBuffer[4][125] = 0x42;
         gFrameBuffer[4][126] = 0x3c;
     }
-
-    if(gAirCopyBlockNumber + gErrorsDuringAirCopy != 0)
+    
+    // Draw memory selection
+    if(gAircopyState == AIRCOPY_READY)
     {
-        // Check CRC
-        if(gErrorsDuringAirCopy != lErrorsDuringAirCopy)
+        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
         {
-            set_bit(crc, gAirCopyBlockNumber + gErrorsDuringAirCopy);
+            sprintf(String, "Settings");            
+        }
+        UI_PrintString(String, 2, 127, 5, 8);
+    }
+
+    if (doneBlocks > 0)
+    {
+        // Track CRC errors per real block index
+        if (gErrorsDuringAirCopy != lErrorsDuringAirCopy)
+        {
+            // Mark the last processed block as faulty
+            set_bit(crc, doneBlocks - 1);
             lErrorsDuringAirCopy = gErrorsDuringAirCopy;
         }
 
-        for(uint8_t i = 0; i < (gAirCopyBlockNumber + gErrorsDuringAirCopy); i++)
+        const AIRCOPY_TransferMap_t *currentMap = AIRCOPY_GetCurrentMap();
+
+        uint16_t total = currentMap->total_blocks;
+        uint16_t done  = gAirCopyBlockNumber + gErrorsDuringAirCopy;
+        
+        if (done > total) done = total;
+
+        for (uint8_t col = 0; col < AIRCOPY_BAR_WIDTH; col++)
         {
-            if(get_bit(crc, i) == 0)
-            {
-                gFrameBuffer[4][i + 4] = 0xbd;
-            }
+            /* 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 error     = processed && get_bit(crc, b);
+
+            if (!processed)
+                gFrameBuffer[4][col + 4] = 0x81;   // not yet processed
+            else if (error)
+                gFrameBuffer[4][col + 4] = 0x81;   // error gap (intentional hole)
+            else
+                gFrameBuffer[4][col + 4] = 0xBD;   // ok filled
         }
+
     }
 
     ST7565_BlitFullScreen();
 }
 
-#endif
+#endif

App/ui/fmradio.c

@@ -35,6 +35,10 @@ void UI_DisplayFM(void)
     char *pPrintStr = String;
     UI_DisplayClear();
 
+#ifdef ENABLE_FEAT_F4HWN
+    UI_DisplayUnlockKeyboard(5);
+#endif
+
     UI_PrintString("FM", 2, 0, 0, 8);
 
     sprintf(String, "%d%s-%dM", 
@@ -59,7 +63,7 @@ void UI_DisplayFM(void)
             pPrintStr = String;
         } else {
             pPrintStr = "VFO";
-            for (unsigned int i = 0; i < 20; i++) {
+            for (unsigned int i = 0; i < FM_CHANNELS_MAX; i++) {
                 if (gEeprom.FM_FrequencyPlaying == gFM_Channels[i]) {
                     sprintf(String, "VFO(CH%02u)", i + 1);
                     pPrintStr = String;
@@ -68,7 +72,7 @@ void UI_DisplayFM(void)
             }
         }
     } else if (gFM_AutoScan) {
-        sprintf(String, "A-SCAN(%u)", gFM_ChannelPosition + 1);
+        sprintf(String, "A-SCAN(%u)", gFM_ChannelPosition);
         pPrintStr = String;
     } else {
         pPrintStr = "M-SCAN";

App/ui/helper.c

@@ -22,12 +22,10 @@
 #include "ui/helper.h"
 #include "ui/inputbox.h"
 #include "misc.h"
+#include "settings.h"
 
-#ifndef ARRAY_SIZE
-    #define ARRAY_SIZE(arr) (sizeof(arr)/sizeof((arr)[0]))
-#endif
 
-void UI_GenerateChannelString(char *pString, const uint8_t Channel)
+void UI_GenerateChannelString(char *pString, const uint16_t Channel)
 {
     unsigned int i;
 
@@ -44,24 +42,26 @@ void UI_GenerateChannelString(char *pString, const uint8_t Channel)
         pString[i + 3] = (gInputBox[i] == 10) ? '-' : gInputBox[i] + '0';
 }
 
-void UI_GenerateChannelStringEx(char *pString, const bool bShowPrefix, const uint8_t ChannelNumber)
+void UI_GenerateChannelStringEx(char *pString, const bool bShowPrefix, const uint16_t ChannelNumber)
 {
     if (gInputBoxIndex > 0) {
-        for (unsigned int i = 0; i < 3; i++) {
+        for (unsigned int i = 0; i < 4; i++) {
             pString[i] = (gInputBox[i] == 10) ? '-' : gInputBox[i] + '0';
         }
 
-        pString[3] = 0;
+        pString[4] = 0;
         return;
     }
 
     if (bShowPrefix) {
         // BUG here? Prefixed NULLs are allowed
-        sprintf(pString, "CH-%03u", ChannelNumber + 1);
-    } else if (ChannelNumber == 0xFF) {
+        sprintf(pString, "CH-%04u", ChannelNumber + 1);
+    } else if (ChannelNumber == MR_CHANNEL_LAST + 1) {
+        strcpy(pString, "None");
+    } else if (ChannelNumber == 0xFFFF) {
         strcpy(pString, "NULL");
     } else {
-        sprintf(pString, "%03u", ChannelNumber + 1);
+        sprintf(pString, "%04u", ChannelNumber + 1);
     }
 }
 
@@ -116,6 +116,35 @@ void UI_PrintStringSmallNormal(const char *pString, uint8_t Start, uint8_t End,
     UI_PrintStringSmall(pString, Start, End, Line, ARRAY_SIZE(gFontSmall[0]), (const uint8_t *)gFontSmall);
 }
 
+void UI_PrintStringSmallNormalInverse(const char *pString, uint8_t Start, uint8_t End, uint8_t Line)
+{
+    // First draw the string normally
+    UI_PrintStringSmallNormal(pString, Start, End, Line);
+
+    // Now invert the framebuffer bits for the rendered area
+    uint8_t len = strlen(pString);
+    uint8_t char_width = 7; // small font is typically 6px wide
+
+    uint8_t x_start = Start;
+    uint8_t x_end   = Start + (len * char_width) + 1;
+
+    if (End != 0 && x_end > End)
+        x_end = End;
+
+    //gFrameBuffer[Line][x_start - 2] ^= 0x3E;
+    gFrameBuffer[Line][x_start - 1] ^= 0x7F;
+    //gFrameBuffer[Line][x_start - 1] ^= 0xFF;
+    for (uint8_t x = x_start; x < x_end; x++)
+    {
+        gFrameBuffer[Line][x] ^= 0xFF;
+        gFrameBuffer[Line - 1][x] ^= 0x80;
+    }
+    //gFrameBuffer[Line][x_end + 0] ^= 0xFF;
+    gFrameBuffer[Line][x_end + 0] ^= 0x7F;
+    //gFrameBuffer[Line][x_end + 1] ^= 0x3E;
+}
+
+
 void UI_PrintStringSmallBold(const char *pString, uint8_t Start, uint8_t End, uint8_t Line)
 {
 #ifdef ENABLE_SMALL_BOLD
@@ -293,6 +322,33 @@ static void sort(int16_t *a, int16_t *b)
         x += 4;
       }
     }
+
+    void UI_DisplayUnlockKeyboard(uint8_t shift) {
+        if (gEeprom.KEY_LOCK && gKeypadLocked > 0)
+        {   // tell user how to unlock the keyboard
+            
+            //memcpy(gFrameBuffer[shift] + 2, gFontKeyLock, sizeof(gFontKeyLock));
+            UI_PrintStringSmallBold("UNLOCK KEYBOARD", 12, 0, shift);
+            //memcpy(gFrameBuffer[shift] + 120, gFontKeyLock, sizeof(gFontKeyLock));
+
+            /*
+            for (uint8_t i = 12; i < 116; i++)
+            {
+                gFrameBuffer[shift][i] ^= 0xFF;
+            }
+            */
+        }
+    }
+
+    bool IsEmptyName(const char *name, uint8_t len) {
+        if (name[0] == '\0' || name[0] == '\xff')
+            return true;
+        for (uint8_t i = 0; i < len; i++) {
+            if (name[i] != ' ' && name[i] != '\xff' && name[i] != '\0')
+                return false;
+        }
+        return true;
+    }
 #endif
     
 void UI_DrawLineBuffer(uint8_t (*buffer)[128], int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool black)

App/ui/helper.h

@@ -20,10 +20,11 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-void UI_GenerateChannelString(char *pString, const uint8_t Channel);
-void UI_GenerateChannelStringEx(char *pString, const bool bShowPrefix, const uint8_t ChannelNumber);
+void UI_GenerateChannelString(char *pString, const uint16_t Channel);
+void UI_GenerateChannelStringEx(char *pString, const bool bShowPrefix, const uint16_t ChannelNumber);
 void UI_PrintString(const char *pString, uint8_t Start, uint8_t End, uint8_t Line, uint8_t Width);
 void UI_PrintStringSmallNormal(const char *pString, uint8_t Start, uint8_t End, uint8_t Line);
+void UI_PrintStringSmallNormalInverse(const char *pString, uint8_t Start, uint8_t End, uint8_t Line);
 void UI_PrintStringSmallBold(const char *pString, uint8_t Start, uint8_t End, uint8_t Line);
 void UI_PrintStringSmallBufferNormal(const char *pString, uint8_t *buffer);
 void UI_PrintStringSmallBufferBold(const char *pString, uint8_t * buffer);
@@ -37,6 +38,8 @@ 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 UI_DisplayUnlockKeyboard(uint8_t shift);
+    bool IsEmptyName(const char *name, uint8_t len);
 #endif
 void UI_DrawLineBuffer(uint8_t (*buffer)[128], int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool black);
 void UI_DrawRectangleBuffer(uint8_t (*buffer)[128], int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool black);

App/ui/main.c

@@ -37,6 +37,7 @@
 #include "ui/main.h"
 #include "ui/ui.h"
 #include "audio.h"
+#include "menu.h"
 
 #ifdef ENABLE_FEAT_F4HWN
     #include "driver/system.h"
@@ -45,7 +46,7 @@
 center_line_t center_line = CENTER_LINE_NONE;
 
 #ifdef ENABLE_FEAT_F4HWN
-    static int8_t RxBlink;
+    // static int8_t RxBlink;
     static int8_t RxBlinkLed = 0;
     static int8_t RxBlinkLedCounter;
     static int8_t RxLine;
@@ -59,16 +60,6 @@ center_line_t center_line = CENTER_LINE_NONE;
     }
 #endif
 
-const int8_t dBmCorrTable[7] = {
-            -15, // band 1
-            -25, // band 2
-            -20, // band 3
-            -4, // band 4
-            -7, // band 5
-            -6, // band 6
-             -1  // band 7
-        };
-
 const char *VfoStateStr[] = {
        [VFO_STATE_NORMAL]="",
        [VFO_STATE_BUSY]="BUSY",
@@ -79,17 +70,19 @@ const char *VfoStateStr[] = {
        [VFO_STATE_VOLTAGE_HIGH]="VOLT HIGH"
 };
 
-// ***************************************************************************
+// ----------------------------------------
 
-static void DrawSmallAntennaAndBars(uint8_t *p, unsigned int level)
+static void DrawSmallPowerBars(uint8_t *p, unsigned int level)
 {
     if(level>6)
         level = 6;
 
-    memcpy(p, BITMAP_Antenna, ARRAY_SIZE(BITMAP_Antenna));
+    char bar = 0b00111110;
 
-    for(uint8_t i = 1; i <= level; i++) {
-        char bar = (0xff << (6-i)) & 0x7F;
+    for(uint8_t i = 0; i <= level; i++) {
+        if(gSetting_set_gui) {
+            bar = (0xff << (6-i)) & 0x7F;
+        }
         memset(p + 2 + i*3, bar, 2);
     }
 }
@@ -165,15 +158,17 @@ static void DrawLevelBar(uint8_t xpos, uint8_t line, uint8_t level, uint8_t bars
 #endif
 
 #ifdef ENABLE_AUDIO_BAR
-
 // Approximation of a logarithmic scale using integer arithmetic
-uint8_t log2_approx(unsigned int value) {
+static uint8_t log2_approx(unsigned int value) {
     uint8_t log = 0;
     while (value >>= 1) {
         log++;
     }
     return log;
 }
+#endif
+
+#ifdef ENABLE_AUDIO_BAR
 
 void UI_DisplayAudioBar(void)
 {
@@ -238,6 +233,135 @@ void UI_DisplayAudioBar(void)
 }
 #endif
 
+#ifdef ENABLE_FEAT_F4HWN_AUDIO_SCOPE
+
+#define SCOPE_SAMPLES        43   // number of columns (43 × 3px = 128px wide)
+#define SCOPE_NOISE_GATE     50u  // minimum range below which the display shows baseline
+#define SCOPE_FLOOR_RISE     2u   // floor rise per frame (+100 units/s at 20ms/frame)
+#define SCOPE_FLOOR_DROP_SHR 3u   // floor drop IIR shift: drop by (floor-min) >> N per frame (~160ms to halve)
+#define SCOPE_VOLUME_MIN     200u // let's assume that the sound level in silence is 200
+
+void UI_DisplayAudioScope(void)
+{
+    static uint16_t g_scope_buf[SCOPE_SAMPLES];
+    static uint8_t  g_scope_write      = 0;
+    static uint16_t g_scope_floor      = SCOPE_VOLUME_MIN;     // persistent floor: snaps down fast, rises slowly
+    static uint8_t  g_scope_ready      = 0;                    // number of valid samples since TX entry
+
+    // REG_64 (VoiceAmplitudeOut) is only meaningful in TX (mic input).
+    // FM RX audio is frequency-encoded — no register gives the instantaneous waveform.
+
+// ------------------------------ Sample audio amplitude ------------------------------
+
+    static bool s_was_tx = false;
+
+    if (gCurrentFunction != FUNCTION_TRANSMIT) {
+        s_was_tx = false;
+        return;
+    }
+
+    // This prevents a sudden spike on the bar caused by release the PTT button
+    if (!GPIO_IsPttPressed()
+#ifdef ENABLE_VOX
+    && !gEeprom.VOX_SWITCH
+#endif
+#ifdef ENABLE_FEAT_F4HWN
+    && !gSetting_set_ptt_session
+#endif
+    )
+    return;
+
+    if (!s_was_tx) {
+        // TX entry: full reset so every new transmission starts from a clean state
+        for (uint8_t i = 0; i < SCOPE_SAMPLES; i++) g_scope_buf[i] = SCOPE_VOLUME_MIN;
+        g_scope_write      = 0u;
+        g_scope_floor      = SCOPE_VOLUME_MIN;
+        s_was_tx           = true;
+    }
+
+    // The first 7 bars after turning on the radio
+    // will not display any values: they cause high bars.
+    if (g_scope_ready >= 7)
+        g_scope_buf[g_scope_write] = BK4819_GetVoiceAmplitudeOut();
+    else
+        g_scope_ready++;
+        
+    // If the reading is 0, it is definitely an incorrect value
+    // caused by the microphone being muted - set it to 200.
+    if (g_scope_buf[g_scope_write] == 0) 
+        g_scope_buf[g_scope_write] =  SCOPE_VOLUME_MIN;
+
+    g_scope_write = (g_scope_write + 1u) % SCOPE_SAMPLES;
+
+// --------------------------------- Refresh display ---------------------------------
+
+    if (gLowBattery && !gLowBatteryConfirmed)
+        return;
+
+    if (gScreenToDisplay != DISPLAY_MAIN
+#ifdef ENABLE_DTMF_CALLING
+        || gDTMF_CallState != DTMF_CALL_STATE_NONE
+#endif
+        )
+        return;
+
+#if defined(ENABLE_ALARM) || defined(ENABLE_TX1750)
+    if (gAlarmState != ALARM_STATE_OFF)
+        return;
+#endif
+
+#ifdef ENABLE_FEAT_F4HWN
+    RxBlinkLed = 0;
+    RxBlinkLedCounter = 0;
+    BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, false);
+    const unsigned int line = isMainOnly() ? 5 : 3;
+#else
+    const unsigned int line = 3;
+#endif
+
+    uint8_t *p_line = gFrameBuffer[line];
+    memset(p_line, 0, LCD_WIDTH);
+
+    // Find min and max across current buffer
+    uint16_t min_val = g_scope_buf[0];
+    uint16_t max_val = g_scope_buf[0];
+    for (uint8_t i = 1u; i < SCOPE_SAMPLES; i++) {
+        if (g_scope_buf[i] < min_val) min_val = g_scope_buf[i];
+        if (g_scope_buf[i] > max_val) max_val = g_scope_buf[i];
+    }
+
+    // Floor tracks buffer minimum with asymmetric IIR:
+    // - drops toward min smoothly (SCOPE_FLOOR_DROP_SHR), avoiding instant-snap ghost
+    // - rises slowly (SCOPE_FLOOR_RISE/frame) to handle loud constant voice
+    if (g_scope_floor > min_val)
+        g_scope_floor -= ((g_scope_floor - min_val) >> SCOPE_FLOOR_DROP_SHR) + 1u;
+    else
+        g_scope_floor += SCOPE_FLOOR_RISE;
+
+    const uint16_t range = (max_val > g_scope_floor) ? (max_val - g_scope_floor) : 0u;
+
+    for (uint8_t i = 0u; i < SCOPE_SAMPLES; i++) {
+        const uint8_t  idx    = (g_scope_write + i) % SCOPE_SAMPLES;
+        uint8_t        height = 0u;
+        if (range >= SCOPE_NOISE_GATE) {
+            const uint16_t v = (g_scope_buf[idx] > g_scope_floor) ? (g_scope_buf[idx] - g_scope_floor) : 0u;
+            height = (uint8_t)((uint32_t)v * 7u / range);
+        }
+        // Filled column using bits 6..0 only (bit 7 always off to avoid overlap with text below)
+        // At silence (height 0): single pixel at bit 6 (baseline)
+        const uint8_t mask = (height > 0u) ? (uint8_t)((0x7Fu << (7u - height)) & 0x7Fu) : 0x40u;
+        // 2px column + 1px gap per sample
+
+        uint8_t *p_col = &p_line[i * 3u];
+        p_col[0] = mask;
+        p_col[1] = mask;
+
+    }
+
+    ST7565_BlitLine(line);
+}
+#endif  // ENABLE_FEAT_F4HWN_AUDIO_SCOPE
+
 void DisplayRSSIBar(const bool now)
 {
 #if defined(ENABLE_RSSI_BAR)
@@ -274,16 +398,19 @@ void DisplayRSSIBar(const bool now)
 
     if(RxLine >= 0 && center_line != CENTER_LINE_IN_USE)
     {
-        if (RxBlink == 0 || RxBlink == 1) {
-            UI_PrintStringSmallBold("RX", 8, 0, RxLine);
-            if (RxBlink == 1) RxBlink = 2;
+        static bool clean = false;
+        uint8_t *p_line0 = gFrameBuffer[RxLine + 0];
+
+        clean = !clean;
+
+        if(clean) {
+            for(uint8_t i = 0; i < sizeof(BITMAP_VFO_Default); i++)
+                p_line0[i] = (p_line0[i] & 0x80) | BITMAP_VFO_Default[i];
         } else {
-            for (uint8_t i = 8; i < 24; i++)
-            {
-                gFrameBuffer[RxLine][i] = 0x00;
-            }
-            RxBlink = 1;
+            for(uint8_t i = 0; i < sizeof(BITMAP_VFO_Empty); i++)
+                p_line0[i] = (p_line0[i] & 0x80) | BITMAP_VFO_Empty[i];
         }
+
         ST7565_BlitLine(RxLine);
     }
 #else
@@ -326,22 +453,34 @@ void DisplayRSSIBar(const bool now)
 #endif
         + dBmCorrTable[gRxVfo->Band];
 
-    rssi_dBm = -rssi_dBm;
-
-    if(rssi_dBm > 141) rssi_dBm = 141;
-    if(rssi_dBm < 53) rssi_dBm = 53;
-
-    uint8_t s_level = 0;
-    uint8_t overS9dBm = 0;
+    // IARU VHF/UHF S-meter: S9 = -93 dBm, 1 S-unit = 6 dB
+    // S(n) threshold = -93 + (n - 9) * 6
+    uint8_t s_level    = 0;
+    uint8_t overS9dBm  = 0;
     uint8_t overS9Bars = 0;
 
-    if(rssi_dBm >= 93) {
-        s_level = map(rssi_dBm, 141, 93, 1, 9);
-    }
-    else {
+    // if      (rssi_dBm >= -93)  s_level = 9;  // S9  = -93 dBm
+    // else if (rssi_dBm >= -99)  s_level = 8;  // S8  = -99 dBm
+    // else if (rssi_dBm >= -105) s_level = 7;  // S7  = -105 dBm
+    // else if (rssi_dBm >= -111) s_level = 6;  // S6  = -111 dBm
+    // else if (rssi_dBm >= -117) s_level = 5;  // S5  = -117 dBm
+    // else if (rssi_dBm >= -123) s_level = 4;  // S4  = -123 dBm
+    // else if (rssi_dBm >= -129) s_level = 3;  // S3  = -129 dBm
+    // else if (rssi_dBm >= -135) s_level = 2;  // S2  = -135 dBm
+    // else if (rssi_dBm >= -141) s_level = 1;  // S1  = -141 dBm
+    // else                       s_level = 0;  // S0 (below -141 dBm)
+
+    if (rssi_dBm >= -93)
         s_level = 9;
-        overS9dBm = map(rssi_dBm, 93, 53, 0, 40);
-        overS9Bars = map(overS9dBm, 0, 40, 0, 4);
+    else if (rssi_dBm < -141)
+        s_level = 0;
+    else 
+        s_level = (rssi_dBm + 147) / 6;
+
+    if (s_level == 9) {
+        // Compute over-S9 dB directly
+        overS9dBm  = (uint8_t)MIN(rssi_dBm - (-93), 40);
+        overS9Bars = overS9dBm / 10;
     }
 #else
     const int16_t s0_dBm   = -gEeprom.S0_LEVEL;                  // S0 .. base level
@@ -361,12 +500,12 @@ void DisplayRSSIBar(const bool now)
 #ifdef ENABLE_FEAT_F4HWN
     if (gSetting_set_gui)
     {
-        sprintf(str, "%3d", -rssi_dBm);
+        sprintf(str, "%3d", rssi_dBm);
         UI_PrintStringSmallNormal(str, LCD_WIDTH + 8, 0, line - 1);
     }
     else
     {
-        sprintf(str, "% 4d %s", -rssi_dBm, "dBm");
+        sprintf(str, "% 4d %s", rssi_dBm, "dBm");
         if(isMainOnly())
             GUI_DisplaySmallest(str, 2, 41, false, true);
         else
@@ -414,7 +553,7 @@ void DisplayRSSIBar(const bool now)
     uint8_t *pLine = (gEeprom.RX_VFO == 0)? gFrameBuffer[2] : gFrameBuffer[6];
     if (now)
         memset(pLine, 0, 23);
-    DrawSmallAntennaAndBars(pLine, Level);
+    DrawSmallPowerBars(pLine, Level);
     if (now)
         ST7565_BlitFullScreen();
 #endif
@@ -523,7 +662,7 @@ void UI_MAIN_TimeSlice500ms(void)
     }
 }
 
-// ***************************************************************************
+// ----------------------------------------
 
 void UI_DisplayMain(void)
 {
@@ -549,32 +688,7 @@ void UI_DisplayMain(void)
         return;
     }
 #else
-    if (gEeprom.KEY_LOCK && gKeypadLocked > 0)
-    {   // tell user how to unlock the keyboard
-        uint8_t shift = 3;
-
-        /*
-        BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, true);
-        SYSTEM_DelayMs(50);
-        BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, false);
-        SYSTEM_DelayMs(50);
-        */
-
-        if(isMainOnly())
-        {
-            shift = 5;
-        }
-        //memcpy(gFrameBuffer[shift] + 2, gFontKeyLock, sizeof(gFontKeyLock));
-        UI_PrintStringSmallBold("UNLOCK KEYBOARD", 12, 0, shift);
-        //memcpy(gFrameBuffer[shift] + 120, gFontKeyLock, sizeof(gFontKeyLock));
-
-        /*
-        for (uint8_t i = 12; i < 116; i++)
-        {
-            gFrameBuffer[shift][i] ^= 0xFF;
-        }
-        */
-    }
+    UI_DisplayUnlockKeyboard(isMainOnly() ? 5 : 3);
 #endif
 
     unsigned int activeTxVFO = gRxVfoIsActive ? gEeprom.RX_VFO : gEeprom.TX_VFO;
@@ -736,12 +850,12 @@ 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)
+        if(TX_freq_check(frequency) != 0 && gEeprom.VfoInfo[vfo_num].TX_LOCK == true && !FUNCTION_IsRx())
         {
             if(isMainOnly())
-                memcpy(p_line0 + 14, BITMAP_VFO_Lock, sizeof(BITMAP_VFO_Lock));
+                memcpy(p_line0 + 25, BITMAP_VFO_Lock, sizeof(BITMAP_VFO_Lock));
             else
-                memcpy(p_line0 + 24, BITMAP_VFO_Lock, sizeof(BITMAP_VFO_Lock));
+                memcpy(p_line0 + 25, BITMAP_VFO_Lock, sizeof(BITMAP_VFO_Lock));
         }
 
         if (gCurrentFunction == FUNCTION_TRANSMIT)
@@ -756,7 +870,9 @@ void UI_DisplayMain(void)
                 if (activeTxVFO == vfo_num)
                 {   // show the TX symbol
                     mode = VFO_MODE_TX;
-                    UI_PrintStringSmallBold("TX", 8, 0, line);
+                    //UI_PrintStringSmallBold("TX", 8, 0, line);
+                    GUI_DisplaySmallest("TX", 10, line == 0 ? 1 : 33, false, true);
+
                 }
             }
         }
@@ -764,31 +880,59 @@ void UI_DisplayMain(void)
         {   // receiving .. show the RX symbol
             mode = VFO_MODE_RX;
             //if (FUNCTION_IsRx() && gEeprom.RX_VFO == vfo_num) {
-            if (FUNCTION_IsRx() && gEeprom.RX_VFO == vfo_num && VfoState[vfo_num] == VFO_STATE_NORMAL) {
+            if (FUNCTION_IsRx()) {
+                if (gEeprom.RX_VFO == vfo_num && VfoState[vfo_num] == VFO_STATE_NORMAL) {
 #ifdef ENABLE_FEAT_F4HWN
-                RxBlinkLed = 1;
-                RxBlinkLedCounter = 0;
-                RxLine = line;
-                RxOnVfofrequency = frequency;
-                if(!isMainVFO)
-                {
-                    RxBlink = 1;
-                }
-                else
-                {
-                    RxBlink = 0;
-                }
+                    RxBlinkLed = 1;
+                    RxBlinkLedCounter = 0;
+                    RxLine = line;
+                    RxOnVfofrequency = frequency;
+                    // if(!isMainVFO)
+                    // {
+                    //     RxBlink = 1;
+                    // }
+                    // else
+                    // {
+                    //     RxBlink = 0;
+                    // }
+
+                    // if (RxBlink == 0 || RxBlink == 1) {
+                        if(gRxVfo->Modulation == MODULATION_AM) {
+                            #ifdef ENABLE_FEAT_F4HWN_AUDIO
+                                strcpy(String, gSubMenu_SET_AUD_AM[gSetting_set_audio_am]);
+                            #else
+                                strcpy(String, "AIR");
+                            #endif
+                        }
+                        else if (gRxVfo->Modulation == MODULATION_USB) {
+                            strcpy(String, "USB");
+                        }
+                        else {
+                            #ifdef ENABLE_FEAT_F4HWN_AUDIO
+                                strcpy(String, gSubMenu_SET_AUD_FM[gSetting_set_audio_fm]);
+                            #else
+                                strcpy(String, "RX");
+                            #endif
+                        }
+
+                        GUI_DisplaySmallest(String, 10, RxLine == 0 ? 1 : 33, false, true);
+                        //UI_PrintStringSmallBold("RX", 8, 0, RxLine);
+                    // }
 #else
-                UI_PrintStringSmallBold("RX", 8, 0, line);
+                    UI_PrintStringSmallBold("RX", 8, 0, line);
 #endif
-            }
+                }
 #ifdef ENABLE_FEAT_F4HWN
-            else
-            {
-                if(RxOnVfofrequency == frequency && !isMainOnly())
-                {
-                    UI_PrintStringSmallNormal(">>", 8, 0, line);
+                else {
+                    if(RxBlinkLed == 1)
+                        RxBlinkLed = 2;
+                }
+            }
+            else {
+                if(RxOnVfofrequency == frequency && !isMainOnly()) {
+                    //UI_PrintStringSmallNormal(">>", 8, 0, line);
                     //memcpy(p_line0 + 14, BITMAP_VFO_Default, sizeof(BITMAP_VFO_Default));
+                    GUI_DisplaySmallest(">>", 8, RxLine == 0 ? 1 : 33, false, true);
                 }
 
                 if(RxBlinkLed == 1)
@@ -799,21 +943,60 @@ void UI_DisplayMain(void)
 
         if (IS_MR_CHANNEL(gEeprom.ScreenChannel[vfo_num]))
         {   // channel mode
-            const unsigned int x = 2;
+            const unsigned int x = 1;
             const bool inputting = gInputBoxIndex != 0 && gEeprom.TX_VFO == vfo_num;
-            if (!inputting)
-                sprintf(String, "M%u", gEeprom.ScreenChannel[vfo_num] + 1);
+            if (!inputting || gScanStateDir != SCAN_OFF)
+                sprintf(String, "%04u", gEeprom.ScreenChannel[vfo_num] + 1);
             else
-                sprintf(String, "M%.3s", INPUTBOX_GetAscii());  // show the input text
-            UI_PrintStringSmallNormal(String, x, 0, line + 1);
+                sprintf(String, "%.4s", INPUTBOX_GetAscii());  // show the input text
+
+            //if (gSetting_set_gui) {
+                UI_PrintStringSmallNormalInverse(String, x, 0, line + 1);
+            /*
+            }
+            else
+            {
+                GUI_DisplaySmallest(String, x + 1, line == 0 ? 9 : 41, false, true);
+                gFrameBuffer[line + 1][0] ^= 0x1C;
+                gFrameBuffer[line + 1][1] ^= 0x3E;
+                for (uint8_t i = 2; i < 21; i++) {
+                    gFrameBuffer[line + 1][i] ^= 0x7F;
+                }
+                gFrameBuffer[line + 1][21] ^= 0x3E;
+                gFrameBuffer[line + 1][22] ^= 0x1C;
+
+            }
+            */
         }
         else if (IS_FREQ_CHANNEL(gEeprom.ScreenChannel[vfo_num]))
         {   // frequency mode
             // show the frequency band number
             const unsigned int x = 2;
-            char * buf = gEeprom.VfoInfo[vfo_num].pRX->Frequency < _1GHz_in_KHz ? "" : "+";
-            sprintf(String, "F%u%s", 1 + gEeprom.ScreenChannel[vfo_num] - FREQ_CHANNEL_FIRST, buf);
-            UI_PrintStringSmallNormal(String, x, 0, line + 1);
+            const uint8_t f = 1 + gEeprom.ScreenChannel[vfo_num] - FREQ_CHANNEL_FIRST;
+            const bool over1GHz = gEeprom.VfoInfo[vfo_num].pRX->Frequency >= _1GHz_in_KHz;
+
+            sprintf(String, over1GHz ? "F%u+" : "F%u", f);
+            //if (gSetting_set_gui) {
+                UI_PrintStringSmallNormalInverse(String, x, 0, line + 1);
+            /*
+            }
+            else
+            {
+                GUI_DisplaySmallest(String, x + 2, line == 0 ? 9 : 41, false, true);
+                uint8_t g = 13;
+                if(over1GHz)
+                    g = 17;
+
+                gFrameBuffer[line + 1][0] ^= 0x1C;
+                gFrameBuffer[line + 1][1] ^= 0x3E;
+                for (uint8_t i = 2; i < g; i++) {
+                    gFrameBuffer[line + 1][i] ^= 0x7F;
+                }
+                gFrameBuffer[line + 1][g] ^= 0x3E;
+                gFrameBuffer[line + 1][g + 1] ^= 0x1C;
+
+            }
+            */
         }
 #ifdef ENABLE_NOAA
         else
@@ -830,7 +1013,7 @@ void UI_DisplayMain(void)
         }
 #endif
 
-        // ************
+        // ----------------------------------------
 
         enum VfoState_t state = VfoState[vfo_num];
 
@@ -843,7 +1026,7 @@ void UI_DisplayMain(void)
         if (state != VFO_STATE_NORMAL)
         {
             if (state < ARRAY_SIZE(VfoStateStr))
-                UI_PrintString(VfoStateStr[state], 31, 0, line, 8);
+                UI_PrintString(VfoStateStr[state], 35, 0, line, 8);
         }
         else if (gInputBoxIndex > 0 && IS_FREQ_CHANNEL(gEeprom.ScreenChannel[vfo_num]) && gEeprom.TX_VFO == vfo_num)
         {   // user entering a frequency
@@ -881,43 +1064,74 @@ void UI_DisplayMain(void)
                 #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
                     if(gEeprom.MENU_LOCK == false) {
                 #endif
-                uint8_t countList = 0;
-                uint8_t shiftList = 0;
 
-                if(gMR_ChannelExclude[gEeprom.ScreenChannel[vfo_num]] == false)
+                const ChannelAttributes_t* att = MR_GetChannelAttributes(gEeprom.ScreenChannel[vfo_num]);
+
+
+                if(att->exclude == false)
                 {
                     // show the scan list assigment symbols
-                    const ChannelAttributes_t att = gMR_ChannelAttributes[gEeprom.ScreenChannel[vfo_num]];
+                    const ChannelAttributes_t* att = MR_GetChannelAttributes(gEeprom.ScreenChannel[vfo_num]);
 
-                    countList = att.scanlist1 + att.scanlist2 + att.scanlist3;
-
-                    if(countList == 0)
-                    {
-                        memcpy(p_line0 + 127 - (1 * 6), BITMAP_ScanList0, sizeof(BITMAP_ScanList0));
+                    uint8_t countList = att->scanlist;
+                    if(countList > MR_CHANNELS_LIST + 1) {
+                        countList = 0;
                     }
-                    else
-                    {
-                        shiftList = countList;
 
-                        if (att.scanlist1)
-                        {
-                            memcpy(p_line0 + 127 - (shiftList * 6), BITMAP_ScanList1, sizeof(BITMAP_ScanList1));
-                            shiftList--;
-                        }
-                        if (att.scanlist2)
-                        {
-                            memcpy(p_line0 + 127 - (shiftList * 6), BITMAP_ScanList2, sizeof(BITMAP_ScanList2));
-                            shiftList--;
-                        }
-                        if (att.scanlist3)
-                        {
-                            memcpy(p_line0 + 127 - (shiftList * 6), BITMAP_ScanList3, sizeof(BITMAP_ScanList3));
+                    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
+                        const char *name = gListName[countList - 1];
+                        
+                        // If name is empty/invalid, display number
+                        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
                 {
-                    memcpy(p_line0 + 127 - (1 * 6), BITMAP_ScanListE, sizeof(BITMAP_ScanListE));
+                    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;
                 }
 
                 #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
@@ -928,7 +1142,7 @@ void UI_DisplayMain(void)
 
                 // compander symbol
 #ifndef ENABLE_BIG_FREQ
-                if (att.compander)
+                if (att->compander)
                     memcpy(p_line0 + 120 + LCD_WIDTH, BITMAP_compand, sizeof(BITMAP_compand));
 #else
                 // TODO:  // find somewhere else to put the symbol
@@ -956,8 +1170,8 @@ void UI_DisplayMain(void)
                         break;
 
                     case MDF_CHANNEL:   // show the channel number
-                        sprintf(String, "CH-%03u", gEeprom.ScreenChannel[vfo_num] + 1);
-                        UI_PrintString(String, 32, 0, line, 8);
+                        sprintf(String, "CH-%04u", gEeprom.ScreenChannel[vfo_num] + 1);
+                        UI_PrintString(String, 36, 0, line, 8);
                         break;
 
                     case MDF_NAME:      // show the channel name
@@ -966,17 +1180,19 @@ void UI_DisplayMain(void)
                         SETTINGS_FetchChannelName(String, gEeprom.ScreenChannel[vfo_num]);
                         if (String[0] == 0)
                         {   // no channel name, show the channel number instead
-                            sprintf(String, "CH-%03u", gEeprom.ScreenChannel[vfo_num] + 1);
+                            sprintf(String, "CH-%04u", gEeprom.ScreenChannel[vfo_num] + 1);
                         }
 
                         if (gEeprom.CHANNEL_DISPLAY_MODE == MDF_NAME) {
-                            UI_PrintString(String, 32, 0, line, 8);
+                            String[10] = 0;
+                            UI_PrintString(String, 33, 0, line, 8);
                         }
                         else {
 #ifdef ENABLE_FEAT_F4HWN
                             if (isMainOnly())
                             {
-                                UI_PrintString(String, 32, 0, line, 8);
+                                String[10] = 0;
+                                UI_PrintString(String, 33, 0, line, 8);
                             }
                             else
                             {
@@ -1043,8 +1259,8 @@ void UI_DisplayMain(void)
                 }
 
                 // show the channel symbols
-                const ChannelAttributes_t att = gMR_ChannelAttributes[gEeprom.ScreenChannel[vfo_num]];
-                if (att.compander)
+                const ChannelAttributes_t* att = MR_GetChannelAttributes(gEeprom.ScreenChannel[vfo_num]);
+                if (att->compander)
 #ifdef ENABLE_BIG_FREQ
                     memcpy(p_line0 + 120, BITMAP_compand, sizeof(BITMAP_compand));
 #else
@@ -1053,7 +1269,7 @@ void UI_DisplayMain(void)
             }
         }
 
-        // ************
+        // ----------------------------------------
 
         {   // show the TX/RX level
             int8_t Level = -1;
@@ -1080,9 +1296,15 @@ void UI_DisplayMain(void)
                     Level = 2;
                 }
                 */
-                Level = gRxVfo->OUTPUT_POWER - 1;
+
+                uint8_t currentPower = gRxVfo->OUTPUT_POWER;
+
+                if(currentPower == OUTPUT_POWER_USER)
+                    Level = gSetting_set_pwr;
+                else
+                    Level = currentPower - 1;
             }
-            else
+            else 
             if (mode == VFO_MODE_RX)
             {   // RX signal level
                 #ifndef ENABLE_RSSI_BAR
@@ -1092,10 +1314,10 @@ void UI_DisplayMain(void)
                 #endif
             }
             if(Level >= 0)
-                DrawSmallAntennaAndBars(p_line1 + LCD_WIDTH, Level);
+                DrawSmallPowerBars(p_line1 + LCD_WIDTH, Level);
         }
 
-        // ************
+        // ----------------------------------------
 
         String[0] = '\0';
         const VFO_Info_t *vfoInfo = &gEeprom.VfoInfo[vfo_num];
@@ -1139,11 +1361,8 @@ void UI_DisplayMain(void)
             break;
 
             case 2:
-            sprintf(String, "%03oN", DCS_Options[pConfig->Code]);
-            break;
-
             case 3:
-            sprintf(String, "%03oI", DCS_Options[pConfig->Code]);
+            sprintf(String, (int)pConfig->CodeType == 2 ? "%03oN" : "%03oI", DCS_Options[pConfig->Code]);
             break;
 
             default:
@@ -1391,6 +1610,14 @@ void UI_DisplayMain(void)
 
         const bool rx = FUNCTION_IsRx();
 
+#ifdef ENABLE_FEAT_F4HWN_AUDIO_SCOPE
+        if (gSetting_mic_bar && gCurrentFunction == FUNCTION_TRANSMIT) {
+            // Reserve the line so no other element overwrites it.
+            // Actual drawing is handled exclusively by the app.c timeslice.
+            center_line = CENTER_LINE_AUDIO_SCOPE;
+        }
+        else
+#endif
 #ifdef ENABLE_AUDIO_BAR
         if (gSetting_mic_bar && gCurrentFunction == FUNCTION_TRANSMIT) {
             center_line = CENTER_LINE_AUDIO_BAR;
@@ -1426,7 +1653,7 @@ void UI_DisplayMain(void)
         if (rx || gCurrentFunction == FUNCTION_FOREGROUND || gCurrentFunction == FUNCTION_POWER_SAVE)
         {
             #if 1
-                if (gSetting_live_DTMF_decoder && gDTMF_RX_live[0] != 0)
+                if (gSetting_live_DTMF_decoder && gDTMF_RX_live[0] != 0 && gKeypadLocked == 0)
                 {   // show live DTMF decode
                     const unsigned int len = strlen(gDTMF_RX_live);
                     const unsigned int idx = (len > (17 - 5)) ? len - (17 - 5) : 0;  // limit to last 'n' chars
@@ -1501,11 +1728,21 @@ void UI_DisplayMain(void)
     if (isMainOnly() && !gDTMF_InputMode)
     {
         sprintf(String, "VFO %s", activeTxVFO ? "B" : "A");
+        GUI_DisplaySmallest(String, 107, 50, false, true);
+
+        gFrameBuffer[6][105] ^= 0x7C;
+        for (uint8_t x = 106; x < 127; x++) {
+            gFrameBuffer[6][x] ^= 0xFE;
+        }
+        gFrameBuffer[6][127] ^= 0x7C;
+
+        /*
         UI_PrintStringSmallBold(String, 92, 0, 6);
         for (uint8_t i = 92; i < 128; i++)
         {
             gFrameBuffer[6][i] ^= 0x7F;
         }
+        */
     }
     //#ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
     //}
@@ -1514,5 +1751,3 @@ void UI_DisplayMain(void)
 
     ST7565_BlitFullScreen();
 }
-
-// ***************************************************************************

App/ui/main.h

@@ -17,10 +17,13 @@
 #ifndef UI_MAIN_H
 #define UI_MAIN_H
 
+#include <stdint.h>
+
 enum center_line_t {
     CENTER_LINE_NONE = 0,
     CENTER_LINE_IN_USE,
     CENTER_LINE_AUDIO_BAR,
+    CENTER_LINE_AUDIO_SCOPE,
     CENTER_LINE_RSSI,
     CENTER_LINE_AM_FIX_DATA,
     CENTER_LINE_DTMF_DEC,
@@ -36,9 +39,13 @@ enum Vfo_txtr_mode{
 typedef enum center_line_t center_line_t;
 
 extern center_line_t center_line;
-extern const int8_t dBmCorrTable[7];
 
+#ifdef ENABLE_AUDIO_BAR
 void UI_DisplayAudioBar(void);
+#endif
+#ifdef ENABLE_FEAT_F4HWN_AUDIO_SCOPE
+void UI_DisplayAudioScope(void);
+#endif
 void UI_MAIN_TimeSlice500ms(void);
 void UI_DisplayMain(void);
 

App/ui/menu.c

@@ -63,17 +63,15 @@ const t_menu_item MenuList[] =
 #ifdef ENABLE_FEAT_F4HWN
     {"TXLock",      MENU_TX_LOCK       }, 
 #endif
-    {"ScAdd1",      MENU_S_ADD1        },
-    {"ScAdd2",      MENU_S_ADD2        },
-    {"ScAdd3",      MENU_S_ADD3        },
+    {"ChList",      MENU_LIST_CH       },
     {"ChSave",      MENU_MEM_CH        }, // was "MEM-CH"
     {"ChDele",      MENU_DEL_CH        }, // was "DEL-CH"
     {"ChName",      MENU_MEM_NAME      },
 
-    {"SList",       MENU_S_LIST        },
-    {"SList1",      MENU_SLIST1        },
-    {"SList2",      MENU_SLIST2        },
-    {"SList3",      MENU_SLIST3        },
+    {"ScList",       MENU_S_LIST       },
+    {"ScPri",        MENU_S_PRI        },
+    {"PriCh1",       MENU_S_PRI_CH_1   },
+    {"PriCh2",       MENU_S_PRI_CH_2   },
     {"ScnRev",      MENU_SC_REV        },
 #ifndef ENABLE_FEAT_F4HWN
     #ifdef ENABLE_NOAA
@@ -149,6 +147,9 @@ const t_menu_item MenuList[] =
     {"SetLck",      MENU_SET_LCK       },
     {"SetMet",      MENU_SET_MET       },
     {"SetGUI",      MENU_SET_GUI       },
+#ifdef ENABLE_FEAT_F4HWN_AUDIO    
+    {"SetRxA",      MENU_SET_AUD       },
+#endif
     {"SetTmr",      MENU_SET_TMR       },
 #ifdef ENABLE_FEAT_F4HWN_SLEEP
     {"SetOff",       MENU_SET_OFF      },
@@ -183,6 +184,7 @@ const t_menu_item MenuList[] =
 #endif
     {"BatCal",      MENU_BATCAL        }, // battery voltage calibration
     {"BatTyp",      MENU_BATTYP        }, // battery type 1600/2200mAh
+    {"SetNav",      MENU_SET_NAV       }, // set navigation (LEFT / RIGHT or UP / DOWN)
     {"Reset",       MENU_RESET         }, // might be better to move this to the hidden menu items ?
 
     {"",                              0xff               }  // end of list - DO NOT delete or move this this
@@ -349,6 +351,12 @@ const char gSubMenu_BATTYP[][12] =
     "2500mAh K1"
 };
 
+const char gSubMenu_SET_NAV[][17] =
+{
+    "LEFT\nRIGHT\nUV-K1",
+    "UP\nDOWN\nUV-K5(8)",
+};
+
 #ifndef ENABLE_FEAT_F4HWN
 const char gSubMenu_SCRAMBLER[][7] =
 {
@@ -404,6 +412,24 @@ const char gSubMenu_SCRAMBLER[][7] =
         "CLASSIC"
     };
 
+    #ifdef ENABLE_FEAT_F4HWN_AUDIO
+        const char gSubMenu_SET_AUD_FM[][6] =
+        {
+            "FLAT",
+            "CLEAN",
+            "MID",
+            "BOOST",
+            "MAX"
+        };
+
+        const char gSubMenu_SET_AUD_AM[][6] =
+        {
+            "SHARP",
+            "STOCK",
+            "OPEN"
+        };
+    #endif
+
     #ifdef ENABLE_FEAT_F4HWN_NARROWER
         const char gSubMenu_SET_NFM[][9] =
         {
@@ -461,9 +487,10 @@ const t_sidefunction gSubMenu_SIDEFUNCTIONS[] =
     {"MAIN ONLY",       ACTION_OPT_MAINONLY},
     {"PTT",             ACTION_OPT_PTT},
     {"WIDE\nNARROW",    ACTION_OPT_WN},
-    //#if !defined(ENABLE_SPECTRUM) || !defined(ENABLE_FMRADIO)
     {"MUTE",            ACTION_OPT_MUTE},
-    //#endif
+    #ifdef ENABLE_FEAT_F4HWN_AUDIO
+        {"RxA",            ACTION_OPT_RXA},
+    #endif
     #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
         {"POWER\nHIGH",    ACTION_OPT_POWER_HIGH},
         {"REMOVE\nOFFSET",  ACTION_OPT_REMOVE_OFFSET},
@@ -626,7 +653,11 @@ void UI_DisplayMenu(void)
         case MENU_MIC:
             {   // display the mic gain in actual dB rather than just an index number
                 const uint8_t mic = gMicGain_dB2[gSubMenuSelection];
-                sprintf(String, "+%u.%01udB", mic / 2, mic % 2);
+                sprintf(String, "+%u.%udB", mic / 2, (mic % 2) * 5);
+
+                gaugeLine = 4;
+                gaugeMin = 0;
+                gaugeMax = 8;
             }
             break;
 
@@ -683,15 +714,14 @@ void UI_DisplayMenu(void)
             if (!gIsInSubMenu || gInputBoxIndex == 0)
             {
                 sprintf(String, "%3d.%05u", gSubMenuSelection / 100000, abs(gSubMenuSelection) % 100000);
-                UI_PrintString(String, menu_item_x1, menu_item_x2, 1, 8);
             }
             else
             {
                 const char * ascii = INPUTBOX_GetAscii();
                 sprintf(String, "%.3s.%.3s  ",ascii, ascii + 3);
-                UI_PrintString(String, menu_item_x1, menu_item_x2, 1, 8);
             }
 
+            UI_PrintString(String, menu_item_x1, menu_item_x2, 1, 8);
             UI_PrintString("MHz",  menu_item_x1, menu_item_x2, 3, 8);
 
             already_printed = true;
@@ -787,9 +817,6 @@ void UI_DisplayMenu(void)
         #endif
         case MENU_BCL:
         case MENU_BEEP:
-        case MENU_S_ADD1:
-        case MENU_S_ADD2:
-        case MENU_S_ADD3:
         case MENU_STE:
         case MENU_D_ST:
 #ifdef ENABLE_DTMF_CALLING
@@ -810,6 +837,7 @@ void UI_DisplayMenu(void)
 #endif
 #ifdef ENABLE_FEAT_F4HWN
         case MENU_SET_TMR:
+        case MENU_S_PRI:
 #endif
             strcpy(String, gSubMenu_OFF_ON[gSubMenuSelection]);
             break;
@@ -817,23 +845,34 @@ void UI_DisplayMenu(void)
         case MENU_MEM_CH:
         case MENU_1_CALL:
         case MENU_DEL_CH:
+        case MENU_S_PRI_CH_1:
+        case MENU_S_PRI_CH_2:
         {
-            const bool valid = RADIO_CheckValidChannel(gSubMenuSelection, false, 0);
-
-            UI_GenerateChannelStringEx(String, valid, gSubMenuSelection);
-            UI_PrintString(String, menu_item_x1, menu_item_x2, 0, 8);
-
-            if (valid && !gAskForConfirmation)
-            {   // 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);
+            if(gSubMenuSelection == MR_CHANNELS_MAX)
+            {
+                UI_PrintString("None", menu_item_x1, menu_item_x2, 2, 8);
+                already_printed = true;
+                break;
             }
+            else
+            {
+                const bool valid = RADIO_CheckValidChannel(gSubMenuSelection, false, 0);
 
-            SETTINGS_FetchChannelName(String, gSubMenuSelection);
-            UI_PrintString(String[0] ? String : "--", menu_item_x1, menu_item_x2, 2, 8);
-            already_printed = true;
-            break;
+                UI_GenerateChannelStringEx(String, valid, gSubMenuSelection);
+                UI_PrintString(String, menu_item_x1, menu_item_x2, 0, 8);
+
+                if (valid && !gAskForConfirmation)
+                {   // 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);
+                }
+
+                SETTINGS_FetchChannelName(String, gSubMenuSelection);
+                UI_PrintString(String[0] ? String : "--", menu_item_x1, menu_item_x2, 2, 8);
+                already_printed = true;
+                break;
+            }
         }
 
         case MENU_MEM_NAME:
@@ -935,17 +974,23 @@ void UI_DisplayMenu(void)
             sprintf(String, gSubMenuSelection == 0 ? gSubMenu_OFF_ON[0] : "%u*100ms", gSubMenuSelection);
             break;
 
+        case MENU_LIST_CH:
         case MENU_S_LIST:
-            if (gSubMenuSelection == 0)
-                strcpy(String, "LIST [0]\nNO LIST");
-            else if (gSubMenuSelection < 4)
-                sprintf(String, "LIST [%u]", gSubMenuSelection);
-            else if (gSubMenuSelection == 4)
-                strcpy(String, "LISTS\n[1, 2, 3]");
-            else if (gSubMenuSelection == 5)
+            if (gSubMenuSelection == MR_CHANNELS_LIST + 1)
                 strcpy(String, "ALL");
+            else if (gSubMenuSelection == 0 && UI_MENU_GetCurrentMenuId() == MENU_LIST_CH)
+                strcpy(String, "OFF");
+            else {
+                const char *name = gListName[gSubMenuSelection - 1];
+                
+                // If first character is empty/invalid, display "N/A"
+                if (IsEmptyName(name, sizeof(gListName[0])))
+                    sprintf(String, "%02u", gSubMenuSelection);
+                else
+                    sprintf(String, "%02u (%.3s)", gSubMenuSelection, name);
+            }
             break;
-
+            
         #ifdef ENABLE_ALARM
             case MENU_AL_MOD:
                 sprintf(String, gSubMenu_AL_MOD[gSubMenuSelection]);
@@ -1058,6 +1103,10 @@ void UI_DisplayMenu(void)
             strcpy(String, gSubMenu_BATTYP[gSubMenuSelection]);
             break;
 
+        case MENU_SET_NAV:
+            strcpy(String, gSubMenu_SET_NAV[gSubMenuSelection]);
+            break;
+
         case MENU_F1SHRT:
         case MENU_F1LONG:
         case MENU_F2SHRT:
@@ -1138,6 +1187,23 @@ void UI_DisplayMenu(void)
             strcpy(String, gSubMenu_SET_MET[gSubMenuSelection]); // Same as SET_MET
             break;
 
+        #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);
+                }
+                else if (gTxVfo->Modulation == MODULATION_USB) {
+                    strcpy(String, "USB");
+                    UI_PrintStringSmallNormal("USB", 108, 0, 0);
+                }
+                else {
+                    strcpy(String, gSubMenu_SET_AUD_FM[gSubMenuSelection]);
+                    UI_PrintStringSmallNormal("FM", 114, 0, 0);
+                }
+                break;
+        #endif
+
         #ifdef ENABLE_FEAT_F4HWN_NARROWER
             case MENU_SET_NFM:
                 strcpy(String, gSubMenu_SET_NFM[gSubMenuSelection]);
@@ -1160,7 +1226,7 @@ void UI_DisplayMenu(void)
                     gaugeMax = 63;
                     //#endif
                 }
-                gEeprom.VOLUME_GAIN = gSubMenuSelection;
+                // 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
@@ -1260,55 +1326,9 @@ void UI_DisplayMenu(void)
         }
     }
 
-    if (UI_MENU_GetCurrentMenuId() == MENU_SLIST1 || UI_MENU_GetCurrentMenuId() == MENU_SLIST2 || UI_MENU_GetCurrentMenuId() == MENU_SLIST3)
+    if (UI_MENU_GetCurrentMenuId() == MENU_S_PRI_CH_1 || UI_MENU_GetCurrentMenuId() == MENU_S_PRI_CH_2)
     {
-        i = UI_MENU_GetCurrentMenuId() - MENU_SLIST1;
 
-        char *pPrintStr = String;
-
-        if (gSubMenuSelection < 0) {
-            pPrintStr = "NULL";
-        } else {
-            UI_GenerateChannelStringEx(String, true, gSubMenuSelection);
-            pPrintStr = String;
-        }
-
-        // channel number
-        UI_PrintString(pPrintStr, menu_item_x1, menu_item_x2, 0, 8);
-
-        SETTINGS_FetchChannelName(String, gSubMenuSelection);
-        pPrintStr = String[0] ? String : "--";
-
-        // channel name and scan-list
-        if (gSubMenuSelection < 0 || !gEeprom.SCAN_LIST_ENABLED[i]) {
-            UI_PrintString(pPrintStr, menu_item_x1, menu_item_x2, 2, 8);
-        } else {
-            /*
-            UI_PrintStringSmallNormal(pPrintStr, menu_item_x1, menu_item_x2, 2);
-
-            if (IS_MR_CHANNEL(gEeprom.SCANLIST_PRIORITY_CH1[i])) {
-                sprintf(String, "PRI%d:%u", 1, gEeprom.SCANLIST_PRIORITY_CH1[i] + 1);
-                UI_PrintString(String, menu_item_x1, menu_item_x2, 3, 8);
-            }
-
-            if (IS_MR_CHANNEL(gEeprom.SCANLIST_PRIORITY_CH2[i])) {
-                sprintf(String, "PRI%d:%u", 2, gEeprom.SCANLIST_PRIORITY_CH2[i] + 1);
-                UI_PrintString(String, menu_item_x1, menu_item_x2, 5, 8);
-            }
-            */
-
-            UI_PrintStringSmallNormal(pPrintStr, menu_item_x1, menu_item_x2, 2);
-
-            for (uint8_t pri = 1; pri <= 2; pri++) {
-                uint8_t channel = (pri == 1) ? gEeprom.SCANLIST_PRIORITY_CH1[i] : gEeprom.SCANLIST_PRIORITY_CH2[i];
-
-                if (IS_MR_CHANNEL(channel)) {
-                    sprintf(String, "PRI%d:%u", pri, channel + 1);
-                    UI_PrintString(String, menu_item_x1, menu_item_x2, pri * 2 + 1, 8);
-                }
-            }
-
-        }
     }
 
     if ((UI_MENU_GetCurrentMenuId() == MENU_R_CTCS || UI_MENU_GetCurrentMenuId() == MENU_R_DCS) && gCssBackgroundScan)
@@ -1331,8 +1351,8 @@ void UI_DisplayMenu(void)
         || UI_MENU_GetCurrentMenuId() == MENU_D_LIST
 #endif
     ) {
-        sprintf(String, "%2d", gSubMenuSelection);
-        UI_PrintStringSmallNormal(String, 105, 0, 0);
+        sprintf(String, "%03d", gSubMenuSelection);
+        UI_PrintStringSmallNormal(String, 107, 0, 0);
     }
 
     if ((UI_MENU_GetCurrentMenuId() == MENU_RESET    ||
@@ -1345,4 +1365,4 @@ void UI_DisplayMenu(void)
     }
 
     ST7565_BlitFullScreen();
-}
+}

App/ui/menu.h

@@ -65,9 +65,7 @@ enum
 #endif
     MENU_SC_REV,
     MENU_AUTOLK,
-    MENU_S_ADD1,
-    MENU_S_ADD2,
-    MENU_S_ADD3,
+    MENU_LIST_CH,
     MENU_STE,
     MENU_RP_STE,
     MENU_MIC,
@@ -75,9 +73,9 @@ enum
     MENU_COMPAND,
     MENU_1_CALL,
     MENU_S_LIST,
-    MENU_SLIST1,
-    MENU_SLIST2,
-    MENU_SLIST3,
+    MENU_S_PRI,
+    MENU_S_PRI_CH_1,
+    MENU_S_PRI_CH_2,    
 #ifdef ENABLE_ALARM
     MENU_AL_MOD,
 #endif
@@ -151,6 +149,10 @@ enum
     #ifdef ENABLE_NOAA
         MENU_NOAA_S,
     #endif
+    MENU_SET_NAV,
+    #ifdef ENABLE_FEAT_F4HWN_AUDIO
+        MENU_SET_AUD,
+    #endif
 #endif
     MENU_BATCAL,  // battery voltage calibration
     MENU_F1SHRT,
@@ -195,6 +197,10 @@ extern const char        gSubMenu_D_RSP[4][11];
     #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
         extern const char gSubMenu_SET_KEY[][9];
     #endif
+    #ifdef ENABLE_FEAT_F4HWN_AUDIO
+        extern const char    gSubMenu_SET_AUD_FM[5][6];
+        extern const char    gSubMenu_SET_AUD_AM[3][6];
+    #endif
 #endif
 
 extern const char* const gSubMenu_PTT_ID[5];

App/ui/status.c

@@ -94,26 +94,37 @@ void UI_DisplayStatus()
     { // SCAN indicator
         if (gScanStateDir != SCAN_OFF || SCANNER_IsScanning()) {
             if (IS_MR_CHANNEL(gNextMrChannel) && !SCANNER_IsScanning()) { // channel mode
-                switch(gEeprom.SCAN_LIST_DEFAULT) {
-                    case 0:
-                        memcpy(line + 0, BITMAP_ScanList0, sizeof(BITMAP_ScanList0));
-                        break;
-                    case 1: 
-                        memcpy(line + 0, BITMAP_ScanList1, sizeof(BITMAP_ScanList1));
-                        break;
-                    case 2:
-                        memcpy(line + 0, BITMAP_ScanList2, sizeof(BITMAP_ScanList2));
-                        break;
-                    case 3:
-                        memcpy(line + 0, BITMAP_ScanList3, sizeof(BITMAP_ScanList3));
-                        break;
-                    case 4:
-                        memcpy(line + 0, BITMAP_ScanList123, sizeof(BITMAP_ScanList123));
-                        break;
-                    case 5:
-                        memcpy(line + 0, BITMAP_ScanListAll, sizeof(BITMAP_ScanListAll));
-                        break;
+
+                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;
                 }
+                else
+                {
+                    const char *name = gListName[gEeprom.SCAN_LIST_DEFAULT - 1];
+
+                    // 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;
+                    }
+                }
+
+                GUI_DisplaySmallest(str, 2, 1, true, true);
+
+                gStatusLine[0] ^= 0x3E;
+                for (uint8_t x = 1; x < end; x++)
+                {
+                    gStatusLine[x] ^= 0x7F;
+                }
+                gStatusLine[end] ^= 0x3E;
             }
             else {  // frequency mode
                 memcpy(line + x + 1, gFontS, sizeof(gFontS));
@@ -155,30 +166,32 @@ void UI_DisplayStatus()
             else
         #endif
             {
-                #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-                if(gEeprom.MENU_LOCK == true) {
-                    memcpy(line + x + 2, gFontRO, sizeof(gFontRO));
-                }
-                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));
+                if(!gAirCopyBootMode) {
+                    #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
+                    if(gEeprom.MENU_LOCK == true) {
+                        memcpy(line + x + 2, gFontRO, sizeof(gFontRO));
                     }
                     else
                     {
-                        memcpy(line + x + 2, gFontMO, sizeof(gFontMO));
+                    #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
                     }
-                #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
+                    #endif
                 }
-                #endif
             }
         }
         x += sizeof(gFontDWR) + 3;
@@ -195,14 +208,16 @@ void UI_DisplayStatus()
 
 #ifdef ENABLE_FEAT_F4HWN
     // PTT indicator
-    if (gSetting_set_ptt_session) {
-        memcpy(line + x, gFontPttOnePush, sizeof(gFontPttOnePush));
-        x1 = x + sizeof(gFontPttOnePush) + 1;
-    }
-    else
-    {
-        memcpy(line + x, gFontPttClassic, sizeof(gFontPttClassic));
-        x1 = x + sizeof(gFontPttClassic) + 1;       
+    if(!gAirCopyBootMode) {
+        if (gSetting_set_ptt_session) {
+            memcpy(line + x, gFontPttOnePush, sizeof(gFontPttOnePush));
+            x1 = x + sizeof(gFontPttOnePush) + 1;
+        }
+        else
+        {
+            memcpy(line + x, gFontPttClassic, sizeof(gFontPttClassic));
+            x1 = x + sizeof(gFontPttClassic) + 1;       
+        }
     }
     x += sizeof(gFontPttClassic) + 3;
 #endif
@@ -218,15 +233,8 @@ void UI_DisplayStatus()
         size = sizeof(gFontKeyLock);
     }
     else if (gWasFKeyPressed) {
-        #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-        if (!gEeprom.MENU_LOCK) {
-            src = gFontF;
-            size = sizeof(gFontF);
-        }
-        #else
         src = gFontF;
         size = sizeof(gFontF);
-        #endif
     }
     #ifdef ENABLE_FEAT_F4HWN
         else if (gMute) {

App/ui/ui.c

@@ -94,9 +94,8 @@ void GUI_SelectNextDisplay(GUI_DisplayType_t Display)
         gAskForConfirmation  = 0;
         gAskToSave           = false;
         gAskToDelete         = false;
-        gWasFKeyPressed      = false;
 
-        gUpdateStatus        = true;
+        HideFKeyIcon();
     }
 
     gScreenToDisplay = Display;

App/ui/welcome.c

@@ -15,6 +15,7 @@
  */
 
 #include <string.h>
+#include <stdint.h>
 
 #include "driver/py25q16.h"
 #include "driver/st7565.h"
@@ -32,6 +33,63 @@
     #include "screenshot.h"
 #endif
 
+#ifdef ENABLE_FEAT_F4HWN_MEM
+// Linker symbols (provided by the linker script)
+extern uint8_t _sdata;          // Start of .data in RAM
+extern uint8_t _edata;          // End of .data in RAM
+extern uint8_t _sbss;           // Start of .bss in RAM
+extern uint8_t _ebss;           // End of .bss in RAM
+
+// _eflash_used must be defined in the linker script immediately after the last
+// section with a FLASH load address (after .noncacheable). Example:
+//
+//   .noncacheable : {
+//       ...
+//   } > RAM AT> FLASH
+//   _eflash_used = LOADADDR(.noncacheable) + SIZEOF(.noncacheable);
+//
+// This gives the exact byte count that the linker reports as FLASH used.
+extern uint8_t _eflash_used;
+
+// Absolute symbols: their *address* IS the numeric size value (ARM/CMSIS convention).
+// RAM = .data + gap + .bss + heap_reserve + stack_reserve
+extern uint8_t _Min_Heap_Size;
+extern uint8_t _Min_Stack_Size;
+
+// Region sizes (must match your linker MEMORY regions)
+#define RAM_SIZE_BYTES     (16u * 1024u)
+#define FLASH_SIZE_BYTES   (118u * 1024u)
+
+// Base address of FLASH — must match ORIGIN(FLASH) in your linker script
+#define FLASH_BASE         (0x08002800u)
+
+static inline uint32_t span(const void* a, const void* b)
+{
+    return (uint32_t)((uintptr_t)b - (uintptr_t)a);
+}
+
+static void build_usage(uint32_t* ram_used, uint32_t* flash_used)
+{
+    // RAM: span from start of .data to end of .bss covers .data + alignment gap + .bss.
+    // Then add heap and stack reservations (absolute linker symbols: address = size).
+    // Proof: (0x20002A60 - 0x20000000) + 0x200 + 0x400 = 10848 + 512 + 1024 = 12384 B ✓
+    const uint32_t heap_size  = (uint32_t)(uintptr_t)&_Min_Heap_Size;
+    const uint32_t stack_size = (uint32_t)(uintptr_t)&_Min_Stack_Size;
+    *ram_used = span(&_sdata, &_ebss) + heap_size + stack_size;
+
+    // FLASH: _eflash_used is placed by the linker script right after the last
+    // section copied to FLASH (.data LMA + .noncacheable LMA).
+    // Note: _etext is NOT usable here because this linker script places .rodata
+    // sections AFTER _etext, making it an unreliable end-of-flash marker.
+    *flash_used = span((void*)FLASH_BASE, &_eflash_used);
+}
+
+static inline uint16_t pct_x100(uint32_t used, uint32_t total)
+{
+    return (uint16_t)((used * 10000u) / total); // 7559 => 75.59%
+}
+#endif
+
 void UI_DisplayReleaseKeys(void)
 {
     memset(gStatusLine,  0, sizeof(gStatusLine));
@@ -52,7 +110,7 @@ void UI_DisplayWelcome(void)
     char WelcomeString0[16];
     char WelcomeString1[16];
     char WelcomeString2[16];
-    char WelcomeString3[20];
+    char WelcomeString3[32];
 
     memset(gStatusLine,  0, sizeof(gStatusLine));
 
@@ -76,9 +134,9 @@ void UI_DisplayWelcome(void)
         memset(WelcomeString1, 0, sizeof(WelcomeString1));
 
         // 0x0EB0
-        PY25Q16_ReadBuffer(0x007020, WelcomeString0, 16);
+        PY25Q16_ReadBuffer(0x00A0C8, WelcomeString0, 16);
         // 0x0EC0
-        PY25Q16_ReadBuffer(0x007030, WelcomeString1, 16);
+        PY25Q16_ReadBuffer(0x00A0D8, WelcomeString1, 16);
 
         sprintf(WelcomeString2, "%u.%02uV %u%%",
                 gBatteryVoltageAverage / 100,
@@ -125,79 +183,37 @@ void UI_DisplayWelcome(void)
 #ifdef ENABLE_FEAT_F4HWN
         UI_PrintStringSmallNormal(Version, 0, 128, 4);
 
-        UI_DrawLineBuffer(gFrameBuffer, 0, 31, 127, 31, 1); // Be ware, status zone = 8 lines, the rest = 56 ->total 64
-
-        for (uint8_t i = 18; i < 110; i++)
+        UI_DrawLineBuffer(gFrameBuffer, 0, 35, 18, 35, 1);
+        gFrameBuffer[4][19] ^= 0x7F;
+        for (uint8_t x = 20; x < 108; x++)
         {
-            gFrameBuffer[4][i] ^= 0xFF;
+            gFrameBuffer[4][x] ^= 0xFF;
+            gFrameBuffer[3][x] ^= 0x80;
         }
+        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;
+            build_usage(&ram_used, &flash_used);
+
+            const uint16_t ram_pct   = pct_x100(ram_used,   RAM_SIZE_BYTES);
+            const uint16_t flash_pct = pct_x100(flash_used, FLASH_SIZE_BYTES);
+
+            // No floats: 7559 => 75.59%
+            sprintf(WelcomeString3,
+            "FLASH %u.%02u %% - SRAM  %u.%02u %%",
+            (unsigned)(flash_pct / 100), (unsigned)(flash_pct % 100),
+            (unsigned)(ram_pct / 100),   (unsigned)(ram_pct % 100));
+
+            GUI_DisplaySmallest(WelcomeString3, 5, 1, true, true);
+            ST7565_BlitStatusLine();
+        #endif
 
         sprintf(WelcomeString3, "%s Edition", Edition);
         UI_PrintStringSmallNormal(WelcomeString3, 0, 127, 6);
 
-        /*
-        #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-            #if ENABLE_FEAT_F4HWN_RESCUE_OPS > 1
-                UI_PrintStringSmallNormal(Edition, 18, 0, 6);
-                if(gEeprom.MENU_LOCK == true) {
-                    memcpy(gFrameBuffer[6] + 103, BITMAP_Ready, sizeof(BITMAP_Ready));
-                }
-                else
-                {
-                    memcpy(gFrameBuffer[6] + 103, BITMAP_NotReady, sizeof(BITMAP_NotReady));                    
-                }
-            #else
-                UI_PrintStringSmallNormal(Edition, 18, 0, 5);
-                memcpy(gFrameBuffer[5] + 103, BITMAP_Ready, sizeof(BITMAP_Ready));
-                
-                #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-                    UI_PrintStringSmallNormal("RescueOps", 18, 0, 6);
-                    if(gEeprom.MENU_LOCK == true) {
-                        memcpy(gFrameBuffer[6] + 103, BITMAP_Ready, sizeof(BITMAP_Ready));
-                    }
-                    else
-                    {
-                        memcpy(gFrameBuffer[6] + 103, BITMAP_NotReady, sizeof(BITMAP_NotReady));
-                    }
-                #endif
-            #endif
-        #else
-            UI_PrintStringSmallNormal(Edition, 18, 0, 6);
-            memcpy(gFrameBuffer[6] + 103, BITMAP_Ready, sizeof(BITMAP_Ready));                    
-        #endif
-        */
-
-        /*
-        #ifdef ENABLE_SPECTRUM
-            #ifdef ENABLE_FMRADIO
-                    UI_PrintStringSmallNormal(Based, 0, 127, 5);
-                    UI_PrintStringSmallNormal(Credits, 0, 127, 6);
-            #else
-                    UI_PrintStringSmallNormal("Bandscope  ", 0, 127, 5);
-                    memcpy(gFrameBuffer[5] + 95, BITMAP_Ready, sizeof(BITMAP_Ready));
-
-                    #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-                        UI_PrintStringSmallNormal("RescueOps  ", 0, 127, 6);
-                        if(gEeprom.MENU_LOCK == true) {
-                            memcpy(gFrameBuffer[6] + 95, BITMAP_Ready, sizeof(BITMAP_Ready));
-                        }
-                    #else
-                        UI_PrintStringSmallNormal("Broadcast  ", 0, 127, 6);
-                    #endif
-            #endif
-        #else
-            #ifdef ENABLE_FEAT_F4HWN_RESCUE_OPS
-                UI_PrintStringSmallNormal("RescueOps  ", 0, 127, 5);
-                if(gEeprom.MENU_LOCK == true) {
-                    memcpy(gFrameBuffer[5] + 95, BITMAP_Ready, sizeof(BITMAP_Ready));
-                }
-            #else
-                UI_PrintStringSmallNormal("Bandscope  ", 0, 127, 5);
-            #endif
-            UI_PrintStringSmallNormal("Broadcast  ", 0, 127, 6);
-            memcpy(gFrameBuffer[6] + 95, BITMAP_Ready, sizeof(BITMAP_Ready));
-        #endif
-        */
 #else
         UI_PrintStringSmallNormal(Version, 0, 127, 6);
 #endif
@@ -206,7 +222,7 @@ void UI_DisplayWelcome(void)
         ST7565_BlitFullScreen();
 
         #ifdef ENABLE_FEAT_F4HWN_SCREENSHOT
-            getScreenShot(true);
+            SCREENSHOT_Update(true);
         #endif
     }
-}
+}

App/usb/usbd_cdc_if.c

@@ -190,8 +190,13 @@ void cdc_acm_data_send_with_dtr(const uint8_t *buf, uint32_t size)
     {
         ep_tx_busy_flag = true;
         usbd_ep_start_write(CDC_IN_EP, buf, size);
-        while (ep_tx_busy_flag)
+        uint32_t timeout = 100000;
+        while (ep_tx_busy_flag && --timeout)
             ;
+        if (!timeout) {
+            ep_tx_busy_flag = false;
+            dtr_enable = 0;  // Consider USB disconnected
+        }
     }
 }
 

CMakeLists.txt

@@ -70,6 +70,10 @@ target_link_libraries(${EXE_NAME} Core App)
 target_compile_definitions(${EXE_NAME} PRIVATE $<$<CONFIG:Debug>:DEBUG>)
 target_link_libraries(${EXE_NAME} ${TOOLCHAIN_LINK_LIBRARIES})
 
+if(ENABLE_LTO)
+    target_compile_options(${EXE_NAME} PRIVATE -flto=auto)
+endif()
+
 # Generate map file
 target_link_options(${EXE_NAME} PRIVATE "-Wl,-Map=${EXE_NAME}.map")
 

CMakePresets.json

@@ -9,6 +9,7 @@
             "toolchainFile": "${sourceDir}/cmake/gcc-arm-none-eabi.cmake",
             "cacheVariables": {
                 "CMAKE_BUILD_TYPE": "Release",
+                "ENABLE_LTO": false,
                 "ENABLE_FMRADIO": false,
                 "ENABLE_UART": true,
                 "ENABLE_USB": true,
@@ -34,7 +35,6 @@
                 "ENABLE_SHOW_CHARGE_LEVEL": false,
                 "ENABLE_REVERSE_BAT_SYMBOL": false,
                 "ENABLE_NO_CODE_SCAN_TIMEOUT": true,
-                "ENABLE_AM_FIX": false,
                 "ENABLE_SQUELCH_MORE_SENSITIVE": true,
                 "ENABLE_FASTER_CHANNEL_SCAN": true,
                 "ENABLE_RSSI_BAR": true,
@@ -59,18 +59,19 @@
                 "ENABLE_FEAT_F4HWN_CTR": true,
                 "ENABLE_FEAT_F4HWN_RESCUE_OPS": false,
                 "ENABLE_FEAT_F4HWN_VOL": false,
-                "ENABLE_FEAT_F4HWN_RESET_CHANNEL": false,
+                "ENABLE_FEAT_F4HWN_AUDIO": false,
+                "ENABLE_FEAT_F4HWN_AUDIO_SCOPE": false,
+                "ENABLE_FEAT_F4HWN_RESET_VFO": true,
                 "ENABLE_FEAT_F4HWN_PMR": false,
                 "ENABLE_FEAT_F4HWN_GMRS_FRS_MURS": false,
                 "ENABLE_FEAT_F4HWN_CA": true,
                 "ENABLE_FEAT_F4HWN_DEBUG": false,
-                "ENABLE_AM_FIX_SHOW_DATA": false,
+                "ENABLE_FEAT_F4HWN_MEM": false,
                 "ENABLE_AGC_SHOW_DATA": false,
                 "ENABLE_UART_RW_BK_REGS": false,
-                "ENABLE_NAVIG_LEFT_RIGHT": true,
                 "ENABLE_SWD": false,
                 "VERSION_STRING_1": "v0.22",
-                "VERSION_STRING_2": "v4.3.1"
+                "VERSION_STRING_2": "v5.3.1"
             }
         },
         {
@@ -187,6 +188,9 @@
                 "ENABLE_FEAT_F4HWN_PMR": true,
                 "ENABLE_FEAT_F4HWN_GMRS_FRS_MURS": true,
                 "ENABLE_FEAT_F4HWN_RESCUE_OPS": true,
+                "ENABLE_FEAT_F4HWN_VOL": true,
+                "ENABLE_FEAT_F4HWN_AUDIO": true,
+                "ENABLE_FEAT_F4HWN_AUDIO_SCOPE": true,
                 "ENABLE_SWD": true,
                 "EDITION_STRING": "Fusion",
                 "TARGET": "f4hwn.fusion"

Core/py32f071xb.ld

@@ -145,6 +145,15 @@ SECTIONS
     _edata = .;        /* define a global symbol at data end */
   } >RAM AT> FLASH
 
+  /* Explicit placement of .noncacheable (CherryUSB) + end-of-FLASH symbol */
+  .noncacheable :
+  {
+    . = ALIGN(4);
+    *(.noncacheable)
+    *(.noncacheable*)
+    . = ALIGN(4);
+  } >RAM AT> FLASH
+  _eflash_used = LOADADDR(.noncacheable) + SIZEOF(.noncacheable);
   
   /* Uninitialized data section */
   . = ALIGN(4);

Dockerfile

@@ -3,7 +3,8 @@ FROM mcr.microsoft.com/devcontainers/python:3.10-bookworm
 # ---------------------------------------------
 # Base build tools
 # ---------------------------------------------
-RUN apt-get update && apt-get install -y --no-install-recommends \
+RUN rm -f /etc/apt/sources.list.d/yarn.list && \
+    apt-get update && apt-get install -y --no-install-recommends \
     build-essential cmake ninja-build python3 curl xz-utils ca-certificates \
  && rm -rf /var/lib/apt/lists/*
 

Dockerfile-ms

@@ -3,7 +3,8 @@ FROM mcr.microsoft.com/devcontainers/python:3.10-bookworm
 # ---------------------------------------------
 # Base build tools
 # ---------------------------------------------
-RUN apt-get update && apt-get install -y --no-install-recommends \
+RUN rm -f /etc/apt/sources.list.d/yarn.list && \
+    apt-get update && apt-get install -y --no-install-recommends \
     build-essential cmake ninja-build python3 curl xz-utils ca-certificates \
  && rm -rf /var/lib/apt/lists/*
 

README.md

@@ -1,3 +1,7 @@
+# Stats
+
+![Alt](https://repobeats.axiom.co/api/embed/ecdd86aa536b716f088339a0c5ee734558f78c28.svg "Repobeats analytics image")
+
 # F4HWN firmware port for the UV-K1 and UV-K5 V3 using the PY32F071 MCU
 
 This repository is a fork of the [F4HWN custom firmware](https://github.com/armel/uv-k5-firmware-custom), who was a fork of [Egzumer custom firmware](https://github.com/egzumer/uv-k5-firmware-custom). It extends the work done for the UV-K5 V1, based on the DP32G030 MCU, and adapts it to the newer UV-K1 and UV-K5 V3 built around the PY32F071 MCU. It is the result of the joint work of [@muzkr](https://github.com/muzkr) and [@armel](https://github.com/armel).
@@ -38,7 +42,7 @@ Anyway, have fun.
 
 # Donations
 
-Special thanks to Jean-Cyrille F6IWW (2 times), Fabrice 14RC123, David F4BPP, Olivier 14RC206, Frédéric F4ESO, Stéphane F5LGW, 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 (3 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, Eric KI1C (2 times), Phil G0ELM, Jérôme Lambert, Meinhard Frank Günther, Eliot Vedel, Alfonso EA7KDF, Jean-François F1EVM, Robert DC1RDB, Ian KE2CHJ, Daryl VK3AWA, Roberto Brunelli, Robert Boardman, Stephen Oliver, Nicolas F4INE and William Bruno 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 and Brian WA6JFK for their [donations](https://www.paypal.com/paypalme/F4HWN). That’s so kind of them. Thanks so much 🙏🏻
 
 ## Table of Contents
 
@@ -338,11 +342,11 @@ Click `Restore Calibration Data` and wait until the process fully completes.
 Many thanks to various people:
 
 * [Muzkr](https://github.com/muzkr)
+* [Andrej](https://github.com/Tunas1337)
 * [Egzumer](https://github.com/egzumer)
 * [OneOfEleven](https://github.com/OneOfEleven)
 * [DualTachyon](https://github.com/DualTachyon)
 * [Mikhail](https://github.com/fagci)
-* [Andrej](https://github.com/Tunas1337)
 * [Manuel](https://github.com/manujedi)
 * @wagner
 * @Lohtse Shar

compile-with-docker.sh

@@ -31,13 +31,16 @@ fi
 # ---------------------------------------------
 # Build the Docker image (only needed once)
 # ---------------------------------------------
-docker build -t "$IMAGE" .
+if [[ "$(docker images -q $IMAGE)" == "" ]]; then
+  echo "Building Docker image..."
+  docker build -t "$IMAGE" .
+fi
 
 # ---------------------------------------------
 # Clean existing CMake cache to ensure toolchain reload
 # ---------------------------------------------
 rm -rf build
-
+export MSYS_NO_PATHCONV=1
 # ---------------------------------------------
 # Function to build one preset
 # ---------------------------------------------
@@ -46,7 +49,9 @@ build_preset() {
   echo ""
   echo "=== 🚀 Building preset: ${preset} ==="
   echo "---------------------------------------------"
-  docker run --rm -it -v "$PWD":/src -w /src "$IMAGE" \
+  docker run --rm \
+    -u $(id -u):$(id -g) \
+    -it -v "$PWD":/src -w /src "$IMAGE" \
     bash -c "which arm-none-eabi-gcc && arm-none-eabi-gcc --version && \
              cmake --preset ${preset} ${EXTRA_ARGS[@]+"${EXTRA_ARGS[@]}"} && \
              cmake --build --preset ${preset} -j"