12 files changed, 385 insertions, 148 deletions
diff --git a/.gitignore b/.gitignore
index ccfe582..a9adb0f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,7 @@
 build
 ChibiOS_*
 **/.*
+gui/stmdspgui
+*.o
+perf*
 
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..0c9d779
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,6 @@
+[submodule "gui/gui/serial"]
+	path = gui/gui/serial
+	url = https://github.com/wjwwood/serial
+[submodule "gui/serial"]
+	path = gui/serial
+	url = https://github.com/wjwwood/serial
diff --git a/gui/Makefile b/gui/Makefile
index 419ed33..99a0243 100644
--- a/gui/Makefile
+++ b/gui/Makefile
@@ -1,15 +1,31 @@
-CXX = clang++-10
-CXXFLAGS = --std=c++20 -Wall -Wextra -pedantic
+CXX = g++-10
+CXXFLAGS = --std=c++20 -ggdb -Og \
+		   -Wall -Wextra -pedantic \
+		   -Wno-deprecated-copy \
+		   -Iserial/include \
+		   $(shell wx-config --cxxflags)
 
-CXXFILES = $(wildcard *.cpp)
+CXXFILES = $(shell find serial/src -name "*.cc") $(wildcard *.cpp)
+OFILES = $(patsubst %.cc, %.o, $(patsubst %.cpp, %.o, $(CXXFILES)))
 
+LIBS = $(shell wx-config --libs)
 OUTELF = stmdspgui
 
-all: $(CXXFILES)
-	@echo "  CXX    " $(CXXFILES)
-	@$(CXX) $(CXXFLAGS) $(CXXFILES) -o $(OUTELF)
+all: $(OUTELF)
+	
+$(OUTELF): $(OFILES)
+	@echo "  CXX    " $(OUTELF)
+	@$(CXX) $(CXXFLAGS) $(OFILES) $(LIBS) -o $(OUTELF)
+
+.cc.o:
+	@echo "  CXX    " $<
+	@$(CXX) $(CXXFLAGS) -c $< -o $@
+
+.cpp.o:
+	@echo "  CXX    " $<
+	@$(CXX) $(CXXFLAGS) -c $< -o $@
 
 clean:
 	@echo "  CLEAN"
-	@rm -f $(OUTELF)
+	@rm -f $(OUTELF) $(OFILES)
 
diff --git a/gui/main.cpp b/gui/main.cpp
index 48f2990..29f74d3 100644
--- a/gui/main.cpp
+++ b/gui/main.cpp
@@ -1,15 +1,6 @@
-#include "stmdsp.hpp"
+#include "wxapp.hpp"
 
-#include <iostream>
+#include <wx/app.h>
 
-int main()
-{
-    stmdsp::scanner scanner;
-
-    scanner.scan();
-    for (const auto& device : scanner.devices())
-        std::cout << "Found stmdsp at: " << device.path() << std::endl;
-
-    return 0;
-}
+wxIMPLEMENT_APP(MainApp);
 
diff --git a/gui/serial b/gui/serial
new file mode 160000
+Subproject cbcca7c83745fedd75afb7a0a27ee5c4112435c
diff --git a/gui/stmdsp.cpp b/gui/stmdsp.cpp
index 267bebc..837d09c 100644
--- a/gui/stmdsp.cpp
+++ b/gui/stmdsp.cpp
@@ -1,31 +1,37 @@
 #include "stmdsp.hpp"
 
