Merge branch 'master' of git.mimbach49.de:GerhardHoffmann/UpdatePTUDevCtrl

This commit is contained in:
Siegfried Siegert 2023-12-08 13:01:03 +01:00
commit 33d45eab2e
Signed by: SiegfriedSiegert
GPG Key ID: 68371E015E8F0B03
59 changed files with 6854 additions and 19808 deletions

18
ATBUpdateTool.ini Normal file
View File

@ -0,0 +1,18 @@
[REPOSITORY_URL]
repository-url="https://git.mimbach49.de/GerhardHoffmann"
[DIRECTORIES]
plugin-directory="/usr/lib/"
working-directory="/opt/app/tools/atbupdate/"
[PLUGINS]
plugin-name="libCAslave.so"
[FLAGS]
no-psa-hardware-update=false
dry-run=false
extended-version=false
yocto-version=false
yocto-install=false
always-download-config=false
always-download-dc=false

41
DCPlugin/.gitignore vendored
View File

@ -1,41 +0,0 @@
# C++ objects and libs
*.slo
*.lo
*.o
*.a
*.la
*.lai
*.so
*.dll
*.dylib
# Qt-es
*.pro.user
*.pro.user.*
moc_*.cpp
qrc_*.cpp
Makefile
Makefile.*
*-build-*
#
*.autosave
ui_*.h
version.h
version.txt
packages/*
*.pro.orig
Output/setup.exe
.directory
*~
resources/icons/*.png
resources/icons/*.jpg
resources/icons/*.gif
resources/style/*.qss
text/*.html
!text/*_template.html
text/*.xml

View File

@ -1,25 +0,0 @@
INCLUDEPATH += $${PWD}/include
DEPENDPATH += $${PWD}
HEADERS += $${PWD}/include/com.h \
$${PWD}/include/controlBus.h \
$${PWD}/include/datIf.h \
$${PWD}/include/dcBL.h \
$${PWD}/include/hwapi.h \
$${PWD}/include/interfaces.h \
$${PWD}/include/prot.h \
$${PWD}/include/sendWRcmd.h \
$${PWD}/include/storeINdata.h \
$${PWD}/include/tslib.h \
$${PWD}/include/shared_mem_buffer.h
SOURCES += $${PWD}/src/com.cpp \
$${PWD}/src/controlBus.cpp \
$${PWD}/src/datIf.cpp \
$${PWD}/src/dcBL.cpp \
$${PWD}/src/hwapi.cpp \
$${PWD}/src/prot.cpp \
$${PWD}/src/sendWRcmd.cpp \
$${PWD}/src/storeINdata.cpp \
$${PWD}/src/tslib.cpp \
$${PWD}/src/shared_mem_buffer.cpp

View File

@ -1,94 +0,0 @@
TEMPLATE = lib
CONFIG += plugin
#CONFIG += c++11 console
#CONFIG -= app_bundle
#QT += widgets
QT -= gui
QT += widgets serialport
INCLUDEPATH += $${PWD}/plugins
INCLUDEPATH += $${PWD}/include
QMAKE_CXXFLAGS += -Wno-deprecated-copy
# default
ARCH = PTU5
include(DCPlugin.pri)
contains( CONFIG, DesktopLinux ) {
QMAKE_CC = ccache $$QMAKE_CC
QMAKE_CXX = ccache $$QMAKE_CXX
QMAKE_CXXFLAGS += -std=c++11
# QMAKE_CXXFLAGS += -Wno-deprecated-ctor
linux-clang { QMAKE_CXXFLAGS += -Qunused-arguments }
ARCH = DesktopLinux
}
contains( CONFIG, PTU5 ) {
# QMAKE_CC = ccache $$QMAKE_CC
# QMAKE_CXX = ccache $$QMAKE_CXX
QMAKE_CXXFLAGS += -std=c++11
linux-clang { QMAKE_CXXFLAGS += -Qunused-arguments }
CONFIG += link_pkgconfig
ARCH = PTU5
}
contains( CONFIG, PTU5_YOCTO ) {
greaterThan(QT_MAJOR_VERSION, 4): QT += serialport
PTU5BASEPATH = /opt/devel/ptu5
ARCH = PTU5
# add qmqtt lib
#LIBS += -lQt5Qmqtt
}
TARGET = ATBDeviceControllerPlugin
#DESTDIR = ../plugins
INTERFACE = DeviceController
INTERFACE_DEFINITION = $${PWD}/include/ATBAPP/DeviceControllerInterface.h
DEFINES += DEVICECONTROLLERPLUGIN_LIBRARY
# The following define makes your compiler emit warnings if you use
# any Qt feature that has been marked deprecated (the exact warnings
# depend on your compiler). Please consult the documentation of the
# deprecated API in order to know how to port your code away from it.
DEFINES += QT_DEPRECATED_WARNINGS
# You can also make your code fail to compile if it uses deprecated APIs.
# 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
# Default rules for deployment.
#qnx: target.path = /tmp/$${TARGET}/bin
#else: unix:!android: target.path = /opt/$${TARGET}/bin
#!isEmpty(target.path): INSTALLS += target
# ATBAPP interface
HEADERS += \
src/ATBAPP/ATBAPPplugin.h \
src/ATBAPP/DeviceControllerInterface.h \
src/ATBAPP/ATBHealthEvent.h \
src/ATBAPP/ATBDeviceControllerPlugin.h
SOURCES += \
src/ATBAPP/ATBHealthEvent.cpp \
src/ATBAPP/ATBDeviceControllerPlugin.cpp
DISTFILES += \
generate-version.sh
# Define how to create version.h
VERSION_H = $$PWD/include/version.h
version.output = $$PWD/include/version.h
version.commands = $$PWD/generate-version.sh $${ARCH} $${TARGET} $${INTERFACE} $${INTERFACE_DEFINITION} $${VERSION_H}
version.depends = FORCE
version.input = VERSION_H
version.variable_out = HEADERS
QMAKE_EXTRA_COMPILERS += version
QMAKE_CLEAN += $${PWD}/include/version.h

View File

View File

@ -1,155 +0,0 @@
#!/bin/bash
VERSION_STRING=""
#GIT='/cygdrive/c/Program Files \(x86\)/Git/bin/git'
GIT=git
parse_git_branch () {
$GIT branch --no-color 2> /dev/null | sed -e '/^[^*]/d' -e "s/* \(.*\)/\1/"
}
ARCH=$1
TARGET=$2
INTERFACE=$3
INTERFACE_DEFINITION=$4
VERSION_H=$5
SCRIPT=$(readlink -f $0)
SCRIPTPATH=`dirname $SCRIPT`
OUTPUTDIR=$(pwd)
echo " current dir is : " $(pwd)
echo $SCRIPT
echo $SCRIPTPATH
echo "changing dir to script path: " $SCRIPTPATH
cd $SCRIPTPATH
# set version string ##################################################################
if [ -z $VERSION_STRING ] ; then
VERSION_STRING=$(date +%Y%m%d_%H%M)
fi
GIT_DESCRIBE=$($GIT describe)
GIT_BRANCH=$(parse_git_branch)
# extract path from branchname:
IFS='_' read -ra TMP_ARRAY <<< "${GIT_BRANCH}"
BRANCH_PATH=${TMP_ARRAY[0]}
# detect if we have a development version:
if [ ${#TMP_ARRAY[1]} -gt 0 ] ; then
DEV_SUFFIX="_dev"
else
DEV_SUFFIX=""
fi
# detect if git status is dirty
GIT_DESCRIBE_DIRTY=$($GIT describe --dirty)
if [ "${GIT_DESCRIBE_DIRTY:(-6)}" == "-dirty" ] ; then
DIRTY_SUFFIX="_dirty"
else
DIRTY_SUFFIX=""
fi
if [ -n "$DIRTY_SUFFIX" ] || [ -n "$DEV_SUFFIX" ] ; then
DEVDIRTY=true
else
DEVDIRTY=false
fi
# extract interface definition
#
#Q_DECLARE_INTERFACE(CCInterface,
# "eu.atb.ptu.plugin.CCInterface/2.9.0")
# -> extract whole string within quotation marks
INTERFACE_VERSION=$(grep 'eu.atb.ptu.plugin.' ${INTERFACE_DEFINITION})
# get string within quotes:
INTERFACE_VERSION=`echo ${INTERFACE_VERSION} | awk -F \" '{print $2}'`
#
# write version.h
echo " TARGET is: $TARGET"
echo " ARCH is: $ARCH"
echo " "
echo " PluginName: $TARGET"
echo " Interface: $INTERFACE"
echo " InterfaceVersion: $INTERFACE_VERSION"
echo " "
echo " new version is: $VERSION_STRING"
echo " git describe is: $GIT_DESCRIBE"
echo " git branch is: $GIT_BRANCH"
echo " branch-path is: $BRANCH_PATH"
echo " "
echo " dev suffix: $DEV_SUFFIX"
echo " dirty suffix: $DIRTY_SUFFIX"
PLUGIN_VERSION=${VERSION_STRING}
#ATB_QT_GIT_DESCRIBE=${GIT_DESCRIBE}_${GIT_BRANCH}
PLUGIN_GIT_DESCRIBE=${GIT_DESCRIBE}_${BRANCH_PATH}${DEV_SUFFIX}${DIRTY_SUFFIX}
#TARGET=IngenicoZVT_CCPlugin
# build version.h #####################################################################
echo " building new version info (version.h) ..."
echo "#ifndef VERSION_H" > ${VERSION_H}
echo "#define VERSION_H" >> ${VERSION_H}
echo "" >> ${VERSION_H}
echo "" >> ${VERSION_H}
echo "#define INTERFACE_VERSION \"${INTERFACE_VERSION}\"" >> ${VERSION_H}
echo "#define PLUGIN_VERSION \"${PLUGIN_VERSION}\"" >> ${VERSION_H}
echo "" >> ${VERSION_H}
echo "#define PLUGIN_GIT_DESCRIBE \"${PLUGIN_GIT_DESCRIBE}\"" >> ${VERSION_H}
echo "" >> ${VERSION_H}
echo "" >> ${VERSION_H}
cat <<EOT >> ${VERSION_H}
const std::string pluginInfoString = R"(
{
"Interface": "${INTERFACE}",
"InterfaceVersion": "${INTERFACE_VERSION}",
"PluginName": "${TARGET}",
"Version": "${PLUGIN_VERSION}",
"git-describe": "${PLUGIN_GIT_DESCRIBE}",
}
)";
EOT
echo "" >> ${VERSION_H}
echo "" >> ${VERSION_H}
if [ ${DEVDIRTY} == "true" ] ; then
echo "#define DEVDIRTY" >> ${VERSION_H}
echo "" >> ${VERSION_H}
echo "" >> ${VERSION_H}
fi
echo "#define SYSTEM_ARCH \"${ARCH}\"" >> ${VERSION_H}
echo "#define ARCH_${ARCH}" >> ${VERSION_H}
echo "" >> ${VERSION_H}
echo "" >> ${VERSION_H}
echo "#endif //VERSION_H" >> ${VERSION_H}

View File

@ -1,105 +0,0 @@
//CAT is always master, no receive before request
#ifndef SER_H
#define SER_H
#include <stdint.h>
#include <QMainWindow>
#include <QString>
#include <QTimer>
#include <QSerialPort>
#include "tslib.h"
#include "controlBus.h"
#define MAXTELEGRAMLEN 90
// display all inputs and outputs in output window:
//#define PRINTALLDEBUGS 1
class T_com : public QMainWindow //, public QPlainTextEdit
{
Q_OBJECT
// complete send message (protocol frame)
QByteArray sendBuffer; //[MAXTELEGRAMLEN];
uint16_t sendLen; // >0: Daten Sendebereit, nach senden wieder auf 0 setzen
// right after reception:
QByteArray rawInput; //[MAXTELEGRAMLEN];
uint16_t rawInLen; // 0: keine neuen Daten erhalten
// QSerialPort *CatSerial = nullptr;
QSerialPort *CatSerial;
//char oeffneSerialPort();
char open_Serial_Port();
void closeSerialPort();
void receiveByLength(void);
private slots:
void readSomeBytes(void);
void serialSendComplete(void);
//void incomingWake(void); //bool LevelOfTheBit);
void receiveTO(void);
void ser_ISR100ms();
public:
T_com(QWidget *parent = nullptr);
~T_com();
QTimer *serRecTime;
bool isPortOpen(void);
void writeToSerial(const QByteArray &data, uint16_t sendLength);
void receiveFixLen(int64_t nrOfbytesToReceive);
bool readFromSerial(QByteArray &data, uint16_t &sendLength);
// retval: true: data available
/*
uint8_t getAllPortPins(void);
// rs232pins: all signals bitwise coded in one byte:
// readback output: bit 0=TxD(=output) bit2=DTR (=output) bit 6=RTS (=output)
// unused inputs: bit1=RxD bit 3=DCD bit 5 = RING
// handshake inputs: bit 4=DSR (0x10) bit 7=CTS (0x80)
bool getHSin_CTS(void);
// return the CTS Handshake input): true= high level (+8V)
bool getHSin_DSR(void);
// return the DSR Handshake input): true= high level (+8V)
bool setHSout_RTS(bool hsout);
// hsout true=positiv voltage +12V false= -12V
// retval: true=setting OK
bool setHSout_DTR(bool hsout);
// hsout true=positiv voltage +12V false= -12V
// retval: true=setting OK
*/
signals:
void receivingFinished();
void sendingFinished();
//void wasWokenBySerialHandshake();
};
#endif // SER_H

View File

@ -1,194 +0,0 @@
#ifndef CONTROLBUS_H
#define CONTROLBUS_H
#include <stdint.h>
#include "tslib.h"
#include <QString>
// ///////////////////////////////////////////////////////////////////////////////////
// control serial interface gui <--> serial
// ///////////////////////////////////////////////////////////////////////////////////
void epi_setSerial(int BaudNr, QString BaudStr, QString ComName, uint8_t connect);
// Actions: open serial port with parameters
void epi_closeSerial(void);
// Actions: close serial port
// Actions, GUI Buttons -> API, start cyclic transmission
void epi_startEmmision(char start); // 1: start sending activated
//void epi_setPeriodicSendTimeVal(uint16_t val);
// Port -> API
void gpi_serialChanged(void);
// serial confirms that port was closed or opened
// Actions, API -> serialPort
uint8_t gpi_getSerialConn(void); // connect if 1, disconnect if 0
int gpi_getBaudNr(void);
QString gpi_getComPortName(void);
void gpi_serialIsOpen(bool offen);
bool epi_isSerialPortOpen();
// true: port is open false: port is closed
// Meldung von TabCom an Datif: starte zyklische Sendung:
bool gpi_isEmmisionOn(void);
//uint16_t gpi_getPeriodicSendTimeVal();
//bool gpi_PeriodicSendTimeHasChanged();
//void epi_setCurrSlavAddr(int slavAd);
//int gpi_getCurrSlavAddr(void);
// ///////////////////////////////////////////////////////////////////////////////////
// Status Display gui <--> serial
// ///////////////////////////////////////////////////////////////////////////////////
//---------------------
// Statuszeile COM Port (serial Port) (open, closed)
// Display in tab_com
QString epi_getTxt4comStateLine(void);
void epi_clrTxt4comStateLine();
// GUI: get Text for serial Comport-State Line
//---------------------
// Statuszeile Handshakes (serial Control) flow.cpp
// geht überhaupt was raus? kommt überhaupt was zurück?
// I
QString epi_getTxt4HsStateLine(void);
void epi_clrTxt4HsStateLine();
// GUI: get Text
// II Master receive state (empfangenes Telgramm OK? crc? length? )
// Statuszeile Auswertung der SlaveResponse (serial Frame, CRC usw) (prot.cpp)
QString epi_getTxt4masterStateLine(void);
void epi_clrTxt4masterStateLine();
// III Slave receive (from Master) OK? if then show results, if not then show errors
// entweder Empfangsfehler anzeigen (crc? length?) oder result OUT-OK, OUT_ERR, IN_OK, IN_ERR
// Hintergrund: wenn der Slave Fehler im Master-Telegramm gefunden hat, dann kann er es auch
// nicht verwenden und nichts ausgeben oder einlesen
QString epi_getTxt4resultStateLine(void);
void epi_clrTxt4resultStateLine();
// IV Statuszeile Sende- und Empfangsdaten (Datif)
// Display in tab_com
QString epi_getTxt4dataStateLine(void);
void epi_clrTxt4dataStateLine();
// GUI: get Text for serial Comport-State Line
// V, unten, Datif
QString epi_getTxt4datifLine(void);
void epi_clrTxt4datifLine();
//---------------------
// sende-empfangs-Rohdaten-Fenster
// Display in tab_com
QString epi_getTxt4RsDiagWin(void);
void epi_clrTxt4RsDiagWin();
QString epi_get2ndTxt4RsDiagWin(void);
void epi_clr2ndTxt4RsDiagWin();
// Statuszeile COM Port (serial Port) (open, closed)
// Display in tab_com
void gpi_setTxt4comStateLine(QString txtline);
// serial: write Text to be displayed in serial Comport-State line (like "connected")
// used in vcp.cpp, links in tabCom
// Statuszeile Handshakes (serial Control)
// I obere Zeile
void gpi_setTxt4HsStateLine(QString txtline);
// used in flow.cc
// II
void gpi_setTxt4masterStateLine(QString txtline);
// III
void gpi_setTxt4resultStateLine(QString txtline);
// IV
void gpi_setTxt4dataStateLine(QString txtline);
// serial: write Text to be displayed in serial Comport-State line (like "connected")
// used in prot.cpp
// V unten:
void gpi_setTxt4datifLine(QString txtline);
// sende-empfangs-Rohdaten-Fenster
// Display in tab_com
void gpi_setTxt4RsDiagWin(QString txtline);
void gpi_set2ndTxt4RsDiagWin(QString txtline);
// ///////////////////////////////////////////////////////////////////////////////////
// Memory for Slave responses, common data
// ///////////////////////////////////////////////////////////////////////////////////
bool epi_getResult_serialTestOK();
// retval: true: test was successful, got right response
// result of serial line test, slave sent fixed string
void gpi_storeResult_serialTestOK(bool wasOn);
// ///////////////////////////////////////////////////////////////////////////////////
// restore just received data
// ///////////////////////////////////////////////////////////////////////////////////
uint8_t gpi_startNewRequest();
// called by Datif
uint8_t gpi_storeResultOfLastRequest(bool answisok);
// written by Datif
uint8_t epi_getResultOfLastRequest();
// retval: 0: in progress 1: OK 2: error
void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t const *receivedData);
// stored by Datif
uint16_t epi_getLastPayLoad(uint16_t plBufSiz, uint8_t *payLoad);
// get data back in *pl, max 64 byte
// retval = nr of bytes received. If host buffer too small then
// only plBufSíz bytes are copied to pl
// plBufSíz=size of host buffer
#endif

View File

@ -1,341 +0,0 @@
// Data Interface between slave (DC) and pi buffer
// determines sending and receiving order of data
// cares for storing input data and restoring output data
#ifndef DIF_H
#define DIF_H
#include <stdint.h>
#include "tslib.h"
#include "prot.h"
#include "dcBL.h"
#include <QMainWindow>
#include <QString>
#include <QTimer>
#include <QDebug>
#include <QDateTime>
#include <QDate>
#include <QTime>
#define CMD2DC_sendTime 20
#define CMD2DC_setWakeFrequ 112
#define CMD2DC_MOV_UPLOCK 113
#define CMD2DC_MOV_DNLOCK 114
#define CMD2DC_UPPER_DOOR 115
#define CMD2DC_LOWER_DOOR 116
#define CMD2DC_VAULT_DOOR 117
#define CMD2DC_REJMOT_ON 118
#define CMD2DC_REJMOT_RUN 119
#define CMD2DC_LED_COIN 100
#define CMD2DC_LED_ILLU 101
#define CMD2DC_LED_TICKET 102
#define CMD2DC_LED_START 104
#define CMD2DC_LED_PIN 103
#define CMD2DC_LED_IN 105
#define CMD2DC_FAN 106
#define CMD2DC_SIREN 107
#define CMD2DC_BARRIER 108
#define CMD2DC_WAKEPTU 109
#define CMD2DC_SWITCHAUXPWR 110
#define CMD2DC_SWITCHAUXDDR 18
#define CMD2DC_SWITCHAUXOUT 19
#define CMD2DC_UCONTACTON 111
#define CMD2DC_DEVICE_PARAM 23
#define CMD2DC_SEND_MACH_ID 11
#define CMD2DC_RDBK_DEV_PARA 14
#define CMD2DC_RDBK_MACH_ID 15
#define CMD2DC_MDB_ON 120
#define CMD2DC_MDB_GET_STATE 107 // REQ
#define CMD2DC_MDB_DORESET 121
#define CMD2DC_MDB_SETWAK 122
//#define CMD2DC_MDB_GETWAK 0x2812 // REQ not nec.
#define CMD2DC_MDB_SENDCMD 123
#define CMD2DC_MDB_SENDMSG 12
#define CMD2DC_MDB_GETRESP 22 // REQ
#define CMD2DC_EMP_SET 24
#define CMD2DC_EMP_GET_ALL 23 // REQ
#define CMD2DC_EMP_STARTPOLL 124
#define CMD2DC_EMP_STARTPAY 125
#define CMD2DC_EMP_STOPPAY 126
#define CMD2DC_EMP_GOTCOIN 108 // REQ
#define CMD2DC_SHUTTER_OPEN 129
#define CMD2DC_ESCR_OPEN 132
#define CMD2DC_ESCR_TAKE 133
#define CMD2DC_ESCR_RETURN 134
#define CMD2DC_MOD_ON 135
#define CMD2DC_MOD_WAK 136
#define CMD2DC_CRED_ON 137
#define CMD2DC_CRED_WAK 138
// READ Commands ((e.g. get input)
#define CMD2DC_TestSerial 10
#define CMD2DC_GetSerialConfig 105
#define CMD2DC_RdBkHWversion 11
#define CMD2DC_RdBkSWversion 12
#define CMD2DC_RdBkDCstate 101
#define CMD2DC_RdBkUID 18
#define CMD2DC_RdBkTime 104
#define CMD2DC_RdBkAnalog 106
#define CMD2DC_GetAllInputs 102
#define CMD2DC_RdBkAllOutputs 103
#define CMD2DC_MIFREADERON 127
#define CMD2DC_ATB_CREATE 128
// Mif read data:
#define CMD2DC_RdBk_MifState 109
#define CMD2DC_RdBk_MifData 24
#define CMD2DC_RdBk_AtbCardType 25
#define CMD2DC_SHUTTER_COIN 131
#define CMD2DC_SHUTTER_OPEN3S 130
#define CMD2DC_SEND_SHUT_TIME 0x2915
#define CMD2DC_ESCR_TAKE 133
#define CMD2DC_ESCR_RETURN 134
#define CMD2DC_PRINTERON 139
#define CMD2DC_RdBk_PrnState 110
#define CMD2DC_RdBk_PrnFonts 26
#define CMD2DC_RdBk_AllPrnData 27
// nr of params:
#define CMD2DC_PRI_SYS_CMD 25 // 3
#define CMD2DC_PRI_ESC_CMD 26 // 4
#define CMD2DC_PRI_SETUP 27 // 5
#define CMD2DC_PRI_MOVE 140 // 2
#define CMD2DC_PRI_SETFONT 141 // 4
#define CMD2DC_PRI_SETLETTER 142 // 3
#define CMD2DC_PRI_CUT 143 // 1
#define CMD2DC_PRI_PRINT_TXT 13 // 64
#define CMD2DC_PRI_LF 144 // 1
#define CMD2DC_PRI_PRIFONTTABLE 145
#define CMD2DC_PRI_BARCODE 14 // ca 15...25
#define CMD2DC_STOR_QR_DATA 15 // 150
#define CMD2DC_PRI_QR_CODE 146 // 0
#define CMD2DC_PRI_LOGOFROMFLASH 147 // 2
#define CMD2DC_PRI_STORE_DOC 16 // 1
#define CMD2DC_PRI_DOCUMENT_NR 17 // 1 + 64
#define CMD2DC_PRI_CLEAR_DOC 148 // 1
/*
// WRITE Commands (e.g. switch relay)
#define CMD2DC_sendTime 0x1310
#define CMD2DC_setWakeFrequ 0x1320
#define CMD2DC_MOV_UPLOCK 0x1801
#define CMD2DC_MOV_DNLOCK 0x1802
#define CMD2DC_UPPER_DOOR 0x1810
#define CMD2DC_LOWER_DOOR 0x1811
#define CMD2DC_VAULT_DOOR 0x1812
// neu 7.10.21:
#define CMD2DC_REJMOT_ON 0x1813
#define CMD2DC_REJMOT_RUN 0x1814
#define CMD2DC_LED_COIN 0x1204
#define CMD2DC_LED_ILLU 0x1205
#define CMD2DC_LED_TICKET 0x1206
#define CMD2DC_LED_START 0x1208
#define CMD2DC_LED_PIN 0x1207
#define CMD2DC_LED_IN 0x1209
#define CMD2DC_FAN 0x1210
#define CMD2DC_SIREN 0x1211
#define CMD2DC_BARRIER 0x1212
#define CMD2DC_WAKEPTU 0x1218
#define CMD2DC_SWITCHAUXPWR 0x1220
#define CMD2DC_SWITCHAUXDDR 0x1222
#define CMD2DC_SWITCHAUXOUT 0x1224
#define CMD2DC_UCONTACTON 0x1226
#define CMD2DC_DEVICE_PARAM 0x2000
#define CMD2DC_SEND_MACH_ID 0x2002
#define CMD2DC_RDBK_DEV_PARA 0x2001
#define CMD2DC_RDBK_MACH_ID 0x2003
// --------------------------- MDB --------------
#define CMD2DC_MDB_ON 0x2800
#define CMD2DC_MDB_GET_STATE 0x2801 // REQ
#define CMD2DC_MDB_DORESET 0x2802
#define CMD2DC_MDB_SETWAK 0x2811
//#define CMD2DC_MDB_GETWAK 0x2812 // REQ not nec.
#define CMD2DC_MDB_SENDCMD 0x2820
#define CMD2DC_MDB_SENDMSG 0x2821
#define CMD2DC_MDB_GETRESP 0x2822 // REQ
// --------------------------- EMP --------------
#define CMD2DC_EMP_SET 0x2830
#define CMD2DC_EMP_GET_ALL 0x2831 // REQ
#define CMD2DC_EMP_STARTPOLL 0x2832
#define CMD2DC_EMP_STARTPAY 0x2834
#define CMD2DC_EMP_STOPPAY 0x2836
#define CMD2DC_EMP_GOTCOIN 0x2837 // REQ
#define CMD2DC_SHUTTER_OPEN 0x2911
#define CMD2DC_ESCR_OPEN 0x2920
#define CMD2DC_ESCR_TAKE 0x2921
#define CMD2DC_ESCR_RETURN 0x2922
#define CMD2DC_MOD_ON 0x2940
#define CMD2DC_MOD_WAK 0x2941
#define CMD2DC_CRED_ON 0x2960
#define CMD2DC_CRED_WAK 0x2961
// READ Commands ((e.g. get input)
#define CMD2DC_TestSerial 0x1101
#define CMD2DC_GetSerialConfig 0x1107
#define CMD2DC_RdBkHWversion 0x110A
#define CMD2DC_RdBkSWversion 0x110B
#define CMD2DC_RdBkDCstate 0x110C
#define CMD2DC_RdBkUID 0x1305
#define CMD2DC_RdBkTime 0x1313
#define CMD2DC_RdBkAnalog 0x1550
#define CMD2DC_GetAllInputs 0x1201
#define CMD2DC_RdBkAllOutputs 0x1202
#define CMD2DC_MIFREADERON 0x2900
#define CMD2DC_ATB_CREATE 0x2907
// Mif read data:
#define CMD2DC_RdBk_MifState 0x2902
#define CMD2DC_RdBk_MifData 0x2903
#define CMD2DC_RdBk_AtbCardType 0x2905
//#define CMD2DC_RdBk_CardData 0x2906
// higher Level operation commands
//#define CMD2DC_SHUTTER_ONE 0x2912
#define CMD2DC_SHUTTER_COIN 0x2913
#define CMD2DC_SHUTTER_OPEN3S 0x2912
#define CMD2DC_SEND_SHUT_TIME 0x2915
#define CMD2DC_ESCR_TAKE 0x2921
#define CMD2DC_ESCR_RETURN 0x2922
#define CMD2DC_PRINTERON 0x2A01
#define CMD2DC_RdBk_PrnState 0x2A02
#define CMD2DC_RdBk_PrnFonts 0x2A12
#define CMD2DC_RdBk_AllPrnData 0x2A40
// nr of params:
#define CMD2DC_PRI_SYS_CMD 0x2A03 // 3
#define CMD2DC_PRI_ESC_CMD 0x2A04 // 4
#define CMD2DC_PRI_SETUP 0x2A05 // 5
#define CMD2DC_PRI_MOVE 0x2A06 // 2
#define CMD2DC_PRI_SETFONT 0x2A10 // 4
#define CMD2DC_PRI_SETLETTER 0x2A11 // 3
#define CMD2DC_PRI_CUT 0x2A13 // 1
#define CMD2DC_PRI_PRINT_TXT 0x2A14 // 64
#define CMD2DC_PRI_LF 0x2A15 // 1
#define CMD2DC_PRI_PRIFONTTABLE 0x2A16
#define CMD2DC_PRI_BARCODE 0x2A17 // ca 15...25
#define CMD2DC_STOR_QR_DATA 0x2A18 // 150
#define CMD2DC_PRI_QR_CODE 0x2A19 // 0
#define CMD2DC_PRI_LOGOFROMFLASH 0x2A1A // 2
#define CMD2DC_PRI_STORE_DOC 0x2A41 // 1
#define CMD2DC_PRI_DOCUMENT_NR 0x2A42 // 1 + 64
#define CMD2DC_PRI_CLEAR_DOC 0x2A43 // 1
*/
#define FIX_SLAVE_ADDR 0
#define SEND_ATONCE 1
#define SENDCOMBINED 0
class T_datif : public QMainWindow
{
Q_OBJECT
char sendINrequestsAutomatic(void);
// sende alle Befehle um die Eingangsdaten abzufragen der Reihe nach
char loadRecDataFromFrame();
void datif_startSending(void);
void datif_sendIOrequest(uint16_t WRcmd, uint16_t RDcmd, uint8_t nrOfWrData);
void datif_send8byteOutCmd(uint16_t WRcmd, uint16_t RDcmd);
bool verifyLineTestresponse(uint8_t RdDlen, uint8_t *receivedData);
void datif_OUT_setTime(void);
uint8_t datif_OUT_SendRandomData(uint8_t *buf, uint8_t Length);
void datif_send64byteOutCmd(uint16_t WRcmd, uint16_t addr, uint16_t RDcmd);
void datif_sendToMemory(uint16_t WRcmd, uint16_t docNr, uint16_t blockNr, uint8_t *data64);
// send printer documents to DC2 memory
// docNr: 0...15(31) with 1280 byte each (20 blocks a 64byte)
// blockNr=0...19 with 64byte each
// docNr =transmitted in WRITEADDRESS high byte
// blockNr=transmitted in WRITEADDRESS low byte
T_prot *myDCIF;
QTimer *datif_trigger;
uint8_t selectedSlaveAddr;
private slots:
char datif_cycleSend();
void StoredRecData();
public:
T_datif(QWidget *parent = nullptr);
T_prot *getProt() { return myDCIF; }
T_prot const *getProt() const { return myDCIF; }
void resetChain(void);
char isPortOpen(void);
void sendWRcommand(uint16_t nxtAsCmd);
// Sende Schreibbefehle die bereits vorher asynchron gespeichert wurden
void send_requests(uint16_t nextWrCmd);
void sendHighLevel(uint16_t nxtHLCmd);
bool areDataValid(void);
signals:
void ResponseRecieved();
//the requested data are stored in peripheral image
// can be loaded with epi
void datif_templatePrintFinished_OK();
void datif_templatePrintFinished_Err();
void datif_gotNewCoin();
};
#endif // CI_H

View File

@ -1,102 +0,0 @@
#ifndef DCBL_H
#define DCBL_H
#include <stdint.h>
#include "qbytearray.h"
#include "qstring.h"
#include <QFile>
uint8_t dcBL_prepareDC_BLcmd(uint8_t Cmd, uint8_t SendDataLength, uint8_t *sendData, uint8_t *outBuf);
// make BL protocol, retval = outbuf length (5...133)
// bring data in correct form: start always with 0x02 finish with 0x03 and append checksum
// 0x02 Cmd < ...sendData ..> CRC CRC 0x03
// Data length = 0...64
// special conversion: if data contain 2 or 3 (STX, ETX) then write two bytes: 0x1B (=ESC) and data|0x80
// so maxlength = 5 + 2 x 64 (if all data are 2 or 3) without 2,3: maxlength = 5 + 64
uint8_t dcBL_readBLversion(uint8_t *sendData);
// minimum size of sendData-buffer: 5byte retval: length
uint8_t dcBL_readFWversion(uint8_t *sendData);
// minimum size of sendData-buffer: 5byte retval: length
uint8_t dcBL_exitBL(uint8_t *sendData);
// minimum size of sendData-buffer: 5byte retval: length
uint8_t dcBL_sendFlashStartAddr2BL(uint32_t startAddr, uint8_t *sendData);
// minimum size of sendData-buffer: 13byte retval: length (9...13)
uint8_t dcBL_writeLastPage(uint8_t *sendData);
// minimum size of sendData-buffer: 5byte retval: length
uint8_t dcBL_restartDC(uint8_t *sendData);
// minimum size of sendData-buffer: 20 byte retval: length
uint8_t dcBL_activatBootloader(uint8_t *sendData);
// minimum size of sendData-buffer: 20 byte retval: length
uint8_t dcBL_getResponse(uint8_t *respBuff);
// retval: nr of received bytes
bool dcBL_responseOK();
// retval: 0: response OK (cmd |0x80) 1: response error (cmd or "0xe0")
bool dcBL_importBinFile(QByteArray readBinFile, uint32_t fileSize, char withDispl);
bool dcBL_isTextMemFree(void);
void dcBL_writeText(QString newTxt);
bool dcBL_checkForText(void);
// if pointer at 0 then no more content
QString dcBL_readText(void);
// read from 0...9 (oldest first)
void dcBL_iniChain(void);
uint8_t dcBL_startChain(void);
uint8_t dcBL_runChain(void);
void dcBL_iniLoading(void);
void dcBL_startLoading(void);
uint8_t dcBL_sendHexfile(void);
uint8_t dcBL_getResult(void);
// call after every step to what's going on....
// 1: connected to BL
// 2: transmission started
// 3: transmission successful
#define RAW_BL_DATALEN 150
void gpi_storeRawReceivedData(uint8_t RdDlen, uint8_t *receivedData);
uint8_t epi_getRawReceivedData(uint8_t *receivedData);
// retval=length, will be zeroed after first reading
uint8_t epi_getRawRecLength(void);
// retval=length
QString epi_getRawReceivedString();
void epi_clrRawReceivedString();
uint8_t dcBL_sendSuccess(uint8_t lastCommand);
// return val: 0: no response by now 1:error 10: OK
// lastCommand=0x21 for sendAddr or 0x22 for send data
char dcBL_loadBinary(char withDisplay);
#endif // DCBL_H

View File

@ -1,35 +0,0 @@
#ifndef hwchk_H
#define hwchk_H
#include <stdint.h>
#include <QTabWidget>
#include <QObject>
#include "interfaces.h"
//#include "datIf.h"
#include <QDebug>
#include <QSharedMemory>
#include "hwapi.h"
//class QSharedMemory;
class hwChk : public QObject,
public hwinf
{
Q_OBJECT
// Q_PLUGIN_METADATA(IID "Atb.Psa2020.software.HWapi/1.0" ) //FILE "HWapi.json")
// Q_INTERFACES(hwinf)
//private:
// QSharedMemory *m_sharedMem;
public:
explicit hwChk(QWidget *parent = nullptr);
virtual ~hwChk();
public:
hwinf *HWaccess;
};
#endif

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,129 +0,0 @@
#ifndef SERIAL_FRAME_H
#define SERIAL_FRAME_H
#include <stdint.h>
#include <QMainWindow>
#include <QString>
#include <QTimer>
#include "tslib.h"
#include "com.h"
/*
get's OUT-data from datif,
get's IN-data from datif
get's send command from datif
makes frame and calls: isSerialFree(), setSendData(),
if not free retrigger datif sending period (normally 500ms or 50ms for direct cmds)
with control-signal: gotReceiveData():
getRecData();
send results to diag window/line
send IN-data to datif
*/
#define FRAME_DATALEN 64
#define FRAME_MAXLEN FRAME_DATALEN+20
#define BL_DATA_LEN 150
#define DATALEN_SEND_FAST 4
#define DATALEN_SEND_LONG 64
#define HEADERLEN_SEND 4
#define TELEGRAMLEN_SEND_FAST 12
#define TELEGRAMLEN_SEND_LONG 70
#define STARTSIGN_SEND_FAST 0x3F
#define STARTSIGN_SEND_LONG 0x3D
#define DATALEN_RECEIVE_FAST 8
#define DATALEN_RECEIVE_LONG 64
#define HEADERLEN_RECEIVE 2
#define TELEGRAMLEN_RECEIVE_FAST 12
#define TELEGRAMLEN_RECEIVE_LONG 68
#define STARTSIGN_RECEIVE_FAST 0x5F
#define STARTSIGN_RECEIVE_LONG 0x5D
class T_prot : public QMainWindow
{
Q_OBJECT
// Dateneingang von Datif:
uint8_t SendDataValid; // bit1: WR OK bit 2: RD OK
uint16_t slaveAddr;
uint16_t WriteCommand;
uint16_t WriteAddr;
uint8_t WrDataLength;
uint8_t ui8OutputData[FRAME_DATALEN];
char chOut_Data[FRAME_DATALEN];
uint8_t kindOfData; // 0: binaries, 1:text
uint16_t ReadCommand;
uint16_t ReadAddr;
uint16_t reserve;
// Ausgangs-Daten, werden vom Datif geholt:
// nur wenn CommandState und readState OK
uint8_t RecSlaveAddr;
bool INdataValid; // nur true wenn CommandState OK und readState OK
uint16_t readSource; // diese (Eingangs-)Daten stehen im Puffer
uint16_t readAddress; // von dieser Adr wurden die Daten gelesen
//uint8_t lastWakeSrc; // falls der Slave den Master geweckt hat
uint8_t RdDataLength;
uint8_t InputData[FRAME_DATALEN];
// 11.11.2020:
uint8_t BLsendDataLength;
uint8_t ui8BLsendData[BL_DATA_LEN];
T_com *mySerialPort;
void startPacking(void);
void startFastPacking(void);
uint8_t FramecheckInData(uint8_t *Inbuf, uint16_t LL);
uint8_t FastCheckInData(uint8_t *Inbuf, uint16_t LL);
uint8_t CheckInResult(uint8_t *Inbuf);
uint8_t ShowFastInData(uint8_t *recBuffer);
uint8_t ShowInData(uint8_t *recBuffer); // was CheckInData
void setRecLen(uint16_t WriteCmd);
private slots:
void analyseRecData(void);
public:
T_com *getSerialPort() { return mySerialPort; }
T_com const *getSerialPort() const { return mySerialPort; }
T_prot();
bool isPortOpen(void);
bool isSerialFree(void);
void setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr, uint8_t WrDatLen, uint8_t *data);
void setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr);
void setUserWriteData(uint16_t WriteCmd);
void setUserWriteText(uint16_t WriteCmd, uint16_t WrAddr, uint8_t WrDatLen, char *data);
void setUserWrite1DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val);
void setUserWrite2DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val0, uint8_t val1);
void setUserReadData( uint16_t ReadCmd, uint16_t RdAddr, uint16_t reserv);
void setUserReadData( uint16_t ReadCmd, uint16_t RdAddr);
void setUserReadData( uint16_t ReadCmd);
void setBLsendData( uint8_t len, uint8_t *buf);
void receiveFixLen(int64_t nrOfbytesToReceive);
void sendUserData(uint16_t slaveAdr);
bool ifDataReceived();
bool getReceivedInData(uint8_t *SlavAddr, uint16_t *readSrc, uint16_t *readAddr,
uint8_t *RdDlen, uint8_t *receivedData);
// retval: data valid, only one time true
signals:
void framerecieved(); //bool gotINdata);
void rawDataRecieved();
};
#endif // T_prot_H

