Ich hab mir vor einiger Zeit ein HANMATEK HO52S Taschenoszi gekauft und bin total begeistert von dem Gerät. Analogbandbreite von 50 MHz, 2 Kanäle und einen integrierten Funktionsgenerator – und das ganze für unter 200 €
Das einzige von dem ich nicht begeistert war, war die PC-Software dazu. Leider nur Windows und unter VirtualBox gings leider auch ned 🙁 Hab mir die Anleitung angeschaut und gesehen, dass man damit eh nicht sehr viel machen kann außer Daten vom Oszi runterzuladen. Eine wirkliche Bedienung des DSOs wäre damit garnicht möglich gewesen.
Hab mir das Gerät etwas genauer angeschaut und wollte rausfinden ob es irgendeine Möglichkeit gibt es auch über den PC anzusprechen. Nach etwas Google hab ich schnell herausgefunden, dass die Firmware des Geräts eigentlich von Owon kommt. Für einige Geräte von Owon gibt es eine Schnittstellendoku im Netz.
Zu meiner großen Freude benutzt das Gerät das supereinfache SCPI-Protokoll über USB – Und ich hatte schon ein Ziel für meinen Urlaub 🙂
Das Bild indem die Kurven dargestellt werden, hab ich einfach vom Oszi selber – Screenshot gemacht, 3x vergrößert und alle Werte wegradiert 🙂 Dann einfach die Werte von der Schnittstelle drüberzeichnen.
Die Software müsste auch für andere ähnliche DSOs von Owon und OEMs funktionieren. Ich würde mich freuen von dir zu hören, wenn du ein anderes Gerät erfolgreich damit zum Laufen bekommst.
Im Archiv findest du ein AppImage, dass du einfach ausführen kannst. Leider musst du noch (als root) install.sh ausführen. Das fügt eine udev-Rule hinzu ohne die eine kommunikation mit dem DSO nicht möglich ist (zumindest als nicht-root).
Die Windows-Benutzer müssen sich noch etwas gedulden. Ich brauche jemand mit einem Windows-Rechner zum Testen, da es leider unter VirtualBox nicht geht (die SW vom Hersteller aber auch nicht). Natürlich würde ich mich riesig freuen, wenn ein/e Windows-Nutzer/in mit DSO dies liest und sich zur Verfügung stellt 🙂
by Stefan·Kommentare deaktiviert für C++ Statemachine-Framework
StateMachines sind das Brot und Butter eines (embedded) Softwareentwicklers. Die meisten StateMachine Frameworks für C++ sind aber sehr kompliziert und verwenden unglaublich viel Templates oder hängen von irgendwelchen Bibliotheken ab. Hab grad Urlaub und hab mir gedacht ich bau mir jetzt endlich ein eigenes Statemachine-Framework. Überraschenderweise war das recht schnell erledigt (ca. 2 Tage). So viel muss ein StateMachine-Framework ja eigentlich garned können hab ich gemerkt. Was mich sehr gewundert hat ist, dass sowas wie parallele States in vielen Frameworks garnicht möglich sind oder sehr aufwendig. Rausgekommen sind im ersten Schuss etwa 100 Zeilen Code in einer einzigen Headerdatei. Auch wenn ich beim Testen recht leicht auf 100% Coverage kam, bin ich nicht sicher, dass das Ding fehlerfrei ist. Also erstmal vorsichtig damit – Wenn du Fehler findest, bitte her damit. Ich hab bestimmt ein paar versteckt 🙂
Features
Eventbasiert
Einfache Initialisierung (alles an einer Stelle bzw. Methode)
SubStates und parallelle States
Single header mit nur etwa 130 LOC – reinkopieren und loslegen – keine Abhängigkeiten zu irgendwelchen Bibliotheken – STL only
Interface mit nur einer Methode die lediglich Events entgegennimmt
Fast keine Templates – C++11 – auch für alte Compiler
Geeignet für Embedded-Systeme (auch Bare-Metal mit wenig RAM, FreeRTOS, Arduino, mbed)
Verschachtelbar – mehrere StateMachines in einem System einfach möglich
Wenig Speicherbedarf – eine einfache StateMachine braucht ca. 1,4 kB (gemessen auf ESP32 mit Arduino)
Schnell – Stateübergang in 5 us auf PC. Auf ESP32 in 75 us (ohne Logging)
Initialisierung aller States, Transitions und Reactions in nur einer überschriebenen Methode
Einfach zu verbinden mit dem Rest des Systems – kleine Aktionen über Lambdas die mit dem „Rest“ verknüpfen
So einfach, dass durch das kleine Beispiel bereits getestet mit 100% LineCoverage (coverage als html liegt mit im Repo)
Update 2024-11-04: Hab einen Timer-Mechanismus eingebaut (ist zwar kein standard StateMachine-Feature, hab ich aber schon oft gebraucht)
Das Repo liegt hier: https://bitbucket.org/bobbery/mystatemachine hab qmake verwendet, damit mans leicht im QtCreator aufmachen und übersetzen kann. Braucht natürlich kein Qt – aber für ein Makefile für jede Plattform bin ich zu faul und qmake hab ich viel lieber als CMake
Das ist die StateMachine – ist einfach nur ein Header mit knapp über 100 LOC
/* Copyright 2024 stefan.box2code.de
*
* Use of this source code is governed by an MIT-style
* license that can be found in the LICENSE file or at
* https://opensource.org/licenses/MIT.
*/
#ifndef STATEMACHINE_H
#define STATEMACHINE_H
#include <functional>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
#define LOG_EVENTS
#define LOG_STATES
template<class StateID, class EventID>
class StateMachine
{
public:
StateMachine() {}
void react(EventID e) { react_p(e); }
void handleTimerTick() { handleTimerTick_p(); }
virtual void init() = 0; // overwrite it to create your machine
virtual ~StateMachine() {}
protected:
void react_p(EventID e)
{
#ifdef LOG_EVENTS
if (m_eventNames.find(e) != m_eventNames.end()) {
std::cout << "on" << m_eventNames.find(e)->second << "()" << std::endl;
}
#endif
bool transitOk = true;
for (StateID sid : m_activeStates) {
if (m_reactions.find(std::make_pair(sid, e)) != m_reactions.end()) {
if (!m_reactions.find(std::make_pair(sid, e))->second()) {
transitOk = false;
}
}
}
if (transitOk) {
transit(e);
}
}
void addInitialState(StateID sid, const std::string &name, StateID parent = StateID::NumStates)
{
m_stateNames[sid] = name;
if (parent != StateID::NumStates) {
m_childStates[parent].insert(sid);
} else {
m_activeStates.insert(sid);
}
m_initials[parent].insert(sid);
}
void addState(StateID sid, const std::string &name, StateID parent = StateID::NumStates)
{
m_stateNames[sid] = name;
if (parent != StateID::NumStates) {
m_childStates[parent].insert(sid);
}
}
void addEventName(EventID eid, const std::string &name) { m_eventNames[eid] = name; }
void addReaction(StateID sid, EventID eid, std::function<bool()> fun)
{
m_reactions.emplace(std::make_pair(sid, eid), fun);
}
void addEntry(StateID sid, std::function<bool()> fun) { m_entry.emplace(sid, fun); }
void addExit(StateID sid, std::function<bool()> fun) { m_exit.emplace(sid, fun); }
void addTransition(StateID sid, EventID eid, StateID target)
{
m_transitions.emplace(std::make_pair(sid, eid), target);
}
void transit(EventID e)
{
std::set<StateID> newActiveStates;
for (StateID id : m_activeStates) {
if (m_transitions.find(std::make_pair(id, e)) != m_transitions.end()) {
StateID activated = m_transitions.find(std::make_pair(id, e))->second;
newActiveStates.insert(activated);
if (m_initials.find(activated) != m_initials.end()) {
for (StateID subInitial : m_initials.find(activated)->second) {
newActiveStates.insert(subInitial);
}
}
} else {
newActiveStates.insert(id);
}
}
std::set<StateID> deactivated;
for (StateID id : m_activeStates) {
if (newActiveStates.count(id) == 0) {
deactivated.insert(id);
}
}
for (StateID id : deactivated) {
if (m_childStates.find(id) != m_childStates.end()) {
for (StateID chId : m_childStates.at(id)) {
newActiveStates.erase(chId);
if (m_exit.find(chId) != m_exit.end()) {
m_exit.at(chId)();
}
}
}
if (m_exit.find(id) != m_exit.end()) {
#ifdef LOG_STATES
std::cout << "onExit() of " << m_stateNames.at(id) << std::endl;
#endif
m_exit.at(id)();
}
}
for (StateID id : newActiveStates) {
if (m_activeStates.count(id) == 0) {
if (m_entry.find(id) != m_entry.end()) {
#ifdef LOG_STATES
std::cout << "onEntry() of " << m_stateNames.at(id) << std::endl;
#endif
m_entry.at(id)();
}
}
}
m_activeStates = newActiveStates;
#ifdef LOG_STATES
std::cout << "Current States: ";
for (StateID id : m_activeStates) {
if (m_stateNames.find(id) != m_stateNames.end()) {
std::cout << m_stateNames.find(id)->second << " ";
}
}
std::cout << std::endl;
#endif
}
void handleTimerTick_p()
{
bool timerExpired = false;
for (auto timer : m_timers) {
if (timer.second < 0) {
continue;
}
m_timers[timer.first] = --timer.second;
if (timer.second == 0) { // timer is expired
m_timers[timer.first] = -1; // timer is stopped
timerExpired = true;
}
}
if (timerExpired) {
react_p(EventID::TimerExpired);
}
}
bool isTimerExpired(size_t timerNum)
{
if (m_timers.find(timerNum) == m_timers.end()) {
return false;
}
return m_timers.at(timerNum) < 0;
}
void startTimer(size_t timerNum, int timeInMs) { m_timers[timerNum] = timeInMs; }
void stopTimer(size_t timerNum) { m_timers[timerNum] = -1; }
std::map<StateID, std::string> m_stateNames;
std::map<EventID, std::string> m_eventNames;
std::map<StateID, std::set<StateID>> m_initials;
std::map<std::pair<StateID, EventID>, StateID> m_transitions;
std::set<StateID> m_activeStates;
std::map<StateID, std::set<StateID>> m_childStates;
typedef std::function<bool()> reactFun;
std::map<std::pair<StateID, EventID>, reactFun> m_reactions;
std::map<StateID, reactFun> m_entry;
std::map<StateID, reactFun> m_exit;
std::map<size_t, int> m_timers;
};
#endif // STATEMACHINE_H
Und ein Besispiel
Das Beispiel ist bewusst einfach und hoffentlich leicht verständlich. Eigentlich wollt ich nur was was mit dem man gut parallelle States demonstrieren kann. Das Diagramm ist mit dem QtCreator gezeichnet:
/* Copyright 2024 stefan.box2code.de
*
* Use of this source code is governed by an MIT-style
* license that can be found in the LICENSE file or at
* https://opensource.org/licenses/MIT.
*/
#include "statemachine.h"
#define MEASURE_TIME
#ifdef MEASURE_TIME
#include <chrono>
#endif
enum class MyStateID {
Startup,
Running,
Lampe1An,
Lampe1Aus,
Lampe2An,
Lampe2Aus,
NumStates
}; // you should always add NumStates on end
enum class MyEventID {
TimerExpired, // must always be there
On,
Off,
Toggle,
NumEvents
}; // you should always add NumEvents on end
class MyApi // The Interface to the Rest of your Application
{
public:
virtual bool checkBatteryFull()
{
std::cout << "Implement battery check" << std::endl;
return false;
}
virtual void turnOnLed() { std::cout << "Implement turn on LED" << std::endl; }
virtual void playAudio() { std::cout << "Implement playing audio" << std::endl; }
virtual void sendEventToAnotherSm(MyEventID)
{
std::cout << "Send event to another state machine in your system" << std::endl;
// anotherStateMachine.react(e);
}
virtual ~MyApi() {}
};
class MyStateMachine : public virtual StateMachine<MyStateID, MyEventID>
{
public:
MyStateMachine(MyApi &api)
: m_api(api)
{
init();
}
void init() override
{
addInitialState(MyStateID::Startup, "Startup");
addReaction(MyStateID::Startup, MyEventID::Off, [&]() {
std::cout << "Hey a Off-Event in Startup" << std::endl;
if (m_api.checkBatteryFull()) { // this is the easy way to call the rest of your system
return true; // must return true to do corresponding transition
}
return false;
});
addTransition(MyStateID::Startup,
MyEventID::Off,
MyStateID::Running); // this one will be forbidden by reaction above
addTransition(MyStateID::Startup, MyEventID::On, MyStateID::Running);
addState(MyStateID::Running, "Running");
addEntry(MyStateID::Running, [&]() {
std::cout << "Entry() of Running" << std::endl;
startTimer(42, 500); // start timer 42 with 500 ms
m_api.turnOnLed(); // this is the easy way to call the rest of your system
return true; // return what ever you want - doesnt matter
});
addExit(MyStateID::Running, [&]() {
std::cout << "Exit() of Running" << std::endl;
stopTimer(42); // timer 42 is now stopped
return false; // return what ever you want - doesnt matter
});
addTransition(MyStateID::Running, MyEventID::Off, MyStateID::Startup);
addTransition(MyStateID::Running, MyEventID::TimerExpired, MyStateID::Startup);
addReaction(MyStateID::Running, MyEventID::TimerExpired, [&]() {
if (isTimerExpired(42)) {
std::cout << "Timer 42 has expired" << std::endl;
return true;
}
return false;
});
addInitialState(MyStateID::Lampe1An, "Lampe1An", MyStateID::Running);
addTransition(MyStateID::Lampe1An, MyEventID::Toggle, MyStateID::Lampe1Aus);
addState(MyStateID::Lampe1Aus, "Lampe1Aus", MyStateID::Running);
addTransition(MyStateID::Lampe1Aus, MyEventID::Toggle, MyStateID::Lampe1An);
addEntry(MyStateID::Lampe1Aus, []() {
std::cout << "Entry() of Lampe1Aus" << std::endl;
return true; // return what ever you want - doesnt matter
});
addExit(MyStateID::Lampe1Aus, []() {
std::cout << "Exit() of Lampe1Aus" << std::endl;
return false; // return what ever you want - doesnt matter
});
addState(MyStateID::Lampe2An, "Lampe2An", MyStateID::Running);
addTransition(MyStateID::Lampe2An, MyEventID::Toggle, MyStateID::Lampe2Aus);
addTransition(MyStateID::Lampe2An, MyEventID::Off, MyStateID::Startup);
addReaction(MyStateID::Lampe2An, MyEventID::Off, []() {
std::cout << "Hey a Off-Event in Lampe2An" << std::endl;
return false; // returns false so the transition is skipped
});
addInitialState(MyStateID::Lampe2Aus, "Lampe2Aus", MyStateID::Running);
addTransition(MyStateID::Lampe2Aus, MyEventID::Toggle, MyStateID::Lampe2An);
addEventName(MyEventID::On, "On");
addEventName(MyEventID::Off, "Off");
addEventName(MyEventID::Toggle, "Toggle");
}
private:
MyApi &m_api;
};
int main()
{
MyApi myApi;
MyStateMachine m(myApi);
#ifdef MEASURE_TIME
auto start = std::chrono::steady_clock::now();
#endif
m.react(MyEventID::Off);
m.react(MyEventID::On);
m.react(MyEventID::Toggle);
m.react(MyEventID::Toggle);
m.react(MyEventID::Toggle);
m.react(MyEventID::Toggle);
m.react(MyEventID::Off);
m.react(MyEventID::Off);
m.react(MyEventID::On);
m.react(MyEventID::Toggle);
m.react(MyEventID::Toggle);
m.react(MyEventID::Toggle);
m.react(MyEventID::Toggle);
m.react(MyEventID::Off);
m.react(MyEventID::On);
m.react(MyEventID::Off);
m.react(MyEventID::On);
#ifdef MEASURE_TIME
std::cout << "Elapsed(us)="
<< std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - start)
.count()
<< std::endl;
#endif
for (int ms = 0; ms < 1000; ms++) {
// of course you should call this in your SysTick-Handler
m.handleTimerTick();
}
}
Du siehst schon – Templates brauchst du nur in einer Zeile um deine eigenen Listen für States und Events einbinden zu können.
Die Anbindung an dein restliches System hab ich nur skizziert.
Ich hoffe der Code ist ansonsten selbsterklärend – Viel Spaß damit
Ach ja, noch die Ausgabe des Programms:
onOff()
Hey a Off-Event in Startup
Implement battery check
onOn()
onEntry() of Running
Entry() of Running
Implement turn on LED
Current States: Running Lampe1An Lampe2Aus
onToggle()
onEntry() of Lampe1Aus
Entry() of Lampe1Aus
Current States: Running Lampe1Aus Lampe2An
onToggle()
onExit() of Lampe1Aus
Exit() of Lampe1Aus
Current States: Running Lampe1An Lampe2Aus
onToggle()
onEntry() of Lampe1Aus
Entry() of Lampe1Aus
Current States: Running Lampe1Aus Lampe2An
onToggle()
onExit() of Lampe1Aus
Exit() of Lampe1Aus
Current States: Running Lampe1An Lampe2Aus
onOff()
Exit() of Lampe1Aus
onExit() of Running
Exit() of Running
Current States: Startup
onOff()
Hey a Off-Event in Startup
Implement battery check
onOn()
onEntry() of Running
Entry() of Running
Implement turn on LED
Current States: Running Lampe1An Lampe2Aus
onToggle()
onEntry() of Lampe1Aus
Entry() of Lampe1Aus
Current States: Running Lampe1Aus Lampe2An
onToggle()
onExit() of Lampe1Aus
Exit() of Lampe1Aus
Current States: Running Lampe1An Lampe2Aus
onToggle()
onEntry() of Lampe1Aus
Entry() of Lampe1Aus
Current States: Running Lampe1Aus Lampe2An
onToggle()
onExit() of Lampe1Aus
Exit() of Lampe1Aus
Current States: Running Lampe1An Lampe2Aus
onOff()
Exit() of Lampe1Aus
onExit() of Running
Exit() of Running
Current States: Startup
onOn()
onEntry() of Running
Entry() of Running
Implement turn on LED
Current States: Running Lampe1An Lampe2Aus
onOff()
Exit() of Lampe1Aus
onExit() of Running
Exit() of Running
Current States: Startup
onOn()
onEntry() of Running
Entry() of Running
Implement turn on LED
Current States: Running Lampe1An Lampe2Aus
Elapsed(us)=123
Timer 42 has expired
Exit() of Lampe1Aus
onExit() of Running
Exit() of Running
Current States: Startup
Mal wieder ein größeres Projekt mit meinem Vermieter und Kumpel Hans zusammen. Ein Android-Fahrradcomputer mit offline Karte, BLE-Sensoren, Aufzeichnung und GPX-Export. Wieder mit meinem neuen Lieblingswerkzeug Dart & Flutter
by Stefan·Kommentare deaktiviert für Cutefish für Ubuntu 20.04
Timo hat neulich den, total schicken, neuen Desktop Cutefish auf YouTube entdeckt.
Wir sind von der Schnelligkeit, Optik und Bedienung total begeistert.
Außerdem ist Cutefish in QT programmiert und benutzt einige Teile von KDE
(QT war immer mein Argument warum ich KDE und nichts anderes verwende 🙂 ).
Leider gibt es nur Downloads für ArchLinux und Manjaro.
Drum hier die Pakete für die letzte LTS von Ubuntu:
Schon die dritte Version des einfachen Getränkeautomats, die ich baue – Selbes Prinzip aber diesmal völlig neue Bauweise. Diesmal hab ich als Basis einfach ein sehr günstiges Android-Tablet verwendet. Für die Implementierung natürlich mein neues Lieblingswerkzeug Dart&Flutter.
Eine „ungebrandede“ Version des Mat-O-Id gibt es bald bei F-Droid
Mal wieder ein richtiges Unsinnsprojekt 🙂 Ein Nudelkocher mit App- bzw. PC-Steuerung über Bluetooth Noch nicht ganz fertig – aber mal die ersten Bilder
Ein Gerät zum Bezahlen von Getränken, mit einem RFID-Token, auf meiner Arbeit. Mittlerweile die zweite Version mit schönerer GUI durch TouchGFX. Zum alten Mat-O-Mat, der schon seit etwa zwei Jahren im Einsatz ist, schreibe ich was wenn dieser erfolgreich durch die neue Version abgelöst ist.
by Stefan·Kommentare deaktiviert für Warm-Wasser Steuerung
Projekt mit meinem Vermieter Hans zusammen – Eine Warm-Wasser Steuerung für ein Ferienhaus. Das Projekt verwendet mein neues Lieblingsboard, das man zur Zeit für einen sagenhaften Preis bei Amazon bekommt. Hab mittlerweile schon 7 davon gekauft, eines kaputt gemacht und 4 davon verbaut. Die ersten Gehversuche damit waren der Mat-O-Mat und zwei Analysegeräte für eine Pumpe. Zum Mat-O-Mat kommt bald was. Verwendet hab ich dazu mbed und die ETL – eine spitzen Kombination, finde ich.
by Stefan·Kommentare deaktiviert für Einfaches EKG mit ARM
Vor kurzem bin ich von AVR Mikrocontrollern auf ARM umgestiegen. Nach ein wenig Herumprobieren fehlt jetzt ein anständiges Projekt. Ich hab lange überlegt und jetzt endlich was Passendes gefunden. Dann mal los …
by Stefan·Kommentare deaktiviert für Koordinatenrechner
Mal eine kleine Fingerübung für zwischendurch.
Auf Arbeit müssen wir oft zwischen verschiedenen Koordinatensystemen konvertieren.
Abhilfe soll der kleine Rechner hier schaffen, der hoffentlich noch um viele Funktionen erweitert wird.
by Stefan·Kommentare deaktiviert für NDS Plugin für QGIS
Hab ich mir schon lange gewünscht – ein einfaches Plugin zum Anzeigen von NDS Kacheln für QGIS.
War super einfach. Kein Wunder, dass es schon so viele QGIS Plugins gibt.
Gemeinsames Projekt mit Bernd. Ziel ist ein Retro Spielautomat für alte Arcade Klassiker mit dem RaspberryPI.
Bernd ist gerade dabei ein Gehäuse zu bauen und ich hab mich derweil um ein einfaches Menü und
eine Möglichkeit zum Anschluss eines klassischen Joysticks an den PI gekümmert
by Stefan·Kommentare deaktiviert für ZECHA Track & Time
Mal wieder ein größeres Projekt in QT – noch nicht ganz fertig aber mal ein Zwischenstand.
Ausschlaggebend war ein Gespräch mit Basti vor etwa drei Wochen.
by Stefan·Kommentare deaktiviert für Browser für Requirements
Nach Langem endlich mal wieder ein Projekt in Qt das richtig Spaß macht 🙂 Spaß macht es vor allem durch die vielen Ideen, Verbesserungswünsche und Bugreports von Kollegen, die das Tool verwenden. An dieser Stelle noch mal vielen Dank dafür. Ich hoffe es gibt noch viel zu tun …
by Stefan·Kommentare deaktiviert für Erstes Projekt mit Wt
Einige wissen vielleicht wie das ist – man findet eine coole Bibliothek und will damit unbedingt was tolles machen. Glücklicherweise hatte ein Kollege ein passendes Problem, das sich gut für ein erstes Projekt eignete …