BLE: Minor improvements to fix occasional not start on tx app first time. (#1605)

Co-authored-by: GullCode <gullradriel@hotmail.com>

firmware/application/apps/ble_rx_app.cpp

@@ -199,7 +199,7 @@ BleRecentEntryDetailView::BleRecentEntryDetailView(NavigationView& nav, const Bl
 }
 
 void BleRecentEntryDetailView::on_save_file(const std::string value, BLETxPacket packetToSave) {
-    std::filesystem::path packet_save_path{u"BLERX/Packets/Packet_????.TXT"};
+    std::filesystem::path packet_save_path{u"BLERX/Packets/????.TXT"};
 
     ensure_directory(packet_save_path);
     auto folder = packet_save_path.parent_path();
@@ -420,6 +420,7 @@ BLERxView::BLERxView(NavigationView& nav)
                   &options_sort,
                   &button_filter,
                   &button_save_list,
+                  &button_clear_list,
                   &button_switch,
                   &recent_entries_view});
 
@@ -448,6 +449,10 @@ BLERxView::BLERxView(NavigationView& nav)
             });
     };
 
+    button_clear_list.on_select = [this](Button&) {
+        recent.clear();
+    };
+
     button_switch.on_select = [&nav](Button&) {
         nav.replace<BLETxView>();
     };
@@ -501,8 +506,24 @@ BLERxView::BLERxView(NavigationView& nav)
     receiver_model.enable();
 }
 
