Display CTCSS tone freq in Audio, Recon, and Level apps (#1231)

* Generate CTCSS messages at fixed rate regardless of tone freq

* Generate CTCSS messages at fixed rate regardless of tone freq

* Function for generating CTCSS description strings

* Function for generating CTCSS description strings

* Increase width of CTCSS text to include tone freq

* Increase width of CTCSS text field to include frequency

* Use CTCSS tone freq when saving HAM freqs to freq file

* Use function in tone_key.cpp for displaying CTCSS string

* Use function in tone_key.cpp for CTCSS descr strings

* Use function in tone_key.cpp for CTCSS descr strings

* Clang test

* Clang

* Clang

* Support for reading CTCSS tones from FreqMan file

* Clang

* Clean up and eliminate floating point

* Clean up and eliminate floating point

* Corrected CTCSS field length

* Corrected CTCSS field length

* Clang

firmware/application/apps/analog_audio_app.cpp

@@ -404,11 +404,7 @@ void AnalogAudioView::update_modulation(ReceiverModel::Mode modulation) {
 }
 
 void AnalogAudioView::handle_coded_squelch(uint32_t value) {
-    tone_index idx = tone_key_index_by_value(value);
-    if (idx >= 0)
-        text_ctcss.set("CTCSS " + tone_key_string(idx));
-    else
-        text_ctcss.set("???");
+    text_ctcss.set(tone_key_string_by_value(value, text_ctcss.parent_rect().width() / 8));
 }
 
 } /* namespace ui */

firmware/application/apps/analog_audio_app.hpp

@@ -71,10 +71,10 @@ class NBFMOptionsView : public View {
         }};
 
     Text text_squelch{
-        {9 * 8, 0 * 16, 8 * 8, 1 * 16},
+        {7 * 8, 0 * 16, 8 * 8, 1 * 16},
         "SQ   /99"};
     NumberField field_squelch{
-        {12 * 8, 0 * 16},
+        {10 * 8, 0 * 16},
         2,
         {0, 99},
         1,
@@ -200,7 +200,7 @@ class AnalogAudioView : public View {
         {28 * 8, 0 * 16}};
 
     Text text_ctcss{
-        {19 * 8, 1 * 16, 11 * 8, 1 * 16},
+        {16 * 8, 1 * 16, 14 * 8, 1 * 16},
         ""};
 
     std::unique_ptr<Widget> options_widget{};

firmware/application/apps/ui_level.cpp

@@ -216,23 +216,10 @@ size_t LevelView::change_mode(freqman_index_t new_mod) {
 }
 
 void LevelView::handle_coded_squelch(const uint32_t value) {
-    static tone_index last_squelch_index = -1;
-
-    if (field_mode.selected_index() == NFM_MODULATION) {
-        tone_index idx = tone_key_index_by_value(value);
-
-        if ((last_squelch_index < 0) || (last_squelch_index != idx)) {
-            last_squelch_index = idx;
-            if (idx >= 0) {
-                text_ctcss.set("T: " + tone_key_string(idx));
-                return;
-            }
-        } else {
-            return;
-        }
-    }
-
-    text_ctcss.set("             ");
+    if (field_mode.selected_index() == NFM_MODULATION)
+        text_ctcss.set(tone_key_string_by_value(value, text_ctcss.parent_rect().width() / 8));
+    else
+        text_ctcss.set("        ");
 }
 
 } /* namespace ui */

firmware/application/apps/ui_level.hpp

@@ -114,7 +114,7 @@ class LevelView : public View {
         }};
 
     Text text_ctcss{
-        {22 * 8, 3 * 16 + 4, 14 * 8, 1 * 8},
+        {22 * 8, 3 * 16 + 4, 8 * 8, 1 * 8},
         ""};
 
     // RSSI: XX/XX/XXX,dt: XX

firmware/application/apps/ui_mictx.hpp