View File

@ -1,250 +0,0 @@
#ifndef SENDWRCMDS_DEFS_H
#define SENDWRCMDS_DEFS_H
#include <stdint.h>
#include "tslib.h"
#include <QString>
// asynch. Commands
// store OUTPUT commands until time to send
// problem: OUT commands are set if a button is pressed or a transaction event happens
// so it's never synchron with sending grid
// but sending must apply the 100ms time grid as we have to wait for the response before sending the next command!!!
// Level 0 (DC direct)
#define SENDDIRCMD_TestSerial 1
#define SENDDIRCMD_MakeReset 2
#define SENDDIRCMD_setTime 3
#define SENDDIRCMD_setWakeFrequ 4
// Level 1 (DC DO's switching connected parts)
#define SENDDIRCMD_MOVEUP_LOCK 5
#define SENDDIRCMD_MOVEDN_LOCK 6
#define SENDDIRCMD_OPENUP_DOOR 7
#define SENDDIRCMD_OPENDN_DOOR 8
#define SENDDIRCMD_LEDILLU 9
#define SENDDIRCMD_LEDCOIN 10
#define SENDDIRCMD_LEDTICKET 11
#define SENDDIRCMD_LEDPAD 12
#define SENDDIRCMD_LEDSTART 13
#define SENDDIRCMD_LEDINSIDE 14
//#define SENDDIRCMD_LED_ALL 15
#define SENDDIRCMD_FAN 16
#define SENDDIRCMD_LAERM 17
#define SENDDIRCMD_REL1 18
#define SENDDIRCMD_WAKEPTU 20
#define SENDDIRCMD_AUXPWR 21
#define SENDDIRCMD_AUXDDR 22
#define SENDDIRCMD_AUXOUT 23
#define SENDDIRCMD_UCONTACT_ON 30
#define SENDDIRCMD_PRN2_SWONOFF 31
#define SENDDIRCMD_MIF_SWONOFF 32 // 0x2900
#define SENDDIRCMD_MIF_ATBCREATE 33 // 0x2907
#define SENDDIRCMD_MOD_SWONOFF 40
#define SENDDIRCMD_MOD_WAKE 41
#define SENDDIRCMD_MDB_POWER 42
#define SENDDIRCMD_MDB_WAKE 43
#define SENDDIRCMD_CRED_ON 44
#define SENDDIRCMD_CRED_WAKE 45
#define SENDDIRCMD_SHUT_MOV 50
#define SENDDIRCMD_ESCRO_MOV 51
#define SENDDIR_OPENVAULT 52
#define SENDDIR_REJMOT_ON 53
#define SENDDIR_REJMOT_RUN 54
// Level 2 (serial from DC to devices)
#define SEND_REQU_SERCONF 100
#define SEND_REQU_HWversion 101
#define SEND_REQU_SWversion 102
#define SEND_REQU_CONDITION 103
#define SEND_REQU_UID 104
#define SEND_REQU_TIME 105
// includes wake frequency
#define SEND_REQU_ANALOGS 110
#define SEND_REQU_DIG_INPUTS 111
#define SEND_REQU_DIG_OUTPUTS 112
#define SEND_REQU_PRN_STATE 120
#define SEND_REQU_PRN_FONTS 121
#define SEND_REQU_PRN_ALL 122
#define SEND_REQU_MIFSTATE 123
// Type and state of reader
#define SEND_REQU_MIFDATA 124
// Type, UID, Header of card
// read one card sector
// sectors must be addressed by RD_ADD
#define SEND_REQU_MIF_ATB_TYPE 125
#define SEND_REQU_MDB_GETSTAT 126
//#define SEND_REQU_MDB_GETWAK 127
#define SEND_REQU_MDB_GETRESP 128
#define SEND_REQU_EMP_GETALL 129
#define SEND_REQU_EMP_GETCOIN 130
#define SENDDIRCMD_DEVICE_PARA 131
#define SENDDIRCMD_MACHINE_ID 132
#define SEND_REQU_DEVICE_PARA 133
#define SEND_REQU_MACINE_ID 134
// further: mdb state, coinchecker state, bill state, modem state, credit_state....
#define SENDDIRCMD_SHUTOPENBYTIME 60
#define SENDDIRCMD_SHUTOPENBYCOIN 61
//#define SENDDIRCMD_SHUT_SENDTIME 62
#define SENDDIRCMD_ESCRO_TAKE 63
#define SENDDIRCMD_ESCRO_GIVE 64
#define SENDDIRCMD_PRN_SYS_CMD 70
#define SENDDIRCMD_PRN_ESC_CMD 71
#define SENDDIRCMD_PRN_SETUP 72
#define SENDDIRCMD_PRN_MOVE 73
#define SENDDIRCMD_PRN_SETFONT 74
#define SENDDIRCMD_PRN_SETLETT 75
#define SENDDIRCMD_PRN_CUT 76
//#define SENDDIRCMD_PRN_TXT // not needed
#define SENDDIRCMD_PRN_LF 78
#define SENDDIRCMD_PRN_FONTTAB 79
#define SENDDIRCMD_PRN_BC 80
#define SENDDIRCMD_PRN_QR 81
#define SENDDIRCMD_PRN_STOREDQR 82
#define SENDDIRCMD_PRN_LOGO_FL 83
//#define SENDDIRCMD_PRN_LOGO_GRAF 84
//#define SENDDIRCMD_PRN_LOGODAT 85
//#define SENDDIRCMD_PRN_STORBC 86
#define SENDDIRCMD_PRN_STORQR 87
#define SENDDIRCMD_PRN_DOC 88
#define SENDDIRCMD_PRN_CLEARDOC 89
//#define SENDDIRCMD_MDB_POWER 42
//#define SENDDIRCMD_MDB_WAKE 43
#define SENDDIRCMD_MDB_RES 90
#define SENDDIRCMD_MDB_SENDCMD 91
#define SENDDIRCMD_MDB_SNDMSG 92
#define SENDDIRCMD_EMP_SETT 93
#define SENDDIRCMD_EMP_POLL 94
#define SENDDIRCMD_EMP_STARPPAY 95
#define SENDDIRCMD_EMP_STOPPAY 96
// obsolete:
#define SENDDIRCMD_PRN1_SENDTEXT 54
#define SENDDIRCMD_PRN1_SENDCMD 55
#define SENDDIRCMD_PRN1_SERPAR 56
#define SENDDIRCMD_PRN_LEVEL2_4B 58
#define SENDDIRCMD_PRN_LEVEL2_64 59
// highest priority
#define CMDSTACKDEPTH 16
// means: up to 16 cmd can be stored. They are issued one by one every 100ms
void sendWRcmd_clrCmdStack(void);
bool sendWRcmd_setSendCommand0(uint16_t nextCmd);
// GUI or app sends a command to DC transfered by serial
uint16_t sendWRcmd_getSendCommand0(void);
// lower priority
#define CMD4STACKDEPTH 8
void sendWRcmd_clrCmd4Stack(void);
bool sendWRcmd_setSendCommand4(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4);
uint16_t sendWRcmd_getSendCommand4(uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4);
#define CMD8STACKDEPTH 4
void sendWRcmd_clrCmd8Stack(void);
bool sendWRcmd_setSendCommand8(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uint16_t dat3, uint32_t dat4);
uint16_t sendWRcmd_getSendCommand8(uint8_t *dat1, uint8_t *dat2, uint16_t *dat3, uint32_t *dat4);
// lowest priority
// wait for resonse before send next!
bool sendWRcmd_setSendBlock160(uint8_t leng, uint8_t *buf);
uint8_t sendWRcmd_getSendBlock160(uint8_t *leng, uint8_t *buf);
// retval = *leng
void sendWRcmd_INI(void);
uint8_t epi_store64ByteSendData(uint8_t length, uint8_t *buf);
// HWapi writes data to be forwarded to DC and further to mdb-device
// not batched! don't use twice within 100ms
uint8_t gpi_restore64ByteSendData(uint8_t *length, uint8_t *buf);
// datif reads data to forward to dc
// ONE printer doc consists of 20 x 64 byte
#define MAXNROF_PRNBYTES 64
#define MAXNROF_PRNBLOCKS 20
void epi_resetPrinterStack(void);
uint8_t epi_storePrnText(char *buf, uint8_t leng);
// store text and binary data from Gui in next higher free memory 0....9
uint8_t gpi_restorePrnText(uint8_t *retbuf);
// read printer text and send to slave, size of retbuf== 64
uint8_t gpi_chk4remainingText(void);
// retval: 0: no more textline left (to send) >0: nr of lines
void epi_storeUserOfSendingTextBuffer(uint8_t user, uint8_t para1, uint8_t para2, uint8_t para3, uint8_t para4 );
// user=1: Text-Print is using this buffer
// 2: QR-code-Printer is using this buffer
uint8_t gpi_getUserOfSendingTextBuffer(uint8_t *para1, uint8_t *para2, uint8_t *para3, uint8_t *para4);
// user=1: Text-Print is using this buffer
// 2: QR-code-Printer is using this buffer
#define FDCMD_STACKDEPTH 16
void sendFDcmd_clrStack(void);
bool sendFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4);
// write Command to memory, wait for transport
bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4);
uint8_t check4FDshortCmd(void);
// returns number of waiting command, maxFDCMD_STACKDEPTH
uint8_t check4freeFDshortCmd(void);
// returns number of free places in short-command stack
#define FDLONG_STACKDEPTH 16
void longFDcmd_clrStack(void);
bool longFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t length, uint8_t *data);
// write Command to memory, wait for transport
// data buffer size always 64! data[64], padded with 0
bool longFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *length, uint8_t *data);
uint8_t check4FDlongCmd(void);
// returns number of waiting command
uint8_t check4freeFDlongCmd(void);
// returns number of free places in long-command stack
uint8_t epi_store64BdevParameter(uint8_t length, uint8_t *buf);
// HWapi writes data to be stored
uint8_t epi_restore64BdevParameter(uint8_t *length, uint8_t *buf);
#endif

View File

@ -1,296 +0,0 @@
#ifndef SHARED_MEM_BUFFER_INCLUDED_H
#define SHARED_MEM_BUFFER_INCLUDED_H
#include <cinttypes>
#include <atomic>
#include <QSharedMemory>
struct SharedMemBuffer {
struct rs {
char comportName[16]; // z.B. "COM48"
char baudStr[16]; // z.B. "19200"
int baudNr; // 0...5 oder -1
uint8_t connect; // 0,1
bool portIsOpen;
} rs;
char AutoEmissionOn; // 1: zyklisch Anfragen zum Slave senden
struct datif {
uint16_t sendingPeriod;
bool sendingPer_changed;
} datif;
#if 0
// controlBus.cpp
char txt4comStateLine[32];
char txt4HsStateLine[32];
char txt4masterStateLine[32];
char txt4resultStateLine[32];
char txt4dataLine[32];
char txt4datifReceive[32];
char txt4diagWindow[32];
char sndTxt4diagWindow[32];
bool Sdata_serialTestResult[32];
uint8_t Sdata_pProtResultOk[32];
uint16_t Sdata_receivedDataLength[32];
uint8_t Sdata_receivedDataBlock[64];
// datif.cpp
uint8_t dif_dataStep;
uint8_t dif_scanStep;
uint8_t RDBLKNR;
uint8_t datif_OutCmdpara1;
uint8_t datif_OutCmdpara2;
uint8_t datif_OutCmdpara3;
uint8_t datif_OutCmdpara4;
uint16_t datif_OutCmdpara5;
uint32_t datif_OutCmdpara6;
uint8_t cycl_running;
// dcBL.cpp
uint8_t dcBL_LastBLcmd; // stored the last sent cmd in order to analys response
uint8_t dcBL_AtbBinFile[300000];
uint32_t dcBL_fileSize;
uint16_t dcBL_nrOfBlocks;
uint16_t dcBL_fileCrc;
uint8_t dcBL_myBuf[300000]; // same content like "dcBL_AtbBinFile" but bytewise
char BlResp[50][32];
uint8_t dcBL_step;
uint8_t dcBL_state;
uint16_t dcBL_BlkCtr;
uint16_t dcBL_cyclCtr;
uint16_t repeatCtr;
uint8_t Sdata_rawData[150];
uint8_t Sdata_LengthRawData;
// hwapi.cpp
uint16_t hwapi_shutterTime;
char ticketTemplate[1024];
// sendWRcmd.cpp
uint16_t nextAsynchsendCmd0[16];
uint8_t nrOfCmdsInQueue;
uint16_t nextAsynchsendCmd4[8];
uint8_t nextCmd4para1[8];
uint8_t nextCmd4para2[8];
uint8_t nextCmd4para3[8];
uint8_t nextCmd4para4[8];
uint8_t nrOfCmds4InQueue;
uint16_t nextAsynchsendCmd8[4];
uint8_t nextCmd8para1[4];
uint8_t nextCmd8para2[4];
uint16_t nextCmd8para3[4];
uint32_t nextCmd8para4[4];
uint8_t nrOfCmds8InQueue;
uint8_t sendAsynchDataBuf[160]; // no stack, only ONE buffer
uint8_t sendAsyDatLen;
uint8_t Sdata_mdbSendBuffer[64];
uint8_t Sdata_mdbSendLen;
uint8_t prnDataParameters[4];
uint8_t prnDataBufferUser;
char Sdata_PRN_TEXT[20][64];
uint8_t pPrnDataBuff; // points to next PRINTER_BLOCK
uint8_t nextFDwrCmd[16];
uint8_t nextFDrdCmd[16];
uint8_t nextFDblkNr[16];
uint8_t nextFDpara1[16];
uint8_t nextFDpara2[16];
uint8_t nextFDpara3[16];
uint8_t nextFDpara4[16];
uint8_t p_nextFDcmdsInQueue;
uint8_t longFDwrCmd[16];
uint8_t longFDrdCmd[16];
uint8_t longFDblkNr[16];
uint8_t longFDlength[16];
uint8_t longFDpara[16][64];
uint8_t p_longFDcmdsInQueue;
// storeInData.cpp
bool indat_savePrnPwr;
bool indat_saveMifPwr;
bool indat_MdbIsOn;
#endif
uint8_t ndbs;
uint8_t pari;
uint8_t nsb;
uint8_t br;
#define MAXNROF_GENSTR 16
char genStrings[MAXNROF_GENSTR][64];
#define MAXNROF_AI 4
uint16_t AI_val[MAXNROF_AI];
struct DigitalInputs {
uint8_t doorSwitch;
uint8_t vaultSwitch;
uint8_t lockSwitch;
uint8_t opto;
uint8_t aux;
bool wakeFromPtu;
bool wakeFromMdb;
bool wakeFromModem;
bool PrnReady;
bool CoinAttach;
bool CoinEscrowOpen;
bool mifCardTap;
bool contactPwrOn;
bool mifarePwrOn;
bool rdbk_mdbTxd;
bool AuxPwrOn;
bool gsmPwrOn;
bool creditPwrOn;
bool printerPwrOn;
bool mdbPwrOn;
bool rejMot_home;
uint8_t npe_sensor;
} din;
struct DigitalOutputs {
uint8_t mbdRxTst;
uint8_t motorBits;
uint8_t serialSwitch; // serial drv on/off, Serial mux1, Serial mux2
uint8_t ledsAndFan;
uint8_t laermUndRelay;
uint8_t ptuWake;
uint8_t auxPower;
uint8_t coinShutter;
uint8_t coinEscrow;
uint8_t printerPower;
} dout;
struct Sdata {
#define NROFMIFSTATEBYTES 40
#define PRN_STATE_ARRAY_SIZE 20
#define PRN_STATE_FONT_SIZE 20
uint8_t MIF_STATE[NROFMIFSTATEBYTES];
uint8_t MIF_DATA[12][64];
uint8_t PRN_STATE[PRN_STATE_ARRAY_SIZE];
uint8_t PRN_FONTS[PRN_STATE_FONT_SIZE];
bool mdb_busRdy;
bool mdb_V12on;
bool mdb_V5on;
uint8_t mdbNrOfRecData;
uint8_t RecBuff[40];
uint8_t empNrOfsettings;
uint8_t emp_settingsBuff[66];
uint8_t NrOfDeviceSetting;
uint8_t DeviceSettingBuff[66];
uint8_t NrOfMachineIDSetting;
uint8_t NrOfMachineIDBuff[66];
uint64_t slaveUID;
uint8_t UIDstr[8];
#define MAXNROF_MEASURE 4
uint32_t measurement[MAXNROF_MEASURE];
bool serialTestResult;
uint8_t pProtResultOk;
uint16_t receivedDataLength;
uint8_t receivedDataBlock[64];
} Sdata;
uint8_t mif_cardType;
uint8_t mif_cardHolder[8];
#define MEMDEPTH_GOTCOINS (16)
struct T_coin {
uint8_t valid;
uint8_t signal;
uint8_t error;
uint8_t pad;
uint16_t value;
} gotCoin[MEMDEPTH_GOTCOINS];
uint8_t ctr_gotCoin;
struct store {
uint32_t insertedAmount;
uint16_t lastCoinType[64];
uint16_t lastCoinValue[64];
uint64_t wakeSrc;
uint8_t rbDevParamLen;
uint8_t rbDevParams[66];
uint8_t deviceCondLen;
uint8_t deviceCond[66];
uint8_t machCondLen;
uint8_t machCond[66];
uint8_t DcBackupNrOfAccNr;
uint16_t DcBackupAccNr[16]; // z.Z. nur 8
uint8_t gotNrBlocksOfVaultRec;
uint8_t vaultrecord[360];
uint32_t amount;
uint16_t nrOfCoins;
bool dcDataValid;
uint8_t wakeReason;
} store;
struct T_globTime {
// Reihenfolge nicht vertauschen!!!!!
uint8_t hour;
uint8_t minute;
uint8_t second;
uint8_t Year;
uint8_t Month;
uint8_t DayOfMonth;
uint8_t DayOfWeek; // 1=monday...7
uint8_t reserve1;
uint16_t MinutesOfToday;
uint16_t reserve2;
uint32_t SecondsOfToday;
uint8_t IsLeapyear;
uint8_t nextLeap;
uint8_t lastLeap;
uint8_t hoursOfWeek;
uint16_t minOfWeek;
uint16_t hoursOfMonth;
uint16_t minOfMonth;
uint16_t dayOfYear;
uint16_t hoursOfYear;
uint16_t reserve3;
uint32_t minOfYear;
uint8_t squareOutMode;
uint8_t free1;
uint16_t reserve4;
uint32_t minOfMillenium;
// bis hierher 44byts
uint32_t free2;
uint32_t free3;
uint32_t free4;
} getGlobalTime;
static QSharedMemory *getShm(std::size_t s = 0);
static SharedMemBuffer *getData() {
return (SharedMemBuffer *)getShm()->data();
}
static SharedMemBuffer const *getDataConst() {
return (SharedMemBuffer const *)getShm()->data();
}
#if 0
static std::atomic<bool> __sharedMemLocked;
static bool sharedMemLocked() {
return __sharedMemLocked;
}
static void setSharedMemLocked() {
__sharedMemLocked = true;
}
static void setSharedMemUnlocked() {
__sharedMemLocked = false;
}
#endif
};
#endif // SHARED_MEM_BUFFER_INCLUDED_H

View File

@ -1,427 +0,0 @@
#ifndef STOREINDATA_H
#define STOREINDATA_H
#include <stdint.h>
//#include "tslib.h"
#include <QString>
#define MAXNROF_AO 3
//#define MAXNROF_GENSTR 16
#define MAXNROF_CONTR_PORTS 11
#define MAXNROF_DIports 2
#define MAXNROF_DOports 2
#define MAXNROF_CTR 2
#define MEASCHAN_TEMPERATURE 0
#define MEASCHAN_VOLTAGE 1
// gpi: DC-driver stores data for graphic peripheral interface
// epi: gui reads values from external peripheral interface
// store power on/off condition of the devices to control the data request
void indat_storePrinterPower(bool isOn);
bool indat_isPrinterOn();
void indat_storeMifarePower(bool isOn);
bool indat_isMifareOn();
void indat_storeMDBisOn(bool isOn);
bool indat_isMdbOn();
void gpi_storeSlaveSerParams(uint8_t slaveBaudRate, uint8_t NrDataBits,
uint8_t parity, uint8_t NrStopBits);
void epi_getSlaveSerParams(uint8_t *slaveBaudRate, uint8_t *NrDataBits,
uint8_t *parity, uint8_t *NrStopBits);
QString epi_getSlaveParamSTR();
void gpi_storeGenerals(uint8_t genNr, QString text);
// 0=HW 1=SW 2=State
QString epi_loadGenerals(uint8_t genNr);
// genNr=0=HW 1=SW 2=State
void gpi_storeUID(uint8_t const *buf8byteUid);
// buffer size: 8 byte
void epi_getUIDdec(uint8_t *buf8byteUid);
// buffer size: 8 byte
QString epi_getUIDstr();
// ///////////////////////////////////////////////////////////////////////////////////
// Time and Date
// ///////////////////////////////////////////////////////////////////////////////////
uint8_t epi_getSquareMode();
void gpi_backupSquareMode(uint8_t squMode);
void gpi_backupTime(uint8_t *timeBuffer, uint8_t Leng); // 104, <=8byte
void epi_getTime(uint8_t *hh, uint8_t *mm, uint8_t *ss);
void epi_getDate(uint8_t *yy, uint8_t *mm, uint8_t *dd);
void epi_getToday(uint8_t *dow, uint16_t *minOfToday, uint32_t *secOfToday);
bool epi_isLeapYear(uint8_t *lastLeapYear, uint8_t *NextLeapYear);
bool epi_isLeapYear();
void epi_getSpecialWeekTimeDate(uint8_t *DayOfWeek, uint8_t *HoursOfWeek, uint16_t *MinutesOfWeek);
void epi_getSpecialMonthTimeDate(uint8_t *DayOfMonth, uint16_t *HoursOfMonth, uint16_t *MinutesOfMonth);
void epi_getSpecialYearTimeDate(uint16_t *DayOfYear, uint16_t *HoursOfYear, uint32_t *MinutesOfYear);
// ///////////////////////////////////////////////////////////////////////////////////
// Analog values
// ///////////////////////////////////////////////////////////////////////////////////
// #define MAXNROF_AI 4
void gpi_storeAIs(uint8_t aiNr, uint16_t val); // rs -> Sdata
uint8_t gpi_getMaxNrAIs();
uint16_t epi_loadAIs(uint8_t aiNr); // Sdata -> gui
// return value of one ADC with channel nr: aiNr 0...15
uint32_t epi_loadMeasureValue(uint8_t ValueNr);
// ValueNr 0=ADC0, 1=ADC1 aso...
void gpi_storeMeasureValue(uint8_t ValueNr, uint32_t val);
// in mV, also bis 65,535V
QString epi_getSlaveTemperatureStr();
QString epi_getSlaveVoltageStr();
// value in "meas_volt" in mV, also bis 65,535V. Value range [6000...16000] (6V...16V)
// ///////////////////////////////////////////////////////////////////////////////////
// digital inputs
// ///////////////////////////////////////////////////////////////////////////////////
void gpi_storeDI_doorSwitches(uint8_t upperDoor, uint8_t lowerDoor, uint8_t vaultDoor);
uint8_t epi_getDI_doorSwitches(void);
// bit0: upper door 1: low door 2:vault door
void gpi_storeDI_vaultSwitches(uint8_t CashBoxIn, uint8_t BillBoxIn);
uint8_t epi_getDI_vaultSwitches(void);
// bit0: cash box 1: bill box in
void gpi_storeDI_lockSwitches(uint8_t indatUL, uint8_t indatLL);
// D5: bit 0: upper lockbar up bit1:down
// D6: bit 0: lower lockbar up bit1:down
uint8_t epi_getDI_lockSwitches(void);
// retval: bit 0: upper lockbar up bit1: upper lockbar is down
// bit 2: lower lockbar up bit1: lower lockbar is down
void gpi_storeDI_optos(uint8_t indatOpto);
// OptoIn bit 0,1: optoin 1,2
uint8_t epi_getDI_optos(void);
// bit0: opto in 1 1: opto in 2
uint8_t gpi_storeDI_auxIn(uint8_t indatAuxIn); // Aux0...5
uint8_t epi_getDI_auxIn(void); // bit0: auxin 1 ... 5: auxin 6
bool gpi_storeDI_ptuWake(bool w);
bool epi_getDI_ptuWake(void);
bool gpi_storeDI_mbdWake(bool w);
bool epi_getDI_mdbWake(void);
bool gpi_storeDI_prnReady(bool ready);
bool epi_getDI_prnReady(void);
bool gpi_storeDI_CoinAttach(bool attach);
bool epi_getDI_CoinAttach(void);
bool gpi_storeDI_CoinEscrow(bool ce);
bool epi_getDI_CoinEscrow(void);
bool gpi_storeDI_mifareCardTapped(bool tapped);
bool epi_getDI_mifareCardTapped(void);
bool gpi_storeDI_modemWake(bool w);
bool epi_getDI_modemWake(void);
bool gpi_storeDI_contactPowerIsOn(bool on);
bool epi_getDI_contactPwr(void);
bool gpi_storeDI_MifarePowerIsOn(bool on);
bool epi_getDI_mifarePwr(void);
bool gpi_storeDI_readbackMdbTxD(bool rdbkMdbTxd);
bool epi_getDI_mdbTxd(void);
bool gpi_storeDI_AuxPowerIsOn(bool on);
bool epi_getDI_auxPwr(void);
bool gpi_storeDI_GsmPowerIsOn(bool on);
bool epi_getDI_gsmPwr(void);
bool gpi_storeDI_CreditPowerIsOn(bool on);
bool epi_getDI_creditPwr(void);
bool gpi_storeDI_PrinterPowerIsOn(bool on);
bool epi_getDI_printerPwr(void);
bool gpi_storeDI_MdbPowerIsOn(bool on);
bool epi_getDI_mdbPwr(void);
bool gpi_storeDI_rejMot_home(bool reject);
bool epi_getDI_rejectMotor_homepos(void);
uint8_t gpi_storeDI_paperLow(uint8_t di);
uint8_t epi_getDI_npe_sensor(void);
// 0: Sensor sees paper 1: no paper 99: off
// ///////////////////////////////////////////////////////////////////////////////////
// readback digital outputs
// ///////////////////////////////////////////////////////////////////////////////////
uint8_t gpi_storeDO_mdbRxTst(uint8_t do_mbdRxTst);
bool epi_getDO_mdbRxTestOut(void);
uint8_t gpi_storeDO_motorOutputs(uint8_t Pwr);
uint8_t epi_getDO_motorOuts(void);
// bit0: upper lock forward bit 1 backward
// bit2: lower lock forward bit 3 backward
uint8_t gpi_storeDO_serialSwitch(uint8_t state);
// serial drv on/off, Serial mux1, Serial mux2
uint8_t epi_getDO_serialSwitch(void);
// serial drv on/off, Serial mux1, Serial mux2
bool epi_getDO_serialDriverIsOn(void);
bool epi_getDO_serialMux1isSetToPrinter(void);
// mux1 off: serial is switched to printer
bool epi_getDO_serialMux1isSetToModem(void);
// mux1 on: serial is switched to modem
bool epi_getDO_serialMux2isSetToCredit(void);
// mux2 off: serial is switched to credit card terminal
bool epi_getDO_serialMux2isSetToMifare(void);
// mux2 on: serial is switched to mifare reader
uint8_t gpi_storeDO_ledsAndFan(uint8_t ledState);
bool epi_getDO_led_coin(void);
bool epi_getDO_led_front(void);
bool epi_getDO_led_ticket(void);
bool epi_getDO_led_pin(void);
bool epi_getDO_led_start(void);
bool epi_getDO_led_inside(void);
bool epi_getDO_fan(void);
uint8_t gpi_storeDO_sirenAndRelay(uint8_t sirenRelay);
bool epi_getDO_sirene(void);
bool epi_getDO_relay(void);
uint8_t gpi_storeDO_ptuWake(uint8_t state);
bool epi_getDO_ptuWake(void);
uint8_t gpi_storeDO_auxPower(uint8_t pwr);
bool epi_getDO_auxPower(void);
uint8_t gpi_storeDO_coinShutter(uint8_t state);
bool epi_getDO_coinShutterOpen(void);
bool epi_getDO_coinShutterTest(void);
uint8_t gpi_storeDO_coinEscrow(uint8_t state);
uint8_t epi_getDO_coinEscrow(void);
// retval: 1:return flap is open 2:take flap is open 0:closed
uint8_t gpi_storeDO_printerPwrOn(uint8_t state);
uint8_t epi_getDO_printerPwr(void);
// ---------------------------------------------------------------------------------------------
// counterchecks, make sure that DC-outputs are correct
/*
bool epi_cntchk_wakePtu(void);
bool epi_cntchk_enabDrv01(void); // no communication possible if 0 !!!!!
bool epi_cntchk_swRs1toModem(void);
bool epi_cntchk_modemWake(void);
bool epi_cntchk_enabDrv2(void);
bool epi_cntchk_swRs2toMIF(void);
bool epi_cntchk_shutterIsOpen(void);
// counter check if shutter is really open, PJ4 must be OUT and HIGH, PB5 must be OUT and HIGH
// retval TRUE: shutter is open FALSE: shutter is closed
bool epi_cntchk_escrowReturnIsOpen(void);
bool epi_cntchk_escrowTakeIsOpen(void);
bool epi_cntchk_aux1DirOut(uint8_t auxNr);
bool epi_cntchk_aux1OutHigh(uint8_t auxNr);
bool epi_cntchk_ledPaperOn(void);
bool epi_cntchk_ledPinpadOn(void);
bool epi_cntchk_ledStartOn(void);
bool epi_cntchk_ledServiceOn(void);
bool epi_cntchk_ledCoinOn(void);
bool epi_cntchk_ledIllumOn(void);
bool epi_cntchk_FanOn(void);
bool epi_cntchk_RelaisOn(void);
bool epi_cntchk_LaermOn(void);
bool epi_cntchk_Mot1Ron(void);
bool epi_cntchk_Mot1Fon(void);
bool epi_cntchk_Mot2Ron(void);
bool epi_cntchk_Mot2Fon(void);
*/
// ------------------------------------------------------------------------------------
// MDB Sendind Data are store here for next transport to DC (Device Controller)
// Transport to Slave runs every 100ms, answer from mdb-slave (e.g. coin changer) comes right
// with next slave answer
// start with: SENDDIRCMD_EXCHGMDB,
// send crude data from here to DC, DC to mdb slaves, mdb answer, return here within 50ms
uint8_t gpi_storeMdbRecData(uint8_t length, uint8_t *buf);
// datif store received mdb data
uint8_t epi_getMdbResponse(void);
// 0=no response 1=ACK 2=NAK 3=ACK with data
uint8_t epi_getMdbRecLength(void);
// 0...31
uint8_t epi_restoreMdbRecData(uint8_t *buf);
// hwapi reads received mdb data from PI
uint8_t gpi_storeMifReaderStateAndCardType(uint8_t const *buf);
/* data description:
byte 0: current read state: 0=power off 1=reader-fault 2=ready
3=just reading 4=read complete
5=read partial, removed too early
6=state unknown
byte 1,2: read data length from card
3: 1=reader is OK (reported serial nr is OK) 0=wrong or no reader
4...15: reader version, expected "SL025-1.8"
byte16: 1=card is present 0:not
17: 0
18: card type reported from reader
19: 1=allowed card type 0=not
20: card size: 1 or 4 (dec) = card size
21: LengthOfUID: 4 or 7 (dec) (byte)
22: UID 8 byte in hex
byte 30: sector logged: 0
byte 31: current sector: 0
byte 32: result, always 0
*/
uint8_t epi_restoreMifState(uint8_t *buf, uint8_t maxBufferSize);
// retval 0=OK 1=error host buffer too small
bool gpi_storeMifCardData(uint8_t blkNr, uint8_t const *receivedData);
// blkNr=0...11 receivedData[64]
uint8_t epi_restoreMifData(uint8_t blkNr, uint8_t *buf, uint8_t maxBufferSize);
// blkNr=0...11 return buf[64]
// retval: 1=error 0=OK
void epi_restorePrinterState(uint8_t *buf);
void gpi_storePrinterState(uint8_t const *buf);
void epi_restorePrinterFonts(uint8_t *buf);
void gpi_storePrinterFonts(uint8_t const *buf);
bool gpi_storeMdbState(bool busReady, bool V12on, bool V5on);
bool epi_restoreMdbBusReady(void);
bool epi_restoreMdbV12Ready(void);
bool epi_restoreMdbV5Ready(void);
void gpi_storeMdbResponse(uint8_t leng, uint8_t const *data);
void epi_restoreMdbResponse(uint8_t *leng, uint8_t *data);
// last received mdb answer (from mdb device)
// only needed if a special command was sent directly
// DB0: mdb Device-Nr
// DB1: last sent mdb command
// DB2: nr of received (payload) data bytes (apart from ACK, can be 0....34)
// DB3...DB38: rec.data (payload)
void gpi_storeEmpSettings(uint8_t leng, uint8_t const *data);
void epi_restoreEmpSettings(uint8_t *leng, uint8_t *data);
/*
void gpi_storeEmpCoinSignal(uint8_t leng, uint8_t *data);
void epi_restoreEmpCoinSignal(uint8_t *leng, uint8_t *data);
// return 5 byte:
// data[0]=got coin 0xFF=emp reported an error 0=got nothing
// data[1]=emp-signal of last inserted coin
// data[2,3]=emp-value of last inserted coin
// data[4] = emp-error or warning
void epi_clearEmpCoinSignal();
*/
void gpi_storeEmpCoinSignal(uint8_t leng, uint8_t const *data);
uint8_t epi_isNewCoinLeft(void);
// retval: 0...16 coins left in FIFO
void epi_restoreEmpCoinSignal(uint8_t *valid, uint8_t *signal, uint8_t *error, uint16_t *value);
void gpi_storeRbDeviceSettings(uint8_t leng, uint8_t const *data);
void epi_restoreRbDeviceSettings(uint8_t *leng, uint8_t *data);
void gpi_storeMachineIDsettings(uint8_t leng, uint8_t const *data);
void epi_restoreMachineIDsettings(uint8_t *leng, uint8_t *data);
void epi_clearCurrentPayment(void);
void gpi_storeCurrentPayment(uint32_t insertedAmount, uint16_t lastCoinType, uint16_t lastCoinValue);
uint32_t epi_CurrentPaymentGetAmount(void);
uint16_t epi_CurrentPaymentGetLastCoin(void);
bool epi_CurrentPaymentGetAllCoins(uint16_t *types, uint16_t *values);
// alle bei diesem Verkauf eingeworfenen Münzen sind gespeichert falls die jmd. braucht
void gpi_storeWakeSources(uint8_t const *receivedData);
uint64_t epi_getWakeSources(void);
uint8_t epi_getWakeReason(void);
void gpi_storeExtendedTime(uint8_t leng, uint8_t const *data);
void epi_restoreExtendedTime(uint8_t *leng, uint8_t *data);
void gpi_storeDeviceConditions(uint8_t leng, uint8_t const *data);
void epi_restoreDeviceConditions(uint8_t *leng, uint8_t *data);
void gpi_storeDynMachineConditions(uint8_t leng, uint8_t const *data);
void epi_restoreDynMachineConditions(uint8_t *leng, uint8_t *data);
void gpi_storeDCbackupAccNr(uint8_t leng, uint8_t const *data);
void epi_restoreDCbackupAccNr(uint8_t *leng, uint16_t *accNrs);
// return accNrs[0..7]
void epi_iniVRstorage(void);
void gpi_storeVaultRecord(uint8_t blkNr, uint8_t const *data);
bool epi_checkIfVaultRecordAvailable(void);
bool epi_restoreVaultRecord(uint16_t *length, uint8_t *buf);
// true if completly received
void gpi_storeCBlevel(uint32_t amount, uint16_t nrOfCoins);
uint32_t epi_getCashBoxContent(void);
uint16_t epi_getNrOfCoinsInCashBox(void);
void gpi_storeNewMifareCard(uint8_t typ, uint8_t const *holder);
uint8_t epi_mifGetCardType(uint8_t const *holder);
//holder[8] = name of card holder
// retval Type of MifareCard, 1=upper door, 2=lower door 3=test printer 4=test coins
void gpi_storeDcDataValid(bool isVal);
bool gpi_areDcDataValid();
#endif

View File

