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.

Der Quellcode (natürlich GPL) liegt unter https://bitbucket.org/bobbery/qpocketscope (ist sehr einfach nur ca. 300 LOC)

Als erstes kommen natürlich die Linux-Nutzer dran:

https://stefan.box2code.de/huge_files/QPocketScope_2024_11_05.tar.gz

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 🙂

Viel Spaß damit – euer Stefan

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 

CodenameCFB ( CORmunity – Fotobox )
KurznamecorCAM
Kunde:Unsere CORmunity bei Corscience
Projektzeitraum:etwa 1,5 Monate
Produktive Stunden:etwa 60
Tarif:CORmunity-4-CORmunity ( nur Material )
Einsatzzweck:Partyfotos 🙂
Quellcode:Applikation etwa 1000 LOC
Neu erworbene Skills:Für Raspi immer das offizielle Netzteil verwenden ( sonst undervoltage )
Bügelbrett eignet sich hervorragend als Montageplattform 🙂
Fotografieren und Beleuchtung ( natürlich immer noch totaler Laie dadrin 🙂 )
Rückblick:Absoluter Funfaktor – so ein geiles Projekt 🙂
Danke an Sina für die super Idee und den Projektanstoß
Danke an Viktoria für die hervorragende Projektleitung und deine rat- und tatkräftige Unterstützung
Danke an Jörg für die Finanzierung und megaschnelle Bestellung unserer benötigten Komponenten
Danke an Sebastian für die tollen Tipps zum Fotografieren
Kundenstimme:fehlt noch
Continue reading

CodenameRDP ( Radarpistole )
Kunde:Hans Reif
Projektzeitraum:über Weihnachten
Produktive Stunden:etwa 20
Tarif:Friends (beer and food 🙂 )
Einsatzzweck:Geschwindigkeitsmessung mit günstigem Doppler-Radarsensor
Quellcode:ESP32-FW ca. 100 LOC
Neu erworbene Skills:Funktionsweise Doppler-Radar
Schaltungssimulation mit EasyEDA und Qucs-S
Rückblick:Wir sind noch nicht fertig und bauen jetzt das Gerät weiter zu einem autonomen System um, das an der Straße positioniert, Fahrzeuge auf beiden Fahrspuren erfasst und protokolliert
Kundenstimme:Später, wenn wir ganz fertig sind 🙂
Continue reading

CodenameTKA ( Ansteuerung für Temperaturkammer )
Kunde:Führender Hersteller von Test und Messequipment
Projektzeitraum:etwa 3 Tage
Produktive Stunden:etwa 3 – 4
Tarif:Wegen Minimalaufwand geschenkt
Einsatzzweck:Ansteuerung einer Temperaturkammer, mit Mustern definiert in Excel-Dokmument, via TCP-Socket-Protokoll
Quellcode:PC-SW ca. 250 LOC
Neu erworbene Skills:
Rückblick:War sehr leicht umzusetzten, Protokoll der Kammer war gut beschrieben, Kunde war schon mit der ersten Demo zufrieden 🙂
Kundenstimme:Fehlt noch
Continue reading

CodenamePMGWeb (Webinterface für Pegelmessgerät)
Kunde:Hans Reif
Projektzeitraum:etwa 2 Monate
Produktive Stunden:etwa 20
Tarif:Friends ( beer and food 🙂 )
Einsatzzweck:Pegelstände von Flüssigkeiten darstellen und Messung triggern
Quellcode:Device ESP 300 LOC
WEB-Page 300 LOC
Neu erworbene Skills:Kann jetzt besser und schneller Webanwendungen mit UI5 bauen
ApexCharts funktionieren recht gut zusammen mit UI5
Rückblick:Es war ein sehr schönes Projekt, Hans war in meiner Lehrzeit mein Elektronikervorbild und es versteht sich von selbst dass wir viel zu quatschen und viel Spaß hatten 🙂
Kundenstimme:Es hat richtig Spaß gemacht, dieses Projekt mit Stefan zu machen. Es funktioniert super, genauso wie ich es mir vorgestellt habe. Stefan hat eine sehr professionelle Arbeit abgeliefert. Vielen Dank. Freue mich schon auf das nächste Projekt.
Continue reading

