]> code.bitgloo.com Git - clyne/stmdsp.git/commitdiff
GUI reads ADC channel
authorClyne Sullivan <clyne@bitgloo.com>
Wed, 24 Jun 2020 23:57:29 +0000 (19:57 -0400)
committerClyne Sullivan <clyne@bitgloo.com>
Wed, 24 Jun 2020 23:57:29 +0000 (19:57 -0400)
.gitignore
gui/stmdsp.cpp
gui/stmdsp.hpp
gui/wxmain.hpp
source/main.cpp

index 235fb5126622c5e411bb802caf75d2e77ce86d85..a9adb0f1cd0802d2f4f4ac34a9b433c4fdacc28d 100644 (file)
@@ -3,4 +3,5 @@ ChibiOS_*
 **/.*
 gui/stmdspgui
 *.o
+perf*
 
index 4812884f44a3bc6379f6c8c00c80983cda2380fa..837d09c96ac22c84e6624a6983d5246c5c2bc94e 100644 (file)
@@ -14,4 +14,24 @@ namespace stmdsp
 
         return m_available_devices;
     }
+
+    device::device(const std::string& file) :
+        m_serial(file, 230400, serial::Timeout::simpleTimeout(50)) {}
+
+    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 {};
+        }
+    }
 }
index 030038d891487a275b99e278d5e76b8737184577..2148fa12188d587d5f71af18bbf3d4616864cfd0 100644 (file)
@@ -28,8 +28,7 @@ namespace stmdsp
     class device
     {
     public:
-        device(const std::string& file) :
-            m_serial(file, 115200, serial::Timeout::simpleTimeout(1000)) {}
+        device(const std::string& file);
 
         ~device() {
             m_serial.close();
@@ -39,19 +38,7 @@ namespace stmdsp
             return m_serial.isOpen() && (m_serial.write("i"), m_serial.read(6) == "stmdsp");
         }
 
-        std::vector<adcsample_t> sample(unsigned long int count = 1) {
-            if (connected()) {
-                m_serial.write(std::vector<uint8_t> {'r',
-                                                     static_cast<uint8_t>(count),
-                                                     static_cast<uint8_t>(count >> 8)});
-                std::vector<adcsample_t> data (count);
-                m_serial.read(reinterpret_cast<uint8_t *>(data.data()),
-                              data.size() * sizeof(adcsample_t));
-                return data;
-            } else {
-                return {};
-            }
-        }
+        std::vector<adcsample_t> sample(unsigned long int count = 1);
 
     private:
         serial::Serial m_serial;
index f23ae384bedbe6558a9bf341b6e3ef31fbe159f5..97baae3d496986115253f6f7b42c68495eff8a1a 100644 (file)
@@ -3,6 +3,8 @@
 
 #include "stmdsp.hpp"
 
+#include <future>
+#include <thread>
 #include <wx/button.h>
 #include <wx/combobox.h>
 #include <wx/dcclient.h>
@@ -21,22 +23,26 @@ class MainFrame : public wxFrame
 
     bool m_is_rendering = false;
     wxTimer *m_render_timer = nullptr;
-    int m_radius = 10;
+    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));
-        auto combo = new wxComboBox(this, Id::SelectDevice, "", wxPoint(470, 20), wxSize(150, 30));
-        combo->SetEditable(false);
+        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())
-            combo->Append(dev);
-        if (combo->GetCount() > 0)
-            combo->SetSelection(0);
+            m_device_combo->Append(dev);
+        if (m_device_combo->GetCount() > 0)
+            m_device_combo->SetSelection(0);
 
         m_render_timer = new wxTimer(this, Id::RenderTimer);
 
@@ -53,19 +59,47 @@ public:
         dc->SetPen(*wxBLACK_PEN);
         dc->DrawRectangle(m_clipping_region);
 
-        dc->SetPen(*wxRED_PEN);
-        dc->DrawCircle(320, 240, m_radius);
+        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_render_timer->Start(100);
-            button->SetLabel("Stop");
+            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;
         }
     }
 
@@ -74,8 +108,10 @@ public:
     }
 
     void updateDrawing() {
-        m_radius++;
-        this->RefreshRect(m_clipping_region);
+        if (m_device_samples = m_device_samples_future.get(); m_device_samples.size() > 0)
+            this->RefreshRect(m_clipping_region);
+
+        doSingle();
     }
 };
 
index dc38ddd1f510c379b0e520548be83e68a80c0af6..b73776a02db182f2be6e49979de284ca71b8e27f 100644 (file)
@@ -23,7 +23,7 @@ static_assert(sizeof(adcsample_t) == sizeof(uint16_t));
 #if CACHE_LINE_SIZE > 0\r
 CC_ALIGN(CACHE_LINE_SIZE)\r
 #endif\r
-static std::array<adcsample_t, CACHE_SIZE_ALIGN(adcsample_t, 100)> adc_samples;\r
+static std::array<adcsample_t, CACHE_SIZE_ALIGN(adcsample_t, 2048)> adc_samples;\r
 \r
 int main()\r
 {\r
@@ -49,11 +49,13 @@ int main()
        while (true) {\r
         if (usbd.active()) {\r
             // Expect to receive a byte command 'packet'.\r
-            if (char cmd; usbd.read(&cmd) > 0) {\r
-                switch (cmd) {\r
+            if (char cmd[3]; usbd.read(&cmd, 3) > 0) {\r
+                switch (cmd[0]) {\r
                 case 'r': // Read in analog signal\r
-                    adc.getSamples(&adc_samples[0], 100);//adc_samples.size());\r
-                    usbd.write(adc_samples.data(), adc_samples.size());\r
+                    if (auto count = std::min(static_cast<unsigned int>(cmd[1] | (cmd[2] << 8)), adc_samples.size()); count > 0) {\r
+                        adc.getSamples(&adc_samples[0], count);\r
+                        usbd.write(adc_samples.data(), count * sizeof(adcsample_t));\r
+                    }\r
                     break;\r
                 case 'i': // Identify ourself as an stmdsp device\r
                     usbd.write("stmdsp", 6);\r
@@ -64,7 +66,7 @@ int main()
             }\r
         }\r
 \r
-               chThdSleepMilliseconds(250);\r
+               chThdSleepMilliseconds(1);\r
        }\r
 }\r
 \r