#include "wxmain.hpp"
#include <wx/combobox.h>
+#include <wx/dcclient.h>
#include <wx/dir.h>
#include <wx/filename.h>
#include <wx/filedlg.h>
#include <wx/textdlg.h>
#include <array>
+#include <sys/mman.h>
#include <vector>
static const std::array<wxString, 6> srateValues {
MRunConnect,
MRunStart,
MRunMeasure,
+ MRunDrawSamples,
MRunLogResults,
MRunUpload,
MRunUnload,
wxDefaultPosition, wxDefaultSize,
srateValues.size(), srateValues.data(),
wxCB_READONLY);
+ m_device_samples = reinterpret_cast<stmdsp::adcsample_t *>(::mmap(
+ nullptr, stmdsp::SAMPLES_MAX * sizeof(stmdsp::adcsample_t),
+ PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0));
+ m_device_samples_input = reinterpret_cast<stmdsp::adcsample_t *>(::mmap(
+ nullptr, stmdsp::SAMPLES_MAX * sizeof(stmdsp::adcsample_t),
+ PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0));
m_menu_bar->Append(menuFile, "&File");
m_menu_bar->Append(menuRun, "&Run");
// General
Bind(wxEVT_TIMER, &MainFrame::onMeasureTimer, this, Id::MeasureTimer);
Bind(wxEVT_CLOSE_WINDOW, &MainFrame::onCloseEvent, this, wxID_ANY);
+ Bind(wxEVT_PAINT, &MainFrame::onPaint, this, wxID_ANY);
// Toolbar actions
Bind(wxEVT_BUTTON, &MainFrame::onRunCompile, this, Id::MCodeCompile, wxID_ANY, comp);
menuRun->AppendSeparator();
Bind(wxEVT_MENU, &MainFrame::onRunStart, this, Id::MRunStart, wxID_ANY, menuRun->Append(MRunStart, "&Start"));
m_run_measure = menuRun->AppendCheckItem(MRunMeasure, "&Measure code time");
+ m_run_draw_samples = menuRun->AppendCheckItem(MRunDrawSamples, "&Draw samples");
Bind(wxEVT_MENU, &MainFrame::onRunLogResults, this, Id::MRunLogResults, wxID_ANY, menuRun->AppendCheckItem(MRunLogResults, "&Log results..."));
menuRun->AppendSeparator();
Bind(wxEVT_MENU, &MainFrame::onRunUpload, this, Id::MRunUpload, wxID_ANY, menuRun->Append(MRunUpload, "&Upload code"));
// Only called while connected and running.
void MainFrame::onMeasureTimer(wxTimerEvent&)
{
- if (m_conv_result_log) {
- // We're meant to log
- if (auto samples = m_device->continuous_read(); samples.size() > 0) {
- for (auto& s : samples) {
- auto str = std::to_string(s);
- m_conv_result_log->Write(str.c_str(), str.size());
+ if (m_conv_result_log || m_run_draw_samples->IsChecked()) {
+ auto samples = m_device->continuous_read();
+ if (samples.size() > 0) {
+ std::copy(samples.cbegin(), samples.cend(), m_device_samples);
+
+ if (m_conv_result_log) {
+ for (auto& s : samples) {
+ auto str = std::to_string(s);
+ m_conv_result_log->Write(str.c_str(), str.size());
+ }
+ }
+ if (m_run_draw_samples->IsChecked()) {
+ samples = m_device->continuous_read_input();
+ std::copy(samples.cbegin(), samples.cend(), m_device_samples_input);
+ this->Refresh();
}
}
}
}
}
+void MainFrame::onPaint(wxPaintEvent&)
+{
+ if (!m_is_running || !m_run_draw_samples->IsChecked()) {
+ if (!m_compile_output->IsShown())
+ m_compile_output->Show();
+ return;
+ } else if (m_compile_output->IsShown()) {
+ m_compile_output->Hide();
+ }
+
+ auto py = m_compile_output->GetScreenPosition().y - this->GetScreenPosition().y - 28;
+ wxRect rect {
+ 0, py,
+ this->GetSize().GetWidth(),
+ this->GetSize().GetHeight() - py - 60
+ };
+
+ auto *dc = new wxPaintDC(this);
+ dc->SetBrush(*wxBLACK_BRUSH);
+ dc->SetPen(*wxBLACK_PEN);
+ dc->DrawRectangle(rect);
+ dc->SetBrush(*wxRED_BRUSH);
+ dc->SetPen(*wxRED_PEN);
+ auto stoy = [&](stmdsp::adcsample_t s) {
+ return static_cast<float>(py) + rect.GetHeight() -
+ (static_cast<float>(rect.GetHeight()) * s / 4095.f);
+ };
+ auto scount = m_device->get_buffer_size();
+ float dx = static_cast<float>(rect.GetWidth()) / scount;
+ float x = 0;
+ float lasty = stoy(2048);
+ for (decltype(scount) i = 0; i < scount; i++) {
+ auto y = stoy(m_device_samples[i]);
+ dc->DrawLine(x, lasty, x + dx, y);
+ x += dx, lasty = y;
+ }
+ dc->SetBrush(*wxBLUE_BRUSH);
+ dc->SetPen(*wxBLUE_PEN);
+ x = 0;
+ lasty = stoy(2048);
+ for (decltype(scount) i = 0; i < scount; i++) {
+ auto y = stoy(m_device_samples_input[i]);
+ dc->DrawLine(x, lasty, x + dx, y);
+ x += dx, lasty = y;
+ }
+ delete dc;
+}
+
void MainFrame::prepareEditor()
{
m_text_editor->SetLexer(wxSTC_LEX_CPP);
srateNums[m_rate_select->GetSelection()]);
} else if (m_conv_result_log) {
m_measure_timer->Start(15);
+ } else if (m_run_draw_samples->IsChecked()) {
+ m_measure_timer->Start(300);
}
m_device->continuous_start();
}
+ m_rate_select->Enable(false);
menuItem->SetItemLabel("&Stop");
m_status_bar->SetStatusText("Running.");
m_is_running = true;
m_device->continuous_stop();
m_measure_timer->Stop();
+ m_rate_select->Enable(true);
menuItem->SetItemLabel("&Start");
m_status_bar->SetStatusText("Ready.");
m_is_running = false;
+
+ if (m_run_draw_samples->IsChecked())
+ m_compile_output->Refresh();
}
}
void MainFrame::onRunEditBSize(wxCommandEvent&)
{
- wxTextEntryDialog dialog (this, "Enter new buffer size (100-4000)", "Set Buffer Size");
+ wxTextEntryDialog dialog (this, "Enter new buffer size (100-4096)", "Set Buffer Size");
if (dialog.ShowModal() == wxID_OK) {
if (wxString value = dialog.GetValue(); !value.IsEmpty()) {
if (unsigned long n; value.ToULong(&n)) {
if (menuItem->IsChecked()) {
m_device->siggen_start();
menuItem->SetItemLabel("Stop &generator");
+ m_status_bar->SetStatusText("Generator running.");
} else {
m_device->siggen_stop();
menuItem->SetItemLabel("Start &generator");
+ m_status_bar->SetStatusText("Ready.");
}
}
// Thread for LED status and wakeup hold
__attribute__((section(".stacks")))
static THD_WORKING_AREA(monitorThreadWA, 4096);
-static THD_FUNCTION(monitorThread, arg);
+/*extern "C"*/static THD_FUNCTION(monitorThread, arg);
// Thread for managing the conversion task
__attribute__((section(".stacks")))
// 'r' - Read or write sample rate.
// 'S' - Stop conversion.
// 's' - Get latest block of conversion results.
+ // 't' - Get latest block of conversion input.
// 'W' - Start signal generator (siggen).
// 'w' - Stop siggen.
USBSerial::write(reinterpret_cast<const uint8_t *>("\0\0"), 2);
}
break;
+ case 't':
+ if (auto samps = samplesIn.modified(); samps != nullptr) {
+ unsigned char buf[2] = {
+ static_cast<unsigned char>(samplesIn.size() / 2 & 0xFF),
+ static_cast<unsigned char>(((samplesIn.size() / 2) >> 8) & 0xFF)
+ };
+ USBSerial::write(buf, 2);
+ unsigned int total = samplesIn.bytesize() / 2;
+ unsigned int offset = 0;
+ unsigned char unused;
+ while (total > 512) {
+ USBSerial::write(reinterpret_cast<uint8_t *>(samps) + offset, 512);
+ while (USBSerial::read(&unused, 1) == 0);
+ offset += 512;
+ total -= 512;
+ }
+ USBSerial::write(reinterpret_cast<uint8_t *>(samps) + offset, total);
+ while (USBSerial::read(&unused, 1) == 0);
+ } else {
+ USBSerial::write(reinterpret_cast<const uint8_t *>("\0\0"), 2);
+ }
+ break;
case 'W':
DAC::start(1, samplesSigGen.data(), samplesSigGen.size());
chSysUnlockFromISR();
conversion_abort();
} else {
- chMBPostI(&conversionMB, buffer == samplesIn.data() ? MSG_CONVFIRST : MSG_CONVSECOND);
+ if (buffer == samplesIn.data()) {
+ samplesIn.setModified();
+ chMBPostI(&conversionMB, MSG_CONVFIRST);
+ } else {
+ samplesIn.setMidmodified();
+ chMBPostI(&conversionMB, MSG_CONVSECOND);
+ }
chSysUnlockFromISR();
}
}
void signal_operate_measure(adcsample_t *buffer, [[maybe_unused]] size_t count)
{
chSysLockFromISR();
- chMBPostI(&conversionMB, buffer == samplesIn.data() ? MSG_CONVFIRST_MEASURE
- : MSG_CONVSECOND_MEASURE);
+ if (buffer == samplesIn.data()) {
+ samplesIn.setModified();
+ chMBPostI(&conversionMB, MSG_CONVFIRST_MEASURE);
+ } else {
+ samplesIn.setMidmodified();
+ chMBPostI(&conversionMB, MSG_CONVSECOND_MEASURE);
+ }
chSysUnlockFromISR();
ADC::setOperation(signal_operate);