@@ -269,7 +269,7 @@ class MicTXView : public View {
 
     OptionsField options_tone_key{
         {12 * 8, (13 * 8) - 5},
-        23,
+        18,
         {}};
 
     Checkbox check_rogerbeep{

firmware/application/apps/ui_recon.cpp

@@ -1426,20 +1426,10 @@ size_t ReconView::change_mode(freqman_index_t new_mod) {
 }
 
 void ReconView::handle_coded_squelch(const uint32_t value) {
-    if (field_mode.selected_index() == NFM_MODULATION) {
-        tone_index idx = tone_key_index_by_value(value);
-
-        if ((last_squelch_index < 0) || (last_squelch_index != idx)) {
-            last_squelch_index = idx;
-            if (idx >= 0) {
-                text_ctcss.set("T: " + tone_key_string(idx));
-                return;
-            }
-        } else {
-            return;
-        }
-    }
-    text_ctcss.set("        ");
+    if (field_mode.selected_index() == NFM_MODULATION)
+        text_ctcss.set(tone_key_string_by_value(value, text_ctcss.parent_rect().width() / 8));
+    else
+        text_ctcss.set("        ");
 }
 
 } /* namespace ui */

firmware/application/apps/ui_recon.hpp

@@ -139,7 +139,6 @@ class ReconView : public View {
     int8_t last_rssi_med{-127};
     int8_t last_rssi_max{-127};
     int32_t last_index{-1};
-    tone_index last_squelch_index{-1};
     int64_t last_freq{0};
     std::string freq_file_path{};
     systime_t chrono_start{};

firmware/application/apps/ui_settings.cpp

@@ -35,6 +35,9 @@ using namespace lpc43xx;
 #include "portapack.hpp"
 using namespace portapack;
 
+#include "file.hpp"
+namespace fs = std::filesystem;
+
 #include "string_format.hpp"
 #include "ui_styles.hpp"
 #include "cpld_update.hpp"
@@ -489,35 +492,30 @@ SetPersistentMemoryView::SetPersistentMemoryView(NavigationView& nav) {
     check_use_sdcard_for_pmem.set_value(pmem::should_use_sdcard_for_pmem());
     check_use_sdcard_for_pmem.on_select = [this](Checkbox&, bool v) {
         File pmem_flag_file_handle;
-        std::string pmem_flag_file = PMEM_FILEFLAG;
         if (v) {
-            auto result = pmem_flag_file_handle.open(pmem_flag_file);
-            if (result.is_valid()) {
-                auto result = pmem_flag_file_handle.create(pmem_flag_file);  // third: create if it is not there
-                if (!result.is_valid()) {
-                    text_pmem_status.set("pmem flag file created");
-                } else {
-                    text_pmem_status.set("!err. creating pmem flagfile!");
-                }
-            } else {
+            if (fs::file_exists(PMEM_FILEFLAG)) {
                 text_pmem_status.set("pmem flag already present");
+            } else {
+                auto error = pmem_flag_file_handle.create(PMEM_FILEFLAG);
+                if (error)
+                    text_pmem_status.set("!err. creating pmem flagfile!");
+                else
+                    text_pmem_status.set("pmem flag file created");
             }
         } else {
-            auto result = delete_file(pmem_flag_file);
-            if (result.code() != FR_OK) {
+            auto result = delete_file(PMEM_FILEFLAG);
+            if (result.code() != FR_OK)
                 text_pmem_status.set("!err. deleting pmem flagfile!");
-            } else {
+            else
                 text_pmem_status.set("pmem flag file deleted");
-            }
         }
     };
 
     button_save_mem_to_file.on_select = [&nav, this](Button&) {
-        if (!pmem::save_persistent_settings_to_file()) {
+        if (!pmem::save_persistent_settings_to_file())
             text_pmem_status.set("!problem saving settings!");
-        } else {
+        else
             text_pmem_status.set("settings saved");
-        }
     };
 
     button_load_mem_from_file.on_select = [&nav, this](Button&) {

firmware/application/freqman.cpp

@@ -122,6 +122,8 @@ bool load_freqman_file(std::string& file_stem, freqman_db& db, bool load_freqs,
     freqman_index_t bandwidth = -1;
     freqman_index_t step = -1;
     freqman_index_t tone = -1;
+    uint32_t tone_freq;
+    char c;
 
     auto result = freqman_file.open("FREQMAN/" + file_stem + ".TXT");
     if (result.is_valid())
@@ -210,12 +212,26 @@ bool load_freqman_file(std::string& file_stem, freqman_db& db, bool load_freqs,
                 step = freqman_entry_get_step_from_str_short(pos);
             }
             // ctcss tone if any
-            /* disabled until better form
-               pos = strstr(line_start, "c=");
-               if (pos) {
-               pos += 2;
-               tone = tone_key_index_by_value( strtoll( pos , nullptr , 10 ) );
-               } */
+            pos = strstr(line_start, "c=");
+            if (pos) {
+                pos += 2;
+                // find decimal point and replace with 0 if there is one, for strtoll
+                length = strcspn(pos, ".,\x0A");
+                if (pos + length <= line_end) {
+                    c = *(pos + length);
+                    *(pos + length) = 0;
+                    // ASCII Hz to integer Hz x 100
+                    tone_freq = strtoll(pos, nullptr, 10) * 100;
+                    // stuff saved character back into string in case it was not a decimal point
+                    *(pos + length) = c;
+                    // now get first digit after decimal point (10ths of Hz)
+                    pos += length + 1;
+                    if (c == '.' && *pos >= '0' && *pos <= '9')
+                        tone_freq += (*pos - '0') * 10;
+                    // convert tone_freq (100x the freq in Hz) to a tone_key index
+                    tone = tone_key_index_by_value(tone_freq);
+                }
+            }
             // Read description until , or LF
             pos = strstr(line_start, "d=");
             if (pos) {
@@ -284,7 +300,7 @@ bool get_freq_string(freqman_entry& entry, std::string& item_string) {
         item_string = "r=" + to_string_dec_uint(frequency_a / 1000) + to_string_dec_uint(frequency_a % 1000UL, 3, '0');
         item_string += ",t=" + to_string_dec_uint(frequency_b / 1000) + to_string_dec_uint(frequency_b % 1000UL, 3, '0');
         if (entry.tone >= 0) {
-            item_string += ",c=" + tone_key_string(entry.tone);
+            item_string += ",c=" + tone_key_value_string(entry.tone);
         }
     }
     if (entry.modulation >= 0 && (unsigned)entry.modulation < freqman_entry_modulations.size()) {

firmware/application/tone_key.cpp

@@ -25,63 +25,68 @@
 
 namespace tonekey {
 
+// Keep list in ascending order by tone frequency
 const tone_key_t tone_keys = {
-    {"None", 0.0},
-    {"0 XZ", 67.000},
-    {"1 WZ", 69.400},
-    {"2 XA", 71.900},
-    {"3 WA", 74.400},
-    {"4 XB", 77.000},
-    {"5 WB", 79.700},
-    {"6 YZ", 82.500},
-    {"7 YA", 85.400},
-    {"8 YB", 88.500},
-    {"9 ZZ", 91.500},
-    {"10 ZA", 94.800},
-    {"11 ZB", 97.400},
-    {"12 1Z", 100.000},
-    {"13 1A", 103.500},
-    {"14 1B", 107.200},
-    {"15 2Z", 110.900},
-    {"16 2A", 114.800},
-    {"17 2B", 118.800},
-    {"18 3Z", 123.000},
-    {"19 3A", 127.300},
-    {"20 3B", 131.800},
-    {"21 4Z", 136.500},
-    {"22 4A", 141.300},
-    {"23 4B", 146.200},
-    {"24 5Z", 151.400},
-    {"25 5A", 156.700},
-    {"40 --", 159.800},
-    {"26 5B", 162.200},
-    {"41 --", 165.500},
-    {"27 6Z", 167.900},
-    {"42 --", 171.300},
-    {"28 6A", 173.800},
-    {"43 --", 177.300},
-    {"29 6B", 179.900},
-    {"44 --", 183.500},
-    {"30 7Z", 186.200},
-    {"45 --", 189.900},
-    {"31 7A", 192.800},
-    {"46 --", 196.600},
-    {"47 --", 199.500},
-    {"32 M1", 203.500},
-    {"48 8Z", 206.500},
-    {"33 M2", 210.700},
-    {"34 M3", 218.100},
-    {"35 M4", 225.700},
-    {"49 9Z", 229.100},
-    {"36 M5", 233.600},
-    {"37 M6", 241.800},
-    {"38 M7", 250.300},
-    {"50 0Z", 254.100},
-    {"Axient 28kHz", 28000.0},
-    {"Senn. 32.768k", 32768.0},
-    {"Senn. 32.000k", 32000.0},
-    {"Sony 32.382k", 32382.0},
-    {"Shure 19kHz", 19000.0}};
+    {"None", F2Ix100(0.0)},
+    {"1 XZ", F2Ix100(67.0)},
+    {"39 WZ", F2Ix100(69.3)},
+    {"2 XA", F2Ix100(71.9)},
+    {"3 WA", F2Ix100(74.4)},
+    {"4 XB", F2Ix100(77.0)},
+    {"5 WB", F2Ix100(79.7)},
+    {"6 YZ", F2Ix100(82.5)},
+    {"7 YA", F2Ix100(85.4)},
+    {"8 YB", F2Ix100(88.5)},
+    {"9 ZZ", F2Ix100(91.5)},
+    {"10 ZA", F2Ix100(94.8)},
+    {"11 ZB", F2Ix100(97.4)},
+    {"12 1Z", F2Ix100(100.0)},
+    {"13 1A", F2Ix100(103.5)},
+    {"14 1B", F2Ix100(107.2)},
+    {"15 2Z", F2Ix100(110.9)},
+    {"16 2A", F2Ix100(114.8)},
+    {"17 2B", F2Ix100(118.8)},
+    {"18 3Z", F2Ix100(123.0)},
+    {"19 3A", F2Ix100(127.3)},
+    {"20 3B", F2Ix100(131.8)},
+    {"21 4Z", F2Ix100(136.5)},
+    {"22 4A", F2Ix100(141.3)},
+    {"23 4B", F2Ix100(146.2)},
+    {"24 5Z", F2Ix100(151.4)},
+    {"25 5A", F2Ix100(156.7)},
+    {"40 --", F2Ix100(159.8)},
+    {"26 5B", F2Ix100(162.2)},
+    {"41 --", F2Ix100(165.5)},
+    {"27 6Z", F2Ix100(167.9)},
+    {"42 --", F2Ix100(171.3)},
+    {"28 6A", F2Ix100(173.8)},
+    {"43 --", F2Ix100(177.3)},
+    {"29 6B", F2Ix100(179.9)},
+    {"44 --", F2Ix100(183.5)},
+    {"30 7Z", F2Ix100(186.2)},
+    {"45 --", F2Ix100(189.9)},
+    {"31 7A", F2Ix100(192.8)},
+    {"46 --", F2Ix100(196.6)},
+    {"47 --", F2Ix100(199.5)},
+    {"32 M1", F2Ix100(203.5)},
+    {"48 8Z", F2Ix100(206.5)},
+    {"33 M2", F2Ix100(210.7)},
+    {"34 M3", F2Ix100(218.1)},
+    {"35 M4", F2Ix100(225.7)},
+    {"49 9Z", F2Ix100(229.1)},
+    {"36 M5", F2Ix100(233.6)},
+    {"37 M6", F2Ix100(241.8)},
+    {"38 M7", F2Ix100(250.3)},
+    {"50 0Z", F2Ix100(254.1)},
+    {"Shure 19kHz", F2Ix100(19000.0)},
+    {"Axient 28kHz", F2Ix100(28000.0)},
+    {"Senn. 32.000k", F2Ix100(32000.0)},
+    {"Sony 32.382k", F2Ix100(32382.0)},
+    {"Senn. 32.768k", F2Ix100(32768.0)}};
+
+std::string fx100_string(uint32_t f) {
+    return to_string_dec_uint(f / 100) + "." + to_string_dec_uint((f / 10) % 10);
+}
 
 void tone_keys_populate(OptionsField& field) {
     using option_t = std::pair<std::string, int32_t>;
@@ -90,12 +95,11 @@ void tone_keys_populate(OptionsField& field) {
     std::string tone_name;
 
     for (size_t c = 0; c < tone_keys.size(); c++) {
-        if (c && c < 51) {
-            auto f = tone_keys[c].second;
-            tone_name = "CTCSS " + tone_keys[c].first + " " + to_string_dec_uint(f) + "." + to_string_dec_uint((uint32_t)(f * 10) % 10);
-        } else {
+        auto f = tone_keys[c].second;
+        if ((c != 0) && (f < 1000 * 100))
+            tone_name = "CTCSS " + fx100_string(f) + " #" + tone_keys[c].first;
+        else
             tone_name = tone_keys[c].first;
-        }
 
         tone_key_options.emplace_back(tone_name, c);
     }
@@ -103,8 +107,8 @@ void tone_keys_populate(OptionsField& field) {
     field.set_options(tone_key_options);
 }
 
-float tone_key_frequency(const tone_index index) {
-    return tone_keys[index].second;
+float tone_key_frequency(tone_index index) {
+    return float(tone_keys[index].second) / 100.0;
 }
 
 std::string tone_key_string(tone_index index) {
@@ -113,20 +117,65 @@ std::string tone_key_string(tone_index index) {
     return tone_keys[index].first;
 }
 
-std::string tone_key_string_by_value(uint32_t value) {
-    return tone_key_string(tone_key_index_by_value(value));
+// Return string showing frequency only from specific table index
+std::string tone_key_value_string(tone_index index) {
+    if (index < 0 || (unsigned)index >= tone_keys.size())
+        return std::string("");
+    return fx100_string(tone_keys[index].second);
 }
 
+// Return variable-length string showing CTCSS tone from tone frequency
+// Value is in 0.01 Hz units
+std::string tone_key_string_by_value(uint32_t value, size_t max_length) {
+    static uint8_t tone_display_toggle{0};
+    static uint32_t last_value;
+    tone_index idx;
+    std::string freq_str;
+
+    // If >10Hz difference between consecutive samples, it's probably noise, so ignore
+    if (abs(value - last_value) > 10 * 100) {
+        last_value = value;
+        tone_display_toggle = 0;
+        return "        ";
+    }
+    last_value = value;
+
+    // Only display 1/10 Hz accuracy if <1000 Hz; max 5 characters
+    if (value < 1000 * 100)
+        freq_str = "T:" + fx100_string(value);
+    else
+        freq_str = "T:" + to_string_dec_uint(value / 100);
+
+    // Check field length is enough for character counts in the string below
+    if (max_length >= 7 + 2 + 5) {
+        idx = tone_key_index_by_value(value);
+        if (idx != -1)
+            return freq_str + " #" + tone_key_string(idx);
+    } else {
+        // Not enough space; toggle between display of tone received and tone code #
+        if (tone_display_toggle++ >= TONE_DISPLAY_TOGGLE_COUNTER) {
+            if (tone_display_toggle >= TONE_DISPLAY_TOGGLE_COUNTER * 2) tone_display_toggle = 0;
+
+            // Look for a match in the table (otherwise just display frequency)
+            idx = tone_key_index_by_value(value);
+            if (idx != -1)
+                return "T:" + tone_key_string(idx);
+        }
+    }
+    return freq_str;
+}
+
+// Search tone_key table for tone frequency value
+// Value is in 0.01 Hz units
 tone_index tone_key_index_by_value(uint32_t value) {
-    float diff;
-    float min_diff{(float)value};
-    float fvalue{(float)((min_diff + 50.0) / 100.0)};
+    uint32_t diff;
+    uint32_t min_diff{value * 2};
     tone_index min_idx{-1};
     tone_index idx;
 
     // Find nearest match
     for (idx = 0; idx < (tone_index)tone_keys.size(); idx++) {
-        diff = abs(fvalue - tone_keys[idx].second);
+        diff = abs(value - tone_keys[idx].second);
         if (diff < min_diff) {
             min_idx = idx;
             min_diff = diff;
@@ -137,7 +186,7 @@ tone_index tone_key_index_by_value(uint32_t value) {
     }
 
     // Arbitrary confidence threshold
-    if (min_diff < 40.0)
+    if (min_diff < TONE_FREQ_TOLERANCE_CENTIHZ)
         return min_idx;
     else
         return -1;

firmware/application/tone_key.hpp

@@ -30,17 +30,22 @@ using namespace ui;
 
 namespace tonekey {
 
+#define TONE_FREQ_TOLERANCE_CENTIHZ (4 * 100)
+#define TONE_DISPLAY_TOGGLE_COUNTER 3
+#define F2Ix100(x) (int32_t)(x * 100.0)
+
 typedef int32_t tone_index;
 
-using tone_key_t = std::vector<std::pair<std::string, float>>;
+using tone_key_t = std::vector<std::pair<std::string, uint32_t>>;
 
 extern const tone_key_t tone_keys;
 
 void tone_keys_populate(OptionsField& field);
-float tone_key_frequency(const tone_index index);
+float tone_key_frequency(tone_index index);
 
-std::string tone_key_string(const tone_index index);
-std::string tone_key_string_by_value(uint32_t value);
+std::string tone_key_string(tone_index index);
+std::string tone_key_value_string(tone_index index);
+std::string tone_key_string_by_value(uint32_t value, size_t max_length);
 tone_index tone_key_index_by_value(uint32_t value);
 
 }  // namespace tonekey

firmware/baseband/proc_nfm_audio.cpp

@@ -53,7 +53,9 @@ void NarrowbandFMAudio::execute(const buffer_c8_t& buffer) {
         if (ctcss_detect_enabled) {
             /* 24kHz int16_t[16]
              * -> FIR filter, <300Hz pass, >300Hz stop, gain of 1
-             * -> 12kHz int16_t[8] */
+             * -> 12kHz int16_t[8]
+             *
+             * Note we're only processing a small section of the wave each time this fn is called */
             auto audio_ctcss = ctcss_filter.execute(audio, work_audio_buffer);
 
             // s16 to f32 for hpf
@@ -72,16 +74,18 @@ void NarrowbandFMAudio::execute(const buffer_c8_t& buffer) {
                 cur_sample = audio_f[c];
                 if (cur_sample * prev_sample < 0.0) {
                     z_acc += z_timer;
-                    z_timer = 0;
+                    z_timer = 1;
                     z_count++;
                 } else
                     z_timer++;
                 prev_sample = cur_sample;
             }
 
-            if (z_count >= 30) {
+            z_filter_count++;
+            if ((z_filter_count >= Z_MIN_FILTER_COUNT) && (z_count >= Z_MIN_ZERO_CROSSINGS)) {
                 ctcss_message.value = (100 * 12000 / 2 * z_count) / z_acc;
                 shared_memory.application_queue.push(ctcss_message);
+                z_filter_count = 0;
                 z_count = 0;
                 z_acc = 0;
             }

firmware/baseband/proc_nfm_audio.hpp

@@ -36,6 +36,9 @@
 
 #include <cstdint>
 
+#define Z_MIN_FILTER_COUNT 224
+#define Z_MIN_ZERO_CROSSINGS 20
+
 class NarrowbandFMAudio : public BasebandProcessor {
    public:
     void execute(const buffer_c8_t& buffer) override;
@@ -88,7 +91,7 @@ class NarrowbandFMAudio : public BasebandProcessor {
     bool pitch_rssi_enabled{false};
 
     float cur_sample{}, prev_sample{};
-    uint32_t z_acc{0}, z_timer{0}, z_count{0};
+    uint32_t z_acc{0}, z_timer{0}, z_count{0}, z_filter_count{0};
     bool ctcss_detect_enabled{true};
     static constexpr float k = 32768.0f;
     static constexpr float ki = 1.0f / k;

firmware/common/portapack_persistent_memory.cpp

@@ -23,27 +23,21 @@
 #include "portapack_persistent_memory.hpp"
 
 #include "audio.hpp"
-#include "portapack.hpp"
-#include "hal.h"
-
-#include "utility.hpp"
-
-#include "memory_map.hpp"
-
 #include "crc.hpp"
-
-#include <algorithm>
-#include <utility>
-
-#include <string>
-#include <fstream>
 #include "file.hpp"
-
+#include "hal.h"
 #include "irq_controls.hpp"
-
+#include "memory_map.hpp"
+#include "portapack.hpp"
 #include "string_format.hpp"
 #include "ui_styles.hpp"
 #include "ui_painter.hpp"
+#include "utility.hpp"
+
+#include <algorithm>
+#include <string>
+#include <fstream>
+#include <utility>
 
 #include <ch.h>
 
@@ -71,9 +65,11 @@ using modem_baudrate_range_t = range_t<int32_t>;
 constexpr modem_baudrate_range_t modem_baudrate_range{50, 9600};
 constexpr int32_t modem_baudrate_reset_value{1200};
 
-/*using modem_bw_range_t = range_t<int32_t>;
-                  constexpr modem_bw_range_t modem_bw_range { 1000, 50000 };
-                  constexpr int32_t modem_bw_reset_value { 15000 };*/
+/*
+using modem_bw_range_t = range_t<int32_t>;
+constexpr modem_bw_range_t modem_bw_range { 1000, 50000 };
+constexpr int32_t modem_bw_reset_value { 15000 };
+*/
 
 using modem_repeat_range_t = range_t<int32_t>;
 constexpr modem_repeat_range_t modem_repeat_range{1, 99};
@@ -81,176 +77,38 @@ constexpr int32_t modem_repeat_reset_value{5};
 
 using clkout_freq_range_t = range_t<uint32_t>;
 constexpr clkout_freq_range_t clkout_freq_range{10, 60000};
-constexpr uint32_t clkout_freq_reset_value{10000};
+constexpr uint16_t clkout_freq_reset_value{10000};
 
 enum data_structure_version_enum : uint32_t {
-    VERSION_CURRENT = 0x10000003,
+    VERSION_CURRENT = 0x10000004,
 };
 
 static const uint32_t TOUCH_CALIBRATION_MAGIC = 0x074af82f;
 
+/* UI config.
+ * NB: Will be default init - override in defaults(). */
 struct ui_config_t {
-   private:
-    enum bits_t {
-        BacklightTimeoutLSB = 0,
-        BacklightTimeoutEnable = 3,
-        ClkoutFreqLSB = 4,
-        ShowGUIReturnIcon = 20,
-        LoadAppSettings = 21,
-        SaveAppSettings = 22,
-        ShowBiggerQRCode = 23,
-        DisableTouchscreen = 24,
-        HideClock = 25,
-        ClockWithDate = 26,
-        ClkOutEnabled = 27,
-        UNUSED = 28,
-        StealthMode = 29,
-        ConfigLogin = 30,
-        ConfigSplash = 31,
-    };
+    uint16_t clkout_freq;
 
-    enum bits_mask_t : uint32_t {
-        BacklightTimeoutMask = ((1 << 3) - 1) << bits_t::BacklightTimeoutLSB,
-        ClkoutFreqMask = ((1 << 16) - 1) << bits_t::ClkoutFreqLSB,
-    };
+    // NB: bitsfields have to be the same type or the compiler will
+    // split into a new byte hence uint8_t for these booleans.
+    uint8_t backlight_timeout : 3;
+    uint8_t enable_backlight_timeout : 1;
+    uint8_t show_gui_return_icon : 1;
+    uint8_t load_app_settings : 1;
+    uint8_t save_app_settings : 1;
+    uint8_t show_large_qr_code : 1;
 
-    uint32_t values;
-
-    constexpr bool bit_read(const bits_t n) const {
-        return ((values >> n) & 1) != 0;
-    }
-
-    constexpr void bit_write(const bits_t n, const bool v) {
-        if (bit_read(n) != v) {
-            values ^= 1 << n;
-        }
-    }
-
-   public:
-    backlight_config_t config_backlight_timer() {
-        const auto timeout_enum = (backlight_timeout_t)((values & bits_mask_t::BacklightTimeoutMask) >> bits_t::BacklightTimeoutLSB);
-        const bool timeout_enabled = bit_read(bits_t::BacklightTimeoutEnable);
-        return backlight_config_t(timeout_enum, timeout_enabled);
-    }
-
-    void set_config_backlight_timer(const backlight_config_t& new_value) {
-        values = (values & ~bits_mask_t::BacklightTimeoutMask) | ((new_value.timeout_enum() << bits_t::BacklightTimeoutLSB) & bits_mask_t::BacklightTimeoutMask);
-        bit_write(bits_t::BacklightTimeoutEnable, new_value.timeout_enabled());
-    }
-
-    constexpr uint32_t clkout_freq() {
-        uint32_t freq = (values & bits_mask_t::ClkoutFreqMask) >> bits_t::ClkoutFreqLSB;
-        if (freq < clkout_freq_range.minimum || freq > clkout_freq_range.maximum) {
-            values = (values & ~bits_mask_t::ClkoutFreqMask) | (clkout_freq_reset_value << bits_t::ClkoutFreqLSB);
-            return clkout_freq_reset_value;
-        } else {
-            return freq;
-        }
-    }
-
-    constexpr void set_clkout_freq(uint32_t freq) {
-        values = (values & ~bits_mask_t::ClkoutFreqMask) | (clkout_freq_range.clip(freq) << bits_t::ClkoutFreqLSB);
-    }
-
-    // ui_config is an uint32_t var storing information bitwise
-    // bits 0-2 store the backlight timer
-    // bits 4-19 (16 bits) store the clkout frequency
-    // bits 21-31 store the different single bit configs depicted below
-    // bit 20 store the display state of the gui return icon, hidden (0) or shown (1)
-
-    constexpr bool show_gui_return_icon() const {  // add return icon in touchscreen menue
-        return bit_read(bits_t::ShowGUIReturnIcon);
-    }
-
-    constexpr void set_gui_return_icon(bool v) {
-        bit_write(bits_t::ShowGUIReturnIcon, v);
-    }
-
-    constexpr bool load_app_settings() const {  // load (last saved) app settings on startup of app
-        return bit_read(bits_t::LoadAppSettings);
-    }
-
-    constexpr void set_load_app_settings(bool v) {
-        bit_write(bits_t::LoadAppSettings, v);
-    }
-
-    constexpr bool save_app_settings() const {  // save app settings when closing app
-        return bit_read(bits_t::SaveAppSettings);
-    }
-
-    constexpr void set_save_app_settings(bool v) {
-        bit_write(bits_t::SaveAppSettings, v);
-    }
-
-    constexpr bool show_bigger_qr_code() const {  // show bigger QR code
-        return bit_read(bits_t::ShowBiggerQRCode);
-    }
-
-    constexpr void set_show_bigger_qr_code(bool v) {
-        bit_write(bits_t::ShowBiggerQRCode, v);
-    }
-
-    constexpr bool disable_touchscreen() const {  // Option to disable touch screen
-        return bit_read(bits_t::DisableTouchscreen);
-    }
-
-    constexpr void set_disable_touchscreen(bool v) {
-        bit_write(bits_t::DisableTouchscreen, v);
-    }
-
-    constexpr bool hide_clock() const {  // clock hidden from main menu
-        return bit_read(bits_t::HideClock);
-    }
-
-    constexpr void set_clock_hidden(bool v) {
-        bit_write(bits_t::HideClock, v);
-    }
-
-    constexpr bool clock_with_date() const {  // show clock with date, if not hidden
-        return bit_read(bits_t::ClockWithDate);
-    }
-
-    constexpr void set_clock_with_date(bool v) {
-        bit_write(bits_t::ClockWithDate, v);
-    }
-
-    constexpr bool clkout_enabled() const {
-        return bit_read(bits_t::ClkOutEnabled);
-    }
-
-    constexpr void set_clkout_enabled(bool v) {
-        bit_write(bits_t::ClkOutEnabled, v);
-    }
-
-    constexpr bool stealth_mode() const {
-        return bit_read(bits_t::StealthMode);
-    }
-
-    constexpr void set_stealth_mode(bool v) {
-        bit_write(bits_t::StealthMode, v);
-    }
-
-    constexpr bool config_login() const {
-        return bit_read(bits_t::ConfigLogin);
-    }
-
-    constexpr void set_config_login(bool v) {
-        bit_write(bits_t::ConfigLogin, v);
-    }
-
-    constexpr bool config_splash() const {
-        return bit_read(bits_t::ConfigSplash);
-    }
-
-    constexpr void set_config_splash(bool v) {
-        bit_write(bits_t::ConfigSplash, v);
-    }
-
-    constexpr ui_config_t()
-        : values(
-              (1 << ConfigSplash) | (clkout_freq_reset_value << ClkoutFreqLSB) | (7 << BacklightTimeoutLSB)) {
-    }
+    bool disable_touchscreen : 1;
+    bool hide_clock : 1;
+    bool clock_show_date : 1;
+    bool clkout_enabled : 1;
+    bool UNUSED_1 : 1;
+    bool stealth_mode : 1;
+    bool config_login : 1;
+    bool config_splash : 1;
 };
+static_assert(sizeof(ui_config_t) == sizeof(uint32_t));
 
 /* Additional UI config.
  * NB: Will be default init - override in defaults(). */
@@ -266,67 +124,48 @@ struct ui_config2_t {
     bool hide_sd_card : 1;
 
     bool hide_mute : 1;
-    bool UNUSED : 7;
+    bool UNUSED_1 : 1;
+    bool UNUSED_2 : 1;
+    bool UNUSED_3 : 1;
+    bool UNUSED_4 : 1;
+    bool UNUSED_5 : 1;
+    bool UNUSED_6 : 1;
+    bool UNUSED_7 : 1;
 
-    uint8_t placeholder_1;
-    uint8_t placeholder_2;
+    uint8_t PLACEHOLDER_2;
+    uint8_t PLACEHOLDER_3;
 };
 static_assert(sizeof(ui_config2_t) == sizeof(uint32_t));
 
+/* Additional config.
+ * NB: Will be default init - override in defaults(). */
 struct misc_config_t {
-   private:
-    enum bits_t {
-        ConfigAudioMute = 0,
-        ConfigSpeakerDisable = 1,
-    };
+    bool mute_audio : 1;
+    bool disable_speaker : 1;
+    bool UNUSED_2 : 1;
+    bool UNUSED_3 : 1;
+    bool UNUSED_4 : 1;
+    bool UNUSED_5 : 1;
+    bool UNUSED_6 : 1;
+    bool UNUSED_7 : 1;
 
-    // misc_config_t bits:
-    // ConfigAudioMute = set to mute all audio output (speakers & headphones)
-    // ConfigSpeakerDisable = set to disable only the speaker and leave headphones enabled (only supported on AK4951 codec)
-
-    uint32_t values;
-
-    constexpr bool bit_read(const bits_t n) const {
-        return ((values >> n) & 1) != 0;
-    }
-
-    constexpr void bit_write(const bits_t n, const bool v) {
-        if (bit_read(n) != v) {
-            values ^= 1 << n;
-        }
-    }
-
-   public:
-    constexpr bool config_audio_mute() const {
-        return bit_read(bits_t::ConfigAudioMute);
-    }
-
-    constexpr void set_config_audio_mute(bool v) {
-        bit_write(bits_t::ConfigAudioMute, v);
-    }
-
-    constexpr bool config_speaker_disable() const {
-        return bit_read(bits_t::ConfigSpeakerDisable);
-    }
-
-    constexpr void set_config_speaker_disable(bool v) {
-        bit_write(bits_t::ConfigSpeakerDisable, v);
-    }
-
-    constexpr misc_config_t()
-        : values(0) {
-    }
+    uint8_t PLACEHOLDER_1;
+    uint8_t PLACEHOLDER_2;
+    uint8_t PLACEHOLDER_3;
 };
+static_assert(sizeof(misc_config_t) == sizeof(uint32_t));
 
-/* IMPORTANT: Report your changes here in the dump_persistent_memory function a few lines later !! */
+/* IMPORTANT: Update dump_persistent_memory (below) when changing data_t. */
+
+/* Struct must pack the same way on M4 and M0 cores.
+ * NB: When adding new members, keep 32bit-aligned.*/
 
-/* struct must pack the same way on M4 and M0 cores. */
 struct data_t {
     data_structure_version_enum structure_version;
     int64_t target_frequency;
     int32_t correction_ppb;
     uint32_t touch_calibration_magic;
-    touch::Calibration touch_calibration;
+    touch::Calibration touch_calibration;  // 7 * 32 bits.
 
     // Modem
     uint32_t modem_def_index;
@@ -337,7 +176,7 @@ struct data_t {
     int32_t modem_baudrate;
     int32_t modem_repeat;
 
-    // Play dead unlock
+    // Play dead unlock (Used?)
     uint32_t playdead_magic;
     uint32_t playing_dead;
     uint32_t playdead_sequence;
@@ -356,26 +195,30 @@ struct data_t {
     // Recon App
     uint64_t recon_config;
 
-    bool placeholder_0;
-
     // enable or disable converter
     bool converter;
     // set up converter (false) or down converter (true) converter
     bool updown_converter;
+    bool updown_frequency_rx_correction;
+    bool updown_frequency_tx_correction;
+    bool UNUSED_4 : 1;
+    bool UNUSED_5 : 1;
+    bool UNUSED_6 : 1;
+    bool UNUSED_7 : 1;
+
     // up/down converter offset
     int64_t converter_frequency_offset;
 
     // frequency correction
     uint32_t frequency_rx_correction;
-    bool updown_frequency_rx_correction;
     uint32_t frequency_tx_correction;
-    bool updown_frequency_tx_correction;
 
     // Rotary encoder dial sensitivity (encoder.cpp/hpp)
-    uint8_t encoder_dial_sensitivity;
+    uint16_t encoder_dial_sensitivity : 4;
+    uint16_t UNUSED_8 : 12;
 
-    // Headphone volume in centibels. (Only really needs 10 bits)
-    int32_t headphone_volume_cb;
+    // Headphone volume in centibels.
+    int16_t headphone_volume_cb;
 
     // Misc flags
     misc_config_t misc_config;
@@ -411,15 +254,23 @@ struct data_t {
 
           hardware_config(0),
           recon_config(0),
-          placeholder_0(0),
-          converter(0),
-          updown_converter(0),
+
+          converter(false),
+          updown_converter(false),
+          updown_frequency_rx_correction(false),
+          updown_frequency_tx_correction(false),
+          UNUSED_4(false),
+          UNUSED_5(false),
+          UNUSED_6(false),
+          UNUSED_7(false),
+
           converter_frequency_offset(0),
+
           frequency_rx_correction(0),
-          updown_frequency_rx_correction(0),
           frequency_tx_correction(0),
-          updown_frequency_tx_correction(0),
+
           encoder_dial_sensitivity(0),
+          UNUSED_8(0),
           headphone_volume_cb(-600),
           misc_config(),
           ui_config2() {
@@ -510,7 +361,10 @@ namespace cache {
 void defaults() {
     cached_backup_ram = backup_ram_t();
 
-    // defaults values for recon app
+    set_config_backlight_timer(backlight_config_t{});
+    set_config_splash(true);
+
+    // Default values for recon app.
     set_recon_autosave_freqs(false);
     set_recon_autostart_recon(true);
     set_recon_continuous(true);
@@ -626,14 +480,16 @@ void set_modem_baudrate(const int32_t new_value) {
     data->modem_baudrate = modem_baudrate_range.clip(new_value);
 }
 
-/*int32_t modem_bw() {
-                  modem_bw_range.reset_if_outside(data->modem_bw, modem_bw_reset_value);
-                  return data->modem_bw;
-                  }
+/*
+int32_t modem_bw() {
+    modem_bw_range.reset_if_outside(data->modem_bw, modem_bw_reset_value);
+    return data->modem_bw;
+}
 
-                  void set_modem_bw(const int32_t new_value) {
-                  data->modem_bw = modem_bw_range.clip(new_value);
-                  }*/
+void set_modem_bw(const int32_t new_value) {
+    data->modem_bw = modem_bw_range.clip(new_value);
+}
+*/
 
 uint8_t modem_repeat() {
     modem_repeat_range.reset_if_outside(data->modem_repeat, modem_repeat_reset_value);
@@ -652,56 +508,56 @@ void set_serial_format(const serial_format_t new_value) {
     data->serial_format = new_value;
 }
 
-bool show_gui_return_icon() {  // add return icon in touchscreen menue
-    return data->ui_config.show_gui_return_icon();
+bool show_gui_return_icon() {  // add return icon in touchscreen menu
+    return data->ui_config.show_gui_return_icon != 0;
 }
 
 bool load_app_settings() {  // load (last saved) app settings on startup of app
-    return data->ui_config.load_app_settings();
+    return data->ui_config.load_app_settings != 0;
 }
 
 bool save_app_settings() {  // save app settings when closing app
-    return data->ui_config.save_app_settings();
+    return data->ui_config.save_app_settings != 0;
 }
 
 bool show_bigger_qr_code() {  // show bigger QR code
-    return data->ui_config.show_bigger_qr_code();
+    return data->ui_config.show_large_qr_code != 0;
 }
 
 bool disable_touchscreen() {  // Option to disable touch screen
-    return data->ui_config.disable_touchscreen();
+    return data->ui_config.disable_touchscreen;
 }
 
-bool hide_clock() {  // clock hidden from main menu
-    return data->ui_config.hide_clock();
+bool hide_clock() {  // Hide clock from main menu
+    return data->ui_config.hide_clock;
 }
 
-bool clock_with_date() {  // show clock with date, if not hidden
-    return data->ui_config.clock_with_date();
+bool clock_with_date() {  // Show clock with date, if not hidden
+    return data->ui_config.clock_show_date;
 }
 
 bool clkout_enabled() {
-    return data->ui_config.clkout_enabled();
+    return data->ui_config.clkout_enabled;
 }
 
 bool config_audio_mute() {
-    return data->misc_config.config_audio_mute();
+    return data->misc_config.mute_audio;
 }
 
 bool config_speaker_disable() {
-    return data->misc_config.config_speaker_disable();
+    return data->misc_config.disable_speaker;
 }
 
 bool stealth_mode() {
-    return data->ui_config.stealth_mode();
+    return data->ui_config.stealth_mode;
 }
 
 bool config_login() {
-    return data->ui_config.config_login();
+    return data->ui_config.config_login;
 }
 
 bool config_splash() {
-    return data->ui_config.config_splash();
+    return data->ui_config.config_splash;
 }
 
 uint8_t config_cpld() {
@@ -709,59 +565,60 @@ uint8_t config_cpld() {
 }
 
 backlight_config_t config_backlight_timer() {
-    return data->ui_config.config_backlight_timer();
+    return {static_cast<backlight_timeout_t>(data->ui_config.backlight_timeout),
+            data->ui_config.enable_backlight_timeout == 1};
 }
 
 void set_gui_return_icon(bool v) {
-    data->ui_config.set_gui_return_icon(v);
+    data->ui_config.show_gui_return_icon = v ? 1 : 0;
 }
 
 void set_load_app_settings(bool v) {
-    data->ui_config.set_load_app_settings(v);
+    data->ui_config.load_app_settings = v ? 1 : 0;
 }
 
 void set_save_app_settings(bool v) {
-    data->ui_config.set_save_app_settings(v);
+    data->ui_config.save_app_settings = v ? 1 : 0;
 }
 
 void set_show_bigger_qr_code(bool v) {
-    data->ui_config.set_show_bigger_qr_code(v);
+    data->ui_config.show_large_qr_code = v ? 1 : 0;
 }
 
 void set_disable_touchscreen(bool v) {
-    data->ui_config.set_disable_touchscreen(v);
+    data->ui_config.disable_touchscreen = v;
 }
 
 void set_clock_hidden(bool v) {
-    data->ui_config.set_clock_hidden(v);
+    data->ui_config.hide_clock = v;
 }
 
 void set_clock_with_date(bool v) {
-    data->ui_config.set_clock_with_date(v);
+    data->ui_config.clock_show_date = v;
 }
 
 void set_clkout_enabled(bool v) {
-    data->ui_config.set_clkout_enabled(v);
+    data->ui_config.clkout_enabled = v;
 }
 
 void set_config_audio_mute(bool v) {
-    data->misc_config.set_config_audio_mute(v);
+    data->misc_config.mute_audio = v;
 }
 
 void set_config_speaker_disable(bool v) {
-    data->misc_config.set_config_speaker_disable(v);
+    data->misc_config.disable_speaker = v;
 }
 
 void set_stealth_mode(bool v) {
-    data->ui_config.set_stealth_mode(v);
+    data->ui_config.stealth_mode = v;
 }
 
 void set_config_login(bool v) {
-    data->ui_config.set_config_login(v);
+    data->ui_config.config_login = v;
 }
 
 void set_config_splash(bool v) {
-    data->ui_config.set_config_splash(v);
+    data->ui_config.config_splash = v;
 }
 
 void set_config_cpld(uint8_t i) {
@@ -769,7 +626,8 @@ void set_config_cpld(uint8_t i) {
 }
 
 void set_config_backlight_timer(const backlight_config_t& new_value) {
-    data->ui_config.set_config_backlight_timer(new_value);
+    data->ui_config.backlight_timeout = static_cast<uint8_t>(new_value.timeout_enum());
+    data->ui_config.enable_backlight_timeout = static_cast<uint8_t>(new_value.timeout_enabled());
 }
 
 uint32_t pocsag_last_address() {
@@ -788,12 +646,17 @@ void set_pocsag_ignore_address(uint32_t address) {
     data->pocsag_ignore_address = address;
 }
 
-uint32_t clkout_freq() {
-    return data->ui_config.clkout_freq();
+uint16_t clkout_freq() {
+    auto freq = data->ui_config.clkout_freq;
+
+    if (freq < clkout_freq_range.minimum || freq > clkout_freq_range.maximum)
+        set_clkout_freq(clkout_freq_reset_value);
+
+    return data->ui_config.clkout_freq;
 }
 
-void set_clkout_freq(uint32_t freq) {
-    data->ui_config.set_clkout_freq(freq);
+void set_clkout_freq(uint16_t freq) {
+    data->ui_config.clkout_freq = freq;
 }
 
 /* Recon app */
@@ -982,26 +845,23 @@ bool should_use_sdcard_for_pmem() {
 }
 
 int save_persistent_settings_to_file() {
-    std::string filename = PMEM_SETTING_FILE;
-    delete_file(filename);
     File outfile;
-    auto result = outfile.create(filename);
-    if (result.is_valid()) {
+    auto error = outfile.create(PMEM_SETTING_FILE);
+    if (error)
         return false;
-    }
+
     outfile.write(reinterpret_cast<char*>(&cached_backup_ram), sizeof(backup_ram_t));
     return true;
 }
 
 int load_persistent_settings_from_file() {
-    std::string filename = PMEM_SETTING_FILE;
     File infile;
-    auto result = infile.open(filename);
-    if (!result.is_valid()) {
-        infile.read(reinterpret_cast<char*>(&cached_backup_ram), sizeof(backup_ram_t));
-        return true;
-    }
-    return false;
+    auto error = infile.open(PMEM_SETTING_FILE);
+    if (error)
+        return false;
+
+    infile.read(reinterpret_cast<char*>(&cached_backup_ram), sizeof(backup_ram_t));
+    return true;
 }
 
 // Pmem size helper
@@ -1057,33 +917,37 @@ bool debug_dump() {
     pmem_dump_file.write_line("tone_mix: " + to_string_dec_uint(data->tone_mix));
     pmem_dump_file.write_line("hardware_config: " + to_string_dec_uint(data->hardware_config));
     pmem_dump_file.write_line("recon_config: 0x" + to_string_hex(data->recon_config, 16));
-    pmem_dump_file.write_line("placeholder_0: " + to_string_dec_int(data->placeholder_0));
     pmem_dump_file.write_line("converter: " + to_string_dec_int(data->converter));
     pmem_dump_file.write_line("updown_converter: " + to_string_dec_int(data->updown_converter));
+    pmem_dump_file.write_line("updown_frequency_rx_correction: " + to_string_dec_int(data->updown_frequency_rx_correction));
+    pmem_dump_file.write_line("updown_frequency_tx_correction: " + to_string_dec_int(data->updown_frequency_tx_correction));
+    // pmem_dump_file.write_line("UNUSED_4: " + to_string_dec_int(data->UNUSED_4));
+    // pmem_dump_file.write_line("UNUSED_5: " + to_string_dec_int(data->UNUSED_5));
+    // pmem_dump_file.write_line("UNUSED_6: " + to_string_dec_int(data->UNUSED_6));
+    // pmem_dump_file.write_line("UNUSED_7: " + to_string_dec_int(data->UNUSED_7));
     pmem_dump_file.write_line("converter_frequency_offset: " + to_string_dec_int(data->converter_frequency_offset));
     pmem_dump_file.write_line("frequency_rx_correction: " + to_string_dec_uint(data->frequency_rx_correction));
-    pmem_dump_file.write_line("updown_frequency_rx_correction: " + to_string_dec_int(data->updown_frequency_rx_correction));
     pmem_dump_file.write_line("frequency_tx_correction: " + to_string_dec_uint(data->frequency_tx_correction));
-    pmem_dump_file.write_line("updown_frequency_tx_correction: " + to_string_dec_int(data->updown_frequency_tx_correction));
     pmem_dump_file.write_line("encoder_dial_sensitivity: " + to_string_dec_uint(data->encoder_dial_sensitivity));
+    // pmem_dump_file.write_line("UNUSED_8: " + to_string_dec_uint(data->UNUSED_8));
     pmem_dump_file.write_line("headphone_volume_cb: " + to_string_dec_int(data->headphone_volume_cb));
 
     // ui_config bits
     const auto backlight_timer = portapack::persistent_memory::config_backlight_timer();
+    pmem_dump_file.write_line("ui_config clkout_freq: " + to_string_dec_uint(clkout_freq()));
     pmem_dump_file.write_line("ui_config backlight_timer.timeout_enabled: " + to_string_dec_uint(backlight_timer.timeout_enabled()));
     pmem_dump_file.write_line("ui_config backlight_timer.timeout_seconds: " + to_string_dec_uint(backlight_timer.timeout_seconds()));
-    pmem_dump_file.write_line("ui_config clkout_freq: " + to_string_dec_uint(clkout_freq()));
-    pmem_dump_file.write_line("ui_config show_gui_return_icon: " + to_string_dec_uint(data->ui_config.show_gui_return_icon()));
-    pmem_dump_file.write_line("ui_config load_app_settings: " + to_string_dec_uint(data->ui_config.load_app_settings()));
-    pmem_dump_file.write_line("ui_config save_app_settings: " + to_string_dec_uint(data->ui_config.save_app_settings()));
-    pmem_dump_file.write_line("ui_config show_bigger_qr_code: " + to_string_dec_uint(data->ui_config.show_bigger_qr_code()));
-    pmem_dump_file.write_line("ui_config disable_touchscreen: " + to_string_dec_uint(data->ui_config.disable_touchscreen()));
-    pmem_dump_file.write_line("ui_config hide_clock: " + to_string_dec_uint(data->ui_config.hide_clock()));
-    pmem_dump_file.write_line("ui_config clock_with_date: " + to_string_dec_uint(data->ui_config.clock_with_date()));
-    pmem_dump_file.write_line("ui_config clkout_enabled: " + to_string_dec_uint(data->ui_config.clkout_enabled()));
-    pmem_dump_file.write_line("ui_config stealth_mode: " + to_string_dec_uint(data->ui_config.stealth_mode()));
-    pmem_dump_file.write_line("ui_config config_login: " + to_string_dec_uint(data->ui_config.config_login()));
-    pmem_dump_file.write_line("ui_config config_splash: " + to_string_dec_uint(data->ui_config.config_splash()));
+    pmem_dump_file.write_line("ui_config show_gui_return_icon: " + to_string_dec_uint(data->ui_config.show_gui_return_icon));
+    pmem_dump_file.write_line("ui_config load_app_settings: " + to_string_dec_uint(data->ui_config.load_app_settings));
+    pmem_dump_file.write_line("ui_config save_app_settings: " + to_string_dec_uint(data->ui_config.save_app_settings));
+    pmem_dump_file.write_line("ui_config show_bigger_qr_code: " + to_string_dec_uint(data->ui_config.show_large_qr_code));
+    pmem_dump_file.write_line("ui_config disable_touchscreen: " + to_string_dec_uint(data->ui_config.disable_touchscreen));
+    pmem_dump_file.write_line("ui_config hide_clock: " + to_string_dec_uint(data->ui_config.hide_clock));
+    pmem_dump_file.write_line("ui_config clock_with_date: " + to_string_dec_uint(data->ui_config.clock_show_date));
+    pmem_dump_file.write_line("ui_config clkout_enabled: " + to_string_dec_uint(data->ui_config.clkout_enabled));
+    pmem_dump_file.write_line("ui_config stealth_mode: " + to_string_dec_uint(data->ui_config.stealth_mode));
+    pmem_dump_file.write_line("ui_config config_login: " + to_string_dec_uint(data->ui_config.config_login));
+    pmem_dump_file.write_line("ui_config config_splash: " + to_string_dec_uint(data->ui_config.config_splash));
 
     // ui_config2 bits
     pmem_dump_file.write_line("ui_config2 hide_speaker: " + to_string_dec_uint(data->ui_config2.hide_speaker));

firmware/common/portapack_persistent_memory.hpp

@@ -34,9 +34,10 @@
 #include "volume.hpp"
 
 // persistant memory from/to sdcard flag file
-#define PMEM_FILEFLAG "/SETTINGS/PMEM_FILEFLAG"
+#define PMEM_FILEFLAG u"/SETTINGS/PMEM_FILEFLAG"
+
 // persistant memory from/to sdcard flag file
-#define PMEM_SETTING_FILE "/SETTINGS/pmem_settings"
+#define PMEM_SETTING_FILE u"/SETTINGS/pmem_settings"
 
 using namespace modems;
 using namespace serializer;
@@ -225,8 +226,8 @@ void set_pocsag_ignore_address(uint32_t address);
 
 bool clkout_enabled();
 void set_clkout_enabled(bool v);
-uint32_t clkout_freq();
-void set_clkout_freq(uint32_t freq);
+uint16_t clkout_freq();
+void set_clkout_freq(uint16_t freq);
 
 /* Recon app */
 bool recon_autosave_freqs();