@ -1,90 +0,0 @@
#ifndef TSLIB_H
#define TSLIB_H
#include <stdint.h>
#include <QByteArray>
#define LOWBYTE false
#define HIGHBYTE true
uint16_t uchar2uint(char Highbyte, char Lowbyte);
uint16_t uchar2uint(uint8_t Highbyte, uint8_t Lowbyte);
uint32_t uchar2ulong(uint8_t Highbyte, uint8_t MHbyte, uint8_t MLbyte, uint8_t Lowbyte);
uint8_t uint2uchar(uint16_t uival, bool getHighB);
uint8_t ulong2uchar(uint32_t ulval, uint8_t getBytNr);
// getBytNr: 0=LSB 3=MSB
void delay(uint16_t MilliSec);
#define MITSEK 1
#define OHNESEK 0
#define HourSys12h 1
#define HourSys24h 0
void GetTimeString(uint8_t hours, uint8_t minutes, uint8_t seconds, uint8_t System12h, uint8_t ShowSec, uint8_t *buf);
// generate time as ascii string from integers hours/minutes/seconds
// System12h=0: 24h system =1: 12h System
// ShowSec=0: String has 5 digits (hh:mm) =1: String has 8 digits (hh:mm:ss)
// return String in *buf // 12 byte für buf!
#define DateFormatDeutsch 0
#define DateFormatAmerica 1
#define UsePointSeperator 0
#define UseSlashSeperator 1
void GetDateString(uint8_t day, uint8_t month, uint8_t yearhigh, uint8_t yearlow, uint8_t format, uint8_t sep, uint8_t *buf);
// generate date as ascii string from integers day/month/year
// yearhigh in europe always 20 (not in arabia)
// format= 0: dd.mm.yyyy (deutsch)
// 1: mm.dd.yyyy (amerika)
// 2: yyyy.mm.dd (Iran, Dubai)
// 3: dd.yyyy.mm
// 4: mm.yyyy.dd
// 5: yyyy.dd.mm
// sep: 0: use . as seperator 1: use / as seperator
// return String in *buf // 11 byte für buf!
void GetShortDateString(uint8_t day, uint8_t month, uint8_t yearlow, uint8_t format, uint8_t sep, uint8_t *buf);
// generate date as ascii string from integers day/month/year
// format= 0: dd.mm.yy (deutsch)
// 1: mm.dd.yy (amerika)
// 2: yy.mm.dd (Iran, Dubai)
// 3: dd.yy.mm
// 4: mm.yy.dd
// 5: yy.dd.mm
// sep: 0: use . as seperator 1: use / as seperator
// return String in *buf // 11byte für buf!
uint16_t tslib_strlen(char *buf);
uint16_t tslib_strlen(uint8_t *buf);
void tslib_strclr(char *buf, char clrsign, uint16_t len);
void tslib_strclr(uint8_t *buf, char clrsign, uint16_t len);
void tslib_strcpy(char *srcbuf, char *destbuf, uint16_t len);
void tslib_strcpy(char *srcbuf, uint8_t *destbuf, uint16_t len);
void tslib_strcpy(uint8_t *srcbuf, uint8_t *destbuf, uint16_t len);
uint16_t tslib_calcCrcCcitt(uint16_t BufLength, uint8_t *buf);
bool tslib_isDecAsciiNumber(char sign);
bool tslib_isHexAsciiNumber(char sign);
int tslib_getMinimum(int val1, int val2);
void tslib_text2array(QByteArray text, char *aray, uint16_t maxArayLen);
// usage: tslib_text2array("my text", ctmp, 50);
void biox_CopyBlock(uint8_t *src, uint16_t srcPos, uint8_t *dest, uint16_t destPos, uint16_t len);
// both buffers starting from pos 0
#endif // TSLIB_H

View File

@ -1,22 +0,0 @@
#ifndef ATBAPPPLUGIN_H
#define ATBAPPPLUGIN_H
/***********************************************************
* a simple class with only one method for plugin info
*/
#include <QObject>
#include <QString>
class ATBAPPplugin
{
public:
virtual const QString & getPluginInfo() = 0;
};
Q_DECLARE_INTERFACE(ATBAPPplugin,
"eu.atb.ptu.plugin.ATBAPPplugin/0.9")
#endif // ATBAPPPLUGIN_H

View File

@ -1,293 +0,0 @@
#include "src/ATBAPP/ATBDeviceControllerPlugin.h"
#include "src/ATBAPP/ATBHealthEvent.h"
#include <QTimer>
#include <QTextCodec>
ATBDeviceControllerPlugin::ATBDeviceControllerPlugin(QObject *parent) : QObject(parent),
pluginState(PLUGIN_STATE::NOT_INITIALIZED)
{
this->pluginInfo = QString::fromUtf8(pluginInfoString.c_str());
this->hw = new hwapi();
connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_templatePrintFinished_OK()), this, SLOT(onPrintFinishedOK()));
connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_templatePrintFinished_Err()), this, SLOT(onPrintFinishedERR()));
connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_gotNewCoin()), this, SLOT(onCashGotCoin()));
connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_vendStopByMax()), this, SLOT(onCashVendStopByMax()));
}
ATBDeviceControllerPlugin::~ATBDeviceControllerPlugin() {}
PLUGIN_STATE ATBDeviceControllerPlugin::initDCPlugin(QObject *healthEventReceiver, const QSettings & settings)
{
this->healthEventReceiver = healthEventReceiver;
// read variables from setting
QString serialPort = settings.value("DEVICE_CONTROLLER/serialPort", "ttymxc2").toString();
QByteArray printerEncoding = settings.value("DEVICE_CONTROLLER/printerEnconding", "ISO 8859-2").toString().toLatin1();
// open serial port
hw->dc_openSerial(5, "115200", serialPort, 1);
// text encoding for printer
this->codec = QTextCodec::codecForName(printerEncoding);
this->pluginState = PLUGIN_STATE::INITIALIZED;
return pluginState;
}
// TASKS: Cash handling -------------------------------------------------------
void ATBDeviceControllerPlugin::requestStartCashInput(const QString & amount)
{
qCritical() << "Start Cash vending with amount = " << amount;
uint32_t amountInt = static_cast<uint32_t>(amount.toUInt());
hw->cash_startPayment(amountInt);
}
void ATBDeviceControllerPlugin::requestStopCashInput()
{
hw->cash_stopPayment();
}
void ATBDeviceControllerPlugin::cashCollect()
{
hw->vend_success();
}
void ATBDeviceControllerPlugin::cashAbort()
{
hw->vend_failed();
}
// TASKS: printing ------------------------------------------------------------
void ATBDeviceControllerPlugin::requestPrintTicket(const QHash<QString, QVariant> & printingData)
{
struct T_dynDat *dynTicketData = new T_dynDat;
memset(dynTicketData, 0, sizeof(*dynTicketData));
qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket( " << endl
<< " licenseplate = " << printingData["licenseplate"] << endl
<< " amount = " << printingData["amount"] << endl
<< " parkingEnd = " << printingData["parkingEnd"] << endl
<< " currentTime = " << printingData["currentTime"] << endl
<< " currentDate = " << printingData["currentDate"] << endl;
// set dynamic printer data:
memcpy((char*)dynTicketData->licensePlate, codec->fromUnicode(printingData["licenseplate"].toString()).data(), 8);
memcpy((char*)dynTicketData->vendingPrice, codec->fromUnicode(printingData["amount"].toString()).data(), 8);
QDateTime parkingEndQDateTime = QDateTime::fromString(printingData["parkingEnd"].toString(), Qt::ISODate);
QDateTime currentDateTime = QDateTime::fromString(printingData["currentTime"].toString(), Qt::ISODate);
memcpy((char*)dynTicketData->parkingEnd, codec->fromUnicode(parkingEndQDateTime.toString("hh:mm")).data(), 8);
memcpy((char*)dynTicketData->currentTime, codec->fromUnicode(currentDateTime.toString("hh:mm")).data(), 8);
memcpy((char*)dynTicketData->currentDate, codec->fromUnicode(currentDateTime.toString("dd.MM.yy")).data(), 8);
// DEBUG
qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket()";
if (!this->hw->dc_isPortOpen()) {
qCritical() << " ... serial port is not open!";
this->onPrintFinishedERR();
return;
}
// TODO: wird hier nur 'licensePlate' gedruckt?
if (!this->hw->prn_sendDynamicPrnValues(dynTicketData->licensePlate)) {
this->errorCode = "hwapi::prn_sendDynamicPrnValues";
this->errorDescription = "hwapi method 'hwapi::prn_sendDynamicPrnValues' result is false";
qCritical() << "ERROR:";
qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket( " << endl
<< " licenseplate = " << printingData["licenseplate"] << endl
<< " amount = " << printingData["amount"] << endl
<< " parkingEnd = " << printingData["parkingEnd"] << endl
<< " currentTime = " << printingData["currentTime"] << endl
<< " currentDate = " << printingData["currentDate"] << endl;
this->onPrintFinishedERR();
return;
}
QTimer::singleShot(1000, this, SLOT(onPrinterDataPrepared()));
}
void ATBDeviceControllerPlugin::onPrinterDataPrepared()
{
this->currentTemplate = 1;
this->onPrinterPrintNextTemplate();
}
void ATBDeviceControllerPlugin::onPrinterPrintNextTemplate()
{
qCritical() << " ... print template " << this->currentTemplate;
if (!this->hw->prn_printTemplate(this->currentTemplate)) {
this->errorCode = "hwapi::prn_printTemplate";
this->errorDescription = QString("hwapi method 'hwapi::onPrinterPrintNextTemplate(%1)' result is false").arg(this->currentTemplate);
this->onPrintFinishedERR();
return;
}
if (this->currentTemplate >= 3) {
// all templates are printed
this->currentTemplate = 0;
// FAKE SIGNAL:
QTimer::singleShot(1000, this, SLOT(onPrintFinishedOK()));
}
else {
// print next template
this->currentTemplate++;
QTimer::singleShot(3000, this, SLOT(onPrinterPrintNextTemplate()));
}
}
/************************************************************************************************
* private slots, interface to low level hwapi
*
*/
void ATBDeviceControllerPlugin::onPrintFinishedOK()
{
// DEBUG
qCritical() << "ATBDeviceControllerPlugin::onPrintFinishedOK()";
emit this->printTicketFinished(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
"",
"");
}
void ATBDeviceControllerPlugin::onPrintFinishedERR()
{
// DEBUG
qCritical() << "ATBDeviceControllerPlugin::onPrintFinishedERR()";
this->errorCode = "PRINTER"; // TODO: get more detailed error code from low level API
this->errorDescription = "Printer error"; // TODO: get more detailed error description from low level API
emit this->printTicketFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
this->errorCode,
this->errorDescription);
}
/************************************************************************************************
* cash payment
*/
void ATBDeviceControllerPlugin::onCashGotCoin()
{
// DEBUG
qCritical() << "ATBDeviceControllerPlugin::onGotCoin()";
uint32_t amountInt = this->hw->getInsertedAmount();
QString amountString = QString::number(amountInt);
emit this->cashInputEvent(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
nsDeviceControllerInterface::CASH_STATE::CACHE_INPUT,
amountString,
"",
"");
}
void ATBDeviceControllerPlugin::onCashVendStopByMax()
{
// DEBUG
qCritical() << "ATBDeviceControllerPlugin::onCashVendStopByMax()";
uint32_t amountInt = this->hw->getInsertedAmount();
QString amountString = QString::number(amountInt);
emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
amountString,
"",
"");
}
/************************************************************************************************
* Mandatory plugin methods
*
*/
PLUGIN_STATE ATBDeviceControllerPlugin::getState()
{
return this->pluginState;
}
QString & ATBDeviceControllerPlugin::getLastError()
{
return this->errorCode;
}
const QString & ATBDeviceControllerPlugin::getLastErrorDescription()
{
return this->errorDescription;
}
const QString & ATBDeviceControllerPlugin::getPluginInfo()
{
return this->pluginInfo;
}
const QString ATBDeviceControllerPlugin::getString(nsDeviceControllerInterface::RESULT_STATE resultState)
{
QString str;
switch (resultState) {
case nsDeviceControllerInterface::RESULT_STATE::SUCCESS:
str = QString("RESULT_STATE::SUCCESS");
break;
case nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND:
str = QString("RESULT_STATE::ERROR_BACKEND");
break;
case nsDeviceControllerInterface::RESULT_STATE::ERROR_TIMEOUT:
str = QString("RESULT_STATE::ERROR_TIMEOUT");
break;
case nsDeviceControllerInterface::RESULT_STATE::ERROR_PROCESS:
str = QString("RESULT_STATE::ERROR_PROCESS");
break;
case nsDeviceControllerInterface::RESULT_STATE::ERROR_RETRY:
str = QString("RESULT_STATE::ERROR_RETRY");
break;
case nsDeviceControllerInterface::RESULT_STATE::INFO:
str = QString("RESULT_STATE::INFO");
break;
}
return str;
}
/************************************************************************************************
* ... end
*/
#if QT_VERSION < 0x050000
Q_EXPORT_PLUGIN2( ATBDeviceControllerPlugin, ATBDeviceControllerPlugin )
#endif

View File

@ -1,125 +0,0 @@
#ifndef ATBDEVICECONTROLLERPLUGIN_H
#define ATBDEVICECONTROLLERPLUGIN_H
#include <QObject>
#include "src/ATBAPP/DeviceControllerInterface.h"
#include "src/ATBAPP/ATBAPPplugin.h"
#include "version.h"
#include "hwapi.h"
#include <unistd.h>
#include <thread>
#include <memory>
#include <QSharedMemory>
class QTextCodec;
using namespace nsDeviceControllerInterface;
class QSettings;
class ATBDeviceControllerPlugin : public QObject,
public DeviceControllerInterface
{
Q_OBJECT
Q_INTERFACES(ATBAPPplugin)
Q_INTERFACES(DeviceControllerInterface)
#if QT_VERSION >= 0x050000
Q_PLUGIN_METADATA( IID "ATBDeviceControllerPlugin" )
#endif
public:
explicit ATBDeviceControllerPlugin(QObject *parent = nullptr);
~ATBDeviceControllerPlugin();
// ----------------------------------------------------------------------------
// interface:
PLUGIN_STATE initDCPlugin(QObject *healthEventReceiver, const QSettings & settings);
// TASKS: Cash handling -------------------------------------------------------
void requestStartCashInput(const QString & amount);
void requestStopCashInput();
void cashCollect();
void cashAbort();
// TASKS: printing ------------------------------------------------------------
void requestPrintTicket(const QHash<QString, QVariant> & printingData);
// mandantory ATBAPP plugin methods: ------------------------------------------
nsDeviceControllerInterface::PLUGIN_STATE getState();
QString & getLastError();
const QString & getLastErrorDescription();
const QString & getPluginInfo();
// helpers e.g. for debug / log
const QString getString(nsDeviceControllerInterface::RESULT_STATE resultState);
signals:
void printTicketFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
const QString & errorCode,
const QString & errorDescription);
void cashInputEvent(nsDeviceControllerInterface::RESULT_STATE resultState,
nsDeviceControllerInterface::CASH_STATE cashState,
const QString & newCashValue,
const QString & errorCode,
const QString & errorDescription);
void cashInputFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
const QString & newCashValue,
const QString & errorCode,
const QString & errorDescription);
void requestServiceMode();
void Error(
const QString & errorCode,
const QString & errorDescription);
private:
QString errorCode;
QString errorDescription;
QString pluginInfo;
int currentTemplate;
bool useDebug;
PLUGIN_STATE pluginState;
QObject* healthEventReceiver;
hwinf* hw;
QTextCodec *codec;
private slots:
// printer
void onPrinterDataPrepared();
void onPrinterPrintNextTemplate();
void onPrintFinishedOK();
void onPrintFinishedERR();
// cash payment
void onCashGotCoin();
void onCashVendStopByMax();
};
#endif // ATBDEVICECONTROLLERPLUGIN_H

View File

@ -1,25 +0,0 @@
#include "src/ATBAPP/ATBHealthEvent.h"
ATBHealthEvent::ATBHealthEvent(ATB_HEALTH_MODE mode, const QString & errorNumber, const QString & errorDescription) :
QEvent(ATB_HEALTH_EVENT),
healthMode(mode),
errorNumber(errorNumber),
errorDescription(errorDescription)
{
}
QString ATBHealthEvent::getErrorNumber()
{
return this->errorNumber;
}
QString ATBHealthEvent::getErrorDescription()
{
return this->errorDescription;
}
ATB_HEALTH_MODE ATBHealthEvent::getMode()
{
return this->healthMode;
}

View File

@ -1,44 +0,0 @@
#ifndef ATBHEALTHEVENT_H
#define ATBHEALTHEVENT_H
#include <QEvent>
#include <QString>
enum class ATB_HEALTH_MODE : quint8;
const QEvent::Type ATB_HEALTH_EVENT = static_cast<QEvent::Type>(QEvent::User + 1);
class ATBHealthEvent : public QEvent
{
public:
ATBHealthEvent(ATB_HEALTH_MODE mode, const QString & errorNumber, const QString & errorDescription);
QString getErrorNumber();
QString getErrorDescription();
ATB_HEALTH_MODE getMode();
signals:
public slots:
private:
ATB_HEALTH_MODE healthMode;
QString errorNumber;
QString errorDescription;
};
enum class ATB_HEALTH_MODE : quint8 {
WARNING,
ERROR,
WARNING_CORRECTION,
ERROR_CORRECTION,
DEBUG,
STATE,
UNSPECIFIED
};
#endif // ATBHEALTHEVENT_H

View File

@ -1,142 +0,0 @@
#ifndef DEVICECONTROLLERINTERFACE_H
#define DEVICECONTROLLERINTERFACE_H
#include <QtPlugin>
#include <QSettings>
#include <QString>
#include "ATBAPPplugin.h"
namespace nsDeviceControllerInterface {
enum class PLUGIN_STATE : quint8;
enum class RESULT_STATE : quint8;
enum class CASH_STATE : quint8;
}
class DeviceControllerInterface : public ATBAPPplugin
{
Q_INTERFACES(ATBAPPplugin)
public:
virtual ~DeviceControllerInterface() {}
virtual nsDeviceControllerInterface::PLUGIN_STATE initDCPlugin(QObject *healthEventReceiver,
const QSettings & settings) = 0;
// TASKS: Cash handling -------------------------------------------------------
/**
* enables coin input
* amount = "0": pay-up
* amount > "0": pay-down
*/
virtual void requestStartCashInput(const QString & amount) = 0;
/**
* called e.g. on Button "NEXT" in pay-up (direct coin input)
*/
virtual void requestStopCashInput() = 0;
/**
* called e.g. on Button "NEXT" in pay-up (direct coin input)
*/
virtual void cashCollect() = 0;
virtual void cashAbort() = 0;
// TASKS: printing ------------------------------------------------------------
virtual void requestPrintTicket(const QHash<QString, QVariant> & printingData) = 0;
// mandantory ATBAPP plugin methods:
virtual nsDeviceControllerInterface::PLUGIN_STATE getState() = 0;
virtual const QString & getLastError() = 0;
virtual const QString & getLastErrorDescription() = 0;
// return a plugin description in JSON or XML
// -> ATBAPPplugin::getPluginInfo()
// helpers e.g. for debug / log
virtual const QString getString(nsDeviceControllerInterface::RESULT_STATE resultState) = 0;
signals:
virtual void printTicketFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
const QString & errorCode,
const QString & errorDescription) = 0;
/**
* emitted on e.g. a coin input
*/
virtual void cashInputEvent(nsDeviceControllerInterface::RESULT_STATE resultState,
nsDeviceControllerInterface::CASH_STATE cashState,
const QString & newCashValue,
/* additional variables? */
const QString & errorCode,
const QString & errorDescription) = 0;
/**
* emitted if cashInput has been stopped, e.g. in result to task requestStopCashInput():
* -> shutter is blocked
* -> no cash input is possible
* -> coins are in cache
*/
virtual void cashInputFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
const QString & newCashValue,
/* additional variables? */
const QString & errorCode,
const QString & errorDescription) = 0;
/**
* emitted e.g. if service door is opened
*/
virtual void requestServiceMode() = 0;
/**
* emitted on error
* depending on errorCode:
* -> interrupt selling process
* -> machine can go to state OOO
* -> send error event to ISMAS
* -> ...
*/
virtual void Error(
/* additional variables? */
const QString & errorCode,
const QString & errorDescription) = 0;
};
Q_DECLARE_INTERFACE(DeviceControllerInterface,
"eu.atb.ptu.plugin.DeviceControllerInterface/1.0")
namespace nsDeviceControllerInterface {
enum class PLUGIN_STATE : quint8 {
NOT_INITIALIZED = 0,
INITIALIZED = 1
};
enum class RESULT_STATE : quint8 {
SUCCESS = 1, // operation was successfull
ERROR_BACKEND, // error from backend (e.g. backend replies with error)
ERROR_TIMEOUT, // the operation timed out
ERROR_PROCESS, // internal plugin error, should not occur (this is a bug in implementation)
ERROR_RETRY, // retry operation
INFO // informational (e.g. display a message, log something etc.)
};
enum class CASH_STATE : quint8 {
CACHE_EMPTY, // Cache still empty, default state
CACHE_INPUT, // Coins are in Cache
OVERPAYED,
/* t.b.d. */
};
}
#endif // DEVICECONTROLLERINTERFACE_H

View File

@ -1,449 +0,0 @@
#include "com.h"
#include <QDebug>
//#include "controlBus.h"
//////////////////////////////////////////////////////////////////////////////////
///
/// serial hardware layer
///
//////////////////////////////////////////////////////////////////////////////////
static int64_t com_want2read;
// -------------------------------------------------------------------------------------------------------------
// --------- PUBLIC --------------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------------------
void T_com::writeToSerial(const QByteArray &data, uint16_t sendLength)
{
sendBuffer=data;
sendLen=sendLength;
if (CatSerial->isOpen())
{
//qDebug() << "sending..." << sendBuffer;
CatSerial->write(sendBuffer);
} else
qDebug() << "error sending, port is not open";
}
bool T_com::readFromSerial(QByteArray &data, uint16_t &sendLength)
{
// return one time true if new data (completly) read.
// return new data in &data and &sendLength to other objects
uint16_t ll=rawInLen;
if (!CatSerial->isOpen())
return false;
data.clear();
data.append(rawInput);
sendLength=ll;
rawInLen=0; // beim 2. Aufruf 0 zurück weil nichts neues da
if (ll>0)
return true;
return false;
}
// -------------------------------------------------------------------------------------------------------------
// --------- PRIVATES --------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------------------
T_com::T_com(QWidget *parent) : QMainWindow(parent)
{
// port settings come from tabCom->Sdata->serial
gpi_serialChanged();
CatSerial = new QSerialPort(); // PortHW object for Control&Analyse Tool
//CatSerial->clear();
//CatSerial->clearError();
connect(CatSerial, &QSerialPort::readyRead, this, &T_com::readSomeBytes);
// still reading, not sure if complete, undefined number of calls while reading
connect(CatSerial, &QSerialPort::bytesWritten, this, &T_com::serialSendComplete);
// system confirms sending complete
//connect(CatSerial, &QSerialPort::dataTerminalReadyChanged, this, &T_com::incomingWake);
//connect(CatSerial, &QSerialPort::requestToSendChanged, this, &T_com::incomingWake);
// timer detects time gap in input flow
serRecTime = new QTimer();
connect(serRecTime, SIGNAL(timeout()), this, SLOT(receiveTO()));
serRecTime->setSingleShot(true); // single shot! only one impulse if receive complete
serRecTime->stop(); // on hold
// check COM-TAB periodic if user wants to connect or disconnect
QTimer *ChkConnectTimer = new QTimer();
connect(ChkConnectTimer, SIGNAL(timeout()), this, SLOT(ser_ISR100ms()));
ChkConnectTimer->setSingleShot(false);
ChkConnectTimer->start(100); // in ms
com_want2read=0;
}
T_com::~T_com()
{
if (CatSerial->isOpen())
CatSerial->close();
}
void T_com::ser_ISR100ms()
{
//qDebug() << "~~>LIB" << "ENTER...";
// call every 100ms to check if user(HMI) wants to connect or disconnect
uint8_t chkConn = gpi_getSerialConn(); // from global GUI buffer (Sdata)
//qDebug() << "~~>LIB" << "checking connect button... " << chkConn;
switch (chkConn)
{
case 0: // 0 button "connect" was just released
//qDebug() << "close serial port" << chkConn;
closeSerialPort();
gpi_serialChanged(); // set chkConn to 2, thus getting edge
break;
case 1: // 1 button "connect" was just pressed
//qDebug() << "open serial port" << chkConn;
open_Serial_Port();
gpi_serialChanged(); // set chkConn to 2, thus getting edge
break;
}
if (CatSerial->isOpen()) {
gpi_serialIsOpen(true);
} else {
gpi_serialIsOpen(false);
}
//qDebug() << "LEAVE " << chkConn;
}
// -------------------------------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------------------
char T_com::open_Serial_Port()
{
//qDebug() << "ENTER";
bool ret;
QString myString=nullptr, myPortName=nullptr, myBaudStr=nullptr;
int myBaudNr;
if (CatSerial->isOpen()) {
qDebug() << "!!!IS OPEN!!!";
return 0; // opening twice is not allowed
}
//qDebug() << "connecting..." << myPortName;
myPortName=gpi_getComPortName(); // was selected and stored from GUI
CatSerial->setPortName(myPortName);
myBaudNr=gpi_getBaudNr(); // was selected and stored from GUI
//qDebug() << "myPortName" << myPortName << ", myBaudNr" << myBaudNr;
switch (myBaudNr)
{
// 0:1200 1:9600 2:19200 3:38400 4:57600 5:115200
case 0: CatSerial->setBaudRate(QSerialPort::Baud1200); myBaudStr="1200"; break;
case 1: CatSerial->setBaudRate(QSerialPort::Baud9600); myBaudStr="9600"; break;
case 2: CatSerial->setBaudRate(QSerialPort::Baud19200); myBaudStr="19200"; break;
case 3: CatSerial->setBaudRate(QSerialPort::Baud38400); myBaudStr="38400"; break;
case 4: CatSerial->setBaudRate(QSerialPort::Baud57600); myBaudStr="57600"; break;
case 5: CatSerial->setBaudRate(QSerialPort::Baud115200); myBaudStr="115200"; break;
}
CatSerial->setDataBits(QSerialPort::Data8);
// alt: QSerialPort::Data5,6,7,8
CatSerial->setParity(QSerialPort::NoParity);
// alt: EvenParity, OddParity, NoParity
CatSerial->setStopBits(QSerialPort::OneStop);
// alternative: OneStop, TwoStop, OneAndHalfStop
CatSerial->setFlowControl(QSerialPort::NoFlowControl);
// alt: HardwareControl, SoftwareControl, NoFlowControl
ret=CatSerial->open(QIODevice::ReadWrite);
// alt: QIODevice::ReadWrite QIODevice::ReadOnly QIODevice::WriteOnly
if (!ret)
{
myString.clear();
myString = "error ";
myString.append(CatSerial->errorString());
qDebug() << myString;
gpi_setTxt4comStateLine(myString);
//qDebug() << "LEAVE";
return 0;
} else
{
myString.clear();
myString.append(myPortName);
//lang=myString.size();
myString.append(" opened with ");
myString.append(myBaudStr);
myString.append(" 8N1");
qDebug() << myString;
gpi_setTxt4comStateLine(myString);
gpi_setTxt4RsDiagWin(myString+"\n");
}
//qDebug() << "LEAVE";
return 0;
}
void T_com::closeSerialPort()
{
//qDebug() << "ENTER";
if (CatSerial->isOpen())
{
qDebug() << "closing connection";
CatSerial->close();
gpi_setTxt4comStateLine("closed");
gpi_setTxt4RsDiagWin("closed");
}
//qDebug() << "LEAVE";
}
void T_com::readSomeBytes(void)
{
// called by serial-read-detection
// restart off-time as input flow is ongoing
// timer for slow receive
// and serves as timeout for fast receive is msg is shorter as expected
serRecTime->stop();
serRecTime->start(20); // in ms
//qDebug()<< "com-rec read some bytes";
this->receiveByLength(); // since 14.12.21: fast receive
}
void T_com::receiveFixLen(int64_t nrOfbytesToReceive)
{
// call this before sending a request to slave
// then we know exactly when reception is complete -> much faster
com_want2read=nrOfbytesToReceive;
// since 14.12.21: FastDevice Protocol has two lengthen:
// fast: 12byte reception long: 68byte
}
void T_com::receiveByLength(void)
{
if (CatSerial->isOpen())
{
QString myString=nullptr, tmpStr=nullptr;
int64_t nrOfBytesreceived = CatSerial->bytesAvailable(); // nr of received bytes
//qDebug()<< "com-rec current Len: "<< nrOfBytesreceived;
if (nrOfBytesreceived >= com_want2read)
{
QByteArray data = CatSerial->readAll(); // erst auslesen wenn alles da! löscht den Empfangspuffer
serRecTime->stop(); // stop timeout to avoid 2nd emit
rawInLen=uint16_t (nrOfBytesreceived);
rawInput.clear();
rawInput.append(data);
// report "new data received" to other objects
//qDebug()<< "com-recFinished by Len "<< rawInLen;
emit receivingFinished();
}
}
}
void T_com::receiveTO(void)
{
// no new input data for 20ms, --> assuming frame complete
// save data in private "rawInput"-buffer
if (CatSerial->isOpen())
{
QString myString=nullptr, tmpStr=nullptr;
int64_t nrOfBytesreceived = CatSerial->bytesAvailable(); // nr of received bytes
QByteArray data = CatSerial->readAll();
rawInLen=uint16_t (nrOfBytesreceived);
rawInput.clear();
rawInput.append(data);
//rawInput[rawInLen]=0; // Zwangsterminierung bei QByteArray nicht nötig
// diag display in serial in/out window and debug window
myString.clear();
myString.setNum(rawInLen);
myString.append(" in: ");
//myString.append(rawInput);
for (int ii=0; ii<rawInLen; ii++)
{
tmpStr.clear();
tmpStr.setNum(rawInput[ii],16); // problem: wenn >0x80 dann wird EIN Byte 16 stellig angezeigt
int ll=tmpStr.length();
if (ll>2)
{
myString.append(tmpStr[ll-2]);
myString.append(tmpStr[ll-1]);
} else
{
myString.append(tmpStr);
}
myString.append(" ");
}
myString.append("\n");
#ifdef PRINTALLDEBUGS
qDebug() << "VCP:" << myString; // display all inputs and outputs in output window
#endif
gpi_setTxt4RsDiagWin(myString);
//gpi_set2ndTxt4RsDiagWin(myString);
// report "new data received" to other objects
//qDebug()<< "com-recFinished by TO";
emit receivingFinished();
}
}
void T_com::serialSendComplete(void)
{
// system confirms sending complete, diag display
QString myString=nullptr, tmpStr=nullptr;
myString.clear();
myString.setNum(sendLen);
myString.append(" out: ");
for (int ii=0; ii<sendLen; ii++)
{
tmpStr.clear();
tmpStr.setNum(sendBuffer[ii],16); // problem: wenn >0x80 dann 16stellig
int ll=tmpStr.length();
if (ll>2)
{
//qDebug() << "long_string" << ll << "\n";
myString.append(tmpStr[ll-2]);
myString.append(tmpStr[ll-1]);
} else
{
myString.append(tmpStr);
}
myString.append(" ");
}
#ifdef PRINTALLDEBUGS
myString.append("\n");
qDebug() << myString; // display all output data in out-window
#endif
gpi_setTxt4RsDiagWin(myString);
emit sendingFinished(); // for whom it may interest
}
bool T_com::isPortOpen(void)
{
if (CatSerial->isOpen())
return true;
return false;
}
// -------------------------------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------------------
/*
uint8_t T_com::getAllPortPins(void)
{
uint8_t rs232pins=0;
rs232pins= uint8_t(CatSerial->pinoutSignals());
// rs232pins: all signals bitwise coded in one byte:
// readback output: bit 0=TxD(=output) bit2=DTR (=output) bit 6=RTS (=output)
// unused inputs: bit1=RxD bit 3=DCD bit 5 = RING
// handshake inputs: bit 4=DSR (0x10) bit 7=CTS (0x80)
//qDebug()<<"serial port pins: " << rs232pins;
return rs232pins;
}
bool T_com::getHSin_CTS(void)
{
// return the used Handshake IN (CTS, alt. DSR): true= high level (+8V)
uint8_t rs232pins=0;
rs232pins= uint8_t(CatSerial->pinoutSignals());
// rs232pins: all signals bitwise coded in one byte:
// readback output: bit 0=TxD(=output) bit2=DTR (=output) bit 6=RTS (=output)
// unused inputs: bit1=RxD bit 3=DCD bit 5 = RING
// handshake inputs: bit 4=DSR (0x10) bit 7=CTS (0x80)
if (rs232pins & 0x80) // CTS
return true;
return false;
}
bool T_com::getHSin_DSR(void)
{
uint8_t rs232pins=0;
rs232pins= uint8_t(CatSerial->pinoutSignals());
if (rs232pins & 0x10) // DSR
return true;
return false;
}
void T_com::incomingWake(void) //(bool LevelOfTheBit)
{
emit wasWokenBySerialHandshake();
}
bool T_com::setHSout_RTS(bool hsout)
{
// hsout true=positiv voltage +12V false= -12V
// retval: true=setting OK
bool cc;
// 10.5.19, am Windows-PC nachgemessen, funktioniert gut
// false ergibt -12V true ergibt +12V
cc=CatSerial->setRequestToSend(hsout); // RTS out
// retval true means "setting was successful"
// alternative: use DTR as Handshake:
//cc=CatSerial->setDataTerminalReady(false); // DTR out
// retval true means "setting was successful"
//qDebug()<<"RTS " <<cc;
return cc;
}
bool T_com::setHSout_DTR(bool hsout)
{
// hsout true=positiv voltage +12V false= -12V
// retval: true=setting OK
bool cc;
// 10.5.19, am Windows-PC nachgemessen, funktioniert gut
// false ergibt -12V true ergibt +12V
cc=CatSerial->setDataTerminalReady(hsout); // DTR out
// retval true means "setting was successful"
//qDebug()<<"DTR " <<cc;
return cc;
}
*/

View File

