mirror of
https://github.com/portapack-mayhem/mayhem-firmware.git
synced 2026-08-08 00:43:49 +00:00
Totoo
2716 lines
92 KiB
C++
2716 lines
92 KiB
C++
/*
|
||
* Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
|
||
* Copyright (C) 2024 Mark Thompson
|
||
* Copyright (C) 2024 u-foka
|
||
*
|
||
* 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 "ui_debug.hpp"
|
||
#include "debug.hpp"
|
||
|
||
#include "ch.h"
|
||
#include "hal.h"
|
||
|
||
#include "radio.hpp"
|
||
#include "string_format.hpp"
|
||
#include "crc.hpp"
|
||
|
||
#include "audio.hpp"
|
||
|
||
#include "ui_sd_card_debug.hpp"
|
||
#include "ui_font_fixed_8x16.hpp"
|
||
#include "ui_painter.hpp"
|
||
#include "ui_external_items_menu_loader.hpp"
|
||
#include "ui_debug_max17055.hpp"
|
||
#include "ui_external_module_view.hpp"
|
||
|
||
#include "portapack.hpp"
|
||
#include "portapack_persistent_memory.hpp"
|
||
using namespace portapack;
|
||
|
||
#include "irq_controls.hpp"
|
||
|
||
namespace ui {
|
||
|
||
/* DebugMemoryView *******************************************************/
|
||
|
||
DebugMemoryView::DebugMemoryView(NavigationView& nav) {
|
||
add_children({&text_title,
|
||
&text_label_m0_core_free,
|
||
&text_label_m0_core_free_value,
|
||
&text_label_m0_heap_fragmented_free,
|
||
&text_label_m0_heap_fragmented_free_value,
|
||
&text_label_m0_heap_fragments,
|
||
&text_label_m0_heap_fragments_value,
|
||
&button_done});
|
||
|
||
const auto m0_core_free = chCoreStatus();
|
||
text_label_m0_core_free_value.set(to_string_dec_uint(m0_core_free, 5));
|
||
|
||
size_t m0_fragmented_free_space = 0;
|
||
const auto m0_fragments = chHeapStatus(NULL, &m0_fragmented_free_space);
|
||
text_label_m0_heap_fragmented_free_value.set(to_string_dec_uint(m0_fragmented_free_space, 5));
|
||
text_label_m0_heap_fragments_value.set(to_string_dec_uint(m0_fragments, 5));
|
||
|
||
button_done.on_select = [&nav](Button&) { nav.pop(); };
|
||
}
|
||
|
||
void DebugMemoryView::focus() {
|
||
button_done.focus();
|
||
}
|
||
|
||
/* RegistersWidget *******************************************************/
|
||
|
||
RegistersWidget::RegistersWidget(
|
||
RegistersWidgetConfig&& config)
|
||
: Widget{}, config(std::move(config)), page_number(0) {
|
||
}
|
||
|
||
void RegistersWidget::update() {
|
||
set_dirty();
|
||
}
|
||
|
||
void RegistersWidget::paint(Painter& painter) {
|
||
const Coord left = (size().width() - config.row_width()) / 2;
|
||
|
||
draw_legend(left, painter);
|
||
draw_values(left, painter);
|
||
}
|
||
|
||
void RegistersWidget::draw_legend(const Coord left, Painter& painter) {
|
||
const auto pos = screen_pos();
|
||
const std::string spaces(config.legend_length(), ' ');
|
||
|
||
for (uint32_t i = 0; i < config.registers_per_page; i += config.registers_per_row()) {
|
||
uint32_t r = page_number * config.registers_per_page + i;
|
||
|
||
const Point offset{
|
||
left, static_cast<int>((i / config.registers_per_row()) * row_height)};
|
||
|
||
const auto text = (r >= config.registers_count) ? spaces : to_string_hex(r, config.legend_length());
|
||
painter.draw_string(
|
||
pos + offset,
|
||
style().invert(),
|
||
text);
|
||
}
|
||
}
|
||
|
||
void RegistersWidget::draw_values(
|
||
const Coord left,
|
||
Painter& painter) {
|
||
const auto pos = screen_pos();
|
||
const std::string spaces(config.value_length(), ' ');
|
||
|
||
for (uint32_t i = 0; i < config.registers_per_page; i++) {
|
||
uint32_t r = page_number * config.registers_per_page + i;
|
||
|
||
const Point offset = {
|
||
static_cast<int>(left + config.legend_width() + 8 + (i % config.registers_per_row()) * (config.value_width() + 8)),
|
||
static_cast<int>((i / config.registers_per_row()) * row_height)};
|
||
|
||
const auto text = (r >= config.registers_count) ? spaces : to_string_hex(reg_read(r), config.value_length());
|
||
painter.draw_string(
|
||
pos + offset,
|
||
style(),
|
||
text);
|
||
}
|
||
}
|
||
|
||
uint32_t RegistersWidget::reg_read(const uint32_t register_number) {
|
||
if (register_number < config.registers_count) {
|
||
switch (config.chip_type) {
|
||
case CT_PMEM:
|
||
return portapack::persistent_memory::pmem_data_word(register_number / 4) >> (register_number % 4 * 8);
|
||
case CT_RFFC5072:
|
||
return radio::debug::first_if::register_read(register_number);
|
||
case CT_MAX283X:
|
||
return radio::debug::second_if::register_read(register_number);
|
||
case CT_SI5351:
|
||
return portapack::clock_generator.read_register(register_number);
|
||
case CT_MAX17055: {
|
||
i2cdev::I2cDev_MAX17055* dev = (i2cdev::I2cDev_MAX17055*)i2cdev::I2CDevManager::get_dev_by_model(I2C_DEVMDL::I2CDEVMDL_MAX17055);
|
||
return dev->read_register(register_number);
|
||
}
|
||
case CT_AUDIO:
|
||
return audio::debug::reg_read(register_number);
|
||
#ifdef PRALINE
|
||
case CT_FPGA:
|
||
return radio::debug::fpga::register_read(register_number);
|
||
#endif
|
||
case CT_SGPIO:
|
||
return radio::debug::sgpio::register_read(register_number);
|
||
}
|
||
}
|
||
return 0xFFFF;
|
||
}
|
||
|
||
void RegistersWidget::reg_write(const uint32_t register_number, const uint32_t value) {
|
||
if (register_number < config.registers_count) {
|
||
switch (config.chip_type) {
|
||
case CT_PMEM:
|
||
break;
|
||
case CT_RFFC5072:
|
||
radio::debug::first_if::register_write(register_number, value);
|
||
break;
|
||
case CT_MAX283X:
|
||
radio::debug::second_if::register_write(register_number, value);
|
||
break;
|
||
case CT_SI5351:
|
||
portapack::clock_generator.write_register(register_number, value);
|
||
break;
|
||
case CT_MAX17055: {
|
||
i2cdev::I2cDev_MAX17055* dev = (i2cdev::I2cDev_MAX17055*)i2cdev::I2CDevManager::get_dev_by_model(I2C_DEVMDL::I2CDEVMDL_MAX17055);
|
||
dev->write_register(register_number, value);
|
||
break;
|
||
}
|
||
case CT_AUDIO:
|
||
audio::debug::reg_write(register_number, value);
|
||
break;
|
||
#ifdef PRALINE
|
||
case CT_FPGA:
|
||
radio::debug::fpga::register_write(register_number, value);
|
||
break;
|
||
#endif
|
||
case CT_SGPIO:
|
||
// SGPIO registers are read-only for debug purposes
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* RegistersView *********************************************************/
|
||
|
||
RegistersView::RegistersView(
|
||
NavigationView& nav,
|
||
const std::string& title,
|
||
RegistersWidgetConfig&& config)
|
||
: registers_widget{std::move(config)} {
|
||
add_children({
|
||
&text_title,
|
||
®isters_widget,
|
||
&button_update,
|
||
&button_done,
|
||
&labels,
|
||
&field_write_reg_num,
|
||
&field_write_data_val,
|
||
&button_write,
|
||
});
|
||
|
||
button_update.on_select = [this](Button&) {
|
||
this->registers_widget.update();
|
||
};
|
||
button_done.on_select = [&nav](Button&) { nav.pop(); };
|
||
|
||
registers_widget.set_parent_rect({0, 48, screen_width, 192});
|
||
registers_widget.set_page(0);
|
||
|
||
text_title.set_parent_rect({(screen_width - static_cast<int>(title.size()) * 8) / 2, 16,
|
||
static_cast<int>(title.size()) * 8, 16});
|
||
text_title.set(title);
|
||
|
||
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();
|
||
};
|
||
|
||
const auto value = registers_widget.reg_read(0);
|
||
field_write_data_val.set_value(value);
|
||
|
||
button_write.set_style(Theme::getInstance()->fg_red);
|
||
button_write.on_select = [this](Button&) {
|
||
this->registers_widget.reg_write(field_write_reg_num.to_integer(), field_write_data_val.to_integer());
|
||
this->registers_widget.update();
|
||
};
|
||
}
|
||
|
||
void RegistersView::focus() {
|
||
button_done.focus();
|
||
}
|
||
|
||
bool RegistersView::on_encoder(const EncoderEvent delta) {
|
||
registers_widget.set_page(std::max(0ul, std::min(registers_widget.page_count() - 1, registers_widget.page() + delta)));
|
||
registers_widget.update();
|
||
|
||
return true;
|
||
}
|
||
|
||
/* ControlsSwitchesWidget ************************************************/
|
||
|
||
void ControlsSwitchesWidget::on_show() {
|
||
display.fill_rectangle(
|
||
screen_rect(),
|
||
Theme::getInstance()->bg_darkest->background);
|
||
}
|
||
|
||
bool ControlsSwitchesWidget::on_key(const KeyEvent key) {
|
||
key_event_mask = 1 << toUType(key);
|
||
long_press_key_event_mask = key_is_long_pressed(key) ? key_event_mask : 0;
|
||
return true;
|
||
}
|
||
|
||
bool ControlsSwitchesWidget::on_encoder(const EncoderEvent delta) {
|
||
last_delta = delta;
|
||
return true;
|
||
}
|
||
|
||
void ControlsSwitchesWidget::paint(Painter& painter) {
|
||
const auto pos = screen_pos();
|
||
|
||
const std::array<Rect, 9> button_rects{{
|
||
{64, 32, 16, 16}, // Right
|
||
{0, 32, 16, 16}, // Left
|
||
{32, 64, 16, 16}, // Down
|
||
{32, 0, 16, 16}, // Up
|
||
{32, 32, 16, 16}, // Select
|
||
{96, 0, 16, 16}, // Dfu
|
||
{16, 96, 16, 16}, // Encoder phase 0
|
||
{48, 96, 16, 16}, // Encoder phase 1
|
||
{96, 64, 16, 16}, // Touch
|
||
}};
|
||
|
||
for (const auto r : button_rects) {
|
||
painter.fill_rectangle(r + pos, Theme::getInstance()->fg_blue->foreground);
|
||
}
|
||
|
||
if (get_touch_frame().touch)
|
||
painter.fill_rectangle(button_rects[8] + pos, Theme::getInstance()->fg_yellow->foreground);
|
||
|
||
const std::array<Rect, 8> raw_rects{{
|
||
{64 + 1, 32 + 1, 16 - 2, 16 - 2}, // Right
|
||
{0 + 1, 32 + 1, 16 - 2, 16 - 2}, // Left
|
||
{32 + 1, 64 + 1, 16 - 2, 16 - 2}, // Down
|
||
{32 + 1, 0 + 1, 16 - 2, 16 - 2}, // Up
|
||
{32 + 1, 32 + 1, 16 - 2, 16 - 2}, // Select
|
||
{96 + 1, 0 + 1, 16 - 2, 16 - 2}, // Dfu
|
||
{16 + 1, 96 + 1, 16 - 2, 16 - 2}, // Encoder phase 0
|
||
{48 + 1, 96 + 1, 16 - 2, 16 - 2}, // Encoder phase 1
|
||
}};
|
||
|
||
auto switches_raw = control::debug::switches();
|
||
for (const auto r : raw_rects) {
|
||
if (switches_raw & 1)
|
||
painter.fill_rectangle(r + pos, Theme::getInstance()->fg_yellow->foreground);
|
||
|
||
switches_raw >>= 1;
|
||
}
|
||
|
||
const std::array<Rect, 6> debounced_rects{{
|
||
{64 + 2, 32 + 2, 16 - 4, 16 - 4}, // Right
|
||
{0 + 2, 32 + 2, 16 - 4, 16 - 4}, // Left
|
||
{32 + 2, 64 + 2, 16 - 4, 16 - 4}, // Down
|
||
{32 + 2, 0 + 2, 16 - 4, 16 - 4}, // Up
|
||
{32 + 2, 32 + 2, 16 - 4, 16 - 4}, // Select
|
||
{96 + 2, 0 + 2, 16 - 4, 16 - 4}, // Dfu
|
||
}};
|
||
|
||
auto switches_debounced = get_switches_state().to_ulong();
|
||
for (const auto r : debounced_rects) {
|
||
if (switches_debounced & 1)
|
||
painter.fill_rectangle(r + pos, Theme::getInstance()->fg_green->foreground);
|
||
|
||
switches_debounced >>= 1;
|
||
}
|
||
|
||
const std::array<Rect, 6> events_rects{{
|
||
{64 + 3, 32 + 3, 16 - 6, 16 - 6}, // Right
|
||
{0 + 3, 32 + 3, 16 - 6, 16 - 6}, // Left
|
||
{32 + 3, 64 + 3, 16 - 6, 16 - 6}, // Down
|
||
{32 + 3, 0 + 3, 16 - 6, 16 - 6}, // Up
|
||
{32 + 3, 32 + 3, 16 - 6, 16 - 6}, // Select
|
||
{96 + 3, 0 + 3, 16 - 6, 16 - 6}, // Dfu
|
||
}};
|
||
|
||
auto switches_event = key_event_mask;
|
||
for (const auto r : events_rects) {
|
||
if (switches_event & 1)
|
||
painter.fill_rectangle(r + pos, Theme::getInstance()->fg_red->foreground);
|
||
|
||
switches_event >>= 1;
|
||
}
|
||
|
||
switches_event = long_press_key_event_mask;
|
||
for (const auto r : events_rects) {
|
||
if (switches_event & 1)
|
||
painter.fill_rectangle(r + pos, Theme::getInstance()->fg_cyan->foreground);
|
||
|
||
switches_event >>= 1;
|
||
}
|
||
|
||
painter.draw_string({5 * 8, 12 * 16}, *Theme::getInstance()->fg_light, to_string_dec_int(last_delta, 3));
|
||
}
|
||
|
||
void ControlsSwitchesWidget::on_frame_sync() {
|
||
set_dirty();
|
||
}
|
||
|
||
/* DebugControlsView *****************************************************/
|
||
|
||
DebugControlsView::DebugControlsView(NavigationView& nav) {
|
||
add_children({
|
||
&labels,
|
||
&switches_widget,
|
||
&options_switches_mode,
|
||
&button_done,
|
||
});
|
||
|
||
button_done.on_select = [&nav](Button&) {
|
||
set_switches_long_press_config(0);
|
||
nav.pop();
|
||
};
|
||
|
||
options_switches_mode.on_change = [this](size_t, OptionsField::value_t v) {
|
||
(void)v;
|
||
set_switches_long_press_config(options_switches_mode.selected_index_value());
|
||
};
|
||
}
|
||
|
||
void DebugControlsView::focus() {
|
||
switches_widget.focus();
|
||
}
|
||
|
||
#ifdef PRALINE
|
||
/* RadioDiagnosticsView **************************************************/
|
||
|
||
RadioDiagnosticsView::RadioDiagnosticsView(NavigationView& nav)
|
||
: nav_(nav) {
|
||
add_children({
|
||
&text_title,
|
||
&text_lbl_rffc,
|
||
&text_rffc_status,
|
||
&text_lbl_max,
|
||
&text_max_status,
|
||
&text_lbl_adc,
|
||
&text_adc_status,
|
||
&text_lbl_fpga,
|
||
&text_fpga_status,
|
||
&text_lbl_sgpio,
|
||
&text_sgpio_status,
|
||
&text_lbl_clock,
|
||
&text_clock_status,
|
||
&text_regs_title,
|
||
&text_lbl_rffc_reg,
|
||
&text_rffc_reg,
|
||
&text_lbl_max_reg,
|
||
&text_max_reg,
|
||
&text_lbl_fpga_reg,
|
||
&text_fpga_reg,
|
||
&text_lbl_sgpio_reg,
|
||
&text_sgpio_reg,
|
||
&text_test_result,
|
||
&button_refresh,
|
||
&button_done,
|
||
});
|
||
|
||
// Set title colors
|
||
text_title.set_style(Theme::getInstance()->fg_yellow);
|
||
text_regs_title.set_style(Theme::getInstance()->fg_yellow);
|
||
|
||
#ifdef PRALINE
|
||
text_lbl_fpga.set("FPGA (iCE40):");
|
||
#else
|
||
text_lbl_fpga.set("CPLD:");
|
||
#endif
|
||
|
||
button_refresh.on_select = [this](Button&) {
|
||
update_status();
|
||
};
|
||
|
||
button_done.on_select = [&nav](Button&) {
|
||
nav.pop();
|
||
};
|
||
|
||
// Initial status update
|
||
update_status();
|
||
}
|
||
|
||
void RadioDiagnosticsView::focus() {
|
||
button_refresh.focus();
|
||
}
|
||
|
||
void RadioDiagnosticsView::update_status() {
|
||
// Read RFFC5072 register 0 to check if it responds
|
||
uint32_t rffc_reg0 = radio::debug::first_if::register_read(0);
|
||
bool rffc_ok = (rffc_reg0 != 0x0000) && (rffc_reg0 != 0xFFFF);
|
||
text_rffc_status.set(rffc_ok ? "OK" : "FAIL");
|
||
text_rffc_status.set_style(rffc_ok ? Theme::getInstance()->fg_green : Theme::getInstance()->fg_red);
|
||
text_rffc_reg.set(to_string_hex(rffc_reg0, 4));
|
||
|
||
// Read MAX283x register 0 to check if it responds
|
||
uint32_t max_reg0 = radio::debug::second_if::register_read(0);
|
||
bool max_ok = (max_reg0 != 0x0000) && (max_reg0 != 0x3FFF);
|
||
text_max_status.set(max_ok ? "OK" : "FAIL");
|
||
text_max_status.set_style(max_ok ? Theme::getInstance()->fg_green : Theme::getInstance()->fg_red);
|
||
text_max_reg.set(to_string_hex(max_reg0, 4));
|
||
|
||
// MAX5864 has no readback - assume OK if other SPI works
|
||
text_adc_status.set("(no readback)");
|
||
text_adc_status.set_style(Theme::getInstance()->fg_medium);
|
||
|
||
#ifdef PRALINE
|
||
// Read FPGA control register
|
||
uint32_t fpga_ctrl = radio::debug::fpga::register_read(1);
|
||
bool fpga_ok = (fpga_ctrl != 0xFF); // 0xFF = not responding
|
||
bool dc_block = (fpga_ctrl & 0x01) != 0;
|
||
text_fpga_status.set(fpga_ok ? (dc_block ? "OK DC_BLK" : "OK NO_DC") : "FAIL");
|
||
text_fpga_status.set_style(fpga_ok ? Theme::getInstance()->fg_green : Theme::getInstance()->fg_red);
|
||
|
||
// Show all FPGA registers
|
||
uint32_t fpga_r2 = radio::debug::fpga::register_read(2);
|
||
uint32_t fpga_r3 = radio::debug::fpga::register_read(3);
|
||
text_fpga_reg.set("C:" + to_string_hex(fpga_ctrl, 2) +
|
||
" D:" + to_string_hex(fpga_r2, 2) +
|
||
" T:" + to_string_hex(fpga_r3, 2));
|
||
#else
|
||
text_fpga_status.set("(CPLD)");
|
||
text_fpga_status.set_style(Theme::getInstance()->fg_medium);
|
||
text_fpga_reg.set("N/A");
|
||
#endif
|
||
|
||
// Check SGPIO status
|
||
uint32_t sgpio_enable = radio::debug::sgpio::register_read(0); // CTRL_ENABLE
|
||
uint32_t sgpio_status = radio::debug::sgpio::register_read(4); // STATUS_1
|
||
bool sgpio_ok = (sgpio_enable != 0);
|
||
text_sgpio_status.set(sgpio_ok ? "ENABLED" : "DISABLED");
|
||
text_sgpio_status.set_style(sgpio_ok ? Theme::getInstance()->fg_green : Theme::getInstance()->fg_orange);
|
||
text_sgpio_reg.set("EN:" + to_string_hex(sgpio_enable, 4) +
|
||
" ST:" + to_string_hex(sgpio_status, 4));
|
||
|
||
// Clock status - check if Si5351 is configured
|
||
// We can't easily read back clock status, so just show assumed state
|
||
text_clock_status.set("(assumed OK)");
|
||
text_clock_status.set_style(Theme::getInstance()->fg_medium);
|
||
|
||
// Summary
|
||
bool all_ok = rffc_ok && max_ok;
|
||
#ifdef PRALINE
|
||
all_ok = all_ok && fpga_ok;
|
||
#endif
|
||
if (all_ok) {
|
||
text_test_result.set("Peripherals responding. Try RX app.");
|
||
text_test_result.set_style(Theme::getInstance()->fg_green);
|
||
} else {
|
||
text_test_result.set("Check failed peripherals above.");
|
||
text_test_result.set_style(Theme::getInstance()->fg_red);
|
||
}
|
||
}
|
||
|
||
/* BasebandStatusView ******************************************************/
|
||
|
||
BasebandStatusView::BasebandStatusView(NavigationView& nav)
|
||
: nav_(nav) {
|
||
add_children({
|
||
&text_title,
|
||
&text_lbl_marker,
|
||
&text_marker,
|
||
&text_lbl_loops,
|
||
&text_loops,
|
||
&text_lbl_wait,
|
||
&text_wait,
|
||
&text_lbl_xfr,
|
||
&text_xfr,
|
||
&text_lbl_missed,
|
||
&text_missed,
|
||
&text_status_line1,
|
||
&text_status_line2,
|
||
&text_status_line3,
|
||
&button_refresh,
|
||
&button_done,
|
||
});
|
||
|
||
// Set title color
|
||
text_title.set_style(Theme::getInstance()->fg_yellow);
|
||
|
||
button_refresh.on_select = [this](Button&) {
|
||
update();
|
||
};
|
||
|
||
button_done.on_select = [&nav](Button&) {
|
||
nav.pop();
|
||
};
|
||
|
||
// Initial update
|
||
update();
|
||
}
|
||
|
||
void BasebandStatusView::focus() {
|
||
button_refresh.focus();
|
||
}
|
||
|
||
void BasebandStatusView::update() {
|
||
// Read counters from shared memory
|
||
uint8_t marker = shared_memory.m4_streaming_marker;
|
||
uint32_t loops = shared_memory.m4_baseband_loops;
|
||
uint32_t wait = shared_memory.m4_dma_wait_count;
|
||
uint32_t xfr = shared_memory.m4_dma_xfr_count;
|
||
uint16_t missed = shared_memory.m4_buffer_missed;
|
||
|
||
// Display counter values
|
||
text_marker.set(to_string_hex(marker, 2));
|
||
text_marker.set_style((marker == 0xAA) ? Theme::getInstance()->fg_green : Theme::getInstance()->fg_red);
|
||
|
||
text_loops.set(to_string_dec_uint(loops));
|
||
text_wait.set(to_string_dec_uint(wait));
|
||
text_xfr.set(to_string_dec_uint(xfr));
|
||
text_missed.set(to_string_dec_uint(missed));
|
||
|
||
// Status interpretation
|
||
if (marker == 0x00) {
|
||
text_status_line1.set("Thread NOT started!");
|
||
text_status_line2.set("M4 baseband crash.");
|
||
text_status_line3.set("Check thread race condition.");
|
||
text_status_line1.set_style(Theme::getInstance()->fg_red);
|
||
text_status_line2.set_style(Theme::getInstance()->fg_red);
|
||
text_status_line3.set_style(Theme::getInstance()->fg_red);
|
||
} else if (marker == 0xAA && loops == 0) {
|
||
text_status_line1.set("Thread started but");
|
||
text_status_line2.set("not looping yet.");
|
||
text_status_line3.set("Wait a moment...");
|
||
text_status_line1.set_style(Theme::getInstance()->fg_orange);
|
||
text_status_line2.set_style(Theme::getInstance()->fg_orange);
|
||
text_status_line3.set_style(Theme::getInstance()->fg_orange);
|
||
} else if (marker == 0xAA && xfr == 0) {
|
||
text_status_line1.set("Thread looping " + to_string_dec_uint(loops) + "x");
|
||
text_status_line2.set("But DMA NOT firing!");
|
||
text_status_line3.set("Check SGPIO14 enable.");
|
||
text_status_line1.set_style(Theme::getInstance()->fg_orange);
|
||
text_status_line2.set_style(Theme::getInstance()->fg_orange);
|
||
text_status_line3.set_style(Theme::getInstance()->fg_orange);
|
||
} else if (xfr > 0) {
|
||
text_status_line1.set("DMA WORKING!");
|
||
text_status_line2.set("Xfr: " + to_string_dec_uint(xfr));
|
||
text_status_line3.set("Data flowing to baseband.");
|
||
text_status_line1.set_style(Theme::getInstance()->fg_green);
|
||
text_status_line2.set_style(Theme::getInstance()->fg_green);
|
||
text_status_line3.set_style(Theme::getInstance()->fg_green);
|
||
}
|
||
}
|
||
|
||
/* SGPIOLiveMonitorView ****************************************************/
|
||
|
||
SGPIOLiveMonitorView::SGPIOLiveMonitorView(NavigationView& nav)
|
||
: nav_(nav) {
|
||
add_children({
|
||
&text_title,
|
||
&text_lbl_ctrl,
|
||
&text_ctrl,
|
||
&text_lbl_in,
|
||
&text_in,
|
||
&text_lbl_ss,
|
||
&text_ss,
|
||
&text_lbl_status,
|
||
&text_status,
|
||
&text_lbl_out,
|
||
&text_out,
|
||
&text_lbl_oen,
|
||
&text_oen,
|
||
&text_diag_line1,
|
||
&text_diag_line2,
|
||
&text_diag_line3,
|
||
&text_diag_line4,
|
||
&button_refresh,
|
||
&button_done,
|
||
});
|
||
|
||
// Set title color
|
||
text_title.set_style(Theme::getInstance()->fg_yellow);
|
||
|
||
button_refresh.on_select = [this](Button&) {
|
||
update();
|
||
};
|
||
|
||
button_done.on_select = [&nav](Button&) {
|
||
nav.pop();
|
||
};
|
||
|
||
// Initial update
|
||
update();
|
||
}
|
||
|
||
void SGPIOLiveMonitorView::focus() {
|
||
button_refresh.focus();
|
||
}
|
||
|
||
void SGPIOLiveMonitorView::update() {
|
||
// Read SGPIO registers via radio debug namespace
|
||
uint32_t ctrl = radio::debug::sgpio::register_read(0); // CTRL_ENABLE
|
||
uint32_t in_reg = radio::debug::sgpio::register_read(1); // GPIO_INREG
|
||
uint32_t status = radio::debug::sgpio::register_read(4); // STATUS_1
|
||
|
||
// Read registers directly from LPC_SGPIO peripheral
|
||
uint32_t reg_ss = LPC_SGPIO->REG_SS[0];
|
||
uint32_t out_reg = LPC_SGPIO->GPIO_OUTREG;
|
||
uint32_t oen_reg = LPC_SGPIO->GPIO_OENREG;
|
||
|
||
// Display register values
|
||
text_ctrl.set(to_string_hex(ctrl, 4));
|
||
text_in.set(to_string_hex(in_reg, 8));
|
||
text_ss.set(to_string_hex(reg_ss, 8));
|
||
text_status.set(to_string_hex(status, 4));
|
||
text_out.set(to_string_hex(out_reg, 4));
|
||
text_oen.set(to_string_hex(oen_reg, 4));
|
||
|
||
// Diagnostics based on register values
|
||
bool gpio_changing = (in_reg & 0xFF) != 0; // Check data pins
|
||
bool regss_active = (reg_ss != 0);
|
||
bool disable_high = (out_reg & (1U << 10)) != 0; // Bit 10 = DISABLE signal
|
||
bool sgpio8_high = (in_reg & (1U << 8)) != 0; // Bit 8 = SGPIO8 clock
|
||
bool sgpio8_output = (oen_reg & (1U << 8)) != 0; // Bit 8 = SGPIO8 direction (should be INPUT=0)
|
||
|
||
// Line 1: SGPIO8 direction check (CRITICAL - must be INPUT)
|
||
if (sgpio8_output) {
|
||
text_diag_line1.set("SGPIO8 OUTPUT! (bus conflict)");
|
||
text_diag_line1.set_style(Theme::getInstance()->fg_red);
|
||
} else if (disable_high) {
|
||
text_diag_line1.set("DISABLE=HIGH! FPGA stopped!");
|
||
text_diag_line1.set_style(Theme::getInstance()->fg_red);
|
||
} else {
|
||
text_diag_line1.set("SGPIO8=IN, DISABLE=LOW");
|
||
text_diag_line1.set_style(Theme::getInstance()->fg_green);
|
||
}
|
||
|
||
// Line 2: Clock signal status (snapshot - can't detect toggling)
|
||
if (disable_high) {
|
||
text_diag_line2.set("Clock N/A (FPGA disabled)");
|
||
text_diag_line2.set_style(Theme::getInstance()->fg_medium);
|
||
} else if (sgpio8_high) {
|
||
text_diag_line2.set("SGPIO8=HIGH (snapshot)");
|
||
text_diag_line2.set_style(Theme::getInstance()->fg_green);
|
||
} else {
|
||
text_diag_line2.set("SGPIO8=LOW (snapshot)");
|
||
text_diag_line2.set_style(Theme::getInstance()->fg_green);
|
||
}
|
||
|
||
// Line 3: REG_SS[0] capture status
|
||
if (!regss_active && !disable_high) {
|
||
text_diag_line3.set("REG_SS[0]=0 (NOT CAPTURING!)");
|
||
text_diag_line3.set_style(Theme::getInstance()->fg_red);
|
||
} else if (regss_active) {
|
||
text_diag_line3.set("REG_SS[0] has data");
|
||
text_diag_line3.set_style(Theme::getInstance()->fg_green);
|
||
} else {
|
||
text_diag_line3.set("Capture N/A (FPGA disabled)");
|
||
text_diag_line3.set_style(Theme::getInstance()->fg_medium);
|
||
}
|
||
|
||
// Line 4: Summary based on key indicators
|
||
if (sgpio8_output) {
|
||
text_diag_line4.set("FIX: Set SGPIO8 to INPUT!");
|
||
text_diag_line4.set_style(Theme::getInstance()->fg_red);
|
||
} else if (disable_high) {
|
||
text_diag_line4.set("FIX: Clear DISABLE bit!");
|
||
text_diag_line4.set_style(Theme::getInstance()->fg_red);
|
||
} else if (regss_active && gpio_changing) {
|
||
text_diag_line4.set("SGPIO capturing data");
|
||
text_diag_line4.set_style(Theme::getInstance()->fg_green);
|
||
} else if (!regss_active && gpio_changing) {
|
||
text_diag_line4.set("Data present, check slices");
|
||
text_diag_line4.set_style(Theme::getInstance()->fg_orange);
|
||
} else if (!regss_active) {
|
||
text_diag_line4.set("No data activity");
|
||
text_diag_line4.set_style(Theme::getInstance()->fg_orange);
|
||
} else {
|
||
text_diag_line4.set("Check DMA config");
|
||
text_diag_line4.set_style(Theme::getInstance()->fg_green);
|
||
}
|
||
}
|
||
|
||
/* RadioRxTestView ********************************************************/
|
||
|
||
RadioRxTestView::RadioRxTestView(NavigationView& nav)
|
||
: nav_(nav) {
|
||
add_children({
|
||
&labels,
|
||
&console,
|
||
&button_init,
|
||
&button_rx,
|
||
&button_freq,
|
||
&button_sgpio,
|
||
&button_full,
|
||
&button_step,
|
||
&button_done,
|
||
});
|
||
|
||
button_init.on_select = [this](Button&) {
|
||
run_init_test();
|
||
};
|
||
|
||
button_rx.on_select = [this](Button&) {
|
||
run_rx_mode_test();
|
||
};
|
||
|
||
button_freq.on_select = [this](Button&) {
|
||
run_freq_test();
|
||
};
|
||
|
||
button_sgpio.on_select = [this](Button&) {
|
||
run_sgpio_test();
|
||
};
|
||
|
||
button_full.on_select = [this](Button&) {
|
||
run_full_test();
|
||
};
|
||
|
||
button_step.on_select = [this](Button&) {
|
||
run_step_test();
|
||
};
|
||
|
||
button_done.on_select = [&nav](Button&) {
|
||
nav.pop();
|
||
};
|
||
|
||
log("Ready. Press buttons to test.");
|
||
log("Init->RX->Freq->SGPIO");
|
||
}
|
||
|
||
void RadioRxTestView::focus() {
|
||
button_full.focus();
|
||
}
|
||
|
||
void RadioRxTestView::log(const std::string& msg) {
|
||
console.writeln(msg);
|
||
}
|
||
|
||
void RadioRxTestView::log_registers(const std::string& label) {
|
||
// RFFC5072 register 0
|
||
uint32_t rffc_r0 = radio::debug::first_if::register_read(0);
|
||
|
||
// MAX283x registers 0, 3, 4 (key freq regs)
|
||
uint32_t max_r0 = radio::debug::second_if::register_read(0);
|
||
uint32_t max_r3 = radio::debug::second_if::register_read(3);
|
||
uint32_t max_r4 = radio::debug::second_if::register_read(4);
|
||
|
||
// SGPIO
|
||
uint32_t sgpio_en = radio::debug::sgpio::register_read(0);
|
||
uint32_t sgpio_data = radio::debug::sgpio::register_read(5);
|
||
|
||
log(label);
|
||
log(" RFFC:" + to_string_hex(rffc_r0, 4));
|
||
log(" MAX r0:" + to_string_hex(max_r0, 4) +
|
||
" r3:" + to_string_hex(max_r3, 4) +
|
||
" r4:" + to_string_hex(max_r4, 4));
|
||
log(" SGPIO en:" + to_string_hex(sgpio_en, 4) +
|
||
" dat:" + to_string_hex(sgpio_data, 8));
|
||
|
||
#ifdef PRALINE
|
||
uint32_t fpga_ctrl = radio::debug::fpga::register_read(1);
|
||
log(" FPGA ctrl:" + to_string_hex(fpga_ctrl, 2));
|
||
#endif
|
||
}
|
||
|
||
void RadioRxTestView::run_init_test() {
|
||
console.clear(true);
|
||
log("=== INIT TEST ===");
|
||
|
||
log("radio::init()...");
|
||
radio::init();
|
||
radio_initialized_ = true;
|
||
|
||
log("set_baseband_rate(8M)...");
|
||
radio::set_baseband_rate(8000000);
|
||
|
||
// Read Si5351 status to check PLL lock
|
||
uint8_t si_status = portapack::clock_manager.si5351_read_status();
|
||
log("Si5351 status: " + to_string_hex(si_status, 2));
|
||
if (si_status & 0x20) {
|
||
log(" WARNING: PLL A unlocked!");
|
||
} else {
|
||
log(" PLL A locked OK");
|
||
}
|
||
|
||
// Read crystal cap register
|
||
uint8_t xtal_cap = portapack::clock_manager.si5351_read_register(183);
|
||
log("Crystal cap: " + to_string_hex(xtal_cap, 2));
|
||
|
||
log_registers("[After init]");
|
||
log("Init+clocks done.");
|
||
}
|
||
|
||
void RadioRxTestView::run_rx_mode_test() {
|
||
console.clear(true);
|
||
log("=== RX MODE TEST ===");
|
||
|
||
if (!radio_initialized_) {
|
||
log("ERROR: Run Init first!");
|
||
return;
|
||
}
|
||
|
||
log_registers("[Before RX mode]");
|
||
|
||
log("Calling set_direction(Receive)...");
|
||
radio::set_direction(rf::Direction::Receive);
|
||
|
||
log_registers("[After RX mode]");
|
||
|
||
// Check MAX283x mode register
|
||
uint32_t max_r0 = radio::debug::second_if::register_read(0);
|
||
log("MAX r0 after RX: " + to_string_hex(max_r0, 4));
|
||
log("RX mode set.");
|
||
}
|
||
|
||
void RadioRxTestView::run_freq_test() {
|
||
console.clear(true);
|
||
log("=== FREQ TEST ===");
|
||
|
||
if (!radio_initialized_) {
|
||
log("ERROR: Run Init first!");
|
||
return;
|
||
}
|
||
|
||
log_registers("[Before freq set]");
|
||
|
||
log("Setting " + to_string_dec_uint(test_frequency_ / 1000000) + " MHz...");
|
||
bool result = radio::set_tuning_frequency(test_frequency_);
|
||
|
||
log_registers("[After freq set]");
|
||
|
||
log(result ? "Freq set OK" : "Freq set FAILED");
|
||
|
||
// Show expected vs actual for MAX2831 freq regs
|
||
// For 433 MHz with MAX2831: F_LO = 40M * (N + F/2^20) / 2
|
||
// N = 43, F = ~629146 for ~433 MHz
|
||
log("(Expected: N~43 in r3, F_hi in r4)");
|
||
}
|
||
|
||
void RadioRxTestView::run_sgpio_test() {
|
||
console.clear(true);
|
||
log("=== SGPIO TEST (FIXED) ===");
|
||
|
||
// CRITICAL FIX: Set DISABLE=HIGH first (reference HackRF pattern)
|
||
LPC_SGPIO->GPIO_OENREG = (1U << 10) | (1U << 11); // SGPIO10,11 outputs
|
||
LPC_SGPIO->GPIO_OUTREG = (1U << 10); // DISABLE=HIGH during config
|
||
log("Set DISABLE=HIGH");
|
||
|
||
// Small delay for signals to settle
|
||
for (volatile int i = 0; i < 10000; i++) {
|
||
}
|
||
|
||
// NOW enable streaming (DISABLE=LOW)
|
||
LPC_SGPIO->GPIO_OUTREG = 0; // DISABLE=LOW, DIRECTION=LOW (RX)
|
||
log("Set DISABLE=LOW (streaming)");
|
||
for (volatile int i = 0; i < 10000; i++) {
|
||
}
|
||
|
||
// Read raw GPIO_INREG multiple times
|
||
uint32_t g[4];
|
||
for (int i = 0; i < 4; i++) {
|
||
g[i] = LPC_SGPIO->GPIO_INREG;
|
||
for (volatile int j = 0; j < 10000; j++) {
|
||
}
|
||
}
|
||
|
||
log("GPIO_IN:");
|
||
log(" " + to_string_hex(g[0], 8) + " " + to_string_hex(g[1], 8));
|
||
log(" " + to_string_hex(g[2], 8) + " " + to_string_hex(g[3], 8));
|
||
|
||
bool changing = (g[0] != g[1]) || (g[1] != g[2]) || (g[2] != g[3]);
|
||
|
||
if (changing) {
|
||
log("PASS: Data changing!");
|
||
} else if (g[0] == 0) {
|
||
log("FAIL: All zeros");
|
||
} else if (g[0] == 0x00000FFF) {
|
||
log("FAIL: 0xFFF = pull-ups");
|
||
log("FPGA not driving data");
|
||
} else {
|
||
log("FAIL: Static " + to_string_hex(g[0], 8));
|
||
}
|
||
|
||
uint32_t out = LPC_SGPIO->GPIO_OUTREG;
|
||
log("HOST_DIS=" + to_string_dec_uint((out >> 10) & 1));
|
||
}
|
||
|
||
void RadioRxTestView::run_full_test() {
|
||
console.clear(true);
|
||
log("=== FULL RX TEST ===");
|
||
|
||
// Step 1: Init
|
||
log("[1/6] Init radio...");
|
||
radio::init();
|
||
radio_initialized_ = true;
|
||
|
||
// Step 2: Set sample rate (configures Si5351 clocks!)
|
||
log("[2/6] Set 8M sample rate...");
|
||
radio::set_baseband_rate(8000000);
|
||
|
||
// Step 3: RX mode
|
||
log("[3/6] Set RX mode...");
|
||
radio::set_direction(rf::Direction::Receive);
|
||
|
||
// Step 4: Frequency - use 2437 MHz (WiFi ch6) which is in MAX2831 range
|
||
uint32_t wifi_freq = 2437000000;
|
||
log("[4/6] Set 2437 MHz (WiFi)...");
|
||
bool freq_ok = radio::set_tuning_frequency(wifi_freq);
|
||
log(freq_ok ? " Freq OK" : " Freq FAIL");
|
||
|
||
// Step 5: Configure SGPIO outputs with correct DISABLE sequence
|
||
log("[5/6] Configure SGPIO...");
|
||
// CRITICAL FIX: Set DISABLE=HIGH first
|
||
LPC_SGPIO->GPIO_OENREG = (1U << 10) | (1U << 11); // SGPIO10,11 as outputs
|
||
LPC_SGPIO->GPIO_OUTREG = (1U << 10); // DISABLE=HIGH during config
|
||
log(" DISABLE=HIGH");
|
||
|
||
// Delay for settle
|
||
for (volatile int i = 0; i < 10000; i++) {
|
||
}
|
||
|
||
// NOW enable streaming (DISABLE=LOW)
|
||
LPC_SGPIO->GPIO_OUTREG = 0; // DISABLE=LOW, DIRECTION=LOW (RX)
|
||
log(" DISABLE=LOW (streaming)");
|
||
|
||
// Step 6: Check raw GPIO pins
|
||
log("[6/6] Check GPIO pins...");
|
||
|
||
// Delay for stabilization
|
||
for (volatile int i = 0; i < 200000; i++) {
|
||
}
|
||
|
||
// Read raw GPIO_INREG multiple times
|
||
uint32_t g1 = LPC_SGPIO->GPIO_INREG;
|
||
for (volatile int i = 0; i < 10000; i++) {
|
||
}
|
||
uint32_t g2 = LPC_SGPIO->GPIO_INREG;
|
||
for (volatile int i = 0; i < 10000; i++) {
|
||
}
|
||
uint32_t g3 = LPC_SGPIO->GPIO_INREG;
|
||
for (volatile int i = 0; i < 10000; i++) {
|
||
}
|
||
uint32_t g4 = LPC_SGPIO->GPIO_INREG;
|
||
|
||
log("GPIO_IN readings:");
|
||
log(" " + to_string_hex(g1, 8) + " " + to_string_hex(g2, 8));
|
||
log(" " + to_string_hex(g3, 8) + " " + to_string_hex(g4, 8));
|
||
|
||
bool gpio_changing = (g1 != g2) || (g2 != g3) || (g3 != g4);
|
||
bool gpio_not_zero = (g1 != 0);
|
||
bool gpio_not_fff = (g1 != 0x00000FFF);
|
||
|
||
// Check Si5351 output enable register (reg 3)
|
||
// Bits 0-7: CLK0-7 output enable (0=enabled, 1=disabled)
|
||
// We want CLK0 and CLK1 enabled (bits 0,1 = 0)
|
||
log("---");
|
||
|
||
if (gpio_changing) {
|
||
log("=== PASS: Data flowing! ===");
|
||
} else if (gpio_not_fff && gpio_not_zero) {
|
||
log("=== PARTIAL: Static data ===");
|
||
log("FPGA outputs but no clock?");
|
||
} else if (!gpio_not_zero) {
|
||
log("=== FAIL: All zeros ===");
|
||
log("FPGA not driving outputs");
|
||
} else {
|
||
log("=== FAIL: All FFF (pull-ups) ===");
|
||
log("FPGA outputs high-Z");
|
||
log("Check: Si5351 CLK0/CLK1");
|
||
}
|
||
|
||
log_registers("[Final]");
|
||
}
|
||
|
||
bool RadioRxTestView::check_gpio_changing() {
|
||
uint32_t g[4];
|
||
for (int i = 0; i < 4; i++) {
|
||
g[i] = LPC_SGPIO->GPIO_INREG;
|
||
for (volatile int j = 0; j < 10000; j++) {
|
||
}
|
||
}
|
||
return (g[0] != g[1]) || (g[1] != g[2]) || (g[2] != g[3]);
|
||
}
|
||
|
||
void RadioRxTestView::run_step_test() {
|
||
console.clear(true);
|
||
log("=== STEP TEST (FIXED) ===");
|
||
log("Correct DISABLE sequence");
|
||
|
||
// Ensure radio is initialized
|
||
if (!radio_initialized_) {
|
||
log("Init radio...");
|
||
radio::init();
|
||
radio_initialized_ = true;
|
||
radio::set_baseband_rate(8000000);
|
||
radio::set_direction(rf::Direction::Receive);
|
||
radio::set_tuning_frequency(2437000000);
|
||
}
|
||
|
||
// Step 0: Baseline with DISABLE=HIGH first
|
||
log("[0] Baseline (DISABLE=HIGH)");
|
||
LPC_SGPIO->CTRL_ENABLE = 0; // Disable all slices
|
||
LPC_SGPIO->GPIO_OENREG = 0x0C00; // Bits 10, 11 outputs
|
||
LPC_SGPIO->GPIO_OUTREG = (1U << 10); // DISABLE=HIGH first!
|
||
for (volatile int i = 0; i < 100000; i++) {
|
||
}
|
||
|
||
// Now enable streaming to check baseline
|
||
LPC_SGPIO->GPIO_OUTREG = 0x0000; // DISABLE=LOW
|
||
for (volatile int i = 0; i < 100000; i++) {
|
||
}
|
||
bool step0 = check_gpio_changing();
|
||
log(step0 ? " PASS: Data changing" : " FAIL: Data static");
|
||
if (!step0) {
|
||
log("ABORT: Baseline broken");
|
||
return;
|
||
}
|
||
|
||
// NOW disable streaming for configuration
|
||
log("[Config] Set DISABLE=HIGH");
|
||
LPC_SGPIO->GPIO_OUTREG = (1U << 10); // DISABLE=HIGH
|
||
for (volatile int i = 0; i < 100000; i++) {
|
||
}
|
||
|
||
// Step 1: OUT_MUX_CFG data pins - test individually
|
||
log("[1] OUT_MUX_CFG[0-7] data");
|
||
uint32_t data_out_mux = (9U << 0) | (0U << 4); // DOUT_DOUTM8A, GPIO_OE
|
||
|
||
for (size_t i = 0; i < 8; i++) {
|
||
uint32_t before = LPC_SGPIO->GPIO_INREG;
|
||
LPC_SGPIO->OUT_MUX_CFG[i] = data_out_mux;
|
||
for (volatile int j = 0; j < 50000; j++) {
|
||
}
|
||
uint32_t after = LPC_SGPIO->GPIO_INREG;
|
||
bool ok = check_gpio_changing();
|
||
|
||
log(" [" + to_string_dec_uint(i) + "] " +
|
||
to_string_hex(before & 0xFF, 2) + "->" +
|
||
to_string_hex(after & 0xFF, 2) +
|
||
(ok ? " OK" : " FAIL"));
|
||
|
||
if (!ok) {
|
||
log("CULPRIT: OUT_MUX_CFG[" + to_string_dec_uint(i) + "]");
|
||
return;
|
||
}
|
||
}
|
||
log(" All data pins PASS");
|
||
|
||
// Step 2: OUT_MUX_CFG control pins - SKIP PIN 10 (HOST_DISABLE)
|
||
log("[2] OUT_MUX_CFG ctrl pins");
|
||
log(" (skipping pin 10 - breaks)");
|
||
|
||
struct {
|
||
int pin;
|
||
uint32_t val;
|
||
} ctrl_pins[] = {
|
||
{8, (0U << 0) | (0U << 4)},
|
||
{9, (0U << 0) | (0U << 4)},
|
||
// {10, (4U << 0) | (0U << 4)}, // SKIP - causes failure
|
||
{11, (4U << 0) | (0U << 4)},
|
||
{14, (0U << 0) | (0U << 4)}};
|
||
|
||
for (auto& p : ctrl_pins) {
|
||
uint32_t before = LPC_SGPIO->GPIO_INREG;
|
||
LPC_SGPIO->OUT_MUX_CFG[p.pin] = p.val;
|
||
for (volatile int i = 0; i < 50000; i++) {
|
||
}
|
||
uint32_t after = LPC_SGPIO->GPIO_INREG;
|
||
bool ok = check_gpio_changing();
|
||
|
||
log(" [" + to_string_dec_uint(p.pin) + "] " +
|
||
to_string_hex(before & 0xFF, 2) + "->" +
|
||
to_string_hex(after & 0xFF, 2) +
|
||
(ok ? " OK" : " FAIL"));
|
||
|
||
if (!ok) {
|
||
log("CULPRIT: OUT_MUX_CFG[" + to_string_dec_uint(p.pin) + "]");
|
||
return;
|
||
}
|
||
}
|
||
log(" All ctrl pins PASS");
|
||
|
||
// Step 3: Set GPIO_OENREG for RX
|
||
log("[3] GPIO_OENREG full RX");
|
||
LPC_SGPIO->GPIO_OENREG = 0x0C00; // Keep same as baseline
|
||
for (volatile int i = 0; i < 100000; i++) {
|
||
}
|
||
bool step3 = check_gpio_changing();
|
||
log(step3 ? " PASS" : " FAIL: Data stopped!");
|
||
if (!step3) {
|
||
log("CULPRIT: GPIO_OENREG");
|
||
return;
|
||
}
|
||
|
||
// Step 3.5: Configure slice D as clock source (CRITICAL!)
|
||
log("[3.5] Slice D clock source");
|
||
const uint32_t slice_d = 3;
|
||
// SGPIO_MUX_CFG: External clock from SGPIO8, qualifier from SGPIO9
|
||
LPC_SGPIO->SGPIO_MUX_CFG[slice_d] = (1U << 0) | (0U << 1) | (0U << 3) | (3U << 5) | (1U << 7) | (0U << 9) | (0U << 11) | (0U << 12);
|
||
// SLICE_MUX_CFG: 1 bit per clock, CLKGEN_MODE=1 (external clock!) <- FIX
|
||
LPC_SGPIO->SLICE_MUX_CFG[slice_d] = (0U << 0) | (0U << 1) | (0U << 2) | (0U << 3) | (1U << 4) | (0U << 6) | (0U << 8);
|
||
LPC_SGPIO->PRESET[slice_d] = 0;
|
||
LPC_SGPIO->COUNT[slice_d] = 0;
|
||
LPC_SGPIO->POS[slice_d] = (0x1F << 0) | (0x1F << 8);
|
||
LPC_SGPIO->REG[slice_d] = 0x11111111;
|
||
LPC_SGPIO->REG_SS[slice_d] = 0x11111111;
|
||
// Enable slice D counter
|
||
LPC_SGPIO->CTRL_ENABLE = (1U << slice_d);
|
||
for (volatile int i = 0; i < 100000; i++) {
|
||
}
|
||
bool step3_5 = check_gpio_changing();
|
||
log(step3_5 ? " PASS" : " FAIL: Data stopped!");
|
||
if (!step3_5) {
|
||
log("CULPRIT: Slice D config");
|
||
return;
|
||
}
|
||
|
||
// Step 4: SGPIO_MUX_CFG slice A
|
||
log("[4] SGPIO_MUX_CFG[A]");
|
||
LPC_SGPIO->SGPIO_MUX_CFG[0] = (1U << 0) | (0U << 1) | (3U << 3) | (3U << 5) | (1U << 7) | (0U << 9) | (0U << 11) | (0U << 12); // Clock from slice D (bit3-4=3), external pin SGPIO8, qualifier SGPIO9
|
||
for (volatile int i = 0; i < 100000; i++) {
|
||
}
|
||
bool step4 = check_gpio_changing();
|
||
log(step4 ? " PASS" : " FAIL: Data stopped!");
|
||
if (!step4) {
|
||
log("CULPRIT: SGPIO_MUX_CFG[A]");
|
||
return;
|
||
}
|
||
|
||
// Step 5: SLICE_MUX_CFG slice A
|
||
log("[5] SLICE_MUX_CFG[A]");
|
||
LPC_SGPIO->SLICE_MUX_CFG[0] = (0U << 0) | (0U << 1) | (1U << 2) | (0U << 3) | (1U << 4) | (3U << 6) | (0U << 8); // CLKGEN_MODE=1 (external clock!), PARALLEL_MODE 1 byte
|
||
for (volatile int i = 0; i < 100000; i++) {
|
||
}
|
||
bool step5 = check_gpio_changing();
|
||
log(step5 ? " PASS" : " FAIL: Data stopped!");
|
||
if (!step5) {
|
||
log("CULPRIT: SLICE_MUX_CFG[A]");
|
||
return;
|
||
}
|
||
|
||
// Step 6: Slice A registers
|
||
log("[6] Slice A registers");
|
||
LPC_SGPIO->PRESET[0] = 0;
|
||
LPC_SGPIO->COUNT[0] = 0;
|
||
LPC_SGPIO->POS[0] = (0x1F << 0) | (0x1F << 8); // pos, pos_reset
|
||
LPC_SGPIO->REG[0] = 0;
|
||
LPC_SGPIO->REG_SS[0] = 0;
|
||
for (volatile int i = 0; i < 100000; i++) {
|
||
}
|
||
bool step6 = check_gpio_changing();
|
||
log(step6 ? " PASS" : " FAIL: Data stopped!");
|
||
if (!step6) {
|
||
log("CULPRIT: Slice A registers");
|
||
return;
|
||
}
|
||
|
||
// Step 7: Enable slice A counter (keep slice D enabled) - still with DISABLE=HIGH
|
||
log("[7] Enable slices D+A");
|
||
LPC_SGPIO->CTRL_ENABLE = (1U << 3) | (1U << 0); // Slice D + Slice A
|
||
for (volatile int i = 0; i < 100000; i++) {
|
||
}
|
||
|
||
// Check STATUS_1 BEFORE enabling streaming
|
||
uint32_t status_pre = LPC_SGPIO->STATUS_1;
|
||
log(" STATUS_1 (pre): " + to_string_hex(status_pre, 4));
|
||
|
||
// Step 8: Enable streaming (DISABLE=LOW) - THIS IS THE CRITICAL TEST
|
||
log("[8] Enable streaming (DISABLE=LOW)");
|
||
LPC_SGPIO->GPIO_OUTREG = 0; // DISABLE=LOW
|
||
for (volatile int i = 0; i < 100000; i++) {
|
||
}
|
||
|
||
// Check if slices become active
|
||
uint32_t status_post = LPC_SGPIO->STATUS_1;
|
||
uint32_t regss = LPC_SGPIO->REG_SS[0];
|
||
uint32_t count_a = LPC_SGPIO->COUNT[0];
|
||
|
||
log(" STATUS_1 (post): " + to_string_hex(status_post, 4));
|
||
log(" REG_SS[0]: " + to_string_hex(regss, 8));
|
||
log(" COUNT[0]: " + to_string_hex(count_a, 8));
|
||
|
||
bool step8 = check_gpio_changing();
|
||
log(step8 ? " GPIO still changing" : " GPIO stopped!");
|
||
|
||
if ((status_post & 1) && regss != 0) {
|
||
log("=== SUCCESS! Slice A capturing! ===");
|
||
} else if (status_post & 1) {
|
||
log("=== PARTIAL: Slice A active but REG_SS=0 ===");
|
||
} else {
|
||
log("=== FAIL: Slice A not active ===");
|
||
log("Expected: STATUS_1 bit 0 = 1");
|
||
log("Actual: STATUS_1 bit 0 = " + to_string_dec_uint(status_post & 1));
|
||
}
|
||
}
|
||
|
||
/* SGPIO8ClockDetectorView ***********************************************/
|
||
|
||
SGPIO8ClockDetectorView::SGPIO8ClockDetectorView(NavigationView& nav)
|
||
: nav_(nav) {
|
||
add_children({
|
||
&text_title,
|
||
&text_lbl_samples,
|
||
&text_samples,
|
||
&text_lbl_toggles,
|
||
&text_toggles,
|
||
&text_status,
|
||
&button_sample,
|
||
&button_done,
|
||
});
|
||
|
||
text_title.set_style(Theme::getInstance()->fg_yellow);
|
||
|
||
button_sample.on_select = [this](Button&) {
|
||
sample_sgpio8();
|
||
};
|
||
|
||
button_done.on_select = [&nav](Button&) {
|
||
nav.pop();
|
||
};
|
||
|
||
// Auto-sample on load
|
||
sample_sgpio8();
|
||
}
|
||
|
||
void SGPIO8ClockDetectorView::focus() {
|
||
button_sample.focus();
|
||
}
|
||
|
||
void SGPIO8ClockDetectorView::sample_sgpio8() {
|
||
// Sample SGPIO8 (bit 8 of GPIO_INREG) as fast as possible
|
||
// NOTE: Software sampling cannot accurately measure clock frequency
|
||
// This only detects presence/absence of clock activity
|
||
const int num_samples = 2000;
|
||
uint8_t samples[num_samples];
|
||
|
||
// Sample as fast as possible
|
||
for (int i = 0; i < num_samples; i++) {
|
||
samples[i] = (LPC_SGPIO->GPIO_INREG >> 8) & 1;
|
||
}
|
||
|
||
// Count toggles (transitions 0→1 or 1→0)
|
||
int toggles = 0;
|
||
for (int i = 1; i < num_samples; i++) {
|
||
if (samples[i] != samples[i - 1]) {
|
||
toggles++;
|
||
}
|
||
}
|
||
|
||
// Display first 20 samples
|
||
std::string sample_str;
|
||
for (int i = 0; i < 20 && i < num_samples; i++) {
|
||
sample_str += (samples[i] ? "1" : "0");
|
||
}
|
||
text_samples.set(sample_str);
|
||
|
||
// Display toggle count
|
||
text_toggles.set(to_string_dec_uint(toggles) + " / " +
|
||
to_string_dec_uint(num_samples - 1) + " transitions");
|
||
|
||
// Status interpretation - just presence detection
|
||
if (toggles > 100) {
|
||
text_status.set("CLOCK ACTIVE");
|
||
text_status.set_style(Theme::getInstance()->fg_green);
|
||
} else if (toggles > 0) {
|
||
text_status.set("SOME ACTIVITY (" + to_string_dec_uint(toggles) + ")");
|
||
text_status.set_style(Theme::getInstance()->fg_orange);
|
||
} else {
|
||
text_status.set("NO CLOCK - Stuck " +
|
||
std::string(samples[0] ? "HIGH" : "LOW"));
|
||
text_status.set_style(Theme::getInstance()->fg_red);
|
||
}
|
||
}
|
||
|
||
/* Si5351DebugView *******************************************************/
|
||
|
||
Si5351DebugView::Si5351DebugView(NavigationView& nav)
|
||
: nav_(nav) {
|
||
add_children({&text_title,
|
||
&text_status_label,
|
||
&text_status_value,
|
||
&text_pll_a_label,
|
||
&text_pll_a_status,
|
||
&text_pll_b_label,
|
||
&text_pll_b_status,
|
||
&text_sys_init_label,
|
||
&text_sys_init_status,
|
||
&text_xtal_cap_label,
|
||
&text_xtal_cap_value,
|
||
&text_clk0_label,
|
||
&text_clk0_status,
|
||
&text_clk0_freq_label,
|
||
&text_clk0_freq_value,
|
||
&text_clk0_div_label,
|
||
&text_clk0_div_value,
|
||
&text_clk1_label,
|
||
&text_clk1_status,
|
||
&button_refresh,
|
||
&button_reset_pll,
|
||
&button_done});
|
||
|
||
text_title.set_style(Theme::getInstance()->fg_yellow);
|
||
|
||
button_refresh.on_select = [this](Button&) {
|
||
refresh_status();
|
||
};
|
||
|
||
button_reset_pll.on_select = [this](Button&) {
|
||
reset_pll();
|
||
};
|
||
|
||
button_done.on_select = [&nav](Button&) {
|
||
nav.pop();
|
||
};
|
||
|
||
// Auto-refresh on load
|
||
refresh_status();
|
||
}
|
||
|
||
void Si5351DebugView::focus() {
|
||
button_refresh.focus();
|
||
}
|
||
|
||
void Si5351DebugView::refresh_status() {
|
||
// Read device status register (reg 0)
|
||
uint8_t status = portapack::clock_manager.si5351_read_status();
|
||
text_status_value.set("0x" + to_string_hex(status, 2));
|
||
|
||
// Decode status bits
|
||
bool pll_a_locked = !(status & 0x20); // Bit 5: LOL_A (Loss of Lock A)
|
||
bool pll_b_locked = !(status & 0x40); // Bit 6: LOL_B (Loss of Lock B)
|
||
bool sys_init = (status & 0x80); // Bit 7: SYS_INIT
|
||
bool los_clkin = (status & 0x10); // Bit 4: LOS (Loss of Signal)
|
||
|
||
// PLL A status
|
||
if (pll_a_locked) {
|
||
text_pll_a_status.set("LOCKED");
|
||
text_pll_a_status.set_style(Theme::getInstance()->fg_green);
|
||
} else {
|
||
text_pll_a_status.set("UNLOCKED");
|
||
text_pll_a_status.set_style(Theme::getInstance()->fg_red);
|
||
}
|
||
|
||
// PLL B status
|
||
if (pll_b_locked) {
|
||
text_pll_b_status.set("LOCKED");
|
||
text_pll_b_status.set_style(Theme::getInstance()->fg_green);
|
||
} else {
|
||
text_pll_b_status.set("UNLOCKED (unused)");
|
||
text_pll_b_status.set_style(Theme::getInstance()->fg_orange);
|
||
}
|
||
|
||
// SYS_INIT status
|
||
if (sys_init) {
|
||
text_sys_init_status.set("IN PROGRESS");
|
||
text_sys_init_status.set_style(Theme::getInstance()->fg_orange);
|
||
} else {
|
||
text_sys_init_status.set("COMPLETE");
|
||
text_sys_init_status.set_style(Theme::getInstance()->fg_green);
|
||
}
|
||
|
||
// Read crystal load capacitance (reg 183)
|
||
uint8_t xtal_cap = portapack::clock_manager.si5351_read_register(183);
|
||
text_xtal_cap_value.set("0x" + to_string_hex(xtal_cap, 2) +
|
||
" (" + to_string_dec_uint((xtal_cap >> 6) & 0x03) + ")");
|
||
|
||
// Read clock output enables (reg 16-23 control, reg 3 for output enable mask)
|
||
uint8_t output_enable_mask = portapack::clock_manager.si5351_read_register(3);
|
||
|
||
// CLK0 (bit 0 of reg 3, reg 16 for control)
|
||
uint8_t clk0_ctrl = portapack::clock_manager.si5351_read_register(16);
|
||
bool clk0_enabled = !(output_enable_mask & 0x01) && !(clk0_ctrl & 0x80);
|
||
text_clk0_status.set(clk0_enabled ? "ON" : "OFF");
|
||
text_clk0_status.set_style(clk0_enabled ? Theme::getInstance()->fg_green
|
||
: Theme::getInstance()->fg_red);
|
||
|
||
// Read MS0 multisynth parameters (registers 42-49) to calculate actual frequency
|
||
// Si5351 MS0 Register Layout:
|
||
// Reg 42: P3[15:8]
|
||
// Reg 43: P3[7:0]
|
||
// Reg 44: bits 6:4 = R_DIV[2:0], bits 1:0 = P1[17:16]
|
||
// Reg 45: P1[15:8]
|
||
// Reg 46: P1[7:0]
|
||
// Reg 47: bits 7:4 = P3[19:16], bits 3:0 = P2[19:16]
|
||
// Reg 48: P2[15:8]
|
||
// Reg 49: P2[7:0]
|
||
uint8_t reg44 = portapack::clock_manager.si5351_read_register(44);
|
||
uint8_t reg45 = portapack::clock_manager.si5351_read_register(45);
|
||
uint8_t reg46 = portapack::clock_manager.si5351_read_register(46);
|
||
|
||
// Decode R divider from bits 6:4 of register 44
|
||
uint8_t r_div_encoded = (reg44 >> 4) & 0x07;
|
||
uint32_t r_div = 1 << r_div_encoded; // R = 2^r_div_encoded
|
||
|
||
// Decode P1 (18-bit value): bits 1:0 of reg44 = P1[17:16], reg45 = P1[15:8], reg46 = P1[7:0]
|
||
uint32_t p1 = ((uint32_t)(reg44 & 0x03) << 16) | ((uint32_t)reg45 << 8) | reg46;
|
||
|
||
// Calculate divider: a = (P1 + 512) / 128 for integer dividers (b=0)
|
||
// Expected for 8 MHz: P1=5888 (0x1700), a=50
|
||
uint32_t ms_div = (p1 + 512) / 128; // Integer divider value
|
||
|
||
// Calculate frequency: f_out = 800 MHz / ms_div / r_div
|
||
uint32_t freq_khz = 800000 / ms_div / r_div; // Result in kHz
|
||
|
||
// Show P1 value and R45 for debugging
|
||
text_clk0_freq_value.set(to_string_dec_uint(freq_khz) + " kHz (P1:" + to_string_hex(p1, 4) + ")");
|
||
text_clk0_div_value.set("MS=" + to_string_dec_uint(ms_div) +
|
||
" R=" + to_string_dec_uint(r_div));
|
||
|
||
// Color code based on expected 8 MHz
|
||
if (freq_khz >= 7900 && freq_khz <= 8100) {
|
||
text_clk0_freq_value.set_style(Theme::getInstance()->fg_green);
|
||
text_clk0_div_value.set_style(Theme::getInstance()->fg_green);
|
||
} else {
|
||
text_clk0_freq_value.set_style(Theme::getInstance()->fg_red);
|
||
text_clk0_div_value.set_style(Theme::getInstance()->fg_red);
|
||
}
|
||
|
||
// CLK1 (bit 1 of reg 3, reg 17 for control)
|
||
uint8_t clk1_ctrl = portapack::clock_manager.si5351_read_register(17);
|
||
bool clk1_enabled = !(output_enable_mask & 0x02) && !(clk1_ctrl & 0x80);
|
||
text_clk1_status.set(clk1_enabled ? "ON" : "OFF");
|
||
text_clk1_status.set_style(clk1_enabled ? Theme::getInstance()->fg_green
|
||
: Theme::getInstance()->fg_red);
|
||
}
|
||
|
||
void Si5351DebugView::reset_pll() {
|
||
// Reset both PLLs (write to reg 177)
|
||
portapack::clock_manager.si5351_read_register(177); // Read first
|
||
portapack::clock_manager.si5351_write_register(177, 0xAC); // Reset both PLLs
|
||
|
||
// Small delay for PLL to settle
|
||
chThdSleepMilliseconds(10);
|
||
|
||
// Refresh status to show new lock state
|
||
refresh_status();
|
||
}
|
||
|
||
#ifdef PRALINE
|
||
/* SignalPathStatusView *************************************************/
|
||
|
||
SignalPathStatusView::SignalPathStatusView(NavigationView& nav)
|
||
: nav_(nav) {
|
||
add_children({
|
||
&text_title,
|
||
&text_lbl_max_enable,
|
||
&text_max_enable,
|
||
&text_lbl_max_mode,
|
||
&text_max_mode,
|
||
&text_lbl_rf_path,
|
||
&text_rf_path,
|
||
&text_lbl_filter,
|
||
&text_filter,
|
||
&text_lbl_mixer,
|
||
&text_mixer,
|
||
&text_lbl_rf_amp,
|
||
&text_rf_amp,
|
||
&text_lbl_lna,
|
||
&text_lna,
|
||
&text_lbl_vga,
|
||
&text_vga,
|
||
&text_lbl_fpga_decim,
|
||
&text_fpga_decim,
|
||
&text_lbl_fpga_ctrl_dc_q,
|
||
&text_fpga_ctrl_dc_q,
|
||
&text_lbl_fpga_ctrl_qs,
|
||
&text_fpga_ctrl_qs,
|
||
&text_status,
|
||
&button_refresh,
|
||
&button_toggle_q,
|
||
&button_done,
|
||
});
|
||
|
||
text_title.set_style(Theme::getInstance()->fg_yellow);
|
||
|
||
button_refresh.on_select = [this](Button&) {
|
||
refresh_status();
|
||
};
|
||
|
||
button_toggle_q.on_select = [this](Button&) {
|
||
static bool q_override = false;
|
||
q_override = !q_override;
|
||
|
||
uint8_t ctrl_reg = 0x01; // DC_BLOCK always on
|
||
if (q_override) {
|
||
ctrl_reg |= 0x02; // Force Q_INVERT ON
|
||
}
|
||
|
||
radio::debug::fpga::register_write(1, ctrl_reg);
|
||
radio::invalidate_spi_config();
|
||
|
||
refresh_status();
|
||
};
|
||
|
||
button_done.on_select = [&nav](Button&) {
|
||
nav.pop();
|
||
};
|
||
|
||
// Initial update
|
||
refresh_status();
|
||
}
|
||
|
||
void SignalPathStatusView::focus() {
|
||
button_refresh.focus();
|
||
}
|
||
|
||
void SignalPathStatusView::refresh_status() {
|
||
// Get cached state from radio driver
|
||
rf::Direction direction = radio::debug::get_cached_direction();
|
||
bool rf_amp = radio::debug::get_cached_rf_amp();
|
||
int_fast8_t cached_lna = radio::debug::get_cached_lna_gain();
|
||
int_fast8_t cached_vga = radio::debug::get_cached_vga_gain();
|
||
|
||
// Get current band.
|
||
auto current_band = radio::debug::rf_path_info::get_current_band();
|
||
switch (current_band) {
|
||
case rf::path::Band::Low:
|
||
text_filter.set("LOW PASS");
|
||
text_filter.set_style(Theme::getInstance()->fg_green);
|
||
text_mixer.set("ENABLED");
|
||
text_mixer.set_style(Theme::getInstance()->fg_green);
|
||
break;
|
||
|
||
case rf::path::Band::Mid:
|
||
text_filter.set("BYPASS");
|
||
text_filter.set_style(Theme::getInstance()->fg_green);
|
||
text_mixer.set("DISABLED");
|
||
text_mixer.set_style(Theme::getInstance()->fg_orange);
|
||
break;
|
||
|
||
case rf::path::Band::High:
|
||
text_filter.set("HIGH PASS");
|
||
text_filter.set_style(Theme::getInstance()->fg_green);
|
||
text_mixer.set("ENABLED");
|
||
text_mixer.set_style(Theme::getInstance()->fg_green);
|
||
break;
|
||
|
||
default:
|
||
text_filter.set("UNKNOWN");
|
||
text_filter.set_style(Theme::getInstance()->fg_red);
|
||
text_mixer.set("UNKNOWN");
|
||
text_mixer.set_style(Theme::getInstance()->fg_red);
|
||
}
|
||
|
||
// Read actual register values to verify
|
||
uint32_t max_r11 = radio::debug::second_if::register_read(11);
|
||
|
||
// Decode actual LNA gain from register (bits 6:5)
|
||
uint8_t lna_bits = (max_r11 >> 5) & 0x03;
|
||
int actual_lna_db;
|
||
switch (lna_bits) {
|
||
case 0:
|
||
actual_lna_db = 0;
|
||
break; // -33 dB from max
|
||
case 2:
|
||
actual_lna_db = 17;
|
||
break; // -16 dB from max
|
||
case 3:
|
||
actual_lna_db = 33;
|
||
break; // Maximum
|
||
default:
|
||
actual_lna_db = -1;
|
||
break; // Invalid
|
||
}
|
||
|
||
// Decode actual VGA gain from register (bits 4:0)
|
||
uint8_t vga_bits = (max_r11 >> 0) & 0x1F;
|
||
int actual_vga_db = vga_bits * 2; // 0-31 → 0-62 dB
|
||
|
||
// MAX2831 Enable/Mode (GPIO-controlled, show cached state)
|
||
bool rx_mode = (direction == rf::Direction::Receive);
|
||
|
||
text_max_enable.set("ENABLED cached");
|
||
text_max_enable.set_style(Theme::getInstance()->fg_green);
|
||
|
||
text_max_mode.set(rx_mode ? "RX cached" : "TX cached");
|
||
text_max_mode.set_style(rx_mode ? Theme::getInstance()->fg_green
|
||
: Theme::getInstance()->fg_orange);
|
||
|
||
// RF path direction
|
||
text_rf_path.set(rx_mode ? "RECEIVE" : "TRANSMIT");
|
||
text_rf_path.set_style(rx_mode ? Theme::getInstance()->fg_green
|
||
: Theme::getInstance()->fg_orange);
|
||
|
||
// RF amp (GPIO-controlled, show cached state)
|
||
text_rf_amp.set(rf_amp ? "ON cached" : "OFF cached");
|
||
text_rf_amp.set_style(rf_amp ? Theme::getInstance()->fg_green
|
||
: Theme::getInstance()->fg_orange);
|
||
|
||
// LNA gain - show both cached and actual
|
||
if (actual_lna_db == cached_lna) {
|
||
text_lna.set(to_string_dec_uint(actual_lna_db) + " dB");
|
||
text_lna.set_style(Theme::getInstance()->fg_green);
|
||
} else if (actual_lna_db >= 0) {
|
||
// MAX2831 has discrete steps: 0, 17, 33 dB
|
||
// Allow ±8 dB tolerance for rounding
|
||
int diff = (actual_lna_db > cached_lna) ? (actual_lna_db - cached_lna) : (cached_lna - actual_lna_db);
|
||
|
||
if (diff <= 8) {
|
||
// Within rounding tolerance - show as OK with note
|
||
text_lna.set(to_string_dec_uint(actual_lna_db) + " dB (req:" +
|
||
to_string_dec_uint(cached_lna) + ")");
|
||
text_lna.set_style(Theme::getInstance()->fg_green);
|
||
} else {
|
||
// Genuine mismatch
|
||
text_lna.set(to_string_dec_uint(actual_lna_db) + " dB (!" +
|
||
to_string_dec_uint(cached_lna) + ")");
|
||
text_lna.set_style(Theme::getInstance()->fg_red);
|
||
}
|
||
} else {
|
||
text_lna.set("INVALID");
|
||
text_lna.set_style(Theme::getInstance()->fg_red);
|
||
}
|
||
|
||
// VGA gain - show both cached and actual
|
||
if (actual_vga_db == cached_vga) {
|
||
text_vga.set(to_string_dec_uint(actual_vga_db) + " dB");
|
||
text_vga.set_style(Theme::getInstance()->fg_green);
|
||
} else {
|
||
text_vga.set(to_string_dec_uint(actual_vga_db) + " dB (!" +
|
||
to_string_dec_uint(cached_vga) + ")");
|
||
text_vga.set_style(Theme::getInstance()->fg_red);
|
||
}
|
||
|
||
// FPGA decimation register
|
||
uint8_t fpga_decim = radio::debug::fpga::register_read(2);
|
||
text_fpga_decim.set("n=" + to_string_dec_uint(fpga_decim) +
|
||
" (/" + to_string_dec_uint(1 << fpga_decim) + ")");
|
||
|
||
// FPGA Register Ctrl Info
|
||
uint32_t fpga_ctrl = radio::debug::fpga::register_read(1);
|
||
// text_fpga_ctrl_dc_q.set(to_string_hex(fpga_ctrl, 2));
|
||
// text_fpga_ctrl_qs.set(to_string_hex(fpga_ctrl, 2));
|
||
|
||
// Decode bits
|
||
bool dc_block = fpga_ctrl & 0x01;
|
||
bool q_invert = fpga_ctrl & 0x02;
|
||
uint8_t quarter_shift = (fpga_ctrl >> 2) & 0x03;
|
||
|
||
// Display human-readable
|
||
std::string fpga_status_dc_q = "DC:" + std::string(dc_block ? "ON" : "OFF") +
|
||
" Q:" + std::string(q_invert ? "INV" : "NOR");
|
||
|
||
std::string fpga_status_qs = "QS:" + to_string_dec_uint(quarter_shift);
|
||
|
||
text_fpga_ctrl_dc_q.set(fpga_status_dc_q);
|
||
text_fpga_ctrl_qs.set(fpga_status_qs);
|
||
|
||
// Summary status
|
||
// Summary status - update to account for rounding tolerance
|
||
int lna_diff = (actual_lna_db > cached_lna) ? (actual_lna_db - cached_lna) : (cached_lna - actual_lna_db);
|
||
bool lna_ok = (actual_lna_db == cached_lna) || (lna_diff <= 8);
|
||
bool gains_match = lna_ok && (actual_vga_db == cached_vga);
|
||
if (rx_mode && gains_match) {
|
||
text_status.set("RX mode, gains verified!");
|
||
text_status.set_style(Theme::getInstance()->fg_green);
|
||
} else if (rx_mode && !gains_match) {
|
||
text_status.set("RX mode, gain MISMATCH!");
|
||
text_status.set_style(Theme::getInstance()->fg_red);
|
||
} else if (gains_match) {
|
||
text_status.set("TX mode, gains verified ✓");
|
||
text_status.set_style(Theme::getInstance()->fg_orange);
|
||
} else {
|
||
text_status.set("TX mode, gain MISMATCH!");
|
||
text_status.set_style(Theme::getInstance()->fg_red);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#ifdef PRALINE
|
||
/* SystemDiagnosticsView *************************************************/
|
||
SystemDiagnosticsView::SystemDiagnosticsView(NavigationView& nav) {
|
||
add_children({
|
||
&text_title,
|
||
&text_lbl_sample,
|
||
&text_sample_rate,
|
||
&text_lbl_band,
|
||
&text_band,
|
||
&button_sample_2m,
|
||
&button_sample_4m,
|
||
&button_sample_8m,
|
||
&button_sample_20m,
|
||
&text_lbl_bb_filter,
|
||
&text_bb_filter,
|
||
&text_lbl_reg8,
|
||
&text_reg8,
|
||
&text_lbl_gpio,
|
||
&text_lbl_lpf,
|
||
&text_gpio_lpf,
|
||
&text_lbl_mix,
|
||
&text_gpio_mix,
|
||
&text_lbl_amp,
|
||
&text_gpio_amp,
|
||
&text_lbl_fpga,
|
||
&text_lbl_fpga_ctrl,
|
||
&text_fpga_ctrl,
|
||
&text_lbl_fpga_decode,
|
||
&button_toggle_q,
|
||
&button_toggle_dc,
|
||
&button_refresh,
|
||
&button_done,
|
||
});
|
||
|
||
text_title.set_style(Theme::getInstance()->fg_yellow);
|
||
text_lbl_gpio.set_style(Theme::getInstance()->fg_yellow);
|
||
text_lbl_fpga.set_style(Theme::getInstance()->fg_yellow);
|
||
|
||
// Sample rate buttons
|
||
button_sample_2m.on_select = [this](Button&) {
|
||
set_sample_rate(2000000);
|
||
};
|
||
|
||
button_sample_4m.on_select = [this](Button&) {
|
||
set_sample_rate(4000000);
|
||
};
|
||
|
||
button_sample_8m.on_select = [this](Button&) {
|
||
set_sample_rate(8000000);
|
||
};
|
||
|
||
button_sample_20m.on_select = [this](Button&) {
|
||
set_sample_rate(20000000);
|
||
};
|
||
|
||
// Q inversion toggle
|
||
button_toggle_q.on_select = [this](Button&) {
|
||
uint32_t current = radio::debug::fpga::register_read(1);
|
||
uint8_t new_val = current ^ 0x02; // Toggle Q_INVERT bit
|
||
radio::debug::fpga::register_write(1, new_val);
|
||
radio::invalidate_spi_config();
|
||
refresh();
|
||
};
|
||
|
||
// DC block toggle
|
||
button_toggle_dc.on_select = [this](Button&) {
|
||
uint32_t current = radio::debug::fpga::register_read(1);
|
||
uint8_t new_val = current ^ 0x01; // Toggle DC_BLOCK bit
|
||
radio::debug::fpga::register_write(1, new_val);
|
||
radio::invalidate_spi_config();
|
||
refresh();
|
||
};
|
||
|
||
button_refresh.on_select = [this](Button&) {
|
||
refresh();
|
||
};
|
||
|
||
button_done.on_select = [&nav](Button&) {
|
||
nav.pop();
|
||
};
|
||
|
||
refresh();
|
||
}
|
||
|
||
void SystemDiagnosticsView::focus() {
|
||
button_refresh.focus();
|
||
}
|
||
|
||
void SystemDiagnosticsView::set_sample_rate(uint32_t rate) {
|
||
portapack::clock_manager.set_sampling_frequency(rate);
|
||
refresh();
|
||
}
|
||
|
||
void SystemDiagnosticsView::read_gpio_states() {
|
||
// Read actual GPIO port states
|
||
uint32_t gpio3_state = LPC_GPIO->PIN[3]; // GPIO3 for mixer
|
||
uint32_t gpio4_state = LPC_GPIO->PIN[4]; // GPIO4 for LPF and amp
|
||
|
||
// Extract specific pins based on hackrf_gpio.hpp definitions:
|
||
// gpio_mix_enable_n = GPIO3_2 (P6_3) - bit 2 of port 3, INVERTED
|
||
// gpio_lpf_enable = GPIO4_8 (PA_1) - bit 8 of port 4
|
||
// gpio_rf_amp_enable = GPIO4_9 (PA_2) - bit 9 of port 4
|
||
|
||
bool mix_n_actual = (gpio3_state >> 2) & 1; // GPIO3[2]
|
||
bool lpf_actual = (gpio4_state >> 8) & 1; // GPIO4[8]
|
||
bool amp_actual = (gpio4_state >> 9) & 1; // GPIO4[9]
|
||
|
||
// Mixer is active LOW, so invert for display
|
||
bool mixer_enabled = !mix_n_actual;
|
||
|
||
// Display with GPIO pin numbers
|
||
text_gpio_lpf.set(
|
||
std::string(lpf_actual ? "ON" : "OFF") +
|
||
" (GPIO4[8]=" + to_string_dec_uint(lpf_actual ? 1 : 0) + ")");
|
||
|
||
text_gpio_mix.set(
|
||
std::string(mixer_enabled ? "ENABLED" : "BYPASSED") +
|
||
" (GPIO3[2]=" + to_string_dec_uint(mix_n_actual ? 1 : 0) + ")");
|
||
|
||
text_gpio_amp.set(
|
||
std::string(amp_actual ? "ON" : "OFF") +
|
||
" (GPIO4[9]=" + to_string_dec_uint(amp_actual ? 1 : 0) + ")");
|
||
|
||
// Color code
|
||
text_gpio_lpf.set_style(lpf_actual ? Theme::getInstance()->fg_green : Theme::getInstance()->fg_red);
|
||
text_gpio_mix.set_style(mixer_enabled ? Theme::getInstance()->fg_green : Theme::getInstance()->fg_red);
|
||
text_gpio_amp.set_style(amp_actual ? Theme::getInstance()->fg_green : Theme::getInstance()->fg_orange);
|
||
}
|
||
|
||
void SystemDiagnosticsView::refresh() {
|
||
// Sample rate
|
||
uint32_t sample_rate = portapack::clock_manager.get_sampling_frequency();
|
||
if (sample_rate >= 1000000) {
|
||
text_sample_rate.set(to_string_dec_uint(sample_rate / 1000000) + " MSS");
|
||
} else {
|
||
text_sample_rate.set(to_string_dec_uint(sample_rate / 1000) + " kSS");
|
||
}
|
||
|
||
// Baseband filter bandwidth
|
||
uint32_t reg8 = radio::debug::second_if::register_read(8);
|
||
text_reg8.set("0x" + to_string_hex(reg8, 4));
|
||
|
||
uint8_t lpf_coarse = reg8 & 0x03; // Bits 1:0
|
||
const char* bw_names[] = {"7.5 MHz", "8.5 MHz", "15 MHz", "18 MHz"};
|
||
text_bb_filter.set(bw_names[lpf_coarse]);
|
||
|
||
// Color code - green if >= 8 MHz, red otherwise
|
||
if (lpf_coarse >= 1) {
|
||
text_bb_filter.set_style(Theme::getInstance()->fg_green);
|
||
} else {
|
||
text_bb_filter.set_style(Theme::getInstance()->fg_red);
|
||
}
|
||
|
||
// Read actual GPIO pin states
|
||
read_gpio_states();
|
||
|
||
uint32_t gpio6_pin = LPC_GPIO->PIN[6];
|
||
bool rffc_locked = (gpio6_pin >> 25) & 1;
|
||
|
||
// Display it by changing one of the existing fields temporarily
|
||
// For example, modify the band display to show lock status:
|
||
|
||
auto current_band = radio::debug::rf_path_info::get_current_band();
|
||
switch (current_band) {
|
||
case rf::path::Band::Low:
|
||
text_band.set("LOW(0-2320MHz)|" + std::string(rffc_locked ? "LCK)" : "ULCK)"));
|
||
text_band.set_style(rffc_locked ? Theme::getInstance()->fg_green : Theme::getInstance()->fg_red);
|
||
break;
|
||
case rf::path::Band::Mid:
|
||
text_band.set("MID(2320-2740MHz)");
|
||
text_band.set_style(Theme::getInstance()->fg_green);
|
||
break;
|
||
case rf::path::Band::High:
|
||
text_band.set("HIGH(2740-7250MHz)");
|
||
text_band.set_style(Theme::getInstance()->fg_green);
|
||
break;
|
||
}
|
||
// FPGA control register
|
||
uint32_t fpga_ctrl = radio::debug::fpga::register_read(1);
|
||
text_fpga_ctrl.set("0x" + to_string_hex(fpga_ctrl, 2));
|
||
|
||
// Decode FPGA register bits
|
||
bool dc_block = fpga_ctrl & 0x01;
|
||
bool q_invert = fpga_ctrl & 0x02;
|
||
uint8_t quarter_shift = (fpga_ctrl >> 2) & 0x03;
|
||
|
||
text_lbl_fpga_decode.set(
|
||
"|DC:" + std::string(dc_block ? "ON" : "OFF") +
|
||
" Q:" + std::string(q_invert ? "INV" : "NOR") +
|
||
" QS:" + to_string_dec_uint(quarter_shift));
|
||
}
|
||
#endif
|
||
|
||
#ifdef PRALINE
|
||
/* GPIODebugView *************************************************/
|
||
GPIODebugView::GPIODebugView(NavigationView& nav) {
|
||
add_children({
|
||
&text_lbl_gpio4,
|
||
&text_lbl_dir4,
|
||
&text_dir4,
|
||
&text_lbl_pin4,
|
||
&text_pin4,
|
||
&text_lbl_set4,
|
||
&text_set4,
|
||
&text_lbl_lpf_bit,
|
||
&text_lpf_dir,
|
||
&text_lpf_pin,
|
||
&text_lpf_set,
|
||
&button_lpf_toggle,
|
||
&button_lpf_on,
|
||
&button_lpf_off,
|
||
&text_lbl_amp_bit,
|
||
&text_amp_dir,
|
||
&text_amp_pin,
|
||
&text_amp_set,
|
||
&button_amp_toggle,
|
||
&button_amp_on,
|
||
&button_amp_off,
|
||
&text_lbl_gpio3,
|
||
&text_lbl_mix_bit,
|
||
&text_mix_dir,
|
||
&text_mix_pin,
|
||
&text_mix_set,
|
||
&button_refresh,
|
||
&button_done,
|
||
});
|
||
|
||
text_lbl_gpio4.set_style(Theme::getInstance()->fg_yellow);
|
||
text_lbl_gpio3.set_style(Theme::getInstance()->fg_yellow);
|
||
|
||
// LPF control buttons
|
||
button_lpf_toggle.on_select = [this](Button&) {
|
||
// Read current state
|
||
uint32_t current = LPC_GPIO->PIN[4];
|
||
bool current_state = (current >> 8) & 1;
|
||
|
||
// Toggle
|
||
if (current_state) {
|
||
LPC_GPIO->CLR[4] = (1 << 8); // Clear bit 8
|
||
} else {
|
||
LPC_GPIO->SET[4] = (1 << 8); // Set bit 8
|
||
}
|
||
|
||
refresh();
|
||
};
|
||
|
||
button_lpf_on.on_select = [this](Button&) {
|
||
LPC_GPIO->SET[4] = (1 << 8); // Force ON
|
||
refresh();
|
||
};
|
||
|
||
button_lpf_off.on_select = [this](Button&) {
|
||
LPC_GPIO->CLR[4] = (1 << 8); // Force OFF
|
||
refresh();
|
||
};
|
||
|
||
// RF Amp control buttons
|
||
button_amp_toggle.on_select = [this](Button&) {
|
||
uint32_t current = LPC_GPIO->PIN[4];
|
||
bool current_state = (current >> 9) & 1;
|
||
|
||
if (current_state) {
|
||
LPC_GPIO->CLR[4] = (1 << 9);
|
||
} else {
|
||
LPC_GPIO->SET[4] = (1 << 9);
|
||
}
|
||
|
||
refresh();
|
||
};
|
||
|
||
button_amp_on.on_select = [this](Button&) {
|
||
LPC_GPIO->SET[4] = (1 << 9); // Force ON
|
||
refresh();
|
||
};
|
||
|
||
button_amp_off.on_select = [this](Button&) {
|
||
LPC_GPIO->CLR[4] = (1 << 9); // Force OFF
|
||
refresh();
|
||
};
|
||
|
||
button_refresh.on_select = [this](Button&) {
|
||
refresh();
|
||
};
|
||
|
||
button_done.on_select = [&nav](Button&) {
|
||
nav.pop();
|
||
};
|
||
|
||
refresh();
|
||
}
|
||
|
||
void GPIODebugView::focus() {
|
||
button_refresh.focus();
|
||
}
|
||
|
||
void GPIODebugView::refresh() {
|
||
// Read GPIO4 registers
|
||
uint32_t gpio4_dir = LPC_GPIO->DIR[4]; // Direction: 1=output, 0=input
|
||
uint32_t gpio4_pin = LPC_GPIO->PIN[4]; // Actual pin state
|
||
uint32_t gpio4_set = LPC_GPIO->SET[4]; // What we're trying to output
|
||
|
||
// Display full registers
|
||
text_dir4.set("0x" + to_string_hex(gpio4_dir, 8));
|
||
text_pin4.set("0x" + to_string_hex(gpio4_pin, 8));
|
||
text_set4.set("0x" + to_string_hex(gpio4_set, 8));
|
||
|
||
// Extract bit 8 (LPF)
|
||
bool lpf_dir = (gpio4_dir >> 8) & 1;
|
||
bool lpf_pin = (gpio4_pin >> 8) & 1;
|
||
bool lpf_set = (gpio4_set >> 8) & 1;
|
||
|
||
text_lpf_dir.set("DIR: " + std::string(lpf_dir ? "OUT" : "IN"));
|
||
text_lpf_pin.set("PIN: " + std::string(lpf_pin ? "1" : "0"));
|
||
text_lpf_set.set("SET: " + std::string(lpf_set ? "1" : "0"));
|
||
|
||
// Color code
|
||
text_lpf_dir.set_style(lpf_dir ? Theme::getInstance()->fg_green : Theme::getInstance()->fg_red);
|
||
text_lpf_pin.set_style(lpf_pin ? Theme::getInstance()->fg_green : Theme::getInstance()->fg_red);
|
||
|
||
// Extract bit 9 (RF Amp)
|
||
bool amp_dir = (gpio4_dir >> 9) & 1;
|
||
bool amp_pin = (gpio4_pin >> 9) & 1;
|
||
bool amp_set = (gpio4_set >> 9) & 1;
|
||
|
||
text_amp_dir.set("DIR: " + std::string(amp_dir ? "OUT" : "IN"));
|
||
text_amp_pin.set("PIN: " + std::string(amp_pin ? "1" : "0"));
|
||
text_amp_set.set("SET: " + std::string(amp_set ? "1" : "0"));
|
||
|
||
text_amp_dir.set_style(amp_dir ? Theme::getInstance()->fg_green : Theme::getInstance()->fg_red);
|
||
text_amp_pin.set_style(amp_pin ? Theme::getInstance()->fg_green : Theme::getInstance()->fg_red);
|
||
|
||
// Read GPIO3 (Mixer) - bit 2
|
||
uint32_t gpio3_dir = LPC_GPIO->DIR[3];
|
||
uint32_t gpio3_pin = LPC_GPIO->PIN[3];
|
||
uint32_t gpio3_set = LPC_GPIO->SET[3];
|
||
|
||
bool mix_dir = (gpio3_dir >> 2) & 1;
|
||
bool mix_pin = (gpio3_pin >> 2) & 1;
|
||
bool mix_set = (gpio3_set >> 2) & 1;
|
||
|
||
text_mix_dir.set("DIR: " + std::string(mix_dir ? "OUT" : "IN"));
|
||
text_mix_pin.set("PIN: " + std::string(mix_pin ? "1" : "0"));
|
||
text_mix_set.set("SET: " + std::string(mix_set ? "1" : "0"));
|
||
|
||
text_mix_dir.set_style(mix_dir ? Theme::getInstance()->fg_green : Theme::getInstance()->fg_red);
|
||
text_mix_pin.set_style(mix_pin ? Theme::getInstance()->fg_green : Theme::getInstance()->fg_red);
|
||
}
|
||
#endif
|
||
|
||
#ifdef PRALINE
|
||
/* RFFC5072StatusView *************************************************/
|
||
|
||
RFFC5072StatusView::RFFC5072StatusView(NavigationView& nav)
|
||
: nav_(nav) {
|
||
add_children({
|
||
&text_title,
|
||
&text_lbl_lock,
|
||
&text_lock,
|
||
&text_lbl_ctrl,
|
||
&text_ctrl,
|
||
&text_lbl_enabled,
|
||
&text_enabled,
|
||
&text_lbl_freq,
|
||
&text_freq,
|
||
&text_lbl_path,
|
||
&text_path,
|
||
&text_lbl_mixer,
|
||
&text_mixer,
|
||
&text_lbl_r0,
|
||
&text_r0,
|
||
&text_lbl_r1,
|
||
&text_r1,
|
||
&text_lbl_r2,
|
||
&text_r2,
|
||
&text_lbl_n,
|
||
&text_n,
|
||
&text_lbl_lodiv,
|
||
&text_lodiv,
|
||
&text_lbl_calc,
|
||
&text_calc,
|
||
&text_status,
|
||
&text_lbl_regs_status,
|
||
&text_regs_status,
|
||
&button_refresh,
|
||
&button_done,
|
||
});
|
||
|
||
text_title.set_style(Theme::getInstance()->fg_yellow);
|
||
|
||
button_refresh.on_select = [this](Button&) {
|
||
refresh_status();
|
||
};
|
||
|
||
button_done.on_select = [&nav](Button&) {
|
||
nav.pop();
|
||
};
|
||
|
||
// Initial update
|
||
refresh_status();
|
||
}
|
||
|
||
void RFFC5072StatusView::focus() {
|
||
button_refresh.focus();
|
||
}
|
||
|
||
void RFFC5072StatusView::refresh_status() {
|
||
// === READ RAW GPIO STATES FOR DEBUGGING ===
|
||
uint32_t gpio2_dir = LPC_GPIO->DIR[2];
|
||
uint32_t gpio2_pin = LPC_GPIO->PIN[2];
|
||
|
||
// Check if the pins are even configured as outputs
|
||
bool enx_is_output = (gpio2_dir >> 13) & 1;
|
||
bool resetx_is_output = (gpio2_dir >> 14) & 1;
|
||
|
||
// === LOCK DETECT ===
|
||
uint32_t gpio6_pin = LPC_GPIO->PIN[6];
|
||
bool rffc_locked = (gpio6_pin >> 25) & 1;
|
||
|
||
text_lock.set(rffc_locked ? "LOCKED" : "UNLOCKED");
|
||
text_lock.set_style(rffc_locked ? Theme::getInstance()->fg_green
|
||
: Theme::getInstance()->fg_red);
|
||
|
||
uint8_t fpga_reg1 = radio::debug::fpga::register_read(1); // CTRL register
|
||
uint8_t fpga_reg2 = radio::debug::fpga::register_read(2); // RX_DECIM
|
||
|
||
text_regs_status.set(
|
||
"FPGA R1:" + to_string_hex(fpga_reg1, 2) +
|
||
" R2:" + to_string_hex(fpga_reg2, 2));
|
||
|
||
// === CONTROL PINS ===
|
||
// ENX = GPIO2[13] (P5_4) - active LOW (0 = enabled)
|
||
// RESETX = GPIO2[14] (P5_5) - active LOW (0 = reset)
|
||
bool enx = (gpio2_pin >> 13) & 1;
|
||
bool resetx = (gpio2_pin >> 14) & 1;
|
||
|
||
text_ctrl.set(std::string(enx ? "DIS" : "EN") + " " +
|
||
std::string(resetx ? "RUN" : "RST") + " " +
|
||
"O:" + std::string(resetx_is_output ? "Y" : "N"));
|
||
|
||
text_ctrl.set_style((enx == 0 && resetx == 1) ? Theme::getInstance()->fg_green
|
||
: Theme::getInstance()->fg_red);
|
||
|
||
// === REGISTERS ===
|
||
// Read CORRECT registers for Path 2 (active path!)
|
||
uint32_t r0 = radio::debug::first_if::register_read(0); // Control
|
||
uint32_t r15 = radio::debug::first_if::register_read(15); // P2_FREQ1
|
||
uint32_t r16 = radio::debug::first_if::register_read(16); // P2_FREQ2
|
||
|
||
// Display
|
||
text_r0.set(to_string_hex(r0, 4));
|
||
text_r1.set(to_string_hex(r15, 4) + " (R15)");
|
||
text_r2.set(to_string_hex(r16, 4) + " (R16)");
|
||
|
||
// Check enabled (R0 bit 4)
|
||
bool enabled = (r0 & 0x0010) != 0;
|
||
text_enabled.set(enabled ? "ENABLED" : "DISABLED");
|
||
text_enabled.set_style(enabled ? Theme::getInstance()->fg_green
|
||
: Theme::getInstance()->fg_red);
|
||
|
||
// Decode from P2_FREQ1 (R15)
|
||
uint16_t n_int = (r15 >> 7) & 0x1FF; // 9 bits
|
||
uint8_t lodiv_sel = (r15 >> 4) & 0x07; // 3 bits
|
||
uint8_t presc_sel = (r15 >> 2) & 0x03; // 2 bits
|
||
|
||
text_n.set(to_string_dec_uint(n_int));
|
||
|
||
// LO divider: 0=÷2, 1=÷4, 2=÷8, 3=÷16, 4=÷32, 5=÷64
|
||
uint16_t lodiv_val = 1u << lodiv_sel;
|
||
uint16_t presc_val = 1u << presc_sel;
|
||
|
||
text_lodiv.set("/" + to_string_dec_uint(lodiv_val) +
|
||
" (P:/" + to_string_dec_uint(presc_val) + ")");
|
||
|
||
// Calculate frequencies
|
||
const uint32_t f_ref_mhz = 40;
|
||
uint32_t f_vco_mhz = (f_ref_mhz * n_int) / presc_val;
|
||
uint32_t f_lo_mhz = f_vco_mhz / lodiv_val;
|
||
|
||
text_calc.set(to_string_dec_uint(f_lo_mhz) + " MHz");
|
||
text_freq.set(to_string_dec_uint(f_vco_mhz) + " MHz VCO");
|
||
|
||
// Check ranges
|
||
bool vco_ok = (f_vco_mhz >= 2700) && (f_vco_mhz <= 5400);
|
||
bool lo_ok = (f_lo_mhz >= 2300) && (f_lo_mhz <= 2700);
|
||
|
||
text_calc.set_style(lo_ok ? Theme::getInstance()->fg_green
|
||
: Theme::getInstance()->fg_red);
|
||
text_freq.set_style(vco_ok ? Theme::getInstance()->fg_green
|
||
: Theme::getInstance()->fg_red);
|
||
|
||
// Check mixer mode
|
||
bool path2_active = (r0 & 0x0020) != 0;
|
||
text_path.set(path2_active ? "PATH2" : "PATH1");
|
||
text_mixer.set(path2_active ? "ACTIVE" : "INACTIVE");
|
||
text_mixer.set_style(path2_active ? Theme::getInstance()->fg_green
|
||
: Theme::getInstance()->fg_orange);
|
||
|
||
// === SUMMARY STATUS ===
|
||
if (!rffc_locked) {
|
||
text_status.set("PLL UNLOCKED!");
|
||
text_status.set_style(Theme::getInstance()->fg_red);
|
||
} else if (enx == 1) {
|
||
text_status.set("DISABLED (ENX=1)!");
|
||
text_status.set_style(Theme::getInstance()->fg_red);
|
||
} else if (resetx == 0) {
|
||
text_status.set("IN RESET (RESETX=0)!");
|
||
text_status.set_style(Theme::getInstance()->fg_red);
|
||
} else if (!enabled) {
|
||
text_status.set("R0 bit 4 = 0 (disabled)");
|
||
text_status.set_style(Theme::getInstance()->fg_red);
|
||
} else if (!path2_active) {
|
||
text_status.set("Path 2 not selected!");
|
||
text_status.set_style(Theme::getInstance()->fg_red);
|
||
} else if (!vco_ok) {
|
||
text_status.set("VCO out of range!");
|
||
text_status.set_style(Theme::getInstance()->fg_red);
|
||
} else if (!lo_ok) {
|
||
text_status.set("LO out of range!");
|
||
text_status.set_style(Theme::getInstance()->fg_red);
|
||
} else {
|
||
text_status.set("All checks passed!");
|
||
text_status.set_style(Theme::getInstance()->fg_green);
|
||
}
|
||
}
|
||
|
||
/* RFFCTuningDebugView *************************************************/
|
||
RFFCTuningDebugView::RFFCTuningDebugView(NavigationView& nav) {
|
||
add_children({
|
||
&text_title,
|
||
&text_lbl_called,
|
||
&text_called,
|
||
&text_lbl_req,
|
||
&text_req,
|
||
&text_lbl_exp_n,
|
||
&text_exp_n,
|
||
&text_lbl_act_n,
|
||
&text_act_n,
|
||
&text_lbl_exp_div,
|
||
&text_exp_div,
|
||
&text_lbl_act_div,
|
||
&text_act_div,
|
||
&text_lbl_calc,
|
||
&text_calc,
|
||
&text_lbl_calc_lo,
|
||
&text_calc_lo,
|
||
&text_lbl_calc_vco,
|
||
&text_calc_vco,
|
||
&text_lbl_vco,
|
||
&text_vco,
|
||
&text_lbl_n_q24,
|
||
&text_n_q24,
|
||
&text_status,
|
||
&button_refresh,
|
||
&button_done,
|
||
});
|
||
|
||
button_refresh.on_select = [this](Button&) {
|
||
refresh();
|
||
};
|
||
|
||
button_done.on_select = [&nav](Button&) {
|
||
nav.pop();
|
||
};
|
||
|
||
refresh();
|
||
}
|
||
|
||
void RFFCTuningDebugView::focus() {
|
||
button_refresh.focus();
|
||
}
|
||
|
||
void RFFCTuningDebugView::refresh() {
|
||
// Get expected values from last tuning attempt
|
||
auto tuning = radio::debug::first_if::get_tuning_info();
|
||
|
||
// Show if set_frequency was ever called
|
||
if (tuning.was_called) {
|
||
text_called.set("YES");
|
||
text_called.set_style(Theme::getInstance()->fg_green);
|
||
|
||
text_req.set(to_string_dec_uint(tuning.requested_freq_mhz) + " MHz");
|
||
text_exp_n.set(to_string_dec_uint(tuning.expected_n));
|
||
|
||
uint16_t exp_lo = 1 << tuning.expected_lodiv;
|
||
uint16_t exp_pr = 1 << tuning.expected_presc;
|
||
text_exp_div.set(to_string_dec_uint(exp_lo) + " / " + to_string_dec_uint(exp_pr));
|
||
} else {
|
||
text_called.set("NO");
|
||
text_called.set_style(Theme::getInstance()->fg_red);
|
||
text_req.set("---");
|
||
text_exp_n.set("---");
|
||
text_exp_div.set("---");
|
||
}
|
||
|
||
// Read actual hardware values
|
||
uint32_t r15 = radio::debug::first_if::register_read(15);
|
||
|
||
uint16_t act_n = (r15 >> 7) & 0x1FF;
|
||
uint8_t act_lo_sel = (r15 >> 4) & 0x07;
|
||
uint8_t act_pr_sel = (r15 >> 2) & 0x03;
|
||
|
||
uint16_t act_lo = 1 << act_lo_sel;
|
||
uint16_t act_pr = 1 << act_pr_sel;
|
||
|
||
text_act_n.set(to_string_dec_uint(act_n));
|
||
text_act_div.set(to_string_dec_uint(act_lo) + " / " + to_string_dec_uint(act_pr));
|
||
|
||
// Calculate what this produces
|
||
uint32_t calc_vco = (40 * act_n) / act_pr;
|
||
uint32_t calc_lo = calc_vco / act_lo;
|
||
text_calc.set(to_string_dec_uint(calc_lo) + " MHz");
|
||
text_vco.set(to_string_dec_uint(tuning.calculated_vco_mhz) + " MHz");
|
||
|
||
text_calc_lo.set(to_string_dec_uint(tuning.calc_lo_freq_mhz) + " MHz");
|
||
text_calc_vco.set(to_string_dec_uint(tuning.calc_vco_inside_mhz) + " MHz");
|
||
text_n_q24.set(to_string_dec_uint(tuning.calc_n_q24 >> 24)); // Show integer part
|
||
|
||
// Status comparison
|
||
if (!tuning.was_called) {
|
||
text_status.set("RFFC Freq set NEVER called!");
|
||
text_status.set_style(Theme::getInstance()->fg_red);
|
||
} else if (act_n == tuning.expected_n) {
|
||
text_status.set("MATCH! Hardware as expected!");
|
||
text_status.set_style(Theme::getInstance()->fg_green);
|
||
} else {
|
||
text_status.set("MISMATCH! Exp:" + to_string_dec_uint(tuning.expected_n) +
|
||
" Act:" + to_string_dec_uint(act_n));
|
||
text_status.set_style(Theme::getInstance()->fg_red);
|
||
}
|
||
}
|
||
|
||
/* MAX2831DebugView *************************************************/
|
||
MAX2831DebugView::MAX2831DebugView(NavigationView& nav) {
|
||
add_children({
|
||
&text_title,
|
||
&text_lbl_called,
|
||
&text_called,
|
||
&text_lbl_valid,
|
||
&text_valid,
|
||
&text_lbl_req,
|
||
&text_req,
|
||
&text_lbl_calc_n,
|
||
&text_calc_n,
|
||
&text_lbl_calc_frac,
|
||
&text_calc_frac,
|
||
&text_spacer,
|
||
&text_lbl_r3,
|
||
&text_r3,
|
||
&text_lbl_r4,
|
||
&text_r4,
|
||
&text_lbl_act_n,
|
||
&text_act_n,
|
||
&text_lbl_act_frac,
|
||
&text_act_frac,
|
||
&text_lbl_calc_freq,
|
||
&text_calc_freq,
|
||
&text_status,
|
||
&button_refresh,
|
||
&button_done,
|
||
});
|
||
|
||
text_spacer.set_style(Theme::getInstance()->fg_yellow);
|
||
|
||
button_refresh.on_select = [this](Button&) {
|
||
refresh();
|
||
};
|
||
|
||
button_done.on_select = [&nav](Button&) {
|
||
nav.pop();
|
||
};
|
||
|
||
refresh();
|
||
}
|
||
|
||
void MAX2831DebugView::focus() {
|
||
button_refresh.focus();
|
||
}
|
||
|
||
void MAX2831DebugView::refresh() {
|
||
auto info = radio::debug::second_if::get_max2831_info();
|
||
|
||
// Show if set_frequency was called
|
||
if (info.set_frequency_called) {
|
||
text_called.set("YES");
|
||
text_called.set_style(Theme::getInstance()->fg_green);
|
||
|
||
if (info.frequency_valid) {
|
||
text_valid.set("YES (2.3-2.6G)");
|
||
text_valid.set_style(Theme::getInstance()->fg_green);
|
||
} else {
|
||
text_valid.set("NO - OUT OF RANGE!");
|
||
text_valid.set_style(Theme::getInstance()->fg_red);
|
||
}
|
||
|
||
text_req.set(to_string_dec_uint(info.requested_freq_mhz) + " MHz");
|
||
text_calc_n.set(to_string_dec_uint(info.calculated_n));
|
||
text_calc_frac.set(to_string_hex(info.calculated_frac, 5));
|
||
} else {
|
||
text_called.set("NO");
|
||
text_called.set_style(Theme::getInstance()->fg_red);
|
||
text_valid.set("---");
|
||
text_req.set("---");
|
||
text_calc_n.set("---");
|
||
text_calc_frac.set("---");
|
||
}
|
||
|
||
// Read actual hardware registers
|
||
uint32_t r3 = radio::debug::second_if::register_read(3);
|
||
uint32_t r4 = radio::debug::second_if::register_read(4);
|
||
|
||
text_r3.set(to_string_hex(r3, 4));
|
||
text_r4.set(to_string_hex(r4, 4));
|
||
|
||
// Decode actual values from registers
|
||
uint16_t act_n = r3 & 0xFF;
|
||
uint32_t act_frac_lo = (r3 >> 8) & 0x3F;
|
||
uint32_t act_frac_hi = r4 & 0x3FFF;
|
||
uint32_t act_frac = (act_frac_hi << 6) | act_frac_lo;
|
||
|
||
text_act_n.set(to_string_dec_uint(act_n));
|
||
text_act_frac.set(to_string_hex(act_frac, 5));
|
||
|
||
// Calculate actual frequency from registers
|
||
// F_LO = 20 MHz × (N + Frac/2^20)
|
||
// For display, show integer part only
|
||
uint32_t calc_freq_mhz = 20 * act_n;
|
||
// Add fractional contribution (approximate)
|
||
uint32_t frac_contribution = (act_frac * 20) >> 20;
|
||
calc_freq_mhz += frac_contribution;
|
||
|
||
text_calc_freq.set(to_string_dec_uint(calc_freq_mhz) + " MHz");
|
||
|
||
// Status
|
||
if (!info.set_frequency_called) {
|
||
text_status.set("MAX2831 set_frequency\nNEVER called!");
|
||
text_status.set_style(Theme::getInstance()->fg_red);
|
||
} else if (!info.frequency_valid) {
|
||
text_status.set("Freq " + to_string_dec_uint(info.requested_freq_mhz) +
|
||
" MHz OUT OF RANGE!\n(need 2300-2600)");
|
||
text_status.set_style(Theme::getInstance()->fg_red);
|
||
} else if (act_n == info.calculated_n && act_frac == info.calculated_frac) {
|
||
text_status.set("MATCH!\nHardware = Expected");
|
||
text_status.set_style(Theme::getInstance()->fg_green);
|
||
} else {
|
||
text_status.set("MISMATCH!\nN: exp=" + to_string_dec_uint(info.calculated_n) +
|
||
" act=" + to_string_dec_uint(act_n));
|
||
text_status.set_style(Theme::getInstance()->fg_red);
|
||
}
|
||
}
|
||
|
||
#endif
|
||
|
||
#endif
|
||
/* DebugPeripheralsMenuView **********************************************/
|
||
|
||
DebugPeripheralsMenuView::DebugPeripheralsMenuView(NavigationView& nav)
|
||
: nav_(nav) {
|
||
set_max_rows(2); // allow wider buttons
|
||
}
|
||
|
||
void DebugPeripheralsMenuView::on_populate() {
|
||
#ifdef PRALINE
|
||
const char* max283x = "MAX2831";
|
||
#else
|
||
const char* max283x = hackrf_r9 ? "MAX2839" : "MAX2837";
|
||
#endif
|
||
const char* si5351x = hackrf_r9 ? "Si5351A" : "Si5351C";
|
||
add_items({
|
||
{"RFFC5072", Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_peripherals_details, [this]() { nav_.push<RegistersView>("RFFC5072", RegistersWidgetConfig{CT_RFFC5072, 31, 31, 16}); }},
|
||
#ifdef PRALINE
|
||
{max283x, Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_peripherals_details, [this, max283x]() { nav_.push<RegistersView>(max283x, RegistersWidgetConfig{CT_MAX283X, 16, 16, 14}); }},
|
||
{"FPGA", Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_peripherals_details, [this]() { nav_.push<RegistersView>("FPGA (iCE40)", RegistersWidgetConfig{CT_FPGA, 6, 6, 8}); }},
|
||
#else
|
||
{max283x, Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_peripherals_details, [this, max283x]() { nav_.push<RegistersView>(max283x, RegistersWidgetConfig{CT_MAX283X, 32, 32, 10}); }},
|
||
#endif
|
||
{"SGPIO", Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_peripherals_details, [this]() { nav_.push<RegistersView>("SGPIO", RegistersWidgetConfig{CT_SGPIO, 6, 6, 16}); }},
|
||
{si5351x, Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_peripherals_details, [this, si5351x]() { nav_.push<RegistersView>(si5351x, RegistersWidgetConfig{CT_SI5351, 188, 96, 8}); }},
|
||
{audio::debug::codec_name(), Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_peripherals_details, [this]() { nav_.push<RegistersView>(audio::debug::codec_name(), RegistersWidgetConfig{CT_AUDIO, audio::debug::reg_count(), audio::debug::reg_count(), audio::debug::reg_bits()}); }},
|
||
});
|
||
if (i2cdev::I2CDevManager::get_dev_by_model(I2C_DEVMDL::I2CDEVMDL_MAX17055)) {
|
||
add_item(
|
||
{"MAX17055", Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_peripherals_details, [this]() { nav_.push<RegistersView>("MAX17055", RegistersWidgetConfig{CT_MAX17055, 256, 16, 16}); }});
|
||
}
|
||
set_max_rows(2); // allow wider buttons
|
||
}
|
||
|
||
/* DebugReboot **********************************************/
|
||
|
||
DebugReboot::DebugReboot(NavigationView& nav) {
|
||
(void)nav;
|
||
|
||
LPC_RGU->RESET_CTRL[0] = (1 << 0);
|
||
|
||
while (1)
|
||
__WFE();
|
||
}
|
||
|
||
void DebugReboot::on_populate() {
|
||
}
|
||
|
||
/* DebugMenuView *********************************************************/
|
||
|
||
DebugMenuView::DebugMenuView(NavigationView& nav)
|
||
: nav_(nav) {
|
||
set_max_rows(2); // allow wider buttons
|
||
}
|
||
|
||
void DebugMenuView::on_populate() {
|
||
if (portapack::persistent_memory::show_gui_return_icon()) {
|
||
add_items({{"..", ui::Theme::getInstance()->fg_light->foreground, &bitmap_icon_previous, [this]() { nav_.pop(); }}});
|
||
}
|
||
add_items({
|
||
#ifdef PRALINE
|
||
{"System Diag", ui::Theme::getInstance()->fg_yellow->foreground, &bitmap_icon_peripherals, [this]() { nav_.push<SystemDiagnosticsView>(); }},
|
||
{"Radio Diag", ui::Theme::getInstance()->fg_yellow->foreground, &bitmap_icon_peripherals, [this]() { nav_.push<RadioDiagnosticsView>(); }},
|
||
{"Signal Path", ui::Theme::getInstance()->fg_yellow->foreground, &bitmap_icon_peripherals, [this]() { nav_.push<SignalPathStatusView>(); }},
|
||
{"GPIO Debug", ui::Theme::getInstance()->fg_yellow->foreground, &bitmap_icon_peripherals, [this]() { nav_.push<GPIODebugView>(); }},
|
||
{"RFFC Status", ui::Theme::getInstance()->fg_yellow->foreground, &bitmap_icon_peripherals, [this]() { nav_.push<RFFC5072StatusView>(); }},
|
||
{"RFFC Tuning", ui::Theme::getInstance()->fg_yellow->foreground, &bitmap_icon_peripherals, [this]() { nav_.push<RFFCTuningDebugView>(); }},
|
||
{"MAX2831 Debug", ui::Theme::getInstance()->fg_yellow->foreground, &bitmap_icon_peripherals, [this]() { nav_.push<MAX2831DebugView>(); }},
|
||
{"Si5351 Clocks", ui::Theme::getInstance()->fg_yellow->foreground, &bitmap_icon_peripherals, [this]() { nav_.push<Si5351DebugView>(); }},
|
||
{"SGPIO8 Clock", ui::Theme::getInstance()->fg_yellow->foreground, &bitmap_icon_peripherals, [this]() { nav_.push<SGPIO8ClockDetectorView>(); }},
|
||
{"Baseband Status", ui::Theme::getInstance()->fg_yellow->foreground, &bitmap_icon_peripherals, [this]() { nav_.push<BasebandStatusView>(); }},
|
||
{"SGPIO Live", ui::Theme::getInstance()->fg_yellow->foreground, &bitmap_icon_peripherals, [this]() { nav_.push<SGPIOLiveMonitorView>(); }},
|
||
{"RX Test", ui::Theme::getInstance()->fg_yellow->foreground, &bitmap_icon_peripherals, [this]() { nav_.push<RadioRxTestView>(); }},
|
||
#endif
|
||
{"Buttons Test", ui::Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_controls, [this]() { nav_.push<DebugControlsView>(); }},
|
||
{"M0 Stack Dump", ui::Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_memory, [this]() { stack_dump(); }},
|
||
{"Memory Dump", ui::Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_memory, [this]() { nav_.push<DebugMemoryDumpView>(); }},
|
||
{"Peripherals", ui::Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_peripherals, [this]() { nav_.push<DebugPeripheralsMenuView>(); }},
|
||
{"Pers. Memory", ui::Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_memory, [this]() { nav_.push<DebugPmemView>(); }},
|
||
{"SD Card", ui::Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_sdcard, [this]() { nav_.push<SDCardDebugView>(); }},
|
||
{"Touch Test", ui::Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_notepad, [this]() { nav_.push<DebugScreenTest>(); }},
|
||
{"Reboot", ui::Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_setup, [this]() { nav_.push<DebugReboot>(); }},
|
||
{"Ext Module", ui::Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_peripherals_details, [this]() { nav_.push<ExternalModuleView>(); }},
|
||
});
|
||
|
||
if (i2cdev::I2CDevManager::get_dev_by_model(I2C_DEVMDL::I2CDEVMDL_MAX17055)) {
|
||
add_item(
|
||
{"Battery", ui::Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_batt_icon, [this]() { nav_.push<BatteryCapacityView>(); }});
|
||
}
|
||
|
||
for (auto const& gridItem : ExternalItemsMenuLoader::load_external_items(app_location_t::DEBUG, nav_)) {
|
||
add_item(gridItem);
|
||
};
|
||
}
|
||
|
||
/* 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(Theme::getInstance()->fg_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)
|
||
: registers_widget(RegistersWidgetConfig{CT_PMEM, PMEM_SIZE_BYTES, page_size, 8}) {
|
||
add_children({®isters_widget, &text_checksum, &text_checksum2, &button_ok});
|
||
|
||
registers_widget.set_parent_rect({0, 32, screen_width, 192});
|
||
|
||
text_checksum.set("Size: " + to_string_dec_uint(portapack::persistent_memory::data_size(), 3) + " CRC: " + to_string_hex(portapack::persistent_memory::pmem_stored_checksum(), 8));
|
||
text_checksum2.set("Calculated CRC: " + to_string_hex(portapack::persistent_memory::pmem_calculated_checksum(), 8));
|
||
|
||
button_ok.on_select = [&nav](Button&) {
|
||
nav.pop();
|
||
};
|
||
|
||
update();
|
||
}
|
||
|
||
bool DebugPmemView::on_encoder(const EncoderEvent delta) {
|
||
registers_widget.set_page(std::max(0ul, std::min((uint32_t)page_count - 1, registers_widget.page() + delta)));
|
||
|
||
update();
|
||
|
||
return true;
|
||
}
|
||
|
||
void DebugPmemView::focus() {
|
||
button_ok.focus();
|
||
}
|
||
|
||
void DebugPmemView::update() {
|
||
registers_widget.update();
|
||
}
|
||
|
||
/* DebugScreenTest ****************************************************/
|
||
|
||
DebugScreenTest::DebugScreenTest(NavigationView& nav)
|
||
: nav_{nav} {
|
||
set_focusable(true);
|
||
srand(LPC_RTC->CTIME0);
|
||
}
|
||
|
||
bool DebugScreenTest::on_key(const KeyEvent key) {
|
||
Painter painter;
|
||
switch (key) {
|
||
case KeyEvent::Select:
|
||
nav_.pop();
|
||
break;
|
||
case KeyEvent::Down:
|
||
painter.fill_rectangle({0, 0, screen_width, screen_height}, rand());
|
||
break;
|
||
case KeyEvent::Left:
|
||
pen_color = rand();
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool DebugScreenTest::on_encoder(EncoderEvent delta) {
|
||
pen_size = clip<int32_t>(pen_size + delta, 1, screen_width);
|
||
return true;
|
||
}
|
||
|
||
bool DebugScreenTest::on_touch(const TouchEvent event) {
|
||
Painter painter;
|
||
pen_pos = event.point;
|
||
painter.fill_rectangle({pen_pos.x() - pen_size / 2, pen_pos.y() - pen_size / 2, pen_size, pen_size}, pen_color);
|
||
return true;
|
||
}
|
||
|
||
void DebugScreenTest::paint(Painter& painter) {
|
||
painter.fill_rectangle({0, 16, screen_width, screen_height - 16}, Theme::getInstance()->bg_darkest->foreground);
|
||
painter.draw_string({10 * 8, screen_height / 2}, *Theme::getInstance()->bg_darkest, "Use Stylus");
|
||
pen_color = rand();
|
||
}
|
||
|
||
/* DebugLCRView *******************************************************/
|
||
|
||
/*DebugLCRView::DebugLCRView(NavigationView& nav, std::string lcr_string) {
|
||
|
||
std::string debug_text;
|
||
|
||
add_children({
|
||
&console,
|
||
&button_exit
|
||
});
|
||
|
||
for(const auto c : lcr_string) {
|
||
if ((c < 32) || (c > 126))
|
||
debug_text += "[" + to_string_dec_uint(c) + "]";
|
||
else
|
||
debug_text += c;
|
||
}
|
||
|
||
debug_text += "\n\n";
|
||
debug_text += "Length: " + to_string_dec_uint(lcr_string.length()) + '\n';
|
||
debug_text += "Checksum: " + to_string_dec_uint(lcr_string.back()) + '\n';
|
||
|
||
console.write(debug_text);
|
||
|
||
button_exit.on_select = [this, &nav](Button&){
|
||
nav.pop();
|
||
};
|
||
}
|
||
|
||
void DebugLCRView::focus() {
|
||
button_exit.focus();
|
||
}*/
|
||
|
||
} /* namespace ui */
|