-#include <chrono>
-#include <filesystem>
-#include <thread>
-
-using namespace std::chrono_literals;
+#include <serial/serial.h>
 
 namespace stmdsp
 {
-    void scanner::scan()
+    std::list<std::string>& scanner::scan()
     {
-        std::string path ("/dev/ttyACM0");
+        auto devices = serial::list_ports();
+        for (auto& device : devices) {
+            if (device.hardware_id.find(STMDSP_USB_ID) != std::string::npos)
+                m_available_devices.emplace_front(device.port);
+        }
+
+        return m_available_devices;
+    }
+
+    device::device(const std::string& file) :
+        m_serial(file, 230400, serial::Timeout::simpleTimeout(50)) {}
 
-        for (unsigned int i = 0; i < 10; i++) {
-            path.back() = '0' + i;
-            if (std::filesystem::exists(path)) {
-                if (device dev (path); dev.open()) {
-                    dev.write("i", 1);
-                    std::this_thread::sleep_for(1s);
-                    char buf[7];
-                    if (dev.read(buf, 6) ==	6) {
-                        buf[6] = '\0';
-                        if (std::string(buf) == "stmdsp")
-                            m_devices.emplace(std::move(dev));
-                    }
-                }
-            }
+    std::vector<adcsample_t> device::sample(unsigned long int count) {
+        if (connected()) {
+            uint8_t request[3] = {
+                'r',
+                static_cast<uint8_t>(count),
+                static_cast<uint8_t>(count >> 8)
+            };
+            m_serial.write(request, 3);
+            std::vector<adcsample_t> data (count);
+            m_serial.read(reinterpret_cast<uint8_t *>(data.data()),
+                          data.size() * sizeof(adcsample_t));
+            return data;
+        } else {
+            return {};
         }
     }
 }
diff --git a/gui/stmdsp.hpp b/gui/stmdsp.hpp
index 12e4578..2148fa1 100644
--- a/gui/stmdsp.hpp
+++ b/gui/stmdsp.hpp
@@ -1,60 +1,49 @@
-#ifndef STMDSPSCANNER_H
-#define STMDSPSCANNER_H
+#ifndef STMDSP_HPP_
+#define STMDSP_HPP_
 
-#include <fstream>
-#include <set>
+#include <cstdint>
+#include <list>
+#include <serial/serial.h>
 #include <string>
 
 namespace stmdsp
 {
-    class device
+    class scanner
     {
-    public:
-        device(const std::string& path) :
-            m_path(path) {}
-
-        bool open() {
-            m_stream.open(m_path, std::ios_base::in | std::ios_base::out | std::ios_base::binary);
-            return m_stream.is_open();
-        }
-
-        std::size_t read(char *buffer, std::size_t count) {
-            return m_stream.readsome(buffer, count);
-        }
-
-        std::size_t write(const char *buffer, std::size_t count) {
-            m_stream.write(buffer, count);
-            return m_stream.good() ? count : 0;
-        }
-
-        const std::string& path() const {
-            return m_path;
-        }
+    private:
+        constexpr static const char *STMDSP_USB_ID = "USB VID:PID=0483:5740";
 
-        auto operator<=>(const device& other) const {
-            return m_path <=> other.m_path;
+    public:
+        std::list<std::string>& scan();
+        auto& devices() {
+            return m_available_devices;
         }
 
     private:
-        std::string m_path;
-        std::fstream m_stream;
+        std::list<std::string> m_available_devices;
     };
 
-    class scanner
-    {
-    private:
-        constexpr static unsigned int STMDSP_VENDOR_ID = 0x0483;
-        constexpr static unsigned int STMDSP_DEVICE_ID = 0x5740;
+    using adcsample_t = uint16_t;
 
+    class device
+    {
     public:
-        void scan();
-        const auto& devices() const {
-            return m_devices;
+        device(const std::string& file);
+
+        ~device() {
+            m_serial.close();
+        }
+
+        bool connected() {
+            return m_serial.isOpen() && (m_serial.write("i"), m_serial.read(6) == "stmdsp");
         }
 
+        std::vector<adcsample_t> sample(unsigned long int count = 1);
+
     private:
-        std::set<device> m_devices;
+        serial::Serial m_serial;
     };
 }
 
-#endif // STMDSPSCANNER_H
+#endif // STMDSP_HPP_
+
diff --git a/gui/wxapp.hpp b/gui/wxapp.hpp
new file mode 100644
index 0000000..6536554
--- /dev/null
+++ b/gui/wxapp.hpp
@@ -0,0 +1,20 @@
+#ifndef WXAPP_HPP_
+#define WXAPP_HPP_
+
+#include "wxmain.hpp"
+
+#include <wx/app.h>
+
+class MainApp : public wxApp
+{
+public:
+    virtual bool OnInit() final {
+        auto mainFrame = new MainFrame;
+        mainFrame->Show(true);
+        SetTopWindow(mainFrame);
+        return true;
+    }
+};
+
+#endif // WXAPP_HPP_
+
diff --git a/gui/wxmain.hpp b/gui/wxmain.hpp
new file mode 100644
index 0000000..97baae3
--- /dev/null
+++ b/gui/wxmain.hpp
@@ -0,0 +1,119 @@
+#ifndef WXMAIN_HPP_
+#define WXMAIN_HPP_
+
+#include "stmdsp.hpp"
+
+#include <future>
+#include <thread>
+#include <wx/button.h>
+#include <wx/combobox.h>
+#include <wx/dcclient.h>
+#include <wx/frame.h>
+#include <wx/stattext.h>
+#include <wx/timer.h>
+
+class MainFrame : public wxFrame
+{
+    enum Id {
+        Welcome = 1,
+        Single,
+        SelectDevice,
+        RenderTimer
+    };
+
+    bool m_is_rendering = false;
+    wxTimer *m_render_timer = nullptr;
+    wxComboBox *m_device_combo = nullptr;
+
+    const wxRect m_clipping_region = {20, 100, 600, 360};
+
+    stmdsp::device *m_device = nullptr;
+    std::future<std::vector<stmdsp::adcsample_t>> m_device_samples_future;
+    std::vector<stmdsp::adcsample_t> m_device_samples;
+
+public:
+    MainFrame() : wxFrame(nullptr, -1, "Hello world", wxPoint(50, 50), wxSize(640, 480))
+    {
+        new wxStaticText(this, Id::Welcome, "Welcome to the GUI.", wxPoint(20, 20));
+        new wxButton(this, Id::Single, "Single", wxPoint(20, 60));
+        m_device_combo = new wxComboBox(this, Id::SelectDevice, "", wxPoint(470, 20), wxSize(150, 30));
+        m_device_combo->SetEditable(false);
+        stmdsp::scanner scanner;
+        for (auto& dev : scanner.scan())
+            m_device_combo->Append(dev);
+        if (m_device_combo->GetCount() > 0)
+            m_device_combo->SetSelection(0);
+
+        m_render_timer = new wxTimer(this, Id::RenderTimer);
+
+        Bind(wxEVT_BUTTON, &MainFrame::onSinglePressed, this, Id::Single);
+        Bind(wxEVT_PAINT, &MainFrame::onPaint, this, wxID_ANY);
+        Bind(wxEVT_TIMER, &MainFrame::onRenderTimer, this, Id::RenderTimer);
+    }
+
+    void onPaint([[maybe_unused]] wxPaintEvent& pe) {
+        auto *dc = new wxClientDC(this);
+        dc->SetClippingRegion(m_clipping_region);
+
+        dc->SetBrush(*wxBLACK_BRUSH);
+        dc->SetPen(*wxBLACK_PEN);
+        dc->DrawRectangle(m_clipping_region);
+
+        if (m_device_samples.size() > 0) {
+            dc->SetPen(*wxRED_PEN);
+            auto points = new wxPoint[m_device_samples.size()];
+            const float spacing = static_cast<float>(m_clipping_region.GetWidth()) / m_device_samples.size();
+            float x = 0;
+            for (auto ptr = points; auto sample : m_device_samples) {
+                *ptr++ = wxPoint {
+                    static_cast<int>(x),
+                    m_clipping_region.GetHeight() - sample * m_clipping_region.GetHeight() / 4096
+                };
+                x += spacing;
+            }
+            dc->DrawLines(m_device_samples.size(), points, m_clipping_region.GetX(), m_clipping_region.GetY());
+            delete[] points;
+        }
+    }
+
+    void doSingle() {
+        m_device_samples_future = std::async(std::launch::async,
+                                             [this]() { return m_device->sample(250); });
+    }
+
+    void onSinglePressed(wxCommandEvent& ce) {
+        auto button = dynamic_cast<wxButton *>(ce.GetEventObject());
+
+        if (!m_render_timer->IsRunning()) {
+            m_device = new stmdsp::device(m_device_combo->GetStringSelection().ToStdString());
+            if (m_device->connected()) {
+                doSingle();
+                m_render_timer->Start(100);
+                button->SetLabel("Stop");
+            } else {
+                delete m_device;
+                m_device = nullptr;
+            }
+        } else {
+            m_render_timer->Stop();
+            button->SetLabel("Single");
+
+            delete m_device;
+            m_device = nullptr;
+        }
+    }
+
+    void onRenderTimer([[maybe_unused]] wxTimerEvent& te) {
+        updateDrawing();
+    }
+
+    void updateDrawing() {
+        if (m_device_samples = m_device_samples_future.get(); m_device_samples.size() > 0)
+            this->RefreshRect(m_clipping_region);
+
+        doSingle();
+    }
+};
+
+#endif // WXMAIN_HPP_
+
diff --git a/source/adc.cpp b/source/adc.cpp
index 0c58e21..4e68a6e 100644
--- a/source/adc.cpp
+++ b/source/adc.cpp
@@ -39,6 +39,40 @@ adcsample_t *ADCd::getSamples(adcsample_t *buffer, size_t count)
     return buffer;
 }
 
+void ADCd::setSampleRate(ADCdRate rate)
+{
+    uint32_t val = 0;
+
+    switch (rate) {
+    case ADCdRate::R2P5:
+        val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_2P5);
+        break;
+    case ADCdRate::R6P5:
+        val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_6P5);
+        break;
+    case ADCdRate::R12P5:
+        val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_12P5);
+        break;
+    case ADCdRate::R24P5:
+        val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_24P5);
+        break;
+    case ADCdRate::R47P5:
+        val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_47P5);
+        break;
+    case ADCdRate::R92P5:
+        val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_92P5);
+        break;
+    case ADCdRate::R247P5:
+        val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_247P5);
+        break;
+    case ADCdRate::R640P5:
+        val = ADC_SMPR1_SMP_AN5(ADC_SMPR_SMP_640P5);
+        break;
+    }
+
+    m_adc_group_config.smpr[0] = val;
+}
+
 void ADCd::initPins()
 {
     palSetPadMode(GPIOA, 0, PAL_MODE_INPUT_ANALOG);
diff --git a/source/adc.hpp b/source/adc.hpp
index 456e697..9989883 100644
--- a/source/adc.hpp
+++ b/source/adc.hpp
@@ -21,9 +21,53 @@ struct ADCdConfig : public ADCConfig
     ADCd *adcdinst;
 };
 