@ -1,326 +0,0 @@
#include <stdint.h>
#include <algorithm>
#include <QString>
#include <QDebug>
#include "tslib.h"
#include "shared_mem_buffer.h"
// ///////////////////////////////////////////////////////////////////////////////////
// control serial interface gui <--> serial
// ///////////////////////////////////////////////////////////////////////////////////
void epi_setSerial(int BaudNr,
QString BaudStr,
QString ComName,
uint8_t connect) {
memset(&SharedMemBuffer::getData()->rs.comportName[0], 0x00,
sizeof(SharedMemBuffer::getData()->rs.comportName));
strncpy(SharedMemBuffer::getData()->rs.comportName,
ComName.toStdString().c_str(),
sizeof(SharedMemBuffer::getData()->rs.comportName)-1);
memset(&SharedMemBuffer::getData()->rs.baudStr[0], 0x00,
sizeof(SharedMemBuffer::getData()->rs.baudStr));
strncpy(SharedMemBuffer::getData()->rs.baudStr,
BaudStr.toStdString().c_str(),
sizeof(SharedMemBuffer::getData()->rs.baudStr)-1);
SharedMemBuffer::getData()->rs.baudNr = BaudNr;
SharedMemBuffer::getData()->rs.connect = connect;
}
void epi_closeSerial(void) {
SharedMemBuffer::getData()->rs.connect = 0;
}
void gpi_serialChanged(void) {
// serial confirms that port was closed or opened
// rs_connect=2; // Flanke, nur 1x öffnen/schließen
SharedMemBuffer::getData()->rs.connect = 2;
}
uint8_t gpi_getSerialConn(void) {
return SharedMemBuffer::getDataConst()->rs.connect;
}
int gpi_getBaudNr(void) {
return SharedMemBuffer::getDataConst()->rs.baudNr;
}
QString gpi_getComPortName(void) {
return SharedMemBuffer::getDataConst()->rs.comportName;
}
void gpi_serialIsOpen(bool offen) {
SharedMemBuffer::getData()->rs.portIsOpen = offen;
}
bool epi_isSerialPortOpen() {
// true: port is open false: port is closed
return SharedMemBuffer::getDataConst()->rs.portIsOpen;
}
// ///////////////////////////////////////////////////////////////////////////////////
// Control transfer gui <--> serial
// ///////////////////////////////////////////////////////////////////////////////////
void epi_startEmmision(char start) {
SharedMemBuffer::getData()->AutoEmissionOn = start;
}
bool gpi_isEmmisionOn(void) {
return SharedMemBuffer::getDataConst()->AutoEmissionOn;
}
uint16_t gpi_getPeriodicSendTimeVal() {
SharedMemBuffer::getData()->datif.sendingPer_changed = 0;
if ((SharedMemBuffer::getDataConst()->datif.sendingPeriod < 3) ||
(SharedMemBuffer::getDataConst()->datif.sendingPeriod > 10000)) {
return 130; // ms, default
}
return SharedMemBuffer::getDataConst()->datif.sendingPeriod;
}
void epi_setPeriodicSendTimeVal(uint16_t val) {
if (val>=3 && val<10000) {
SharedMemBuffer::getData()->datif.sendingPer_changed = 1;
SharedMemBuffer::getData()->datif.sendingPeriod = val;
}
}
bool gpi_PeriodicSendTimeHasChanged() {
return SharedMemBuffer::getDataConst()->datif.sendingPer_changed;
}
// ///////////////////////////////////////////////////////////////////////////////////
// Status Display gui <--> serial
// ///////////////////////////////////////////////////////////////////////////////////
// linke Spalte, über Connect Button
static QString txt4comStateLine;
QString epi_getTxt4comStateLine(void) {
// GUI: get Text for serial Comport-State Line
return txt4comStateLine;
}
void gpi_setTxt4comStateLine(QString txtline) {
// serial: write Text to be displayed in serial Comport-State line (like "connected")
txt4comStateLine.clear();
if (txtline=="")
txt4comStateLine.clear();
else
txt4comStateLine=txtline;
}
void epi_clrTxt4comStateLine() {
txt4comStateLine.clear();
}
// rechte Spalte, oberste Statuszeile
// I) "Handshakes" (serial Control) flow.cpp
// geht überhaupt was raus? kommt überhaupt was zurück?
static QString txt4HsStateLine;
QString epi_getTxt4HsStateLine(void) {
return txt4HsStateLine;
}
void gpi_setTxt4HsStateLine(QString txtline) {
txt4HsStateLine.clear();
if (txtline=="")
txt4HsStateLine.clear();
else
txt4HsStateLine=txtline;
}
void epi_clrTxt4HsStateLine() {
txt4HsStateLine.clear();
}
// II) Master receive state (empfangenes Telgramm OK? crc? length? )
// Statuszeile Auswertung der SlaveResponse (serial Frame, CRC usw) (prot.cpp)
static QString txt4masterStateLine;
QString epi_getTxt4masterStateLine(void) {
return txt4masterStateLine;
}
void gpi_setTxt4masterStateLine(QString txtline) {
txt4masterStateLine.clear();
if (txtline=="")
txt4masterStateLine.clear();
else
txt4masterStateLine=txtline;
}
void epi_clrTxt4masterStateLine() {
txt4masterStateLine.clear();
}
//---------------------------------------------------------------------------------------------
// III Slave receive (from Master) OK? if then show results, if not then show errors
// entweder Empfangsfehler anzeigen (crc? length?) oder result OUT-OK, OUT_ERR, IN_OK, IN_ERR
// Hintergrund: wenn der Slave Fehler im Master-Telegramm gefunden hat, dann kann er es auch
// nicht verwenden und nichts ausgeben oder einlesen
static QString txt4resultStateLine;
QString epi_getTxt4resultStateLine(void) {
return txt4resultStateLine;
}
void gpi_setTxt4resultStateLine(QString txtline) {
txt4resultStateLine.clear();
if (txtline=="")
txt4resultStateLine.clear();
else
txt4resultStateLine=txtline;
}
void epi_clrTxt4resultStateLine() {
txt4resultStateLine.clear();
}
//---------------------------------------------------------------------------------------------
// IV Statuszeile Empfangsdaten
static QString txt4dataLine;
QString epi_getTxt4dataStateLine(void) {
// GUI: get Text for serial Comport-State Line
return txt4dataLine;
}
void gpi_setTxt4dataStateLine(QString txtline) {
// serial: write Text to be displayed in serial Comport-State line (like "connected")
txt4dataLine.clear();
if (txtline=="")
txt4dataLine.clear();
else
txt4dataLine=txtline;
}
void epi_clrTxt4dataStateLine() {
txt4dataLine.clear();
}
//---------------------------------------------------------------------------------------------
// 5. Zeile: Datif Ergebnis, Daten brauchbar?
static QString txt4datifReceive;
QString epi_getTxt4datifLine(void) {
return txt4datifReceive;
}
void gpi_setTxt4datifLine(QString txtline) {
txt4datifReceive.clear();
if (txtline=="")
txt4datifReceive.clear();
else
txt4datifReceive=txtline;
}
void epi_clrTxt4datifLine() {
txt4datifReceive.clear();
}
//---------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------
static QString txt4diagWindow;
QString epi_getTxt4RsDiagWin(void) {
return txt4diagWindow;
}
void gpi_setTxt4RsDiagWin(QString txtline) {
txt4diagWindow.clear();
if (txtline=="")
txt4diagWindow.clear();
else
txt4diagWindow=txtline;
}
void epi_clrTxt4RsDiagWin() {
txt4diagWindow.clear();
}
//---------------------------------------------------------------------------------------------
static QString sndTxt4diagWindow;
QString epi_get2ndTxt4RsDiagWin(void) {
return sndTxt4diagWindow;
}
void gpi_set2ndTxt4RsDiagWin(QString txtline) {
sndTxt4diagWindow.clear();
if (txtline=="")
sndTxt4diagWindow.clear();
else
sndTxt4diagWindow=txtline;
}
void epi_clr2ndTxt4RsDiagWin() {
sndTxt4diagWindow.clear();
}
// ///////////////////////////////////////////////////////////////////////////////////
// Memory for Slave responses, common data
// ///////////////////////////////////////////////////////////////////////////////////
void gpi_storeResult_serialTestOK(bool wasOk) {
SharedMemBuffer::getData()->Sdata.serialTestResult = wasOk;
}
bool epi_getResult_serialTestOK() {
// retval: true: test was successful, got right response
return SharedMemBuffer::getDataConst()->Sdata.serialTestResult;
}
// ///////////////////////////////////////////////////////////////////////////////////
// Store received data for hwapi
// ///////////////////////////////////////////////////////////////////////////////////
void gpi_startNewRequest() {
SharedMemBuffer::getData()->Sdata.pProtResultOk = 0;
}
void gpi_storeResultOfLastRequest(bool answisok) {
SharedMemBuffer::getData()->Sdata.pProtResultOk = answisok ? 1 : 2;
}
uint8_t epi_getResultOfLastRequest() {
// retval: 0: in progress 1: OK 2: error
return SharedMemBuffer::getDataConst()->Sdata.pProtResultOk;
}
void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t const *receivedData) {
SharedMemBuffer::getData()->Sdata.receivedDataLength
= std::min(RdDlen, (uint8_t)(64));
memset((char *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
0x00, sizeof(SharedMemBuffer::getData()->Sdata.receivedDataBlock));
strncpy((char *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
(char const *)receivedData,
sizeof(SharedMemBuffer::getData()->Sdata.receivedDataBlock)-1);
}
uint16_t epi_getLastPayLoad(uint16_t plBufSiz, uint8_t *payLoad) {
// get data back in *pl, max 64 byte
// retval = nr of bytes received. If host buffer too small then
// only plBufSíz bytes are copied to pl
// plBufSíz=size of host buffer
uint16_t ml = std::min(plBufSiz, (uint16_t)(64));
if (SharedMemBuffer::getDataConst()->Sdata.receivedDataLength < ml) {
ml = SharedMemBuffer::getDataConst()->Sdata.receivedDataLength;
}
strncpy((char *)payLoad,
(char const *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
ml);
return SharedMemBuffer::getDataConst()->Sdata.receivedDataLength;
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,25 +0,0 @@
#include <stdint.h>
#include "hwChk.h"
hwChk::hwChk(QWidget *parent) : QObject(parent)
{
// myDCIF = new T_prot();
// h: T_prot *myDCIF;
//myDatif = new T_datif();
HWaccess = new hwinf();
struct T_moduleCondition dcModCond;
sys_getDeviceConditions(dcModCond);
}
hwChk::~hwChk()
{
}

File diff suppressed because it is too large Load Diff

View File

@ -1,764 +0,0 @@
#include "prot.h"
#include <QDebug>
#include "controlBus.h"
#include "dcBL.h"
T_prot::T_prot()
{
mySerialPort = new T_com();
connect(mySerialPort, SIGNAL(receivingFinished()), this, SLOT( analyseRecData() ));
//connect(mySerialPort, SIGNAL(sendingFinished()), this, SLOT(sendeFin()));
for (int nn=0; nn<FRAME_DATALEN; nn++)
{
chOut_Data[nn]=0;
ui8OutputData[nn]=0;
InputData[nn]=0;
}
for (int nn=0; nn<BL_DATA_LEN; nn++)
{
ui8BLsendData[nn]=0;
}
WriteCommand=0;
WriteAddr=0;
WrDataLength=0;
SendDataValid=0;
kindOfData=0;
slaveAddr=0;
ReadCommand=0;
ReadAddr=0;
reserve =0;
RecSlaveAddr =0;
INdataValid=0;
readSource =0;
readAddress=0;
RdDataLength=0;
BLsendDataLength=0;
}
// ---------------------------------------------------------------------------------------------------------
// sending.....
// ---------------------------------------------------------------------------------------------------------
bool T_prot::isPortOpen(void)
{
return mySerialPort->isPortOpen();
}
bool T_prot::isSerialFree(void)
{
return true; // ohne HS's kann er nicht blockiert sein
}
void T_prot::setRecLen(uint16_t WriteCmd)
{
if (WriteCmd<100)
{
RdDataLength=DATALEN_RECEIVE_LONG; // store here already because it's no longer
// returned from slave
mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_LONG);
} else
{
RdDataLength=DATALEN_RECEIVE_FAST;
mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_FAST);
}
}
void T_prot::setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr, uint8_t WrDatLen, uint8_t *data)
{
WriteCommand=WriteCmd;
WriteAddr=WrAddr;
WrDataLength=WrDatLen;
if (WrDataLength>FRAME_DATALEN)
WrDataLength=FRAME_DATALEN;
for (int nn=0; nn<WrDataLength; nn++)
ui8OutputData[nn]=data[nn];
SendDataValid=1; // always set WR first
kindOfData=0; // 0: binaries, 1:text
this->setRecLen(WriteCmd);
}
void T_prot::setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr)
{
WriteCommand=WriteCmd;
WriteAddr=WrAddr;
WrDataLength=0;
for (int nn=0; nn<FRAME_DATALEN; nn++)
ui8OutputData[nn]=0;
SendDataValid=1; // always set WR first
kindOfData=0; // 0: binaries, 1:text
this->setRecLen(WriteCmd);
}
void T_prot::setUserWriteData(uint16_t WriteCmd)
{
WriteCommand=WriteCmd;
WriteAddr=0;
WrDataLength=0;
for (int nn=0; nn<FRAME_DATALEN; nn++)
ui8OutputData[nn]=0;
SendDataValid=1; // always set WR first
kindOfData=0; // 0: binaries, 1:text
this->setRecLen(WriteCmd);
}
void T_prot::setUserWrite1DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val)
{
// wie oben, jedoch einfachere Datenübergabe
WriteCommand=WriteCmd;
WriteAddr=WrAddr;
WrDataLength=1;
ui8OutputData[0]=val;
SendDataValid=1; // always set WR first
kindOfData=0; // 0: binaries, 1:text
this->setRecLen(WriteCmd);
}
void T_prot::setUserWrite2DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val0, uint8_t val1)
{
WriteCommand=WriteCmd;
WriteAddr=WrAddr;
WrDataLength=2;
ui8OutputData[0]=val0;
ui8OutputData[1]=val1;
SendDataValid=1; // always set WR first
kindOfData=0; // 0: binaries, 1:text
this->setRecLen(WriteCmd);
}
void T_prot::setUserWriteText(uint16_t WriteCmd, uint16_t WrAddr, uint8_t WrDatLen, char *data)
{
WriteCommand=WriteCmd;
WriteAddr=WrAddr;
WrDataLength=WrDatLen;
if (WrDataLength>FRAME_DATALEN)
WrDataLength=FRAME_DATALEN;
for (int nn=0; nn<WrDataLength; nn++)
chOut_Data[nn]=data[nn];
SendDataValid=1; // always set WR first
kindOfData=1; // 0: binaries, 1:text
this->setRecLen(WriteCmd);
}
void T_prot::setUserReadData( uint16_t ReadCmd, uint16_t RdAddr, uint16_t reserv)
{
ReadCommand=ReadCmd;
ReadAddr=RdAddr;
reserve=reserv;
SendDataValid |=2;
readAddress=RdAddr; // store here already because it's no longer returned from slave
readSource=ReadCmd;
}
void T_prot::setUserReadData( uint16_t ReadCmd, uint16_t RdAddr)
{
ReadCommand=ReadCmd;
ReadAddr=RdAddr;
reserve=0;
SendDataValid |=2;
readAddress=RdAddr; // store here already because it's no longer returned from slave
readSource=ReadCmd;
}
void T_prot::setUserReadData( uint16_t ReadCmd)
{
ReadCommand=ReadCmd;
ReadAddr=0;
reserve=0;
SendDataValid |=2;
readAddress=0; // store here already because it's no longer returned from slave
readSource=ReadCmd;
}
void T_prot::setBLsendData( uint8_t len, uint8_t *buf)
{
for (int nn=0; nn<BL_DATA_LEN; nn++)
ui8BLsendData[nn]=0;
BLsendDataLength=len;
if ( BLsendDataLength>BL_DATA_LEN) BLsendDataLength=BL_DATA_LEN;
for (int nn=0; nn<BLsendDataLength; nn++)
ui8BLsendData[nn]=buf[nn];
WriteCommand=0xFFFF;
this->setRecLen(100); // how many??
//readAddress= // needed??
//qDebug()<<"prot: got BL data " << len << "bytes, ";
//for (int i=0; i<len; ++i) {
// printf("%02x ", (unsigned char)buf[i]);
//} printf("\n");
/*
qDebug()<<buf[0] <<buf[1] <<buf[2] <<buf[3] <<buf[4] <<buf[5] <<buf[6] <<buf[7];
qDebug() <<buf[8] <<buf[9] <<buf[10] <<buf[11] <<buf[12] <<buf[13]<<buf[14]<<buf[15];
qDebug() <<buf[16] <<buf[17] <<buf[18] <<buf[19] <<buf[20] <<buf[21]<<buf[22]<<buf[23];
qDebug() <<buf[24] <<buf[25] <<buf[26] <<buf[27] <<buf[28] <<buf[29]<<buf[30]<<buf[31];
qDebug() <<buf[32] <<buf[33] <<buf[34] <<buf[35] <<buf[36] <<buf[37]<<buf[38]<<buf[39];
qDebug() <<buf[40] <<buf[41] <<buf[42] <<buf[43] <<buf[44] <<buf[45]<<buf[46]<<buf[47];
qDebug() <<buf[48] <<buf[49] <<buf[50] <<buf[51] <<buf[52] <<buf[53] <<buf[54]<<buf[55];
qDebug() <<buf[56] <<buf[57] <<buf[58] <<buf[59] <<buf[60] <<buf[61] <<buf[62]<<buf[63];
qDebug() <<buf[64] <<buf[65] <<buf[66] <<buf[67] <<buf[68] <<buf[69] <<buf[70]<<buf[71];
qDebug() <<buf[72] <<buf[73] <<buf[74] <<buf[75] <<buf[76] <<buf[77] <<buf[78]<<buf[79];
*/
}
void T_prot::receiveFixLen(int64_t nrOfbytesToReceive)
{
mySerialPort->receiveFixLen(nrOfbytesToReceive);
}
void T_prot::sendUserData(uint16_t slaveAdr)
{
// man könnte hier noch "SendDataValid" abfragen,
// muss immer 3 sein, muss man aber nicht
//qDebug() << "prot send user data "<<slaveAdr;
QByteArray packBuf_2;
slaveAddr=slaveAdr;
if (WriteCommand==0xFFFF)
{
// Bypass for bootloader, no protocol frame but send as is...
packBuf_2.clear();
for (int nn=0; nn<BLsendDataLength; nn++)
packBuf_2[nn]=char(ui8BLsendData[nn]);
mySerialPort->writeToSerial(packBuf_2, BLsendDataLength);
} else
startFastPacking(); // quicker since 15.12.21TS
//startPacking();
}
void T_prot::startFastPacking(void)
{
uint16_t mycrc;
uint16_t sendLen;
uint8_t uctmp, nn, pp, CrcLp;
char sendBuffer[FRAME_MAXLEN], ctmp;
//qDebug() << "prot start fast packing "<<slaveAddr;
for (int nn=0; nn<FRAME_MAXLEN; nn++)
sendBuffer[nn]=0;
if (WriteCommand>9 && WriteCommand<100)
{
// long command 10...99
// WriteCommand==0 if only read request, then use short sending
sendBuffer[0]=STARTSIGN_SEND_LONG;
WrDataLength=DATALEN_SEND_LONG; // immer
//qDebug() << "send long cmd, len: " << WrDataLength;
} else
{
// fast command
sendBuffer[0]=STARTSIGN_SEND_FAST;
WrDataLength=DATALEN_SEND_FAST; // immer
//qDebug() << "send fast cmd, len: " << WrDataLength;
}
sendBuffer[1]= uint8_t(WriteCommand);
sendBuffer[2]= uint8_t(ReadCommand);
if (WriteAddr>0)
sendBuffer[3]= char(WriteAddr); // bei fast nur EINE adresse, wr hat Vorrang
else
sendBuffer[3]= char(ReadAddr);
// beim Fast prot. ist das reserve dann ists egal was drin steht
if (kindOfData) // 0: binaries, 1:text
{
for (nn=0; nn<WrDataLength; nn++)
{
pp=HEADERLEN_SEND+nn;
ctmp=(chOut_Data[nn]); // text
sendBuffer[pp]= char(ctmp);
}
} else
{
for (nn=0; nn<WrDataLength; nn++)
{
pp=HEADERLEN_SEND+nn;
uctmp=(ui8OutputData[nn]); // bin
sendBuffer[pp]= char(uctmp);
}
}
CrcLp= HEADERLEN_SEND + WrDataLength;
mycrc=0;
for (nn=0; nn<CrcLp; nn++)
{
uctmp=sendBuffer[nn];
mycrc+=uint16_t(uctmp);
//qDebug() << mycrc;
}
sendBuffer[CrcLp]=char(mycrc);
mycrc>>=8;
sendBuffer[CrcLp+1]=char(mycrc);
sendLen=CrcLp+2;
// send to VCP:
QByteArray packBuff;
packBuff.clear();
packBuff.append(sendBuffer, sendLen); // ohne sendLen wird beim ersten \0 abgeschnitten!!!
mySerialPort->writeToSerial(packBuff, sendLen);
}
/*
void T_prot::startPacking(void)
{
uint16_t mycrc;
uint16_t uitmp, sendLen;
uint8_t uctmp, nn, pp, CrcLp;
char sendBuffer[FRAME_MAXLEN], ctmp;
//qDebug() << "prot start packing "<<slaveAddr;
for (int nn=0; nn<FRAME_MAXLEN; nn++)
sendBuffer[nn]=0;
sendBuffer[0]='>';
uitmp=slaveAddr;
sendBuffer[1]= char(uitmp);
uitmp>>=8;
sendBuffer[2]= char(uitmp);
uitmp=WriteCommand;
sendBuffer[3]= char(uitmp);
uitmp>>=8;
sendBuffer[4]= char(uitmp);
uitmp=WriteAddr;
sendBuffer[5]= char(uitmp);
uitmp>>=8;
sendBuffer[6]= char(uitmp);
uitmp=ReadCommand;
sendBuffer[7]= char(uitmp);
uitmp>>=8;
sendBuffer[8]= char(uitmp);
uitmp=ReadAddr;
sendBuffer[9]= char(uitmp);
uitmp>>=8;
sendBuffer[10]= char(uitmp);
uitmp=reserve;
sendBuffer[11]= '-'; //char(uitmp);
uitmp>>=8;
sendBuffer[12]= '-'; //char(uitmp);
sendBuffer[13]= char(WrDataLength);
CrcLp= 14 + WrDataLength;
if (kindOfData) // 0: binaries, 1:text
{
for (nn=0; nn<WrDataLength; nn++)
{
pp=14+nn;
ctmp=(chOut_Data[nn]);
sendBuffer[pp]= ctmp;
}
} else
{
for (nn=0; nn<WrDataLength; nn++)
{
pp=14+nn;
uctmp=(ui8OutputData[nn]);
sendBuffer[pp]= char(uctmp);
}
}
mycrc=0;
for (nn=0; nn<CrcLp; nn++)
{
uctmp=sendBuffer[nn];
mycrc+=uint16_t(uctmp);
//qDebug() << mycrc;
}
sendBuffer[CrcLp]=char(mycrc);
mycrc>>=8;
sendBuffer[CrcLp+1]=char(mycrc);
sendLen=CrcLp+2;
sendBuffer[CrcLp+2]=13;
sendBuffer[CrcLp+3]=10;
sendLen+=2;
// send to VCP:
QByteArray packBuff;
packBuff.clear();
packBuff.append(sendBuffer, sendLen); // ohne sendLen wird beim ersten \0 abgeschnitten!!!
mySerialPort->writeToSerial(packBuff, sendLen);
// void T_com::writeToSerial(const QByteArray &data, uint16_t sendLength)
}
*/
// ---------------------------------------------------------------------------------------------------------
// receiving.....
// ---------------------------------------------------------------------------------------------------------
void T_prot::analyseRecData(void)
{
// Aufruf per connect aus serialcontrol wenn Daten empfangen wurden
// getRecData(QByteArray &data, uint16_t &sendLength);
QByteArray Indata;
QString myString, tempStr;
//char recBuffer[FRAME_MAXLEN];
uint8_t recBuffer[FRAME_MAXLEN];
uint16_t recLength;
INdataValid=false;
gpi_setTxt4HsStateLine("");
gpi_setTxt4masterStateLine("");
gpi_setTxt4resultStateLine("");
gpi_setTxt4dataStateLine("");
gpi_setTxt4datifLine("");
// read from "VCP":
mySerialPort->readFromSerial(Indata, recLength);
//qDebug()<<"prot: got data " << recLength;
if (recLength>FRAME_MAXLEN)
recLength=FRAME_MAXLEN;
for (int nn=0; nn<recLength; nn++)
recBuffer[nn]=uint8_t(Indata[nn]);
myString.clear();
tempStr.clear();
//uint8_t result=FramecheckInData(recBuffer, recLength); // check input data (response from slave)
uint8_t result=FastCheckInData(recBuffer, recLength); // check input data (response from slave)
if (result>0)
{
// dann anzeige
switch (result)
{
case 1: gpi_setTxt4masterStateLine("wrong length received"); break;
case 2: gpi_setTxt4masterStateLine("wrong start sign received"); break;
case 3: gpi_setTxt4masterStateLine("received datalen too big"); break;
case 4: gpi_setTxt4masterStateLine("wrong data len received"); break;
case 5: gpi_setTxt4masterStateLine("wrong crc received"); break;
}
myString.setNum(result);
// Daten abspeichern, könnten vom BL sein:
gpi_storeRawReceivedData(uint8_t(recLength), recBuffer);
emit rawDataRecieved();
} else
{
//& result ==0
gpi_setTxt4masterStateLine("slave response OK");
// Daten OK, also prüfe Inhalt.
// Konnte der Slave das Master-Command verwenden oder hatte es Fehler?
// konnte der Slave die geforderten Daten ausgeben (DOs, AOs)?
// konnte der Slave die geforderten Daten einlesen (AIs, DIs)?
//CheckInResult(recBuffer); // Ergebnisse des Slaves anzeigen
// stimmt nicht mehr bei FastProt
ShowFastInData(recBuffer); // Eingangs-Daten des Slaves anzeigen
}
emit framerecieved();
//qDebug() << "framereceived emitted";
}
uint8_t T_prot::FastCheckInData(uint8_t *Inbuf, uint16_t LL)
{
uint16_t rawInLen=LL, crcL_Addr, recCrc, myCrc, nn, datalen, nxt;
if (Inbuf[0]!=STARTSIGN_RECEIVE_FAST && Inbuf[0]!=STARTSIGN_RECEIVE_LONG)
{
//qDebug() << "prot: got wrong start sign: " << Inbuf[0];
return 2; // wrong start sign
}
if ( (rawInLen<TELEGRAMLEN_RECEIVE_FAST && Inbuf[0]==STARTSIGN_RECEIVE_FAST) ||
(rawInLen<TELEGRAMLEN_RECEIVE_LONG && Inbuf[0]==STARTSIGN_RECEIVE_LONG) )
{
//qDebug("prot: got %d bytes only", rawInLen);
return 1; // wrong length
}
if (Inbuf[0]==0x5F)
datalen=DATALEN_RECEIVE_FAST;
else
datalen=DATALEN_RECEIVE_LONG;
crcL_Addr=datalen+HEADERLEN_RECEIVE; // weil im definierten protocol 2 bytes vor den Daten stehen
recCrc=0;
recCrc=uchar2uint(uint8_t(Inbuf[crcL_Addr+1]), uint8_t(Inbuf[crcL_Addr]));
myCrc=0;
for (nn=0; nn<crcL_Addr; nn++)
{
nxt=uint16_t (Inbuf[nn]);
nxt &=0x00FF; // the casting makes 0xFFFF out of 0xFF !!!!!!!!!
myCrc+=nxt;
//qDebug("CRC: nxt: %d sum: %d", nxt, myCrc);
}
if (myCrc != recCrc)
{
//qDebug() << "crc does not match: mycrc=" << myCrc<< " receivedCRC=" << recCrc;
//qDebug("calculated over %d bytes", crcL_Addr);
return 5; // crc wrong
}
return 0;
}
/*
uint8_t T_prot::FramecheckInData(uint8_t *Inbuf, uint16_t LL)
{
uint16_t rawInLen=LL, crcL_Addr, recCrc, myCrc, nn, datalen, nxt;
if (rawInLen<12)
{
qDebug("prot: got %d bytes only", rawInLen);
return 1; // wrong length
}
if ( Inbuf[0] != '<')
return 2; // wrong start sign
datalen=uint16_t(Inbuf[9]);
if ( datalen > FRAME_DATALEN) //[9]=reported data lenght
return 3; // reported datalen too big
if ((datalen !=(rawInLen-12)) && (datalen !=(rawInLen-13)) && (datalen !=(rawInLen-14)) )
{
// angehängtes CR und/oder LF tolerieren
qDebug() << "wrong data length, " << datalen << " " << rawInLen;
return 4; // data len does not match to complete length
}
crcL_Addr=datalen+10; // weil im definierten protocol 10 bytes vor den Daten stehen
recCrc=0;
recCrc=uchar2uint(uint8_t(Inbuf[crcL_Addr+1]), uint8_t(Inbuf[crcL_Addr]));
myCrc=0;
for (nn=0; nn<crcL_Addr; nn++)
{
nxt=uint16_t (Inbuf[nn]);
nxt &=0x00FF; // the casting makes 0xFFFF out of 0xFF !!!!!!!!!
myCrc+=nxt;
//qDebug("CRC: nxt: %d sum: %d", nxt, myCrc);
}
if (myCrc != recCrc)
{
qDebug() << "crc does not match: mycrc=" << myCrc<< " receivedCRC=" << recCrc;
qDebug("calculated over %d bytes", crcL_Addr);
return 5; // crc wrong
}
return 0;
}
*/
uint8_t T_prot::CheckInResult(uint8_t *Inbuf)
{
char slaveresult;
QString myString=nullptr, tempStr=nullptr;
// slave results anzeigen
slaveresult=Inbuf[2]; // hier steht das "Command Result" des slaves,
// d.h das Ergebnis der Protokol-Prüfung (Master->Slave)
switch (slaveresult)
{
// received message (from master) analysis:
// 0: got valid request
// this errors can only come back from a single device (not bus)
// or from a bus slave in local mode
// 1: wrong start 2: wrong length
// 3: wrong crc 4: wrong addr
case 1: gpi_setTxt4resultStateLine("slave got wrong start sign"); break;
case 2: gpi_setTxt4resultStateLine("slave got wrong length"); break;
case 3: gpi_setTxt4resultStateLine("slave got wrong crc"); break;
case 4: gpi_setTxt4resultStateLine("slave got wrong addr"); break;
case 10: gpi_setTxt4resultStateLine("slave is in local mode"); break;
case 13: gpi_setTxt4resultStateLine("local mode with wrong crc"); break;
case 14: gpi_setTxt4resultStateLine("local mode with wrong addr"); break;
// wenn 1..4 dann konnte der Slave das Mastertelegramm gar nicht verwenden, also hier Stoppen
}
if (slaveresult>0 && slaveresult<10)
return 1;
// Slave hat gültiges Kommando empfangen:
// 2.result auswerten:
// recBuffer[3]; // Write result, d.h. Ergebnis des Schreibvorganges (z.B. DOs) des Slaves
// recBuffer[4]; // Read result, d.h. Ergebnis des Lesevorganges (z.B. DIs) des Slaves
// bisher nicht bekannt welche Fehlercodes es gibt, also den code direkt ausgeben.
// bisher bekannt: 0=OK
myString.clear();
myString = "Slave OUT and IN Result: ";
tempStr.setNum(Inbuf[3],16);
myString.append(tempStr);
myString.append(" ");
tempStr.setNum(Inbuf[4],16);
myString.append(tempStr);
gpi_setTxt4resultStateLine(myString);
return 0;
}
uint8_t T_prot::ShowFastInData(uint8_t *recBuffer)
{
QString myString=nullptr, tempStr=nullptr;
uint8_t result;
RecSlaveAddr=0;
result=recBuffer[1]; // total result
result &=0x60; // only read result (bit 5,6)
if (result==0) // read result =OK,
// dann sind die Eingangsdaten gültig
{
myString.append("valid INdata: ");
INdataValid=true;
//readSource already set with sending
readAddress=0;
// RdDataLength already set with sending
if (RdDataLength>FRAME_DATALEN)
RdDataLength=FRAME_DATALEN;
for (int ii=0; ii<RdDataLength; ii++)
InputData[ii]=uint8_t(recBuffer[ii+HEADERLEN_RECEIVE]);
tempStr.setNum(readSource,16);
myString.append(tempStr);
myString.append(" add:");
tempStr.setNum(readAddress);
myString.append(tempStr);
//myString.append(" wakeSrc:");
//tempStr.setNum(lastWakeSrc);
//myString.append(tempStr);
myString.append(" Dlen:");
tempStr.setNum(RdDataLength);
myString.append(tempStr);
} else
{
myString=" "; // Eingangsdaten nicht gültig, sieht man aber weiter oben schon
}
gpi_setTxt4dataStateLine(myString);
//qDebug() << myString;
//qDebug("prot_checkInData_bindata: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d ",
// InputData[0], InputData[1], InputData[2], InputData[3],
// InputData[4], InputData[5], InputData[6], InputData[7],
// InputData[8], InputData[9], InputData[10], InputData[11],
// InputData[12], InputData[13], InputData[14], InputData[15]);
return 0;
}
/*
uint8_t T_prot::ShowInData(uint8_t *recBuffer)
{
QString myString=nullptr, tempStr=nullptr;
RecSlaveAddr=recBuffer[1];
if (recBuffer[2]==0 && recBuffer[4]==0) // comand result=OK und read result =OK,
// dann sind die Eingangsdaten gültig
{
myString.append("valid INdata: ");
INdataValid=true;
readSource=uchar2uint(recBuffer[6],recBuffer[5]);
readAddress=uchar2uint(recBuffer[8],recBuffer[7]);
//lastWakeSrc=uint8_t(recBuffer[4]);
RdDataLength=uint8_t(recBuffer[9]);
if (RdDataLength>FRAME_DATALEN)
RdDataLength=FRAME_DATALEN;
for (int ii=0; ii<RdDataLength; ii++)
InputData[ii]=uint8_t(recBuffer[ii+10]);
tempStr.setNum(readSource,16);
myString.append(tempStr);
myString.append(" add:");
tempStr.setNum(readAddress);
myString.append(tempStr);
//myString.append(" wakeSrc:");
//tempStr.setNum(lastWakeSrc);
//myString.append(tempStr);
myString.append(" Dlen:");
tempStr.setNum(RdDataLength);
myString.append(tempStr);
} else
{
myString=" "; // Eingangsdaten nicht gültig, sieht man aber weiter oben schon
}
gpi_setTxt4dataStateLine(myString);
//qDebug() << myString;
//qDebug("prot_checkInData_bindata: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d ",
// InputData[0], InputData[1], InputData[2], InputData[3],
// InputData[4], InputData[5], InputData[6], InputData[7],
// InputData[8], InputData[9], InputData[10], InputData[11],
// InputData[12], InputData[13], InputData[14], InputData[15]);
return 0;
}
*/
bool T_prot::ifDataReceived()
{
return INdataValid;
}
bool T_prot::getReceivedInData(uint8_t *SlavAddr, uint16_t *readSrc, uint16_t *readAddr,
uint8_t *RdDlen, uint8_t *receivedData)
{
uint8_t nn;
*SlavAddr=RecSlaveAddr;
*readSrc=readSource; // diese (Eingangs-)Daten stehen im Puffer
*readAddr=readAddress; // von dieser Adr wurden die Daten gelesen
//*lastWakSourc=lastWakeSrc; // falls der Slave den Master geweckt hat
*RdDlen=RdDataLength;
for (nn=0; nn<FRAME_DATALEN; nn++)
receivedData[nn]=0;
for (nn=0; nn<RdDataLength; nn++)
receivedData[nn]=InputData[nn];
return INdataValid; // nur true wenn CommandState OK und readState OK
}

View File

