clyne
/
stmdsp
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Labels Milestones

New Pull Request

Gui #1

Merged
tcsullivan merged 9 commits from gui into master 4 years ago
Conversation 0 Commits 9 Files Changed 12
12 changed files with 386 additions and 148 deletions
Show Stats Download Patch File Download Diff File

3
.gitignore vendored
Unescape Escape View File

@ -1,4 +1,7 @@
build
ChibiOS_*
**/.*
gui/stmdspgui
*.o
perf*

6
.gitmodules vendored
Unescape Escape View File

@ -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

30
gui/Makefile
Unescape Escape View File

@ -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)

15
gui/main.cpp
Unescape Escape View File

@ -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);

1
gui/serial

@ -0,0 +1 @@
Subproject commit cbcca7c83745fedd75afb7a0a27ee5c4112435c2

48
gui/stmdsp.cpp
Unescape Escape View File

@ -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 {};
}
}
}

69
gui/stmdsp.hpp
Unescape Escape View File

@ -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_

20
gui/wxapp.hpp
Unescape Escape View File

@ -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_

119
gui/wxmain.hpp
Unescape Escape View File

@ -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_

34
source/adc.cpp
Unescape Escape View File

@ -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);

47
source/adc.hpp
Unescape Escape View File

@ -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 = {

142
source/main.cpp
Unescape Escape View File

@ -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);
}
}

Write Preview
Loading…
Cancel
Save