+enum class ADCdRate : unsigned int {
+    R2P5,
+    R6P5,
+    R12P5,
+    R24P5,
+    R47P5,
+    R92P5,
+    R247P5,
+    R640P5
+};
+
 class ADCd
 {
 public:
+    constexpr static const unsigned int CLOCK_RATE = 40000000;
+    constexpr static unsigned int SAMPLES_PER_SECOND(ADCdRate rate) {
+        unsigned int sps = 0;
+        switch (rate) {
+        case ADCdRate::R2P5:
+            sps = 15;
+            break;
+        case ADCdRate::R6P5:
+            sps = 19;
+            break;
+        case ADCdRate::R12P5:
+            sps = 25;
+            break;
+        case ADCdRate::R24P5:
+            sps = 37;
+            break;
+        case ADCdRate::R47P5:
+            sps = 60;
+            break;
+        case ADCdRate::R92P5:
+            sps = 105;
+            break;
+        case ADCdRate::R247P5:
+            sps = 260;
+            break;
+        case ADCdRate::R640P5:
+            sps = 653;
+            break;
+        }
+
+        return static_cast<unsigned int>(1.f / (sps / static_cast<float>(CLOCK_RATE)));
+    }
+
     constexpr explicit ADCd(ADCDriver& adcd, GPTDriver& gptd) :
         m_adcd(&adcd), m_gptd(&gptd), m_adc_config{},
         m_adc_group_config(ADC_GROUP_CONFIG),
@@ -31,6 +75,7 @@ public:
 
     void start();
     adcsample_t *getSamples(adcsample_t *buffer, size_t count);
+    void setSampleRate(ADCdRate rate);
 
 private:
     static const GPTConfig m_gpt_config;
@@ -43,6 +88,8 @@ private:
     bool m_is_adc_finished;
 
     void initPins();
+    //void selectPins(bool a0, bool a1);
+
     static void adcEndCallback(ADCDriver *adcd);
 
     constexpr static const ADCConversionGroup ADC_GROUP_CONFIG = {
diff --git a/source/main.cpp b/source/main.cpp
index b8d2fa1..95211b4 100644
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -1,68 +1,74 @@
-/**
- * @file main.cpp
- * @brief Program entry point.
- *
- * Copyright (C) 2020 Clyne Sullivan
- *
- * Distributed under the GNU GPL v3 or later. You should have received a copy of
- * the GNU General Public License along with this program.
- * If not, see <https://www.gnu.org/licenses/>.
- */
-
-#include "ch.h"
-#include "hal.h"
-
-#include "adc.hpp"
-#include "dac.hpp"
-#include "usbserial.hpp"
-
-#include <array>
-
-#if CACHE_LINE_SIZE > 0
-CC_ALIGN(CACHE_LINE_SIZE)
-#endif
-static std::array<adcsample_t, CACHE_SIZE_ALIGN(adcsample_t, 100)> adc_samples;
-
-int main()
-{
-    halInit();
-    chSysInit();
-
-    palSetPadMode(GPIOA, 5,  PAL_MODE_OUTPUT_PUSHPULL); // LED
-
-    ADCd adc (ADCD1, GPTD4);
-    adc.start();
-
-    //DACd dac (DACD1, {
-    //    .init         = 0,
-    //    .datamode     = DAC_DHRM_12BIT_RIGHT,
-    //    .cr           = 0
-    //});
-    //dac.start();
-    //dac.write(0, 1024);
-
-    USBSeriald usbd (SDU1);
-    usbd.start();
-
-	while (true) {
-        if (usbd.active()) {
-            // Expect to receive a byte command 'packet'.
-            if (char cmd; usbd.read(&cmd) > 0) {
-                switch (cmd) {
-                case 'r': // Read in analog signal
-                    adc.getSamples(&adc_samples[0], adc_samples.size());
-                    usbd.write(adc_samples.data(), adc_samples.size());
-                    break;
-                case 'i': // Identify ourself as an stmdsp device
-                    usbd.write("stmdsp", 6);
-                    break;
-                default:
-                    break;
-                }
-            }
-        }
-
-		chThdSleepMilliseconds(250);
-	}
-}
-
+/**
+ * @file main.cpp
+ * @brief Program entry point.
+ *
+ * Copyright (C) 2020 Clyne Sullivan
+ *
+ * Distributed under the GNU GPL v3 or later. You should have received a copy of
+ * the GNU General Public License along with this program.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ch.h"
+#include "hal.h"
+
+#include "adc.hpp"
+#include "dac.hpp"
+#include "usbserial.hpp"
+
+#include <array>
+
+static_assert(sizeof(adcsample_t) == sizeof(uint16_t));
+
+#if CACHE_LINE_SIZE > 0
+CC_ALIGN(CACHE_LINE_SIZE)
+#endif
+static std::array<adcsample_t, CACHE_SIZE_ALIGN(adcsample_t, 2048)> adc_samples;
+
+int main()
+{
+    halInit();
+    chSysInit();
+
+    palSetPadMode(GPIOA, 5,  PAL_MODE_OUTPUT_PUSHPULL); // LED
+
+    ADCd adc (ADCD1, GPTD4);
+    adc.start();
+
+    //DACd dac (DACD1, {
+    //    .init         = 0,
+    //    .datamode     = DAC_DHRM_12BIT_RIGHT,
+    //    .cr           = 0
+    //});
+    //dac.start();
+    //dac.write(0, 1024);
+
+    USBSeriald usbd (SDU1);
+    usbd.start();
+
+	while (true) {
+        if (usbd.active()) {
+            // Expect to receive a byte command 'packet'.
+            if (char cmd[3]; usbd.read(&cmd, 1) > 0) {
+                switch (cmd[0]) {
+                case 'r': // Read in analog signal
+                    if (usbd.read(&cmd[1], 2) < 2)
+                        break;
+                    if (auto count = std::min(static_cast<unsigned int>(cmd[1] | (cmd[2] << 8)), adc_samples.size()); count > 0) {
+                        adc.getSamples(&adc_samples[0], count);
+                        usbd.write(adc_samples.data(), count * sizeof(adcsample_t));
+                    }
+                    break;
+                case 'i': // Identify ourself as an stmdsp device
+                    usbd.write("stmdsp", 6);
+                    break;
+                default:
+                    break;
+                }
+            }
+        }
+
+		chThdSleepMilliseconds(1);
+	}
+}
+