@ -1,704 +0,0 @@
#include <stdint.h>
#include <QString>
#include <QDebug>
#include "tslib.h"
#include "sendWRcmd.h"
void indat_PrnPwr(void);
void sendWRcmd_INI(void)
{
sendWRcmd_clrCmdStack();
sendWRcmd_clrCmd4Stack();
sendFDcmd_clrStack();
longFDcmd_clrStack();
}
// Command Stack for commands without parameters
static uint16_t nextAsynchsendCmd0[CMDSTACKDEPTH];
static uint8_t nrOfCmdsInQueue;
/* convention: use simple (not rotating) FIFO Stack:
Example: nrOfCmdsInQueue=4 then
nextAsynchsendCmd0[0]=cmd1 // was stored as first
nextAsynchsendCmd0[1]=cmd2
nextAsynchsendCmd0[2]=cmd3
nextAsynchsendCmd0[3]=cmd4 // came in as last
Send: [0] first, then move buffer 1 down:
nextAsynchsendCmd0[0]=cmd2
nextAsynchsendCmd0[1]=cmd3
nextAsynchsendCmd0[2]=cmd4
nextAsynchsendCmd0[3]=0;
nrOfCmdsInQueue=3 now
*/
void sendWRcmd_clrCmdStack(void)
{
uint8_t nn;
for (nn=0; nn<CMDSTACKDEPTH; nn++)
nextAsynchsendCmd0[nn]=0;
nrOfCmdsInQueue=0;
}
bool sendWRcmd_setSendCommand0(uint16_t nextCmd)
{
// write Command to memory, wait for transport
if (nrOfCmdsInQueue>=CMDSTACKDEPTH)
{
qDebug() << "cannot save cmd because stack is full";
return false; // not possible
}
nextAsynchsendCmd0[nrOfCmdsInQueue++]=nextCmd;
//qDebug() << "PI cmd queued:"<< nextCmd << ", saved, pp=" << nrOfCmdsInQueue;
return true; // ok, will be sent
}
uint16_t sendWRcmd_getSendCommand0(void)
{
uint16_t nxtAsynchCmd;
uint8_t nn, ll;
if (nrOfCmdsInQueue==0 || nrOfCmdsInQueue>CMDSTACKDEPTH)
return 0; // error
nxtAsynchCmd=nextAsynchsendCmd0[0];
// move Puffer down by one element
if (CMDSTACKDEPTH>0)
ll=CMDSTACKDEPTH-1;
else
ll=0;
for (nn=0; nn<ll; nn++)
nextAsynchsendCmd0[nn]=nextAsynchsendCmd0[nn+1];
if (nrOfCmdsInQueue>0)
nrOfCmdsInQueue--;
//qDebug() << "PI cmd queued:"<< nxtAsynchCmd << ", restored, pp now =" << nrOfCmdsInQueue;
return nxtAsynchCmd;
}
//---------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
// Command Stack for commands with 4 parameters
static uint16_t nextAsynchsendCmd4[CMD4STACKDEPTH];
static uint8_t nextCmd4para1[CMD4STACKDEPTH];
static uint8_t nextCmd4para2[CMD4STACKDEPTH];
static uint8_t nextCmd4para3[CMD4STACKDEPTH];
static uint8_t nextCmd4para4[CMD4STACKDEPTH];
static uint8_t nrOfCmds4InQueue;
/* convention: use simple (not rotating) FIFO Stack:
Example: nrOfCmdsInQueue=4 then
nextAsynchsendCmd0[0]=cmd1 // was stored as first
nextAsynchsendCmd0[1]=cmd2
nextAsynchsendCmd0[2]=cmd3
nextAsynchsendCmd0[3]=cmd4 // came in as last
Send: [0] first, then move buffer 1 down:
nextAsynchsendCmd0[0]=cmd2
nextAsynchsendCmd0[1]=cmd3
nextAsynchsendCmd0[2]=cmd4
nextAsynchsendCmd0[3]=0;
nrOfCmdsInQueue=3 now
*/
void sendWRcmd_clrCmd4Stack(void)
{
uint8_t nn;
for (nn=0; nn<CMD4STACKDEPTH; nn++)
{
nextAsynchsendCmd4[nn]=0;
nextCmd4para1[nn]=0;
nextCmd4para2[nn]=0;
nextCmd4para3[nn]=0;
nextCmd4para4[nn]=0;
}
nrOfCmds4InQueue=0;
}
bool sendWRcmd_setSendCommand4(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4)
{
// write Command to memory, wait for transport
if (nrOfCmds4InQueue>=CMD4STACKDEPTH)
{
qDebug() << "cannot save cmd because stack is full";
return false; // not possible
}
nextAsynchsendCmd4[nrOfCmds4InQueue]=nextCmd;
nextCmd4para1[nrOfCmds4InQueue]=dat1;
nextCmd4para2[nrOfCmds4InQueue]=dat2;
nextCmd4para3[nrOfCmds4InQueue]=dat3;
nextCmd4para4[nrOfCmds4InQueue]=dat4;
//qDebug() << "data with 4 data byte saved, pp=" << nrOfCmds4InQueue;
//qDebug() << " dat1=" << nextCmd4para1[nrOfCmds4InQueue] << " dat2=" << nextCmd4para2[nrOfCmds4InQueue]
// << " dat3=" << nextCmd4para3[nrOfCmds4InQueue] << " dat4=" << nextCmd4para4[nrOfCmds4InQueue];
nrOfCmds4InQueue++;
return true; // ok, will be sent
}
uint16_t sendWRcmd_getSendCommand4(uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4)
{
uint16_t nxtAsynchCmd;
uint8_t nn, ll;
if (nrOfCmds4InQueue==0 || nrOfCmds4InQueue>CMD4STACKDEPTH)
return 0; // error
nxtAsynchCmd=nextAsynchsendCmd4[0];
*dat1=nextCmd4para1[0];
*dat2=nextCmd4para2[0];
*dat3=nextCmd4para3[0];
*dat4=nextCmd4para4[0];
//qDebug() << "cmd4 restored to send from [0]; pp=" << nrOfCmds4InQueue;
//qDebug() << " data1: " << nextCmd4para1[0] << " data2: " << nextCmd4para2[0] <<
// " data3: " << nextCmd4para3[0] << " data4: " << nextCmd4para4[0];
// move Puffer down by one element
if (CMD4STACKDEPTH>0)
ll=CMD4STACKDEPTH-1;
else
ll=0;
for (nn=0; nn<ll; nn++)
{
nextAsynchsendCmd4[nn]=nextAsynchsendCmd4[nn+1];
nextCmd4para1[nn]=nextCmd4para1[nn+1];
nextCmd4para2[nn]=nextCmd4para2[nn+1];
nextCmd4para3[nn]=nextCmd4para3[nn+1];
nextCmd4para4[nn]=nextCmd4para4[nn+1];
}
if (nrOfCmds4InQueue>0)
nrOfCmds4InQueue--;
//qDebug() << "cmd4 after push down: pp=" << nrOfCmds4InQueue;
return nxtAsynchCmd;
}
static uint16_t nextAsynchsendCmd8[CMD8STACKDEPTH];
static uint8_t nextCmd8para1[CMD8STACKDEPTH];
static uint8_t nextCmd8para2[CMD8STACKDEPTH];
static uint16_t nextCmd8para3[CMD8STACKDEPTH];
static uint32_t nextCmd8para4[CMD8STACKDEPTH];
static uint8_t nrOfCmds8InQueue;
void sendWRcmd_clrCmd8Stack(void)
{
uint8_t nn;
for (nn=0; nn<CMD8STACKDEPTH; nn++)
{
nextAsynchsendCmd8[nn]=0;
nextCmd8para1[nn]=0;
nextCmd8para2[nn]=0;
nextCmd8para3[nn]=0;
nextCmd8para4[nn]=0;
}
nrOfCmds8InQueue=0;
}
bool sendWRcmd_setSendCommand8(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uint16_t dat3, uint32_t dat4)
{
// write Command to memory, wait for transport
if (nrOfCmds8InQueue>=CMD8STACKDEPTH)
{
qDebug() << "cannot save cmd because stack is full";
return false; // not possible
}
nextAsynchsendCmd8[nrOfCmds8InQueue]=nextCmd;
nextCmd8para1[nrOfCmds8InQueue]=dat1;
nextCmd8para2[nrOfCmds8InQueue]=dat2;
nextCmd8para3[nrOfCmds8InQueue]=dat3;
nextCmd8para4[nrOfCmds8InQueue]=dat4;
nrOfCmds8InQueue++;
return true; // ok, will be sent
}
uint16_t sendWRcmd_getSendCommand8(uint8_t *dat1, uint8_t *dat2, uint16_t *dat3, uint32_t *dat4)
{
uint16_t nxtAsynchCmd;
uint8_t nn, ll;
if (nrOfCmds8InQueue==0 || nrOfCmds8InQueue>CMD8STACKDEPTH)
return 0; // error
nxtAsynchCmd=nextAsynchsendCmd8[0];
*dat1=nextCmd8para1[0];
*dat2=nextCmd8para2[0];
*dat3=nextCmd8para3[0];
*dat4=nextCmd8para4[0];
// move buffer down by one element
if (CMD8STACKDEPTH>0)
ll=CMD8STACKDEPTH-1;
else
ll=0;
for (nn=0; nn<ll; nn++)
{
nextAsynchsendCmd8[nn]=nextAsynchsendCmd8[nn+1];
nextCmd8para1[nn]=nextCmd8para1[nn+1];
nextCmd8para2[nn]=nextCmd8para2[nn+1];
nextCmd8para3[nn]=nextCmd8para3[nn+1];
nextCmd8para4[nn]=nextCmd8para4[nn+1];
}
if (nrOfCmds8InQueue>0)
nrOfCmds8InQueue--;
return nxtAsynchCmd;
}
static uint8_t sendAsynchDataBuf[160]; // no stack, only ONE buffer
static uint8_t sendAsyDatLen;
bool sendWRcmd_setSendBlock160(uint8_t leng, uint8_t *buf)
{
//qDebug() << "pi epi: storing send data";
if (leng>160) leng=160;
sendAsyDatLen=leng;
tslib_strclr(sendAsynchDataBuf, 0, 160);
for (uint8_t nn=0; nn<leng; nn++)
sendAsynchDataBuf[nn]=buf[nn];
return true; // ok, will be sent
}
uint8_t sendWRcmd_getSendBlock160(uint8_t *leng, uint8_t *buf)
{
//qDebug() << "pi gpi: restoring send data";
*leng=sendAsyDatLen;
for (uint8_t nn=0; nn<sendAsyDatLen; nn++)
buf[nn]=sendAsynchDataBuf[nn];
sendAsyDatLen=0;
//tslib_strclr(sendAsynchDataBuf, 0, 64);
return *leng;
}
// ------------------------------------------------------------------------------------
// MDB Sendind Data are store here for next transport to DC (Device Controller)
// Transport to Slave runs every 100ms, answer from mdb-slave (e.g. coin changer) comes rigth
// with next slave answer
// start with: SENDDIRCMD_EXCHGMDB,
// send crude data from here to DC, DC to mdb slaves, mdb answer, return here within 50ms
static uint8_t Sdata_mdbSendBuffer[64];
static uint8_t Sdata_mdbSendLen;
uint8_t epi_store64ByteSendData(uint8_t length, uint8_t *buf)
{
// HWapi writes data to be forwarded to DC and further to mdb-device
for (uint8_t nn=0; nn<length; nn++)
Sdata_mdbSendBuffer[nn]=buf[nn];
Sdata_mdbSendLen=length;
return 0;
}
uint8_t gpi_restore64ByteSendData(uint8_t *length, uint8_t *buf)
{
// datif reads data to forward to dc
for (uint8_t nn=0; nn<Sdata_mdbSendLen; nn++)
buf[nn]=Sdata_mdbSendBuffer[nn];
*length=Sdata_mdbSendLen;
Sdata_mdbSendLen=0;
return 0;
}
//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
//---------------------------------------- Printer Text Fifo -------------------------
static uint8_t prnDataParameters[4];
static uint8_t prnDataBufferUser;
void epi_storeUserOfSendingTextBuffer(uint8_t user, uint8_t para1, uint8_t para2, uint8_t para3, uint8_t para4 )
{
// user=1: Text-Print is using this buffer
// 2: QR-code-Printer is using this buffer
prnDataBufferUser=user;
prnDataParameters[0]=para1;
prnDataParameters[1]=para2;
prnDataParameters[2]=para3;
prnDataParameters[3]=para4;
// qDebug() << "new user stored: " << user;
}
uint8_t gpi_getUserOfSendingTextBuffer(uint8_t *para1, uint8_t *para2, uint8_t *para3, uint8_t *para4)
{
// user=1: Text-Print is using this buffer
// 2: QR-code-Printer is using this buffer
//qDebug() << "returning user "<< prnDataBufferUser;
*para1=prnDataParameters[0];
*para2=prnDataParameters[1];
*para3=prnDataParameters[2];
*para4=prnDataParameters[3];
return prnDataBufferUser;
}
// Sending Text Fifo
// ONE printer doc consists of 20 x 64 byte
// #define MAXNROF_PRNBYTES 64
// #define MAXNROF_PRNBLOCKS 20
static char Sdata_PRN_TEXT[MAXNROF_PRNBLOCKS][MAXNROF_PRNBYTES];
static uint8_t pPrnDataBuff; // points to next PRINTER_BLOCK
//static uint8_t pPrnDataBuff; // points to next waiting printer text
// defined above, needed if more then one text is stored (before sent)
// every block will be sent after 100ms, if 8 blocks are stored within this 100ms
// then pointer goes up to 8. Important: FIFO!!!!!!!!
void epi_resetPrinterStack(void)
{
pPrnDataBuff=0;
}
uint8_t epi_storePrnText(char *buf, uint8_t leng)
{
// store text from Gui in next higher free memory 0....9
uint16_t len;
uint8_t pp, nn;
pp=pPrnDataBuff; // next free memory block with 64byte each
if (pp>=MAXNROF_PRNBLOCKS)
return 1; // not possible, no free mem
//len=tslib_strlen(buf); // kennt keine Binärzeichen!!!!!!
len=leng;
if (len>MAXNROF_PRNBYTES)
len=MAXNROF_PRNBYTES;
tslib_strclr(Sdata_PRN_TEXT[pp], 0, MAXNROF_PRNBYTES);
for (nn=0; nn<len; nn++)
Sdata_PRN_TEXT[pp][nn]=buf[nn]; // copy new text into buffer
if (pPrnDataBuff<MAXNROF_PRNBLOCKS)
pPrnDataBuff++; // inc pointer if end not yet reached
return 0; // OK
}
uint8_t gpi_restorePrnText(uint8_t *retbuf)
{
// read printer text and send to slave, size of retbuf == 64
// always read from [0] because this is the oldest (Fifo)
// then move all text lines down by one and dec pointer
uint8_t nn, pp=pPrnDataBuff;
if (pp==0) // next free memory block with 64byte each
return 1; // no text in buffer
// example: pp=5: then buffers [0...4] are occupied
for (nn=0; nn<MAXNROF_PRNBYTES; nn++)
retbuf[nn] = uint8_t (Sdata_PRN_TEXT[0][nn]); // restore oldest text
// now copy textline [1] to [0], then
// copy textline [2] to [1], then
// copy textline [3] to [2] .... upto [pp-1] to [pp-2]
// hint: copying from 9....0 would delete all strings!!!!!!
for (nn=0; nn<(pp-1); nn++)
tslib_strcpy(Sdata_PRN_TEXT[nn+1], Sdata_PRN_TEXT[nn], MAXNROF_PRNBYTES);
if (pPrnDataBuff>0)
pPrnDataBuff--;
pp=pPrnDataBuff;
// example: pp=4: then buffers [0...3] are still occupied, pp=0: all buffers empty
// now clear highest copyed line (which got free now)
tslib_strclr(Sdata_PRN_TEXT[pp], 0, MAXNROF_PRNBYTES);
// optionally: clear all remaining higher lines:
for (nn=(pp+1); nn<MAXNROF_PRNBLOCKS; nn++)
tslib_strclr(Sdata_PRN_TEXT[nn], 0, MAXNROF_PRNBYTES);
return 0;
}
uint8_t gpi_chk4remainingText(void)
{
// retval: 0: no more textline left (to send) >0: nr of 64byte-blocks
return (pPrnDataBuff);
}
// ---------------------------------------------------------------------------------
// 11.4.23 neu, Kommando direkt an "FastDevice"-protokoll senden, nicht mehr umsetzen
// ---------------------------------------------------------------------------------
// short command, 4 data bytes
static uint8_t nextFDwrCmd[FDCMD_STACKDEPTH];
static uint8_t nextFDrdCmd[FDCMD_STACKDEPTH];
static uint8_t nextFDblkNr[FDCMD_STACKDEPTH];
static uint8_t nextFDpara1[FDCMD_STACKDEPTH];
static uint8_t nextFDpara2[FDCMD_STACKDEPTH];
static uint8_t nextFDpara3[FDCMD_STACKDEPTH];
static uint8_t nextFDpara4[FDCMD_STACKDEPTH];
static uint8_t p_nextFDcmdsInQueue;
/* convention: use simple (not rotating) FIFO Stack:
Example: nrOfCmdsInQueue=4 then
nextAsynchsendCmd0[0]=cmd1 // was stored as first
nextAsynchsendCmd0[1]=cmd2
nextAsynchsendCmd0[2]=cmd3
nextAsynchsendCmd0[3]=cmd4 // came in as last
Send: [0] first, then move buffer 1 down:
nextAsynchsendCmd0[0]=cmd2
nextAsynchsendCmd0[1]=cmd3
nextAsynchsendCmd0[2]=cmd4
nextAsynchsendCmd0[3]=0;
nrOfCmdsInQueue=3 now
*/
void sendFDcmd_clrStack(void)
{
uint8_t nn;
for (nn=0; nn<FDCMD_STACKDEPTH; nn++)
{
nextFDwrCmd[nn]=0;
nextFDrdCmd[nn]=0;
nextFDblkNr[nn]=0;
nextFDpara1[nn]=0;
nextFDpara2[nn]=0;
nextFDpara3[nn]=0;
nextFDpara4[nn]=0;
}
p_nextFDcmdsInQueue=0;
}
bool sendFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4)
{
// write Command to memory, wait for transport
if (p_nextFDcmdsInQueue>=FDCMD_STACKDEPTH)
{
qDebug() << "cannot save cmd because stack is full";
return false; // not possible
}
nextFDwrCmd[p_nextFDcmdsInQueue]=nextWrCmd;
nextFDrdCmd[p_nextFDcmdsInQueue]=nextRdCmd;
nextFDblkNr[p_nextFDcmdsInQueue]=blockNum;
nextFDpara1[p_nextFDcmdsInQueue]=dat1;
nextFDpara2[p_nextFDcmdsInQueue]=dat2;
nextFDpara3[p_nextFDcmdsInQueue]=dat3;
nextFDpara4[p_nextFDcmdsInQueue]=dat4;
//qDebug() << "data with 4 data byte saved, pp=" << nrOfCmds4InQueue;
//qDebug() << " dat1=" << nextCmd4para1[nrOfCmds4InQueue] << " dat2=" << nextCmd4para2[nrOfCmds4InQueue]
// << " dat3=" << nextCmd4para3[nrOfCmds4InQueue] << " dat4=" << nextCmd4para4[nrOfCmds4InQueue];
p_nextFDcmdsInQueue++;
return true; // ok, will be sent
}
bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4)
{
uint8_t nn, ll;
if (p_nextFDcmdsInQueue==0 || p_nextFDcmdsInQueue>FDCMD_STACKDEPTH)
return false; // not possible
*nextWrCmd=nextFDwrCmd[0];
*nextRdCmd=nextFDrdCmd[0];
*blockNum=nextFDblkNr[0];
*dat1=nextFDpara1[0];
*dat2=nextFDpara2[0];
*dat3=nextFDpara3[0];
*dat4=nextFDpara4[0];
//qDebug() << "cmd4 restored to send from [0]; pp=" << nrOfCmds4InQueue;
//qDebug() << " data1: " << nextCmd4para1[0] << " data2: " << nextCmd4para2[0] <<
// " data3: " << nextCmd4para3[0] << " data4: " << nextCmd4para4[0];
// move Puffer down by one element
if (FDCMD_STACKDEPTH>0)
ll=FDCMD_STACKDEPTH-1;
else
ll=0;
for (nn=0; nn<ll; nn++)
{
nextFDwrCmd[nn]=nextFDwrCmd[nn+1];
nextFDrdCmd[nn]=nextFDrdCmd[nn+1];
nextFDblkNr[nn]=nextFDblkNr[nn+1];
nextFDpara1[nn]=nextFDpara1[nn+1];
nextFDpara2[nn]=nextFDpara2[nn+1];
nextFDpara3[nn]=nextFDpara3[nn+1];
nextFDpara4[nn]=nextFDpara4[nn+1];
}
if (p_nextFDcmdsInQueue>0)
p_nextFDcmdsInQueue--;
//qDebug() << "cmd4 after push down: pp=" << nrOfCmds4InQueue;
return true; // ok, will be sent
}
uint8_t check4FDshortCmd(void)
{
// returns number of waiting command, max FDCMD_STACKDEPTH
return p_nextFDcmdsInQueue;
}
uint8_t check4freeFDshortCmd(void)
{
// returns number of free places in short-command stack
return FDCMD_STACKDEPTH - p_nextFDcmdsInQueue;
}
// long command, 64 data bytes
static uint8_t longFDwrCmd[FDLONG_STACKDEPTH];
static uint8_t longFDrdCmd[FDLONG_STACKDEPTH];
static uint8_t longFDblkNr[FDLONG_STACKDEPTH];
static uint8_t longFDlength[FDLONG_STACKDEPTH];
static uint8_t longFDpara[FDLONG_STACKDEPTH][64];
static uint8_t p_longFDcmdsInQueue;
void longFDcmd_clrStack(void)
{
uint8_t nn, mm;
for (nn=0; nn<FDLONG_STACKDEPTH; nn++)
{
longFDwrCmd[nn]=0;
longFDrdCmd[nn]=0;
longFDblkNr[nn]=0;
longFDlength[nn]=0;
for (mm=0; mm<64; mm++)
longFDpara[nn][mm]=0;
}
p_longFDcmdsInQueue=0;
}
bool longFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t length, uint8_t *data)
{
// write Command to memory, wait for transport
// data buffer size always 64! data[64], padded with 0
uint8_t nn;
if (p_longFDcmdsInQueue>=FDLONG_STACKDEPTH)
{
qDebug() << "cannot save cmd because stack is full";
return false; // not possible
}
longFDwrCmd[p_longFDcmdsInQueue]=nextWrCmd;
longFDrdCmd[p_longFDcmdsInQueue]=nextRdCmd;
longFDblkNr[p_longFDcmdsInQueue]=blockNum;
longFDlength[p_longFDcmdsInQueue]=length;
for (nn=0; nn<64; nn++)
longFDpara[p_longFDcmdsInQueue][nn]=data[nn];
p_longFDcmdsInQueue++;
return true; // ok, will be sent
}
bool longFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *length, uint8_t *data)
{
uint8_t nn, mm, ll;
if (p_longFDcmdsInQueue==0 || p_longFDcmdsInQueue>FDLONG_STACKDEPTH)
return false; // not possible
*nextWrCmd= longFDwrCmd[0];
*nextRdCmd= longFDrdCmd[0];
*blockNum = longFDblkNr[0];
*length = longFDlength[0];
for (mm=0; mm<64; mm++)
data[mm] = longFDpara[0][mm];
// move Puffer down by one element
if (FDLONG_STACKDEPTH>0)
ll=FDLONG_STACKDEPTH-1;
else
ll=0;
for (nn=0; nn<ll; nn++)
{
longFDwrCmd[nn] = longFDwrCmd[nn+1];
longFDrdCmd[nn] = longFDrdCmd[nn+1];
longFDblkNr[nn] = longFDblkNr[nn+1];
longFDlength[nn] = longFDlength[nn+1];
for (mm=0; mm<64; mm++)
longFDpara[nn][mm] = longFDpara[nn+1][mm];
}
if (p_longFDcmdsInQueue>0)
p_longFDcmdsInQueue--;
return true; // ok, will be sent
}
uint8_t check4FDlongCmd(void)
{
// returns number of waiting command
return p_longFDcmdsInQueue;
}
uint8_t check4freeFDlongCmd(void)
{
// returns number of free places in command stack
return FDLONG_STACKDEPTH - p_longFDcmdsInQueue;
}
static uint8_t Sdata_DeviceParameter[64];
static uint8_t Sdata_DevParaLen;
uint8_t epi_store64BdevParameter(uint8_t length, uint8_t *buf)
{
// HWapi writes data to be stored
uint8_t nn;
for (nn=0; nn<length; nn++)
Sdata_DeviceParameter[nn]=buf[nn];
for (nn=length; nn<64; nn++)
Sdata_DeviceParameter[nn]=0;
Sdata_DevParaLen=length;
return 0;
}
uint8_t epi_restore64BdevParameter(uint8_t *length, uint8_t *buf)
{
for (uint8_t nn=0; nn<Sdata_DevParaLen; nn++)
buf[nn]=Sdata_DeviceParameter[nn];
*length=Sdata_DevParaLen;
return 0;
}

View File

@ -1,39 +0,0 @@
#include "shared_mem_buffer.h"
#include <QDebug>
#include <atomic>
#ifdef QT_POSIX_IPC
// The POSIX backend can be explicitly selected using the -feature-ipc_posix
// option to the Qt configure script. If it is enabled, the QT_POSIX_IPC
// macro will be defined. -> we use SystemV shared memory
#error "QT_POSIX_IPC defined"
#else
#include <sys/ipc.h> // ftok
#endif
// std::atomic_bool SharedMemBuffer::__sharedMemLocked{false};
QSharedMemory *SharedMemBuffer::getShm(std::size_t size) {
static QSharedMemory shMem;
if (size > 0) {
static const long nativeKey = ftok("/etc/os-release", 'H');
static const QString fkey = std::to_string(nativeKey).c_str();
shMem.setKey(fkey);
if (!shMem.isAttached()) {
if (shMem.create(size)) {
return &shMem;
} else {
if (shMem.error() == QSharedMemory::AlreadyExists) {
if (shMem.attach()) {
return &shMem;
}
}
}
qCritical() << shMem.nativeKey() << shMem.key() << shMem.data()
<< shMem.error() << shMem.errorString();
return nullptr;
}
}
return &shMem;
}

File diff suppressed because it is too large Load Diff

View File

@ -1,598 +0,0 @@
#include "tslib.h"
#include <QThread>
//tslib::tslib()
//{
//}
/*
uint16_t tslib::uchar2uint(uint8_t Highbyte, uint8_t Lowbyte)
{
uint16_t uitmp;
uitmp=0;
uitmp |= uint8_t(Highbyte);
uitmp<<=8;
uitmp |= uint8_t(Lowbyte);
return uitmp;
}
uint8_t tslib::uint2uchar(uint16_t uival, bool getHighB)
{
// getHighB: low=GetLowByte
uint16_t uitmp=uival;
if (getHighB==0)
return uint8_t(uitmp);
uitmp>>=8;
return uint8_t(uitmp);
}*/
uint16_t uchar2uint(char Highbyte, char Lowbyte)
{
uint16_t uitmp;
uitmp=0;
uitmp |= uint8_t(Highbyte);
uitmp<<=8;
uitmp |= uint8_t(Lowbyte);
return uitmp;
}
uint16_t uchar2uint(uint8_t Highbyte, uint8_t Lowbyte)
{
uint16_t uitmp;
uitmp=0;
uitmp |= uint8_t(Highbyte);
uitmp<<=8;
uitmp |= uint8_t(Lowbyte);
return uitmp;
}
uint32_t uchar2ulong(uint8_t Highbyte, uint8_t MHbyte, uint8_t MLbyte, uint8_t Lowbyte)
{
uint32_t ultmp=0;
ultmp |= uint8_t(Highbyte);
ultmp<<=8;
ultmp |= uint8_t(MHbyte);
ultmp<<=8;
ultmp |= uint8_t(MLbyte);
ultmp<<=8;
ultmp |= uint8_t(Lowbyte);
return ultmp;
}
uint8_t uint2uchar(uint16_t uival, bool getHighB)
{
// getHighB: low=GetLowByte
uint16_t uitmp=uival;
if (getHighB==0)
return uint8_t(uitmp);
uitmp>>=8;
return uint8_t(uitmp);
}
uint8_t ulong2uchar(uint32_t ulval, uint8_t getBytNr)
{
// getBytNr: 0=LSB 3=MSB
uint32_t ultmp=ulval;
if (getBytNr==0)
return uint8_t(ultmp);
ultmp>>=8;
if (getBytNr==1)
return uint8_t(ultmp);
ultmp>>=8;
if (getBytNr==2)
return uint8_t(ultmp);
ultmp>>=8;
return uint8_t(ultmp);
}
void delay(uint16_t MilliSec)
{
QThread::msleep(uint32_t(MilliSec));
}
void GetTimeString(uint8_t hours, uint8_t minutes, uint8_t seconds, uint8_t System12h, uint8_t ShowSec, uint8_t *buf)
{
// Zahlenwerte in String wandeln, 12/24h-Format // 12byte für buf!
uint8_t usa;
uint16_t jj;
uint8_t hh, mm, ss, with_sec;
// buf[0]= ganz linkes Zeichen
hh=hours;
mm=minutes;
ss=seconds;
// 15.10.12, Plausibilitätsprüfung --------------------------------------------------
if (hh>23) hh=0;
if (mm>59) mm=0;
if (ss>59) ss=0;
with_sec=ShowSec;
for (jj=0; jj<12; jj++) buf[jj]=0;
usa = System12h; // 1:12h 0:24h
// Stunden:
if (usa)
{
// 12h System
if (hh==0 || hh==12)
{
// 12AM (Mitternacht) oder 12PM (Mittag)
buf[0]=0x31;
buf[1]=0x32;
} else
if (hh<12)
{
// 1..11AM
buf[0]=hh/10+0x30;
buf[1]=hh%10+0x30;
} else
{
//13:00 bis 23Uhr
buf[0]=(hh-12)/10+0x30;
buf[1]=(hh-12)%10+0x30;
}
} else
{
// 24h System
buf[0]=hh/10+0x30;
buf[1]=hh%10+0x30;
}
// Minuten:
buf[2]=':';
buf[3]=mm/10+0x30;
buf[4]=mm%10+0x30;
jj=5;
if (with_sec)
{
buf[jj++]=':';
buf[jj++]=ss/10+0x30;
buf[jj++]=ss%10+0x30;
}
if (usa)
{
buf[jj++]=' ';
if (hh<12)
buf[jj++]='A';
else
buf[jj++]='P';
buf[jj++]='M';
}
}
// ------------------- ********************************************************************************
void GetDateString(uint8_t day, uint8_t month, uint8_t yearhigh, uint8_t yearlow, uint8_t format, uint8_t sep, uint8_t *buf)
{
// generate date as ascii string from integers day/month/year
// yearhigh: 10..29, in europe always 20 (not in arabia!) comes as hex number, e.g. 0x20
// format= 0: dd.mm.yyyy (deutsch)
// 1: mm.dd.yyyy (amerika)
// 2: yyyy.mm.dd (Iran, Dubai)
// 3: dd.yyyy.mm
// 4: mm.yyyy.dd
// 5: yyyy.dd.mm
// sep: 0: use . as seperator 1: use / as seperator
// return String in *buf // 11byte für buf!
uint8_t tag, mon, jahr, d10, d1, m10, m1, y1000, y100, y10, y1;
uint8_t slash;
y100= (yearhigh & 0x0F)+0x30;
y1000=((yearhigh & 0xF0)>>4)+0x30;
// if (yearhigh>=20)
// {
// y1000='2';
// y100=28+yearhigh; // '0' + (yearhigh-20)
// } else
// if (yearhigh<20)
// {
// y1000='1';
// y100=38-yearhigh; // '9' - (19-yearhigh)
// }
tag=day;
mon=month;
jahr=yearlow;
if (mon>12 || mon==0) mon=1; // 23.10.12
if (tag>31 || tag==0) tag=1;
if (jahr>50 || jahr<11) jahr=1;
if (sep==0)
slash='.'; // slash==0
else if (sep==1)
slash='/';
else
if (sep>=0x20)
slash=sep;
else
slash='.';
d10 =tag/10;
d1 =tag%10;
m10 =mon/10;
m1 =mon%10;
y10 =jahr/10;
y1 =jahr%10;
d10 +=0x30; // in Asccii wandeln
d1 +=0x30;
m10 +=0x30;
m1 +=0x30;
y10 +=0x30;
y1 +=0x30;
switch (format)
{
// 0: dd.mm.yyyy
case 0: buf[0]=d10; buf[1]=d1; buf[2]=slash; buf[3]=m10; buf[4]=m1; buf[5]=slash;
buf[6]=y1000; buf[7]=y100; buf[8]=y10; buf[9]=y1; break;
// 1: mm.dd.yyyy
case 1: buf[0]=m10; buf[1]=m1; buf[2]=slash; buf[3]=d10; buf[4]=d1; buf[5]=slash;
buf[6]=y1000; buf[7]=y100; buf[8]=y10; buf[9]=y1; break;
// 2: yyyy.mm.dd
case 2: buf[0]=y1000; buf[1]=y100; buf[2]=y10; buf[3]=y1; buf[4]=slash; buf[5]=m10;
buf[6]=m1; buf[7]=slash; buf[8]=d10; buf[9]=d1; break;
// 3: dd.yyyy.mm
case 3: buf[0]=d10; buf[1]=d1; buf[2]=slash; buf[3]=y1000; buf[4]=y100;
buf[5]=y10; buf[6]=y1; buf[7]=slash; buf[8]=m10; buf[9]=m1; break;
// 4: mm.yyyy.dd
case 4: buf[0]=m10; buf[1]=m1; buf[2]=slash; buf[3]=y1000; buf[4]=y100;
buf[5]=y10; buf[6]=y1; buf[7]=slash; buf[8]=d10; buf[9]=d1; break;
// 5: yyyy.dd.mm
case 5: buf[0]=y1000; buf[1]=y100; buf[2]=y10; buf[3]=y1; buf[4]=slash; buf[5]=d10;
buf[6]=d1; buf[7]=slash; buf[8]=m10; buf[9]=m1; break;
}
buf[10]=0;
}
// ------------------- ********************************************************************************
void GetShortDateString(uint8_t day, uint8_t month, uint8_t yearlow, uint8_t format, uint8_t sep, uint8_t *buf)
{
// generate date as ascii string from integers day/month/year
// format= 0: dd.mm.yy (deutsch)
// 1: mm.dd.yy (amerika)
// 2: yy.mm.dd (Iran, Dubai)
// 3: dd.yy.mm
// 4: mm.yy.dd
// 5: yy.dd.mm
// sep: 0: use . as seperator 1: use / as seperator
// return String in *buf // 11byte für buf!
uint8_t tag, mon, jahr, d10, d1, m10, m1, y10, y1;
uint8_t slash;
tag=day;
mon=month;
jahr=yearlow;
if (mon>12 || mon==0) mon=1; // 23.10.12
if (tag>31 || tag==0) tag=1;
if (jahr>50 || jahr<11) jahr=1;
if (sep==0)
slash='.'; // slash==0
else if (sep==1)
slash='/';
else if (sep>=0x20)
slash=sep;
else
slash='.';
d10 =tag/10;
d1 =tag%10;
m10 =mon/10;
m1 =mon%10;
y10 =jahr/10;
y1 =jahr%10;
d10 +=0x30; // in Asccii wandeln
d1 +=0x30;
m10 +=0x30;
m1 +=0x30;
y10 +=0x30;
y1 +=0x30;
switch (format)
{
// 0: dd.mm.yyyy
case 0: buf[0]=d10; buf[1]=d1; buf[2]=slash; buf[3]=m10; buf[4]=m1; buf[5]=slash;
buf[6]=y10; buf[7]=y1; break;
// 1: mm.dd.yyyy
case 1: buf[0]=m10; buf[1]=m1; buf[2]=slash; buf[3]=d10; buf[4]=d1; buf[5]=slash;
buf[6]=y10; buf[7]=y1; break;
// 2: yyyy.mm.dd
case 2: buf[0]=y10; buf[1]=y1; buf[2]=slash; buf[3]=m10;
buf[4]=m1; buf[5]=slash; buf[6]=d10; buf[7]=d1; break;
// 3: dd.yyyy.mm
case 3: buf[0]=d10; buf[1]=d1; buf[2]=slash;
buf[3]=y10; buf[4]=y1; buf[5]=slash; buf[6]=m10; buf[7]=m1; break;
// 4: mm.yyyy.dd
case 4: buf[0]=m10; buf[1]=m1; buf[2]=slash;
buf[3]=y10; buf[4]=y1; buf[5]=slash; buf[6]=d10; buf[7]=d1; break;
// 5: yyyy.dd.mm
case 5: buf[0]=y10; buf[1]=y1; buf[2]=slash; buf[3]=d10;
buf[4]=d1; buf[5]=slash; buf[6]=m10; buf[7]=m1; break;
}
buf[8]=0;
}
uint16_t tslib_strlen(char *buf)
{
uint16_t nn;
for (nn=0; nn<0xFFF0; nn++)
if (buf[nn]==0)
return nn;
return 0;
}
uint16_t tslib_strlen(uint8_t *buf)
{
uint16_t nn;
for (nn=0; nn<0xFFF0; nn++)
if (buf[nn]==0)
return nn;
return 0;
}
void tslib_strclr(char *buf, char clrsign, uint16_t len)
{
uint16_t nn;
for (nn=0; nn<len; nn++)
buf[nn]=clrsign;
}
void tslib_strclr(uint8_t *buf, char clrsign, uint16_t len)
{
uint16_t nn;
for (nn=0; nn<len; nn++)
buf[nn]=uint8_t (clrsign);
}
void tslib_strcpy(char *srcbuf, char *destbuf, uint16_t len)
{
uint16_t nn;
for (nn=0; nn<len; nn++)
destbuf[nn]=srcbuf[nn];
}
void tslib_strcpy(char *srcbuf, uint8_t *destbuf, uint16_t len)
{
uint16_t nn;
for (nn=0; nn<len; nn++)
destbuf[nn]=uint8_t(srcbuf[nn]);
}
void tslib_strcpy(uint8_t *srcbuf, uint8_t *destbuf, uint16_t len)
{
uint16_t nn;
for (nn=0; nn<len; nn++)
destbuf[nn]=srcbuf[nn];
}
bool tslib_isDecAsciiNumber(char sign)
{
if (sign>=0x30 && sign<=0x39)
return true;
return false;
}
bool tslib_isHexAsciiNumber(char sign)
{
if (sign>=0x30 && sign<=0x39)
return true;
if (sign>=0x61 && sign<=0x66) // a...f
return true;
if (sign>=0x41 && sign<=0x46) // A...F
return true;
return false;
}
int tslib_getMinimum(int val1, int val2)
{
if (val1<val2)
return val1;
return val2;
}
void tslib_text2array(QByteArray text, char *aray, uint16_t maxArayLen)
{
QByteArray sloc;
int ii, LL=text.length();
if (LL>maxArayLen) LL=maxArayLen;
for (ii=0; ii<LL; ii++)
{
aray[ii]=text.at(ii);
}
if (LL==maxArayLen)
aray[LL-1]=0;
else
aray[LL]=0;
}
// -----------------------------------------------------------------------------------------------
// functions for DeviceController's Bootloader ---------------------------------------------------
// -----------------------------------------------------------------------------------------------
/*
uint16_t tslib_calcCrcCcitt(uint16_t BufLength, uint8_t *buf)
{
uint8_t nn, B15H, element;
uint16_t crc = 0x84cf;
while (BufLength--)
{
element = *buf++;
for (nn = 0; nn < 8; nn++)
{
B15H = 0;
if(crc & 0x8000)
B15H = 1;
crc = (crc << 1) | ((element >> (7 - nn)) & 0x01);
if (B15H)
{
crc ^= 0x1021;
}
}
}
for (nn = 0; nn < 16; nn++)
{
B15H = 0;
if(crc & 0x8000)
B15H = 1;
crc = (crc << 1) | 0x00;
if (B15H)
{
crc ^= 0x1021;
}
}
return crc;
}
static uint8_t LastBLcmd; // stored the last sent cmd in order to analys response
// cmd echo'ed: error cmd or'ed with 0x80: OK
uint8_t tslib_prepareDC_BLcmd(uint8_t Cmd, uint8_t SendDataLength, uint8_t *sendData, uint8_t *outBuf)
{
// make BL protocol, retval = outbuf length (5...133)
// bring data in correct form: start always with 0x02 finish with 0x03 and append checksum
// 0x02 Cmd < ...sendData ..> CRC CRC 0x03
// Data length = 0...64
// special conversion: if data contain 2 or 3 (STX, ETX) then write two bytes: 0x1B (=ESC) and data|0x80
// so maxlength = 5 + 2 x 64 (if all data are 2 or 3) without 2,3: maxlength = 5 + 64
uint8_t myBuf[140], pp=0, nn, uctmp, currLen=0;
uint16_t calcCrc;
tslib_strclr(myBuf, 0, 140);
myBuf[pp++]=2; // STX
myBuf[pp++]=Cmd;
LastBLcmd=Cmd;
// append data:
for (nn=0; nn<SendDataLength; nn++)
{
uctmp=sendData[nn];
if (uctmp==2 || uctmp==3) // STX or ETX in normal data!
{
myBuf[pp++]=0x1B; // ESC
myBuf[pp++]=uctmp | 0x80;
} else
myBuf[pp++]=uctmp;
}
currLen=pp;
// calc crc: (over cmd and data, without STX)
calcCrc=tslib_calcCrcCcitt(uint16_t(currLen), myBuf);
myBuf[pp++]=uint8_t(calcCrc & 0x00FF);
myBuf[pp++]=uint8_t((calcCrc>>8) & 0x00FF);
myBuf[pp++]=3;
currLen=pp;
return currLen;
}
// some special commands (right out of bootloader manual)
uint8_t tslib_readBLversion(uint8_t *sendData)
{
// minimum size of sendData-buffer: 5byte retval: length
uint8_t myBuf[2];
tslib_strclr(myBuf, 0, 2);
return tslib_prepareDC_BLcmd(0x11, 0, myBuf, sendData);
}
uint8_t tslib_readFWversion(uint8_t *sendData)
{
// minimum size of sendData-buffer: 5byte retval: length
uint8_t myBuf[2];
tslib_strclr(myBuf, 0, 2);
return tslib_prepareDC_BLcmd(0x12, 0, myBuf, sendData);
}
uint8_t tslib_exitBL(uint8_t *sendData)
{
// minimum size of sendData-buffer: 5byte retval: length
uint8_t myBuf[2];
tslib_strclr(myBuf, 0, 2);
return tslib_prepareDC_BLcmd(0x18, 0, myBuf, sendData);
}
uint8_t tslib_sendFlashStartAddr2BL(uint32_t startAddr, uint8_t *sendData)
{
// minimum size of sendData-buffer: 13byte retval: length (9...13)
uint8_t myBuf[2];
tslib_strclr(myBuf, 0, 2);
return tslib_prepareDC_BLcmd(0x11, 0, myBuf, sendData);
}
*/
// -----------------------------------------------------------------------------------------------
void biox_CopyBlock(uint8_t *src, uint16_t srcPos, uint8_t *dest, uint16_t destPos, uint16_t len)
{
// both buffers starting from pos 0
uint16_t xx,yy,zz,ii;
xx = srcPos;
yy = destPos;
zz = len;
for (ii = 0; ii < zz; ++ii)
{
dest[yy + ii] = src[xx + ii];
}
}

View File

@ -15,47 +15,129 @@ DEFINES += QT_DEPRECATED_WARNINGS
# In order to do so, uncomment the following line. # 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. # 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 #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0
VERSION=1.3.4
# 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.
# 1.3.13: Fix: if the customer repository is corrupted, remove it and re-clone
# the repository (without checking the ISMAS-trigger (WAIT-)button.
# 1.3.14: Add additional check for sanity of customer repository using
# "git fsck".
# Stream-lined code of update process: massive refactoring.
# Added functionality: If WAIT button is not active, then an existing
# customer repository will be repaired, or a not existing repository
# will be cloned. The process stops then.
# However, if the WAIT button is active, the at least the commands in
# opkg_commands will be executed. Changed files in the customer
# repository will be worked on: tariff-files will be synced with the
# local filesystem, json-files will be downloaded to firmware.
# The device-controller firmware will be handled in a later version.
# 1.3.15: Bug fixes found during testing.
# Don't disable Exit-button during update-process.
# Removed worker-thread with an own event-loop: only the GUI thread
# has an event loop. Tested JSON-downloads several times successfully
# (using the slave lib where the CA helper tool was active as master).
# Turned previous worker-object into its own thread, but without any
# own event-loop (so it cannot block anything inside the CA-plugin).
# 1.3.16: Bug fixes found during testing.
# 1.3.17: Add ATBUpdateTool.ini and custom command line parser. Settings
# given in ATBUpdateTool.ini can be overwritten on the command-line.
# 1.3.18: Bug fixes found during testing.
# 1.3.19: Bug fixes found during testing.
VERSION="1.3.20"
# 1.3.20: Bug fixes found during testing.
# PLANNED TODOS:
# 1: Das Repository wird repariert bwz. neu geklont. Unabhaengig vom WAIT.
# 2: Wenn der WAIT-Button aktiv ist, dann wird ein Repository repariert (neu
# geklont), aber zusaetzlich werden alle verfuegbaren Dateien als neu
# angesehen und die entsprechenden Aktionen durchgefuehrt: tariff-files
# spiegeln, json-files laden und dc laden. Also VORSICHT: das repository
# muss in diesem fall wirklich in ordnung sein.
# 3: Wurde keine Datei geaendert, kein initiales Clone und der WAIT-button
# nicht aktiv, so (passiert natuerlich nichts) kann man davon ausgehen,
# dass es sich um ein automatisches Update handelt. Dann koennte man im
# ISMAS eine entsprechende Meldung anzeigen als Teil von SEND-LAST-VERSION.
# Wenn der WAIT-button aktiv ist, dann werden zumindest die opkg-commands
# ausgefuehrt.
# 4: rsync: immer alle Dateien soiegeln (bis auf opkg-commands)
# 5: Falls das Tool mal abstuerzt, dann einen Signal-Handler (fuer TERM)
# installieren, sodass zumnidest SEND-LAST-VERSION mit rausgeht.
# 6: rsync: explizites Binary, nicht das in busybox enthaltene.
# 7: Versionen der Json-Files lassen sich auslesen.
# Problem: Einstellungen in den Json-Files lassen sich auch mittels
# Funktionen in der CD-Library ueberschreiben. Damit ist dann wieder nicht
# mehr so klar, was jetzt eigentlich aktiv ist.
# 8: m_alwaysDownloadConfig und m_alwaysDownloadDC: vorbereitet: man koennte
# es so arrangieren, dass der DC plus die Json-files im Repository immer
# runtergeladen werden, obwohl sich im Repository gar nicts veraendert
# hat. Eeventuell nuetzlich beim initialen Setuo eines PSA.
# 9: Das Kunden-Repository sollte immer gezogen werden, unabhaengig von der
# Stellung des WAIT-Button. Grund: es koennte sein, dass andernfalls ein
# PSA weit hiter anderen steht, und dann ploetzlich einmal alle vorher-
# gehenden Aenderungen anzieht, die gar nicht fuer ihn gemeint waren.
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")
EXTENDED_VERSION="$${VERSION}-$${GIT_COMMIT}"
INCLUDEPATH += plugins INCLUDEPATH += plugins
CONFIG += c++17 console CONFIG += c++17
# CONFIG -= app_bundle # CONFIG -= app_bundle
DEFINES+=APP_VERSION=\\\"$$VERSION\\\" DEFINES+=APP_VERSION=\\\"$$VERSION\\\"
DEFINES+=APP_BUILD_DATE=\\\"$$BUILD_DATE\\\"
DEFINES+=APP_BUILD_TIME=\\\"$$BUILD_TIME\\\"
DEFINES+=APP_EXTENDED_VERSION=\\\"$$EXTENDED_VERSION\\\"
# keep comments, as /* fall through */
QMAKE_CXXFLAGS += -C
QMAKE_CXXFLAGS += -g QMAKE_CXXFLAGS += -g
QMAKE_CXXFLAGS += -Wno-deprecated-copy 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 ) { contains( CONFIG, PTU5 ) {
greaterThan(QT_MAJOR_VERSION, 4): QT += serialport greaterThan(QT_MAJOR_VERSION, 4): QT += serialport
CONFIG += link_pkgconfig CONFIG += link_pkgconfig
lessThan(QT_MAJOR_VERSION, 5): PKGCONFIG += qextserialport 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 # QMAKE_CXXFLAGS += -Wno-deprecated-copy
ARCH = PTU5 ARCH = PTU5
DEFINES+=PTU5 DEFINES+=PTU5
} }
contains( CONFIG, PTU5_YOCTO ) { contains( CONFIG, PTU5_YOCTO ) {
greaterThan(QT_MAJOR_VERSION, 4): QT += serialport greaterThan(QT_MAJOR_VERSION, 4): QT += serialport
QMAKE_CXXFLAGS += -std=c++17 # for GCC >= 4.7 QMAKE_CXXFLAGS += -std=c++17 # for GCC >= 4.7
QMAKE_CXXFLAGS += -Wno-deprecated-copy # QMAKE_CXXFLAGS += -Wno-deprecated-copy
PTU5BASEPATH = /opt/devel/ptu5 PTU5BASEPATH = /opt/devel/ptu5
ARCH = PTU5 ARCH = PTU5
DEFINES+=PTU5 DEFINES+=PTU5
@ -69,7 +151,7 @@ contains( CONFIG, DesktopLinux ) {
# QMAKE_CC = ccache $$QMAKE_CC # QMAKE_CC = ccache $$QMAKE_CC
# QMAKE_CXX = ccache $$QMAKE_CXX # QMAKE_CXX = ccache $$QMAKE_CXX
QMAKE_CXXFLAGS += -std=c++17 QMAKE_CXXFLAGS += -std=c++17
QMAKE_CXXFLAGS += -Wno-deprecated-copy # QMAKE_CXXFLAGS += -Wno-deprecated-copy
linux-clang { QMAKE_CXXFLAGS += -Qunused-arguments } linux-clang { QMAKE_CXXFLAGS += -Qunused-arguments }
ARCH = DesktopLinux ARCH = DesktopLinux
DEFINES+=DesktopLinux DEFINES+=DesktopLinux
@ -87,7 +169,7 @@ SOURCES += \
process/command.cpp \ process/command.cpp \
message_handler.cpp \ message_handler.cpp \
worker.cpp \ worker.cpp \
worker_thread.cpp commandline_parser.cpp
HEADERS += \ HEADERS += \
update.h \ update.h \
@ -101,24 +183,15 @@ HEADERS += \
process/command.h \ process/command.h \
message_handler.h \ message_handler.h \
worker.h \ worker.h \
worker_thread.h \ commandline_parser.h \
plugins/interfaces.h plugins/interfaces.h
OTHER_FILES += \
ATBUpdateTool.ini
FORMS += \ FORMS += \
mainwindow.ui 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 # for running program on target through QtCreator

251
commandline_parser.cpp Normal file
View File

@ -0,0 +1,251 @@
#include "commandline_parser.h"
#include <QDir>
#include <QSettings>
#include <QDebug>
#include <QFile>
CommandLineParser::CommandLineParser()
: m_repositoryUrl("https://git.mimbach49.de/GerhardHoffmann")
, m_plugInDir("/usr/lib/")
, m_plugInName("libCAslave.so")
, m_workingDir("/opt/app/tools/atbupdate/")
, m_dryRun("false")
, m_noUpdatePsaHardware("false")
, m_showYoctoVersion("false")
, m_showYoctoInstallStatus("false")
, m_showExtendedVersion("false")
, m_iniFileName("ATBUpdateTool.ini")
, m_alwaysDownloadConfig("false")
, m_alwaysDownloadDC("false")
, m_repositoryUrlOption(
QCommandLineOption(
QStringList() << "repository-url" << "repository-url",
QCoreApplication::translate("main", "Where to find a customer repository."),
QCoreApplication::translate("main", "directory")))
, m_iniFileDirectoryOption(
QCommandLineOption(
QStringList() << "ini-directory" << "ini-directory",
QCoreApplication::translate("main", "Where to find an ini-file."),
QCoreApplication::translate("main", "directory")))
, m_iniFileNameOption(
QCommandLineOption(
QStringList() << "ini-filename" << "ini-filename",
QCoreApplication::translate("main", "Name of ini-file."),
QCoreApplication::translate("main", "file")))
, m_pluginDirectoryOption(
QCommandLineOption(
QStringList() << "plugin-directory" << "plugin-directory",
QCoreApplication::translate("main", "Where to find dc-plugin."),
QCoreApplication::translate("main", "directory")))
, m_pluginNameOption(
QCommandLineOption(
QStringList() << "plugin-name" << "plugin-name",
QCoreApplication::translate("main", "Name of dc-plugin."),
QCoreApplication::translate("main", "directory")))
, m_noDownloadOption(
QCommandLineOption(
"no-psa-hardware-update",
QCoreApplication::translate("main", "Do not update the PSA firmware (json, device-controller).")))
, m_alwaysDownloadConfigOption(
QCommandLineOption(
"always-download-config",
QCoreApplication::translate("main", "Always download the (json-)configs to DC).")))
, m_alwaysDownloadDCOption(
QCommandLineOption(
"always-download-dc",
QCoreApplication::translate("main", "Always download the dc-bin-file to DC).")))
, m_workingDirectoryOption(
QCommandLineOption(
QStringList() << "working-directory" << "working-directory",
QCoreApplication::translate("main", "working directory of update-script."),
QCoreApplication::translate("main", "directory")))
, m_dryRunOption(
QCommandLineOption(
QStringList() << "d" << "dry-run",
QCoreApplication::translate("main", "Start ATBUpdateTool in dry-run-mode. No actual actions.")))
, m_extendedVersionOption(
QCommandLineOption(
QStringList() << "V" << "extended-version",
QCoreApplication::translate("main", "Show extended version (including last git commit).")))
, m_yoctoVersionOption(
QCommandLineOption(
QStringList() << "y" << "yocto-version",
QCoreApplication::translate("main", "Show yocto version of ATBUpdateTool.")))
, m_yoctoInstallStatusOption(
QCommandLineOption(
QStringList() << "Y" << "yocto-install",
QCoreApplication::translate("main", "Show yocto install status of ATBUpdateTool."))) {
configure();
}
void CommandLineParser::configure() {
m_parser.setApplicationDescription("Download tool for downloading device controller firmware, printer json-files and executing opkg-commands.");
m_parser.addHelpOption();
m_parser.addVersionOption();
m_repositoryUrlOption.setDefaultValue("https://git.mimbach49.de/GerhardHoffmann");
m_parser.addOption(m_repositoryUrlOption);
m_iniFileDirectoryOption.setDefaultValue(".");
m_parser.addOption(m_iniFileDirectoryOption);
m_iniFileNameOption.setDefaultValue("ATBUpdateTool.ini");
m_parser.addOption(m_iniFileNameOption);
m_pluginDirectoryOption.setDefaultValue("/usr/lib/");
m_parser.addOption(m_pluginDirectoryOption);
m_pluginNameOption.setDefaultValue("libCAslave.so");
m_parser.addOption(m_pluginNameOption);
m_alwaysDownloadConfigOption.setDefaultValue("false");
m_parser.addOption(m_alwaysDownloadConfigOption);
m_alwaysDownloadDCOption.setDefaultValue("false");
m_parser.addOption(m_alwaysDownloadDCOption);
m_noDownloadOption.setDefaultValue("false");
m_parser.addOption(m_noDownloadOption);
m_workingDirectoryOption.setDefaultValue("/opt/app/tools/atbupdate/");
m_parser.addOption(m_workingDirectoryOption);
m_dryRunOption.setDefaultValue("false");
m_parser.addOption(m_dryRunOption);
m_extendedVersionOption.setDefaultValue("false");
m_parser.addOption(m_extendedVersionOption);
m_yoctoVersionOption .setDefaultValue("false");
m_parser.addOption(m_yoctoVersionOption);
m_yoctoInstallStatusOption .setDefaultValue("false");
m_parser.addOption(m_yoctoInstallStatusOption);
}
void CommandLineParser::readSettings() {
QString const iniFileDir = m_parser.value(m_iniFileDirectoryOption);
QString const iniFileName = m_parser.value(m_iniFileNameOption);
m_iniFileName = QDir::cleanPath(iniFileDir + QDir::separator() + iniFileName);
if (!m_iniFileName.isEmpty()) {
if (QFile(m_iniFileName).exists()) {
QSettings settings(m_iniFileName, QSettings::IniFormat);
QStringList keys = settings.allKeys();
for (QString const &key: keys) {
QVariant v = settings.value(key);
if (key.contains("repository-url")) {
m_repositoryUrl = v.toString();
} else
if (key.contains("plugin-directory")) {
m_plugInDir = v.toString();
} else
if (key.contains("working-directory")) {
m_workingDir = v.toString();
} else
if (key.contains("dry-run")) {
m_dryRun = (v.toBool() ? "true" : "false");
} else
if (key.contains("extended-version")) {
m_showExtendedVersion = (v.toBool() ? "true" : "false");
} else
if (key.contains("no-psa-hardware-update")) {
m_noUpdatePsaHardware = (v.toBool() ? "true" : "false");
} else
if (key.contains("always-download-config")) {
m_alwaysDownloadConfig = (v.toBool() ? "true" : "false");
} else
if (key.contains("always-download-dc")) {
m_alwaysDownloadDC = (v.toBool() ? "true" : "false");
} else
if (key.contains("yocto-install")) {
m_showYoctoInstallStatus = (v.toBool() ? "true" : "false");
} else
if (key.contains("yocto-version")) {
m_showYoctoVersion = (v.toBool() ? "true" : "false");
} else
if (key.contains("plugin-name")) {
m_plugInName = v.toString();
}
}
}
}
}
QString CommandLineParser::repositoryUrl() {
if (m_parser.isSet(m_repositoryUrlOption)) {
m_repositoryUrl = m_parser.value(m_repositoryUrlOption);
}
return m_repositoryUrl;
}
QString CommandLineParser::plugInDir() {
if (m_parser.isSet(m_pluginDirectoryOption)) {
m_plugInDir = m_parser.value(m_pluginDirectoryOption);
}
return m_plugInDir;
}
QString CommandLineParser::plugInName() {
if (m_parser.isSet(m_pluginNameOption)) {
m_plugInName = m_parser.value(m_pluginNameOption);
}
return m_plugInName;
}
QString CommandLineParser::workingDir() {
if (m_parser.isSet(m_workingDirectoryOption)) {
m_workingDir = m_parser.value(m_workingDirectoryOption);
}
return m_workingDir;
}
bool CommandLineParser::dryRun() {
if (m_parser.isSet(m_dryRunOption)) {
m_dryRun = m_parser.value(m_dryRunOption);
}
return m_dryRun == "false" ? false : true;
}
bool CommandLineParser::noUpdatePsaHardware() {
if (m_parser.isSet(m_noDownloadOption)) {
m_noUpdatePsaHardware = m_parser.value(m_noDownloadOption);
}
return m_noUpdatePsaHardware == "false" ? false : true;
}
bool CommandLineParser::yoctoVersion() {
if (m_parser.isSet(m_yoctoVersionOption)) {
m_showYoctoVersion = m_parser.value(m_yoctoVersionOption);
}
return m_showYoctoVersion == "false" ? false : true;
}
bool CommandLineParser::yoctoInstallStatus() {
if (m_parser.isSet(m_yoctoInstallStatusOption)) {
m_showYoctoInstallStatus = m_parser.value(m_yoctoInstallStatusOption);
}
return m_showYoctoInstallStatus == "false" ? false : true;
}
bool CommandLineParser::extendedVersion() {
if (m_parser.isSet(m_extendedVersionOption)) {
m_showExtendedVersion = m_parser.value(m_extendedVersionOption);
}
return m_showExtendedVersion == "false" ? false : true;
}
bool CommandLineParser::alwaysDownloadConfig() {
if (m_parser.isSet(m_alwaysDownloadConfigOption)) {
m_alwaysDownloadConfig = m_parser.value(m_alwaysDownloadConfigOption);
}
return m_alwaysDownloadConfig == "false" ? false : true;
}
bool CommandLineParser::alwaysDownloadDC() {
if (m_parser.isSet(m_alwaysDownloadDCOption)) {
m_alwaysDownloadDC = m_parser.value(m_alwaysDownloadDCOption);
}
return m_alwaysDownloadDC == "false" ? false : true;
}

63
commandline_parser.h Normal file
View File

@ -0,0 +1,63 @@
#ifndef COMMAND_LINE_PARSER_H_INCLUDED
#define COMMAND_LINE_PARSER_H_INCLUDED
#include <QCoreApplication>
#include <QCommandLineParser>
#include <QCommandLineOption>
#include <QString>
class CommandLineParser : public QCommandLineParser {
QString m_repositoryUrl;
QString m_plugInDir;
QString m_plugInName;
QString m_workingDir;
QString m_dryRun;
QString m_noUpdatePsaHardware;
QString m_showYoctoVersion;
QString m_showYoctoInstallStatus;
QString m_showExtendedVersion;
QString m_iniFileName;
QString m_alwaysDownloadConfig;
QString m_alwaysDownloadDC;
QCommandLineOption m_repositoryUrlOption;
QCommandLineOption m_iniFileDirectoryOption;
QCommandLineOption m_iniFileNameOption;
QCommandLineOption m_pluginDirectoryOption;
QCommandLineOption m_pluginNameOption;
QCommandLineOption m_noDownloadOption;
QCommandLineOption m_alwaysDownloadConfigOption;
QCommandLineOption m_alwaysDownloadDCOption;
QCommandLineOption m_workingDirectoryOption;
QCommandLineOption m_dryRunOption;
QCommandLineOption m_extendedVersionOption;
QCommandLineOption m_yoctoVersionOption;
QCommandLineOption m_yoctoInstallStatusOption;
QCommandLineParser m_parser;
void configure();
public:
explicit CommandLineParser();
~CommandLineParser() = default;
QCommandLineParser &parser() { return m_parser; }
QCommandLineParser const &parser() const { return m_parser; }
void process(const QCoreApplication &app) { m_parser.process(app); }
QString const &iniFileName() const { return m_iniFileName; }
void readSettings();
QString repositoryUrl();
QString plugInDir();
QString plugInName();
QString workingDir();
bool dryRun();
bool noUpdatePsaHardware();
bool yoctoVersion();
bool yoctoInstallStatus();
bool extendedVersion();
bool alwaysDownloadConfig();
bool alwaysDownloadDC();
};
#endif // COMMAND_LINE_PARSER_H_INCLUDED

230
doc/ATBUpdateTool.drawio Normal file
View File

@ -0,0 +1,230 @@
<mxfile host="www.draw.io" modified="2023-11-07T10:37:35.350Z" agent="Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/118.0" etag="ldmgaDoAxcOIqmOptaKH" version="22.0.8" type="device">
<diagram id="C5RBs43oDa-KdzZeNtuy" name="Page-1">
<mxGraphModel dx="1042" dy="633" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" math="0" shadow="0">
<root>
<mxCell id="WIyWlLk6GJQsqaUBKTNV-0" />
<mxCell id="WIyWlLk6GJQsqaUBKTNV-1" parent="WIyWlLk6GJQsqaUBKTNV-0" />
<mxCell id="WIyWlLk6GJQsqaUBKTNV-2" value="" style="rounded=0;html=1;jettySize=auto;orthogonalLoop=1;fontSize=11;endArrow=block;endFill=0;endSize=8;strokeWidth=1;shadow=0;labelBackgroundColor=none;edgeStyle=orthogonalEdgeStyle;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="WIyWlLk6GJQsqaUBKTNV-3" target="WIyWlLk6GJQsqaUBKTNV-6" edge="1">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="WIyWlLk6GJQsqaUBKTNV-3" value="START" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
<mxGeometry x="350" y="10" width="120" height="40" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-82" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="WIyWlLk6GJQsqaUBKTNV-6">
<mxGeometry relative="1" as="geometry">
<mxPoint x="220" y="180" as="targetPoint" />
</mxGeometry>
</mxCell>
<mxCell id="WIyWlLk6GJQsqaUBKTNV-6" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;&lt;div&gt;Existent customer repository&lt;/div&gt;&lt;div&gt;?&lt;/div&gt;" style="rhombus;whiteSpace=wrap;html=1;shadow=0;fontFamily=Helvetica;fontSize=12;align=center;strokeWidth=1;spacing=6;spacingTop=-4;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
<mxGeometry x="170" y="60" width="100" height="90" as="geometry" />
</mxCell>
<object label="" id="KwNStDcgQ-FNAQaH3l0E-18">
<mxCell style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="WIyWlLk6GJQsqaUBKTNV-7" target="KwNStDcgQ-FNAQaH3l0E-9">
<mxGeometry relative="1" as="geometry" />
</mxCell>
</object>
<mxCell id="WIyWlLk6GJQsqaUBKTNV-7" value="Clone customer repository" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;points=[[0,0,0,0,0],[0,0.25,0,0,0],[0,0.5,0,0,0],[0,0.75,0,0,0],[0,1,0,0,0],[0.25,0,0,0,0],[0.25,1,0,0,0],[0.5,0,0,0,0],[0.5,1,0,0,0],[0.75,0,0,0,0],[0.75,1,0,0,0],[1,0,0,0,0],[1,0.25,0,0,0],[1,0.5,0,0,0],[1,0.75,0,0,0],[1,1,0,0,0]];" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
<mxGeometry x="310" y="130" width="120" height="40" as="geometry" />
</mxCell>
<mxCell id="WIyWlLk6GJQsqaUBKTNV-10" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;&lt;div&gt;Repository corrupted&lt;/div&gt;&lt;div&gt;?&lt;/div&gt;" style="rhombus;whiteSpace=wrap;html=1;shadow=0;fontFamily=Helvetica;fontSize=12;align=center;strokeWidth=1;spacing=6;spacingTop=-4;movable=1;resizable=1;rotatable=1;deletable=1;editable=1;locked=0;connectable=1;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
<mxGeometry x="170" y="180" width="100" height="80" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-19" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.15;entryY=0.55;entryDx=0;entryDy=0;entryPerimeter=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="KwNStDcgQ-FNAQaH3l0E-9" target="KwNStDcgQ-FNAQaH3l0E-110">
<mxGeometry relative="1" as="geometry">
<mxPoint x="600" y="150" as="targetPoint" />
</mxGeometry>
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-9" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;&lt;div&gt;Repository corrupted&lt;/div&gt;&lt;div&gt;?&lt;/div&gt;" style="rhombus;whiteSpace=wrap;html=1;shadow=0;fontFamily=Helvetica;fontSize=12;align=center;strokeWidth=1;spacing=6;spacingTop=-4;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="480" y="150" width="90" height="80" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-11" value="FAIL" style="strokeWidth=2;html=1;shape=mxgraph.flowchart.terminator;whiteSpace=wrap;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="585" y="10" width="100" height="40" as="geometry" />
</mxCell>
<UserObject label="Yes" placeholders="1" name="Variable" id="KwNStDcgQ-FNAQaH3l0E-20">
<mxCell style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;overflow=hidden;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="560" y="160" width="80" height="20" as="geometry" />
</mxCell>
</UserObject>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-23" value="&lt;div&gt;No&lt;/div&gt;&lt;div&gt;&lt;br&gt;&lt;/div&gt;" style="text;strokeColor=none;align=center;fillColor=none;html=1;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="430" y="280" width="60" height="20" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-25" value="Delete corrupted repository" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;points=[[0,0,0,0,0],[0,0.25,0,0,0],[0,0.5,0,0,0],[0,0.75,0,0,0],[0,1,0,0,0],[0.25,0,0,0,0],[0.25,1,0,0,0],[0.5,0,0,0,0],[0.5,1,0,0,0],[0.75,0,0,0,0],[0.75,1,0,0,0],[1,0,0,0,0],[1,0.25,0,0,0],[1,0.5,0,0,0],[1,0.75,0,0,0],[1,1,0,0,0]];" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="310" y="200" width="120" height="40" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-26" value="" style="edgeStyle=none;orthogonalLoop=1;jettySize=auto;html=1;rounded=0;movable=1;resizable=1;rotatable=1;deletable=1;editable=1;locked=0;connectable=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;entryPerimeter=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" target="KwNStDcgQ-FNAQaH3l0E-25">
<mxGeometry width="80" relative="1" as="geometry">
<mxPoint x="270" y="220" as="sourcePoint" />
<mxPoint x="310" y="220" as="targetPoint" />
<Array as="points" />
</mxGeometry>
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-27" value="" style="edgeStyle=none;orthogonalLoop=1;jettySize=auto;html=1;rounded=0;exitX=0.5;exitY=0;exitDx=0;exitDy=0;exitPerimeter=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;entryPerimeter=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="KwNStDcgQ-FNAQaH3l0E-25" target="WIyWlLk6GJQsqaUBKTNV-7">
<mxGeometry width="80" relative="1" as="geometry">
<mxPoint x="540" y="240" as="sourcePoint" />
<mxPoint x="620" y="240" as="targetPoint" />
<Array as="points" />
</mxGeometry>
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-93" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="KwNStDcgQ-FNAQaH3l0E-28" target="KwNStDcgQ-FNAQaH3l0E-92">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-28" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;&lt;div&gt;ISMAS trigger&lt;/div&gt;&lt;div&gt;&lt;b&gt;WAIT&lt;/b&gt;&lt;br&gt;&lt;/div&gt;&lt;div&gt;?&lt;b&gt;&lt;br&gt;&lt;/b&gt;&lt;/div&gt;" style="rhombus;whiteSpace=wrap;html=1;shadow=0;fontFamily=Helvetica;fontSize=12;align=center;strokeWidth=1;spacing=6;spacingTop=-4;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="300" y="380" width="140" height="90" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-29" value="" style="edgeStyle=none;orthogonalLoop=1;jettySize=auto;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="KwNStDcgQ-FNAQaH3l0E-9" target="KwNStDcgQ-FNAQaH3l0E-78">
<mxGeometry width="80" relative="1" as="geometry">
<mxPoint x="540" y="240" as="sourcePoint" />
<mxPoint x="420" y="300" as="targetPoint" />
<Array as="points">
<mxPoint x="525" y="300" />
</Array>
</mxGeometry>
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-34" value="" style="edgeStyle=none;orthogonalLoop=1;jettySize=auto;html=1;rounded=0;entryX=1;entryY=1;entryDx=0;entryDy=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" target="KwNStDcgQ-FNAQaH3l0E-37">
<mxGeometry width="80" relative="1" as="geometry">
<mxPoint x="220" y="260" as="sourcePoint" />
<mxPoint x="320" y="300" as="targetPoint" />
<Array as="points">
<mxPoint x="220" y="300" />
</Array>
</mxGeometry>
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-37" value="&lt;div&gt;No&lt;/div&gt;&lt;div&gt;&lt;br&gt;&lt;/div&gt;" style="text;strokeColor=none;align=center;fillColor=none;html=1;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="250" y="280" width="120" height="20" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-42" value="" style="edgeStyle=none;orthogonalLoop=1;jettySize=auto;html=1;rounded=0;exitX=0;exitY=0.5;exitDx=0;exitDy=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="KwNStDcgQ-FNAQaH3l0E-28" target="KwNStDcgQ-FNAQaH3l0E-72">
<mxGeometry width="80" relative="1" as="geometry">
<mxPoint x="260" y="430" as="sourcePoint" />
<mxPoint x="99" y="560" as="targetPoint" />
<Array as="points">
<mxPoint x="40" y="425" />
<mxPoint x="40" y="570" />
</Array>
</mxGeometry>
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-43" value="&lt;div&gt;Yes&lt;/div&gt;&lt;div&gt;&lt;br&gt;&lt;/div&gt;" style="text;strokeColor=none;align=center;fillColor=none;html=1;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="240" y="405" width="60" height="20" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-65" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" target="KwNStDcgQ-FNAQaH3l0E-45">
<mxGeometry relative="1" as="geometry">
<mxPoint x="120" y="585" as="sourcePoint" />
</mxGeometry>
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-66" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" target="KwNStDcgQ-FNAQaH3l0E-46">
<mxGeometry relative="1" as="geometry">
<mxPoint x="120" y="670" as="sourcePoint" />
</mxGeometry>
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-63" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.5;entryY=0;entryDx=0;entryDy=0;entryPerimeter=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" target="KwNStDcgQ-FNAQaH3l0E-44">
<mxGeometry relative="1" as="geometry">
<mxPoint x="120" y="510" as="sourcePoint" />
</mxGeometry>
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-76" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.994;exitY=0.491;exitDx=0;exitDy=0;exitPerimeter=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="KwNStDcgQ-FNAQaH3l0E-75" target="KwNStDcgQ-FNAQaH3l0E-107">
<mxGeometry relative="1" as="geometry">
<mxPoint x="760" y="445" as="targetPoint" />
<mxPoint x="730" y="580" as="sourcePoint" />
</mxGeometry>
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-79" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="KwNStDcgQ-FNAQaH3l0E-78" target="KwNStDcgQ-FNAQaH3l0E-28">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-78" value="" style="shape=waypoint;sketch=0;fillStyle=solid;size=6;pointerEvents=1;points=[];fillColor=none;resizable=0;rotatable=0;perimeter=centerPerimeter;snapToPoint=1;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="360" y="290" width="20" height="20" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-81" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.5;entryY=0;entryDx=0;entryDy=0;entryPerimeter=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="WIyWlLk6GJQsqaUBKTNV-6" target="WIyWlLk6GJQsqaUBKTNV-7">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-83" value="&lt;div&gt;No&lt;/div&gt;&lt;div&gt;&lt;br&gt;&lt;/div&gt;" style="text;strokeColor=none;align=center;fillColor=none;html=1;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="290" y="90" width="60" height="30" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-84" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;&lt;div&gt;&lt;br&gt;&lt;/div&gt;&lt;div&gt;Yes&lt;/div&gt;&lt;div&gt;&lt;br&gt;&lt;/div&gt;&lt;div&gt;&lt;br&gt;&lt;/div&gt;" style="text;strokeColor=none;align=center;fillColor=none;html=1;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="170" y="140" width="60" height="30" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-86" value="opkg_commands always counts as a file to update" style="shape=note;whiteSpace=wrap;html=1;backgroundOutline=1;fontColor=#000000;darkOpacity=0.05;fillColor=#FFF9B2;strokeColor=none;fillStyle=solid;direction=west;gradientDirection=north;gradientColor=#FFF2A1;shadow=1;size=20;pointerEvents=1;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="240" y="610" width="120" height="100" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-87" value="in case someone has changed the zone (which means changed the branch)" style="shape=note;whiteSpace=wrap;html=1;backgroundOutline=1;fontColor=#000000;darkOpacity=0.05;fillColor=#FFF9B2;strokeColor=none;fillStyle=solid;direction=west;gradientDirection=north;gradientColor=#FFF2A1;shadow=1;size=20;pointerEvents=1;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="90" y="610" width="140" height="100" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-88" value="Update Json-configuration files) and the device controller firmware." style="shape=note;whiteSpace=wrap;html=1;backgroundOutline=1;fontColor=#000000;darkOpacity=0.05;fillColor=#FFF9B2;strokeColor=none;fillStyle=solid;direction=west;gradientDirection=north;gradientColor=#FFF2A1;shadow=1;size=20;pointerEvents=1;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="370" y="610" width="180" height="100" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-89" value="Sync tariff-files and ini-files with local filesystem." style="shape=note;whiteSpace=wrap;html=1;backgroundOutline=1;fontColor=#000000;darkOpacity=0.05;fillColor=#FFF9B2;strokeColor=none;fillStyle=solid;direction=west;gradientDirection=north;gradientColor=#FFF2A1;shadow=1;size=20;pointerEvents=1;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="560" y="610" width="160" height="100" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-90" value="Make sure the customer repository is in place and useable." style="shape=note;whiteSpace=wrap;html=1;backgroundOutline=1;fontColor=#000000;darkOpacity=0.05;fillColor=#FFF9B2;strokeColor=none;fillStyle=solid;direction=west;gradientDirection=north;gradientColor=#FFF2A1;shadow=1;size=20;pointerEvents=1;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="20" y="110" width="140" height="95" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-91" value="&lt;b&gt;NEVER&lt;/b&gt; do any real update-steps without an active ISMAS trigger." style="shape=note;whiteSpace=wrap;html=1;backgroundOutline=1;fontColor=#000000;darkOpacity=0.05;fillColor=#FFF9B2;strokeColor=none;fillStyle=solid;direction=west;gradientDirection=north;gradientColor=#FFF2A1;shadow=1;size=20;pointerEvents=1;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="20" y="320" width="140" height="80" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-92" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;&lt;div&gt;Initial/repaired&lt;/div&gt;&lt;div&gt;clone&lt;/div&gt;&lt;div&gt;?&lt;br&gt;&lt;/div&gt;" style="strokeWidth=2;html=1;shape=mxgraph.flowchart.decision;whiteSpace=wrap;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="585" y="375" width="100" height="100" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-96" value="SUCCESS" style="strokeWidth=2;html=1;shape=mxgraph.flowchart.terminator;whiteSpace=wrap;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="710" y="10" width="100" height="40" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-132" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="KwNStDcgQ-FNAQaH3l0E-97" target="KwNStDcgQ-FNAQaH3l0E-11">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-97" value="&lt;div&gt;Send Last Version&lt;/div&gt;" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;points=[[0,0,0,0,0],[0,0.25,0,0,0],[0,0.5,0,0,0],[0,0.75,0,0,0],[0,1,0,0,0],[0.25,0,0,0,0],[0.25,1,0,0,0],[0.5,0,0,0,0],[0.5,1,0,0,0],[0.75,0,0,0,0],[0.75,1,0,0,0],[1,0,0,0,0],[1,0.25,0,0,0],[1,0.5,0,0,0],[1,0.75,0,0,0],[1,1,0,0,0]];" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="580" y="100" width="110" height="30" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-99" value="No" style="text;strokeColor=none;align=center;fillColor=none;html=1;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="450" y="400" width="60" height="20" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-103" value="No" style="text;strokeColor=none;align=center;fillColor=none;html=1;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="580" y="330" width="60" height="20" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-104" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.15;entryY=0.4;entryDx=0;entryDy=0;entryPerimeter=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="KwNStDcgQ-FNAQaH3l0E-92" target="KwNStDcgQ-FNAQaH3l0E-107">
<mxGeometry relative="1" as="geometry">
<mxPoint x="700" y="425" as="targetPoint" />
</mxGeometry>
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-106" value="" style="group" vertex="1" connectable="0" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="50" y="540" width="770" height="57" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-72" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;&lt;div&gt;&amp;nbsp;&amp;nbsp; Checkout branch&lt;/div&gt;&lt;div&gt;&lt;br&gt;&lt;/div&gt;" style="shape=step;perimeter=stepPerimeter;fixedSize=1;points=[];whiteSpace=wrap;html=1;" vertex="1" parent="KwNStDcgQ-FNAQaH3l0E-106">
<mxGeometry width="130" height="57" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-73" value="&lt;div&gt;Update files&lt;/div&gt;&lt;div&gt;(Json, DeviceController)&lt;br&gt;&lt;/div&gt;" style="shape=step;perimeter=stepPerimeter;fixedSize=1;points=[];whiteSpace=wrap;html=1;" vertex="1" parent="KwNStDcgQ-FNAQaH3l0E-106">
<mxGeometry x="350" width="194" height="57" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-74" value="&lt;div&gt;Compute files &lt;br&gt;&lt;/div&gt;&lt;div&gt;to update&lt;br&gt;&lt;/div&gt;" style="shape=step;perimeter=stepPerimeter;fixedSize=1;points=[];whiteSpace=wrap;html=1;" vertex="1" parent="KwNStDcgQ-FNAQaH3l0E-106">
<mxGeometry x="110" width="140" height="57" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-75" value="&lt;div&gt;(R)Sync with local&lt;/div&gt;&lt;div&gt;filesystem&lt;br&gt;&lt;/div&gt;" style="shape=step;perimeter=stepPerimeter;fixedSize=1;points=[];whiteSpace=wrap;html=1;" vertex="1" parent="KwNStDcgQ-FNAQaH3l0E-106">
<mxGeometry x="520" width="170" height="57" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-105" value="&lt;div&gt;Exec&lt;/div&gt;&lt;div&gt;opkg-commands&lt;/div&gt;" style="shape=step;perimeter=stepPerimeter;fixedSize=1;points=[];whiteSpace=wrap;html=1;" vertex="1" parent="KwNStDcgQ-FNAQaH3l0E-106">
<mxGeometry x="230" width="140" height="57" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-107" value="" style="shape=waypoint;sketch=0;fillStyle=solid;size=6;pointerEvents=1;points=[];fillColor=none;resizable=0;rotatable=0;perimeter=centerPerimeter;snapToPoint=1;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="750" y="415" width="20" height="20" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-109" value="&lt;div&gt;Yes&lt;/div&gt;&lt;div&gt;&lt;br&gt;&lt;/div&gt;" style="text;strokeColor=none;align=center;fillColor=none;html=1;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="690" y="415" width="60" height="20" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-120" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.5;entryY=1;entryDx=0;entryDy=0;entryPerimeter=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="KwNStDcgQ-FNAQaH3l0E-110" target="KwNStDcgQ-FNAQaH3l0E-97">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-110" value="" style="shape=waypoint;sketch=0;fillStyle=solid;size=6;pointerEvents=1;points=[];fillColor=none;resizable=0;rotatable=0;perimeter=centerPerimeter;snapToPoint=1;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="625" y="180" width="20" height="20" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-129" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.95;entryY=0.95;entryDx=0;entryDy=0;entryPerimeter=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="KwNStDcgQ-FNAQaH3l0E-92" target="KwNStDcgQ-FNAQaH3l0E-110">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-135" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="KwNStDcgQ-FNAQaH3l0E-130" target="KwNStDcgQ-FNAQaH3l0E-96">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-130" value="&lt;div&gt;Send Last Version&lt;/div&gt;" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;points=[[0,0,0,0,0],[0,0.25,0,0,0],[0,0.5,0,0,0],[0,0.75,0,0,0],[0,1,0,0,0],[0.25,0,0,0,0],[0.25,1,0,0,0],[0.5,0,0,0,0],[0.5,1,0,0,0],[0.75,0,0,0,0],[0.75,1,0,0,0],[1,0,0,0,0],[1,0.25,0,0,0],[1,0.5,0,0,0],[1,0.75,0,0,0],[1,1,0,0,0]];" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
<mxGeometry x="705" y="100" width="110" height="30" as="geometry" />
</mxCell>
<mxCell id="KwNStDcgQ-FNAQaH3l0E-131" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.5;entryY=1;entryDx=0;entryDy=0;entryPerimeter=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="KwNStDcgQ-FNAQaH3l0E-107" target="KwNStDcgQ-FNAQaH3l0E-130">
<mxGeometry relative="1" as="geometry" />
</mxCell>
</root>
</mxGraphModel>
</diagram>
</mxfile>

Binary file not shown.

View File

@ -26,29 +26,93 @@ GitClient::GitClient(QString const &customerNrStr,
} }
bool GitClient::gitCloneCustomerRepository() { 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.
*/
// Note: for some reason it is necessary to pass "--progress ---v",
// otherwise QProcess returns an error of 128 = 0x80 for the command.
QString gitCommand("git clone --progress -vvv --filter=blob:none ");
gitCommand += m_repositoryPath; gitCommand += m_repositoryPath;
Command c(gitCommand); Command c(gitCommand);
qInfo() << "IN CURRENT WD" << m_workingDirectory qInfo() << "IN CURRENT WD" << m_workingDirectory
<< "CLONE" << m_repositoryPath << "..."; << "CLONE VIA COMMAND" << gitCommand;
if (c.execute(m_workingDirectory)) { // execute the command in wd if (c.execute(m_workingDirectory)) { // execute the command in wd
QString const result = c.getCommandResult(); QString const result = c.getCommandResult();
if (!result.isEmpty()) { if (!result.isEmpty()) {
// Cloning into 'customer_281'...\n // Cloning into 'customer_281'...\n
static QRegularExpression re("(^\\s*Cloning\\s+into\\s+[']\\s*)(.*)(\\s*['].*$)"); int customer = -1;
QRegularExpressionMatch match = re.match(result); int cloning = result.indexOf("Cloning", 0, Qt::CaseInsensitive);
if (match.hasMatch()) { if (cloning != -1) {
if (re.captureCount() == 3) { // start with full match (0), then the other 3 matches customer = result.indexOf("customer_", cloning, Qt::CaseInsensitive);
if (match.captured(2).trimmed() == m_customerNr) { if (customer != -1) {
qInfo() << "CLONING" << m_repositoryPath << "OK"; QString customerNr = result.mid(customer);
return true; static constexpr char const ch = '\'';
int i = customerNr.indexOf(QChar(ch));
if (i != -1) {
if ((customerNr = customerNr.mid(0, i)) == m_customerNr) {
qInfo() << "CLONING" << m_repositoryPath << "OK";
return true;
}
Utils::printCriticalErrorMsg(
QString("ERROR CLONE RESULT HAS WRONG CUSTOMER-NR. (%1 != %2) CLONE_RESULT=%3")
.arg(customerNr)
.arg(m_customerNr)
.arg(result));
return false;
} }
} }
} }
Utils::printCriticalErrorMsg(
QString("ERROR CLONE RESULT HAS WRONG FORMAT. CLONING=%1 CUSTOMER=%2 CLONE_RESULT=%3")
.arg(cloning)
.arg(customer)
.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; return false;
} }
@ -114,16 +178,14 @@ bool GitClient::gitCloneAndCheckoutBranch() {
return false; return false;
} }
QStringList GitClient::gitShowReason() { QStringList GitClient::gitShowReason(QString branchName) {
QStringList lst; QStringList lst;
if (QDir(m_customerRepository).exists()) { if (QDir(m_customerRepository).exists()) {
// %h: commit (short form) // %h: commit (short form)
// %s: commit message // %s: commit message
// %cI: commit date, strict ISO 8601 format // %cI: commit date, strict ISO 8601 format
// Note: use master branch. By convention, there is a ChangeLog file // Note: branch with branchName has to exist: format zg1/zone1
// in the root of the repository, which has to be always the last file Command c(QString("git show origin/%1 -s --format=\"c=%h m=%s d=%cI\"").arg(branchName));
// to be checked in when the customer repository somehow changed.
Command c("git show origin/master -s --format=\"c=%h m=%s d=%cI\"");
if (c.execute(m_customerRepository)) { if (c.execute(m_customerRepository)) {
QString const s = c.getCommandResult().trimmed(); QString const s = c.getCommandResult().trimmed();
int const c = s.indexOf("c="); int const c = s.indexOf("c=");
@ -217,92 +279,88 @@ std::optional<QStringList> GitClient::gitDiff(QString const &commits) {
return std::nullopt; return std::nullopt;
} }
bool GitClient::gitFsck() {
bool r = false;
if (QDir(m_customerRepository).exists()) {
Command c("git fsck");
if ((r = c.execute(m_customerRepository)) == false) {
QString const &s = c.getCommandResult().trimmed();
Utils::printCriticalErrorMsg(QString("GIT FSCK FAILED: %1").arg(s));
}
}
return r;
}
/* /*
Hat sich nichts geaendert, so werden auch keine Commits <>..<> angezeigt 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()) { if (QDir(m_customerRepository).exists()) {
qInfo() << "BRANCH NAME" << m_branchName; qInfo() << "BRANCH NAME" << m_branchName;
Command c("git fetch"); Command c("git pull");
if (c.execute(m_customerRepository)) { if (c.execute(m_customerRepository)) {
QString const s = c.getCommandResult().trimmed(); QString const s = c.getCommandResult().trimmed();
if (!s.isEmpty()) { if (!s.isEmpty()) {
QStringList lines = Update::split(s, '\n'); QStringList lines = Update::split(s, '\n');
worker()->CONSOLE(lines) << Worker::UPDATE_STEP::UPDATE_REPOSITORY;
if (!lines.empty()) { if (!lines.empty()) {
int zoneNr = Utils::read1stLineOfFile("/mnt/system_data/zone_nr"); static const QRegularExpression alreadyUpToDate("^\\s*Already\\s+up\\s+to\\s+date.*$");
m_branchName = (zoneNr != 0) ? QString("zg1/zone%1").arg(zoneNr) : "master"; if (std::none_of(lines.cbegin(), lines.cend(),
// lines can look like this: [](QString const &s) { return s.contains(alreadyUpToDate); })) {
// From https://git.mimbach49.de/GerhardHoffmann/customer_281 int zoneNr = Utils::read1stLineOfFile("/mnt/system_data/zone_nr");
// 41ec581..5d25ac3 master -> origin/master m_branchName = (zoneNr != 0) ? QString("zg1/zone%1").arg(zoneNr) : "master";
// ff10f57..43530a1 zg1/zone1 -> origin/zg1/zone1 // lines can look like this:
// 6ed893f..5d9882c zg1/zone2 -> origin/zg1/zone2 // From https://git.mimbach49.de/GerhardHoffmann/customer_281
// 4384d17..77045d8 zg1/zone3 -> origin/zg1/zone3 // 41ec581..5d25ac3 master -> origin/master
// 89d2812..36a0d74 zg1/zone5 -> origin/zg1/zone5 // ff10f57..43530a1 zg1/zone1 -> origin/zg1/zone1
bool found = false; // 6ed893f..5d9882c zg1/zone2 -> origin/zg1/zone2
for (int i=0; i < lines.size(); ++i) { // 4384d17..77045d8 zg1/zone3 -> origin/zg1/zone3
if (lines.at(i).contains(m_branchName)) { // 89d2812..36a0d74 zg1/zone5 -> origin/zg1/zone5
found = true; bool found = false;
// 409f198..6c22726 zg1/zone1 -> origin/zg1/zone1 for (int i=0; i < lines.size(); ++i) {
static QRegularExpression re("(^\\s*)([0-9A-Fa-f]+..[0-9A-Fa-f]+)(.*$)"); if (lines.at(i).contains(m_branchName)) {
QRegularExpressionMatch match = re.match(lines.at(i)); found = true;
if (match.hasMatch()) { // 409f198..6c22726 zg1/zone1 -> origin/zg1/zone1
if (re.captureCount() == 3) { // start with full match (0), then the other 3 matches static QRegularExpression re("(^\\s*)([0-9A-Fa-f]+..[0-9A-Fa-f]+)(.*$)");
return match.captured(2); QRegularExpressionMatch match = re.match(lines.at(i));
if (match.hasMatch()) {
if (re.captureCount() == 3) { // start with full match (0), then the other 3 matches
QString const matchCaptured = match.captured(2);
worker()->CONSOLE(QStringList(matchCaptured)) << Worker::UPDATE_STEP::UPDATE_REPOSITORY;
return matchCaptured;
} else {
QStringList lst(QString("(wrong capture count (%1)").arg(re.captureCount()));
worker()->GUI(lst) << (worker()->CONSOLE(lst) << Worker::UPDATE_STEP::UPDATE_REPOSITORY_FAILURE);
}
} else { } else {
emit m_worker->showErrorMessage("git fetch", QStringList lst("no regex-match for commits");
QString("(wrong cap-count (%1)").arg(re.captureCount())); worker()->GUI(lst) << (worker()->CONSOLE(lst) << Worker::UPDATE_STEP::UPDATE_REPOSITORY_FAILURE);
} }
} else {
emit m_worker->showErrorMessage("git fetch",
"no regex-match for commits");
Utils::printCriticalErrorMsg("NO REGEX MATCH FOR COMMITS");
} }
} }
} if (!found) {
if (!found) { QStringList lst(QString("unknown branch name ") + m_branchName);
emit m_worker->showErrorMessage("git fetch", worker()->GUI(lst) << (worker()->CONSOLE(lst) << Worker::UPDATE_STEP::UPDATE_REPOSITORY_FAILURE);
QString("unkown branch name ") + m_branchName); }
Utils::printCriticalErrorMsg("UNKNOWN BRANCH NAME " + m_branchName); } else {
return "Already up to date";
} }
} else { } else {
emit m_worker->showErrorMessage("git fetch", QStringList lst(QString("WRONG FORMAT FOR RESULT OF 'GIT PULL' ") + s);
QString("wrong format for result of 'git fetch' ") + s); worker()->GUI(lst) << (worker()->CONSOLE(lst) << Worker::UPDATE_STEP::UPDATE_REPOSITORY_FAILURE);
Utils::printCriticalErrorMsg(QString("WRONG FORMAT FOR RESULT OF 'GIT FETCH' ") + s);
} }
} else { } else {
emit m_worker->showErrorMessage("git fetch", "empty result for 'git fetch'"); QStringList lst("EMPTY RESULT FOR 'GIT PULL'");
Utils::printCriticalErrorMsg("EMPTY RESULT FOR 'GIT FETCH'"); worker()->GUI(lst) << (worker()->CONSOLE(lst) << Worker::UPDATE_STEP::UPDATE_REPOSITORY_FAILURE);
} }
} }
} else { } else {
emit m_worker->showErrorMessage("git fetch", QString("repository ") + m_customerRepository + " does not exist"); QStringList lst(QString("REPOSITORY ") + m_customerRepository + " DOES NOT EXIST");
Utils::printCriticalErrorMsg(QString("REPOSITORY ") + m_customerRepository + " DOES NOT EXIST"); worker()->GUI(lst) << (worker()->CONSOLE(lst) << Worker::UPDATE_STEP::UPDATE_REPOSITORY_FAILURE);
} }
return std::nullopt; 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() { std::optional<QStringList> GitClient::gitMerge() {
Command c("git merge"); Command c("git merge");
if (c.execute(m_workingDirectory)) { if (c.execute(m_workingDirectory)) {

View File

@ -43,14 +43,17 @@ class GitClient : public QObject {
bool gitCloneAndCheckoutBranch(); bool gitCloneAndCheckoutBranch();
std::optional<QString> gitFetch(); Worker *worker() { return m_worker; }
bool gitFetchAndDiff(); Worker const *worker() const { return m_worker; }
bool gitPull();
std::optional<QString> gitPull();
std::optional<QStringList> gitDiff(QString const &commit); std::optional<QStringList> gitDiff(QString const &commit);
std::optional<QStringList> gitMerge(); std::optional<QStringList> gitMerge();
bool gitFsck();
QString gitLastCommit(QString fileName); QString gitLastCommit(QString fileName);
QStringList gitShowReason(); QStringList gitShowReason(QString branchName);
static QString gitBlob(QString fileName); static QString gitBlob(QString fileName);
QString gitCommitForBlob(QString blob); QString gitCommitForBlob(QString blob);
bool gitIsFileTracked(QString file2name); bool gitIsFileTracked(QString file2name);

2372
interfaces.h Executable file

File diff suppressed because it is too large Load Diff

View File

@ -23,6 +23,15 @@
#include <QJsonObject> #include <QJsonObject>
#if 0 #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% # $1: EVENT: U0001 update finished: 100%
# U0002 reset TRG # U0002 reset TRG
# U0003 error # U0003 error
@ -47,6 +56,12 @@ void IsmasClient::printDebugMessage(int port,
QString const &clientIP, QString const &clientIP,
int clientPort, int clientPort,
QString const &message) { QString const &message) {
#if 0
Q_UNUSED(port);
Q_UNUSED(clientIP);
Q_UNUSED(clientPort);
Q_UNUSED(message);
#else
qDebug().noquote() qDebug().noquote()
<< "\n" << "\n"
<< "SEND-REQUEST-RECEIVE-RESPONSE ..." << "\n" << "SEND-REQUEST-RECEIVE-RESPONSE ..." << "\n"
@ -55,12 +70,19 @@ void IsmasClient::printDebugMessage(int port,
<< "local address ..." << clientIP << "\n" << "local address ..." << clientIP << "\n"
<< "local port ......" << clientPort << "\n" << "local port ......" << clientPort << "\n"
<< message; << message;
#endif
} }
void IsmasClient::printInfoMessage(int port, void IsmasClient::printInfoMessage(int port,
QString const &clientIP, QString const &clientIP,
int clientPort, int clientPort,
QString const &message) { QString const &message) {
#if 0
Q_UNUSED(port);
Q_UNUSED(clientIP);
Q_UNUSED(clientPort);
Q_UNUSED(message);
#else
qInfo().noquote() qInfo().noquote()
<< "\n" << "\n"
<< "SEND-REQUEST-RECEIVE-RESPONSE ..." << "\n" << "SEND-REQUEST-RECEIVE-RESPONSE ..." << "\n"
@ -69,6 +91,7 @@ void IsmasClient::printInfoMessage(int port,
<< "local address ..." << clientIP << "\n" << "local address ..." << clientIP << "\n"
<< "local port ......" << clientPort << "\n" << "local port ......" << clientPort << "\n"
<< message; << message;
#endif
} }
void IsmasClient::printErrorMessage(int port, void IsmasClient::printErrorMessage(int port,
@ -292,7 +315,7 @@ IsmasClient::sendRequestReceiveResponse(int port, QString const &request) {
} }
} }
printInfoMessage(port, clientIP, clientPort, QString("MESSAGE RECEIVED ") + buf); // printInfoMessage(port, clientIP, clientPort, QString("MESSAGE RECEIVED ") + buf);
QString response(buf); QString response(buf);
if (int idx = response.indexOf("{\"error\":\"ISMAS is offline\"}")) { if (int idx = response.indexOf("{\"error\":\"ISMAS is offline\"}")) {
@ -367,16 +390,18 @@ QString IsmasClient::errorBackendNotConnected(QString const &info,
version.toStdString().c_str()); version.toStdString().c_str());
} }
QString IsmasClient::errorGitClone(int percent, QString const &info, QString const &version) { QString IsmasClient::errorGitClone(QString const &info,
QString const &version) {
return updateNewsToIsmas("U0003", return updateNewsToIsmas("U0003",
percent, m_progressInPercent,
RESULT_CODE::INSTALL_ERROR, RESULT_CODE::INSTALL_ERROR,
"CLONE CUSTOMER REPOSITORY FAILED", "CLONE CUSTOMER REPOSITORY FAILED",
info.toStdString().c_str(), info.toStdString().c_str(),
version.toStdString().c_str()); version.toStdString().c_str());
} }
QString IsmasClient::backendConnected(QString const &info, QString const &version) { QString IsmasClient::backendConnected(QString const &info,
QString const &version) {
return updateNewsToIsmas("U0010", return updateNewsToIsmas("U0010",
m_progressInPercent, m_progressInPercent,
RESULT_CODE::SUCCESS, RESULT_CODE::SUCCESS,
@ -385,7 +410,8 @@ QString IsmasClient::backendConnected(QString const &info, QString const &versio
version.toStdString().c_str()); version.toStdString().c_str());
} }
QString IsmasClient::execOpkgCommand(QString const &info, QString const &version) { QString IsmasClient::execOpkgCommand(QString const &info,
QString const &version) {
return updateNewsToIsmas("U0010", return updateNewsToIsmas("U0010",
m_progressInPercent, m_progressInPercent,
RESULT_CODE::SUCCESS, RESULT_CODE::SUCCESS,
@ -622,6 +648,9 @@ QString IsmasClient::updateOfPSASendVersion(PSAInstalled const &psa) {
"}," "},"
"\"ATBQT\" : {" "\"ATBQT\" : {"
"\"VERSION\" : \"%s\"" "\"VERSION\" : \"%s\""
"},"
"\"ATB-UPDATE-TOOL\" : {"
"\"VERSION\" : \"%s\""
"}" "}"
"}," "},"
"\"PLUGINS\" : {" "\"PLUGINS\" : {"
@ -749,6 +778,7 @@ QString IsmasClient::updateOfPSASendVersion(PSAInstalled const &psa) {
psa.sw.apismVersion.toStdString().c_str(), psa.sw.apismVersion.toStdString().c_str(),
psa.sw.atbQTVersion.toStdString().c_str(), psa.sw.atbQTVersion.toStdString().c_str(),
psa.sw.atbUpdateToolVersion.toStdString().c_str(),
psa.pluginVersion.deviceController.toStdString().c_str(), psa.pluginVersion.deviceController.toStdString().c_str(),
psa.pluginVersion.ingenicoISelfCC.toStdString().c_str(), psa.pluginVersion.ingenicoISelfCC.toStdString().c_str(),
@ -857,7 +887,14 @@ QString IsmasClient::jsonParseFailed(int resultCode, QString reason, QString con
version.toStdString().c_str()); version.toStdString().c_str());
} }
std::optional<QString> IsmasClient::finalResult(int resultCode, QString reason, QString const &version) { std::optional<QString> IsmasClient::finalResult(int resultCode,
QString reason,
QString const &version) {
Q_UNUSED(resultCode);
Q_UNUSED(reason);
Q_UNUSED(version);
/*
m_progressInPercent = 100; m_progressInPercent = 100;
if (resultCode == RESULT_CODE::SUCCESS) { if (resultCode == RESULT_CODE::SUCCESS) {
return updateNewsToIsmas("U0002", return updateNewsToIsmas("U0002",
@ -875,6 +912,7 @@ std::optional<QString> IsmasClient::finalResult(int resultCode, QString reason,
reason.toStdString().c_str(), reason.toStdString().c_str(),
version.toStdString().c_str()); version.toStdString().c_str());
} }
*/
return std::nullopt; return std::nullopt;
} }

View File

@ -48,6 +48,7 @@ struct PSAInstalled {
struct SoftWare { struct SoftWare {
QString apismVersion; QString apismVersion;
QString atbQTVersion; QString atbQTVersion;
QString atbUpdateToolVersion;
} sw; } sw;
struct PluginVersion { struct PluginVersion {
@ -98,6 +99,7 @@ struct PSAInstalled {
sw.apismVersion = "N/A"; sw.apismVersion = "N/A";
sw.atbQTVersion = "N/A"; sw.atbQTVersion = "N/A";
sw.atbUpdateToolVersion = "N/A";
pluginVersion.deviceController = "N/A"; pluginVersion.deviceController = "N/A";
pluginVersion.ingenicoISelfCC = "N/A"; pluginVersion.ingenicoISelfCC = "N/A";
@ -175,7 +177,7 @@ public:
QString cloneAndCheckoutCustomerRepository(QString const &info, QString const &version = QString()); // clone and checkout customer repository QString cloneAndCheckoutCustomerRepository(QString const &info, QString const &version = QString()); // clone and checkout customer repository
QString checkoutBranch(QString const &info, QString const &version = QString()); // checkout branch QString checkoutBranch(QString const &info, QString const &version = QString()); // checkout branch
QString errorBackendNotConnected(QString const &info, QString const &version = QString()); // checkout branch QString errorBackendNotConnected(QString const &info, QString const &version = QString()); // checkout branch
QString errorGitClone(int percent, QString const &info, QString const &version = QString()); QString errorGitClone(QString const &info, QString const &version = QString());
QString backendConnected(QString const &info, QString const &version = QString()); QString backendConnected(QString const &info, QString const &version = QString());
QString updateTriggerSet(QString const &info, QString const &version = QString()); QString updateTriggerSet(QString const &info, QString const &version = QString());
QString errorUpdateTrigger(QString const &info, QString const &version = QString()); QString errorUpdateTrigger(QString const &info, QString const &version = QString());

160
main.cpp
View File

@ -10,6 +10,7 @@
#include "message_handler.h" #include "message_handler.h"
#include "plugins/interfaces.h" #include "plugins/interfaces.h"
#include "commandline_parser.h"
#include <unistd.h> #include <unistd.h>
#include <memory> #include <memory>
@ -21,6 +22,7 @@
#include <QCommandLineParser> #include <QCommandLineParser>
#include <QStandardPaths> #include <QStandardPaths>
#include <QMainWindow> #include <QMainWindow>
#include <QSettings>
#include "update.h" #include "update.h"
#include "git/git_client.h" #include "git/git_client.h"
@ -51,7 +53,7 @@ int main(int argc, char *argv[]) {
if (value != "C") { if (value != "C") {
qputenv("LC_ALL", "C"); qputenv("LC_ALL", "C");
} }
// qputenv("XDG_RUNTIME_DIR", "/run/user/0"); // qputenv("XDG_RUNTIME_DIR", "/var/run/user/0");
openlog("ATB-UPDATE", LOG_PERROR | LOG_PID | LOG_CONS, LOG_USER); openlog("ATB-UPDATE", LOG_PERROR | LOG_PID | LOG_CONS, LOG_USER);
@ -64,74 +66,73 @@ int main(int argc, char *argv[]) {
setDebugLevel(LOG_NOTICE); setDebugLevel(LOG_NOTICE);
} }
//#if defined (Q_OS_UNIX) || defined (Q_OS_LINUX) CommandLineParser parser;
//#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();
parser.addVersionOption();
QCommandLineOption pluginDirectoryOption(QStringList() << "plugin-directory" << "plugin-directory",
QCoreApplication::translate("main", "Where to find dc-plugin."),
QCoreApplication::translate("main", "directory"));
QString const pluginDefault = "/usr/lib";
pluginDirectoryOption.setDefaultValue(pluginDefault);
parser.addOption(pluginDirectoryOption);
QCommandLineOption pluginNameOption(QStringList() << "plugin-name" << "plugin-name",
QCoreApplication::translate("main", "Name of dc-plugin."),
QCoreApplication::translate("main", "directory"));
QString const pluginNameDefault = "libCAslave.so";
pluginNameOption.setDefaultValue(pluginNameDefault);
parser.addOption(pluginNameOption);
QCommandLineOption workingDirectoryOption(QStringList() << "working-directory" << "working-directory",
QCoreApplication::translate("main", "working directory of update-script."),
QCoreApplication::translate("main", "directory"));
QString const workingDirectoryDefault = "/opt/app/tools/atbupdate";
workingDirectoryOption.setDefaultValue(workingDirectoryDefault);
parser.addOption(workingDirectoryOption);
QCommandLineOption dryRunOption(QStringList() << "d" << "dry-run",
QCoreApplication::translate("main", "Start ATBUpdateTool in dry-run-mode. No actual actions."));
parser.addOption(dryRunOption);
// Process the actual command line arguments given by the user
parser.process(a); parser.process(a);
QString plugInDir = parser.value(pluginDirectoryOption); parser.readSettings();
QString plugInName = parser.value(pluginNameOption);
QString workingDir = parser.value(workingDirectoryOption); QString repositoryUrl = parser.repositoryUrl();
bool dryRun = parser.isSet(dryRunOption); QString plugInDir = parser.plugInDir();
QString plugInName = parser.plugInName();
QString workingDir = parser.workingDir();
QString iniFileName = parser.iniFileName();
bool const dryRun = parser.dryRun();
bool const noUpdatePsaHardware = parser.noUpdatePsaHardware();
bool const showYoctoVersion = parser.yoctoVersion();
bool const showYoctoInstallStatus = parser.yoctoInstallStatus();
bool const showExtendedVersion = parser.extendedVersion();
bool const alwaysDownloadConfig = parser.alwaysDownloadConfig();
bool const alwaysDownloadDC = parser.alwaysDownloadDC();
QString const rtPath = QCoreApplication::applicationDirPath(); QString const rtPath = QCoreApplication::applicationDirPath();
int const machineNr = Utils::read1stLineOfFile("/mnt/system_data/machine_nr");
int const customerNr = Utils::read1stLineOfFile("/mnt/system_data/cust_nr");
int const zoneNr = Utils::read1stLineOfFile("/mnt/system_data/zone_nr");
QString const branchName = (zoneNr != 0)
? QString("zg1/zone%1").arg(zoneNr) : "master";
qInfo() << "pwd ......................" << rtPath;
qInfo() << "repositoryUrl ............" << repositoryUrl;
qInfo() << "plugInDir ................" << plugInDir;
qInfo() << "plugInName ..............." << plugInName;
qInfo() << "workingDir ..............." << workingDir;
qInfo() << "dryRun ..................." << dryRun;
qInfo() << "noUpdatePsaHardware ......" << noUpdatePsaHardware;
qInfo() << "alwaysDownloadConfig ....." << alwaysDownloadConfig;
qInfo() << "alwaysDownloadDC ........." << alwaysDownloadDC;
qInfo() << "showYoctoVersion ........." << showYoctoVersion;
qInfo() << "showYoctoInstallStatus ..." << showYoctoInstallStatus;
qInfo() << "showExtendedVersion ......" << showExtendedVersion;
qInfo() << "iniFileName .............." << iniFileName;
qInfo() << "extended-version ........." << APP_EXTENDED_VERSION;
qInfo() << "machineNr ................" << machineNr;
qInfo() << "customerNr ..............." << customerNr;
qInfo() << "zoneNr ..................." << zoneNr;
if (showExtendedVersion) {
printf(APP_EXTENDED_VERSION"\n");
return 0;
}
if (showYoctoVersion) {
printf("%s\n", Worker::getATBUpdateToolYoctoVersion().toStdString().c_str());
return 0;
}
if (showYoctoInstallStatus) {
printf("%s\n", Worker::getATBUpdateToolYoctoInstallationStatus().toStdString().c_str());
return 0;
}
QThread::currentThread()->setObjectName("main thread");
qInfo() << "Main thread" << QThread::currentThreadId();
if (!QDir(plugInDir).exists()) { if (!QDir(plugInDir).exists()) {
qCritical() << plugInDir qCritical() << plugInDir
<< "does not exists, but has to contain dc-library"; << "does not exists, but has to contain dc-library";
exit(-1); 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 // before loading the library, delete all possible shared memory segments
#if defined Q_OS_LINUX || defined Q_OS_UNIX #if defined Q_OS_LINUX || defined Q_OS_UNIX
// system("rm -rf /tmp/qipc*"); // system("rm -rf /tmp/qipc*");
@ -139,49 +140,24 @@ int main(int argc, char *argv[]) {
#error "Only tested under UNIX/LINUX" #error "Only tested under UNIX/LINUX"
#endif #endif
hwinf *hw = Update::loadDCPlugin(QDir(plugInDir), plugInName);
hw->dc_autoRequest(true);
// hw->dc_openSerial(5, "115200", "ttymxc2", 1);
int machineNr = Utils::read1stLineOfFile("/etc/machine_nr");
int customerNr = Utils::read1stLineOfFile("/etc/cust_nr");
int zoneNr = Utils::read1stLineOfFile("/etc/zone_nr");
QString const branchName = (zoneNr != 0)
? QString("zg1/zone%1").arg(zoneNr) : "master";
QThread::currentThread()->setObjectName("main thread");
qInfo() << "Main thread" << QThread::currentThreadId();
Worker worker(customerNr, Worker worker(customerNr,
machineNr, machineNr,
zoneNr, zoneNr,
repositoryUrl,
branchName, branchName,
plugInDir,
plugInName, plugInName,
workingDir, workingDir,
noUpdatePsaHardware,
alwaysDownloadConfig,
alwaysDownloadDC,
dryRun); dryRun);
QString const customerNrStr( MainWindow mw(&worker);
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); worker.setMainWindow(&mw);
mw.setWindowFlags(Qt::Window | Qt::FramelessWindowHint); mw.setWindowFlags(Qt::Window | Qt::FramelessWindowHint);
mw.setWindowState(Qt::WindowFullScreen); mw.showFullScreen();
mw.show();
return a.exec(); return a.exec();
} }

View File

@ -10,104 +10,17 @@
#include <QMessageBox> #include <QMessageBox>
#include <QDebug> #include <QDebug>
#include <QScrollBar> #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) : QMainWindow(parent)
, ui(new Ui::MainWindow) , ui(new Ui::MainWindow)
, m_hw(hw)
, m_worker(worker) , m_worker(worker)
, m_width(70) , m_width(70)
, m_progressRunning(false) , m_progressRunning(false)
, m_progressValue(0)
, m_update(update)
, m_updateStep(UpdateDcEvent::UpdateStep::NONE) { , 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)); this->setStatusBar(new QStatusBar(this));
QFont f; QFont f;
f.setStyleHint(QFont::Monospace); f.setStyleHint(QFont::Monospace);
@ -125,10 +38,11 @@ MainWindow::MainWindow(hwinf *hw, Worker *worker, Update *update, QWidget *paren
QString start = QDateTime::currentDateTime().toString(Qt::ISODate); QString start = QDateTime::currentDateTime().toString(Qt::ISODate);
lst << QString("Start: ") + start.leftJustified(m_width-10); lst << QString("Start: ") + start.leftJustified(m_width-10);
lst << QString("").leftJustified(m_width-3, '='); lst << QString("").leftJustified(m_width-3, '=');
lst << QString("Machine number : %1 ").arg(m_worker->machineNr()).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("Customer number : %1 ").arg(m_worker->customerNr()).leftJustified(m_width-3); lst << QString("Machine number : %1 ").arg(m_worker->machineNr()).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("Customer number : %1 ").arg(m_worker->customerNr()).leftJustified(m_width-3);
lst << QString("APISM version : %1").arg(m_worker->apismVersion()).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, '='); lst << QString("").leftJustified(m_width-3, '=');
ui->updateStatus->setText(lst.join('\n')); ui->updateStatus->setText(lst.join('\n'));
@ -136,7 +50,7 @@ MainWindow::MainWindow(hwinf *hw, Worker *worker, Update *update, QWidget *paren
// ui->updateStatus->installEventFilter(this); // ui->updateStatus->installEventFilter(this);
m_startTimer = new QTimer(this); m_startTimer = new QTimer(this);
connect(m_startTimer, SIGNAL(timeout()), m_worker, SLOT(update())); connect(m_startTimer, SIGNAL(timeout()), m_worker, SLOT(start()));
m_startTimer->setSingleShot(true); m_startTimer->setSingleShot(true);
m_startTimer->start(1000); m_startTimer->start(1000);
@ -153,6 +67,8 @@ MainWindow::MainWindow(hwinf *hw, Worker *worker, Update *update, QWidget *paren
connect(m_worker, SIGNAL(appendText(QString,QString)),this,SLOT(onAppendText(QString,QString))); 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(showErrorMessage(QString,QString)),this, SLOT(onShowErrorMessage(QString,QString)));
connect(m_worker, SIGNAL(showStatusMessage(QString,QString)),this, SLOT(onShowStatusMessage(QString,QString))); connect(m_worker, SIGNAL(showStatusMessage(QString,QString)),this, SLOT(onShowStatusMessage(QString,QString)));
connect(m_worker, SIGNAL(showErrorMessage(QStringList)),this, SLOT(onShowErrorMessage(QStringList)));
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(QString,QString)),this,SLOT(onReplaceLast(QString,QString)));
connect(m_worker, SIGNAL(replaceLast(QStringList,QString)),this, SLOT(onReplaceLast(QStringList,QString))); connect(m_worker, SIGNAL(replaceLast(QStringList,QString)),this, SLOT(onReplaceLast(QStringList,QString)));
} }
@ -176,22 +92,22 @@ void MainWindow::customEvent(QEvent *event) {
case START_PROGRESS_LOOP: { case START_PROGRESS_LOOP: {
m_progressRunning = true; m_progressRunning = true;
ui->updateProgress->reset(); ui->updateProgress->reset();
m_progressValue = 10; // m_progressValue = 10;
QApplication::postEvent(this, new ProgressEvent(this, m_progressValue)); QApplication::postEvent(this, new ProgressEvent(this, 1));
} break; } break;
case STOP_PROGRESS_LOOP: { case STOP_PROGRESS_LOOP: {
m_progressRunning = false; m_progressRunning = false;
m_progressValue -= 10; // m_progressValue -= 10;
m_worker->setProgress(m_progressValue/10); // m_worker->setProgress(m_progressValue/10);
} break; } break;
default: { default: {
if (m_progressRunning) { if (m_progressRunning) {
m_progressValue = progress; // m_progressValue = progress;
ui->updateProgress->setValue(progress/10); ui->updateProgress->setValue(progress);
QApplication::postEvent(this, new ProgressEvent(this, progress+10)); // ueberpruefen: hauptfenster schickt sich selber ein event
QThread::msleep(500); // QApplication::postEvent(this, new ProgressEvent(this, progress));
} // QThread::msleep(500);
} }}
} }
} else } else
if (sender == m_worker) { if (sender == m_worker) {
@ -211,86 +127,6 @@ void MainWindow::customEvent(QEvent *event) {
} else { } else {
qCritical() << "!!! UNKNOWN SENDER !!!"; 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(); QThread::yieldCurrentThread();
@ -308,29 +144,33 @@ void MainWindow::onEnableExit() {
ui->exit->setEnabled(true); 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() { void MainWindow::onRestartExitTimer() {
m_exitTimer->stop(); m_exitTimer->stop();
m_exitTimer->start(60 * 1000); m_exitTimer->start(60 * 1000);
// ui->updateStatus->blockSignals(true); scrollDownTextEdit();
ui->updateStatus->setEnabled(false);
} }
void MainWindow::onQuit() { void MainWindow::onQuit() {
m_exitTimer->stop(); m_exitTimer->stop();
qCritical() << QString("ON QUIT: EXIT CODE %1").arg(m_worker->returnCode()); int errorCode = 0;
qApp->exit(m_worker->returnCode());
qCritical()
<< QString("ON QUIT: CURRENT STEP %1")
.arg(m_worker->getSmap()[m_worker->currentStep()]);
// TODO: replace SEND_LAST_VERSION with UPDATE_SUCCEEDED
if (m_worker->currentStep() != Worker::UPDATE_STEP::SEND_LAST_VERSION) {
errorCode = -1;
}
qCritical() << QString("ON QUIT: EXIT CODE %1").arg(errorCode);
qApp->exit(errorCode);
} }
void MainWindow::scrollDownTextEdit() { void MainWindow::scrollDownTextEdit() {
Utils::printInfoMsg(QString("SCROLL-DOWN-TEXT_EDIT CALLED AT ") // Utils::printInfoMsg(QString("SCROLL-DOWN-TEXT_EDIT CALLED AT ")
+ QDateTime::currentDateTime().toString(Qt::ISODateWithMs)); // + QDateTime::currentDateTime().toString(Qt::ISODateWithMs));
ui->updateStatus->setEnabled(true); ui->updateStatus->setEnabled(true);
@ -341,10 +181,12 @@ void MainWindow::scrollDownTextEdit() {
} }
void MainWindow::onAppendText(QString text, QString suffix) { void MainWindow::onAppendText(QString text, QString suffix) {
Utils::printInfoMsg(QString("ON APPEND CALLED AT ") // Utils::printInfoMsg(QString("ON APPEND CALLED AT ")
+ QDateTime::currentDateTime().toString(Qt::ISODateWithMs)); // + QDateTime::currentDateTime().toString(Qt::ISODateWithMs));
QString editText = ui->updateStatus->toPlainText(); QString editText = ui->updateStatus->toPlainText();
scrollDownTextEdit();
if (!suffix.isNull() && suffix.size() > 0) { if (!suffix.isNull() && suffix.size() > 0) {
//qInfo() << "TEXT" << text << "SUFFIX" << suffix; //qInfo() << "TEXT" << text << "SUFFIX" << suffix;
if (suffix == Worker::UPDATE_STEP_SUCCESS || suffix == Worker::UPDATE_STEP_FAIL) { if (suffix == Worker::UPDATE_STEP_SUCCESS || suffix == Worker::UPDATE_STEP_FAIL) {
@ -370,9 +212,8 @@ void MainWindow::onAppendText(QString text, QString suffix) {
} }
void MainWindow::onReplaceLast(QStringList newTextLines, QString suffix) { void MainWindow::onReplaceLast(QStringList newTextLines, QString suffix) {
Utils::printInfoMsg(QString("ON REPLACE LAST (LIST) CALLED AT ") // Utils::printInfoMsg(QString("ON REPLACE LAST (LIST) CALLED AT ")
+ QDateTime::currentDateTime().toString(Qt::ISODateWithMs)); // + QDateTime::currentDateTime().toString(Qt::ISODateWithMs));
int const s = newTextLines.size(); int const s = newTextLines.size();
if (s > 0) { if (s > 0) {
QString editText = ui->updateStatus->toPlainText(); QString editText = ui->updateStatus->toPlainText();
@ -405,13 +246,17 @@ void MainWindow::onReplaceLast(QStringList newTextLines, QString suffix) {
} }
void MainWindow::onReplaceLast(QString text, QString suffix) { void MainWindow::onReplaceLast(QString text, QString suffix) {
Utils::printInfoMsg(QString("ON REPLACE LAST (TEXT) CALLED AT ") // Utils::printInfoMsg(QString("ON REPLACE LAST (TEXT) CALLED AT ")
+ QDateTime::currentDateTime().toString(Qt::ISODateWithMs)); // + QDateTime::currentDateTime().toString(Qt::ISODateWithMs));
QString editText = ui->updateStatus->toPlainText(); QString editText = ui->updateStatus->toPlainText();
QStringList lines = editText.split('\n', QString::SplitBehavior::SkipEmptyParts); QStringList lines = editText.split('\n', QString::SplitBehavior::SkipEmptyParts);
if (lines.size() > 0) { if (lines.size() > 0) {
lines.removeLast(); // removing the last line is really meant for refreshing the last line
// with a string very similar than the original one, typically only
// followed by a suffix.
if (lines.last().contains(text)) {
lines.removeLast();
}
if (!suffix.isNull() && suffix.size() > 0 && suffix != "\n") { if (!suffix.isNull() && suffix.size() > 0 && suffix != "\n") {
QString const add = text.leftJustified(m_width-10) + suffix; QString const add = text.leftJustified(m_width-10) + suffix;
if (!add.isEmpty()) { if (!add.isEmpty()) {
@ -443,3 +288,21 @@ void MainWindow::onShowErrorMessage(QString title, QString text) {
void MainWindow::onShowStatusMessage(QString title, QString text) { void MainWindow::onShowStatusMessage(QString title, QString text) {
onShowMessage(title, text); onShowMessage(title, text);
} }
void MainWindow::onShowErrorMessage(QStringList lst) {
if (lst.size() >= 2) {
onShowMessage(lst.at(0), lst.at(1));
}
if (lst.size() == 1) {
onShowMessage(lst.at(0), "");
}
}
void MainWindow::onShowStatusMessage(QStringList lst) {
if (lst.size() >= 2) {
onShowMessage(lst.at(0), lst.at(1));
}
if (lst.size() == 1) {
onShowMessage(lst.at(0), "");
}
}

View File

@ -21,10 +21,9 @@ class MainWindow : public QMainWindow {
protected: protected:
void customEvent(QEvent *event) override; void customEvent(QEvent *event) override;
// bool eventFilter(QObject *obj, QEvent *ev) override;
public: public:
MainWindow(hwinf *hw, Worker *worker, Update *update, QWidget *parent = nullptr); MainWindow(Worker *worker, QWidget *parent = nullptr);
~MainWindow(); ~MainWindow();
static const int START_PROGRESS_LOOP = -1; static const int START_PROGRESS_LOOP = -1;
@ -34,11 +33,6 @@ public:
static const int BL_IS_UP_COUNT = 5; static const int BL_IS_UP_COUNT = 5;
static const int BL_STOP_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; } UpdateDcEvent::UpdateStep updateStep() const { return m_updateStep; }
void setUpdateStep(UpdateDcEvent::UpdateStep updateStep) { m_updateStep = updateStep; } void setUpdateStep(UpdateDcEvent::UpdateStep updateStep) { m_updateStep = updateStep; }
@ -48,6 +42,8 @@ public slots:
void onReplaceLast(QString, QString suffix = ""); void onReplaceLast(QString, QString suffix = "");
void onShowErrorMessage(QString, QString); void onShowErrorMessage(QString, QString);
void onShowStatusMessage(QString, QString); void onShowStatusMessage(QString, QString);
void onShowErrorMessage(QStringList);
void onShowStatusMessage(QStringList);
void onStopStartTimer(); void onStopStartTimer();
void onRestartExitTimer(); void onRestartExitTimer();
void onEnableExit(); void onEnableExit();
@ -70,14 +66,12 @@ private:
void onShowMessage(QString, QString); void onShowMessage(QString, QString);
Ui::MainWindow *ui; Ui::MainWindow *ui;
hwinf *m_hw;
Worker *m_worker; Worker *m_worker;
int const m_width; int const m_width;
QTimer *m_startTimer; QTimer *m_startTimer;
QTimer *m_exitTimer; QTimer *m_exitTimer;
bool m_progressRunning; bool m_progressRunning;
int m_progressValue; //int m_progressValue;
Update *m_update;
UpdateDcEvent::UpdateStep m_updateStep; UpdateDcEvent::UpdateStep m_updateStep;
}; };
#endif // MAINWINDOW_H #endif // MAINWINDOW_H

1819
plugins/interfaces.h Normal file → Executable file

File diff suppressed because it is too large Load Diff

Binary file not shown.

BIN
plugins/libCAslave.so Executable file

Binary file not shown.

Binary file not shown.

View File

@ -4,6 +4,7 @@
#include <QDebug> #include <QDebug>
#include <QDir> #include <QDir>
#include <QRegularExpression> #include <QRegularExpression>
#include <QDateTime>
Command::Command(QString const &command, int start_timeout, int finish_timeout) Command::Command(QString const &command, int start_timeout, int finish_timeout)
: m_command(command.trimmed()) : m_command(command.trimmed())
@ -65,39 +66,58 @@ bool Command::execute(QString workingDirectory, QStringList args) {
p->start(m_command); p->start(m_command);
} }
qint64 const start = QDateTime::currentDateTime().toMSecsSinceEpoch();
if (p->waitForStarted(m_waitForStartTimeout)) { if (p->waitForStarted(m_waitForStartTimeout)) {
qDebug() << "PROCESS" << m_command << "STARTED IN" << p->workingDirectory(); qDebug() << "PROCESS" << m_command << "STARTED IN" << p->workingDirectory();
if (p->state() == QProcess::ProcessState::Running) { if (p->state() == QProcess::ProcessState::Running) {
qDebug() << "PROCESS" << m_command << "RUNNING IN" << p->workingDirectory(); 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(); qDebug() << "PROCESS" << m_command << "FINISHED IN" << p->workingDirectory();
if (p->exitStatus() == QProcess::NormalExit) { if (p->exitStatus() == QProcess::NormalExit) {
if ((m_exitCode = p->exitCode()) == 0) { if ((m_exitCode = p->exitCode()) == 0) {
qint64 const end = QDateTime::currentDateTime().toMSecsSinceEpoch();
qDebug() << "EXECUTED" << m_command qDebug() << "EXECUTED" << m_command
<< QString("(runtime %1ms)").arg(end-start)
<< "with code" << m_exitCode << "with code" << m_exitCode
<< "IN" << p->workingDirectory(); << "IN" << p->workingDirectory();
return true; return true;
} else { } else {
qint64 const end = QDateTime::currentDateTime().toMSecsSinceEpoch();
qCritical() << "EXECUTED" << m_command qCritical() << "EXECUTED" << m_command
<< QString("(runtime %1ms)").arg(end-start)
<< "with code" << m_exitCode << "with code" << m_exitCode
<< "IN" << p->workingDirectory(); << "IN" << p->workingDirectory();
} }
} else { } else {
qint64 const end = QDateTime::currentDateTime().toMSecsSinceEpoch();
qCritical() << "PROCESS" << m_command << "CRASHED with code" qCritical() << "PROCESS" << m_command << "CRASHED with code"
<< p->exitCode() << p->exitCode()
<< QString("(after %1ms)").arg(end-start)
<< "IN" << p->workingDirectory(); << "IN" << p->workingDirectory();
} }
} else { } else {
qint64 const end = QDateTime::currentDateTime().toMSecsSinceEpoch();
qCritical() << "PROCESS" << m_command qCritical() << "PROCESS" << m_command
<< "DID NOT FINISH" << "DID NOT FINISH WITH" << wait
<< "IN" << p->workingDirectory(); << "MS IN" << p->workingDirectory()
<< QString("(runtime %1ms)").arg(end-start);
} }
} else { } else {
qCritical() << "WRONG PROCESS STATE" << p->state() qCritical() << "WRONG PROCESS STATE" << p->state()
<< "IN" << p->workingDirectory(); << "IN" << p->workingDirectory();
} }
} else { } else {
qint64 const end = QDateTime::currentDateTime().toMSecsSinceEpoch();
qCritical() << "PROCESS" << m_command << "TIMEOUT AT START" qCritical() << "PROCESS" << m_command << "TIMEOUT AT START"
<< QString("(runtime %1ms)").arg(end-start)
<< "IN" << p->workingDirectory(); << "IN" << p->workingDirectory();
} }
return false; return false;

View File

@ -29,11 +29,7 @@
#include <QMap> #include <QMap>
#define UPDATE_OPKG (1) #define UPDATE_OPKG (1)
#define UPDATE_DC (1) #define UPDATE_DC (0)
#define UPDATE_PRINTER_TEMPLATES (1)
#define UPDATE_CASH_TEMPLATE (1)
#define UPDATE_CONF_TEMPLATE (1)
#define UPDATE_DEVICE_TEMPLATE (1)
static const QMap<QString, int> baudrateMap = { static const QMap<QString, int> baudrateMap = {
{"1200" , 0}, {"9600" , 1}, {"19200" , 2}, {"38400" , 3}, {"1200" , 0}, {"9600" , 1}, {"19200" , 2}, {"38400" , 3},
@ -98,11 +94,11 @@ bool Update::unloadDCPlugin() {
return false; return false;
} }
Update::Update(hwinf *hw, Update::Update(Worker *worker,
Worker *worker,
QString customerRepository, QString customerRepository,
QString customerNrStr, QString customerNrStr,
QString branchName, QString branchName,
QString plugInDir,
QString pluginName, QString pluginName,
QString workingDir, QString workingDir,
bool dryRun, bool dryRun,
@ -110,7 +106,7 @@ Update::Update(hwinf *hw,
char const *serialInterface, char const *serialInterface,
char const *baudrate) char const *baudrate)
: QObject(parent) : QObject(parent)
, m_hw(hw) , m_hw(loadDCPlugin(QDir(plugInDir), pluginName))
, m_worker(worker) , m_worker(worker)
, m_serialInterface(serialInterface) , m_serialInterface(serialInterface)
, m_baudrate(baudrate) , m_baudrate(baudrate)
@ -119,214 +115,33 @@ Update::Update(hwinf *hw,
, m_branchName(branchName) , m_branchName(branchName)
, m_pluginName(pluginName) , m_pluginName(pluginName)
, m_workingDir(workingDir) , m_workingDir(workingDir)
, m_dryRun(dryRun) { , m_dryRun(dryRun)
, m_sys_areDCdataValid(false) {
qInfo() << "UPDATE: m_serialInterface ..." << m_serialInterface; int tries = 20;
qInfo() << "UPDATE: m_baudrate ..." << m_baudrate; while ((m_sys_areDCdataValid = m_hw->sys_areDCdataValid()) == false) {
qInfo() << "UPDATE: m_customerRepository ..." << m_customerRepository; // must deliver 'true', only then are all data from hwapi valid
qInfo() << "UPDATE: m_customerNr ..........." << m_customerNrStr; if (--tries < 0) {
qInfo() << "UPDATE: m_branchName ..........." << m_branchName; qCritical() << "ERROR!!! DC DATA NOT VALID -> CA-MASTER-PLUGIN NOT CONNECTED";
qInfo() << "UPDATE: m_pluginName ..........." << m_pluginName; }
qInfo() << "UPDATE: m_workingDirectory ....." << m_workingDir; m_hw->dc_autoRequest(true);
QThread::msleep(500);
}
qCritical() << "UPDATE: m_sys_areDCDataValid ..." << m_sys_areDCdataValid;
//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() { Update::~Update() {
} }
Update::DownloadResult Update::sendStatus(int ret) const {
switch (ret) { // return values of dc are:
case 0: // 0: no answer by now
return DownloadResult::NOP; // 1: error
case 10: // 10: success
return DownloadResult::OK;
default:;
}
return DownloadResult::ERROR;
}
Update::DownloadResult Update::sendNextAddress(int bNum) const {
// sends address only if blockNumber is one of 0, 1024, 2048, 3072, 4096
int noAnswerCount = 0;
int errorCount = 0;
if ( bNum==0 || bNum==1024 || bNum==2048 || bNum==3072 || bNum==4096 ) {
// qDebug() << "addr-block" << bNum << "...";
while (noAnswerCount <= 250) {
m_hw->bl_sendAddress(bNum);
QThread::msleep(100);
DownloadResult const res = sendStatus(m_hw->bl_wasSendingAddOK());
if (res != DownloadResult::NOP) {
if (res == DownloadResult::ERROR) {
if (++errorCount >= 10) {
qCritical() << "addr-block" << bNum << "...FAILED";
return res;
}
} else { // res == DownloadResult::OK
// qInfo() << "addr-block" << bNum << "...OK";
return res;
}
} else {
noAnswerCount += 1; // no answer by now
}
}
// wait max. about 3 seconds
return DownloadResult::TIMEOUT;
}
// blockNumber is not one of 0, 1024, 2048, 3072, 4096 -> do nothing
return DownloadResult::NOP;
}
Update::DownloadResult Update::sendNextDataBlock(QByteArray const &binary,
int bNum) const {
uint8_t local[66];
int const bAddr = bNum * 64;
int noAnswerCount = 0;
int errorCount = 0;
memcpy(local, binary.constData() + bAddr, 64);
local[64] = local[65] = 0x00;
// QByteArray b((const char *)(&local[0]), 64);
// qCritical() << "SNDB" << bNum << b.size() << b.toHex();
while (noAnswerCount <= 250) {
m_hw->bl_sendDataBlock(64, local);
QThread::msleep(10);
DownloadResult const res = sendStatus(m_hw->bl_wasSendingDataOK());
if (res != DownloadResult::NOP) {
if (res == DownloadResult::ERROR) {
if (++errorCount >= 10) {
qCritical() << "data for block" << bNum << "...FAILED";
return res;
}
} else {
// qInfo() << "data for block" << bNum << "OK";
return res;
}
} else {
noAnswerCount += 1; // no answer by now
}
}
// wait max. about 3 seconds
return DownloadResult::TIMEOUT;
}
Update::DownloadResult Update::dc_downloadBinary(QByteArray const &b) const {
int const nBlocks = (((b.size())%64)==0) ? (b.size()/64) : (b.size()/64)+1;
// fill lst block of data to be sent with 0xFF
QByteArray ba = b.leftJustified(nBlocks*64, (char)(0xFF));
qInfo() << "total number of bytes to send to dc" << ba.size();
qInfo() << "total number of blocks to send to dc" << nBlocks;
int bNum = 0;
DownloadResult res = DownloadResult::OK;
fprintf(stderr, "\n64-byte block %04d ", bNum);
while (res != DownloadResult::ERROR && bNum < nBlocks) {
if ((res = sendNextAddress(bNum)) != DownloadResult::ERROR) {
if ((res = sendNextDataBlock(ba, bNum)) != DownloadResult::ERROR) {
bNum += 1;
fprintf(stderr, ".");
if ((bNum % 80) == 0) {
fprintf(stderr, "\n64-byte block %04d ", bNum);
}
}
}
}
fprintf(stderr, "\nlast 64-byte block %04d\n", bNum);
int const rest = ba.size() % 64;
int const offset = ba.size() - rest;
char const *startAddress = ba.constData() + offset;
if (rest > 0) {
// SHOULD NEVER HAPPEN !!!
uint8_t local[66];
memset(local, 0xFF, sizeof(local));
memcpy(local, startAddress, rest);
qCritical() << "ERROR SEND REMAINING" << rest << "BYTES";
m_hw->bl_sendDataBlock(64, local);
}
m_hw->bl_sendLastBlock();
qInfo() << "last result" << (int)sendStatus(m_hw->bl_wasSendingDataOK());
return res;
}
bool Update::startBootloader() const { // deprecated
return false;
#if 0
int nStartTry = 5;
while (--nStartTry >= 0) {
m_hw->bl_startBL();
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";
return true;
} else {
qCritical() << "bootloader not up ("
<< nStartTry << "," << nCheckTry << ")" << QThread::currentThread();
}
}
}
qCritical() << "starting bootloader...FAILED" << QThread::currentThread();
return false;
#endif
}
bool Update::stopBootloader() const {
// 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);
}
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);
}
} 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. // br is a index into a table, used for historical reasons.
bool Update::openSerial(int br, QString baudrate, QString comPort) const { bool Update::openSerial(int br, QString baudrate, QString comPort) const {
qDebug() << "opening serial" << br << baudrate << comPort << "..."; qDebug() << "opening serial" << br << baudrate << comPort << "...";
@ -358,51 +173,6 @@ bool Update::isSerialOpen() const {
return m_hw->dc_isPortOpen(); return m_hw->dc_isPortOpen();
} }
bool Update::resetDeviceController() const { // deprecated
return false;
#if 0
qDebug() << "resetting device controller...";
m_hw->bl_rebootDC();
// wait maximally 3 seconds, before starting bootloader
qInfo() << "resetting device controller...OK";
return true;
#endif
}
QByteArray Update::loadBinaryDCFile(QString filename) const {
qDebug() << "loading dc binary" << filename << "...";
QFile file(filename); // closed in destructor call
if (!file.exists()) {
qCritical() << file.fileName() << "does not exist";
return QByteArray();
}
if (!file.open(QIODevice::ReadOnly)) {
qCritical() << "cannot open file" << file.fileName();
return QByteArray();
}
qInfo() << "loading dc binary" << filename << "...OK";
return file.readAll();
}
bool Update::downloadBinaryToDC(QString const &bFile) const {
qDebug() << "sending" << bFile << "to dc...";
QByteArray const dcBinary = loadBinaryDCFile(bFile);
if (dcBinary.size() > 0) {
if (dc_downloadBinary(dcBinary) != DownloadResult::OK) {
qCritical() << "sending" << bFile << "to dc...FAILED";
return false;
} else {
qInfo() << "sending" << bFile << "to dc...OK";
}
} else {
qCritical() << "sending" << bFile << "to dc...FAILED";
qCritical() << "loading binary" << bFile << "FAILED";
return false;
}
return true;
}
/* /*
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -486,111 +256,78 @@ bool Update::downloadBinaryToDC(QString const &bFile) const {
// There is no problem to repeat this command until the // There is no problem to repeat this command until the
// bootloader is really not running anymore. // bootloader is really not running anymore.
*/ */
bool Update::updateBinary(char const *fileToSendToDC) { bool Update::updateBinary(QString const &fileToSendToDC) {
qInfo() << "UPDATING DEVICE CONTROLLER FIRMWARE BINARY" << fileToSendToDC; qInfo() << "UPDATING DEVICE CONTROLLER FIRMWARE BINARY" << fileToSendToDC;
return false;
QFile fn(fileToSendToDC); QFile fn(fileToSendToDC);
bool r; if (!fn.exists()) {
if ((r = fn.exists()) == true) { // output via CONSOLE() etc
QFileInfo fi(fn); return false;
if ((r = updateDC(fileToSendToDC)) == true) { }
Utils::printInfoMsg(
QString(" UPDATING BINARY ") + fi.fileName() bool bl_isUp = false;
+ QString(" (size=%1").arg(fi.size()) + ") DONE"); if (m_hw->bl_completeStart()) {
} else { int cnt = 5;
Utils::printCriticalErrorMsg( while (--cnt > 0) {
QString(" UPDATING BINARY ") + fi.fileName() if (m_hw->bl_isUp()) {
+ QString(" (size=%1").arg(fi.size()) + ") FAILED"); bl_isUp = true;
break;
}
} }
} else {
Utils::printCriticalErrorMsg(
QString(fileToSendToDC) + " DOES NOT EXIST -> NO UPDATE OF DC FIRMWARE");
}
return r;
}
bool Update::updateDC(QString bFile) const {
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);
} }
int const cntLimit = 100; // wait until its for sure that bl_startBL() if (!bl_isUp) {
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; return false;
} }
m_worker->mainWindow()->setUpdateStep(UpdateDcEvent::UpdateStep::BL_CHECK); if (!m_hw->bl_storeFirmware(fileToSendToDC)) {
m_hw->bl_stopBL();
return false;
}
for (int i=1; i <= MainWindow::BL_IS_UP_COUNT; ++i) { uint16_t const nrOfFirmwareBlocks = m_hw->bl_getNrOfFirmwareBlocks();
QApplication::postEvent(m_worker->mainWindow(), new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::BL_CHECK, i));
QThread::sleep(1); for (uint16_t blockNr = 0; blockNr <= nrOfFirmwareBlocks; ++blockNr) {
QApplication::postEvent(m_worker->mainWindow(), new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::BL_IS_UP, i)); m_hw->bl_blockAutoLoad(blockNr);
if (m_worker->mainWindow()->updateStep() == UpdateDcEvent::UpdateStep::BL_IS_UP) {
break; int sleepTime = 0;
while (1) {
if (sleepTime > 1500) {
m_hw->bl_stopBL();
return false;
}
int8_t const r = m_hw->bl_blockAutoResponse();
// after every "bl_blockAutoLoad()" call this until response
// retval 0: wait 1: OK, blk was sent 2: OK, transfer complete
// 3: error despite repeating, cancel. probably bin file corrupted
// Max duration: 3x no response from BL = 900ms
switch(r) {
case 1:
/* fall through */
case 2:
sleepTime = 0;
break;
case 0: {
QThread::msleep(100);
sleepTime += 100;
} break;
case 3:
m_hw->bl_stopBL();
return false;
default:
m_hw->bl_stopBL();
return false; // unknown error code
}
} }
QThread::sleep(1);
m_hw->bl_stopBL();
} }
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)) {
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;
}
// 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;
}
Utils::printInfoMsg(QString("UPDATING DC: ") + bFile + " ...OK");
return true; return true;
} }
@ -610,10 +347,6 @@ bool Update::downloadJson(enum FileTypeJson type,
int templateIdx, int templateIdx,
QString jsFileToSendToDC) const { QString jsFileToSendToDC) const {
qDebug() << "updating json-file:" << jsFileToSendToDC << "...";
qDebug() << " template-index:" << templateIdx;
qDebug() << " json-type:" << jsonType(type);
m_hw->dc_autoRequest(true); // downloading Json needs the AutoEmission flag m_hw->dc_autoRequest(true); // downloading Json needs the AutoEmission flag
qDebug() << "SET AUTO-REQUEST=TRUE"; qDebug() << "SET AUTO-REQUEST=TRUE";
QThread::sleep(1); // make sure the auto-request flag is acknowledged QThread::sleep(1); // make sure the auto-request flag is acknowledged
@ -623,7 +356,7 @@ bool Update::downloadJson(enum FileTypeJson type,
while ((ready = m_hw->sys_ready4sending()) == false) { while ((ready = m_hw->sys_ready4sending()) == false) {
QThread::msleep(200); QThread::msleep(200);
if (--nTry <= 0) { if (--nTry <= 0) {
qCritical() << "SYS NOT READY FOR SENDING AFTER 5 SECONDS"; Utils::printCriticalErrorMsg("SYS NOT READY FOR SENDING AFTER 5 SECONDS");
break; break;
} }
} }
@ -636,22 +369,46 @@ bool Update::downloadJson(enum FileTypeJson type,
if (file.open(QIODevice::ReadOnly)) { if (file.open(QIODevice::ReadOnly)) {
if (fi.size() <= 800) { if (fi.size() <= 800) {
QByteArray ba = file.readAll(); 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), if (m_hw->sys_sendJsonFileToDc((uint8_t)(type),
templateIdx, templateIdx,
(uint8_t *)ba.data())) { (uint8_t *)ba.data())) {
QThread::sleep(1);
qDebug() << "SENT" << jsFileToSendToDC; m_hw->dc_autoRequest(true);
QThread::msleep(500);
// testing
m_hw->request_ReadbackMachineID();
QThread::msleep(500);
uint8_t data[64];
memset(data, 0x00, sizeof(data));
uint8_t length = 0;
m_hw->readback_machineIDdata(&length, data);
QThread::msleep(500);
QByteArray ba((const char*)data, length);
qCritical() << length << "MACHINE ID =" << ba.toHex(':');
ret = true; ret = true;
} }
} else { } else {
qCritical() << "SIZE OF" << jsFileToSendToDC Utils::printCriticalErrorMsg(
<< "TOO BIG (" << fi.size() << "BYTES)"; QString("SIZE OF %1 TOO BIG (%2 BYTES)")
.arg(jsFileToSendToDC).arg(fi.size()));
} }
} else { } else {
qCritical() << "CANNOT OPEN" << jsFileToSendToDC << "FOR READING"; Utils::printCriticalErrorMsg(
QString("CAN NOT OPEN ") + jsFileToSendToDC + " FOR READING");
} }
} else { } else {
qCritical() << jsFileToSendToDC << "DOES NOT EXIST"; Utils::printCriticalErrorMsg(
QString(jsFileToSendToDC) + " DOES NOT EXIST");
} }
} }
@ -738,112 +495,56 @@ QStringList Update::getDcSoftAndHardWareVersion() {
} }
bool Update::doUpdate(int &displayIndex, QStringList const &filesToWorkOn) { bool Update::doUpdate(int &displayIndex, QStringList const &filesToWorkOn) {
bool serialOpened = false; if (m_sys_areDCdataValid == false) {
qCritical() << "ERROR!!! DC DATA NOT VALID -> CA-MASTER-PLUGIN NOT CONNECTED";
QString const &parentName = Utils::getParentName(); return false;
Utils::printInfoMsg(
QString("PARENT OF ATB-UPDATE-TOOL (ppid=%1) ").arg(getppid()) + parentName);
if (parentName == "ATBQT" || parentName == "systemd") {
// the tool was not called during 'service' ot during an automatic
// update procedure. and it was called explicitly with libCAmaster.so
if (m_pluginName.contains("master", Qt::CaseInsensitive)) {
Utils::printCriticalErrorMsg(parentName
+ " IS MASTER, BUT ATB-UPDATE-TOOL CALLED WITH libCAmaster.so");
return false;
}
Utils::printInfoMsg(
QString("ATB-UPDATE-TOOL STARTED AS SLAVE OF ") + parentName);
} else
if (Utils::isATBQTRunning()) { // manual testing
if (m_pluginName.contains("master", Qt::CaseInsensitive)) {
Utils::printCriticalErrorMsg(
"ATBQT IS MASTER, BUT ATB-UPDATE-TOOL CALLED WITH libCAmaster.so");
return false;
}
Utils::printInfoMsg(
"ATB-UPDATE-TOOL STARTED AS SLAVE-SIBLING OF ATBQT-MASTER");
} else {
if (m_pluginName.contains("slave", Qt::CaseInsensitive)) {
Utils::printCriticalErrorMsg(
"ATB-UPDATE-TOOL CALLED WITH libCAslave.so ALTHOUGH MASTER");
return false;
}
Utils::printInfoMsg("ATB-UPDATE-TOOL STARTED AS MASTER");
if ((serialOpened = openSerial(baudrateMap.value(m_baudrate),
m_baudrate,
m_serialInterface)) == false) {
Utils::printCriticalErrorMsg(
QString("CANNOT OPEN ")
+ m_serialInterface
+ "( BAUDRATE=" + m_baudrate + ")");
return false;
}
m_hw->dc_autoRequest(false);
Utils::printInfoMsg(
QString("SERIAL OPEN ") + m_serialInterface
+ " (BAUDRATE=" + m_baudrate + ")");
} }
bool res = false; bool res = false;
QList<QString>::const_iterator it; QList<QString>::const_iterator it;
for (it = filesToWorkOn.cbegin(); it != filesToWorkOn.cend(); ++it) { for (it = filesToWorkOn.cbegin(); it != filesToWorkOn.cend(); ++it) {
m_worker->startProgressLoop(); m_worker->startProgressLoop();
QString fToWorkOn = (*it).trimmed(); QString const &fToWorkOn = QDir::cleanPath(m_customerRepository + QDir::separator() + it->trimmed());
fToWorkOn = QDir::cleanPath(m_customerRepository + QDir::separator() + fToWorkOn);
static const QRegularExpression version("^.*dc2c[.][0-9]{1,2}[.][0-9]{1,2}[.]bin.*$"); static const QRegularExpression version("^.*dc2c[.][0-9]{1,2}[.][0-9]{1,2}[.]bin.*$");
if (fToWorkOn.contains(version)) { if (fToWorkOn.contains(version)) {
Utils::printInfoMsg("DO-UPDATE FILE-TO-WORK-ON " + fToWorkOn); bool updateBinaryRes = true;
QFile fn(fToWorkOn); // CONSOLE()
QFileInfo finfo(fn);
if (!fn.exists()) { // check for broken link
Utils::printCriticalErrorMsg("DO-UPDATE FILE-TO-WORK-ON "
+ fToWorkOn + " DOES NOT EXIST");
res = false;
} else {
bool updateBinaryRes = true;
qInfo() << "DOWNLOADING" << finfo.completeBaseName() << "TO DC"; m_hw->dc_autoRequest(false);// default: turn auto-request setting off
#if UPDATE_DC == 1 QThread::sleep(1); // wait to be sure that there are no more
m_hw->dc_autoRequest(false);// default: turn auto-request setting off // commands sent to dc-hardware
QThread::sleep(1); // wait to be sure that there are no more
// commands sent to dc-hardware
qInfo() << "SET AUTO-REQUEST=FALSE";
if ((updateBinaryRes = updateBinary(fToWorkOn.toStdString().c_str())) == true) { if ((updateBinaryRes = updateBinary(fToWorkOn)) == true) {
qCritical() << "downloaded binary" << fToWorkOn;
++displayIndex;
emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(2, ' ') + QString(")")
+ QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
Worker::UPDATE_STEP_DONE);
}
m_hw->dc_autoRequest(true); // turn auto-request setting on // qCritical() << "downloaded binary" << fToWorkOn;
qInfo() << "SET AUTO-REQUEST=TRUE";
QStringList const &versions = Update::getDcSoftAndHardWareVersion(); ++displayIndex;
if (versions.size() >= 2) { emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(2, ' ') + QString(")")
if (updateBinaryRes == true) { + QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
qInfo() << "dc-hardware-version (UPDATED)" << versions[0]; Worker::UPDATE_STEP_DONE);
qInfo() << "dc-firmware-version (UPDATED)" << versions[1];
} else {
qInfo() << "dc-hardware-version (NOT UPDATED)" << versions[0];
qInfo() << "dc-firmware-version (NOT UPDATED)" << versions[1];
}
}
#endif
res = updateBinaryRes;
} }
m_hw->dc_autoRequest(true); // turn auto-request setting on
// qInfo() << "SET AUTO-REQUEST=TRUE";
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;
} else if (fToWorkOn.contains("DC2C_print", Qt::CaseInsensitive) } else if (fToWorkOn.contains("DC2C_print", Qt::CaseInsensitive)
&& fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) { && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
res = true; res = true;
#if UPDATE_PRINTER_TEMPLATES == 1
int i = fToWorkOn.indexOf("DC2C_print", Qt::CaseInsensitive); int i = fToWorkOn.indexOf("DC2C_print", Qt::CaseInsensitive);
int const templateIdx = fToWorkOn.mid(i).midRef(10, 2).toInt(); int const templateIdx = fToWorkOn.mid(i).midRef(10, 2).toInt();
if ((templateIdx < 1) || (templateIdx > 32)) { if ((templateIdx < 1) || (templateIdx > 32)) {
@ -851,68 +552,60 @@ bool Update::doUpdate(int &displayIndex, QStringList const &filesToWorkOn) {
res = false; res = false;
} else { } else {
if ((res = updatePrinterTemplate(templateIdx, fToWorkOn))) { 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; ++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(), + QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
Worker::UPDATE_STEP_DONE); Worker::UPDATE_STEP_DONE);
} }
} }
#endif
} else if (fToWorkOn.contains("DC2C_cash", Qt::CaseInsensitive) } else if (fToWorkOn.contains("DC2C_cash", Qt::CaseInsensitive)
&& fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) { && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
res = true; res = true;
#if UPDATE_CASH_TEMPLATE == 1
if ((res = updateCashConf(fToWorkOn))) { if ((res = updateCashConf(fToWorkOn))) {
qInfo() << "downloaded cash template"<< fToWorkOn; Utils::printInfoMsg(QString("DOWNLOADED CASH TEMPLATE %1").arg(fToWorkOn));
++displayIndex; ++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(), + QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
Worker::UPDATE_STEP_DONE); Worker::UPDATE_STEP_DONE);
} }
#endif
} else if (fToWorkOn.contains("DC2C_conf", Qt::CaseInsensitive) } else if (fToWorkOn.contains("DC2C_conf", Qt::CaseInsensitive)
&& fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) { && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
res = true; res = true;
#if UPDATE_CONF_TEMPLATE == 1
if ((res= updateConfig(fToWorkOn))) { if ((res= updateConfig(fToWorkOn))) {
qInfo() << "downloaded config template"<< fToWorkOn; Utils::printInfoMsg(QString("DOWNLOADED CONFIG TEMPLATE %1").arg(fToWorkOn));
++displayIndex; ++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(), + QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
Worker::UPDATE_STEP_DONE); Worker::UPDATE_STEP_DONE);
} }
#endif
} else if (fToWorkOn.contains("DC2C_device", Qt::CaseInsensitive) } else if (fToWorkOn.contains("DC2C_device", Qt::CaseInsensitive)
&& fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) { && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
res = true; res = true;
#if UPDATE_DEVICE_TEMPLATE == 1
if ((res = updateDeviceConf(fToWorkOn))) { if ((res = updateDeviceConf(fToWorkOn))) {
qInfo() << "downloaded device template"<< fToWorkOn; Utils::printInfoMsg(QString("DOWNLOADED DEVICE TEMPLATE %1").arg(fToWorkOn));
++displayIndex; ++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(), + QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
Worker::UPDATE_STEP_DONE); Worker::UPDATE_STEP_DONE);
} }
#endif
} else { } else {
qCritical() << "UNKNOWN JSON FILE NAME" << fToWorkOn; qCritical() << "UNKNOWN JSON FILE NAME" << fToWorkOn;
res = false; res = false;
} }
m_worker->stopProgressLoop(); // m_worker->stopProgressLoop();
m_worker->setProgress(100); // m_worker->setProgress(100);
if (res == false) { if (res == false) {
break; break;
} }
} // for (it = openLines.cbegin(); it != openLines.end(); ++it) { } // for (it = openLines.cbegin(); it != openLines.end(); ++it) {
//m_hw->dc_autoRequest(true); // ALWAYS turn autoRequest ON m_hw->dc_autoRequest(true); // ALWAYS turn autoRequest ON
//qDebug() << "SET AUTO-REQUEST=TRUE"; qDebug() << "SET AUTO-REQUEST=TRUE";
if (serialOpened) {
m_hw->dc_closeSerial();
}
return res; return res;
} }