+std::string BLERxView::build_line_str(BleRecentEntry entry) {
+    std::string macAddressStr = to_string_mac_address(entry.packetData.macAddress, 6, false) + ",";
+    std::string timestameStr = entry.timestamp + ",";
+    std::string nameStr = entry.nameString + ",";
+    std::string pduStr = pdu_type_to_string(entry.pduType) + ",";
+    std::string dataStr = "0x" + entry.dataString + ",";
+    std::string hitsStr = to_string_dec_int(entry.numHits) + ",";
+    std::string dbStr = to_string_dec_int(entry.dbValue) + ",";
+    std::string channelStr = to_string_dec_int(entry.channelNumber) + ",";
+
+    std::string lineStr = timestameStr + macAddressStr + nameStr + pduStr + dataStr + hitsStr + dbStr + channelStr;
+    lineStr += pad_string_with_spaces(maxLineLength - lineStr.length());
+
+    return lineStr;
+}
+
 void BLERxView::on_save_file(const std::string value) {
-    std::filesystem::path packet_save_path{u"BLERX/Lists/List_????.csv"};
+    std::filesystem::path packet_save_path{u"BLERX/Lists/????.csv"};
 
     ensure_directory(packet_save_path);
     auto folder = packet_save_path.parent_path();
@@ -513,40 +534,125 @@ void BLERxView::on_save_file(const std::string value) {
 }
 
 bool BLERxView::saveFile(const std::filesystem::path& path) {
-    File f;
-    auto error = f.create(path);
-    if (error)
+    // Check to see if file was previously saved.
+    bool file_existed = file_exists(path);
+
+    // Attempt to open, if it can't be opened. Create new.
+    auto src = std::make_unique<File>();
+    auto error = src->open(path, false, true);
+
+    if (error) {
         return false;
-
-    auto it = recent.begin();
-
-    std::string headerStr = "Timestamp, MAC Address, Name, Packet Type, Data, Hits, dB, Channel \n";
-    f.write(headerStr.c_str(), headerStr.length());
-
-    while (it != recent.end()) {
-        BleRecentEntry entry = (BleRecentEntry)*it;
-
-        std::string macAddressStr = to_string_mac_address(entry.packetData.macAddress, 6, false) + ", ";
-        std::string timestameStr = entry.timestamp + ", ";
-        std::string nameStr = entry.nameString + ", ";
-        std::string pduStr = pdu_type_to_string(entry.pduType) + ", ";
-        std::string dataStr = "0x" + entry.dataString + ", ";
-        std::string hitsStr = to_string_dec_int(entry.numHits) + ", ";
-        std::string dbStr = to_string_dec_int(entry.dbValue) + ", ";
-        std::string channelStr = to_string_dec_int(entry.channelNumber) + "\n";
-
-        f.write(timestameStr.c_str(), timestameStr.length());
-        f.write(macAddressStr.c_str(), macAddressStr.length());
-        f.write(nameStr.c_str(), nameStr.length());
-        f.write(pduStr.c_str(), pduStr.length());
-        f.write(dataStr.c_str(), dataStr.length());
-        f.write(hitsStr.c_str(), hitsStr.length());
-        f.write(dbStr.c_str(), dbStr.length());
-        f.write(channelStr.c_str(), channelStr.length());
-
-        it++;
     }
 
+    for (const auto& entry : recent) {
+        tempList.emplace_back(entry);
+    }
+
+    if (!file_existed) {
+        src->write_line(headerStr.c_str());
+
+        auto it = tempList.begin();
+
+        while (it != tempList.end()) {
+            BleRecentEntry entry = (BleRecentEntry)*it;
+            src->write_line(build_line_str(entry).c_str());
+            it++;
+        }
+    } else {
+        // Check file for macAddressStr before adding.
+        char currentLine[maxLineLength];
+        uint64_t startPos = headerStr.length();
+        uint64_t bytesRead = 0;
+        uint64_t bytePos = 0;
+
+        File::Size currentSize = src->size();
+
+        auto dst = std::make_unique<File>();
+        const std::filesystem::path tempFilePath = path + "~";
+        auto error = dst->open(tempFilePath, false, true);
+
+        if (error) {
+            return false;
+        }
+
+        dst->write_line(headerStr.c_str());
+
+        src->seek(startPos);
+
+        // Look for ones found and rewrite.
+        do {
+            memset(currentLine, 0, maxLineLength);
+
+            bytesRead = readUntil(*src, currentLine, currentSize, '\n');
+
+            if (!bytesRead) {
+                break;
+            }
+
+            bytePos += bytesRead;
+
+            std::string lineStr = "";
+            std::string macAddressStr = "";
+            BleRecentEntry foundEntry;
+
+            char* token;
+            token = strtok(currentLine, ",");
+
+            while (token != NULL) {
+                auto it = tempList.begin();
+
+                while (it != tempList.end()) {
+                    BleRecentEntry& entry = reinterpret_cast<BleRecentEntry&>(*it);
+
+                    macAddressStr = to_string_mac_address(entry.packetData.macAddress, 6, false);
+
+                    if (strstr(token, macAddressStr.c_str()) != NULL) {
+                        entry.entryFound = true;
+                        foundEntry = entry;
+                        break;
+                    }
+
+                    it++;
+                }
+
+                if (foundEntry.entryFound) {
+                    break;
+                }
+
+                token = strtok(NULL, ",");
+            }
+
+            if (foundEntry.entryFound) {
+                dst->write_line(build_line_str(foundEntry).c_str());
+            }
+
+        } while (bytePos <= currentSize);
+
+        // Write the ones not found.
+        auto it = tempList.begin();
+
+        while (it != tempList.end()) {
+            BleRecentEntry entry = (BleRecentEntry)*it;
+
+            if (!entry.entryFound) {
+                dst->write_line(build_line_str(entry).c_str());
+            }
+
+            it++;
+        }
+
+        // Close files before renaming/deleting.
+        src.reset();
+        dst.reset();
+
+        // Delete original and overwrite with temp file.
+        delete_file(path);
+        rename_file(tempFilePath, path);
+    }
+
+    tempList.clear();
+
     return true;
 }
 

firmware/application/apps/ble_rx_app.hpp

@@ -85,6 +85,7 @@ struct BleRecentEntry {
     uint16_t numHits;
     ADV_PDU_TYPE pduType;
     uint8_t channelNumber;
+    bool entryFound;
 
     BleRecentEntry()
         : BleRecentEntry{0} {
@@ -101,7 +102,8 @@ struct BleRecentEntry {
           include_name{},
           numHits{},
           pduType{},
-          channelNumber{} {
+          channelNumber{},
+          entryFound{} {
     }
 
     Key key() const {
@@ -188,6 +190,7 @@ class BLERxView : public View {
     std::string title() const override { return "BLE RX"; };
 
    private:
+    std::string build_line_str(BleRecentEntry entry);
     void on_save_file(const std::string value);
     bool saveFile(const std::filesystem::path& path);
     void on_data(BlePacketData* packetData);
@@ -212,6 +215,8 @@ class BLERxView : public View {
     std::string filterBuffer{};
     std::string filter{};
     std::string listFileBuffer{};
+    std::string headerStr = "Timestamp, MAC Address, Name, Packet Type, Data, Hits, dB, Channel";
+    uint16_t maxLineLength = 140;
 
     static constexpr auto header_height = 3 * 16;
     static constexpr auto switch_button_height = 3 * 16;
@@ -274,13 +279,17 @@ class BLERxView : public View {
     Console console{
         {0, 4 * 16, 240, 240}};
 
+    Button button_clear_list{
+        {2 * 8, 320 - (16 + 32), 7 * 8, 32},
+        "Clear"};
+
     Button button_save_list{
-        {1 * 8, 16 * 16, 13 * 8, 2 * 16},
-        "Save List"};
+        {11 * 8, 320 - (16 + 32), 11 * 8, 32},
+        "Export CSV"};
 
     Button button_switch{
-        {16 * 8, 16 * 16, 13 * 8, 2 * 16},
-        "Switch to Rx"};
+        {240 - 6 * 8, 320 - (16 + 32), 4 * 8, 32},
+        "Tx"};
 
     std::string str_log{""};
     bool logging{false};
@@ -288,6 +297,7 @@ class BLERxView : public View {
     std::unique_ptr<BLELogger> logger{};
 
     BleRecentEntries recent{};
+    BleRecentEntries tempList{};
 
     const RecentEntriesColumns columns{{
         {"Mac Address", 17},

firmware/application/apps/ble_tx_app.cpp

@@ -94,33 +94,6 @@ uint32_t stringToUint32(const std::string& str) {
     return result;
 }
 
-void readUntil(File& file, char* result, std::size_t maxBufferSize, char delimiter) {
-    std::size_t bytesRead = 0;
-
-    while (true) {
-        char ch;
-        File::Result<File::Size> readResult = file.read(&ch, 1);
-
-        if (readResult.is_ok() && readResult.value() > 0) {
-            if (ch == delimiter) {
-                // Found a space character, stop reading
-                break;
-            } else if (bytesRead < maxBufferSize) {
-                // Append the character to the result if there's space
-                result[bytesRead++] = ch;
-            } else {
-                // Buffer is full, break to prevent overflow
-                break;
-            }
-        } else {
-            break;  // End of file or error
-        }
-    }
-
-    // Null-terminate the result string
-    result[bytesRead] = '\0';
-}
-
 static std::uint64_t get_freq_by_channel_number(uint8_t channel_number) {
     uint64_t freq_hz;
 
@@ -194,6 +167,9 @@ void BLETxView::toggle() {
 }
 
 void BLETxView::start() {
+    baseband::run_image(portapack::spi_flash::image_tag_btle_tx);
+    transmitter_model.enable();
+
     int randomChannel = channel_number;
 
     if (auto_channel) {
@@ -219,27 +195,19 @@ void BLETxView::start() {
             return;
         }
 
-        transmitter_model.enable();
         button_play.set_bitmap(&bitmap_stop);
         is_running = true;
     }
 
-    // Send next packet.
+    // Setup next packet configuration.
     progressbar.set_max(packets[current_packet].packet_count);
     baseband::set_btletx(randomChannel, random_mac ? randomMac : packets[current_packet].macAddress, packets[current_packet].advertisementData, pduType);
-
-    is_sending = true;
-
-    if ((packet_counter % 10) == 0) {
-        text_packets_sent.set(to_string_dec_uint(packet_counter));
-    }
-
-    packet_counter--;
-    progressbar.set_value(packets[current_packet].packet_count - packet_counter);
 }
 
 void BLETxView::stop() {
     transmitter_model.disable();
+    baseband::shutdown();
+
     progressbar.set_value(0);
     button_play.set_bitmap(&bitmap_play);
     check_loop.set_value(false);
@@ -249,30 +217,39 @@ void BLETxView::stop() {
     is_running = false;
 }
 
+void BLETxView::reset() {
+    transmitter_model.disable();
+    baseband::shutdown();
+
+    start();
+}
+
 // called each 1/60th of second, so 6 = 100ms
 void BLETxView::on_timer() {
     if (++mscounter == timer_period) {
         mscounter = 0;
 
-        if (is_active() && !is_sending) {
+        if (is_active()) {
             // Reached end of current packet repeats.
             if (packet_counter == 0) {
                 // Done sending all packets.
                 if (current_packet == (num_packets - 1)) {
+                    current_packet = 0;
+
                     // If looping, restart from beginning.
                     if (check_loop.value()) {
-                        update_current_packet(packets[current_packet], 0);
-                        start();
+                        update_current_packet(packets[current_packet], current_packet);
+                        reset();
                     } else {
                         stop();
                     }
                 } else {
                     current_packet++;
                     update_current_packet(packets[current_packet], current_packet);
-                    start();
+                    reset();
                 }
             } else {
-                start();
+                reset();
             }
         }
     }
@@ -281,15 +258,18 @@ void BLETxView::on_timer() {
 void BLETxView::on_tx_progress(const bool done) {
     if (done) {
         if (is_active()) {
-            is_sending = false;
+            if ((packet_counter % 10) == 0) {
+                text_packets_sent.set(to_string_dec_uint(packet_counter));
+            }
+
+            packet_counter--;
+            progressbar.set_value(packets[current_packet].packet_count - packet_counter);
         }
     }
 }
 
 BLETxView::BLETxView(NavigationView& nav)
     : nav_{nav} {
-    baseband::run_image(portapack::spi_flash::image_tag_btle_tx);
-
     add_children({&button_open,
                   &text_filename,
                   &progressbar,

firmware/application/apps/ble_tx_app.hpp

@@ -108,6 +108,7 @@ class BLETxView : public View {
     void toggle();
     void start();
     void stop();
+    void reset();
     void handle_replay_thread_done(const uint32_t return_code);
     void file_error();
     bool saveFile(const std::filesystem::path& path);
@@ -142,7 +143,6 @@ class BLETxView : public View {
     char randomMac[13] = "010203040506";
 
     bool is_running = false;
-    bool is_sending = false;
     uint64_t timer_count{0};
     int16_t timer_period{1};
     bool repeatLoop = false;
@@ -268,7 +268,7 @@ class BLETxView : public View {
 
     Button button_switch{
         {16 * 8, 16 * 16, 13 * 8, 2 * 16},
-        "Switch to Tx"};
+        "Switch to Rx"};
 
     std::string str_log{""};
     bool logging{true};

firmware/application/apps/ert_app.cpp

@@ -65,9 +65,13 @@ std::string commodity_type(CommodityType value) {
 
 } /* namespace ert */
 
-void ERTLogger::on_packet(const ert::Packet& packet) {
+void ERTLogger::on_packet(const ert::Packet& packet, const uint32_t target_frequency) {
     const auto formatted = packet.symbols_formatted();
-    std::string entry = ert::format::type(packet.type()) + " " + formatted.data + "/" + formatted.errors;
+
+    // TODO: function doesn't take uint64_t, so when >= 1<<32, weirdness will ensue!
+    const auto target_frequency_str = to_string_dec_uint(target_frequency, 10);
+
+    std::string entry = target_frequency_str + " " + ert::format::type(packet.type()) + " " + formatted.data + "/" + formatted.errors;
     log_file.write_entry(packet.received_at(), entry);
 }
 
@@ -99,10 +103,12 @@ void RecentEntriesTable<ERTRecentEntries>::draw(
     painter.draw_string(target_rect.location(), style, line);
 }
 
-ERTAppView::ERTAppView(NavigationView&) {
+ERTAppView::ERTAppView(NavigationView& nav)
+    : nav_{nav} {
     baseband::run_image(portapack::spi_flash::image_tag_ert);
 
     add_children({
+        &field_frequency,
         &field_rf_amp,
         &field_lna,
         &field_vga,
@@ -110,6 +116,8 @@ ERTAppView::ERTAppView(NavigationView&) {
         &recent_entries_view,
     });
 
+    field_frequency.set_step(1000000);
+
     receiver_model.enable();
 
     logger = std::make_unique<ERTLogger>();
@@ -134,7 +142,7 @@ void ERTAppView::set_parent_rect(const Rect new_parent_rect) {
 
 void ERTAppView::on_packet(const ert::Packet& packet) {
     if (logger) {
-        logger->on_packet(packet);
+        logger->on_packet(packet, receiver_model.target_frequency());
     }
 
     if (packet.crc_ok()) {

firmware/application/apps/ert_app.hpp

@@ -24,6 +24,7 @@
 
 #include "ui_navigation.hpp"
 #include "ui_receiver.hpp"
+#include "ui_freq_field.hpp"
 #include "ui_rssi.hpp"
 #include "ui_channel.hpp"
 
@@ -95,7 +96,7 @@ class ERTLogger {
         return log_file.append(filename);
     }
 
-    void on_packet(const ert::Packet& packet);
+    void on_packet(const ert::Packet& packet, const uint32_t target_frequency);
 
    private:
     LogFile log_file{};
@@ -126,6 +127,7 @@ class ERTAppView : public View {
     ERTRecentEntries recent{};
     std::unique_ptr<ERTLogger> logger{};
 
+    NavigationView& nav_;
     RxRadioState radio_state_{
         911600000 /* frequency */,
         2500000 /* bandwidth */,
@@ -143,6 +145,10 @@ class ERTAppView : public View {
 
     static constexpr auto header_height = 1 * 16;
 
+    RxFrequencyField field_frequency{
+        {5 * 8, 0 * 16},
+        nav_};
+
     RFAmpField field_rf_amp{
         {13 * 8, 0 * 16}};
 

firmware/application/apps/tpms_app.cpp

@@ -34,9 +34,6 @@ namespace tpms {
 
 namespace format {
 
-static bool use_kpa = true;
-static bool use_celsius = true;
-
 std::string type(Reading::Type type) {
     return to_string_dec_uint(toUType(type), 2);
 }
@@ -46,11 +43,11 @@ std::string id(TransponderID id) {
 }
 
 std::string pressure(Pressure pressure) {
-    return to_string_dec_int(use_kpa ? pressure.kilopascal() : pressure.psi(), 3);
+    return to_string_dec_int(units_psi ? pressure.psi() : pressure.kilopascal(), 3);
 }
 
 std::string temperature(Temperature temperature) {
-    return to_string_dec_int(use_celsius ? temperature.celsius() : temperature.fahrenheit(), 3);
+    return to_string_dec_int(units_fahr ? temperature.fahrenheit() : temperature.celsius(), 3);
 }
 
 std::string flags(Flags flags) {
@@ -165,18 +162,16 @@ TPMSAppView::TPMSAppView(NavigationView&) {
     options_band.set_by_value(receiver_model.target_frequency());
 
     options_pressure.on_change = [this](size_t, int32_t i) {
-        tpms::format::use_kpa = !i;
+        tpms::format::units_psi = (bool)i;
         update_view();
     };
-
-    options_pressure.set_selected_index(0, true);
+    options_pressure.set_selected_index(tpms::format::units_psi, true);
 
     options_temperature.on_change = [this](size_t, int32_t i) {
-        tpms::format::use_celsius = !i;
+        tpms::format::units_fahr = (bool)i;
         update_view();
     };
-
-    options_temperature.set_selected_index(0, true);
+    options_temperature.set_selected_index(tpms::format::units_fahr, true);
 
     logger = std::make_unique<TPMSLogger>();
     if (logger) {

firmware/application/apps/tpms_app.hpp

@@ -37,6 +37,17 @@
 
 #include "tpms_packet.hpp"
 
+namespace tpms {
+
+namespace format {
+
+static bool units_psi{false};
+static bool units_fahr{false};
+
+} /* namespace format */
+
+} /* namespace tpms */
+
 namespace std {
 
 } /* namespace std */
@@ -103,11 +114,17 @@ class TPMSAppView : public View {
 
    private:
     RxRadioState radio_state_{
-        315000000 /* frequency*/,
+        314950000 /* frequency*/,
         1750000 /* bandwidth */,
         2457600 /* sampling rate */};
+
     app_settings::SettingsManager settings_{
-        "rx_tpms", app_settings::Mode::RX};
+        "rx_tpms",
+        app_settings::Mode::RX,
+        {
+            {"units_psi"sv, &tpms::format::units_psi},
+            {"units_fahr"sv, &tpms::format::units_fahr},
+        }};
 
     MessageHandlerRegistration message_handler_packet{
         Message::ID::TPMSPacket,
@@ -129,11 +146,12 @@ class TPMSAppView : public View {
         {21 * 8, 5, 6 * 8, 4},
     };
 
+    // "315 MHz" TPMS sensors transmit at either 314.9 or 315 MHz but we should pick up either
     OptionsField options_band{
         {0 * 8, 0 * 16},
         3,
         {
-            {"315", 315000000},
+            {"315", 314950000},
             {"434", 433920000},
         }};
 

firmware/application/apps/ui_debug.cpp

@@ -277,14 +277,11 @@ RegistersView::RegistersView(
                                 static_cast<int>(title.size()) * 8, 16});
     text_title.set(title);
 
-    field_write_reg_num.set_value(0);
     field_write_reg_num.on_change = [this](SymField&) {
         field_write_data_val.set_value(this->registers_widget.reg_read(field_write_reg_num.to_integer()));
         field_write_data_val.set_dirty();
     };
 
-    field_write_data_val.on_change = [this](SymField&) {};
-
     const auto value = registers_widget.reg_read(0);
     field_write_data_val.set_value(value);
 
@@ -450,9 +447,10 @@ DebugMenuView::DebugMenuView(NavigationView& nav) {
         {"Buttons Test", ui::Color::dark_cyan(), &bitmap_icon_controls, [&nav]() { nav.push<DebugControlsView>(); }},
         {"Debug Dump", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { portapack::persistent_memory::debug_dump(); }},
         {"M0 Stack Dump", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { stack_dump(); }},
-        {"Memory", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugMemoryView>(); }},
-        {"P.Memory", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugPmemView>(); }},
+        {"Memory Dump", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugMemoryDumpView>(); }},
+        {"Memory Usage", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugMemoryView>(); }},
         {"Peripherals", ui::Color::dark_cyan(), &bitmap_icon_peripherals, [&nav]() { nav.push<DebugPeripheralsMenuView>(); }},
+        {"Pers. Memory", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugPmemView>(); }},
         //{ "Radio State",	ui::Color::white(),	nullptr,	[&nav](){ nav.push<NotImplementedView>(); } },
         {"SD Card", ui::Color::dark_cyan(), &bitmap_icon_sdcard, [&nav]() { nav.push<SDCardDebugView>(); }},
         {"Temperature", ui::Color::dark_cyan(), &bitmap_icon_temperature, [&nav]() { nav.push<TemperatureView>(); }},
@@ -466,6 +464,43 @@ DebugMenuView::DebugMenuView(NavigationView& nav) {
     set_max_rows(2);  // allow wider buttons
 }
 
+/* DebugMemoryDumpView *********************************************************/
+
+DebugMemoryDumpView::DebugMemoryDumpView(NavigationView& nav) {
+    add_children({
+        &button_dump,
+        &button_read,
+        &button_write,
+        &button_done,
+        &labels,
+        &field_starting_address,
+        &field_byte_count,
+        &field_rw_address,
+        &field_data_value,
+    });
+
+    button_done.on_select = [&nav](Button&) { nav.pop(); };
+
+    button_dump.on_select = [this](Button&) {
+        if (field_byte_count.to_integer() != 0)
+            memory_dump((uint32_t*)field_starting_address.to_integer(), ((uint32_t)field_byte_count.to_integer() + 3) / 4, false);
+    };
+
+    button_read.on_select = [this](Button&) {
+        field_data_value.set_value(*(uint32_t*)field_rw_address.to_integer());
+        field_data_value.set_dirty();
+    };
+
+    button_write.set_style(&Styles::red);
+    button_write.on_select = [this](Button&) {
+        *(uint32_t*)field_rw_address.to_integer() = (uint32_t)field_data_value.to_integer();
+    };
+}
+
+void DebugMemoryDumpView::focus() {
+    button_done.focus();
+}
+
 /* DebugPmemView *********************************************************/
 
 DebugPmemView::DebugPmemView(NavigationView& nav)

firmware/application/apps/ui_debug.hpp

@@ -48,8 +48,8 @@ class DebugMemoryView : public View {
 
    private:
     Text text_title{
-        {96, 96, 48, 16},
-        "Memory",
+        {72, 96, 96, 16},
+        "Memory Usage",
     };
 
     Text text_label_m0_core_free{
@@ -301,6 +301,58 @@ class DebugControlsView : public View {
         "Done"};
 };
 
+class DebugMemoryDumpView : public View {
+   public:
+    DebugMemoryDumpView(NavigationView& nav);
+    void focus() override;
+    std::string title() const override { return "Memory Dump"; };
+
+   private:
+    Button button_dump{
+        {72, 4 * 16, 96, 24},
+        "Dump"};
+
+    Button button_read{
+        {16, 11 * 16, 96, 24},
+        "Read"};
+
+    Button button_write{
+        {128, 11 * 16, 96, 24},
+        "Write"};
+
+    Button button_done{
+        {128, 240, 96, 24},
+        "Done"};
+
+    Labels labels{
+        {{5 * 8, 1 * 16}, "Dump Range to File", Color::yellow()},
+        {{0 * 8, 2 * 16}, "Starting Address: 0x", Color::light_grey()},
+        {{0 * 8, 3 * 16}, "Byte Count:       0x", Color::light_grey()},
+        {{3 * 8, 8 * 16}, "Read/Write Single Word", Color::yellow()},
+        {{0 * 8, 9 * 16}, "Memory Address:   0x", Color::light_grey()},
+        {{0 * 8, 10 * 16}, "Data Value:       0x", Color::light_grey()}};
+
+    SymField field_starting_address{
+        {20 * 8, 2 * 16},
+        8,
+        SymField::Type::Hex};
+
+    SymField field_byte_count{
+        {20 * 8, 3 * 16},
+        8,
+        SymField::Type::Hex};
+
+    SymField field_rw_address{
+        {20 * 8, 9 * 16},
+        8,
+        SymField::Type::Hex};
+
+    SymField field_data_value{
+        {20 * 8, 10 * 16},
+        8,
+        SymField::Type::Hex};
+};
+
 class DebugPmemView : public View {
    public:
     DebugPmemView(NavigationView& nav);

firmware/application/apps/ui_morse.cpp

@@ -56,13 +56,23 @@ static msg_t ookthread_fn(void* arg) {
         v = (symbol < 2) ? 1 : 0;  // TX on for dot or dash, off for pause
         delay = morse_symbols[symbol];
 
-        gpio_og_tx.write(v);
+        if (hackrf_r9) {           // r9 has a common PIN 54 for MODE CONTROL TX / RX,  <=r6 has two independent MODE CONTROL pins (TX and RX)
+            gpio_r9_rx.write(!v);  // in hackrf r9 opposite logic "0" means tx , "1" rx = no tx)
+        } else {
+            gpio_og_tx.write(v);  // in hackrf <=r6, "1" means tx , "0" no tx.
+        }
+
         arg_c->on_tx_progress(i, false);
 
         chThdSleepMilliseconds(delay * arg_c->time_unit_ms);
     }
 
-    gpio_og_tx.write(0);  // Ensure TX is off
+    if (hackrf_r9) {          // r9 has a common PIN 54 for MODE CONTROL TX / RX,  <=r6 has two independent MODE CONTROL pins (TX and RX)
+        gpio_r9_rx.write(1);  // Hackrf_r9 , common pin,  rx="1" (we ensure TX is off)  / tx="0"
+    } else {
+        gpio_og_tx.write(0);  // Hackrf <=r6 independent TX / RX  pins ,now touching the tx pin ==> Ensure TX is off
+    }
+
     arg_c->on_tx_progress(0, true);
     chThdExit(0);
 
@@ -121,9 +131,9 @@ bool MorseView::start_tx() {
     transmitter_model.set_baseband_bandwidth(1'750'000);  // Min TX LPF .already tested in FM morse max tone 9,999k , max dev 150khz
     transmitter_model.enable();
 
-    if (modulation == CW) {
+    if (mode_cw) {
         ookthread = chThdCreateStatic(ookthread_wa, sizeof(ookthread_wa), NORMALPRIO + 10, ookthread_fn, this);
-    } else if (modulation == FM) {
+    } else {
         baseband::set_tones_config(transmitter_model.channel_bandwidth(), 0, symbol_count, false, false);
     }
 
@@ -133,8 +143,8 @@ bool MorseView::start_tx() {
 void MorseView::update_tx_duration() {
     uint32_t duration_ms;
 
-    time_unit_ms = 1200 / field_speed.value();
-    symbol_count = morse_encode(message, time_unit_ms, field_tone.value(), &time_units);
+    time_unit_ms = 1200 / speed;
+    symbol_count = morse_encode(message, time_unit_ms, tone, &time_units);
 
     if (symbol_count) {
         duration_ms = time_units * time_unit_ms;
@@ -175,7 +185,7 @@ void MorseView::on_loop_progress(const uint32_t progress, const bool done) {
 }
 
 void MorseView::set_foxhunt(size_t i) {
-    message = foxhunt_codes[i];
+    message = foxhunt_codes[i - 1];
     buffer = message.c_str();
     text_message.set(message);
     update_tx_duration();
@@ -188,7 +198,7 @@ MorseView::MorseView(
 
     add_children({&labels,
                   &checkbox_foxhunt,
-                  &options_foxhunt,
+                  &field_foxhunt,
                   &field_speed,
                   &field_tone,
                   &options_modulation,
@@ -200,36 +210,46 @@ MorseView::MorseView(
                   &tx_view});
 
     // Default settings
-    field_speed.set_value(15);                 // 15wps
-    field_tone.set_value(700);                 // 700Hz FM tone
-    options_modulation.set_selected_index(0);  // CW mode
-    options_loop.set_selected_index(0);        // Off
+    field_speed.set_value(speed);
+    field_tone.set_value(tone);
+    options_modulation.set_by_value(mode_cw);
+    options_loop.set_by_value(loop);
+    checkbox_foxhunt.set_value(foxhunt_mode);
+    field_foxhunt.set_value(foxhunt_code);
 
     checkbox_foxhunt.on_select = [this](Checkbox&, bool value) {
         foxhunt_mode = value;
 
         if (foxhunt_mode)
-            set_foxhunt(options_foxhunt.selected_index_value());
+            set_foxhunt(foxhunt_code);
     };
 
-    options_foxhunt.on_change = [this](size_t i, int32_t) {
+    field_foxhunt.on_change = [this](int32_t value) {
+        foxhunt_code = value;
+
         if (foxhunt_mode)
-            set_foxhunt(i);
+            set_foxhunt(foxhunt_code);
     };
 
-    options_modulation.on_change = [this](size_t i, int32_t) {
-        modulation = (modulation_t)i;
-    };
-
-    options_loop.on_change = [this](size_t i, uint32_t n) {
+    options_modulation.on_change = [this](size_t i, int32_t value) {
         (void)i;  // avoid unused warning
-        loop = n;
+        mode_cw = (bool)value;
     };
 
-    field_speed.on_change = [this](int32_t) {
+    options_loop.on_change = [this](size_t i, uint32_t value) {
+        (void)i;  // avoid unused warning
+        loop = value;
+    };
+
+    field_speed.on_change = [this](int32_t value) {
+        speed = value;
         update_tx_duration();
     };
 
+    field_tone.on_change = [this](int32_t value) {
+        tone = value;
+    };
+
     button_message.on_select = [this, &nav](Button&) {
         this->on_set_text(nav);
     };

firmware/application/apps/ui_morse.hpp

@@ -65,7 +65,6 @@ class MorseView : public View {
 
    private:
     NavigationView& nav_;
-    std::string buffer{"PORTAPACK"};
     std::string message{};
     uint32_t time_units{0};
 
@@ -74,14 +73,25 @@ class MorseView : public View {
         1750000 /* bandwidth */,
         1536000 /* sampling rate */
     };
-    app_settings::SettingsManager settings_{
-        "tx_morse", app_settings::Mode::TX};
 
-    enum modulation_t {
-        CW = 0,
-        FM = 1
-    };
-    modulation_t modulation{CW};
+    std::string buffer{"PORTAPACK"};
+    bool mode_cw{true};
+    bool foxhunt_mode{false};
+    uint32_t foxhunt_code{1};
+    uint32_t speed{15};
+    uint32_t tone{700};
+    app_settings::SettingsManager settings_{
+        "tx_morse",
+        app_settings::Mode::TX,
+        {
+            {"message"sv, &buffer},
+            {"foxhunt"sv, &foxhunt_mode},
+            {"foxhunt_code"sv, &foxhunt_code},
+            {"speed"sv, &speed},
+            {"tone"sv, &tone},
+            {"mode_cw"sv, &mode_cw},
+            {"loop"sv, &loop},
+        }};
 
     bool start_tx();
     void update_tx_duration();
@@ -90,7 +100,6 @@ class MorseView : public View {
 
     Thread* ookthread{nullptr};
     Thread* loopthread{nullptr};
-    bool foxhunt_mode{false};
     bool run{false};
 
     Labels labels{
@@ -104,20 +113,12 @@ class MorseView : public View {
         {4 * 8, 16},
         8,
         "Foxhunt:"};
-    OptionsField options_foxhunt{
+    NumberField field_foxhunt{
         {17 * 8, 16 + 4},
-        7,
-        {{"1 (MOE)", 0},
-         {"2 (MOI)", 1},
-         {"3 (MOS)", 2},
-         {"4 (MOH)", 3},
-         {"5 (MO5)", 4},
-         {"6 (MON)", 5},
-         {"7 (MOD)", 6},
-         {"8 (MOB)", 7},
-         {"9 (MO6)", 8},
-         {"X (MO) ", 9},
-         {"T (S) ", 10}}};
+        2,
+        {1, 11},
+        1,
+        ' '};
 
     NumberField field_speed{
         {10 * 8, 6 * 8},
@@ -136,8 +137,8 @@ class MorseView : public View {
     OptionsField options_modulation{
         {15 * 8, 10 * 8},
         2,
-        {{"CW", 0},
-         {"FM", 1}}};
+        {{"CW", true},
+         {"FM", false}}};
 
     OptionsField options_loop{
         {9 * 8, 12 * 8},

firmware/application/apps/ui_settings.cpp

@@ -343,6 +343,38 @@ void SetUIView::focus() {
     button_save.focus();
 }
 
+/* SetSDCardView *********************************************/
+
+SetSDCardView::SetSDCardView(NavigationView& nav) {
+    add_children({&labels,
+                  &checkbox_sdcard_speed,
+                  &button_test_sdcard_high_speed,
+                  &text_sdcard_test_status,
+                  &button_save,
+                  &button_cancel});
+
+    checkbox_sdcard_speed.set_value(pmem::config_sdcard_high_speed_io());
+
+    button_test_sdcard_high_speed.on_select = [&nav, this](Button&) {
+        pmem::set_config_sdcard_high_speed_io(true, false);
+        text_sdcard_test_status.set("!! HIGH SPEED MODE ON !!");
+    };
+
+    button_save.on_select = [&nav, this](Button&) {
+        pmem::set_config_sdcard_high_speed_io(checkbox_sdcard_speed.value(), true);
+        send_system_refresh();
+        nav.pop();
+    };
+
+    button_cancel.on_select = [&nav, this](Button&) {
+        nav.pop();
+    };
+}
+
+void SetSDCardView::focus() {
+    button_save.focus();
+}
+
 /* SetConverterSettingsView ******************************/
 
 SetConverterSettingsView::SetConverterSettingsView(NavigationView& nav) {
@@ -636,6 +668,7 @@ SettingsMenuView::SettingsMenuView(NavigationView& nav) {
         {"QR Code", ui::Color::dark_cyan(), &bitmap_icon_qr_code, [&nav]() { nav.push<SetQRCodeView>(); }},
         {"Radio", ui::Color::dark_cyan(), &bitmap_icon_options_radio, [&nav]() { nav.push<SetRadioView>(); }},
         {"User Interface", ui::Color::dark_cyan(), &bitmap_icon_options_ui, [&nav]() { nav.push<SetUIView>(); }},
+        {"SD Card", ui::Color::dark_cyan(), &bitmap_icon_sdcard, [&nav]() { nav.push<SetSDCardView>(); }},
     });
     set_max_rows(2);  // allow wider buttons
 }

firmware/application/apps/ui_settings.hpp

@@ -306,8 +306,43 @@ class SetUIView : public View {
 
     Button button_cancel{
         {16 * 8, 16 * 16, 12 * 8, 32},
-        "Cancel",
-    };
+        "Cancel"};
+};
+
+class SetSDCardView : public View {
+   public:
+    SetSDCardView(NavigationView& nav);
+
+    void focus() override;
+
+    std::string title() const override { return "SD Card"; };
+
+   private:
+    Labels labels{
+        // 01234567890123456789012345678
+        {{1 * 8, 120 - 48}, "    HIGH SPEED SDCARD IO     ", Color::light_grey()},
+        {{1 * 8, 120 - 32}, "   May or may not work !!    ", Color::light_grey()}};
+
+    Checkbox checkbox_sdcard_speed{
+        {2 * 8, 120},
+        20,
+        "enable high speed IO"};
+
+    Button button_test_sdcard_high_speed{
+        {2 * 8, 152, 27 * 8, 32},
+        "TEST BUTTON (NO PMEM SAVE)"};
+
+    Text text_sdcard_test_status{
+        {2 * 8, 198, 28 * 8, 16},
+        ""};
+
+    Button button_save{
+        {2 * 8, 16 * 16, 12 * 8, 32},
+        "Save"};
+
+    Button button_cancel{
+        {16 * 8, 16 * 16, 12 * 8, 32},
+        "Cancel"};
 };
 
 class SetConverterSettingsView : public View {

firmware/application/debug.cpp

@@ -258,38 +258,43 @@ void draw_stack_dump() {
     }
 }
 
-// Disk I/O in this function doesn't work after a fault
-// Using the stack while dumping the stack isn't ideal, but hopefully anything imporant is still on the call stack.
 bool stack_dump() {
+    uint32_t num_words = &__process_stack_end__ - &__process_stack_base__;
+    return memory_dump(&__process_stack_base__, num_words, true);
+}
+
+bool memory_dump(uint32_t* addr_start, uint32_t num_words, bool stack_flag) {
     Painter painter;
     std::string debug_dir = "DEBUG";
     std::filesystem::path filename{};
-    File stack_dump_file{};
+    File dump_file{};
     bool error;
     std::string str;
+    uint32_t* addr_end;
     uint32_t* p;
     int n{0};
     bool data_found{false};
 
     make_new_directory(debug_dir);
-    filename = next_filename_matching_pattern(debug_dir + "/STACK_DUMP_????.TXT");
+    filename = next_filename_matching_pattern(debug_dir + "/" + (stack_flag ? "STACK" : "MEMORY") + "_DUMP_????.TXT");
     error = filename.empty();
     if (!error)
-        error = stack_dump_file.create(filename) != 0;
+        error = dump_file.create(filename) != 0;
     if (error) {
         painter.draw_string({16, 320 - 32}, ui::Styles::red, "ERROR DUMPING " + filename.filename().string() + "!");
         return false;
     }
 
-    for (p = &__process_stack_base__; p < &__process_stack_end__; p++) {
+    addr_end = addr_start + num_words;
+    for (p = addr_start; p < addr_end; p++) {
         // skip past unused stack words
-        if (!data_found) {
+        if (stack_flag && !data_found) {
             if (*p == CRT0_STACKS_FILL_PATTERN)
                 continue;
             else {
                 data_found = true;
-                auto stack_space_left = p - &__process_stack_base__;
-                stack_dump_file.write_line(to_string_hex((uint32_t)&__process_stack_base__, 8) + ": Unused words " + to_string_dec_uint(stack_space_left));
+                auto stack_space_left = p - addr_start;
+                dump_file.write_line(to_string_hex((uint32_t)addr_start, 8) + ": Unused words " + to_string_dec_uint(stack_space_left));
 
                 // align subsequent lines to start on 16-byte boundaries
                 p -= (stack_space_left & 3);
@@ -299,20 +304,20 @@ bool stack_dump() {
         // write address
         if (n++ == 0) {
             str = to_string_hex((uint32_t)p, 8) + ":";
-            stack_dump_file.write(str.data(), 9);
+            dump_file.write(str.data(), 9);
         }
 
         // write stack dword
         str = " " + to_string_hex(*p, 8);
-        stack_dump_file.write(str.data(), 9);
+        dump_file.write(str.data(), 9);
 
         if (n == 4) {
-            stack_dump_file.write("\r\n", 2);
+            dump_file.write("\r\n", 2);
             n = 0;
         }
     }
 
-    painter.draw_string({16, 320 - 32}, ui::Styles::green, filename.filename().string() + " dumped!");
+    painter.draw_string({0, 320 - 16}, ui::Styles::green, filename.filename().string() + " dumped!");
     return true;
 }
 

firmware/application/debug.hpp

@@ -48,5 +48,6 @@ inline uint32_t get_free_stack_space() {
 }
 
 bool stack_dump();
+bool memory_dump(uint32_t* addr_start, uint32_t num_words, bool stack_flag);
 
 #endif /*__DEBUG_H__*/

firmware/application/hw/max2837.cpp

@@ -342,7 +342,7 @@ int8_t MAX2837::temp_sense() {
     _map.r.rx_top.ts_adc_trigger = 0;
     flush_one(Register::RX_TOP);
 
-    return value * 4.31 - 6;  // reg value is 0 to 31; possible return range is -6 C to 127 C
+    return std::min(127, (int)(value * 4.31 - 40));  // reg value is 0 to 31; possible return range is -40 C to 127 C
 }
 
 }  // namespace max2837

firmware/application/hw/max2839.cpp

@@ -372,7 +372,7 @@ int8_t MAX2839::temp_sense() {
     _map.r.rx_top_2.ts_adc_trigger = 0;
     flush_one(Register::RX_TOP_2);
 
-    return value * 4.31 - 75;  // reg value is 0 to 31; possible return range is -75 C to 58 C
+    return std::min(127, (int)(value * 4.31 - 40));  // reg value is 0 to 31; possible return range is -40 C to 127 C
 }
 
 }  // namespace max2839

firmware/application/radio.cpp

@@ -61,7 +61,7 @@ static constexpr SPIConfig ssp_config_max283x = {
     .ssport = gpio_max283x_select.port(),
     .sspad = gpio_max283x_select.pad(),
     .cr0 =
-        CR0_CLOCKRATE(ssp_scr(ssp1_pclk_f, ssp1_cpsr, max283x_spi_f)) | CR0_FRFSPI | CR0_DSS16BIT,
+        CR0_CLOCKRATE(ssp_scr(ssp1_pclk_f, ssp1_cpsr, max283x_spi_f) + 1) | CR0_FRFSPI | CR0_DSS16BIT,
     .cpsr = ssp1_cpsr,
 };
 

firmware/application/string_format.cpp

@@ -348,6 +348,35 @@ void generateRandomMacAddress(char* macAddress) {
     macAddress[12] = '\0';  // Null-terminate the string
 }
 
+uint64_t readUntil(File& file, char* result, std::size_t maxBufferSize, char delimiter) {
+    std::size_t bytesRead = 0;
+
+    while (true) {
+        char ch;
+        File::Result<File::Size> readResult = file.read(&ch, 1);
+
+        if (readResult.is_ok() && readResult.value() > 0) {
+            if (ch == delimiter) {
+                // Found a space character, stop reading
+                break;
+            } else if (bytesRead < maxBufferSize) {
+                // Append the character to the result if there's space
+                result[bytesRead++] = ch;
+            } else {
+                // Buffer is full, break to prevent overflow
+                break;
+            }
+        } else {
+            break;  // End of file or error
+        }
+    }
+
+    // Null-terminate the result string
+    result[bytesRead] = '\0';
+
+    return bytesRead;
+}
+
 std::string unit_auto_scale(double n, const uint32_t base_unit, uint32_t precision) {
     const uint32_t powers_of_ten[5] = {1, 10, 100, 1000, 10000};
     std::string string{""};

firmware/application/string_format.hpp

@@ -81,6 +81,8 @@ std::string to_string_mac_address(const uint8_t* macAddress, uint8_t length, boo
 std::string to_string_formatted_mac_address(const char* macAddress);
 void generateRandomMacAddress(char* macAddress);
 
+uint64_t readUntil(File& file, char* result, std::size_t maxBufferSize, char delimiter);
+
 /* Scales 'n' to be a value less than 1000. 'base_unit' is the index of the unit from
  * 'unit_prefix' that 'n' is in initially. 3 is the index of the '1s' unit. */
 std::string unit_auto_scale(double n, const uint32_t base_unit, uint32_t precision);

firmware/application/ui_navigation.cpp

@@ -171,6 +171,9 @@ SystemStatusView::SystemStatusView(
         pmem::load_persistent_settings_from_file();
     }
 
+    // force apply of selected sdcard speed override at UI startup
+    pmem::set_config_sdcard_high_speed_io(pmem::config_sdcard_high_speed_io(), false);
+
     button_back.id = -1;  // Special ID used by FocusManager
     title.set_style(&Styles::bg_dark_grey);
 

firmware/chibios/os/hal/include/hal.h

@@ -205,11 +205,12 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-  void halInit(void);
+void halInit(void);
 #if HAL_IMPLEMENTS_COUNTERS
-  bool_t halIsCounterWithin(halrtcnt_t start, halrtcnt_t end);
-  void halPolledDelay(halrtcnt_t ticks);
+bool_t halIsCounterWithin(halrtcnt_t start, halrtcnt_t end);
+void halPolledDelay(halrtcnt_t ticks);
 #endif /* HAL_IMPLEMENTS_COUNTERS */
+void sdio_cclk_set(const size_t divider_value);
 #ifdef __cplusplus
 }
 #endif

firmware/common/portapack_persistent_memory.cpp

@@ -40,6 +40,7 @@
 #include <utility>
 
 #include <ch.h>
+#include <hal.h>
 
 using namespace std;
 
@@ -143,7 +144,7 @@ struct misc_config_t {
     bool mute_audio : 1;
     bool disable_speaker : 1;
     bool config_disable_external_tcxo : 1;
-    bool UNUSED_3 : 1;
+    bool config_sdcard_high_speed_io : 1;
     bool UNUSED_4 : 1;
     bool UNUSED_5 : 1;
     bool UNUSED_6 : 1;
@@ -394,6 +395,8 @@ void defaults() {
     set_recon_update_ranges_when_recon(true);
     set_recon_load_hamradios(true);
     set_recon_match_mode(0);
+
+    set_config_sdcard_high_speed_io(false, true);
 }
 
 void init() {
@@ -581,6 +584,10 @@ bool config_disable_external_tcxo() {
     return data->misc_config.config_disable_external_tcxo;
 }
 
+bool config_sdcard_high_speed_io() {
+    return data->misc_config.config_sdcard_high_speed_io;
+}
+
 bool stealth_mode() {
     return data->ui_config.stealth_mode;
 }
@@ -646,6 +653,19 @@ void set_config_disable_external_tcxo(bool v) {
     data->misc_config.config_disable_external_tcxo = v;
 }
 
+void set_config_sdcard_high_speed_io(bool v, bool save) {
+    if (v) {
+        /* 200MHz / (2 * 2) = 50MHz */
+        /* TODO: Adjust SCU pin configurations: pull-up/down, slew, glitch filter? */
+        sdio_cclk_set(2);
+    } else {
+        /* 200MHz / (2 * 4) = 25MHz */
+        sdio_cclk_set(4);
+    }
+    if (save)
+        data->misc_config.config_sdcard_high_speed_io = v;
+}
+
 void set_stealth_mode(bool v) {
     data->ui_config.stealth_mode = v;
 }
@@ -1015,6 +1035,7 @@ bool debug_dump() {
     pmem_dump_file.write_line("misc_config config_audio_mute: " + to_string_dec_int(config_audio_mute()));
     pmem_dump_file.write_line("misc_config config_speaker_disable: " + to_string_dec_int(config_speaker_disable()));
     pmem_dump_file.write_line("ui_config config_disable_external_tcxo: " + to_string_dec_uint(config_disable_external_tcxo()));
+    pmem_dump_file.write_line("ui_config config_sdcard_high_speed_io: " + to_string_dec_uint(config_sdcard_high_speed_io()));
 
     // receiver_model
     pmem_dump_file.write_line("\n[Receiver Model]");

firmware/common/portapack_persistent_memory.hpp

@@ -174,6 +174,7 @@ uint8_t config_cpld();
 void set_config_cpld(uint8_t i);
 
 bool config_disable_external_tcxo();
+bool config_sdcard_high_speed_io();
 bool config_splash();
 bool config_converter();
 bool config_updown_converter();
@@ -193,6 +194,7 @@ void set_load_app_settings(bool v);
 void set_save_app_settings(bool v);
 void set_show_bigger_qr_code(bool v);
 void set_config_disable_external_tcxo(bool v);
+void set_config_sdcard_high_speed_io(bool v, bool save);
 void set_config_splash(bool v);
 bool config_converter();
 bool config_updown_converter();

firmware/common/ui_focus.cpp

@@ -30,6 +30,8 @@
 #include <utility>
 #include <vector>
 
+#define pow2(x) ((x) * (x))
+
 namespace ui {
 
 Widget* FocusManager::focus_widget() const {
@@ -138,12 +140,12 @@ static int32_t rect_distances(
     switch (direction) {
         case KeyEvent::Right:
         case KeyEvent::Left:
-            return ((std::abs(perpendicular_axis_end - perpendicular_axis_start) + 1) ^ 3) * sqrt((on_axis_distance + 1));
+            return pow2(std::abs(perpendicular_axis_end - perpendicular_axis_start) + 1) * (on_axis_distance + 1);
             break;
 
         case KeyEvent::Up:
         case KeyEvent::Down:
-            return (sqrt(std::abs(perpendicular_axis_end - perpendicular_axis_start) + 1)) * ((on_axis_distance + 1) ^ 3);
+            return (std::abs(perpendicular_axis_end - perpendicular_axis_start) + 1) * pow2(on_axis_distance + 1);
             break;
 
         default: