Set version to 1.3.12

Replaced using gitFetch() with gitPull()
Removed gitFetchAndDiff() and original version of gitPull().
2023-10-18 11:45:54 +02:00 · 2023-10-18 11:40:04 +02:00 · 2023-10-18 11:38:26 +02:00 · 2023-10-18 11:37:46 +02:00 · 2023-10-18 11:36:13 +02:00 · 2023-10-18 11:35:23 +02:00
19 changed files with 1462 additions and 668 deletions
--- a/OnDemandUpdatePTU.pro
+++ b/OnDemandUpdatePTU.pro
@@ -15,39 +15,62 @@ DEFINES += QT_DEPRECATED_WARNINGS
 # In order to do so, uncomment the following line.
 # You can also select to disable deprecated APIs only up to a certain version of Qt.
 #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
-VERSION=1.1.1
+
+# 1.3.6 :   Do not update device-controller/json files, but have the library
+#           (in a later step) do that.
+#           Fixed sending messages to ISMAS.
+#           Always execute contents of opkg_commands-file (even if there are no
+#           changes).
+# 1.3.7 :   Wait forever for git-commands to finish in QProcess executing such
+#           a command.
+# 1.3.8 :   Remove accessing opkg_commands under file-system-path /etc/psa_update.
+#           Activate download of json-configuration files.
+# 1.3.9 :   Fix sendLastVersion: use configured branch and not master branch in
+#               git show origin/master -s --format="c=%h m=%s d=%cI"    ==>
+#               git show origin/zg1/zone1 -s --format="c=%h m=%s d=%cI"
+#           Use dynamic values for os-release and apism-version when sending
+#           last version info.
+# 1.3.10:   Fix premature killing opkg-commands: detected timeout of 100s was
+#           too small when updating apism.
+#           Fix display of UPDATE_SUCCESS when opkg_command fails. Detected when
+#           updating apsim failed.
+# 1.3.11:   Integrate version of ATBUpdateTool in SendLastVersion-ISMAS-message.
+# 1.3.12:   Add command parameters for output of yocto-infos about ATBUpdateTool.
+#           Use 'git pull' instead of 'git fetch'.
+#           Use 'git clone --filter=blob:none' instead of 'git clone' to speed
+#           up cloning of customer repository.
+
+win32 {
+    BUILD_DATE=$$system("date /t")
+    BUILD_TIME=$$system("time /t")
+} else {
+    BUILD_DATE=$$system("date +%d-%m-%y")
+    BUILD_TIME=$$system("date +%H:%M:%S")
+}
+
+GIT_COMMIT=$$system("git log -1 --format=oneline | cut -d' ' -f1")
+
+VERSION="1.3.11"
+EXTENDED_VERSION="$${VERSION}-$${GIT_COMMIT}"

 INCLUDEPATH += plugins

-CONFIG += c++17 console
+CONFIG += c++17
 # CONFIG -= app_bundle

 DEFINES+=APP_VERSION=\\\"$$VERSION\\\"
+DEFINES+=APP_BUILD_DATE=\\\"$$BUILD_DATE\\\"
+DEFINES+=APP_BUILD_TIME=\\\"$$BUILD_TIME\\\"
+DEFINES+=APP_EXTENDED_VERSION=\\\"$$EXTENDED_VERSION\\\"

 QMAKE_CXXFLAGS += -g
 QMAKE_CXXFLAGS += -Wno-deprecated-copy

-# custom target for 'git subtree'
-# subtree.target = subtree
-# subtree.commands = git subtree add --prefix DCPlugin https://git.mimbach49.de/GerhardHoffmann/DCPlugin.git master --squash
-# subtree.depends =
-# QMAKE_EXTRA_UNIX_TARGETS += subtree
-
-# ! exists(DCPlugin) {
-#     $$system("git subtree add --prefix DCPlugin https://git.mimbach49.de/GerhardHoffmann/DCPlugin.git master --squash")
-# } else {
-    # $$system("git subtree pull --prefix DCPlugin https://git.mimbach49.de/GerhardHoffmann/DCPlugin.git master --squash")
-# }
-
-# You can make your code fail to compile if it uses deprecated APIs.
-# In order to do so, uncomment the following line.
-#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
-
 contains( CONFIG, PTU5 ) {
    greaterThan(QT_MAJOR_VERSION, 4): QT += serialport
    CONFIG += link_pkgconfig
    lessThan(QT_MAJOR_VERSION, 5):   PKGCONFIG += qextserialport
-    QMAKE_CXXFLAGS += -std=c++17   # for GCC >= 4.7
+    QMAKE_CXXFLAGS += -O2 -std=c++17   # for GCC >= 4.7
    QMAKE_CXXFLAGS += -Wno-deprecated-copy
    ARCH = PTU5
    DEFINES+=PTU5
@@ -78,6 +101,7 @@ contains( CONFIG, DesktopLinux ) {
 SOURCES += \
        main.cpp \
        progress_event.cpp \
+        update_dc_event.cpp \
        mainwindow.cpp \
        utils.cpp \
        update.cpp \
@@ -91,6 +115,7 @@ SOURCES += \
 HEADERS += \
        update.h \
        progress_event.h \
+        update_dc_event.h \
        utils.h \
        mainwindow.h \
        git/git_client.h \
@@ -105,18 +130,6 @@ HEADERS += \
 FORMS += \
    mainwindow.ui

-OTHER_FILES += \
-    /opt/app/tools/atbupdate/update_log.csv \
-    main.cpp.bck \
-    main.cpp.bck2 \
-    main.cpp.bck3
-
-# https://blog.developer.atlassian.com/the-power-of-git-subtree/?_ga=2-71978451-1385799339-1568044055-1068396449-1567112770
-# git subtree add --prefix DCPlugin https://git.mimbach49.de/GerhardHoffmann/DCPlugin.git master --squash
-# git subtree pull --prefix DCPlugin https://git.mimbach49.de/GerhardHoffmann/DCPlugin.git master --squash
-# include(./DCPlugin/DCPlugin.pri)
-
-

 ##########################################################################################
 # for running program on target through QtCreator
--- a/git/git_client.cpp
+++ b/git/git_client.cpp
@@ -26,12 +26,54 @@ GitClient::GitClient(QString const &customerNrStr,
 }

 bool GitClient::gitCloneCustomerRepository() {
-    QString gitCommand("git clone ");
+    /*  Blobless clone
+        ==============
+
+        When using the --filter=blob:none option, the initial git clone will
+        download all reachable commits and trees, and only download the blobs
+        for commits when you do a git checkout. This includes the first checkout
+        inside the git clone operation.
+
+        The important thing to notice is that we have a copy of every blob at
+        HEAD but the blobs in the history are not present. If your repository
+        has a deep history full of large blobs, then this option can
+        significantly reduce your git clone times. The commit and tree data is
+        still present, so any subsequent git checkout only needs to download
+        the missing blobs. The Git client knows how to batch these requests to
+        ask the server only for the missing blobs.
+
+        Further, when running git fetch in a blobless clone, the server only
+        sends the new commits and trees. The new blobs are downloaded only
+        after a git checkout. Note that git pull runs git fetch and then git
+        merge, so it will download the necessary blobs during the git merge
+        command.
+
+        When using a blobless clone, you will trigger a blob download whenever
+        you need the contents of a file, but you will not need one if you only
+        need the OID (object-id) of a file. This means that git log can detect
+        which commits changed a given path without needing to download extra
+        data.
+
+        This means that blobless clones can perform commands like git
+        merge-base, git log, or even git log -- <path> with the same performance
+        as a full clone.
+
+        Commands like git diff or git blame <path> require the contents of the
+        paths to compute diffs, so these will trigger blob downloads the first
+        time they are run. However, the good news is that after that you will
+        have those blobs in your repository and do not need to download them a
+        second time. Most developers only need to run git blame on a small
+        number of files, so this tradeoff of a slightly slower git blame command
+        is worth the faster clone and fetch times.
+
+        Note: git v2.18 does not support treeless clones: --filter=tree:0.
+     */
+    QString gitCommand("git clone --filter=blob:none ");
    gitCommand += m_repositoryPath;
    Command c(gitCommand);

    qInfo() << "IN CURRENT WD" << m_workingDirectory
-            << "CLONE" << m_repositoryPath << "...";
+            << "CLONE VIA COMMAND" << gitCommand;

    if (c.execute(m_workingDirectory)) { // execute the command in wd
        QString const result = c.getCommandResult();
@@ -47,8 +89,13 @@ bool GitClient::gitCloneCustomerRepository() {
                    }
                }
            }
+            Utils::printCriticalErrorMsg(
+                QString("ERROR CLONE RESULT HAS WRONG FORMAT. rcc=%1 CLONE_RESULT=%2")
+                    .arg(re.captureCount())
+                    .arg(result));
+            return false;
        }
-        Utils::printCriticalErrorMsg(QString("ERROR CLONE RESULT HAS WRONG FORMAT. CLONE_RESULT=") + result);
+        Utils::printCriticalErrorMsg("ERROR CLONE RESULT IS EMPTY");
    }
    return false;
 }
@@ -114,19 +161,23 @@ bool GitClient::gitCloneAndCheckoutBranch() {
    return false;
 }

-QStringList GitClient::gitShowReason() {
+QStringList GitClient::gitShowReason(QString branchName) {
    QStringList lst;
    if (QDir(m_customerRepository).exists()) {
        // %h: commit (short form)
        // %s: commit message
        // %cI: commit date, strict ISO 8601 format
-        Command c("git show -s --format=\"c=%h m=%s d=%cI\"");
+        // Note: branch with branchName has to exist: format zg1/zone1
+        Command c(QString("git show origin/%1 -s --format=\"c=%h m=%s d=%cI\"").arg(branchName));
        if (c.execute(m_customerRepository)) {
            QString const s = c.getCommandResult().trimmed();
            int const c = s.indexOf("c=");
            int const m = s.indexOf("m=");
            int const d = s.indexOf("d=");
-            QString commit{""}, msg{""}, date{""};
+
+            QString msg = IsmasClient::getReasonForLastSendVersion();
+            QString commit{""}, date{""};
+
            if (c != -1) {
                int start = c + 2;
                if (m >= start) {
@@ -136,7 +187,9 @@ QStringList GitClient::gitShowReason() {
                    start = m + 2;
                    if (d >= start) {
                        length = d - start;
+                        msg += " (";
                        msg = s.mid(start, length).trimmed();
+                        msg += ")";

                        start = d + 2;
                        date = s.mid(start);
@@ -212,11 +265,11 @@ std::optional<QStringList> GitClient::gitDiff(QString const &commits) {
 /*
 Hat sich nichts geaendert, so werden auch keine Commits <>..<> angezeigt
 */
-std::optional<QString> GitClient::gitFetch() {
+std::optional<QString> GitClient::gitPull() {
    if (QDir(m_customerRepository).exists()) {
        qInfo() << "BRANCH NAME" << m_branchName;

-        Command c("git fetch");
+        Command c("git pull");
        if (c.execute(m_customerRepository)) {
            QString const s = c.getCommandResult().trimmed();
            if (!s.isEmpty()) {
@@ -242,59 +295,38 @@ std::optional<QString> GitClient::gitFetch() {
                                if (re.captureCount() == 3) { // start with full match (0), then the other 3 matches
                                    return match.captured(2);
                                } else {
-                                    emit m_worker->showErrorMessage("git fetch",
+                                    emit m_worker->showErrorMessage("git pull",
                                        QString("(wrong cap-count (%1)").arg(re.captureCount()));
                                }
                            } else {
-                                emit m_worker->showErrorMessage("git fetch",
+                                emit m_worker->showErrorMessage("git pull",
                                    "no regex-match for commits");
                                Utils::printCriticalErrorMsg("NO REGEX MATCH FOR COMMITS");
                            }
                        }
                    }
                    if (!found) {
-                        emit m_worker->showErrorMessage("git fetch",
+                        emit m_worker->showErrorMessage("git pull",
                            QString("unkown branch name ") + m_branchName);
                        Utils::printCriticalErrorMsg("UNKNOWN BRANCH NAME " + m_branchName);
                    }
                } else {
-                    emit m_worker->showErrorMessage("git fetch",
-                        QString("wrong format for result of 'git fetch' ") + s);
+                    emit m_worker->showErrorMessage("git pull",
+                        QString("wrong format for result of 'git pull' ") + s);
                    Utils::printCriticalErrorMsg(QString("WRONG FORMAT FOR RESULT OF 'GIT FETCH' ") + s);
                }
            } else {
-                emit m_worker->showErrorMessage("git fetch", "empty result for 'git fetch'");
-                Utils::printCriticalErrorMsg("EMPTY RESULT FOR 'GIT FETCH'");
+                // emit m_worker->showErrorMessage("git fetch", "empty result for 'git fetch'");
+                Utils::printInfoMsg("EMPTY RESULT FOR 'GIT PULL'");
            }
        }
    } else {
-        emit m_worker->showErrorMessage("git fetch", QString("repository ") + m_customerRepository + " does not exist");
+        emit m_worker->showErrorMessage("git pull", QString("repository ") + m_customerRepository + " does not exist");
        Utils::printCriticalErrorMsg(QString("REPOSITORY ") + m_customerRepository + " DOES NOT EXIST");
    }
    return std::nullopt;
 }

-bool GitClient::gitFetchAndDiff() {
-    if (gitFetch()) {
-        QString gitCommand("git diff --compact-summary HEAD..FETCH_HEAD");
-        Command c(gitCommand);
-        return c.execute(m_workingDirectory);
-    }
-    return false;
-}
-
-bool GitClient::gitPull() {
-    if (QDir(m_customerRepository).exists()) {
-        Command c("git pull");
-        if (c.execute(m_customerRepository)) {
-            qInfo() << "PULLED INTO" << m_customerRepository;
-            return true;
-        }
-        Utils::printCriticalErrorMsg(QString("PULL INTO " + m_customerRepository + " FAILED"));
-    }
-    return false;
-}
-
 std::optional<QStringList> GitClient::gitMerge() {
    Command c("git merge");
    if (c.execute(m_workingDirectory)) {
--- a/git/git_client.h
+++ b/git/git_client.h
@@ -43,14 +43,12 @@ class GitClient : public QObject {

    bool gitCloneAndCheckoutBranch();

-    std::optional<QString> gitFetch();
-    bool gitFetchAndDiff();
-    bool gitPull();
+    std::optional<QString> gitPull();
    std::optional<QStringList> gitDiff(QString const &commit);
    std::optional<QStringList> gitMerge();

    QString gitLastCommit(QString fileName);
-    QStringList gitShowReason();
+    QStringList gitShowReason(QString branchName);
    static QString gitBlob(QString fileName);
    QString gitCommitForBlob(QString blob);
    bool gitIsFileTracked(QString file2name);
--- a/ismas/ismas_client.cpp
+++ b/ismas/ismas_client.cpp
@@ -1,4 +1,5 @@
 #include "ismas/ismas_client.h"
+#include "utils.h"

 #include <cstring>
 #include <cstdio>
@@ -22,6 +23,15 @@
 #include <QJsonObject>

 #if 0
+########################
+# Spec vom 27.10.2023:
+# U0010 -> %-Werte
+# U0001 -> 100%
+# U0003 -> "FAIL"
+# U0002 -> "" (OK -> WAIT state reset)
+# ISMAS -> "WAIT"
+########################
+#
 # $1: EVENT: U0001 update finished: 100%
 #            U0002 reset TRG
 #            U0003 error
@@ -393,6 +403,15 @@ QString IsmasClient::execOpkgCommand(QString const &info, QString const &version
                             version.toStdString().c_str());
 }

+QString IsmasClient::rsyncFile(QString const &info, QString const &version) {
+    return updateNewsToIsmas("U0010",
+                             m_progressInPercent,
+                             RESULT_CODE::SUCCESS,
+                             "RSYNC FILE",
+                             info.toStdString().c_str(),
+                             version.toStdString().c_str());
+}
+
 QString IsmasClient::updateTriggerSet(QString const &info, QString const &version) {
    return updateNewsToIsmas("U0010",
                             m_progressInPercent,
@@ -607,10 +626,14 @@ QString IsmasClient::updateOfPSASendVersion(PSAInstalled const &psa) {
                "}"
            "},"
            "\"SOFTWARE\": {"
-                "\"RAUC\" : \"%s\","
-                "\"OPKG\" : \"%s\","
+                "\"APISM\" : {"
+                    "\"VERSION\" : \"%s\""
+                "},"
                "\"ATBQT\" : {"
                    "\"VERSION\" : \"%s\""
+                "},"
+                "\"ATB-UPDATE-TOOL\" : {"
+                    "\"VERSION\" : \"%s\""
                "}"
            "},"
            "\"PLUGINS\" : {"
@@ -736,9 +759,9 @@ QString IsmasClient::updateOfPSASendVersion(PSAInstalled const &psa) {
        psa.dc.gitBlob.toStdString().c_str(),
        psa.dc.gitLastCommit.toStdString().c_str(),

-        psa.sw.raucVersion.toStdString().c_str(),
-        psa.sw.opkgVersion.toStdString().c_str(),
+        psa.sw.apismVersion.toStdString().c_str(),
        psa.sw.atbQTVersion.toStdString().c_str(),
+        psa.sw.atbUpdateToolVersion.toStdString().c_str(),

        psa.pluginVersion.deviceController.toStdString().c_str(),
        psa.pluginVersion.ingenicoISelfCC.toStdString().c_str(),
@@ -820,7 +843,7 @@ QString IsmasClient::updateOfPSAActivated(QString const &version) {   // sent ev
 }

 QString IsmasClient::updateOfPSASucceeded(QString const &version) {
-    m_progressInPercent = 0;
+    m_progressInPercent = 100;
    return updateNewsToIsmas("U0001",
                             m_progressInPercent,
                             RESULT_CODE::SUCCESS,
@@ -847,14 +870,21 @@ QString IsmasClient::jsonParseFailed(int resultCode, QString reason, QString con
                             version.toStdString().c_str());
 }

-std::optional<QString> IsmasClient::finalResult(int resultCode, QString reason, QString const &version) {
-    m_progressInPercent = 0;
+std::optional<QString> IsmasClient::finalResult(int resultCode,
+                                                QString reason,
+                                                QString const &version) {
+    Q_UNUSED(resultCode);
+    Q_UNUSED(reason);
+    Q_UNUSED(version);
+
+    /*
+    m_progressInPercent = 100;
    if (resultCode == RESULT_CODE::SUCCESS) {
        return updateNewsToIsmas("U0002",
                                 m_progressInPercent,
-                                 RESULT_CODE::SUCCESS,
+                                 resultCode,
                                 "FINAL-UPDATE-RESULT",
-                                 "(re-)set WAIT state",
+                                 reason.toStdString().c_str(),
                                 version.toStdString().c_str());
    }
    if (resultCode == RESULT_CODE::INSTALL_ERROR) {
@@ -865,6 +895,7 @@ std::optional<QString> IsmasClient::finalResult(int resultCode, QString reason,
                                 reason.toStdString().c_str(),
                                 version.toStdString().c_str());
    }
+    */
    return std::nullopt;
 }

@@ -877,3 +908,18 @@ QString IsmasClient::updateOfPSAFailed(int resultCode, QString step,
                             reason.toStdString().c_str(),
                             version.toStdString().c_str());
 }
+
+char const *IsmasClient::reason[REASON::ENTRIES] = {
+    "TIME-TRIGGERED", "SERVICE", "DEV-TEST"
+};
+
+QString IsmasClient::getReasonForLastSendVersion() {
+    QString const &parentName = Utils::getParentName();
+    if (parentName == "ATBQT") {
+        return reason[REASON::SERVICE];
+    }
+    if (parentName == "systemd") {
+        return reason[REASON::TIME_TRIGGERED];
+    }
+    return reason[REASON::DEV_TEST];
+}
--- a/ismas/ismas_client.h
+++ b/ismas/ismas_client.h
@@ -46,9 +46,9 @@ struct PSAInstalled {
    } dc;

    struct SoftWare {
-        QString raucVersion;
-        QString opkgVersion;
+        QString apismVersion;
        QString atbQTVersion;
+        QString atbUpdateToolVersion;
    } sw;

    struct PluginVersion {
@@ -97,9 +97,9 @@ struct PSAInstalled {
        dc.gitLastCommit = "N/A";
        dc.size = -1;

-        sw.raucVersion = "N/A";
-        sw.opkgVersion = "N/A";
+        sw.apismVersion = "N/A";
        sw.atbQTVersion = "N/A";
+        sw.atbUpdateToolVersion = "N/A";

        pluginVersion.deviceController = "N/A";
        pluginVersion.ingenicoISelfCC = "N/A";
@@ -141,6 +141,7 @@ public:
        DIRECT_PORT = 7778
    };

+
    enum RESULT_CODE {
        SUCCESS=0,
        NO_UPDATE_NECESSARY=1,
@@ -148,9 +149,20 @@ public:
        WRONG_PACKAGE=3,
        INSTALL_ERROR=4};

+    enum REASON {
+        TIME_TRIGGERED = 0,
+        SERVICE,
+        DEV_TEST,
+        ENTRIES
+    };
+
+    static char const *reason[REASON::ENTRIES];
+
    static std::optional<QString>
        sendRequestReceiveResponse(int port, QString const &request);

+    static QString getReasonForLastSendVersion();
+
    int getProgressInPercent() const {return m_progressInPercent; }
    void setProgressInPercent(int procent) { m_progressInPercent = procent; }

@@ -171,6 +183,7 @@ public:
    QString errorUpdateTrigger(QString const &info, QString const &version = QString());
    QString gitFetch(QString const &info, QString const &version = QString());
    QString execOpkgCommand(QString const &info, QString const &version = QString());
+    QString rsyncFile(QString const &info, QString const &version = QString());
    QString errorGitFetch(int resultCode, QString const &info, QString const &version = QString());
    QString updateOfPSAActivated(QString const &version = QString());
                                    // and update accepted
--- a/main.cpp
+++ b/main.cpp
@@ -32,6 +32,12 @@

 #include <QThread>
 #include <QtWidgets>
+#include <QScopedPointer>
+
+#if defined (Q_OS_UNIX) || defined (Q_OS_LINUX)
+#include <unistd.h>
+#include <errno.h>
+#endif

 #ifdef PTU5
 #define SERIAL_PORT "ttymxc2"
@@ -58,6 +64,24 @@ int main(int argc, char *argv[]) {
        setDebugLevel(LOG_NOTICE);
    }

+//#if defined (Q_OS_UNIX) || defined (Q_OS_LINUX)
+//#ifdef _POSIX_THREAD_PROCESS_SHARED
+//    errno = 0;
+//    int res = 0;
+//    if ((res = sysconf(_SC_THREAD_PROCESS_SHARED)) < 0) {
+//        if (errno != 0) {
+//            qCritical() << "_POSIX_THREAD_PROCESS_SHARED NOT SUPPORTED"
+//                        << strerror(errno);
+//            exit(-1);
+//        }
+//    } else {
+//        if (res == _POSIX_THREAD_PROCESS_SHARED) {
+//            Utils::printInfoMsg("_POSIX_THREAD_PROCESS_SHARED SUPPORTED");
+//        }
+//    }
+//#endif
+//#endif
+
    QCommandLineParser parser;
    parser.setApplicationDescription("Download tool for downloading device controller firmware, printer json-files and executing opkg-commands.");
    parser.addHelpOption();
@@ -73,7 +97,7 @@ int main(int argc, char *argv[]) {
    QCommandLineOption pluginNameOption(QStringList() << "plugin-name" << "plugin-name",
        QCoreApplication::translate("main", "Name of dc-plugin."),
        QCoreApplication::translate("main", "directory"));
-    QString const pluginNameDefault = "libCAmaster.so";
+    QString const pluginNameDefault = "libCAslave.so";
    pluginNameOption.setDefaultValue(pluginNameDefault);
    parser.addOption(pluginNameOption);

@@ -88,36 +112,29 @@ int main(int argc, char *argv[]) {
        QCoreApplication::translate("main", "Start ATBUpdateTool in dry-run-mode. No actual actions."));
    parser.addOption(dryRunOption);

+    QCommandLineOption extendedVersionOption(QStringList() << "V" << "extended-version",
+        QCoreApplication::translate("main", "Show extended version (including last git commit)."));
+    parser.addOption(extendedVersionOption);
+
+    QCommandLineOption yoctoVersionOption(QStringList() << "y" << "yocto-version",
+        QCoreApplication::translate("main", "Show yocto version of ATBUpdateTool."));
+    parser.addOption(yoctoVersionOption);
+
+    QCommandLineOption yoctoInstallStatusOption(QStringList() << "Y" << "yocto-install",
+        QCoreApplication::translate("main", "Show yocto install status of ATBUpdateTool."));
+    parser.addOption(yoctoInstallStatusOption);
+
    // Process the actual command line arguments given by the user
    parser.process(a);
    QString plugInDir = parser.value(pluginDirectoryOption);
    QString plugInName = parser.value(pluginNameOption);
    QString workingDir = parser.value(workingDirectoryOption);
-    bool dryRun = parser.isSet(dryRunOption);
+    bool const dryRun = parser.isSet(dryRunOption);
+    bool const showYoctoVersion = parser.isSet(yoctoVersionOption);
+    bool const showYoctoInstallStatus = parser.isSet(yoctoInstallStatusOption);
+    bool const showExtendedVersion = parser.isSet(extendedVersionOption);
    QString const rtPath = QCoreApplication::applicationDirPath();

-    if (!QDir(plugInDir).exists()) {
-        qCritical() << plugInDir
-                    << "does not exists, but has to contain dc-library";
-        exit(-1);
-    }
-
-    qInfo() << "pwd ..............." << rtPath;
-    qInfo() << "plugInDir ........." << plugInDir;
-    qInfo() << "plugInName ........" << plugInName;
-    qInfo() << "workingDir ........" << workingDir;
-    qInfo() << "dryRun ............" << dryRun;
-
-    // before loading the library, delete all possible shared memory segments
-#if defined Q_OS_LINUX || defined Q_OS_UNIX
-    // system("rm -rf /tmp/qipc*");
-#else
-#error "Only tested under UNIX/LINUX"
-#endif
-
-    hwinf *hw = Update::loadDCPlugin(QDir(plugInDir), plugInName);
-    // hw->dc_autoRequest(false);
-
    int machineNr = Utils::read1stLineOfFile("/etc/machine_nr");
    int customerNr = Utils::read1stLineOfFile("/etc/cust_nr");
    int zoneNr = Utils::read1stLineOfFile("/etc/zone_nr");
@@ -127,21 +144,76 @@ int main(int argc, char *argv[]) {
    QThread::currentThread()->setObjectName("main thread");
    qInfo() << "Main thread" << QThread::currentThreadId();

+    if (showExtendedVersion) {
+        printf(APP_EXTENDED_VERSION"\n");
+        return 0;
+    }

-    Worker worker(hw,
-                  customerNr,
+    if (showYoctoVersion) {
+        printf("%s\n", Worker::getATBUpdateToolYoctoVersion().toStdString().c_str());
+        return 0;
+    }
+
+    if (showYoctoInstallStatus) {
+        printf("%s\n", Worker::getATBUpdateToolYoctoInstallationStatus().toStdString().c_str());
+        return 0;
+    }
+
+    if (!QDir(plugInDir).exists()) {
+        qCritical() << plugInDir
+                    << "does not exists, but has to contain dc-library";
+        exit(-1);
+    }
+
+    qInfo() << "pwd ......................" << rtPath;
+    qInfo() << "plugInDir ................" << plugInDir;
+    qInfo() << "plugInName ..............." << plugInName;
+    qInfo() << "workingDir ..............." << workingDir;
+    qInfo() << "dryRun ..................." << dryRun;
+    qInfo() << "extended-version ........." << APP_EXTENDED_VERSION;
+    //qInfo() << "yocto-version ............" << Worker::getATBUpdateToolYoctoVersion();
+    //qInfo() << "yocto-install-status ....." << Worker::getATBUpdateToolYoctoInstallationStatus();
+
+    // before loading the library, delete all possible shared memory segments
+#if defined Q_OS_LINUX || defined Q_OS_UNIX
+    // system("rm -rf /tmp/qipc*");
+#else
+#error "Only tested under UNIX/LINUX"
+#endif
+
+    hwinf *hw = Update::loadDCPlugin(QDir(plugInDir), plugInName);
+    hw->dc_autoRequest(true);
+    // hw->dc_openSerial(5, "115200", "ttymxc2", 1);
+
+    Worker worker(customerNr,
                  machineNr,
                  zoneNr,
                  branchName,
+                  plugInName,
                  workingDir,
                  dryRun);

-    MainWindow mw(&worker);
+    QString const customerNrStr(
+        QString("customer_") + QString::number(customerNr).rightJustified(3, '0'));
+
+    QScopedPointer<Update> update(
+        new Update(hw,
+                   &worker,
+                   QDir::cleanPath(workingDir + QDir::separator() + customerNrStr),
+                   customerNrStr,
+                   branchName,
+                   plugInName,
+                   workingDir,
+                   dryRun,
+                   nullptr,
+                   SERIAL_PORT,
+                   "115200"));
+
+    MainWindow mw(hw, &worker, update.get());
    worker.setMainWindow(&mw);

    mw.setWindowFlags(Qt::Window | Qt::FramelessWindowHint);
-    mw.setWindowState(Qt::WindowFullScreen);
-    mw.show();
+    mw.showFullScreen();

    return a.exec();
 }
--- a/mainwindow.cpp
+++ b/mainwindow.cpp
@@ -3,20 +3,111 @@
 #include "worker.h"
 #include "utils.h"
 #include "progress_event.h"
+#include "update_dc_event.h"
+#include "plugins/interfaces.h"

 #include <QDateTime>
 #include <QMessageBox>
 #include <QDebug>
 #include <QScrollBar>
+#include <QEvent>

-MainWindow::MainWindow(Worker *worker, QWidget *parent)
+
+
+#if EMERGENCY_LEAVE_BL==1
+static int step = 0;
+
+void MainWindow::emergencyLeaveBL() {
+    //
+    qCritical() << __func__ << step;
+    switch(step) {
+    case 0:
+        if (m_hw->dc_openSerial(5, "115200", "ttymxc2", 1)) {
+            qCritical() << __func__ << "open ok";
+            step++;
+            QThread::msleep(2000);
+            m_hw->dc_autoRequest(false);
+            emit leaveBL();
+        }
+        break;
+    case 1:
+        m_hw->bl_rebootDC();
+        QThread::msleep(1000);
+        qCritical() << __func__ << "reboot ok" << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+        step++;
+        emit leaveBL();
+        break;
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+        m_hw->bl_startBL();
+        QThread::msleep(1000);
+        qCritical() << __func__ << "start" << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+        step++;
+        emit leaveBL();
+        break;
+    case 7:
+    case 9:
+    case 11:
+    case 13:
+    case 15:
+        m_hw->bl_checkBL();
+        qCritical() << __func__ << "check" << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+        QThread::msleep(1500);
+        ++step;
+        emit leaveBL();
+        break;
+    case 8:
+    case 10:
+    case 12:
+    case 14:
+    case 16:
+        qCritical() << __func__ << "is Up..." << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+        if (m_hw->bl_isUp()) {
+            qCritical() << __func__ << "is Up...OK" << step << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+            QThread::msleep(5000);
+            step = 16;
+        } else {
+            qCritical() << __func__ << "is Up...NO" << step << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+        }
+        ++step;
+        emit leaveBL();
+        break;
+    case 17:
+    case 18:
+    case 19:
+        qCritical() << __func__ << "stop" << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+        m_hw->bl_stopBL();
+        QThread::msleep(1000);
+        //m_hw->dc_closeSerial();
+        ++step;
+        emit leaveBL();
+        break;
+    }
+}
+#endif
+
+MainWindow::MainWindow(hwinf *hw, Worker *worker, Update *update, QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
+    , m_hw(hw)
    , m_worker(worker)
    , m_width(70)
    , m_progressRunning(false)
-    , m_progressValue(0) {
+    , m_progressValue(0)
+    , m_update(update)
+    , m_updateStep(UpdateDcEvent::UpdateStep::NONE) {

+#if EMERGENCY_LEAVE_BL==1
+    QTimer *t = new QTimer(this);
+    connect(t, SIGNAL(timeout()), this, SLOT(emergencyLeaveBL()));
+    connect(this, SIGNAL(leaveBL()), this, SLOT(emergencyLeaveBL()), Qt::QueuedConnection);
+    t->setSingleShot(true);
+    t->start(1000);
+    return;
+#endif

    this->setStatusBar(new QStatusBar(this));
    QFont f;
@@ -35,13 +126,16 @@ MainWindow::MainWindow(Worker *worker, QWidget *parent)
    QString start = QDateTime::currentDateTime().toString(Qt::ISODate);
    lst << QString("Start: ") + start.leftJustified(m_width-10);
    lst << QString("").leftJustified(m_width-3, '=');
+    lst << QString("Update tool version: %1 - %2 %3").arg(APP_VERSION).arg(APP_BUILD_DATE).arg(APP_BUILD_TIME).leftJustified(m_width-3);
    lst << QString("Machine number     : %1 ").arg(m_worker->machineNr()).leftJustified(m_width-3);
    lst << QString("Customer number    : %1 ").arg(m_worker->customerNr()).leftJustified(m_width-3);
    lst << QString("Zone number        : %1 (%2)").arg(m_worker->zoneNr()).arg(Utils::zoneName(m_worker->zoneNr())).leftJustified(m_width-3);
+    lst << QString("APISM version      : %1").arg(m_worker->apismVersion()).leftJustified(m_width-3);
    lst << QString("").leftJustified(m_width-3, '=');

    ui->updateStatus->setText(lst.join('\n'));
    ui->updateStatus->setEnabled(true);
+    // ui->updateStatus->installEventFilter(this);

    m_startTimer = new QTimer(this);
    connect(m_startTimer, SIGNAL(timeout()), m_worker, SLOT(update()));
@@ -60,6 +154,7 @@ MainWindow::MainWindow(Worker *worker, QWidget *parent)
    connect(m_worker, SIGNAL(restartExitTimer()),this,SLOT(onRestartExitTimer()));
    connect(m_worker, SIGNAL(appendText(QString,QString)),this,SLOT(onAppendText(QString,QString)));
    connect(m_worker, SIGNAL(showErrorMessage(QString,QString)),this, SLOT(onShowErrorMessage(QString,QString)));
+    connect(m_worker, SIGNAL(showStatusMessage(QString,QString)),this, SLOT(onShowStatusMessage(QString,QString)));
    connect(m_worker, SIGNAL(replaceLast(QString,QString)),this,SLOT(onReplaceLast(QString,QString)));
    connect(m_worker, SIGNAL(replaceLast(QStringList,QString)),this, SLOT(onReplaceLast(QStringList,QString)));
 }
@@ -118,6 +213,86 @@ void MainWindow::customEvent(QEvent *event) {
        } else {
            qCritical() << "!!! UNKNOWN SENDER !!!";
        }
+    } else
+    if (event->type() == UpdateDcEvent::type()) {
+        UpdateDcEvent *pevent = (UpdateDcEvent *)event;
+        UpdateDcEvent::UpdateStep const updateStep = pevent->updateStep();
+        QObject const *sender = pevent->sender();
+        if (sender == m_worker) {
+            QDateTime const &recv = QDateTime::currentDateTime();
+            QDateTime const &send = pevent->sendDateTime();
+            qint64 const delay = recv.toMSecsSinceEpoch() - send.toMSecsSinceEpoch();
+            switch(updateStep) {
+            case UpdateDcEvent::UpdateStep::NONE:
+                break;
+            case UpdateDcEvent::UpdateStep::DC_REBOOT: {
+                m_hw->bl_rebootDC();
+                QString msg = QDateTime::currentDateTime().toString(Qt::ISODateWithMs)
+                          + QString(": reset device controller (delay=%1ms").arg(delay);
+                emit m_worker->showStatusMessage("dc update", msg);
+                Utils::printInfoMsg(msg.toUpper());
+                m_updateStep = UpdateDcEvent::UpdateStep::DC_REBOOT;
+            } break;
+            case UpdateDcEvent::UpdateStep::BL_START: {
+                QString const &msg = recv.toString(Qt::ISODateWithMs)
+                    + QString(": start bootloader (%1, delay=%2ms)").arg(pevent->count()).arg(delay);
+                emit m_worker->showStatusMessage("dc update", msg);
+                Utils::printInfoMsg(msg.toUpper());
+                m_hw->bl_startBL();
+                if (pevent->count() == BL_START_COUNT) {
+                    m_updateStep = UpdateDcEvent::UpdateStep::BL_START;
+                }
+            } break;
+            case UpdateDcEvent::UpdateStep::BL_CHECK: {
+                if (m_updateStep != UpdateDcEvent::UpdateStep::BL_IS_UP) {
+                    QString const &msg = recv.toString(Qt::ISODateWithMs)
+                        + QString(": request bootloader version (%1, delay=%2ms)").arg(pevent->count()).arg(delay);
+                    emit m_worker->showStatusMessage("dc update", msg);
+                    Utils::printInfoMsg(msg.toUpper());
+                    m_hw->bl_checkBL();
+                    //m_updateStep = UpdateDcEvent::UpdateStep::BL_CHECK;
+                }
+            } break;
+            case UpdateDcEvent::UpdateStep::BL_IS_UP: {
+                QString msg = recv.toString(Qt::ISODateWithMs)
+                    + QString(": check running bootloader (%1, delay=%2ms)").arg(pevent->count()).arg(delay);
+                emit m_worker->showStatusMessage("dc update", msg);
+                Utils::printInfoMsg(msg.toUpper());
+                if (m_updateStep != UpdateDcEvent::UpdateStep::BL_IS_UP) {
+                    if (m_hw->bl_isUp()) {
+                        msg = recv.toString(Qt::ISODateWithMs)
+                            + QString(": bootloader running (%1, delay=%2ms)").arg(pevent->count()).arg(delay);
+                        emit m_worker->showStatusMessage("dc update", msg);
+                        Utils::printInfoMsg(msg.toUpper());
+                        m_updateStep = UpdateDcEvent::UpdateStep::BL_IS_UP;
+                    } else {
+                        msg = recv.toString(Qt::ISODateWithMs)
+                            + QString(": bootloader stop requested (%1, delay=%2ms)").arg(pevent->count()).arg(delay);
+                        emit m_worker->showStatusMessage("dc update", msg);
+                        Utils::printInfoMsg(msg.toUpper());
+                        if (m_updateStep == UpdateDcEvent::UpdateStep::BL_STOP) {
+                            msg = QDateTime::currentDateTime().toString(Qt::ISODateWithMs)
+                                    + QString(": bootloader down (%1, delay=%2ms)").arg(pevent->count()).arg(delay);
+                            emit m_worker->showStatusMessage("dc update", msg);
+                            Utils::printInfoMsg(msg.toUpper());
+                            m_updateStep = UpdateDcEvent::UpdateStep::BL_IS_DOWN;
+                        }
+                    }
+                }
+            } break;
+            case UpdateDcEvent::UpdateStep::BL_STOP: {
+                QString const &msg = QDateTime::currentDateTime().toString(Qt::ISODateWithMs)
+                    + QString(": stop bootloader (%1, delay=%2ms)").arg(pevent->count()).arg(delay);
+                emit m_worker->showStatusMessage("dc update", msg);
+                Utils::printInfoMsg(msg.toUpper());
+                //if (m_bootLoaderIsUp) {
+                m_hw->bl_stopBL();
+                m_updateStep = UpdateDcEvent::UpdateStep::BL_STOP;
+                //}
+            } break;
+            default: ;
+            }
+        }
    }

    QThread::yieldCurrentThread();
@@ -135,9 +310,19 @@ void MainWindow::onEnableExit() {
   ui->exit->setEnabled(true);
 }

+//bool MainWindow::eventFilter(QObject *obj, QEvent *ev) {
+//    if (obj == ui->updateStatus) {
+//        qCritical() << "REc. event for text edit" << ev->type();
+//    }
+//    return QMainWindow::eventFilter(obj, ev);
+//}
+
 void MainWindow::onRestartExitTimer() {
    m_exitTimer->stop();
    m_exitTimer->start(60 * 1000);
+
+    scrollDownTextEdit();
+    ui->updateStatus->setEnabled(false);
 }

 void MainWindow::onQuit() {
@@ -147,6 +332,9 @@ void MainWindow::onQuit() {
 }

 void MainWindow::scrollDownTextEdit() {
+    // Utils::printInfoMsg(QString("SCROLL-DOWN-TEXT_EDIT CALLED AT ")
+    //    + QDateTime::currentDateTime().toString(Qt::ISODateWithMs));
+
    ui->updateStatus->setEnabled(true);

    QTextCursor tmpCursor = ui->updateStatus->textCursor();
@@ -156,28 +344,44 @@ void MainWindow::scrollDownTextEdit() {
 }

 void MainWindow::onAppendText(QString text, QString suffix) {
+    // Utils::printInfoMsg(QString("ON APPEND CALLED AT ")
+    //    + QDateTime::currentDateTime().toString(Qt::ISODateWithMs));
+
    QString editText = ui->updateStatus->toPlainText();
+    scrollDownTextEdit();
+
    if (!suffix.isNull() && suffix.size() > 0) {
        //qInfo() << "TEXT" << text << "SUFFIX" << suffix;
        if (suffix == Worker::UPDATE_STEP_SUCCESS || suffix == Worker::UPDATE_STEP_FAIL) {
-            editText += QString("\n").leftJustified(m_width-3, '=');
-            editText += " ";
+            ui->updateStatus->insertPlainText(QString("\n").leftJustified(m_width-3, '=') + " ");
+            // editText += QString("\n").leftJustified(m_width-3, '=');
+            // editText += " ";
        }
-        editText += (QString("\n") + text).leftJustified(m_width - (2 + suffix.size()) ) + suffix;
+        QString const &add = (QString("\n") + text).leftJustified(m_width - (2 + suffix.size())) + suffix;
+        ui->updateStatus->insertPlainText(add);
+        // editText += add;
    } else {
-        editText += text.leftJustified(m_width-9);
+        QString const &add = text.leftJustified(m_width-9);
+        ui->updateStatus->insertPlainText(add);
+        //editText += add;
    }

-    Utils::printLineEditInfo(editText.split('\n'));
-    ui->updateStatus->setPlainText(editText.trimmed());
-    scrollDownTextEdit();
+    // debug
+    // QString editText = ui->updateStatus->toPlainText();
+    // Utils::printLineEditInfo(editText.split('\n', QString::SplitBehavior::SkipEmptyParts));
+    // ui->updateStatus->setText(editText.trimmed());
+
+    // scrollDownTextEdit();
 }

 void MainWindow::onReplaceLast(QStringList newTextLines, QString suffix) {
+    // Utils::printInfoMsg(QString("ON REPLACE LAST (LIST) CALLED AT ")
+    //    + QDateTime::currentDateTime().toString(Qt::ISODateWithMs));
+
    int const s = newTextLines.size();
    if (s > 0) {
        QString editText = ui->updateStatus->toPlainText();
-        QStringList lines = editText.split('\n');
+        QStringList lines = editText.split('\n', QString::SplitBehavior::SkipEmptyParts);
        QString newText;
        if (lines.size() >= s) {
            for (int i = 0; i < s; ++i) {
@@ -206,25 +410,41 @@ void MainWindow::onReplaceLast(QStringList newTextLines, QString suffix) {
 }

 void MainWindow::onReplaceLast(QString text, QString suffix) {
-        //qInfo() << "REPL TEXT" << text << "SUFFIX" << suffix;
+    // Utils::printInfoMsg(QString("ON REPLACE LAST (TEXT) CALLED AT ")
+    //    + QDateTime::currentDateTime().toString(Qt::ISODateWithMs));
+
    QString editText = ui->updateStatus->toPlainText();
-    QStringList lines = editText.split('\n');
+    QStringList lines = editText.split('\n', QString::SplitBehavior::SkipEmptyParts);
    if (lines.size() > 0) {
        lines.removeLast();
        if (!suffix.isNull() && suffix.size() > 0 && suffix != "\n") {
+            QString const add = text.leftJustified(m_width-10) + suffix;
+            if (!add.isEmpty()) {
                lines += text.leftJustified(m_width-10) + suffix;
+            }
        } else {
+            QString const add = text.leftJustified(m_width-10);
+            if (!add.isEmpty()) {
                lines += text.leftJustified(m_width-10);
            }
        }
+    }

    Utils::printLineEditInfo(lines);
    ui->updateStatus->setText(lines.join('\n').trimmed());
    scrollDownTextEdit();
 }

-void MainWindow::onShowErrorMessage(QString title, QString text) {
+void MainWindow::onShowMessage(QString title, QString text) {
    this->statusBar()->clearMessage();
    this->statusBar()->showMessage( // timeout: 10000
-        QString(title + ": " + text).leftJustified(80, ' '), 10000);
+        QString(title + " " + text).leftJustified(80, ' '), 10000);
+}
+
+void MainWindow::onShowErrorMessage(QString title, QString text) {
+    onShowMessage(title, text);
+}
+
+void MainWindow::onShowStatusMessage(QString title, QString text) {
+    onShowMessage(title, text);
 }
--- a/mainwindow.h
+++ b/mainwindow.h
@@ -10,44 +10,74 @@ namespace Ui { class MainWindow; }
 QT_END_NAMESPACE

 #include "worker.h"
+#include "update.h"
+#include "update_dc_event.h"

+#define EMERGENCY_LEAVE_BL 0
+
+class hwinf;
 class MainWindow : public QMainWindow {
    Q_OBJECT

 protected:
    void customEvent(QEvent *event) override;
+    // bool eventFilter(QObject *obj, QEvent *ev) override;

 public:
-    MainWindow(Worker *worker, QWidget *parent = nullptr);
+    MainWindow(hwinf *hw, Worker *worker, Update *update, QWidget *parent = nullptr);
    ~MainWindow();

    static const int START_PROGRESS_LOOP = -1;
    static const int STOP_PROGRESS_LOOP = -2;
+    static const int BL_START_COUNT = 5;
+    static const int BL_CHECK_COUNT = 5;
+    static const int BL_IS_UP_COUNT = 5;
+    static const int BL_STOP_COUNT = 5;

    int progressValue() const { return m_progressValue; }
+    hwinf *getPlugin() { return m_hw; }
+    hwinf const *getPlugin() const { return m_hw; }
+    Update *getUpdate() { return m_update; }
+    Update const *getUpdate() const { return m_update; }
+    UpdateDcEvent::UpdateStep updateStep() const { return m_updateStep; }
+    void setUpdateStep(UpdateDcEvent::UpdateStep updateStep) { m_updateStep = updateStep; }

 public slots:
    void onAppendText(QString, QString suffix = "");
    void onReplaceLast(QStringList, QString suffix = "");
    void onReplaceLast(QString, QString suffix = "");
    void onShowErrorMessage(QString, QString);
+    void onShowStatusMessage(QString, QString);
    void onStopStartTimer();
    void onRestartExitTimer();
    void onEnableExit();
    void onDisableExit();
+#if EMERGENCY_LEAVE_BL==1
+    void emergencyLeaveBL();
+#endif
+
+signals:
+
+#if EMERGENCY_LEAVE_BL==1
+    void leaveBL();
+#endif

 private slots:
    void onQuit();

 private:
    void scrollDownTextEdit();
+    void onShowMessage(QString, QString);

    Ui::MainWindow *ui;
+    hwinf *m_hw;
    Worker *m_worker;
-    int m_width;
+    int const m_width;
    QTimer *m_startTimer;
    QTimer *m_exitTimer;
    bool m_progressRunning;
    int m_progressValue;
+    Update *m_update;
+    UpdateDcEvent::UpdateStep m_updateStep;
 };
 #endif // MAINWINDOW_H
--- a/plugins/interfaces.h
+++ b/plugins/interfaces.h
@@ -193,7 +193,7 @@ struct T_moduleCondition
        uint8_t	coinChecker;		// EMP, OMP or mei-cashflow

        uint8_t	coinEscrow;
-        uint8_t	mifareReader;
+        uint8_t	mifareReader;       // 0: unknown  1=OK  200=no response  201=wrong response   202: Reader reports HW-error
        uint8_t	creditTerm;
        uint8_t	coinReject;

@@ -818,7 +818,7 @@ public:
 // --------------------------------------------- MIFARE -----------------------------------------------------
 // ----------------------------------------------------------------------------------------------------------

-
+// obsolete
    virtual uint8_t mif_returnReaderStateAndCardType(uint8_t *buf, uint8_t maxBufferSize) const =0;
        // retval 0=OK 1=error host buffer too small
    /* data description, new fast version:
@@ -840,13 +840,16 @@ public:
    virtual bool mif_readerIsOK(void) const =0;

    virtual bool mif_cardAttached(void) const =0;
+        // not working! use mif_cardIsAttached() instead

    virtual uint8_t mif_readResult(void) const =0;
        // result: 0: unknown or still in progress
        //         1: card read successful
        //         2: reading error
+        // not working!

    virtual QString mif_cardUID(void) const =0;
+        // not working

    virtual uint8_t mif_getCardDataDec(uint8_t blkNr, uint8_t *buf, uint8_t maxBufferSize) const =0;

@@ -1289,7 +1292,7 @@ public:
        // 1= wrong length    2=wrong start sign           5= wrong crc
        // 6= slave: master cmd was wrong       7: slave: could not write/read data
        // 8=timeout, got no response from slave
-
+        // 0,8 work, 1..6 not yet tested. 8 comes immed. and stays 8 until reconnect

    // use for important and extended commands (print several templates, print ticket...)
    virtual void log_startSupervision(void) const =0;
@@ -1299,6 +1302,7 @@ public:
        // 0: started, in progress
        // 1: done and OK
        // 2: done and error
+        // not working properly, always 0

    virtual bool log_getVaultData(uint8_t *data) const =0;
        // get vault record in linear 8bit buffer with 384 byte
@@ -1343,6 +1347,37 @@ public:



+    // new functions from 8.9.23
+    virtual QString mif_getReaderType(void) const =0;
+        // return "SL025" if correct reader is connected
+
+    virtual void mif_getCardSize(uint8_t *cardSize, uint8_t *idLeng) const =0;
+        // cardSize=1k or 4kByte
+        // idLeng =4Byte or 7 byte
+
+    virtual char mif_getAtbCardData(uint8_t *buf, uint8_t maxBuffSiz) const =0;
+        // return complete buffer binary, just for test purpose
+
+    virtual bool mif_isValidAtbCard(void) const =0;
+
+    virtual uint32_t mif_getAtbCardCuNu(void) const =0;
+
+    virtual uint8_t mif_getAtbCardTyp(void) const =0;
+        // return 1=upper door card     1=lower door    3=printer-test   4=coin-test
+        //          0: not a valid atb2020 card
+
+    virtual QString mif_getAtbCardPerso(void) const =0;
+        // e.g. "PNsax001" used for personal number, name shortcode, card number
+        // free to use, can be set in AtbMcw23.exe tool
+
+    virtual void mif_getAtbCardExpire(uint8_t *year, uint8_t *month, uint8_t *day, uint8_t *hour, uint8_t *minute) const =0;
+
+
+
+
+
+
+
 signals:
    virtual void hwapi_templatePrintFinished_OK(void) const=0;
    virtual void hwapi_templatePrintFinished_Err(void) const=0;
@@ -1413,9 +1448,15 @@ signals:
 //#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/4.1"
 //#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/4.2"
 //#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/4.3"
-#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/4.4"
-
+//#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/4.4"
+    // 8.9.2023 two new functions (end of file) for mifare test
+//#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/4.5"
+    // 18.9.2023 major improvements for DC data exchange
+    // verification of door and cash box signals
+    // intensive verification of Json-Programming Master-Slave (PTU to DC), 100% ok

+#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/4.6"
+    // 20.9.2023: speeding up door and cash box signals


 Q_DECLARE_INTERFACE(hwinf, HWINF_iid)
--- a/plugins/libCAmaster.so
+++ b/plugins/libCAmaster.so
--- a/process/command.cpp
+++ b/process/command.cpp
@@ -69,7 +69,14 @@ bool Command::execute(QString workingDirectory, QStringList args) {
        qDebug() << "PROCESS" << m_command << "STARTED IN" << p->workingDirectory();
        if (p->state() == QProcess::ProcessState::Running) {
            qDebug() << "PROCESS" << m_command << "RUNNING IN" << p->workingDirectory();
-            if (p->waitForFinished(m_waitForFinishTimeout)) {
+            // wait forever for git/opkg-commands to finish
+            int wait = m_waitForFinishTimeout;
+            if (m_command.trimmed().startsWith("git", Qt::CaseInsensitive) ||
+                m_command.trimmed().startsWith("opkg", Qt::CaseInsensitive)) {
+                wait = -1;
+            }
+            bool const no_timeout = p->waitForFinished(wait);
+            if (no_timeout) {
                qDebug() << "PROCESS" << m_command << "FINISHED IN" << p->workingDirectory();
                if (p->exitStatus() == QProcess::NormalExit) {
                    if ((m_exitCode = p->exitCode()) == 0) {
@@ -89,8 +96,8 @@ bool Command::execute(QString workingDirectory, QStringList args) {
                }
            } else {
                qCritical() << "PROCESS" << m_command
-                            << "DID NOT FINISH"
-                            << "IN" << p->workingDirectory();
+                            << "DID NOT FINISH WITH" << wait
+                            << "MS IN" << p->workingDirectory();
            }
        } else {
            qCritical() << "WRONG PROCESS STATE" << p->state()
--- a/update.cpp
+++ b/update.cpp
@@ -1,5 +1,8 @@
 #include "update.h"
 #include "worker.h"
+#include "utils.h"
+#include "update_dc_event.h"
+#include "mainwindow.h"

 #include <QCoreApplication>
 #include <QApplication>
@@ -9,10 +12,11 @@
 #include <QTextStream>
 #include <QRegularExpression>
 #include <QRegExp>
+#include <QApplication>

-//#include <iostream>
-//#include <fstream>
-//#include <ctime>
+#if defined (Q_OS_UNIX) || defined (Q_OS_LINUX)
+#include "unistd.h"
+#endif

 #include "plugins/interfaces.h"

@@ -25,17 +29,15 @@
 #include <QMap>

 #define UPDATE_OPKG                 (1)
-#define UPDATE_DC                   (1)
-#define UPDATE_PRINTER_TEMPLATES    (1)
-#define UPDATE_CASH_TEMPLATE        (1)
-#define UPDATE_CONF_TEMPLATE        (1)
-#define UPDATE_DEVICE_TEMPLATE      (1)
+#define UPDATE_DC                   (0)

 static const QMap<QString, int> baudrateMap = {
  {"1200"   ,   0}, {"9600"   ,   1}, {"19200"  ,   2}, {"38400"  ,   3},
  {"57600"  ,   4}, {"115200" ,   5}
 };

+QPluginLoader Update::pluginLoader;
+
 hwinf *Update::loadDCPlugin(QDir const &plugInDir, QString const &fname) {
    hwinf *hw = nullptr;
    if (plugInDir.exists()) {
@@ -44,7 +46,8 @@ hwinf *Update::loadDCPlugin(QDir const &plugInDir, QString const &fname) {
        QFileInfo info(pluginLibName);
        if (info.exists()) {
            pluginLibName = plugInDir.absoluteFilePath(pluginLibName);
-            static QPluginLoader pluginLoader(pluginLibName);
+            pluginLoader.setFileName(pluginLibName);
+            // static QPluginLoader pluginLoader(pluginLibName);
            if (!pluginLoader.load()) {
                qCritical() << "in directory" << plugInDir.absolutePath();
                qCritical() << "cannot load plugin" << pluginLoader.fileName();
@@ -76,11 +79,27 @@ hwinf *Update::loadDCPlugin(QDir const &plugInDir, QString const &fname) {
    return hw;
 }

+bool Update::unloadDCPlugin() {
+    if (pluginLoader.unload()) {
+        qCritical() << "unloaded plugin" << pluginLoader.fileName();
+        // Note: will re-instantiate the library !
+        // QObject *rootObject = pluginLoader.instance();
+        // if (rootObject) {
+        //    qCritical() << "reloaded plugin: root object again available";
+        //    return false;
+        // }
+        // qCritical()unloaded plugin: root object gone";
+        return true;
+    }
+    return false;
+}
+
 Update::Update(hwinf *hw,
               Worker *worker,
               QString customerRepository,
               QString customerNrStr,
               QString branchName,
+               QString pluginName,
               QString workingDir,
               bool dryRun,
               QObject *parent,
@@ -94,8 +113,17 @@ Update::Update(hwinf *hw,
    , m_customerRepository(customerRepository)
    , m_customerNrStr(customerNrStr)
    , m_branchName(branchName)
+    , m_pluginName(pluginName)
    , m_workingDir(workingDir)
    , m_dryRun(dryRun) {
+
+    qInfo() << "UPDATE: m_serialInterface    ..." << m_serialInterface;
+    qInfo() << "UPDATE: m_baudrate           ..." << m_baudrate;
+    qInfo() << "UPDATE: m_customerRepository ..." << m_customerRepository;
+    qInfo() << "UPDATE: m_customerNr ..........." << m_customerNrStr;
+    qInfo() << "UPDATE: m_branchName ..........." << m_branchName;
+    qInfo() << "UPDATE: m_pluginName ..........." << m_pluginName;
+    qInfo() << "UPDATE: m_workingDirectory ....." << m_workingDir;
 }

 Update::~Update() {
@@ -221,48 +249,99 @@ Update::DownloadResult Update::dc_downloadBinary(QByteArray const &b) const {
    return res;
 }

-bool Update::startBootloader() const {
-    qDebug() << "starting bootloader...";
-    int nTry = 5;
-    while (--nTry >= 0) {
+bool Update::startBootloader() const { // deprecated
+    return false;
+#if 0
+    int nStartTry = 5;
+    while (--nStartTry >= 0) {
        m_hw->bl_startBL();
-        QThread::msleep(5000);
+        QThread::msleep(500);
+        int nCheckTry = 10;
+        while (--nCheckTry >= 0) {
            m_hw->bl_checkBL();
+            QThread::msleep(500);
            if (m_hw->bl_isUp()) {
                qInfo() << "starting bootloader...OK";
-            QThread::msleep(5000);
                return true;
            } else {
-            qCritical() << "bootloader not up (" << nTry << ")";
+                qCritical() << "bootloader not up ("
+                            << nStartTry << "," << nCheckTry << ")" << QThread::currentThread();
            }
        }
-    qCritical() << "starting bootloader...FAILED";
+    }
+    qCritical() << "starting bootloader...FAILED" << QThread::currentThread();
    return false;
+#endif
 }

 bool Update::stopBootloader() const {
-    qDebug() << "stopping bootloader...";
-    int nTry = 5;
-    while (--nTry >= 0) {
-        m_hw->bl_stopBL();
+    // stop bootloader: this MUST work -> otherwise the PSA has to be restarted
+    // manually
+    emit m_worker->showErrorMessage("dc update", "stopping bootloader...");
+
+    int nTryFinalize = 1; // could do this in an endless loop
+
+    do {
+        // in principle, any value except BL_STOP will do, as we want to detect
+        // change to BL_STOP
+        m_worker->mainWindow()->setUpdateStep(UpdateDcEvent::UpdateStep::BL_CHECK);
+
+        QApplication::postEvent(
+            m_worker->mainWindow(),
+            new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::BL_STOP, nTryFinalize));
+
+        QThread::sleep(1);
+
+        int const cntLimit = 20;
+        int cnt = 0;
+        while (++cnt < cntLimit &&
+            m_worker->mainWindow()->updateStep() != UpdateDcEvent::UpdateStep::BL_STOP) {
+            // wait until bl_stopBL() has been sent
            QThread::msleep(500);
-        if (!m_hw->bl_isUp()) {
-            qInfo() << "stopping bootloader...OK";
-            return true;
        }
+
+        QApplication::postEvent(
+            m_worker->mainWindow(),
+            new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::BL_CHECK, nTryFinalize));
+        QThread::sleep(1);
+
+        QApplication::postEvent(
+            m_worker->mainWindow(),
+            new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::BL_IS_UP, nTryFinalize));
+        QThread::sleep(1);
+
+        cnt = 0;
+        while (++cnt < cntLimit &&
+            m_worker->mainWindow()->updateStep() != UpdateDcEvent::UpdateStep::BL_IS_DOWN) {
+            // wait until  done
+            QThread::msleep(200);
        }
-    qCritical() << "stopping bootloader...FAILED";
-    return false;
+
+    } while (++nTryFinalize <= MainWindow::BL_STOP_COUNT &&
+             m_worker->mainWindow()->updateStep() != UpdateDcEvent::UpdateStep::BL_IS_DOWN);
+
+    return (m_worker->mainWindow()->updateStep() == UpdateDcEvent::UpdateStep::BL_IS_DOWN);
 }

 // br is a index into a table, used for historical reasons.
 bool Update::openSerial(int br, QString baudrate, QString comPort) const {
    qDebug() << "opening serial" << br << baudrate << comPort << "...";
-    if (m_hw->dc_openSerial(br, baudrate, comPort, 1)) { // 1 for connect
-        qInfo() << "opening serial" << br << baudrate << comPort << "...OK";
+    if (m_hw->dc_openSerial(br, baudrate, comPort, 1) == true) { // 1 for connect
+        Utils::printInfoMsg(
+            QString("OPENING SERIAL %1").arg(br)
+                  + " " + baudrate + " " + comPort + "...OK");
+
+        // m_hw->dc_autoRequest(true);
+        m_hw->dc_autoRequest(false);
+        QThread::sleep(1);
+
+        Utils::printInfoMsg(QString("IS PORT OPEN %1").arg(m_hw->dc_isPortOpen()));
        return true;
    }
-    qCritical() << "opening serial" << br << baudrate << comPort << "...FAILED";
+
+    Utils::printCriticalErrorMsg(
+        QString("OPENING SERIAL %1").arg(br)
+              + " " + baudrate + " " + comPort + "...FAILED");
    return false;
 }

@@ -275,13 +354,15 @@ bool Update::isSerialOpen() const {
    return m_hw->dc_isPortOpen();
 }

-bool Update::resetDeviceController() const {
+bool Update::resetDeviceController() const { // deprecated
+    return false;
+#if 0
    qDebug() << "resetting device controller...";
    m_hw->bl_rebootDC();
    // wait maximally 3 seconds, before starting bootloader
-    QThread::sleep(1);
    qInfo() << "resetting device controller...OK";
    return true;
+#endif
 }

 QByteArray Update::loadBinaryDCFile(QString filename) const {
@@ -319,17 +400,61 @@ bool Update::downloadBinaryToDC(QString const &bFile) const {
 }

 /*
- Using the DC bootloader:
- 1  :   bl_reboot()      // send to application, want DC2 to reset (in order to start
-                        // the bootloader)
- 2  :   bl_startBL():   // send within 4s after DC poewer-on, otherwise bl is left
- 3  :   bl_check():     // send command to verify if bl is up
- 4  :   bl_isUp():      // returns true if bl is up and running

+ ///////////////////////////////////////////////////////////////////////////////
+ //
+ //                        USING THE DC BOOTLOADER
+ //
+ ///////////////////////////////////////////////////////////////////////////////
+
+ 1  :   bl_reboot()     // send to application, want DC2 to reset (in order to
+                        // start the bootloader)
+                        //
+                        // NOTE: this function is NOT reliable !!! Sometimes it
+                        // simply does not work, in which case bl_startBL,
+                        // bl_checkBL and bl_isUp do not work as well.
+                        // Alas, there is no feedback if bl_reboot worked!
+                        //
+                        // NOTE: this function can be called only once per
+                        // minute, because once called again, the controller
+                        // performs some self-checks consuming some time.
+                        //
+                        // NOTE: after a successful bl_reboot(), the device is
+                        // waiting about 4 seconds in the bootloader. To stay in
+                        // the bootloader, we have to send the command
+                        // bl_startBL(), which is kind of a misnomer, as it
+                        // should be bl_doNotLeaveBL().
+                        //
+ 2  :   bl_startBL():   // send within 4s after DC power-on, otherwise
+                        // bootloader is left.
+                        //
+                        // NOTE: a running bootloader is a MUST for the download
+                        // process of a device controller firmware as it does
+                        // the actual writing of the memory (the bl_reboot()
+                        // from above erases the available memory).
+                        //
+ 3  :   bl_check():     // send command to verify if bl is up
+                        //
+                        // NOTE: this command is kind of a request that we want
+                        // to check if the bootloader is up. The device
+                        // (actually the bootloader) responds with its version.
+                        //
+ 4  :   bl_isUp():      // returns true if bl is up and running
+                        //
+                        // NOTE: we know what the bootloader version actually is
+                        // as the bootloader does not change. By comparing the
+                        // string received in the previous step with this known
+                        // version string we know if the bootloader is up.
+                        //
+                        // NOTE FOR ALL PREVIOUS STEPS: execute them in their
+                        // own slots each to be sure to receive any possible
+                        // responds from the device.
+                        //
 5  :   bl_sendAddress(blockNumber)
                        // send start address, nr of 64-byte block, start with 0
                        // will be sent only for following block-numbers:
-                        // 0, 1024, 2048, 3072 and 4096, so basically every 64kByte
+                        // 0, 1024, 2048, 3072 and 4096, so basically every
+                        // 64kByte.
                        // for other addresses nothing happens

 6  :   bl_wasSendingAddOK()
@@ -349,54 +474,119 @@ bool Update::downloadBinaryToDC(QString const &bFile) const {
                        //             10: OK

 10 :   bl_stopBL()     // leave bl and start (the new) application
+                        //
+                        // NOTE: this function MUST work under all conditions.
+                        // Alas, there is no direct result for this command, so
+                        // the only way of knowing it was successful is to ask
+                        // the device if the bootloader is still running.
+                        // There is no problem to repeat this command until the
+                        // bootloader is really not running anymore.
 */
 bool Update::updateBinary(char const *fileToSendToDC) {
-    qInfo() << "UPDATING DEVICE CONTROLLER BINARY" << fileToSendToDC;
+    qInfo() << "UPDATING DEVICE CONTROLLER FIRMWARE BINARY" << fileToSendToDC;
    QFile fn(fileToSendToDC);
    bool r;
    if ((r = fn.exists()) == true) {
        QFileInfo fi(fn);
-        qInfo() << "      UPDATING BINARY" << fi.fileName() << "(size=" << fi.size() << ")";
        if ((r = updateDC(fileToSendToDC)) == true) {
-            qCritical() << QString(80, '*');
-            qInfo() << "      UPDATING BINARY" << fi.fileName() << "(size=" << fi.size() << ") DONE";
-            qCritical() << QString(80, '*');
+            Utils::printInfoMsg(
+                QString("      UPDATING BINARY ") + fi.fileName()
+                      + QString(" (size=%1").arg(fi.size()) + ") DONE");
        } else {
-            qCritical() << QString(80, '*');
-            qCritical() << "      UPDATING BINARY" << fi.fileName() << "(size=" << fi.size() << ") FAILED";
-            qCritical() << QString(80, '*');
+            Utils::printCriticalErrorMsg(
+                QString("      UPDATING BINARY ") + fi.fileName()
+                      + QString(" (size=%1").arg(fi.size()) + ") FAILED");
        }
    } else {
-        qCritical() << QString(80, '*');
-        qCritical() << fileToSendToDC << "does not exist -> NO UPDATE OF DC FIRMWARE";
-        qCritical() << QString(80, '*');
+        Utils::printCriticalErrorMsg(
+            QString(fileToSendToDC) + " DOES NOT EXIST -> NO UPDATE OF DC FIRMWARE");
    }
    return r;
 }

 bool Update::updateDC(QString bFile) const {
-    qDebug() << "updating dc...";
-    qDebug() << "updating dc: file to send" << bFile;
-    if (!resetDeviceController()) {
-        return false;
+    qDebug() << "IN UPDATEDC: UPDATING DC: FILE TO SEND" << bFile;
+
+    m_worker->mainWindow()->setUpdateStep(UpdateDcEvent::UpdateStep::NONE);
+
+    QApplication::postEvent(            // step 1: reset device controller
+        m_worker->mainWindow(),
+        new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::DC_REBOOT, 1));
+    QThread::sleep(1);
+
+    for (int i=1; i <= MainWindow::BL_START_COUNT; ++i) {
+        QApplication::postEvent(        // step 2: start bootloader (5x)
+            m_worker->mainWindow(),
+            new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::BL_START, i));
+        QThread::sleep(1);
    }
-    if (!startBootloader()) {
-        // even when start seems to fail, stopping the boot loader does not harm
-        stopBootloader();
+
+    int const cntLimit = 100;       // wait until its for sure that bl_startBL()
+    int cnt = 0;                    // has been excuted
+    while (++cnt < cntLimit &&
+        m_worker->mainWindow()->updateStep() != UpdateDcEvent::UpdateStep::BL_START) {
+        // wait until all bl_startBL() are done
+        QThread::msleep(200);
+    }
+
+    if (cnt == cntLimit) {
+        // start events not received ???
+        Utils::printCriticalErrorMsg("BL_START EVENT NOT RECEIVED AFTER 20 SECS");
        return false;
    }

+    m_worker->mainWindow()->setUpdateStep(UpdateDcEvent::UpdateStep::BL_CHECK);
+
+    for (int i=1; i <= MainWindow::BL_IS_UP_COUNT; ++i) {
+        QApplication::postEvent(m_worker->mainWindow(), new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::BL_CHECK, i));
+        QThread::sleep(1);
+        QApplication::postEvent(m_worker->mainWindow(), new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::BL_IS_UP, i));
+        if (m_worker->mainWindow()->updateStep() == UpdateDcEvent::UpdateStep::BL_IS_UP) {
+            break;
+        }
+        QThread::sleep(1);
+    }
+
+    cnt = 0;
+    while (++cnt < cntLimit &&
+        m_worker->mainWindow()->updateStep() != UpdateDcEvent::UpdateStep::BL_IS_UP) {
+        // wait until all bl_startBL() are done
+        QThread::msleep(200);
+    }
+
+    if (cnt == cntLimit) {
+        // really not up
+        Utils::printCriticalErrorMsg("BL_IS_UP EVENT NOT RECEIVED AFTER 20 SECS");
+        stopBootloader(); // try to stop bootloader whichhas been already started
+        return false;
+    }
+
+    if (m_worker->mainWindow()->updateStep() == UpdateDcEvent::UpdateStep::BL_IS_UP) {
+        // bootloader MUST be running to download device-controller
+#if 0
        if (!downloadBinaryToDC(bFile)) {
-        stopBootloader();
-        qCritical() << "updating dc: " << bFile << "...FAILED";
+            Utils::printCriticalErrorMsg(
+                QString("UPDATING DC: ") + bFile + " ...DOWNLOAD FAILED");
+        }
+#endif
+
+    } else {
+        Utils::printCriticalErrorMsg(
+            QString("UPDATING DC: ") + bFile + " BOOT LOADER NOT RUNNING -> NO DOWNLOAD ("
+                  + QThread::currentThread()->objectName() + ")");
        return false;
    }
-    qInfo() << "updating dc: " << bFile << "...OK";

-    stopBootloader();
-    //resetDeviceController();
+    // do this unconditionally, even if bootloader is not running at all ->
+    // the controller possibly tells us nonsense.
+    if (!stopBootloader()) {
+        Utils::printCriticalErrorMsg(
+            QString("UPDATING DC: ") + bFile + " BOOT LOADER STILL RUNNING ("
+                  + QThread::currentThread()->objectName() + ")");
+        return false;
+    }

-    QThread::sleep(3);
+    Utils::printInfoMsg(QString("UPDATING DC: ") + bFile + " ...OK");
    return true;
 }

@@ -416,9 +606,12 @@ bool Update::downloadJson(enum FileTypeJson type,
                          int templateIdx,
                          QString jsFileToSendToDC) const {

-    qDebug() << "updating json-file:" << jsFileToSendToDC << "...";
-    qDebug() << "    template-index:" << templateIdx;
-    qDebug() << "         json-type:" << jsonType(type);
+
+    Utils::printInfoMsg(
+        QString("UPDATING JSON-FILE=%1, TEMPLATE-INDEX=%2, JSON-TYPE=%3")
+            .arg(jsFileToSendToDC)
+            .arg(templateIdx)
+            .arg(jsonType(type)));

    m_hw->dc_autoRequest(true); // downloading Json needs the AutoEmission flag
    qDebug() << "SET AUTO-REQUEST=TRUE";
@@ -429,7 +622,7 @@ bool Update::downloadJson(enum FileTypeJson type,
    while ((ready = m_hw->sys_ready4sending()) == false) {
        QThread::msleep(200);
        if (--nTry <= 0) {
-            qCritical() << "SYS NOT READY FOR SENDING AFTER 5 SECONDS";
+            Utils::printCriticalErrorMsg("SYS NOT READY FOR SENDING AFTER 5 SECONDS");
            break;
        }
    }
@@ -442,22 +635,27 @@ bool Update::downloadJson(enum FileTypeJson type,
            if (file.open(QIODevice::ReadOnly)) {
                if (fi.size() <= 800) {
                    QByteArray ba = file.readAll();
+                    // kindOfFile: 1=config, 2=device, 3=cash, 4=serial, 5=time, 6=printer
+                    //      nrOfTemplate=1...32 if kindOfFile==6
+                    //      content = content of the Json file, max 800byte ascii signs
                    if (m_hw->sys_sendJsonFileToDc((uint8_t)(type),
                                                   templateIdx,
                                                   (uint8_t *)ba.data())) {
                        QThread::sleep(1);
-                        qDebug() << "SENT" << jsFileToSendToDC;
                        ret = true;
                    }
                } else {
-                    qCritical() << "SIZE OF" << jsFileToSendToDC
-                                << "TOO BIG (" << fi.size() << "BYTES)";
+                    Utils::printCriticalErrorMsg(
+                        QString("SIZE OF %1 TOO BIG (%2 BYTES)")
+                            .arg(jsFileToSendToDC).arg(fi.size()));
                }
            } else {
-                qCritical() << "CANNOT OPEN" << jsFileToSendToDC << "FOR READING";
+                Utils::printCriticalErrorMsg(
+                    QString("CAN NOT OPEN ") + jsFileToSendToDC + " FOR READING");
            }
        } else {
-            qCritical() << jsFileToSendToDC << "DOES NOT EXIST";
+            Utils::printCriticalErrorMsg(
+                QString(jsFileToSendToDC) + " DOES NOT EXIST");
        }
    }

@@ -518,40 +716,9 @@ void Update::finished(int /*exitCode*/, QProcess::ExitStatus /*exitStatus*/) {
    disconnect(p, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(readyReadStandardError()));
 }

-bool Update::doUpdate(int &displayIndex, QStringList const &filesToWorkOn) {
-    //
-    // ACHTUNG !!!
-    //
-    return true;
-
-    bool serialOpened = false;
-    bool serialOpen = false;
-
-    if (!serialOpen) {
-        if (!isSerialOpen()) { // open serial only if not already open
-            if ((serialOpened = openSerial(baudrateMap.value(m_baudrate), m_baudrate, m_serialInterface)) == false) {
-                qCritical() << "CANNOT OPEN" << m_serialInterface << "(BAUDRATE="
-                            << m_baudrate << ")";
-                return false;
-            }
-        }
-        serialOpen = true;
-        qInfo() << "SERIAL OPEN" << m_serialInterface << "(BAUDRATE=" << m_baudrate << ")";
-    }
-
-    bool res = false;
-    QList<QString>::const_iterator it;
-    for (it = filesToWorkOn.cbegin(); it != filesToWorkOn.cend(); ++it) {
-        m_worker->startProgressLoop();
-        QString fToWorkOn = (*it).trimmed();
-        fToWorkOn = QDir::cleanPath(m_customerRepository + QDir::separator() + fToWorkOn);
-
-        static const QRegularExpression version("^.*dc2c[.][0-9][0-9][.][0-9][0-9][.]bin.*$");
-        if (fToWorkOn.contains(version)) {
-
-            qInfo() << QString(80, '*');
-            qInfo() << "DO-UPDATE FILE-TO-WORK-ON" << fToWorkOn;
-            qInfo() << QString(80, '*');
+QStringList Update::getDcSoftAndHardWareVersion() {
+    m_hw->dc_autoRequest(true);
+    QThread::sleep(1); // make sure the timer-slots are active

    for (int i=0; i < 3; ++i) { // send explicit reuests to get
                                // current SW/HW-versions
@@ -560,36 +727,48 @@ bool Update::doUpdate(int &displayIndex, QStringList const &filesToWorkOn) {
        QThread::sleep(1);
    }

-            QString const hwVersion = m_hw->dc_getHWversion().toLower();
-            QString const fwVersion = m_hw->dc_getSWversion().toLower();
+    QString const &hwVersion = m_hw->dc_getHWversion().toLower().trimmed();
+    QString const &swVersion = m_hw->dc_getSWversion().toLower().trimmed();

-            qInfo() << "current dc-hardware-version" << hwVersion;
-            qInfo() << "current dc-firmware-version" << fwVersion;
+    m_hw->dc_autoRequest(false);
+    QThread::sleep(1); // make sure the timer-slots are inactive
+
+    if (!hwVersion.isEmpty() && !swVersion.isEmpty()) {
+        return QStringList() << hwVersion << swVersion;
+    }
+
+    return QStringList() << "DC HW-version not available"
+                         << "DC SW-version not available";
+}
+
+bool Update::doUpdate(int &displayIndex, QStringList const &filesToWorkOn) {
+    // always assume that serial line is open
+    bool res = false;
+    QList<QString>::const_iterator it;
+    for (it = filesToWorkOn.cbegin(); it != filesToWorkOn.cend(); ++it) {
+        m_worker->startProgressLoop();
+        QString const &fToWorkOn = QDir::cleanPath(m_customerRepository + QDir::separator() + it->trimmed());
+#if UPDATE_DC == 1
+        static const QRegularExpression version("^.*dc2c[.][0-9]{1,2}[.][0-9]{1,2}[.]bin.*$");
+        if (fToWorkOn.contains(version)) {
+            Utils::printInfoMsg("DO-UPDATE FILE-TO-WORK-ON " + fToWorkOn);

            QFile fn(fToWorkOn);
            QFileInfo finfo(fn);
            if (!fn.exists()) { // check for broken link
-                qCritical() << QString(80, '*');
-                qCritical() << "FILE-TO-WORK-ON" << fn << "DOES NOT EXIST";
-                qCritical() << QString(80, '*');
+                Utils::printCriticalErrorMsg("DO-UPDATE FILE-TO-WORK-ON "
+                    + fToWorkOn + " DOES NOT EXIST");
                res = false;
            } else {
-                if (false) {
-                //if (fwVersion.startsWith(linkTarget.completeBaseName())) {
-                //    qCritical() << "current dc-firmware-version" << fwVersion
-                //                << "already installed";
-                //    res = false;
-                } else {
-                    res = true;
+                bool updateBinaryRes = true;

                qInfo() << "DOWNLOADING" << finfo.completeBaseName() << "TO DC";
-#if UPDATE_DC == 1
                m_hw->dc_autoRequest(false);// default: turn auto-request setting off
                QThread::sleep(1);          // wait to be sure that there are no more
                                            // commands sent to dc-hardware
                qInfo() << "SET AUTO-REQUEST=FALSE";

-                    if ((res = updateBinary(fToWorkOn.toStdString().c_str())) == true) {
+                if ((updateBinaryRes = updateBinary(fToWorkOn.toStdString().c_str())) == true) {
                    qCritical() << "downloaded binary" << fToWorkOn;
                    ++displayIndex;
                    emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(2, ' ') + QString(")")
@@ -599,19 +778,23 @@ bool Update::doUpdate(int &displayIndex, QStringList const &filesToWorkOn) {

                m_hw->dc_autoRequest(true); // turn auto-request setting on
                qInfo() << "SET AUTO-REQUEST=TRUE";
-                    qInfo() << "WAIT 10 SECS TO RECEIVE RESPONSES...";

-                    QThread::sleep(10); // wait to be sure that responses
-                                        // have been received
-                    qInfo() << "updated dc-hardware-version" << m_hw->dc_getHWversion();
-                    qInfo() << "updated dc-firmware-version" << m_hw->dc_getSWversion();
+                QStringList const &versions = Update::getDcSoftAndHardWareVersion();
+                if (versions.size() >= 2) {
+                    if (updateBinaryRes == true) {
+                        qInfo() << "dc-hardware-version (UPDATED)" << versions[0];
+                        qInfo() << "dc-firmware-version (UPDATED)" << versions[1];
+                    } else {
+                        qInfo() << "dc-hardware-version (NOT UPDATED)" << versions[0];
+                        qInfo() << "dc-firmware-version (NOT UPDATED)" << versions[1];
+                    }
+                }
+                res = updateBinaryRes;
+            }
 #endif
-                }
-            }
-        } else if (fToWorkOn.contains("DC2C_print", Qt::CaseInsensitive)
+        if (fToWorkOn.contains("DC2C_print", Qt::CaseInsensitive)
         && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
            res = true;
-#if UPDATE_PRINTER_TEMPLATES == 1
            int i = fToWorkOn.indexOf("DC2C_print", Qt::CaseInsensitive);
            int const templateIdx = fToWorkOn.mid(i).midRef(10, 2).toInt();
            if ((templateIdx < 1) || (templateIdx > 32)) {
@@ -619,50 +802,46 @@ bool Update::doUpdate(int &displayIndex, QStringList const &filesToWorkOn) {
                res = false;
            } else {
                if ((res = updatePrinterTemplate(templateIdx, fToWorkOn))) {
-                    qInfo() << "downloaded printer template"<< fToWorkOn;
+                    Utils::printInfoMsg(
+                        QString("DOWNLOADED PRINTER TEMPLATE %1 WITH INDEX=%2")
+                            .arg(fToWorkOn)
+                            .arg(templateIdx));
                    ++displayIndex;
-                    emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(2, ' ') + QString(")")
+                    emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(3, ' ') + QString(")")
                          + QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
                            Worker::UPDATE_STEP_DONE);
                }
            }
-#endif
        } else if (fToWorkOn.contains("DC2C_cash", Qt::CaseInsensitive)
                && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
            res = true;
-#if UPDATE_CASH_TEMPLATE == 1
            if ((res = updateCashConf(fToWorkOn))) {
-                qInfo() << "downloaded cash template"<< fToWorkOn;
+                Utils::printInfoMsg(QString("DOWNLOADED CASH TEMPLATE %1").arg(fToWorkOn));
                ++displayIndex;
-                emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(2, ' ') + QString(")")
+                emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(3, ' ') + QString(")")
                      + QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
                        Worker::UPDATE_STEP_DONE);
            }
-#endif
        } else if (fToWorkOn.contains("DC2C_conf", Qt::CaseInsensitive)
                && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
            res = true;
-#if UPDATE_CONF_TEMPLATE == 1
            if ((res= updateConfig(fToWorkOn))) {
-                qInfo() << "downloaded config template"<< fToWorkOn;
+                Utils::printInfoMsg(QString("DOWNLOADED CONFIG TEMPLATE %1").arg(fToWorkOn));
                ++displayIndex;
-                emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(2, ' ') + QString(")")
+                emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(3, ' ') + QString(")")
                      + QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
                        Worker::UPDATE_STEP_DONE);
            }
-#endif
        } else if (fToWorkOn.contains("DC2C_device", Qt::CaseInsensitive)
                && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
            res = true;
-#if UPDATE_DEVICE_TEMPLATE == 1
            if ((res = updateDeviceConf(fToWorkOn))) {
-                qInfo() << "downloaded device template"<< fToWorkOn;
+                Utils::printInfoMsg(QString("DOWNLOADED DEVICE TEMPLATE %1").arg(fToWorkOn));
                ++displayIndex;
-                emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(2, ' ') + QString(")")
+                emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(3, ' ') + QString(")")
                      + QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
                        Worker::UPDATE_STEP_DONE);
            }
-#endif
        } else {
            qCritical() << "UNKNOWN JSON FILE NAME" << fToWorkOn;
            res = false;
--- a/update.h
+++ b/update.h
@@ -7,6 +7,7 @@
 #include <QDir>
 #include <QByteArray>
 #include <QProcess>
+#include <QPluginLoader>

 #include "plugins/interfaces.h"

@@ -27,15 +28,19 @@ class Update : public QObject {
    QString m_customerRepository;
    QString m_customerNrStr;
    QString m_branchName;
+    QString m_pluginName;
    QString m_workingDir;
    bool m_maintenanceMode;
    bool m_dryRun;

+    static QPluginLoader pluginLoader;
+
 public:
    enum class DownloadResult {OK, ERROR, TIMEOUT, NOP};
    enum class FileTypeJson {CONFIG=1, DEVICE=2, CASH=3, SERIAL=4, TIME=5, PRINTER=6};

    static hwinf *loadDCPlugin(QDir const &plugInDir, QString const &fn);
+    static bool unloadDCPlugin();
    static QStringList split(QString line, QChar sep = ',');


@@ -44,6 +49,7 @@ public:
                    QString customerRepository,
                    QString customerNrStr,
                    QString branchName,
+                    QString pluginName,
                    QString workingDir,
                    bool dryRun = false,
                    QObject *parent = nullptr,
@@ -85,6 +91,7 @@ private:
    bool updateDeviceConf(QString jsFileToSendToDC);
    bool downloadJson(enum FileTypeJson type, int templateIdx,
                      QString jsFileToSendToDC) const;
+    QStringList getDcSoftAndHardWareVersion();

 private slots:
    void readyReadStandardOutput();
--- a/update_dc_event.cpp
+++ b/update_dc_event.cpp
@@ -0,0 +1,25 @@
+#include "update_dc_event.h"
+
+QEvent::Type UpdateDcEvent::customEventType = QEvent::None;
+
+UpdateDcEvent::UpdateDcEvent(QObject const *sender,
+                             UpdateStep updateStep,
+                             int count,
+                             QDateTime const &sendDateTime)
+    : QEvent(UpdateDcEvent::type())
+    , m_sender(sender)
+    , m_updateStep(updateStep)
+    , m_count(count)
+    , m_sendDateTime(sendDateTime) {
+}
+
+UpdateDcEvent::~UpdateDcEvent() {
+}
+
+QEvent::Type UpdateDcEvent::type() {
+    if (customEventType == QEvent::None) {
+        int generatedType = QEvent::registerEventType();
+        customEventType = static_cast<QEvent::Type>(generatedType);
+    }
+    return customEventType;
+}
--- a/update_dc_event.h
+++ b/update_dc_event.h
@@ -0,0 +1,40 @@
+#ifndef UPDATE_DC_EVENT_H_INCLUDED
+#define UPDATE_DC_EVENT_H_INCLUDED
+
+#include <QEvent>
+#include <QDateTime>
+
+class UpdateDcEvent : public QEvent {
+public:
+    enum UpdateStep { NONE, DC_REBOOT, BL_START, BL_CHECK, BL_CHECK_AFTER_STOP, BL_IS_UP, BL_IS_DOWN, BL_STOP};
+
+private:
+    QObject const *m_sender;
+    UpdateStep m_updateStep;
+    int m_count;
+    QDateTime m_sendDateTime;
+
+public:
+    explicit UpdateDcEvent(QObject const *sender, UpdateStep updateStep,
+                           int count,
+                           QDateTime const &sendDateTime = QDateTime::currentDateTime());
+    virtual ~UpdateDcEvent();
+    static QEvent::Type type();
+
+    QObject const *sender() { return m_sender; }
+    QObject const *sender() const { return m_sender; }
+
+    void setUpdateStep(UpdateStep updateStep) { m_updateStep = updateStep; }
+    UpdateStep updateStep() { return m_updateStep; }
+    UpdateStep updateStep() const { return m_updateStep; }
+    int count() const { return m_count; }
+    void setCount(int count) { m_count = count; }
+    QDateTime &sendDateTime() { return m_sendDateTime; }
+    QDateTime const &sendDateTime() const { return m_sendDateTime; }
+
+private:
+    static QEvent::Type customEventType;
+};
+
+
+#endif // PROGRESS_EVENT_H_INCLUDED
--- a/utils.cpp
+++ b/utils.cpp
@@ -2,9 +2,19 @@
 #include "message_handler.h"
 #include "git/git_client.h"

+
+#if defined (Q_OS_UNIX) || defined (Q_OS_LINUX)
+#include "unistd.h"
+#endif
+
 #include <QFile>
 #include <QTextStream>
 #include <QDebug>
+#include <QDir>
+#include <QDirIterator>
+#include <QRegularExpression>
+
+#include <fstream>

 int Utils::read1stLineOfFile(QString fileName) {
    QFile f(fileName);
@@ -37,15 +47,21 @@ QString Utils::zoneName(quint8 i) {
 }

 void Utils::printCriticalErrorMsg(QString const &errorMsg) {
-    qCritical() << QString(80, '!');
+    qCritical() << QString(80, 'E');
    qCritical() << errorMsg;
-    qCritical() << QString(80, '!');
+    qCritical() << QString(80, 'E');
+}
+
+void Utils::printUpdateStatusMsg(QString const &updateMsg) {
+    qCritical() << QString(80, 'U');
+    qCritical() << updateMsg;
+    qCritical() << QString(80, 'U');
 }

 void Utils::printInfoMsg(QString const &infoMsg) {
-    qCritical() << QString(80, '=');
+    qCritical() << QString(80, 'I');
    qCritical() << infoMsg;
-    qCritical() << QString(80, '=');
+    qCritical() << QString(80, 'I');

 }

@@ -169,3 +185,53 @@ bool Utils::sameFilesInDirs(QDir const &dir1, QDir const &dir2,

    return true;
 }
+
+
+QString Utils::getParentName() { // get name of parent process
+    QString ppid = QString("/proc/%1/status").arg(getppid());
+    std::ifstream f(ppid.toStdString().c_str());
+    if (f.is_open()) {
+        std::string next;
+        while (std::getline(f, next)) {
+            QString line = QString(next.c_str()).simplified();
+            if (line.startsWith("Name")) {
+                int const idx = line.indexOf(QChar(':'));
+                if (idx != -1) {
+                    return line.mid(idx+1).trimmed();
+                }
+            }
+        }
+    }
+    return "";
+}
+
+bool Utils::isATBQTRunning() {
+    QDirIterator it("/proc",
+                    QStringList() << "status",
+                    QDir::Files,
+                    QDirIterator::Subdirectories);
+    while (it.hasNext()) {
+        QString const &nextStatusFile = it.next();
+        static const QRegularExpression re("^/proc/[0-9]{1,}/status");
+        QRegularExpressionMatch match = re.match(nextStatusFile);
+        if (match.hasMatch()) {
+            std::ifstream f(nextStatusFile.toStdString().c_str());
+            if (f.is_open()) {
+                std::string next;
+                while (std::getline(f, next)) {
+                    QString line = QString(next.c_str()).simplified();
+                    if (line.startsWith("Name")) {
+                        int const idx = line.indexOf(QChar(':'));
+                        if (idx != -1) {
+                            QString const binary = line.mid(idx+1).trimmed();
+                            if (binary == "ATBQT") {
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
--- a/utils.h
+++ b/utils.h
@@ -14,11 +14,16 @@ namespace Utils {
    QString zoneName(quint8 i);
    void printCriticalErrorMsg(QString const &errorMsg);
    void printInfoMsg(QString const &infoMsg);
+    void printUpdateStatusMsg(QString const &updateMsg);
    void printLineEditInfo(QStringList const &lines);
    QString getTariffLoadTime(QString fileName);
    QString rstrip(QString const &str);
    bool sameFilesInDirs(QDir const &dir1, QDir const &dir2,
                         QStringList const &nameFilters = {"*.json"});
+
+
+    QString getParentName();
+    bool isATBQTRunning();
 }

 #endif // UTILS_H_INCLUDED
--- a/worker.cpp
+++ b/worker.cpp
@@ -15,6 +15,7 @@
 #include <QMessageBox>
 #include <QPushButton>
 #include <QJsonParseError>
+#include <Qt>

 #include <thread>

@@ -30,34 +31,35 @@ QString const Worker::UPDATE_STEP_DONE(" [done]");
 QString const Worker::UPDATE_STEP_FAIL(" [FAIL]");
 QString const Worker::UPDATE_STEP_SUCCESS(" [SUCCESS]");

-Worker::Worker(hwinf *hw,
-               int customerNr,
+Worker::Worker(int customerNr,
               int machineNr,
               int zoneNr,
               QString branchName,
+               QString pluginName,
               QString workingDirectory,
               bool dryRun,
               QObject *parent,
               char const *serialInterface,
               char const *baudrate)
-  : m_hw(hw)
-  , m_workerThread("workerThread")
+  : m_workerThread("workerThread")
  , m_customerNr(customerNr)
  , m_customerNrStr(QString("customer_") + QString::number(m_customerNr).rightJustified(3, '0'))
  , m_machineNr(machineNr)
  , m_zoneNr(zoneNr)
+  , m_pluginName(pluginName)
  , m_workingDirectory(workingDirectory)
  , m_branchName(branchName)
  , m_customerRepositoryPath(QString("https://git.mimbach49.de/GerhardHoffmann/%1.git").arg(m_customerNrStr))
  , m_customerRepository(QDir::cleanPath(m_workingDirectory + QDir::separator() + m_customerNrStr))
-  , m_update(new Update(m_hw, this, m_customerRepository, m_customerNrStr, m_branchName,
-                        m_workingDirectory, dryRun, parent, serialInterface, baudrate))
+  , m_dryRun(dryRun)
+  , m_parent(parent)
+  , m_serialInterface(serialInterface)
+  , m_baudrate(baudrate)
  , m_gc(m_customerNrStr, m_customerRepository, m_workingDirectory, m_branchName, this)
  , m_osVersion(getOsVersion())
  , m_atbqtVersion(getATBQTVersion())
+  , m_atbUpdateToolVersion(getATBUpdateToolVersion())
  , m_cpuSerial(getCPUSerial())
-  , m_raucVersion(getRaucVersion())
-  , m_opkgVersion(getOpkgVersion())
  , m_pluginVersionATBDeciceController(getPluginVersion("/opt/app/ATBAPP/plugins/libATBDeviceControllerPlugin.so"))
  , m_pluginVersionIngenicoISelf(getPluginVersion("/opt/app/ATBAPP/plugins/libIngenicoISelf_CCPlugin.so"))
  , m_pluginVersionMobilisisCalc(getPluginVersion("/opt/app/ATBAPP/plugins/libMOBILISIS_CalculatePricePlugin.so"))
@@ -70,11 +72,19 @@ Worker::Worker(hwinf *hw,
  , m_filesToUpdate()
  , m_updateProcessRunning(true)
  , m_returnCode(0)
+  , m_mainWindow(nullptr) /* contains plugin */
  , m_progressValue(0)
+  //, m_withoutIsmasDirectPort(true) /* useful for testing */ {
  , m_withoutIsmasDirectPort(false) /* useful for testing */ {

+    this->setObjectName("worker-object");
    QDir::setCurrent(m_workingDirectory);

+    if (std::optional<QString> v = getApismVersion()) {
+        m_apismVersion = v.value();
+    }
+
+    Utils::printInfoMsg("STARTING PTU-UPDATE");
    qInfo() << "CURRENT TIME ..............." << QDateTime::currentDateTime().toString(Qt::ISODate);
    qInfo() << "OS VERSION ................." << m_osVersion;
    qInfo() << "ATBQT VERSION .............." << m_atbqtVersion;
@@ -86,7 +96,10 @@ Worker::Worker(hwinf *hw,
    qInfo() << "MACHINE_NR ................." << m_machineNr;
    qInfo() << "ZONE_NR ...................." << m_zoneNr;
    qInfo() << "BRANCH_NAME ................" << m_branchName;
+    qInfo() << "PLUGIN_NAME ................" << m_pluginName;
    qInfo() << "WORKING_DIRECTORY .........." << m_workingDirectory;
+    qInfo() << "APISM VERSION .............." << m_apismVersion;
+    qInfo() << "ATB UPDATE TOOL VERSION ...." << m_atbUpdateToolVersion;

    this->moveToThread(&m_workerThread);
    m_workerThread.start();
@@ -112,9 +125,6 @@ Worker::~Worker() {
            }
        }
    }
-    if (m_update) {
-        delete m_update;
-    }
 }

 void Worker::setProgress(int progress) {
@@ -139,22 +149,14 @@ void Worker::update() {
 }

 void Worker::privateUpdate() {
+    if (!m_mainWindow) {
+        Utils::printCriticalErrorMsg("m_mainWindow NOT SET");
+        return;
+    }
+
    m_updateProcessRunning = true;
-
    bool sentIsmasLastVersionNotification = false;

-    //emit appendText("\nRestart APISM ...");
-    //startProgressLoop();
-    //Command c("systemctl restart apism");
-    //if (c.execute("/tmp")) {
-    //    QThread::sleep(10); // give APISM some time to reconnect
-    //    stopProgressLoop();
-    //    emit replaceLast("Restart APISM ...", UPDATE_STEP_DONE);
-    //} else {
-    //    stopProgressLoop();
-    //    emit replaceLast("Restart APISM ...", UPDATE_STEP_FAIL);
-    //}
-
    emit disableExit();

    m_returnCode = -1;
@@ -166,8 +168,7 @@ void Worker::privateUpdate() {
            stopProgressLoop();
            emit replaceLast("Initializing customer environment", UPDATE_STEP_DONE);

-            int progress = (m_mainWindow->progressValue()/10) + 10;
-            setProgress(progress);
+            setProgress(5);

            m_updateStatus = UpdateStatus(UPDATE_STATUS::GIT_CLONE_AND_CHECKOUT_SUCCESS,
                                  QString("CLONED AND CHECKED OUT: ") + m_customerRepository);
@@ -177,7 +178,7 @@ void Worker::privateUpdate() {
                        m_ismasClient.cloneAndCheckoutCustomerRepository(
                            m_updateStatus.m_statusDescription));

-            setProgress(progress + 10);
+            setProgress(10);

            IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
                    QString("#M=APISM#C=CMD_EVENT#J=") +
@@ -191,9 +192,7 @@ void Worker::privateUpdate() {
            m_returnCode = 0;
        } else {
            stopProgressLoop();
-
-            int progress = (m_mainWindow->progressValue()/10) + 10;
-            setProgress(progress);
+            setProgress(0);

            emit replaceLast("Initializing customer environment", UPDATE_STEP_FAIL);

@@ -206,13 +205,9 @@ void Worker::privateUpdate() {
            m_returnCode = -3;
        }
    } else {
-        m_ismasClient.setProgressInPercent(10);
-        if (backendConnected()) {
-            m_ismasClient.setProgressInPercent(20);
-            if (updateTriggerSet()) {
-                m_ismasClient.setProgressInPercent(30);
-                if (customerEnvironment()) {
-                    m_ismasClient.setProgressInPercent(40);
+        if (updateTriggerSet(5)) {
+            if (customerEnvironment(30)) {
+                m_ismasClient.setProgressInPercent(50);
                if (filesToUpdate()) {
                    // send message to ISMAS about files which have been
                    // checked in into git repository
@@ -222,23 +217,19 @@ void Worker::privateUpdate() {
                        QString("#M=APISM#C=CMD_EVENT#J=") +
                            m_ismasClient.updateOfPSAContinues("CHECK-FILES-TO-UPDATE",
                                                               m_updateStatus.m_statusDescription));
-                        m_ismasClient.setProgressInPercent(50);
-                        if (updateFiles(50)) {
-                            m_ismasClient.setProgressInPercent(60);
-                            if (syncCustomerRepositoryAndFS()) {
+                    if (updateFiles(60)) {
                        m_ismasClient.setProgressInPercent(70);
-                                if (sendIsmasLastVersionNotification()) {
+                        if (syncCustomerRepositoryAndFS()) {
                            m_ismasClient.setProgressInPercent(80);
+                            if (sendIsmasLastVersionNotification()) {
+                                m_ismasClient.setProgressInPercent(90);
                                sentIsmasLastVersionNotification = true;
                                if (saveLogFile()) {
-                                        m_ismasClient.setProgressInPercent(90);
-
                                    IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
                                        QString("#M=APISM#C=CMD_EVENT#J=") +
                                            m_ismasClient.updateOfPSASucceeded(""));

                                    // mark update as activated -> this resets the WAIT button
-                                        m_ismasClient.setProgressInPercent(95);
                                    IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
                                        QString("#M=APISM#C=CMD_EVENT#J=") +
                                            m_ismasClient.updateOfPSAActivated());
@@ -314,16 +305,6 @@ void Worker::privateUpdate() {
                                                    m_updateStatus.m_statusDescription));
            m_returnCode = -5;
        }
-        } else {
-            m_updateStatus = UpdateStatus(UPDATE_STATUS::BACKEND_CHECK_FAILURE,
-                                QString("ISMAS backend not available"));
-            IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-                QString("#M=APISM#C=CMD_EVENT#J=") +
-                    m_ismasClient.updateOfPSAFailed(IsmasClient::RESULT_CODE::INSTALL_ERROR,
-                                                    "ISMAS-BACKEND-CHECK",
-                                                    m_updateStatus.m_statusDescription));
-            m_returnCode = -4;
-        }
    }

    m_ismasClient.setProgressInPercent(100);
@@ -333,21 +314,20 @@ void Worker::privateUpdate() {
        stopProgressLoop();
        emit appendText(QString("UPDATE "), UPDATE_STEP_FAIL);

-        m_updateStatus = UpdateStatus(UPDATE_STATUS::UPDATE_PROCESS_FAILURE,
-                                      QString("Update process failed"));
-        if (std::optional<QString> s = m_ismasClient.finalResult(IsmasClient::RESULT_CODE::INSTALL_ERROR,
-                                                                 "FINAL-UPDATE-RESULT",
-                                                                 m_updateStatus.m_statusDescription)) {
-            IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-                QString("#M=APISM#C=CMD_EVENT#J=") + s.value());
-        }
+        // m_updateStatus = UpdateStatus(UPDATE_STATUS::UPDATE_PROCESS_FAILURE,
+        //                               QString("Update process failed"));
+        // if (std::optional<QString> s = m_ismasClient.finalResult(IsmasClient::RESULT_CODE::INSTALL_ERROR,
+        //                                                         m_updateStatus.m_statusDescription)) {
+        //    IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
+        //        QString("#M=APISM#C=CMD_EVENT#J=") + s.value());
+        // }
+
    } else {
        emit appendText(QString("UPDATE "), UPDATE_STEP_SUCCESS);

        m_updateStatus = UpdateStatus(UPDATE_STATUS::UPDATE_PROCESS_SUCCESS,
-                                      QString("Update process succeeded"));
+                                      QString("Update process succeeded. Reset WAIT."));
        if (std::optional<QString> s = m_ismasClient.finalResult(IsmasClient::RESULT_CODE::SUCCESS,
-                                                                 "FINAL-UPDATE-RESULT",
                                                                 m_updateStatus.m_statusDescription)) {
            IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
                QString("#M=APISM#C=CMD_EVENT#J=") + s.value());
@@ -364,34 +344,20 @@ void Worker::privateUpdate() {
    emit restartExitTimer();
 }

-bool Worker::backendConnected() {
-    // deactivated: REQ_SELF does not really help. Observation was that even
-    // id ISMAS is reported as 'true', a following check of the update-trigger
-    // button has no access to ISMAS.
-    return true;
-
-    emit appendText("\nConnecting backend ...");
-
-    if (false) { // so linker removes dead code
-        for (int repeat = 0; repeat < 100; ++repeat) {
-            qInfo() << "REPEAT" << repeat << "In backendConnected() -> #M=APISM#C=REQ_SELF#J={}";
-            startProgressLoop();
+std::optional<QString> Worker::getApismVersion() {
+    for (int repeat = 0; repeat < 10; ++repeat) {
+        qInfo() << "REPEAT" << repeat << "In getApismVersion() -> #M=APISM#C=REQ_SELF#J={}";
        std::optional<QString> result
            = IsmasClient::sendRequestReceiveResponse(
                IsmasClient::APISM::DIRECT_PORT, "#M=APISM#C=REQ_SELF#J={}");
        if (result) {
-                stopProgressLoop();
-                int progress = (m_mainWindow->progressValue()/10) + 10;
-                setProgress(progress);
-
            QString msg  = result.value();
-                qInfo() << "In backendConnected() -> APISM response" << msg;
+            qInfo() << "In getApismVersion() -> APISM response" << msg;
            QJsonParseError parseError;
            QJsonDocument document(QJsonDocument::fromJson(msg.toUtf8(), &parseError));
            if (parseError.error != QJsonParseError::NoError) {
                qCritical() << "(1) INVALID JSON MSG: PARSING FAILED (msg=" << msg << "):"
                            << parseError.error << parseError.errorString();
-                    setProgress(100);
                m_updateStatus = UpdateStatus(UPDATE_STATUS::JSON_PARSE_FAILURE,
                                              QString("(2) INVALID JSON %1 %2 %3")
                                                .arg(msg)
@@ -401,105 +367,44 @@ bool Worker::backendConnected() {
                    QString("#M=APISM#C=CMD_EVENT#J=") +
                        m_ismasClient.jsonParseFailed(IsmasClient::RESULT_CODE::INSTALL_ERROR,
                                                      m_updateStatus.m_statusDescription));
-                    emit replaceLast("Connecting backend ...", UPDATE_STEP_FAIL);
-                    return false;
+                return std::nullopt;
            }
            if (!document.isObject()) {
                qCritical() << "FILE IS NOT A JSON OBJECT!";
-                    setProgress(100);
                m_updateStatus = UpdateStatus(UPDATE_STATUS::JSON_PARSE_FAILURE,
                                              QString("NOT A JSON-OBJECT %1").arg(msg));
                IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
                    QString("#M=APISM#C=CMD_EVENT#J=") +
                        m_ismasClient.jsonParseFailed(IsmasClient::RESULT_CODE::INSTALL_ERROR,
                                                      m_updateStatus.m_statusDescription));
-                    emit replaceLast("Connecting backend ...", UPDATE_STEP_FAIL);
-                    return false;
+                return std::nullopt;
            }
-
-                setProgress(progress + 1);
-
            QJsonObject obj = document.object();
            QStringList keys = obj.keys().filter("CMD_GET_APISMSTATUS_RESPONSE");
-                if (keys.size() == 1) {
-                    QString const key = keys.at(0);
-                    QJsonValue v = obj.value(key);
-                    if (v.isObject()) {
-                        obj = v.toObject();
-                        bool ismas = obj.value("ISMAS").toBool();
-                        QString status = obj.value("Broker").toString();
-                        qInfo() << "REPEAT" << repeat << "In backendConnected() Broker=<"
-                                << status << ">, ISMAS=<" << (ismas ? "true>" : "false>");
-                        if (ismas) {
-                            if (status == "Connected") {
-                                // do not send, as this would result in a corrupted wait button
-                                // but update the user-interface
-                                setProgress(100);
-                                emit replaceLast("Connecting backend ...", UPDATE_STEP_OK);
-                                return true;
-                            }
-                        }
-
-                        m_updateStatus = UpdateStatus(UPDATE_STATUS::BACKEND_CHECK,
-                                                      QString ("REPEAT %1 Broker=<").arg(repeat)
-                                                        + status + ">, ISMAS=<" + (ismas ? "true>" : "false>"));
-                        //IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-                        //    QString("#M=APISM#C=CMD_EVENT#J=") +
-                        //        m_ismasClient.updateOfPSAContinues("BACKEND-CHECK", m_updateStatus.m_statusDescription));
-
-                        qInfo() << "BACKEND-CHECK" << m_updateStatus.m_statusDescription;
-                        emit showErrorMessage("Check backend connection", m_updateStatus.m_statusDescription);
-                        QThread::sleep(6);
-                        continue;
-                    } else {
-                        setProgress(100);
-                        m_updateStatus = UpdateStatus(UPDATE_STATUS::BACKEND_CHECK_FAILURE,
-                                                      "CMD_GET_APISM_STATUS_RESPONSE KEY NOT A JSON-OBJECT");
-                        IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-                            QString("#M=APISM#C=CMD_EVENT#J=") +
-                                m_ismasClient.sanityCheckFailed(IsmasClient::RESULT_CODE::INSTALL_ERROR,
-                                                                m_updateStatus.m_statusDescription));
-                        emit showErrorMessage("check backend connection", m_updateStatus.m_statusDescription);
-                        emit replaceLast("Connecting backend ...", UPDATE_STEP_FAIL);
-                        return false;
-                    }
-                } else {
-                    setProgress(100);
+            if (keys.size() != 1) {
                m_updateStatus = UpdateStatus(UPDATE_STATUS::BACKEND_CHECK_FAILURE,
                                    "CMD_GET_APISMSTATUS_RESPONSE KEY NOT AVAILABLE");
                IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
                    QString("#M=APISM#C=CMD_EVENT#J=") +
                        m_ismasClient.sanityCheckFailed(IsmasClient::RESULT_CODE::INSTALL_ERROR,
                                                        m_updateStatus.m_statusDescription));
-                    emit showErrorMessage("check backend connection", m_updateStatus.m_statusDescription);
-                    emit replaceLast("Connecting backend ...", UPDATE_STEP_FAIL);
-                    return false;
-                }
-
+                emit showErrorMessage("apism response", m_updateStatus.m_statusDescription);
+                return std::nullopt;
            } else {
-                stopProgressLoop();
-                int progress = (m_mainWindow->progressValue()/10) + 10;
-                setProgress(progress);
+                QString const key = keys.at(0);
+                QJsonValue v = obj.value(key);
+                return v.toObject().value("Version").toString();
+            }
+        } else {
+            QThread::sleep(1);
        }
    }
-
-        setProgress(100);
-
-        emit replaceLast("Connecting backend", UPDATE_STEP_FAIL);
-        emit showErrorMessage("Error", "Backend not available");
-
-        m_updateStatus = UpdateStatus(UPDATE_STATUS::BACKEND_NOT_CONNECTED,
-                                      QString("NO BACKEND CONNECTION"));
-        IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
-            QString("#M=APISM#C=CMD_EVENT#J=") +
-                m_ismasClient.errorBackendNotConnected(m_updateStatus.m_statusDescription, ""));
-    }
-    return false;
+    return std::nullopt;
 }

 #define CHECK_UPDATE_TRIGGER_SET "Check update trigger ..."

-bool Worker::updateTriggerSet() {
+bool Worker::updateTriggerSet(int progress) {
    if (m_withoutIsmasDirectPort) { // useful for testing
        return true;
    }
@@ -514,11 +419,11 @@ bool Worker::updateTriggerSet() {

        if (repeat > 1) {
            int const durationMs = QTime::currentTime().msecsSinceStartOfDay() - startMs;
-            QString const &msg = QString("[%1] time: %2.%3s").arg(repeat).arg(durationMs / 1000).arg(durationMs % 1000);
+            QString const &msg = QString("elapsed: %1.%2s").arg(durationMs / 1000).arg(durationMs % 1000);
            qInfo() << "REPEAT" << msg;
            emit showErrorMessage("check update trigger", msg);
        } else {
-            emit showErrorMessage("check update trigger", QString("[%1]").arg(repeat));
+            emit showErrorMessage("check update trigger", "");
        }

        if ((repeat % 10) == 0) {
@@ -535,8 +440,7 @@ bool Worker::updateTriggerSet() {
                = IsmasClient::sendRequestReceiveResponse(
                    IsmasClient::APISM::DIRECT_PORT, "#M=APISM#C=REQ_ISMASPARAMETER#J={}")) {
            stopProgressLoop();
-            int progress = (m_mainWindow->progressValue()/10) + 10;
-            setProgress(progress);
+            setProgress(m_mainWindow->progressValue()/10 + 11);

            QString msg = result.value();

@@ -575,15 +479,13 @@ bool Worker::updateTriggerSet() {
                emit replaceLast(CHECK_UPDATE_TRIGGER_SET, UPDATE_STEP_FAIL);
                return false;
            }
-            progress += 1;
-            setProgress(progress);
+            setProgress(m_mainWindow->progressValue()/10 + 11);

            QJsonObject obj = document.object();

            // always look for an 'error' first
            if (obj.contains("error")) {
-                progress += 1;
-                setProgress(progress);
+                setProgress(m_mainWindow->progressValue()/10 + 11);
                QString value = obj.value("error").toString();
                emit showErrorMessage("check update trigger", QString("REPEAT %1 error=<").arg(repeat) + value + ">");
                qInfo() << "REPEAT" << repeat << "In updateTriggerSet() error=<"
@@ -668,8 +570,7 @@ bool Worker::updateTriggerSet() {
                emit replaceLast(CHECK_UPDATE_TRIGGER_SET, UPDATE_STEP_FAIL);
                return false;
            }
-            progress += 1;
-            setProgress(progress);
+            setProgress(m_mainWindow->progressValue()/10 + 11);

            if (obj.contains("Fileupload")) {
                QJsonValue v = obj.value("Fileupload");
@@ -687,11 +588,17 @@ bool Worker::updateTriggerSet() {
                            m_updateStatus = UpdateStatus(UPDATE_STATUS::ISMAS_SANITY_CHECK_OK,
                                                          QString("MACHINE-NR (%1) AND CUST-NR (%2) OK")
                                                            .arg(m_machineNr).arg(m_customerNr));
+
+                            m_ismasClient.setProgressInPercent(progress);
+
                            IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
                                QString("#M=APISM#C=CMD_EVENT#J=") +
                                    m_ismasClient.updateOfPSAContinues("MACHINE-AND-CUSTOMER-CHECK",
                                                                   m_updateStatus.m_statusDescription));

+                            progress += 5;
+                            m_ismasClient.setProgressInPercent(progress);
+
                            m_updateStatus = UpdateStatus(UPDATE_STATUS::ISMAS_UPDATE_TRIGGER_SET,
                                QString("UPDATE TRIGGER SET. CONTINUE. "));
                            IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
@@ -703,9 +610,7 @@ bool Worker::updateTriggerSet() {
                        } else
                        if (QRegExp("\\s*").exactMatch(triggerValue)) { // check for whitespace
                            stopProgressLoop();
-                            int progress = (m_mainWindow->progressValue()/10) + 10;
-                            progress += 1;
-                            setProgress(progress);
+                            setProgress(m_mainWindow->progressValue()/10 + 11);
                            emit showErrorMessage("check update trigger", "empty update-trigger");
                            QThread::sleep(6);
                            continue;
@@ -760,9 +665,7 @@ bool Worker::updateTriggerSet() {
            }
        } else {
            stopProgressLoop();
-            int progress = (m_mainWindow->progressValue()/10) + 10;
-            progress += 1;
-            setProgress(progress);
+            setProgress(m_mainWindow->progressValue()/10 + 11);
            emit showErrorMessage("check update trigger", "no ISMAS response");
            QThread::sleep(6);
        }
@@ -780,14 +683,14 @@ bool Worker::updateTriggerSet() {
    return false;
 }

-bool Worker::customerEnvironment() {
+bool Worker::customerEnvironment(int progress) {
    emit appendText("\nPrepare customer environment ...");
    if (QDir(m_customerRepository).exists()) {
        startProgressLoop();
+        setProgress(m_mainWindow->progressValue()/10 + 11);
        if (m_gc.gitCheckoutBranch()) {
            stopProgressLoop();
-            int progress = (m_mainWindow->progressValue()/10) + 10;
-            setProgress(progress);
+            m_ismasClient.setProgressInPercent(progress);

            m_updateStatus = UpdateStatus(UPDATE_STATUS::GIT_CHECKOUT_BRANCH,
                                    QString("CHECKED-OUT BRANCH ") + m_gc.branchName());
@@ -802,8 +705,8 @@ bool Worker::customerEnvironment() {
            return true;
        } else {
            stopProgressLoop();
-            int progress = (m_mainWindow->progressValue()/10) + 10;
-            setProgress(progress);
+            m_ismasClient.setProgressInPercent(0);
+
            emit showErrorMessage("cust-env",
                                  QString("Checkout ") + m_customerRepository + " failed");
            Utils::printCriticalErrorMsg(QString("CHECKOUT OF " + m_customerRepository + "FAILED"));
@@ -821,7 +724,11 @@ bool Worker::customerEnvironment() {
 bool Worker::filesToUpdate() {
    emit appendText("\nFetch changes files ...");
    startProgressLoop();
-    if (std::optional<QString> changes = m_gc.gitFetch()) {
+
+    // always execute contents of opkg_commands-file
+    m_filesToUpdate << "etc/psa_update/opkg_commands";
+
+    if (std::optional<QString> changes = m_gc.gitPull()) {
        stopProgressLoop();
        int progress = (m_mainWindow->progressValue()/10) + 10;
        setProgress(progress);
@@ -835,10 +742,23 @@ bool Worker::filesToUpdate() {
            setProgress(progress + 20);
            if (m_gc.gitPull()) {
                emit replaceLast(QString("Fetch changes files ..."), UPDATE_STEP_DONE);
-                m_filesToUpdate = changedFileNames.value();
+                m_filesToUpdate << changedFileNames.value();
+            } else {
+                emit showErrorMessage("files to update", "pulling files failed");
+                Utils::printCriticalErrorMsg("PULLING FILES FAILED");
+
+                emit replaceLast(QString("Fetch changes files ..."), UPDATE_STEP_FAIL);
+
+                stopProgressLoop();
+                setProgress(100);
+
+                return false;
+            }
+        }

        Utils::printInfoMsg("FILES-TO-UPDATE " + m_filesToUpdate.join(','));

+        m_filesToUpdate.removeDuplicates();
        int const size = m_filesToUpdate.size();
        if (size > 1) {
            emit appendText(QString("Found %1 files to update :").arg(size), UPDATE_STEP_DONE);
@@ -849,39 +769,16 @@ bool Worker::filesToUpdate() {
            emit appendText("Found 1 file to update :", UPDATE_STEP_DONE);
            emit appendText(QString("\n ") + m_filesToUpdate.at(0));
        }
+
+        setProgress(progress + 30);
+    }
+
    return true;
 }
-            emit showErrorMessage("files to update", "pulling files failed");
-            Utils::printCriticalErrorMsg("PULLING FILES FAILED");
-
-        } else {
-            emit showErrorMessage("files to update", "no files to update (checked-in any files?)");
-            Utils::printCriticalErrorMsg("NO FILES TO UPDATE (CHECKED IN ANY FILES?)");
-        }
-        setProgress(progress + 30);
-    } else {
-        stopProgressLoop();
-        int progress = (m_mainWindow->progressValue()/10) + 10;
-        setProgress(progress + 30);
-
-        emit showErrorMessage("files to update",
-                              QString("no changes in ") + m_customerRepository +
-                              " (checked-in any files?)");
-
-        Utils::printCriticalErrorMsg("NO CHANGES IN "
-                                     + m_customerRepository
-                                     + " (CHECKED IN ANY FILES?)");
-    }
-
-    emit replaceLast(QString("Fetch changes files ..."), UPDATE_STEP_FAIL);
-    setProgress(100);
-    return false;
-}

 bool Worker::updateFiles(quint8 percent) {
    QStringList filesToDownload;
    m_displayIndex = 0;
-
    startProgressLoop();
    for (int i = 0; i < m_filesToUpdate.size(); ++i) {
        QString const fName = m_filesToUpdate.at(i);
@@ -895,16 +792,17 @@ bool Worker::updateFiles(quint8 percent) {
                if (f.exists()) {
                    if (f.open(QIODevice::ReadOnly)) {
                        QTextStream in(&f);
-                        int cmdCount = 0;
                        QStringList opkgCommands;
+                        bool executeOpkgCommandFailed = false;
                        while (!in.atEnd()) {
                            QString line = in.readLine();
                            static const QRegularExpression comment("^\\s*#.*$");
                            if (line.indexOf(comment, 0) == -1) {
                                // found opkg command
                                QString opkgCommand = line.trimmed();
-                                ++cmdCount;
-                                executeOpkgCommand(opkgCommand);
+                                if (!executeOpkgCommand(opkgCommand)) {
+                                    executeOpkgCommandFailed = true;
+                                } else {
                                    QString cmd = "\n  " + opkgCommand;
                                    emit appendText(cmd);
                                    opkgCommands << cmd;
@@ -917,26 +815,36 @@ bool Worker::updateFiles(quint8 percent) {
                                                m_ismasClient.execOpkgCommand(m_updateStatus.m_statusDescription, ""));
                                }
                            }
+                        }
                        f.close();
-                        if (cmdCount > 0) {
+                        if (!executeOpkgCommandFailed) {
+                            if (opkgCommands.size() > 0) {
                                m_displayIndex = 1;
-                            QString prepend = QString("(") + QString("%1").arg(m_displayIndex).rightJustified(2, ' ') + QString(")")
+                                QString prepend = QString("(") + QString("%1").arg(m_displayIndex).rightJustified(3, ' ') + QString(")")
                                                    + QString(" Update opkg pakets ... ");
                                opkgCommands.prepend(prepend);
                                emit replaceLast(opkgCommands, UPDATE_STEP_DONE);
+                            }
                        } else {
                            m_displayIndex = 1;
-                            emit replaceLast(QString("(") + QString("%1").arg(m_displayIndex).rightJustified(2, ' ') + QString(")")
+                            emit replaceLast(QString("(") + QString("%1").arg(m_displayIndex).rightJustified(3, ' ') + QString(")")
                                          + QString(" Update opkg pakets ... "), UPDATE_STEP_FAIL);
+
+                            stopProgressLoop();
+                            setProgress(100);
+                            return false;
                        }
                    }
                }
            }
        } else
-        if (fName.contains("print", Qt::CaseInsensitive)) {
+        if (fName.contains("DC2C_print", Qt::CaseInsensitive) ||
+            fName.contains("DC2C_device", Qt::CaseInsensitive) ||
+            fName.contains("DC2C_conf", Qt::CaseInsensitive) ||
+            fName.contains("DC2C_cash", Qt::CaseInsensitive)) {
            filesToDownload << fName;  // download printer-config-files
        } else {
-            static const QRegularExpression version("^.*dc2c[.][0-9][0-9][.][0-9][0-9][.]bin.*$");
+            static const QRegularExpression version("^.*dc2c[.][0-9]{1,2}[.][0-9]{1,2}[.]bin.*$");
            if (fName.contains(version)) {
                filesToDownload << fName; // download device controller
            }
@@ -945,16 +853,21 @@ bool Worker::updateFiles(quint8 percent) {

    stopProgressLoop();
    setProgress(100);
-    bool ret = true;

    if (filesToDownload.size() > 0) {
        Utils::printInfoMsg(QString("FILES_TO_DOWNLOAD_TO_PSA_HW ") + filesToDownload.join(','));
-        ret = m_update->doUpdate(m_displayIndex, filesToDownload);
+
+        Update *update = m_mainWindow->getUpdate();
+        if (update) {
+            return update->doUpdate(m_displayIndex, filesToDownload);
+        } else {
+            Utils::printCriticalErrorMsg("UPDATE NOT SET");
+        }
    } else {
        Utils::printCriticalErrorMsg("NO FILES_TO_DOWNLOAD_TO_PSA_HW");
    }

-    return ret;
+    return true;
 }

 bool Worker::syncCustomerRepositoryAndFS() {
@@ -965,23 +878,29 @@ bool Worker::syncCustomerRepositoryAndFS() {
        if (QDir::setCurrent(m_customerRepository)) {
            Command md("bash");
            if (!md.execute(m_customerRepository,
-                            QStringList() << "-c" << "mkdir -p /etc/psa_config /etc/psa_update /etc/dc /etc/psa_tariff")) {
+                            QStringList() << "-c" << "mkdir -p /etc/psa_config /etc/dc /etc/psa_tariff")) {
                qCritical() << "COULD NOT EXECUTE '" << md.command() << "' exitCode=(" << md.exitCode() << ")";
            }
            int progress = 10;
            setProgress(progress);
-            QString const params("-vv                     "
+            QString const params("-vvv                    "
                                 "--recursive             "
                                 "--progress              "
                                 "--checksum              "
                                 "--exclude=.*            "
                                 "--include=*.bin         "
                                 "--include=*.json        "
-                                 "--include=opkg_commands "
                                 "--include=*.ini");
            QStringList cmds;
+
+            if (QDir(QDir::cleanPath(m_customerRepository + QDir::separator() + "etc/")).exists()) {
                cmds << QString("rsync ") + params.simplified() + " etc/ /etc";
+                Utils::printInfoMsg(QString("CONFIGURED SYNCING TO /ETC"));
+            }
+            if (QDir(QDir::cleanPath(m_customerRepository + QDir::separator() + "opt/")).exists()) {
                cmds << QString("rsync ") + params.simplified() + " opt/ /opt";
+                Utils::printInfoMsg(QString("CONFIGURED SYNCING TO /OPT"));
+            }

            QString cmd;
            bool error = false;
@@ -991,10 +910,28 @@ bool Worker::syncCustomerRepositoryAndFS() {
                if (!error) {
                    Command c("bash");
                    qInfo() << "EXECUTING CMD..." << cmd;
+                    Utils::printInfoMsg(QString("EXECUTING CMD %1...").arg(cmd));
                    if (c.execute(m_customerRepository, QStringList() << "-c" << cmd)) {
                        QStringList result = c.getCommandResult().split('\n');
+                        QString const &p1 = "send_files mapped ";
+                        QString const &p2 = "of size";
                        for (int i = 0; i < result.size(); ++i) {
-                            qInfo() << result.at(i);
+                            QString line = result.at(i);
+                            qInfo() << line;
+
+                            // "send_files mapped etc/psa_tariff/tariff01.json of size 19339"
+                            int sendFilesAtPos = line.indexOf(p1);
+                            int ofSizeAtPos = line.indexOf(p2);
+                            if (sendFilesAtPos != -1 && ofSizeAtPos != -1) {
+                                sendFilesAtPos += p1.length();
+                                QString const &s = line.mid(sendFilesAtPos, ofSizeAtPos - sendFilesAtPos).trimmed();
+                                m_updateStatus = UpdateStatus(UPDATE_STATUS::RSYNC_FILE_SUCCESS,
+                                    QString("RSYNC FILE ") + s.split("/").last() +
+                                            " LAST-COMMIT: " + m_gc.gitLastCommit(s));
+                                IsmasClient::sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
+                                        QString("#M=APISM#C=CMD_EVENT#J=") +
+                                            m_ismasClient.rsyncFile(m_updateStatus.m_statusDescription, ""));
+                            }
                        }
                    } else {
                        Utils::printCriticalErrorMsg(QString("CMD ") + cmd + " FAILED: "
@@ -1044,6 +981,30 @@ QString Worker::getOsVersion() const {
    return "N/A";
 }

+QString Worker::getATBUpdateToolYoctoVersion() {
+    if (QFile::exists("/var/lib/opkg/status")) {
+        QString const cmd = QString("echo -n $(cat /var/lib/opkg/status | grep -A1 atbupdatetool | tail -n 1 | cut -d':' -f2 | cut -d' ' -f2)");
+        Command c("bash");
+        if (c.execute("/tmp", QStringList() << "-c" << cmd)) {
+            return c.getCommandResult(); // 1.3.9+git0+226553a8ab-r0
+        }
+    }
+    return "N/A";
+}
+
+QString Worker::getATBUpdateToolYoctoInstallationStatus()  {
+    if (QFile::exists("/var/lib/opkg/status")) {
+        QString const cmd = QString("echo -n $(cat /var/lib/opkg/status | grep -A3 atbupdatetool | tail -n 1 | cut -d':' -f2 | cut -d' ' -f2,3,4)");
+        Command c("bash");
+        if (c.execute("/tmp", QStringList() << "-c" << cmd)) {
+            return c.getCommandResult(); // 1.3.9+git0+226553a8ab-r0
+        }
+    }
+    return "N/A";
+}
+
+
+
 QString Worker::getATBQTVersion() const {
    QString const cmd = QString("echo -n $(/opt/app/ATBAPP/ATBQT -v | head -n 2 | cut -d':' -f2)");
    Command c("bash");
@@ -1053,6 +1014,10 @@ QString Worker::getATBQTVersion() const {
    return "N/A";
 }

+QString Worker::getATBUpdateToolVersion() const {
+    return APP_EXTENDED_VERSION;
+}
+
 QString Worker::getCPUSerial() const {
    QString const cmd = QString("echo -n $(cat /proc/cpuinfo | grep -i Serial | cut -d':' -f2)");
    Command c("bash");
@@ -1091,14 +1056,15 @@ QString Worker::getPluginVersion(QString const &pluginFileName) const {

 QStringList Worker::getDCVersion() const {
    QStringList lst = (QStringList() << "N/A" << "N/A");
-    if (m_hw) {
-        m_hw->dc_autoRequest(true); // turn auto-request setting on
+    hwinf *hwi = m_mainWindow->getPlugin();
+    if (hwi) {
+        hwi->dc_autoRequest(true); // turn auto-request setting on

        QByteArray const cmp(8, char(0));
        QByteArray hw(""), sw("");
        for (int i=0; i<5; ++i) {
-            hw = m_hw->dc_getHWversion().toUtf8();
-            sw = m_hw->dc_getSWversion().toUtf8();
+            hw = hwi->dc_getHWversion().toUtf8();
+            sw = hwi->dc_getSWversion().toUtf8();
            if (!hw.startsWith(cmp)) {
                lst.clear();
                qInfo() << hw << sw;
@@ -1147,9 +1113,7 @@ PSAInstalled Worker::getPSAInstalled() {
    QString printSysDir("/etc/psa_config");
    QString tariffSysDir("/etc/psa_tariff");
    QString tariffRepoDir("etc/psa_tariff");
-    QString opkgSysDir("/etc/psa_update");
    QString opkgRepoDir("etc/psa_update");
-    QString const &absPathNameOpkg = QDir::cleanPath(opkgSysDir + QDir::separator() + "opkg_commands");
    QString const &absPathNameRepositoryOpkg = QDir::cleanPath(opkgRepoDir + QDir::separator() + "opkg_commands");
    QString absPathName;
    QString absPathNameRepository;
@@ -1158,7 +1122,7 @@ PSAInstalled Worker::getPSAInstalled() {
    psaInstalled.versionInfo.reason = "";
    psaInstalled.versionInfo.created = "";

-    QStringList versionInfo = m_gc.gitShowReason();
+    QStringList versionInfo = m_gc.gitShowReason(m_branchName);
    if (versionInfo.size() == 3) {
        psaInstalled.versionInfo.lastCommit = versionInfo.at(0);
        psaInstalled.versionInfo.reason = versionInfo.at(1);
@@ -1180,12 +1144,12 @@ PSAInstalled Worker::getPSAInstalled() {
    psaInstalled.tariff.info = "N/A";
    psaInstalled.tariff.version = "N/A";

-    psaInstalled.hw.linuxVersion = m_osVersion;
+    psaInstalled.hw.linuxVersion = getOsVersion();
    psaInstalled.hw.cpuSerial = m_cpuSerial;

-    psaInstalled.opkg.blob = m_gc.gitBlob(absPathNameOpkg);
-    psaInstalled.opkg.size = getFileSize(absPathNameOpkg);
-    psaInstalled.opkg.loadTime = Utils::getTariffLoadTime(absPathNameOpkg);
+    psaInstalled.opkg.blob = m_gc.gitBlob(absPathNameRepositoryOpkg);
+    psaInstalled.opkg.size = getFileSize(absPathNameRepositoryOpkg);
+    psaInstalled.opkg.loadTime = Utils::getTariffLoadTime(absPathNameRepositoryOpkg);
    psaInstalled.opkg.lastCommit = m_gc.gitLastCommit(absPathNameRepositoryOpkg);

    psaInstalled.dc.versionHW = deviceControllerVersionHW;
@@ -1194,9 +1158,11 @@ PSAInstalled Worker::getPSAInstalled() {
    psaInstalled.dc.gitLastCommit = "N/A";
    psaInstalled.dc.size = -1;

-    psaInstalled.sw.raucVersion = m_raucVersion;
-    psaInstalled.sw.opkgVersion = m_opkgVersion;
-    psaInstalled.sw.atbQTVersion = m_atbqtVersion;
+    if (std::optional<QString> v = getApismVersion()) {
+        psaInstalled.sw.apismVersion = v.value();
+    }
+    psaInstalled.sw.atbQTVersion = getATBQTVersion();
+    psaInstalled.sw.atbUpdateToolVersion = m_atbUpdateToolVersion;

    psaInstalled.pluginVersion.deviceController = m_pluginVersionATBDeciceController;
    psaInstalled.pluginVersion.ingenicoISelfCC = m_pluginVersionIngenicoISelf;
@@ -1232,6 +1198,14 @@ PSAInstalled Worker::getPSAInstalled() {
    return psaInstalled;
 }

+hwinf *Worker::getPlugin() {
+    return m_mainWindow ? m_mainWindow->getPlugin() : nullptr;
+}
+
+hwinf const *Worker::getPlugin() const {
+    return m_mainWindow ? m_mainWindow->getPlugin() : nullptr;
+}
+
 /************************************************************************************************
 * operators
 */
@@ -1345,6 +1319,10 @@ QDebug operator<< (QDebug debug, UpdateStatus status) {
        debug << QString("UPDATE_STATUS::ISMAS_RESPONSE_RECEIVED: ")
              << status.m_statusDescription;
    break;
+    case UPDATE_STATUS::RSYNC_FILE_SUCCESS:
+        debug << QString("UPDATE_STATUS::RSYNC_FILE_SUCCESS: ")
+              << status.m_statusDescription;
+    break;
    case UPDATE_STATUS::EXEC_OPKG_COMMANDS:
        debug << QString("UPDATE_STATUS::EXEC_OPKG_COMMANDS: ")
              << status.m_statusDescription;
@@ -1468,6 +1446,10 @@ QString& operator<< (QString& str, UpdateStatus status) {
        str = QString("UPDATE_STATUS::EXEC_OPKG_COMMANDS: ");
        str += status.m_statusDescription;
    break;
+    case UPDATE_STATUS::RSYNC_FILE_SUCCESS:
+        str = QString("UPDATE_STATUS::RSYNC_FILE_SUCCESS: ");
+        str += status.m_statusDescription;
+    break;
    //default:;
    }
    return str;
--- a/worker.h
+++ b/worker.h
@@ -9,6 +9,8 @@
 #include <QJsonObject>
 #include <QHash>

+#include <optional>
+
 #include "worker_thread.h"
 #include "update.h"
 #include "git/git_client.h"
@@ -41,6 +43,7 @@ enum class UPDATE_STATUS : quint8 {
    EXEC_OPKG_COMMANDS,
    RSYNC_UPDATES_FAILURE,
    RSYNC_UPDATES_SUCCESS,
+    RSYNC_FILE_SUCCESS,
    JSON_PARSE_FAILURE,
    UPDATE_PROCESS_SUCCESS,
    UPDATE_PROCESS_FAILURE,
@@ -71,24 +74,26 @@ class hwinf;
 class Worker : public QObject {
    Q_OBJECT

-    hwinf *m_hw;
    WorkerThread m_workerThread;
    int const m_customerNr;
    QString const m_customerNrStr;
    int const m_machineNr;
    int const m_zoneNr;
+    QString const m_pluginName;
    QString const m_workingDirectory;
    QString const m_branchName;
    QString const m_customerRepositoryPath;
    QString const m_customerRepository;
-    Update *m_update;
+    bool const m_dryRun;
+    QObject *m_parent;
+    QString const m_serialInterface;
+    QString const m_baudrate;
    IsmasClient m_ismasClient;
    GitClient m_gc;
    QString const m_osVersion;
    QString const m_atbqtVersion;
+    QString const m_atbUpdateToolVersion;
    QString const m_cpuSerial;
-    QString const m_raucVersion;
-    QString const m_opkgVersion;
    QString const m_pluginVersionATBDeciceController;
    QString const m_pluginVersionIngenicoISelf;
    QString const m_pluginVersionMobilisisCalc;
@@ -110,10 +115,12 @@ class Worker : public QObject {
    MainWindow *m_mainWindow;
    int m_progressValue;
    bool m_withoutIsmasDirectPort;
+    QString m_apismVersion;

    bool executeOpkgCommand(QString opkgCommand);
    QString getOsVersion() const;
    QString getATBQTVersion() const;
+    QString getATBUpdateToolVersion() const;
    QString getCPUSerial() const;
    QString getRaucVersion() const;
    QString getOpkgVersion() const;
@@ -123,16 +130,19 @@ class Worker : public QObject {
    qint64 getFileSize(QString const &fileName) const;

 public:
+    static QString getATBUpdateToolYoctoVersion();
+    static QString getATBUpdateToolYoctoInstallationStatus();
+
    static const QString UPDATE_STEP_OK;
    static const QString UPDATE_STEP_DONE;
    static const QString UPDATE_STEP_FAIL;
    static const QString UPDATE_STEP_SUCCESS;

-    explicit Worker(hwinf *hw,
-                    int customerNr, // 281
+    explicit Worker(int customerNr, // 281
                    int machineNr,
                    int zoneNr,
                    QString branchName,
+                    QString pluginName,
                    QString workingDir = ".",
                    bool dryRun = false,
                    QObject *parent = nullptr,
@@ -141,6 +151,8 @@ public:
    ~Worker();

    void setMainWindow(MainWindow *mainWindow) { m_mainWindow = mainWindow; }
+    hwinf *getPlugin();
+    hwinf const *getPlugin() const;
    void setProgress(int progress);
    void startProgressLoop();
    void stopProgressLoop();
@@ -154,6 +166,11 @@ public:
    int machineNr() const { return m_machineNr; }
    int customerNr() const { return m_customerNr; }
    int zoneNr() const { return m_zoneNr; }
+    QString apismVersion() const { return m_apismVersion; }
+    QString atbUpdateToolVersion() const { return m_atbUpdateToolVersion; }
+
+    MainWindow *mainWindow() { return m_mainWindow; }
+    MainWindow const *mainWindow() const { return m_mainWindow; }

    //friend QDebug operator<<(QDebug debug, Worker const &w) {
    //    Q_UNUSED(w);
@@ -169,6 +186,7 @@ signals:
    void replaceLast(QString, QString);
    void replaceLast(QStringList, QString);
    void showErrorMessage(QString title, QString description);
+    void showStatusMessage(QString title, QString description);
    void stopStartTimer();
    void restartExitTimer();
    void enableExit();
@@ -178,9 +196,8 @@ public slots:
    void update();

 private slots:
-    bool backendConnected();
-    bool updateTriggerSet();
-    bool customerEnvironment();
+    bool updateTriggerSet(int progress);
+    bool customerEnvironment(int progress);
    bool filesToUpdate();
    bool updateFiles(quint8 percent);
    bool syncCustomerRepositoryAndFS();
@@ -190,6 +207,7 @@ private slots:
 private:
    PSAInstalled getPSAInstalled();
    void privateUpdate();
+    std::optional<QString> getApismVersion();
 };

 #endif // WORKER_H_INCLUDED
Author	SHA1	Message	Date
Gerhard Hoffmann	9b175d7789	Set version to 1.3.12	2023-10-18 11:45:54 +02:00
Gerhard Hoffmann	2d7f145a25	Replaced using gitFetch() with gitPull()	2023-10-18 11:40:04 +02:00
Gerhard Hoffmann	4589c4ca76	Removed gitFetchAndDiff() and original version of gitPull().	2023-10-18 11:38:26 +02:00
Gerhard Hoffmann	a32258a59e	Replaced "git fetch" with "git pull".	2023-10-18 11:37:46 +02:00
Gerhard Hoffmann	22f25e5251	Replaced 'git clone' with 'git clone --filter=blob:none' to speed up cloning of customer-repository.	2023-10-18 11:36:13 +02:00
Gerhard Hoffmann	258d883a51	Replaced gitFetch() with gitPull()	2023-10-18 11:35:23 +02:00
Gerhard Hoffmann	504e242d42	Implemented getATBUpdateToolYoctoVersion() and getATBUpdateToolYoctoInstallationStatus()	2023-10-18 11:31:15 +02:00
Gerhard Hoffmann	731cdcbe09	Added getATBUpdateToolYoctoVersion() and getATBUpdateToolYoctoInstallationStatus()	2023-10-18 11:30:12 +02:00
Gerhard Hoffmann	b4e2d4c54a	Minor: Move reading of machine_nr, customer_nr and zone_nr upwards.	2023-10-18 11:28:06 +02:00
Gerhard Hoffmann	42961dea40	Add command-parameters yoctoVersionOption (yocto-version of ATBUpdateTool as reported by opkg), and yoctoInstallStatusOption (info if ATBUpdateTool is installed as reported by opkg).	2023-10-18 11:26:30 +02:00
Gerhard Hoffmann	fd2f601f67	Add printAupdateStatusMsg().	2023-10-18 11:21:32 +02:00
Gerhard Hoffmann	b45af505cd	Minor: change output format.	2023-10-18 11:21:08 +02:00
Gerhard Hoffmann	2dfe80b654	Add printUpdateStatusMsg()	2023-10-18 11:20:31 +02:00
Gerhard Hoffmann	4b9dcc5e99	Set version to 1.3.11: integrate extended version (VERSION + last git commit) in send-last-version-message.	2023-10-12 12:13:49 +02:00
Gerhard Hoffmann	53639b55c9	Integrate call parameter -V (= --extended-version) to show extended version (including last git commit)	2023-10-12 12:12:16 +02:00
Gerhard Hoffmann	3a83efbd3f	Integrate extended version of ATBUpdateTool into send-last-version command to ISMAS.	2023-10-12 12:11:48 +02:00
Gerhard Hoffmann	c9d6a8d245	Integrate extended version of ATBUpdateTool into send-last-version	2023-10-12 12:10:24 +02:00
Gerhard Hoffmann	91db59b9f3	Integrate version of ATBUpdateTool in send-last-version.	2023-10-12 12:09:19 +02:00
Gerhard Hoffmann	1d81e6b650	Minor: removed unused code.	2023-10-12 12:08:19 +02:00
Gerhard Hoffmann	6d57b45d1a	Use getATBQTVersion() for dynamic value of atbapp.	2023-10-12 12:07:38 +02:00
Gerhard Hoffmann	4e7ce2cd70	set version to 1.3.10: remove timeout on opkg-commands. tested download of DC2C_cash.conf file.	2023-10-10 16:05:16 +02:00
Gerhard Hoffmann	47fac31223	remove timeout for process runtime for opkg-commands	2023-10-10 16:03:52 +02:00
Gerhard Hoffmann	0d353cfbcf	Check if opkg_command failed, and if this is the case, stop the update-process without showing a wrong UPDATE-SUCCESS.	2023-10-10 16:01:45 +02:00
Gerhard Hoffmann	bdcb073bf8	set version to 1.3.9	2023-10-10 14:26:20 +02:00
Gerhard Hoffmann	226553a8ab	Set version to 1.3.9 after fix of gitShowReason().	2023-10-09 15:57:11 +02:00
Gerhard Hoffmann	d4ee56559b	Use getShowReason() with branchName. Use getOsVersion(0 and getApismVersion().	2023-10-09 15:54:58 +02:00
Gerhard Hoffmann	355b28ba40	Use current branch name in gitShowReason(), not just master	2023-10-09 15:53:35 +02:00
Gerhard Hoffmann	edeff35d7e	Activate download of json-configuration files.	2023-10-06 13:02:23 +02:00
Gerhard Hoffmann	09d5de1b0b	rsync: check if source directories in customer repositories exist.	2023-10-06 13:00:25 +02:00
Gerhard Hoffmann	145fdab26e	Minor: fixed output format (in text edit)	2023-10-06 13:00:00 +02:00
Gerhard Hoffmann	89d1ec5b21	Deactivate download of device controller. Will be added in coming version.	2023-10-06 12:58:38 +02:00
Gerhard Hoffmann	f38c975dc6	Remove check for which parent has started atbupdatetool: it is always systemd now.	2023-10-06 12:57:38 +02:00
Gerhard Hoffmann	fba007aa35	Activate download of json-configuration files.	2023-10-06 12:56:03 +02:00
Gerhard Hoffmann	8b6adb3ea7	Scrolldown text edit at end of whole update process to show UPDATE_SUCCESS message.	2023-10-06 12:51:30 +02:00
Gerhard Hoffmann	30603317c6	Minor: Add debug messages or change debug message format.	2023-10-06 10:47:08 +02:00
Gerhard Hoffmann	7083f3b4f8	Minor: add debug message.	2023-10-06 10:44:55 +02:00
Gerhard Hoffmann	7ff866525e	Fix: allow for json-files EC2C_conf/cash/device.json as well.	2023-10-06 10:43:55 +02:00
Gerhard Hoffmann	2164037123	Do not use opkg_commnands-file as located in the filesystem under /etc/psa_update anymore.	2023-10-06 10:42:35 +02:00
Gerhard Hoffmann	2e7d33c4c8	Set version to 1.3.7: wait forever for git-commands to finish in QProcess.	2023-10-05 10:54:19 +02:00
Gerhard Hoffmann	2a2751f6f3	Add creation of BUILD_DATE and BUILD_TIME	2023-10-04 14:34:54 +02:00
Gerhard Hoffmann	2764ef4371	Output of current tool version at program startup	2023-10-04 14:33:52 +02:00
Gerhard Hoffmann	9783f343e1	Set version to 1.3.6: exec opkg-commands even for unchanged opkg-commnds-file	2023-10-04 13:23:06 +02:00
Gerhard Hoffmann	8c6f0dfcc7	Minor: use Q_UNUSED() for unused parameters	2023-10-04 13:21:49 +02:00
Gerhard Hoffmann	d688ad3d5c	Minor: comments	2023-10-04 10:34:56 +02:00
Gerhard Hoffmann	7b3f652b0e	Deactivated doUpdate	2023-10-04 10:20:52 +02:00
Gerhard Hoffmann	4cc42b2a65	Set version to 1.3.6. Removed DCPlugin related stuff.	2023-09-28 12:11:47 +02:00
Gerhard Hoffmann	d783fd7fb6	Minor: print info instead of critical message when git fetch is empty	2023-09-28 12:09:57 +02:00
Gerhard Hoffmann	e0a0ff54e1	Added comment for U00-ISMAS values. Deactivated finalResult()	2023-09-28 12:08:42 +02:00
Gerhard Hoffmann	863d052a21	Removed debug info in appendText()/replcaeLst().	2023-09-28 12:06:28 +02:00
Gerhard Hoffmann	61b3d29e31	Disable text-edit (showing update-status) ehen update procedure finished.	2023-09-28 12:05:07 +02:00
Gerhard Hoffmann	cac4f7249e	Minor: Add progress parameters.	2023-09-28 12:01:55 +02:00
Gerhard Hoffmann	3223c430be	Do not rsync opkg_commnds to local file systems: this sync is not needed.	2023-09-28 12:00:24 +02:00
Gerhard Hoffmann	c09682ea33	Always execute commands contained in opkg_commands, even if no change in opkg_commands. WAIT button in ISMAS must still be activated.	2023-09-28 11:57:17 +02:00
Gerhard Hoffmann	fef1d43d5f	Adapated information of update-progress-status.	2023-09-28 11:56:20 +02:00
Gerhard Hoffmann	705424727b	Removed call to final-result: ISMAS will not show U0002 twice.	2023-09-28 11:53:59 +02:00
Gerhard Hoffmann	b96f0896e3	Add explicit message when update-process is starting.	2023-09-28 11:53:10 +02:00
Gerhard Hoffmann	a3967c76ac	Use showFullScreen() instead of using a flag	2023-09-28 11:47:09 +02:00
Siegfried Siegert	1197598a3d	Set version to 1.3.5	2023-09-21 16:52:42 +02:00
Siegfried Siegert	ec13e97226	Update interfaces.h to HWapi/4.6	2023-09-21 15:55:31 +02:00
Siegfried Siegert	a8dd9d7e24	Merge branch 'master' of git.mimbach49.de:GerhardHoffmann/UpdatePTUDevCtrl	2023-09-21 15:50:19 +02:00
Gerhard Hoffmann	82751eb1d4	Set version to 1.3.4.	2023-09-11 10:14:41 +02:00
Gerhard Hoffmann	17a4a69df2	Added some debug output for parent-process-name	2023-09-11 10:14:04 +02:00
Gerhard Hoffmann	a03261d04a	Fixed getParentName() to work analogously to isATBQTRunning().	2023-09-11 10:12:20 +02:00
Gerhard Hoffmann	7832ef5d8c	Set version to 1.3.3.	2023-09-10 17:22:49 +02:00
Gerhard Hoffmann	9c213d0a97	Added some better debug output in the slots concerned with the text edit of the main window ("update status"). Use insertPlainText() when adding to the text edit to simplify code.	2023-09-10 16:55:32 +02:00
Gerhard Hoffmann	18378afdc5	Did some testing with event filters on the main window. not used.	2023-09-10 16:54:54 +02:00
Gerhard Hoffmann	6dd8a8c6b3	did some testing with event filter. not used.	2023-09-10 16:54:29 +02:00
Gerhard Hoffmann	adfb358e12	Add some output to see if start of the update tool is configured correctly.	2023-09-10 16:51:36 +02:00
Gerhard Hoffmann	ff418b11a1	Use plauginLoader as a dedicated static object.	2023-09-10 16:51:07 +02:00
Gerhard Hoffmann	38e79f0354	Use pluginLoader as a dedicated static object.	2023-09-10 16:50:19 +02:00
Gerhard Hoffmann	103b3f3f9c	isATBQTRunning(): Use std::fstream to read /proc/<pid>/status, as the lines end on '\r', not on '\n'.	2023-09-10 16:46:59 +02:00
Gerhard Hoffmann	ff6a6e0e45	Use libCAslave.so as default library to use for downloading the device-controller-firmware.	2023-09-10 16:45:40 +02:00
Gerhard Hoffmann	afbce3b4ea	Add new dc-lib	2023-09-09 15:10:53 +02:00
Gerhard Hoffmann	823e59a582	Set version to 1.3.2	2023-09-09 15:09:59 +02:00
Gerhard Hoffmann	01cfbddfb1	Add update_dc_event	2023-09-09 15:08:03 +02:00
Gerhard Hoffmann	838efd3945	Show status message in the status bar of the GUI.	2023-09-09 15:06:58 +02:00
Gerhard Hoffmann	9a65cb4456	Add some debug message when adding content to the text edit of the GUI.	2023-09-09 15:06:21 +02:00
Gerhard Hoffmann	df0951d671	Add the steps to prepare the bootloader for device-controller-firmware download using cutom-events of type update-dc-event.	2023-09-09 15:04:41 +02:00
Gerhard Hoffmann	60cc752819	Add connect for showning a status message in status bar.	2023-09-09 15:03:52 +02:00
Gerhard Hoffmann	57b4716e2a	Add emergency test function: if device stays in bootloader then use it to make the device to leave the bootloader.	2023-09-09 15:02:45 +02:00
Gerhard Hoffmann	15f28e9ffd	Add m_update-object and prepare for doing the bootloader setup for downloading the device controller firmware.	2023-09-09 15:01:03 +02:00
Gerhard Hoffmann	a07893ddab	doUpdate() and updateDC(): communicate with main window to enter bootloader (i.e. to prepare device for download of device controller firmware), but do not perform an actual download at the moment.	2023-09-09 14:59:05 +02:00
Gerhard Hoffmann	d0eb1d12d8	Add some debug output to updateBinary().	2023-09-09 14:57:49 +02:00
Gerhard Hoffmann	cd59a39569	Add some more debug output to updateBinary().	2023-09-09 14:57:04 +02:00
Gerhard Hoffmann	67c8b2f472	Extended comment: USING THE BOOTLOADER.	2023-09-09 14:55:48 +02:00
Gerhard Hoffmann	5158878ce2	Extend comment for: USING THE BOOTLOADER. Bitte geben Sie eine Commit-Beschreibung für Ihre Änderungen ein. Zeilen,	2023-09-09 14:54:48 +02:00
Gerhard Hoffmann	b6971c1db5	resetDeviceController(): deprecated.	2023-09-09 14:54:12 +02:00
Gerhard Hoffmann	9df46a1c49	Add some debug output to openSerial().	2023-09-09 14:53:36 +02:00
Gerhard Hoffmann	6765b12f0c	startBootloader(): deprecated.	2023-09-09 14:52:40 +02:00
Gerhard Hoffmann	3e925756cf	Add getDcSoftAndHardWareVersion() utility.	2023-09-09 14:43:46 +02:00
Gerhard Hoffmann	b2798b349e	Fixed reg-exp for name of device controller firmare version.	2023-09-09 14:41:53 +02:00
Gerhard Hoffmann	64dce44fe1	Move update-object into main window. Activate using ISMAS WAIT button.	2023-09-09 14:40:43 +02:00
Gerhard Hoffmann	7e96b65c1b	Move m_update-object to main window. Add signal for showing status messages at status bar of ATBUpdateTool gui.	2023-09-09 14:38:53 +02:00
Gerhard Hoffmann	276d65a9d8	Add utility isATBQTRunning().	2023-09-09 14:33:13 +02:00
Gerhard Hoffmann	ba71728979	Move the dc-plugin (and the update-object) into the gui-thread instead of the worker thread, so the worker-thread cannot block itself when inside a slot and therefore not able to react to qt-signals.	2023-09-09 14:30:53 +02:00
Gerhard Hoffmann	e82742a609	Add helper class update_dc_event to dend customer messages from the worker-thread to the gui-thread. The gui-thread will then perform bl_rebootDC, bl_startBL, bl_checkBL(), bl_isUp() and bl_stopBL().	2023-09-09 14:27:50 +02:00
Gerhard Hoffmann	6773a7243a	Save name of device-controller-plugin (either libCAmaster or libCAslave) in the Update-object.	2023-09-06 09:12:25 +02:00
Gerhard Hoffmann	22c8997f1e	Set autoRequest to false and pass a pointer to the device-controller-plugin to the main window instead to the worker (thread).	2023-09-06 09:10:14 +02:00
Gerhard Hoffmann	9531a08b4a	Add a pointer to the device-controller-plugin. The main window will always be owned by the GUI thread, and the GUI thread is loading the plugin. Hence the worker-thread does not block itself when inside a QT slot.	2023-09-06 09:07:45 +02:00
Gerhard Hoffmann	c065b57f0c	Remove direct member m_hw, a pointer to the device-controller-plugin. The worker shall not load the plugin, otherwise it would block itself inside an QT slot.	2023-09-06 09:04:43 +02:00
Gerhard Hoffmann	cef05b7511	Set version to 1.3.1: extended reason in send-last-version	2023-09-04 11:48:15 +02:00
Gerhard Hoffmann	bb35e985ad	Using IsmasClient::getReasonForLastSendVersion()	2023-09-04 11:46:37 +02:00
Gerhard Hoffmann	981a2ea13a	Added method getReasonForSendLastVersion()	2023-09-04 11:45:30 +02:00
Gerhard Hoffmann	b14b296011	Added utility getParentName() (name of parent process)	2023-09-04 11:42:12 +02:00
Gerhard Hoffmann	1ef9853876	Set version of UpdateTool to 1.3.0. 1.3.0: main change: add fetching info for current apiism-version and send if to ISMAS.	2023-08-30 11:47:56 +02:00
Gerhard Hoffmann	01d8312aa8	Removed rauc/opkg-members. Added m_apismVersion member.	2023-08-30 11:46:55 +02:00
Gerhard Hoffmann	507586f9dc	Added fetching apism-version. Fixed calls to final_result().	2023-08-30 11:46:00 +02:00
Gerhard Hoffmann	12ffa71455	Removed rauc/opkg-versions. Added fetching of apism-version.	2023-08-30 11:44:20 +02:00
Gerhard Hoffmann	a84f495d43	Removed output of rauc/opkg-versions, and added output of apism-version.	2023-08-30 11:42:05 +02:00
Gerhard Hoffmann	7e4b5006eb	Fixed return string of final result().	2023-08-30 11:41:23 +02:00
Gerhard Hoffmann	0a28f0d82c	Add message for current APISM version	2023-08-30 11:39:37 +02:00
Gerhard Hoffmann	5427844977	For each customer repository change the file ChangeLog in branch master as last step. The git commit for this file will be used as output, so this file has always be the last to be checked in.	2023-08-30 11:36:28 +02:00
Gerhard Hoffmann	a45e552d90	set version to 1.2.0	2023-08-25 08:46:29 +02:00
Gerhard Hoffmann	be28570d23	Minor change for output in status bar.	2023-08-23 16:27:47 +02:00
Gerhard Hoffmann	1509e8619c	Send message to ISMAS when rsyncing a traiff-file	2023-08-23 16:26:55 +02:00
Gerhard Hoffmann	a8df026a80	Added rsyncFile() method.	2023-08-23 16:26:11 +02:00