CodenameCLM (Curved Light Modulator)
Kunde:Jörg vom Deep Zone Experience Project
Projektzeitraum:etwa 5 Monate
Produktive Stunden:etwa 60
Tarif:CORmunity ( pay in beer 🙂 )
Einsatzzweck:verraten wir nicht 🙂
Quellcode:Device 200 LOC
PC-Design-SW 550 LOC
WEB-Page 260 LOC
Android-App 200 LOC
Neu erworbene Skills:Einfacher und stromsparender Aufbau von batteriebetriebenen Geräten

Eigene Leiterplatten sind schnell entworfen und machen auch für Prototypen Sinn da unglaublich günstig – außerdem macht’s Spaß

Miniaturisierung und Optimierung für den Low-Cost Markt (Materialkosten < 7€ bei Einzelstückzahlen)

Lichtleiter mit 3D-Drucker ( danke Norbert 🙂 )
Rückblick:Es war ein sehr schönes Projekt, Jörg ist immer gut gelaunt, immer erreichbar, hat sehr gute Ideen, einen Sinn fürs Wesentliche und einen sehr netten Humor
Kundenstimme:Stefan hat die Projektidee schnell und einfach umgesetzt sowie im Projekt eine Menge guter Ideen eingebracht. Das Ergebnis lässt sich sehen und wir sind auch mit überschaubaren Ausgaben zum Ziel gekommen. Ich freue mich auf die nächste Ausbaustufe. 
Continue reading

Letztes Jahr hatte ich die Gelegenheit
etwas mit dem coolen HTML5-Framework eines Kunden zu machen.

Hab dann nach einer freien Alternative gesucht und bin bei
UI5 von SAP gelandet und bin voll begeistert.

Continue reading

svg2qml war kein guter Name – gab’s schon 🙂 Wir nennens jetzt mal InkBridge4Qml

Einfaches Tool zum generieren von QML aus SVG-Bildern. Funktionalität ist ähnlich zur kostenpflichtigen Qt Bridge for Adobe Photoshop.

Happy animating 🙂

Continue reading

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

Continue reading

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:

Continue reading

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

Continue reading

Mal wieder ein richtiges Unsinnsprojekt 🙂
Ein Nudelkocher mit App- bzw. PC-Steuerung über Bluetooth
Noch nicht ganz fertig – aber mal die ersten Bilder

Continue reading

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.

Continue reading

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.

Continue reading

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 …

Continue reading

Lange Zeit hab ich mich bei Mikrocontrollern auf 8-Bit beschränkt (8051 und AVR).
Ich dachte immer die 32-Bit ARM Controller wären zu teuer und für die meisten Anwendungen sowieso überdimensioniert.
Aber das stimmt bei weitem nicht mehr…

Continue reading

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.

Continue reading

Nicht wirklich ein Freizeitprojekt, da ich den größten Teil auf Arbeit geschrieben habe
wegen Lizenzanforderungen von PCLint und Visual Studio

Continue reading

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

Continue reading

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 …

Continue reading

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 …

Continue reading

Wer mit mir schon gearbeitet hat weiß, dass ich ein Fan von Anekdoten bin. Oft sagt nämlich ein kurzer Satz mehr aus als das was in einem ganzen Buch niedergeschrieben ist …

Continue reading

Zauberkünstler ist ein kleines Programm, dass ich vor einigen Jahren mit C++ und QT, für einen mir bekannten Zauberer geschrieben habe. Es war damals (ca. 2005) eines meiner ersten größeren Programme, die ich mit C++ geschrieben habe. Daher hat es vielleicht nicht gerade das beste objektorientierte Design, ist aber sehr einfach aufgebaut und gut zu verstehen.

Continue reading