V1.9.0 (#1660)

* Update version.txt

* Update past_version.txt

.github/workflows/past_version.txt

@@ -1 +1 @@
-v1.7.4
+v1.8.0

.github/workflows/version.txt

@@ -1 +1 @@
-v1.8.0
+v1.9.0

firmware/application/CMakeLists.txt

@@ -204,6 +204,7 @@ set(CPPSRC
 	portapack.cpp
 	usb_serial_shell.cpp
 	usb_serial_event.cpp
+	usb_serial_thread.cpp
 	usb_serial.cpp
 	qrcodegen.cpp
 	radio.cpp

firmware/application/apps/ble_rx_app.cpp

@@ -436,6 +436,8 @@ BLERxView::BLERxView(NavigationView& nav)
         nav_.push<BleRecentEntryDetailView>(entry);
     };
 
+    usb_serial_thread = std::make_unique<UsbSerialThread>();
+
     ensure_directory(find_packet_path);
     ensure_directory(log_packets_path);
     ensure_directory(packet_save_path);
@@ -684,24 +686,16 @@ bool BLERxView::saveFile(const std::filesystem::path& path) {
 }
 
 void BLERxView::on_data(BlePacketData* packet) {
-    std::string str_console = "";
-
     if (!logging) {
         str_log = "";
     }
 
     str_console += pdu_type_to_string((ADV_PDU_TYPE)packet->type);
-
     str_console += " Len:";
     str_console += to_string_dec_uint(packet->size);
-
-    str_console += "\n";
-
-    str_console += "Mac:";
+    str_console += " Mac:";
     str_console += to_string_mac_address(packet->macAddress, 6, false);
-
-    str_console += "\n";
-    str_console += "Data:";
+    str_console += " Data:";
 
     int i;
 
@@ -709,8 +703,6 @@ void BLERxView::on_data(BlePacketData* packet) {
         str_console += to_string_hex(packet->data[i], 2);
     }
 
-    str_console += "\n";
-
     uint64_t macAddressEncoded = copy_mac_address_to_uint64(packet->macAddress);
 
     // Start of Packet stuffing.
@@ -728,9 +720,13 @@ void BLERxView::on_data(BlePacketData* packet) {
 
     // Log at End of Packet.
     if (logger && logging) {
-        logger->log_raw_data(str_console);
+        logger->log_raw_data(str_console + "\r\n");
     }
 
+    usb_serial_thread->serial_str = str_console + "\r\n";
+    usb_serial_thread->str_ready = true;
+    str_console = "";
+
     if (!searchList.empty()) {
         auto it = searchList.begin();
 

firmware/application/apps/ble_rx_app.hpp

@@ -35,6 +35,7 @@
 #include "radio_state.hpp"
 #include "log_file.hpp"
 #include "utility.hpp"
+#include "usb_serial_thread.hpp"
 
 #include "recent_entries.hpp"
 
@@ -194,6 +195,7 @@ class BLERxView : public View {
     std::string build_line_str(BleRecentEntry entry);
     void on_save_file(const std::string value);
     bool saveFile(const std::filesystem::path& path);
+    std::unique_ptr<UsbSerialThread> usb_serial_thread{};
     void on_data(BlePacketData* packetData);
     void on_filter_change(std::string value);
     void on_file_changed(const std::filesystem::path& new_file_path);
@@ -213,6 +215,7 @@ class BLERxView : public View {
     uint8_t sort_index{0};
     std::string filter{};
     bool logging{false};
+
     bool name_enable{true};
     app_settings::SettingsManager settings_{
         "rx_ble",
@@ -225,6 +228,7 @@ class BLERxView : public View {
             {"name"sv, &name_enable},
         }};
 
+    std::string str_console = "";
     uint8_t console_color{0};
     uint32_t prev_value{0};
     uint8_t channel_number = 37;

firmware/application/apps/ui_subghzd.cpp

@@ -88,8 +88,7 @@ SubGhzDView::SubGhzDView(NavigationView& nav)
     recent_entries_view.on_select = [this](const SubGhzDRecentEntry& entry) {
         nav_.push<SubGhzDRecentEntryDetailView>(entry);
     };
-    baseband::set_subghzd(0);  // am
-    receiver_model.set_sampling_rate(4'000'000);
+    baseband::set_subghzd_config(0, receiver_model.sampling_rate());  // 0=am
     receiver_model.enable();
     signal_token_tick_second = rtc_time::signal_tick_second += [this]() {
         on_tick_second();

firmware/application/apps/ui_weatherstation.cpp

@@ -115,8 +115,7 @@ WeatherView::WeatherView(NavigationView& nav)
     recent_entries_view.on_select = [this](const WeatherRecentEntry& entry) {
         nav_.push<WeatherRecentEntryDetailView>(entry);
     };
-    baseband::set_weather();
-    receiver_model.set_sampling_rate(4'000'000);  // needed too
+    baseband::set_subghzd_config(0, receiver_model.sampling_rate());  // 0=am
     receiver_model.enable();
     signal_token_tick_second = rtc_time::signal_tick_second += [this]() {
         on_tick_second();
@@ -233,4 +232,4 @@ void RecentEntriesTable<ui::WeatherRecentEntries>::draw(
     painter.draw_string(target_rect.location(), style, line);
 }
 
-}  // namespace ui
+}  // namespace ui

firmware/application/apps/ui_weatherstation.hpp

@@ -100,8 +100,8 @@ class WeatherView : public View {
     NavigationView& nav_;
     RxRadioState radio_state_{
         433'920'000 /* frequency */,
-        2'500'000 /* bandwidth max283x*/,
-        4'000'000 /* sampling rate */,
+        1'750'000 /* bandwidth */,
+        2'000'000 /* sampling rate */,
         ReceiverModel::Mode::AMAudio};
     app_settings::SettingsManager settings_{
         "rx_weather",

firmware/application/baseband_api.cpp

@@ -319,13 +319,8 @@ void set_spectrum_painter_config(const uint16_t width, const uint16_t height, bo
     send_message(&message);
 }
 
-void set_weather() {
-    const SubGhzFPRxConfigureMessage message{0};
-    send_message(&message);
-}
-
-void set_subghzd(uint8_t modulation = 0) {
-    const SubGhzFPRxConfigureMessage message{modulation};
+void set_subghzd_config(uint8_t modulation = 0, uint32_t sampling_rate = 0) {
+    const SubGhzFPRxConfigureMessage message{modulation, sampling_rate};
     send_message(&message);
 }
 

firmware/application/baseband_api.hpp

@@ -88,8 +88,7 @@ void set_spectrum(const size_t sampling_rate, const size_t trigger);
 void set_siggen_tone(const uint32_t tone);
 void set_siggen_config(const uint32_t bw, const uint32_t shape, const uint32_t duration);
 void set_spectrum_painter_config(const uint16_t width, const uint16_t height, bool update, int32_t bw);
-void set_weather();
-void set_subghzd(uint8_t modulation);
+void set_subghzd_config(uint8_t modulation, uint32_t sampling_rate);
 void request_beep();
 
 void run_image(const portapack::spi_flash::image_tag_t image_tag);

firmware/application/usb_serial_cdc.c

@@ -115,11 +115,11 @@ usb_request_status_t usb_get_line_coding_request(usb_endpoint_t* const endpoint,
 }
 usb_request_status_t usb_set_control_line_state_request(usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage) {
     if (stage == USB_TRANSFER_STAGE_SETUP) {
-        if (endpoint->setup.value == 3) {
-            on_channel_opened();
-        } else {
-            on_channel_closed();
-        }
+        // if (endpoint->setup.value == 3) {
+        on_channel_opened();
+        //} else {
+        //    on_channel_closed();
+        //}
 
         usb_transfer_schedule_ack(endpoint->in);
     }

firmware/application/usb_serial_io.c

@@ -73,10 +73,12 @@ void serial_bulk_transfer_complete(void* user_data, unsigned int bytes_transferr
 
 static void onotify(GenericQueue* qp) {
     SerialUSBDriver* sdp = chQGetLink(qp);
+    uint8_t buff[64];
     int n = chOQGetFullI(&sdp->oqueue);
+    if (n > 64) n = 64;  // don't overflow
     if (n > 0) {
         for (int i = 0; i < n; i++) {
-            usb_endpoint_bulk_in.buffer[i] = chOQGetI(&sdp->oqueue);
+            buff[i] = chOQGetI(&sdp->oqueue);
         }
 
         int ret;
@@ -84,7 +86,7 @@ static void onotify(GenericQueue* qp) {
         do {
             ret = usb_transfer_schedule(
                 &usb_endpoint_bulk_in,
-                &usb_endpoint_bulk_in.buffer[0],
+                &buff[0],
                 n,
                 NULL,
                 NULL);

firmware/application/usb_serial_shell.cpp

@@ -30,6 +30,7 @@
 #include "usb_serial_io.h"
 #include "ff.h"
 #include "chprintf.h"
+#include "chqueues.h"
 
 #include <string>
 #include <codecvt>
@@ -39,6 +40,45 @@
 #define SHELL_WA_SIZE THD_WA_SIZE(1024 * 3)
 #define palOutputPad(port, pad) (LPC_GPIO->DIR[(port)] |= 1 << (pad))
 
+// queue handler from ch
+static msg_t qwait(GenericQueue* qp, systime_t time) {
+    if (TIME_IMMEDIATE == time)
+        return Q_TIMEOUT;
+    currp->p_u.wtobjp = qp;
+    queue_insert(currp, &qp->q_waiting);
+    return chSchGoSleepTimeoutS(THD_STATE_WTQUEUE, time);
+}
+
+// This function fills the output buffer, and sends all data in 1 packet
+static size_t fillOBuffer(OutputQueue* oqp, const uint8_t* bp, size_t n) {
+    qnotify_t nfy = oqp->q_notify;
+    size_t w = 0;
+
+    chDbgCheck(n > 0, "chOQWriteTimeout");
+    chSysLock();
+    while (TRUE) {
+        while (chOQIsFullI(oqp)) {
+            if (qwait((GenericQueue*)oqp, TIME_INFINITE) != Q_OK) {
+                chSysUnlock();
+                return w;
+            }
+        }
+        while (!chOQIsFullI(oqp) && n > 0) {
+            oqp->q_counter--;
+            *oqp->q_wrptr++ = *bp++;
+            if (oqp->q_wrptr >= oqp->q_top)
+                oqp->q_wrptr = oqp->q_buffer;
+            w++;
+            --n;
+        }
+        if (nfy) nfy(oqp);
+
+        chSysUnlock(); /* Gives a preemption chance in a controlled point.*/
+        if (n == 0) return w;
+        chSysLock();
+    }
+}
+
 static void cmd_reboot(BaseSequentialStream* chp, int argc, char* argv[]) {
     (void)chp;
     (void)argc;
@@ -152,6 +192,53 @@ static void cmd_screenshot(BaseSequentialStream* chp, int argc, char* argv[]) {
     chprintf(chp, "generated %s\r\n", path.string().c_str());
 }
 
+// gives full color.
+static void cmd_screenframe(BaseSequentialStream* chp, int argc, char* argv[]) {
+    (void)argc;
+    (void)argv;
+
+    for (int i = 0; i < ui::screen_height; i++) {
+        std::array<ui::ColorRGB888, ui::screen_width> row;
+        portapack::display.read_pixels({0, i, ui::screen_width, 1}, row);
+        for (int px = 0; px < ui::screen_width; px += 5) {
+            char buffer[5 * 3 * 2];
+            sprintf(buffer, "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", row[px].r, row[px].g, row[px].b, row[px + 1].r, row[px + 1].g, row[px + 1].b, row[px + 2].r, row[px + 2].g, row[px + 2].b, row[px + 3].r, row[px + 3].g, row[px + 3].b, row[px + 4].r, row[px + 4].g, row[px + 4].b);
+            fillOBuffer(&((SerialUSBDriver*)chp)->oqueue, (const uint8_t*)buffer, 5 * 3 * 2);
+        }
+        chprintf(chp, "\r\n");
+    }
+    chprintf(chp, "ok\r\n");
+}
+
+static char getChrFromRgb(uint8_t r, uint8_t g, uint8_t b) {
+    uint8_t chR = r >> 6;  // 3bit
+    uint8_t chG = g >> 6;  // 3bit
+    uint8_t chB = b >> 6;  // 3bit
+    uint8_t res = chR << 4 | chG << 2 | chB;
+    res += 32;
+    return res;
+}
+
+// sends only 1 byte (printable only) per pixel, so around 96 colors
+static void cmd_screenframeshort(BaseSequentialStream* chp, int argc, char* argv[]) {
+    (void)argc;
+    (void)argv;
+
+    for (int y = 0; y < ui::screen_height; y++) {
+        std::array<ui::ColorRGB888, ui::screen_width> row;
+        portapack::display.read_pixels({0, y, ui::screen_width, 1}, row);
+        for (int px = 0; px < ui::screen_width; px += 60) {
+            char buffer[60];
+            for (int i = 0; i < 60; ++i) {
+                buffer[i] = getChrFromRgb(row[px + i].r, row[px + i].g, row[px + i].b);
+            }
+            fillOBuffer(&((SerialUSBDriver*)chp)->oqueue, (const uint8_t*)buffer, 60);
+        }
+        chprintf(chp, "\r\n");
+    }
+
+    chprintf(chp, "ok\r\n");
+}
 static void cmd_write_memory(BaseSequentialStream* chp, int argc, char* argv[]) {
     if (argc != 2) {
         chprintf(chp, "usage: write_memory <address> <value (1 or 4 bytes)>\r\n");
@@ -248,6 +335,22 @@ static void cmd_sd_delete(BaseSequentialStream* chp, int argc, char* argv[]) {
 
 File* shell_file = nullptr;
 
+static void cmd_sd_filesize(BaseSequentialStream* chp, int argc, char* argv[]) {
+    if (argc != 1) {
+        chprintf(chp, "usage: filesize <path>\r\n");
+        return;
+    }
+    auto path = path_from_string8(argv[0]);
+    FILINFO res;
+    auto stat = f_stat(path.tchar(), &res);
+    if (stat == FR_OK) {
+        chprintf(chp, "%lu\r\n", res.fsize);
+        chprintf(chp, "ok\r\n");
+    } else {
+        chprintf(chp, "error\r\n");
+    }
+}
+
 static void cmd_sd_open(BaseSequentialStream* chp, int argc, char* argv[]) {
     if (argc != 1) {
         chprintf(chp, "usage: open <path>\r\n");
@@ -335,6 +438,7 @@ static void cmd_sd_read(BaseSequentialStream* chp, int argc, char* argv[]) {
 
         size -= bytes_to_read;
     } while (size > 0);
+    chprintf(chp, "ok\r\n");
 }
 
 static void cmd_sd_write(BaseSequentialStream* chp, int argc, char* argv[]) {
@@ -382,6 +486,8 @@ static const ShellCommand commands[] = {
     {"sd_over_usb", cmd_sd_over_usb},
     {"flash", cmd_flash},
     {"screenshot", cmd_screenshot},
+    {"screenframe", cmd_screenframe},
+    {"screenframeshort", cmd_screenframeshort},
     {"write_memory", cmd_write_memory},
     {"read_memory", cmd_read_memory},
     {"button", cmd_button},
@@ -392,6 +498,7 @@ static const ShellCommand commands[] = {
     {"close", cmd_sd_close},
     {"read", cmd_sd_read},
     {"write", cmd_sd_write},
+    {"filesize", cmd_sd_filesize},
     {NULL, NULL}};
 
 static const ShellConfig shell_cfg1 = {

firmware/application/usb_serial_thread.cpp

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2016 Jared Boone, ShareBrained Technology, Inc.
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "usb_serial_thread.hpp"
+#include "buffer_exchange.hpp"
+
+// UsbSerialThread //////////////////////////////////////////////////////////
+
+UsbSerialThread::UsbSerialThread() {
+    create_thread();
+}
+
+UsbSerialThread::~UsbSerialThread() {
+    stop();
+}
+
+void UsbSerialThread::create_thread() {
+    thread = chThdCreateFromHeap(NULL, 1024, NORMALPRIO + 10, UsbSerialThread::static_fn, this);
+}
+
+void UsbSerialThread::stop() {
+    if (thread) {
+        chThdTerminate(thread);
+        chThdWait(thread);
+        thread = nullptr;
+    }
+}
+
+msg_t UsbSerialThread::static_fn(void* arg) {
+    auto obj = static_cast<UsbSerialThread*>(arg);
+    obj->run();
+    return 0;
+}
+
+void UsbSerialThread::run() {
+    while (!chThdShouldTerminate()) {
+        if (str_ready) {
+            str_ready = false;
+            chprintf((BaseSequentialStream*)&SUSBD1, serial_str.c_str());
+        }
+
+        chThdSleepMilliseconds(50);
+    }
+}

firmware/application/usb_serial_thread.hpp

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2016 Jared Boone, ShareBrained Technology, Inc.
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __USB_SERIAL_THREAD_H__
+#define __USB_SERIAL_THREAD_H__
+
+#include "ch.h"
+
+#include "event_m0.hpp"
+
+#include "io.hpp"
+#include "optional.hpp"
+
+#include "chprintf.h"
+#include "usb_serial_io.h"
+
+#include <cstdint>
+#include <cstddef>
+#include <utility>
+
+class UsbSerialThread {
+   public:
+    UsbSerialThread();
+    ~UsbSerialThread();
+
+    void stop();
+
+    UsbSerialThread(const UsbSerialThread&) = delete;
+    UsbSerialThread(UsbSerialThread&&) = delete;
+    UsbSerialThread& operator=(const UsbSerialThread&) = delete;
+    UsbSerialThread& operator=(UsbSerialThread&&) = delete;
+    bool str_ready = false;
+    std::string serial_str{};
+
+   private:
+    Thread* thread{nullptr};
+    static msg_t static_fn(void* arg);
+    void run();
+    void create_thread();
+};
+
+#endif /*__CAPTURE_THREAD_H__*/

firmware/baseband/proc_subghzd.cpp

@@ -47,7 +47,7 @@ void SubGhzDProcessor::execute(const buffer_c8_t& buffer) {
         tm += mag;
         if (meashl == currentHiLow && currentDuration < 30'000'000)  // allow pass 'end' signal
         {
-            if (currentDuration < UINT32_MAX) currentDuration += nsPerDecSamp;
+            currentDuration += nsPerDecSamp;
         } else {  // called on change, so send the last duration and dir.
             if (protoList) protoList->feed(currentHiLow, currentDuration / 1000);
             currentDuration = nsPerDecSamp;
@@ -73,7 +73,12 @@ void SubGhzDProcessor::on_message(const Message* const message) {
 void SubGhzDProcessor::configure(const SubGhzFPRxConfigureMessage& message) {
     // constexpr size_t decim_0_output_fs = baseband_fs / decim_0.decimation_factor; //unused
     // constexpr size_t decim_1_output_fs = decim_0_output_fs / decim_1.decimation_factor; //unused
-    (void)message;  // unused
+
+    modulation = message.modulation;  // TODO: add support for FM (currently AM only)
+
+    baseband_fs = message.sampling_rate;
+    baseband_thread.set_sampling_rate(baseband_fs);
+    nsPerDecSamp = 1'000'000'000 / baseband_fs * 8;  // Scaled it due to less array buffer sampes due to /8 decimation.  250 nseg (4Mhz) * 8
 
     decim_0.configure(taps_200k_wfm_decim_0.taps);
     decim_1.configure(taps_200k_wfm_decim_1.taps);

firmware/baseband/proc_subghzd.hpp

@@ -40,8 +40,9 @@ class SubGhzDProcessor : public BasebandProcessor {
     void on_message(const Message* const message) override;
 
    private:
-    static constexpr size_t baseband_fs = 4'000'000;                           // it works, I think we need to write that master clock in the baseband_threat , even later we decimate it.
-    static constexpr uint32_t nsPerDecSamp = 1'000'000'000 / baseband_fs * 8;  // 10 exp9/baseband_fs * 8
+    size_t baseband_fs = 0;  // will be set later by configure message
+    uint32_t nsPerDecSamp = 0;
+    uint8_t modulation = 0;
 
     /* Array Buffer aux. used in decim0 and decim1 IQ c16 signed  data ; (decim0 defines the max length of the array) */
     std::array<complex16_t, 512> dst{};  // decim0 /4 ,  2048/4 = 512 complex I,Q

firmware/baseband/proc_weather.cpp

@@ -47,7 +47,7 @@ void WeatherProcessor::execute(const buffer_c8_t& buffer) {
         tm += mag;
         if (meashl == currentHiLow && currentDuration < 30'000'000)  // allow pass 'end' signal
         {
-            if (currentDuration < UINT32_MAX) currentDuration += nsPerDecSamp;
+            currentDuration += nsPerDecSamp;
         } else {  // called on change, so send the last duration and dir.
             if (protoList) protoList->feed(currentHiLow, currentDuration / 1000);
             currentDuration = nsPerDecSamp;
@@ -71,9 +71,12 @@ void WeatherProcessor::on_message(const Message* const message) {
 }
 
 void WeatherProcessor::configure(const SubGhzFPRxConfigureMessage& message) {
+    baseband_fs = message.sampling_rate;
+    baseband_thread.set_sampling_rate(baseband_fs);
+    nsPerDecSamp = 1'000'000'000 / baseband_fs * 8;  // Scaled it due to less array buffer sampes due to /8 decimation.  250 nseg (4Mhz) * 8
+
     // constexpr size_t decim_0_output_fs = baseband_fs / decim_0.decimation_factor; //unused
     // constexpr size_t decim_1_output_fs = decim_0_output_fs / decim_1.decimation_factor; //unused
-    (void)message;  // unused
 
     decim_0.configure(taps_200k_wfm_decim_0.taps);
     decim_1.configure(taps_200k_wfm_decim_1.taps);

firmware/baseband/proc_weather.hpp

@@ -40,8 +40,8 @@ class WeatherProcessor : public BasebandProcessor {
     void on_message(const Message* const message) override;
 
    private:
-    static constexpr size_t baseband_fs = 4'000'000;                           // it works, I think we need to write that master clock in the baseband_threat , even later we decimate it.
-    static constexpr uint32_t nsPerDecSamp = 1'000'000'000 / baseband_fs * 8;  // Scaled it due to less array buffer sampes due to /8 decimation.  250 nseg (4Mhz) * 8
+    size_t baseband_fs = 0;  // will be set later by configure message.
+    uint32_t nsPerDecSamp = 0;
 
     /* Array Buffer aux. used in decim0 and decim1 IQ c16 signed  data ; (decim0 defines the max length of the array) */
     std::array<complex16_t, 512> dst{};  // decim0 /4 ,  2048/4 = 512 complex I,Q

firmware/common/message.hpp

@@ -1241,10 +1241,11 @@ class SpectrumPainterBufferConfigureResponseMessage : public Message {
 
 class SubGhzFPRxConfigureMessage : public Message {
    public:
-    constexpr SubGhzFPRxConfigureMessage(uint8_t modulation = 0)
-        : Message{ID::SubGhzFPRxConfigure}, modulation{modulation} {
+    constexpr SubGhzFPRxConfigureMessage(uint8_t modulation = 0, uint32_t sampling_rate = 0)
+        : Message{ID::SubGhzFPRxConfigure}, modulation{modulation}, sampling_rate{sampling_rate} {
     }
     uint8_t modulation = 0;  // 0 am, 1 fm
+    uint32_t sampling_rate = 0;
 };
 
 class WeatherDataMessage : public Message {

firmware/common/ui_widget.cpp

@@ -28,8 +28,10 @@
 #include <cstddef>
 #include <algorithm>
 
+#include "chprintf.h"
 #include "irq_controls.hpp"
 #include "string_format.hpp"
+#include "usb_serial_io.h"
 
 using namespace portapack;