View File

@ -21,8 +21,8 @@ class Worker;
class Update : public QObject { class Update : public QObject {
Q_OBJECT Q_OBJECT
hwinf *m_hw; hwinf *m_hw = nullptr;
Worker *m_worker; Worker *m_worker = nullptr;
char const *m_serialInterface; char const *m_serialInterface;
char const *m_baudrate; char const *m_baudrate;
QString m_customerRepository; QString m_customerRepository;
@ -32,6 +32,7 @@ class Update : public QObject {
QString m_workingDir; QString m_workingDir;
bool m_maintenanceMode; bool m_maintenanceMode;
bool m_dryRun; bool m_dryRun;
bool m_sys_areDCdataValid;
static QPluginLoader pluginLoader; static QPluginLoader pluginLoader;
@ -44,11 +45,11 @@ public:
static QStringList split(QString line, QChar sep = ','); static QStringList split(QString line, QChar sep = ',');
explicit Update(hwinf *hw, explicit Update(Worker *worker,
Worker *worker,
QString customerRepository, QString customerRepository,
QString customerNrStr, QString customerNrStr,
QString branchName, QString branchName,
QString plugInDir,
QString pluginName, QString pluginName,
QString workingDir, QString workingDir,
bool dryRun = false, bool dryRun = false,
@ -58,6 +59,9 @@ public:
virtual ~Update() override; virtual ~Update() override;
bool doUpdate(int &displayIndex, QStringList const &linesToWorkOn); bool doUpdate(int &displayIndex, QStringList const &linesToWorkOn);
hwinf *hw() { return m_hw; }
hwinf const *hw() const { return m_hw; }
//QString customerId() { return m_customerId; } //QString customerId() { return m_customerId; }
//QString const customerId() const { return m_customerId; } //QString const customerId() const { return m_customerId; }
@ -69,23 +73,14 @@ public:
private: private:
static QString jsonType(enum FileTypeJson type); static QString jsonType(enum FileTypeJson type);
DownloadResult sendStatus(int ret) const;
DownloadResult sendNextAddress(int bNum) const;
DownloadResult sendNextDataBlock(QByteArray const &b, int bNum) const;
DownloadResult dc_downloadBinary(QByteArray const &binary) const;
bool startBootloader() const;
bool stopBootloader() const;
bool openSerial(int br, QString baudrate, QString comPort) const; bool openSerial(int br, QString baudrate, QString comPort) const;
void closeSerial() const; void closeSerial() const;
bool isSerialOpen() const; bool isSerialOpen() const;
bool resetDeviceController() const; bool resetDeviceController() const;
QByteArray loadBinaryDCFile(QString filename) const; QByteArray loadBinaryDCFile(QString filename) const;
bool downloadBinaryToDC(QString const &bFile) const; bool downloadBinaryToDC(QString const &bFile) const;
bool updateDC(QString bFile) const;
bool updatePrinterTemplate(int templateIdx, QString fname) const; bool updatePrinterTemplate(int templateIdx, QString fname) const;
bool updateBinary(char const *fileToSendToDC); bool updateBinary(QString const &fileToSendToDC);
bool updateConfig(QString jsFileToSendToDC); bool updateConfig(QString jsFileToSendToDC);
bool updateCashConf(QString jsFileToSendToDC); bool updateCashConf(QString jsFileToSendToDC);
bool updateDeviceConf(QString jsFileToSendToDC); bool updateDeviceConf(QString jsFileToSendToDC);

View File

@ -46,17 +46,90 @@ QString Utils::zoneName(quint8 i) {
return "N/A"; return "N/A";
} }
void Utils::printCriticalErrorMsg(QString const &errorMsg) { void Utils::printCriticalErrorMsg(QString const &errorMsg, bool upper, bool lower) {
qCritical() << QString(80, '!'); if (upper) qCritical() << QString(80, 'E');
qCritical() << errorMsg; qCritical() << errorMsg;
qCritical() << QString(80, '!');
if (lower) qCritical() << QString(80, 'E');
} }
void Utils::printInfoMsg(QString const &infoMsg) { void Utils::printCriticalErrorMsg(QStringList const &errorMsg) {
qCritical() << QString(80, '='); qCritical() << QString(80, 'E');
qCritical() << infoMsg; for (int i = 0; i < errorMsg.size(); ++i) {
qCritical() << QString(80, '='); qCritical() << errorMsg.at(i);
}
qCritical() << QString(80, 'E');
}
void Utils::printUpdateStatusMsg(QDebug debug, QStringList const &updateMsg) {
//if (updateMsg.size() > 1) {
// qCritical() << QString(80, 'U');
//}
Q_UNUSED(debug);
for (int i = 0; i < updateMsg.size(); ++i) {
qInfo() << updateMsg.at(i);
}
//if (updateMsg.size() > 1) {
// qCritical() << QString(80, 'U');
//}
}
void Utils::printUpdateStatusMsg(QStringList const &updateMsg) {
//if (updateMsg.size() > 1) {
// qCritical() << QString(80, 'U');
//}
for (int i = 0; i < updateMsg.size(); ++i) {
qCritical() << updateMsg.at(i);
}
//if (updateMsg.size() > 1) {
// qCritical() << QString(80, 'U');
//}
}
void Utils::printUpdateStatusMsg(QString const &updateMsg, bool upper, bool lower) {
if (upper) qCritical() << QString(80, 'U');
qCritical() << updateMsg;
if (lower) qCritical() << QString(80, 'U');
}
void Utils::printUpdateStatusMsg(QDebug debug, QString const &updateMsg,
bool upper, bool lower) {
if (upper) debug << QString(80, 'U');
qInfo() << updateMsg;
if (lower) debug << QString(80, 'U');
}
void Utils::printInfoMsg(QString const &infoMsg, bool upper, bool lower) {
if (upper) qCritical() << QString(80, 'I');
qCritical() << infoMsg;
if (lower) qCritical() << QString(80, 'I');
}
void Utils::printInfoMsg(QStringList const &infoMsg) {
//if (infoMsg.size() > 1) {
// qCritical() << QString(80, 'I');
//}
for (int i = 0; i < infoMsg.size(); ++i) {
qCritical() << infoMsg.at(i);
}
//if (infoMsg.size() > 1) {
// qCritical() << QString(80, 'I');
//}
} }
void Utils::printLineEditInfo(QStringList const &lines) { void Utils::printLineEditInfo(QStringList const &lines) {

11
utils.h
View File

@ -8,12 +8,19 @@
#include <QFileInfo> #include <QFileInfo>
#include <QDateTime> #include <QDateTime>
#include <QDir> #include <QDir>
#include <QDebug>
namespace Utils { namespace Utils {
int read1stLineOfFile(QString fileName); int read1stLineOfFile(QString fileName);
QString zoneName(quint8 i); QString zoneName(quint8 i);
void printCriticalErrorMsg(QString const &errorMsg); void printCriticalErrorMsg(QString const &errorMsg, bool upper=false, bool lower=false);
void printInfoMsg(QString const &infoMsg); void printCriticalErrorMsg(QStringList const &errorMsg);
void printInfoMsg(QString const &infoMsg, bool upper=false, bool lower=false);
void printInfoMsg(QStringList const &infoMsg);
void printUpdateStatusMsg(QDebug debug, QStringList const &updateMsg);
void printUpdateStatusMsg(QStringList const &updateMsg);
void printUpdateStatusMsg(QString const &updateMsg, bool upper=false, bool lower=false);
void printUpdateStatusMsg(QDebug debug, QString const &updateMsg, bool upper=false, bool lower=false);
void printLineEditInfo(QStringList const &lines); void printLineEditInfo(QStringList const &lines);
QString getTariffLoadTime(QString fileName); QString getTariffLoadTime(QString fileName);
QString rstrip(QString const &str); QString rstrip(QString const &str);

1599
worker.cpp

File diff suppressed because it is too large Load Diff

1207
worker.h

File diff suppressed because it is too large Load Diff