Compare commits

...

7 Commits

23 changed files with 4278 additions and 3159 deletions

42
.gitignore vendored
View File

@ -1 +1,41 @@
*.user # 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

@ -2,6 +2,7 @@ INCLUDEPATH += $${PWD}/include
DEPENDPATH += $${PWD} DEPENDPATH += $${PWD}
HEADERS += $${PWD}/include/com.h \ HEADERS += $${PWD}/include/com.h \
$$PWD/include/datei.h \
$${PWD}/include/controlBus.h \ $${PWD}/include/controlBus.h \
$${PWD}/include/datIf.h \ $${PWD}/include/datIf.h \
$${PWD}/include/dcBL.h \ $${PWD}/include/dcBL.h \
@ -14,6 +15,8 @@ HEADERS += $${PWD}/include/com.h \
$${PWD}/include/shared_mem_buffer.h $${PWD}/include/shared_mem_buffer.h
SOURCES += $${PWD}/src/com.cpp \ SOURCES += $${PWD}/src/com.cpp \
$$PWD/src/datei.cpp \
$$PWD/src/main.cpp \
$${PWD}/src/controlBus.cpp \ $${PWD}/src/controlBus.cpp \
$${PWD}/src/datIf.cpp \ $${PWD}/src/datIf.cpp \
$${PWD}/src/dcBL.cpp \ $${PWD}/src/dcBL.cpp \

View File

@ -15,9 +15,9 @@ QMAKE_CXXFLAGS += -Wno-deprecated-copy
ARCH = PTU5 ARCH = PTU5
contains( CONFIG, DesktopLinux ) { 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++11 QMAKE_CXXFLAGS += -std=c++17
# QMAKE_CXXFLAGS += -Wno-deprecated-ctor # QMAKE_CXXFLAGS += -Wno-deprecated-ctor
linux-clang { QMAKE_CXXFLAGS += -Qunused-arguments } linux-clang { QMAKE_CXXFLAGS += -Qunused-arguments }
ARCH = DesktopLinux ARCH = DesktopLinux
@ -27,7 +27,7 @@ contains( CONFIG, DesktopLinux ) {
contains( CONFIG, PTU5 ) { contains( CONFIG, PTU5 ) {
# QMAKE_CC = ccache $$QMAKE_CC # QMAKE_CC = ccache $$QMAKE_CC
# QMAKE_CXX = ccache $$QMAKE_CXX # QMAKE_CXX = ccache $$QMAKE_CXX
QMAKE_CXXFLAGS += -std=c++11 QMAKE_CXXFLAGS += -std=c++17
linux-clang { QMAKE_CXXFLAGS += -Qunused-arguments } linux-clang { QMAKE_CXXFLAGS += -Qunused-arguments }
CONFIG += link_pkgconfig CONFIG += link_pkgconfig
ARCH = PTU5 ARCH = PTU5
@ -38,6 +38,8 @@ contains( CONFIG, PTU5 ) {
} }
contains( CONFIG, PTU5_YOCTO ) { contains( CONFIG, PTU5_YOCTO ) {
greaterThan(QT_MAJOR_VERSION, 4): QT += serialport
PTU5BASEPATH = /opt/devel/ptu5
ARCH = PTU5 ARCH = PTU5
# add qmqtt lib # add qmqtt lib
@ -45,7 +47,9 @@ contains( CONFIG, PTU5_YOCTO ) {
} }
TARGET = CashAgentLib TARGET = CashAgentLib
DESTDIR = ../plugins #DESTDIR = ../plugins
INTERFACE = DeviceController
INTERFACE_DEFINITION = $${PWD}/include/ATBAPP/DeviceControllerInterface.h
# The following define makes your compiler emit warnings if you use # The following define makes your compiler emit warnings if you use
@ -66,3 +70,21 @@ DEFINES += QT_DEPRECATED_WARNINGS
#else: unix:!android: target.path = /opt/$${TARGET}/bin #else: unix:!android: target.path = /opt/$${TARGET}/bin
#!isEmpty(target.path): INSTALLS += target #!isEmpty(target.path): INSTALLS += target
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
HEADERS +=

155
generate-version.sh Executable file
View File

@ -0,0 +1,155 @@
#!/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

@ -170,7 +170,7 @@ uint8_t epi_getResultOfLastRequest();
// retval: 0: in progress 1: OK 2: error // retval: 0: in progress 1: OK 2: error
void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t const *receivedData); void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t *receivedData);
// stored by Datif // stored by Datif
uint16_t epi_getLastPayLoad(uint16_t plBufSiz, uint8_t *payLoad); uint16_t epi_getLastPayLoad(uint16_t plBufSiz, uint8_t *payLoad);

View File

@ -303,6 +303,7 @@ class T_datif : public QMainWindow
// docNr =transmitted in WRITEADDRESS high byte // docNr =transmitted in WRITEADDRESS high byte
// blockNr=transmitted in WRITEADDRESS low byte // blockNr=transmitted in WRITEADDRESS low byte
int datif_noResponseCtr;
T_prot *myDCIF; T_prot *myDCIF;
QTimer *datif_trigger; QTimer *datif_trigger;
@ -315,9 +316,6 @@ private slots:
public: public:
T_datif(QWidget *parent = nullptr); T_datif(QWidget *parent = nullptr);
T_prot *getProt() { return myDCIF; }
T_prot const *getProt() const { return myDCIF; }
void resetChain(void); void resetChain(void);
char isPortOpen(void); char isPortOpen(void);
void sendWRcommand(uint16_t nxtAsCmd); void sendWRcommand(uint16_t nxtAsCmd);

202
include/datei.h Normal file
View File

@ -0,0 +1,202 @@
#ifndef DATEI_H
#define DATEI_H
#include <stdint.h>
#include <QFile>
#include <QFileInfo>
#include <QDebug>
#include "tslib.h"
#include <QString>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonParseError>
// create csv file with:
#define FILESEPERATOR ','
// pasre csv with:
#define FILESEP1 ','
#define FILESEP2 ';'
#define NEWLINEINFILE '\n'
#define MAXNUMBEROFSEQUENCES 200
// only for csv files
// all generated files located in sudirectory "dynamic machine data - dmd"
#define FILENAME_SHAREDDATA "../dmd/DCshare.csv"
#define FILENAME_SHARED_UID "../dmd/DC_UID.csv"
// -------------------------------------------------------------------------------------------------
// ------------------------------------------------------ create csv file -------------------------------
// -------------------------------------------------------------------------------------------------
// create array with strings and values (to be written to file)
void csv_startCreatingFile(void);
void csv_addTextToFile(QString myText);
void csv_addIntToFile(int myValue);
void csv_addUintToFile(uint myValue);
void csv_addLongvalToFile(qlonglong myValue);
void csv_addUlongvalToFile(qulonglong myValue);
//void csv_addCurrentTimeToFile(void);
//void csv_addCurrentDateToFile(void);
void csv_addNewlineToFile(void);
QByteArray csv_readbackArray(void);
// -------------------------------------------------------------------------------------------------
// ------------------------------------------------------ parse csv file -------------------------------
// -------------------------------------------------------------------------------------------------
// return number of entries in the just read file (entries are seperated by
// comma or line-feed)
uint32_t csv_nrOfEntriesInFile(QByteArray readFromFile);
// before: QByteArray sourceFile=datei_readFromFile(filename);
QByteArray csv_getOneFileSequence(QByteArray sourceFile, uint32_t sequNr);
// not needed, just for test // sequNr: 0....(size-1)
// get single entries of of the just read file:
int csv_getEntryAsInt(QByteArray sourceFile, uint32_t sequNr);
// sequNr: 0....(size-1)
int32_t csv_getEntryAsLong(QByteArray sourceFile, uint32_t sequNr);
// sequNr: 0....(size-1)
uint8_t csv_getEntryAsUshort(QByteArray sourceFile, uint32_t sequNr);
// sequNr: 0....(size-1)
uint16_t csv_getEntryAsUint(QByteArray sourceFile, uint32_t sequNr);
// sequNr: 0....(size-1)
uint32_t csv_getEntryAsUlong(QByteArray sourceFile, uint32_t sequNr);
// sequNr: 0....(size-1)
uint64_t csv_getEntryAs2Ulong(QByteArray sourceFile, uint32_t sequNr);
// sequNr: 0....(size-1)
QString csv_getEntryAsString(QByteArray sourceFile, uint32_t sequNr);
// sequNr: 0....(size-1)
// -------------------------------------------------------------------------------------------------
// ------------------------------------------------------ create Json Record -------------------------------
// -------------------------------------------------------------------------------------------------
void json_startRecord(void);
// clear buffer and write opening curly bracket {
void json_enterIntToRecord(QString attribute, ulong i_value);
// example: "parameter":1234567890
void json_enterTextToRecord(QString attribute, QString txt_value);
// example: "parameter":"slow"
//void json_addCurrentTimeToRecord(QString attribute);
// example: if attribute=myTime: "myTime":"hh_mm_ss"
//void json_addCurrentDateToRecord(QString attribute);
// example: if attribute=myDate: "myDate":"dd.mm.yyyy"
// also / possible as seperator
// further possible forms:
// 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
void json_enterArrayToRecord(QString attribute, uint8_t *buf, ulong nrofVals);
// add array of numbers with "nrofVals" elements
void json_enterStructToRecord(QString attribute);
// every call must be concluded with an extra "json_finishFile()"
// example: "sname":{
void json_finishStruct(void);
void json_finishRecord(void);
// close curly bracket
QString json_readbackRecordStr(void);
QByteArray json_readbackRecordBa(void);
// -------------------------------------------------------------------------------------------------
// ------------------------------------------------------ parse Json file -------------------------------
// -------------------------------------------------------------------------------------------------
// first: QByteArray datei_readFromFile(QString filename);
//void datei_json_readTestFile(QString filename);
int json_nrOfPairsInFile(QByteArray filename);
bool json_exists(QByteArray filename, QString searchForKey);
// look for "searchForKey" =name of the pair (left of : )
// retval true if exists
bool json_remove(QByteArray filename, QString searchFor);
// look for "searchFor" =name of the pair (left of : ) and remove the record from file
// retval true if removed
QString json_searchForStringInFile(QByteArray filename, QString searchFor);
// look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
int json_searchForIntInFile(QByteArray filename, QString searchFor);
// look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
//.......................
QJsonObject json_searchForObjectInFile(QByteArray filename, QString searchFor);
// return an object from the json file
int json_nrOfPairsInObject(QJsonObject objname);
QString json_searchForStringInObject(QJsonObject objname, QString searchFor);
// look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
int json_searchForIntInObject(QJsonObject objname, QString searchFor);
// look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
//.......................
QJsonArray json_searchForArrayInFile(QByteArray filename, QString searchFor);
// look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
int json_nrOfValuesInArray(QJsonArray arrayname);
bool json_getValuesOfArray(QJsonArray arrayname, int *buf, int MaxBufferSize);
// assuming that the array consists of integers
// -------------------------------------------------------------------------------------------------
// ------------------------------------------------------ read, write, copy files -------------------
// -------------------------------------------------------------------------------------------------
void datei_closeFile(QString filename);
// read content of an exiting file:
QByteArray datei_readFromFile(QString filename);
bool datei_ifFileExists(QString filename);
char datei_writeToFile(QString filename, QByteArray content);
// retval=0 if successful 1: no write access allowed
// 2:cannot open to append 3:cannot create new file
bool datei_copyFile(QString currentFileName, QString newFileName);
// retval=true if successful
bool datei_clearFile(QString filename);
// retval=true if successful
#endif // DATEI_H

View File

@ -17,71 +17,8 @@ matching interfaces.h:
//#define HWINF_iid "Atb.Psa2020.software.HWapi/3.1" //#define HWINF_iid "Atb.Psa2020.software.HWapi/3.1"
//#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.1" //#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.1"
#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.3" #define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.3"
PSA1259 hardware control using the DeviceController DC2
covering enclosure (switches and doors) and money devices,
controls mifare card to access or program
optional it can control printer, modem, bar code reader and credit card
* API to the PSA1259 Hardware
* All data come in from device controller via serial interface and will be stored
* in "PI" = peripheral image
* PI is updated every 100ms (up to 30ms possible)
* This api uses stored pi data and returns them in the following functions
* created: Q1/2020 TS
*
The devices, connected to device controller2 (DC2) can be controlled in different access levels.
Level 1:
direct connection to DC2, check versions, state and parameters
control serial interfaces
digital/analog IO's
read and write to connected devices on lowest level, this is a kind of fall-back-level
in case higher levels fail or do not support the needed (new) function
Example: send a specific printer command, several bytes that need to be conform to
printer manual. This command is routed to the printer through the DC2 without
any action of the DC. You can write your own device driver that way.
Level 1 is flexible but complicated
Level 2:
The DC controls the connected devices containing a device driver. The DC offers
usage of the device by simple commands,
Example: "Printer on", "set Font size 3" "print "hello world"", "cut"
In opposite to level 1 where you had to send a set of numbers and letters.
In other words: you "talk" to the device controller, not to the device itself.
Level 3:
start/stop complete processes.
Example: 1) print (predefined) document nr 3 with Text, letter size, font set, cut.
Also power up/down the printer, check if paper ok and so on.
*/ */
/*
Another access example: control the coin unit
Level 1): read digital inputs to detect coin,
switch digital output which opens coin slot
communicate with coin checker by certain mdb-commands (manual conform)
poll coin checker for inserted coins
close coin slot after 3seconds by setting DO to 0....
Level 2): get message of attached coin from DC
send command "initialize coin checker" to DC
send command "open slot for 3s"
poll DC for inserted coins, DC polls coin checker in right way, no need
to know the data sheet of the coin checker or mdb-bus
command to DC "open coin escrow's return flap for 1s"
Level 3): send command: "start payment process"
all coin devices are started up
coin blocker opens for 3s if a coin is attached
coin checker summarizes inserted value and reports sum
later send command "stop payment process" (puts coins to vault) or
send command "cancel payment process" (returns coins to user)
*/
#ifndef hwapi_H #ifndef hwapi_H
#define hwapi_H #define hwapi_H
@ -89,11 +26,13 @@ Level 3): send command: "start payment process"
#include <stdint.h> #include <stdint.h>
#include <QTabWidget> #include <QTabWidget>
#include <QtPlugin> #include <QtPlugin>
#include <QTimer>
#include <QObject> #include <QObject>
#include "interfaces.h" #include <../plugins/interfaces.h>
#include "datIf.h" #include "datIf.h"
class QSharedMemory;
class hwapi : public QObject, class hwapi : public QObject,
public hwinf public hwinf
{ {
@ -102,32 +41,16 @@ class hwapi : public QObject,
Q_INTERFACES(hwinf) Q_INTERFACES(hwinf)
private: private:
void sub_storeSendingText(QByteArray *buf) const; void sub_storeSendingText(QByteArray *buf) const;
QTimer *hwapi_TimerPayment;
DownloadResult sendNextAddress(int bNum) const;
DownloadResult sendNextDataBlock(QByteArray const &b, int bNum) const;
DownloadResult sendStatus(int ret) const;
DownloadResult dc_downloadBinary(QByteArray const &binary) const;
bool startBootloader() const;
bool stopBootloader() const;
bool openSerial(int br, QString baudrate, QString comPort) const;
bool closeSerial(QString comport) const;
bool resetDeviceController() const;
QByteArray loadBinaryDCFile(QString filename) const;
bool downloadBinaryToDC(QString const &bFile) const;
QSharedMemory *m_sharedMem;
public: public:
explicit hwapi(QWidget *parent = nullptr); explicit hwapi(QWidget *parent = nullptr);
virtual ~hwapi();
T_datif *myDatif; T_datif *myDatif;
virtual QStringList dc_getStatus() const;
// ------------------------------------------------------------------------------ // ------------------------------------------------------------------------------
// Level 0 commands, interface // commands, interface
// open, close, change serial interface // open, close, change serial interface
// actually not neccessary as it is opened automatically on program start // actually not neccessary as it is opened automatically on program start
// start automatic READ requests // start automatic READ requests
@ -139,7 +62,7 @@ public:
// ComName: for example "COM48" // ComName: for example "COM48"
// connect: 0, 1 // connect: 0, 1
bool dc_closeSerial(void) const override; void dc_closeSerial(void) const override;
bool dc_isPortOpen(void) const override ; bool dc_isPortOpen(void) const override ;
@ -147,21 +70,10 @@ public:
// select if READ-Requests are sent manually one by one or automatically // select if READ-Requests are sent manually one by one or automatically
// automatically request ALL digital and analog sensors, get time/date, get status information // automatically request ALL digital and analog sensors, get time/date, get status information
bool dc_updateDC(QString binFileName, QString baudrate,
QString comPort) const override;
bool dc_updatePrinterTemplate(enum FileTypeJson type,
QVector<int> templateIdx,
QVector<QString> fnames,
QString br,
QString serial = QString()) const override;
bool dc_printTemplate(enum FileTypeJson type,
QVector<int> templateIdx,
QString br,
QString serial = QString()) const override;
// ------------------------------------------------------------------------------ // ------------------------------------------------------------------------------
// Level 1, control device-controller (functions of µC) // control device-controller (functions of µC)
// check serial connection to deviceController // check serial connection to deviceController
// read response from DC2 (input data) // read response from DC2 (input data)
// some test function for serial communication // some test function for serial communication
@ -248,8 +160,15 @@ public:
uint8_t bl_exitBL(uint8_t *sendData) const override; uint8_t bl_exitBL(uint8_t *sendData) const override;
// minimum size of sendData-buffer: 5byte retval: length // minimum size of sendData-buffer: 5byte retval: length
// ------------------------------------------------------------------------------ // ------------------------------------------------------------------------------
// Level 2 DC2-onboard devices // DC2-onboard devices
// WR: set time // WR: set time
// RD. get time, get measure, get test results // RD. get time, get measure, get test results
// ------------------------------------------------------------------------------ // ------------------------------------------------------------------------------
@ -323,7 +242,7 @@ public:
bool dc_mainFuseIsOk(void) const override; bool dc_mainFuseIsOk(void) const override;
// ------------------------------------------------------------------------------ // ------------------------------------------------------------------------------
// Level 3: digital outputs and simple switching of connected devices // igital outputs and simple switching of connected devices
// simple processes like flashing a led or open flap for 1s // simple processes like flashing a led or open flap for 1s
// ------------------------------------------------------------------------------ // ------------------------------------------------------------------------------
@ -379,7 +298,7 @@ public:
// ------------------------------------------------------------------------------ // ------------------------------------------------------------------------------
// Level 3: digital inputs of connected devices // digital inputs of connected devices
// ------------------------------------------------------------------------------ // ------------------------------------------------------------------------------
bool door_isContactPowerOn(void) const override; bool door_isContactPowerOn(void) const override;
@ -741,29 +660,29 @@ public:
// up to 8 dynamic values can be defined in the template ("print val3 here") and will be sent with printing command // up to 8 dynamic values can be defined in the template ("print val3 here") and will be sent with printing command
// example: print current time at this point (the time of printing not the storage time!!) // example: print current time at this point (the time of printing not the storage time!!)
void pri_startTicketDesign(void) const override; //void pri_startTicketDesign(void) const override;
// start for every new printer document, reseting collecting buffer // start for every new printer document, reseting collecting buffer
// all further functions write/append text, numbers and command to the ticket-buffer, up to 1278 bytes allowed // all further functions write/append text, numbers and command to the ticket-buffer, up to 1278 bytes allowed
// return val of the appending functions: true=ok false=too long, buffer full // return val of the appending functions: true=ok false=too long, buffer full
int pri_TD_getCurrentSize(void) const override; //int pri_TD_getCurrentSize(void) const override;
// retval: 0...1278 // retval: 0...1278
bool pri_TD_addText(QByteArray text) const override; //bool pri_TD_addText(QByteArray text) const override;
// example: pri_TD_addText("Hello") const override; // example: pri_TD_addText("Hello") const override;
// example: pri_TD_addText(tempStr) const override; // example: pri_TD_addText(tempStr) const override;
// retval: true=ok false=too long, buffer full // retval: true=ok false=too long, buffer full
bool pri_TD_addValue(int val) const override; //bool pri_TD_addValue(int val) const override;
// +/- 0...2^(31) // +/- 0...2^(31)
bool pri_TD_addNewLine(void) const override; //bool pri_TD_addNewLine(void) const override;
bool pri_TD_addSign(char sign) const override; //bool pri_TD_addSign(char sign) const override;
// example: '.' ' ' 0x20 'W' '$' // example: '.' ' ' 0x20 'W' '$'
bool pri_TD_addCommand(char group, char attribute, char p1, char p2, char p3, char p4, char p5) const override; //bool pri_TD_addCommand(char group, char attribute, char p1, char p2, char p3, char p4, char p5) const override;
// always add 8 byte to the ticket layout: ESC & group & attribute & parameter1...5 // always add 8 byte to the ticket layout: ESC & group & attribute & parameter1...5
/* complete list of possible commands: /* complete list of possible commands:
group 50 : paper group 50 : paper
@ -804,11 +723,11 @@ public:
*/ */
char prn_clearDocument(uint8_t documentNumber) const override; //char prn_clearDocument(uint8_t documentNumber) const override;
// clear memory buffer for ONE document // clear memory buffer for ONE document
// function takes a second! don't send right before "store doc" // function takes a second! don't send right before "store doc"
bool prn_store_Document(uint8_t documentNumber ) const override; //bool prn_store_Document(uint8_t documentNumber ) const override;
// send the predefined Layout (generated with above TD functions) to DeviceController to save // send the predefined Layout (generated with above TD functions) to DeviceController to save
// documentNumber=0...15 // documentNumber=0...15
@ -820,7 +739,7 @@ public:
// the place in the ticket layout is predefined (already in DC memory) // the place in the ticket layout is predefined (already in DC memory)
// the dynamics are first calculated at printing time // the dynamics are first calculated at printing time
bool prn_printDocument(uint8_t documentNumber, struct T_dynDat *dynTicketData) const override; //bool prn_printDocument(uint8_t documentNumber, struct T_dynDat *dynTicketData) const override;
@ -924,7 +843,7 @@ public:
void bl_rebootDC(void) const override; void bl_rebootDC(void) const override;
void bl_startBL(void) const override; void bl_startBL(void) const override;
bool bl_checkBL(void) const override; void bl_checkBL(void) const override;
bool bl_isUp(void) const override; bool bl_isUp(void) const override;
// return true is bl is up and running // return true is bl is up and running
// also initializes "sendFile" // also initializes "sendFile"
@ -1001,6 +920,7 @@ public:
// return true if successful. could fail if more the 8 commands are waiting // return true if successful. could fail if more the 8 commands are waiting
bool rtc_getExtendedTime(uint8_t *leng, uint8_t *data) const override; bool rtc_getExtendedTime(uint8_t *leng, uint8_t *data) const override;
bool rtc_getExtendedTime(struct T_extTime *exTime) const override; bool rtc_getExtendedTime(struct T_extTime *exTime) const override;
bool sys_runCompleteTest(void) const override; bool sys_runCompleteTest(void) const override;
@ -1047,9 +967,23 @@ public:
bool prn_printTestTicket(void) const override; bool prn_printTestTicket(void) const override;
// return true if sending to DC OK, false if cmd-stack is full // return true if sending to DC OK, false if cmd-stack is full
bool cash_startPayment(uint32_t amount) const override; bool cash_startPayment(uint32_t amount) const override;
// 17.4.23TS: extended to 32bit // 17.4.23TS: extended to 32bit
uint8_t cash_paymentProcessing(void) const override;
// run this function periodically while coin payment process to generate necessary signals
// return value:
// 0: stopped 1: starting up 2: coin collection
// 3: finished by User (Push button) 4: finished, Max-Value collected
// 5: finished by escrow
// 10,11: error cannot start
// 12: timeout while payment, coins returned
// 13: stopped by unexpected error
bool cash_cancelPayment(void) const override; bool cash_cancelPayment(void) const override;
// and return coins // and return coins
@ -1083,11 +1017,22 @@ public:
uint64_t sys_getWakeSource(void) const override; uint64_t sys_getWakeSource(void) const override;
// retval: 6 bytes, bit coded, 1=event keeps DC awake // retval: 6 bytes, bit coded, 1=event keeps DC awake
uint8_t sys_getWakeReason(void) const override;
// Master was woken by following reason:
// 1: MDB Event
// 2: Coin Event
// ( 3: Master Event) - will not set the wake line
// ( 4: 32s pulse) - will not set the wake line
// 5: Door Event
// ( 6: Diag Event) - will not set the wake line
// 7: 30min-Pulse for HB
void sys_getDeviceConditions(uint8_t *leng, uint8_t *data) const override; void sys_getDeviceConditions(uint8_t *leng, uint8_t *data) const override;
void sys_getDeviceConditions(struct T_moduleCondition *devCond) const override; void sys_getDeviceConditions(struct T_moduleCondition *devCond) const override;
void sys_getDynMachineConditions(uint8_t *leng, uint8_t *data) const override; void sys_getDynMachineConditions(uint8_t *leng, uint8_t *data) const override;
void sys_getDynMachineConditions(struct T_dynamicCondition *dynMachCond) const override; void sys_getDynMachineConditions(struct T_dynamicCondition *dynMachCond) const override;
@ -1106,17 +1051,58 @@ public:
// bit5: printer not ready // bit5: printer not ready
void sys_sendDeviceParameter(struct T_devices *deviceSettings) const override;
void sys_restoreDeviceParameter(struct T_devices *deviceSettings) const override;
bool sys_areDCdataValid(void) const override;
bool sys_sendingTest(void) const override;
void prn_requestCurrentDynData(void) const override;
bool prn_getCurrentDynamicPrnValuesFromDC(uint8_t *dynPrnVal ) const override;
// which was sent with: bool prn_sendDynamicPrnValues(uint8_t *dynPrnVal ) const override;
bool prn_dynDataAreEqual(uint8_t *buf) const override;
bool prn_printKombiticket(uint8_t nrOfKombi) const override;
// print four of the templates loaded by Json prior
// nr = 1..8
void lock_triggerUpperSolenoid(void) const override;
void lock_triggerLowerSolenoid(void) const override;
signals: signals:
void hwapi_templatePrintFinished_OK(void) const override; void hwapi_templatePrintFinished_OK(void) const override;
void hwapi_templatePrintFinished_Err(void) const override; void hwapi_templatePrintFinished_Err(void) const override;
void hwapi_coinCollectionJustStarted(void) const override;
void hwapi_coinCollectionAborted(void) const override;
void hwapi_gotNewCoin(void) const override; void hwapi_gotNewCoin(void) const override;
void hwapi_vendStopByMax(void) const override; void hwapi_payStopByMax(void) const override;
void hwapi_vendStopByPushbutton(void) const override; void hwapi_payStopByPushbutton(void) const override;
void hwapi_payStopByEscrow(void) const override;
void hwapi_payStopByError(void) const override;
void hwapi_payStopByTimeout(void) const override;
void hwapi_payCancelled(void) const override;
void hwapi_coinProcessJustStopped(void) const override;
private slots: private slots:
void hwapi_slotPrintFinished_OK(void); void hwapi_slotPrintFinished_OK(void);
void hwapi_slotPrintFinished_Err(void); void hwapi_slotPrintFinished_Err(void);
void hwapi_slotGotCoin(void); void hwapi_slotGotCoin(void);
void hwapi_slotPayProc(void);
}; };

File diff suppressed because it is too large Load Diff

View File

@ -93,9 +93,6 @@ private slots:
void analyseRecData(void); void analyseRecData(void);
public: public:
T_com *getSerialPort() { return mySerialPort; }
T_com const *getSerialPort() const { return mySerialPort; }
T_prot(); T_prot();
bool isPortOpen(void); bool isPortOpen(void);
bool isSerialFree(void); bool isSerialFree(void);

View File

@ -211,8 +211,15 @@ uint8_t gpi_getUserOfSendingTextBuffer(uint8_t *para1, uint8_t *para2, uint8_t *
// user=1: Text-Print is using this buffer // user=1: Text-Print is using this buffer
// 2: QR-code-Printer is using this buffer // 2: QR-code-Printer is using this buffer
#define FDCMD_STACKDEPTH 16 #define FDCMD_STACKDEPTH 16
void sendFDcmd_clrStack(void); 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); 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 // 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); bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4);
@ -220,23 +227,35 @@ bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, ui
uint8_t check4FDshortCmd(void); uint8_t check4FDshortCmd(void);
// returns number of waiting command, maxFDCMD_STACKDEPTH // returns number of waiting command, maxFDCMD_STACKDEPTH
uint8_t checkNextFDcmd(void);
// return 0: no command waiting
// 1: short cmd
// 2: long cmd
uint8_t check4freeFDshortCmd(void); uint8_t check4freeFDshortCmd(void);
// returns number of free places in short-command stack // returns number of free places in short-command stack
#define FDLONG_STACKDEPTH 16 //#define FDLONG_STACKDEPTH 16
void longFDcmd_clrStack(void); //void longFDcmd_clrStack(void);
bool longFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t length, uint8_t *data); 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 // write Command to memory, wait for transport
// data buffer size always 64! data[64], padded with 0 // 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);
bool longFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *length, uint8_t *data); bool longFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *length, uint8_t *data);
uint8_t check4FDlongCmd(void); //uint8_t check4FDlongCmd(void);
// returns number of waiting command // returns number of waiting command
uint8_t check4freeFDlongCmd(void); //uint8_t check4freeFDlongCmd(void);
// returns number of free places in long-command stack // 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 #endif

View File

@ -7,6 +7,12 @@
#include <QSharedMemory> #include <QSharedMemory>
struct SharedMemBuffer { struct SharedMemBuffer {
struct rs { struct rs {
char comportName[16]; // z.B. "COM48" char comportName[16]; // z.B. "COM48"
char baudStr[16]; // z.B. "19200" char baudStr[16]; // z.B. "19200"
@ -198,6 +204,7 @@ struct SharedMemBuffer {
uint8_t mif_cardType; uint8_t mif_cardType;
uint8_t mif_cardHolder[8]; uint8_t mif_cardHolder[8];
#if 0
#define MEMDEPTH_GOTCOINS (16) #define MEMDEPTH_GOTCOINS (16)
struct T_coin { struct T_coin {
uint8_t valid; uint8_t valid;
@ -207,6 +214,7 @@ struct SharedMemBuffer {
uint16_t value; uint16_t value;
} gotCoin[MEMDEPTH_GOTCOINS]; } gotCoin[MEMDEPTH_GOTCOINS];
uint8_t ctr_gotCoin; uint8_t ctr_gotCoin;
#endif
struct store { struct store {
uint32_t insertedAmount; uint32_t insertedAmount;

View File

@ -8,7 +8,7 @@
#define MAXNROF_AO 3 #define MAXNROF_AO 3
//#define MAXNROF_GENSTR 16 #define MAXNROF_GENSTR 16
#define MAXNROF_CONTR_PORTS 11 #define MAXNROF_CONTR_PORTS 11
#define MAXNROF_DIports 2 #define MAXNROF_DIports 2
#define MAXNROF_DOports 2 #define MAXNROF_DOports 2
@ -32,6 +32,9 @@ bool indat_isMifareOn();
void indat_storeMDBisOn(bool isOn); void indat_storeMDBisOn(bool isOn);
bool indat_isMdbOn(); bool indat_isMdbOn();
void gpi_storeSlaveSerParams(uint8_t slaveBaudRate, uint8_t NrDataBits, void gpi_storeSlaveSerParams(uint8_t slaveBaudRate, uint8_t NrDataBits,
uint8_t parity, uint8_t NrStopBits); uint8_t parity, uint8_t NrStopBits);
@ -40,16 +43,29 @@ void epi_getSlaveSerParams(uint8_t *slaveBaudRate, uint8_t *NrDataBits,
QString epi_getSlaveParamSTR(); QString epi_getSlaveParamSTR();
void gpi_storeGenerals(uint8_t genNr, QString text); void gpi_storeGenerals(uint8_t genNr, QString text);
// 0=HW 1=SW 2=State // 0=HW 1=SW 2=State
QString epi_loadGenerals(uint8_t genNr); QString epi_loadGenerals(uint8_t genNr);
// genNr=0=HW 1=SW 2=State // genNr=0=HW 1=SW 2=State
void gpi_storeUID(uint8_t const *buf8byteUid); void gpi_storeUID(uint8_t const *buf8byteUid);
//void gpi_storeUID(uint8_t *buf8byteUid);
// buffer size: 8 byte // buffer size: 8 byte
void epi_getUIDdec(uint8_t *buf8byteUid); void epi_getUIDdec(uint8_t *buf8byteUid);
// buffer size: 8 byte // buffer size: 8 byte
QString epi_getUIDstr(); QString epi_getUIDstr();
@ -79,7 +95,7 @@ void epi_getSpecialYearTimeDate(uint16_t *DayOfYear, uint16_t *HoursOfYear, uint
// /////////////////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////////
// #define MAXNROF_AI 4 #define MAXNROF_AI 4
void gpi_storeAIs(uint8_t aiNr, uint16_t val); // rs -> Sdata void gpi_storeAIs(uint8_t aiNr, uint16_t val); // rs -> Sdata
@ -128,119 +144,185 @@ void gpi_storeDI_optos(uint8_t indatOpto);
uint8_t epi_getDI_optos(void); uint8_t epi_getDI_optos(void);
// bit0: opto in 1 1: opto in 2 // bit0: opto in 1 1: opto in 2
uint8_t gpi_storeDI_auxIn(uint8_t indatAuxIn); // Aux0...5 void gpi_storeDI_auxIn(uint8_t indatAuxIn);
uint8_t epi_getDI_auxIn(void); // bit0: auxin 1 ... 5: auxin 6 // Aux0...5
uint8_t epi_getDI_auxIn(void);
// bit0: auxin 1 ... 5: auxin 6
void gpi_storeDI_ptuWake(uint8_t indat);
bool gpi_storeDI_ptuWake(bool w);
bool epi_getDI_ptuWake(void); bool epi_getDI_ptuWake(void);
bool gpi_storeDI_mbdWake(bool w); void gpi_storeDI_mbdWake(uint8_t indat);
bool epi_getDI_mdbWake(void); bool epi_getDI_mdbWake(void);
bool gpi_storeDI_prnReady(bool ready); void gpi_storeDI_prnReady(uint8_t indat);
bool epi_getDI_prnReady(void); bool epi_getDI_prnReady(void);
bool gpi_storeDI_CoinAttach(bool attach); void gpi_storeDI_CoinAttach(uint8_t indat);
bool epi_getDI_CoinAttach(void); bool epi_getDI_CoinAttach(void);
bool gpi_storeDI_CoinEscrow(bool ce); void gpi_storeDI_CoinEscrow(uint8_t indat);
bool epi_getDI_CoinEscrow(void); bool epi_getDI_CoinEscrow(void);
bool gpi_storeDI_mifareCardTapped(bool tapped); void gpi_storeDI_mifareCardTapped(uint8_t indat);
bool epi_getDI_mifareCardTapped(void); bool epi_getDI_mifareCardTapped(void);
bool gpi_storeDI_modemWake(bool w); void gpi_storeDI_modemWake(uint8_t indat);
bool epi_getDI_modemWake(void); bool epi_getDI_modemWake(void);
bool gpi_storeDI_contactPowerIsOn(bool on);
void gpi_storeDI_contactPowerIsOn(bool di_contact_PwrOn);
bool epi_getDI_contactPwr(void); bool epi_getDI_contactPwr(void);
bool gpi_storeDI_MifarePowerIsOn(bool on); void gpi_storeDI_MifarePowerIsOn(bool di_mifare_PwrOn);
bool epi_getDI_mifarePwr(void); bool epi_getDI_mifarePwr(void);
bool gpi_storeDI_readbackMdbTxD(bool rdbkMdbTxd); void gpi_storeDI_readbackMdbTxD(bool di_rdbkMdbTxd);
bool epi_getDI_mdbTxd(void); bool epi_getDI_mdbTxd(void);
bool gpi_storeDI_AuxPowerIsOn(bool on); void gpi_storeDI_AuxPowerIsOn(bool di_Aux_PwrOn);
bool epi_getDI_auxPwr(void); bool epi_getDI_auxPwr(void);
bool gpi_storeDI_GsmPowerIsOn(bool on); void gpi_storeDI_GsmPowerIsOn(bool di_gsm_PwrOn);
bool epi_getDI_gsmPwr(void); bool epi_getDI_gsmPwr(void);
bool gpi_storeDI_CreditPowerIsOn(bool on); void gpi_storeDI_CreditPowerIsOn(bool di_credit_PwrOn);
bool epi_getDI_creditPwr(void); bool epi_getDI_creditPwr(void);
bool gpi_storeDI_PrinterPowerIsOn(bool on); void gpi_storeDI_PrinterPowerIsOn(bool di_printer_PwrOn);
bool epi_getDI_printerPwr(void); bool epi_getDI_printerPwr(void);
bool gpi_storeDI_MdbPowerIsOn(bool on); void gpi_storeDI_MdbPowerIsOn(bool di_mdb_PwrOn);
bool epi_getDI_mdbPwr(void); bool epi_getDI_mdbPwr(void);
bool gpi_storeDI_rejMot_home(bool reject);
void gpi_storeDI_rejMot_home(bool di);
bool epi_getDI_rejectMotor_homepos(void); bool epi_getDI_rejectMotor_homepos(void);
uint8_t gpi_storeDI_paperLow(uint8_t di); void gpi_storeDI_paperLow(uint8_t di);
uint8_t epi_getDI_npe_sensor(void); uint8_t epi_getDI_npe_sensor(void);
// 0: Sensor sees paper 1: no paper 99: off // 0: Sensor sees paper 1: no paper 99: off
// /////////////////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////////
// readback digital outputs // readback digital outputs
// /////////////////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////////
uint8_t gpi_storeDO_mdbRxTst(uint8_t do_mbdRxTst); void gpi_storeDO_mdbRxTst(uint8_t do_mbdRxTst);
bool epi_getDO_mdbRxTestOut(void); bool epi_getDO_mdbRxTestOut(void);
uint8_t gpi_storeDO_motorOutputs(uint8_t Pwr);
void gpi_storeDO_motorOutputs(uint8_t Pwr);
uint8_t epi_getDO_motorOuts(void); uint8_t epi_getDO_motorOuts(void);
// bit0: upper lock forward bit 1 backward // bit0: upper lock forward bit 1 backward
// bit2: lower lock forward bit 3 backward // bit2: lower lock forward bit 3 backward
uint8_t gpi_storeDO_serialSwitch(uint8_t state);
void gpi_storeDO_serialSwitch(uint8_t state);
// serial drv on/off, Serial mux1, Serial mux2 // serial drv on/off, Serial mux1, Serial mux2
uint8_t epi_getDO_serialSwitch(void); uint8_t epi_getDO_serialSwitch(void);
// serial drv on/off, Serial mux1, Serial mux2 // serial drv on/off, Serial mux1, Serial mux2
bool epi_getDO_serialDriverIsOn(void); bool epi_getDO_serialDriverIsOn(void);
bool epi_getDO_serialMux1isSetToPrinter(void); bool epi_getDO_serialMux1isSetToPrinter(void);
// mux1 off: serial is switched to printer // mux1 off: serial is switched to printer
bool epi_getDO_serialMux1isSetToModem(void); bool epi_getDO_serialMux1isSetToModem(void);
// mux1 on: serial is switched to modem // mux1 on: serial is switched to modem
bool epi_getDO_serialMux2isSetToCredit(void); bool epi_getDO_serialMux2isSetToCredit(void);
// mux2 off: serial is switched to credit card terminal // mux2 off: serial is switched to credit card terminal
bool epi_getDO_serialMux2isSetToMifare(void); bool epi_getDO_serialMux2isSetToMifare(void);
// mux2 on: serial is switched to mifare reader // mux2 on: serial is switched to mifare reader
uint8_t gpi_storeDO_ledsAndFan(uint8_t ledState);
void gpi_storeDO_ledsAndFan(uint8_t ledState);
bool epi_getDO_led_coin(void); bool epi_getDO_led_coin(void);
bool epi_getDO_led_front(void); bool epi_getDO_led_front(void);
bool epi_getDO_led_ticket(void); bool epi_getDO_led_ticket(void);
bool epi_getDO_led_pin(void); bool epi_getDO_led_pin(void);
bool epi_getDO_led_start(void); bool epi_getDO_led_start(void);
bool epi_getDO_led_inside(void); bool epi_getDO_led_inside(void);
bool epi_getDO_fan(void); bool epi_getDO_fan(void);
uint8_t gpi_storeDO_sirenAndRelay(uint8_t sirenRelay); void gpi_storeDO_sirenAndRelay(uint8_t sirenRelay);
bool epi_getDO_sirene(void); bool epi_getDO_sirene(void);
bool epi_getDO_relay(void); bool epi_getDO_relay(void);
uint8_t gpi_storeDO_ptuWake(uint8_t state); void gpi_storeDO_ptuWake(uint8_t state);
bool epi_getDO_ptuWake(void); bool epi_getDO_ptuWake(void);
uint8_t gpi_storeDO_auxPower(uint8_t pwr); void gpi_storeDO_auxPower(uint8_t pwr);
bool epi_getDO_auxPower(void); bool epi_getDO_auxPower(void);
uint8_t gpi_storeDO_coinShutter(uint8_t state);
void gpi_storeDO_coinShutter(uint8_t state);
bool epi_getDO_coinShutterOpen(void); bool epi_getDO_coinShutterOpen(void);
bool epi_getDO_coinShutterTest(void); bool epi_getDO_coinShutterTest(void);
uint8_t gpi_storeDO_coinEscrow(uint8_t state);
void gpi_storeDO_coinEscrow(uint8_t state);
uint8_t epi_getDO_coinEscrow(void); uint8_t epi_getDO_coinEscrow(void);
// retval: 1:return flap is open 2:take flap is open 0:closed // retval: 1:return flap is open 2:take flap is open 0:closed
uint8_t gpi_storeDO_printerPwrOn(uint8_t state);
void gpi_storeDO_printerPwrOn(uint8_t state);
uint8_t epi_getDO_printerPwr(void); uint8_t epi_getDO_printerPwr(void);
// --------------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------------
// counterchecks, make sure that DC-outputs are correct // counterchecks, make sure that DC-outputs are correct
@ -287,14 +369,21 @@ bool epi_cntchk_Mot2Fon(void);
uint8_t gpi_storeMdbRecData(uint8_t length, uint8_t *buf); uint8_t gpi_storeMdbRecData(uint8_t length, uint8_t *buf);
// datif store received mdb data // datif store received mdb data
uint8_t epi_getMdbResponse(void); uint8_t epi_getMdbResponse(void);
// 0=no response 1=ACK 2=NAK 3=ACK with data // 0=no response 1=ACK 2=NAK 3=ACK with data
uint8_t epi_getMdbRecLength(void); uint8_t epi_getMdbRecLength(void);
// 0...31 // 0...31
uint8_t epi_restoreMdbRecData(uint8_t *buf); uint8_t epi_restoreMdbRecData(uint8_t *buf);
// hwapi reads received mdb data from PI // hwapi reads received mdb data from PI
uint8_t gpi_storeMifReaderStateAndCardType(uint8_t const *buf);
uint8_t gpi_storeMifReaderStateAndCardType(uint8_t *buf);
/* data description: /* data description:
byte 0: current read state: 0=power off 1=reader-fault 2=ready byte 0: current read state: 0=power off 1=reader-fault 2=ready
@ -318,24 +407,41 @@ byte 32: result, always 0
uint8_t epi_restoreMifState(uint8_t *buf, uint8_t maxBufferSize); uint8_t epi_restoreMifState(uint8_t *buf, uint8_t maxBufferSize);
// retval 0=OK 1=error host buffer too small // retval 0=OK 1=error host buffer too small
bool gpi_storeMifCardData(uint8_t blkNr, uint8_t const *receivedData);
void gpi_storeMifCardData(uint8_t blkNr, uint8_t *receivedData);
// blkNr=0...11 receivedData[64] // blkNr=0...11 receivedData[64]
uint8_t epi_restoreMifData(uint8_t blkNr, uint8_t *buf, uint8_t maxBufferSize); uint8_t epi_restoreMifData(uint8_t blkNr, uint8_t *buf, uint8_t maxBufferSize);
// blkNr=0...11 return buf[64] // blkNr=0...11 return buf[64]
// retval: 1=error 0=OK // retval: 1=error 0=OK
#define pi_prnStateArraySize 20
#define pi_prnFontArraySize 20
void epi_restorePrinterState(uint8_t *buf); void epi_restorePrinterState(uint8_t *buf);
void gpi_storePrinterState(uint8_t const *buf);
void gpi_storePrinterState(uint8_t *buf);
void epi_restorePrinterFonts(uint8_t *buf); void epi_restorePrinterFonts(uint8_t *buf);
void gpi_storePrinterFonts(uint8_t const *buf);
bool gpi_storeMdbState(bool busReady, bool V12on, bool V5on); void gpi_storePrinterFonts(uint8_t *buf);
void gpi_storeMdbState(uint8_t busReady, uint8_t V12on, uint8_t V5on );
bool epi_restoreMdbBusReady(void); bool epi_restoreMdbBusReady(void);
bool epi_restoreMdbV12Ready(void); bool epi_restoreMdbV12Ready(void);
bool epi_restoreMdbV5Ready(void); bool epi_restoreMdbV5Ready(void);
void gpi_storeMdbResponse(uint8_t leng, uint8_t const *data);
void gpi_storeMdbResponse(uint8_t leng, uint8_t *data);
void epi_restoreMdbResponse(uint8_t *leng, uint8_t *data); void epi_restoreMdbResponse(uint8_t *leng, uint8_t *data);
// last received mdb answer (from mdb device) // last received mdb answer (from mdb device)
// only needed if a special command was sent directly // only needed if a special command was sent directly
@ -344,9 +450,12 @@ void epi_restoreMdbResponse(uint8_t *leng, uint8_t *data);
// DB2: nr of received (payload) data bytes (apart from ACK, can be 0....34) // DB2: nr of received (payload) data bytes (apart from ACK, can be 0....34)
// DB3...DB38: rec.data (payload) // DB3...DB38: rec.data (payload)
void gpi_storeEmpSettings(uint8_t leng, uint8_t const *data);
void gpi_storeEmpSettings(uint8_t leng, uint8_t *data);
void epi_restoreEmpSettings(uint8_t *leng, uint8_t *data); void epi_restoreEmpSettings(uint8_t *leng, uint8_t *data);
/* /*
void gpi_storeEmpCoinSignal(uint8_t leng, uint8_t *data); void gpi_storeEmpCoinSignal(uint8_t leng, uint8_t *data);
@ -360,61 +469,108 @@ void epi_restoreEmpCoinSignal(uint8_t *leng, uint8_t *data);
void epi_clearEmpCoinSignal(); void epi_clearEmpCoinSignal();
*/ */
#define MEMDEPTH_GOTCOINS 16
void gpi_storeEmpCoinSignal(uint8_t leng, uint8_t const *data); void gpi_storeEmpCoinSignal(uint8_t leng, uint8_t *data);
uint8_t epi_isNewCoinLeft(void); uint8_t epi_isNewCoinLeft(void);
// retval: 0...16 coins left in FIFO // retval: 0...16 coins left in FIFO
void epi_restoreEmpCoinSignal(uint8_t *valid, uint8_t *signal, uint8_t *error, uint16_t *value); 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 gpi_storeRbDeviceSettings(uint8_t leng, uint8_t *data);
void epi_restoreRbDeviceSettings(uint8_t *leng, uint8_t *data); void epi_restoreRbDeviceSettings(uint8_t *leng, uint8_t *data);
void gpi_storeMachineIDsettings(uint8_t leng, uint8_t const *data);
void gpi_storeMachineIDsettings(uint8_t leng, uint8_t *data);
void epi_restoreMachineIDsettings(uint8_t *leng, uint8_t *data); void epi_restoreMachineIDsettings(uint8_t *leng, uint8_t *data);
void epi_clearCurrentPayment(void); void epi_clearCurrentPayment(void);
void gpi_storeCurrentPayment(uint32_t insertedAmount, uint16_t lastCoinType, uint16_t lastCoinValue); void gpi_storeCurrentPayment(uint32_t insertedAmount, uint16_t lastCoinType, uint16_t lastCoinValue);
uint32_t epi_CurrentPaymentGetAmount(void); uint32_t epi_CurrentPaymentGetAmount(void);
uint16_t epi_CurrentPaymentGetLastCoin(void); uint16_t epi_CurrentPaymentGetLastCoin(void);
bool epi_CurrentPaymentGetAllCoins(uint16_t *types, uint16_t *values); bool epi_CurrentPaymentGetAllCoins(uint16_t *types, uint16_t *values);
// alle bei diesem Verkauf eingeworfenen Münzen sind gespeichert falls die jmd. braucht // alle bei diesem Verkauf eingeworfenen Münzen sind gespeichert falls die jmd. braucht
void gpi_storeWakeSources(uint8_t const *receivedData);
void gpi_storeWakeSources(uint8_t *receivedData);
uint64_t epi_getWakeSources(void); uint64_t epi_getWakeSources(void);
void gpi_storeExtendedTime(uint8_t leng, uint8_t const *data); uint8_t epi_getWakeReason(void);
void gpi_storeExtendedTime(uint8_t leng, uint8_t *data);
void epi_restoreExtendedTime(uint8_t *leng, uint8_t *data); void epi_restoreExtendedTime(uint8_t *leng, uint8_t *data);
void gpi_storeDeviceConditions(uint8_t leng, uint8_t const *data);
void gpi_storeDeviceConditions(uint8_t leng, uint8_t *data);
void epi_restoreDeviceConditions(uint8_t *leng, uint8_t *data); void epi_restoreDeviceConditions(uint8_t *leng, uint8_t *data);
void gpi_storeDynMachineConditions(uint8_t leng, uint8_t const *data);
void gpi_storeDynMachineConditions(uint8_t leng, uint8_t *data);
void epi_restoreDynMachineConditions(uint8_t *leng, uint8_t *data); void epi_restoreDynMachineConditions(uint8_t *leng, uint8_t *data);
void gpi_storeDCbackupAccNr(uint8_t leng, uint8_t const *data);
void gpi_storeDCbackupAccNr(uint8_t leng, uint8_t *data);
void epi_restoreDCbackupAccNr(uint8_t *leng, uint16_t *accNrs); void epi_restoreDCbackupAccNr(uint8_t *leng, uint16_t *accNrs);
// return accNrs[0..7] // return accNrs[0..7]
void epi_iniVRstorage(void); void epi_iniVRstorage(void);
void gpi_storeVaultRecord(uint8_t blkNr, uint8_t const *data);
void gpi_storeVaultRecord(uint8_t blkNr, uint8_t *data );
bool epi_checkIfVaultRecordAvailable(void); bool epi_checkIfVaultRecordAvailable(void);
bool epi_restoreVaultRecord(uint16_t *length, uint8_t *buf ); bool epi_restoreVaultRecord(uint16_t *length, uint8_t *buf );
// true if completly received // true if completly received
void gpi_storeCBlevel(uint32_t amount, uint16_t nrOfCoins ); void gpi_storeCBlevel(uint32_t amount, uint16_t nrOfCoins );
uint32_t epi_getCashBoxContent(void); uint32_t epi_getCashBoxContent(void);
uint16_t epi_getNrOfCoinsInCashBox(void); uint16_t epi_getNrOfCoinsInCashBox(void);
void gpi_storeNewMifareCard(uint8_t typ, uint8_t const *holder); void gpi_storeNewMifareCard(uint8_t typ, uint8_t *holder );
uint8_t epi_mifGetCardType(uint8_t const *holder); uint8_t epi_mifGetCardType(uint8_t *holder);
//holder[8] = name of card holder //holder[8] = name of card holder
// retval Type of MifareCard, 1=upper door, 2=lower door 3=test printer 4=test coins // retval Type of MifareCard, 1=upper door, 2=lower door 3=test printer 4=test coins
void gpi_storeDcDataValid(bool isVal);
bool epi_areDcDataValid();
void epi_clearDynData(void);
void gpi_storeDynData(uint8_t *DCdynDat);
// buffer size: 64 byte
bool epi_getDynPrnData(uint8_t *DCdynDat);
// buffer size: 64 byte
// return true if data are new and valid
#endif #endif

View File

@ -24,13 +24,21 @@ struct T_emp
// dynamic: // dynamic:
uint8_t state; // step counter of EMP (electronic coin checker) FSM (finite state machine): uint8_t state; // step counter of EMP (electronic coin checker) FSM (finite state machine):
// 0=Emp & Bus power off, 1=powered, poll off 2=polling on // 0=start command
// 3=device responded, requesting status // 1=powered, do emp ini, send reset
// 4=waiting for status 5=have status, // 2=delay
// 6: IDLE, have paramters from master, polling running, ready for payment // 3=wait for response, requesting status after response
// Master can stop/start polling and acceptance // 4,5 through, startup
// 7: end of transaction, polling on, accept off, reporting coins, (wait for last coin) // 6: wait for status
// 8: transaction running, polling on, acceptance on, reporting coins, // 7: through, startup
// 8: IDLE state. EMP is up and ready, polling is running
// 9: polling on, payment not yet on
// 10: payment, check coins
// 11: through
// 12: wait 1s for last coin
// 90: stop all, 1s delay
// 99: off, all stopped
uint8_t pollingRunning; uint8_t pollingRunning;
uint8_t paymentRunning; uint8_t paymentRunning;
@ -80,6 +88,7 @@ struct Tprn_hw_state
bool nowAligned; bool nowAligned;
}; };
// obsolete
struct T_dynDat struct T_dynDat
{ {
uint8_t licensePlate[8]; uint8_t licensePlate[8];
@ -122,17 +131,17 @@ struct T_vaultRecord
//16 //16
char label3buffer[4]; // mw > char label3buffer[4]; // mw >
// Verkauf, Tür zu: // Verkauf, Tür zu:
uint32_t VKcoinsInserted[16]; // nur für Wechsler, soviel wurde eingeworfen uint32_t VKcoinsInserted[16]; // nur für Wechsler, soviel wurde eingeworfen
uint32_t VKcoinsReturned[6]; // nur für Wechsler, Anzahl Münzen pro Typ, soviel wurde zurückgegeben uint32_t VKcoinsReturned[6]; // nur für Wechsler, Anzahl Münzen pro Typ, soviel wurde zurückgegeben
//88 //88
// Service, Tür offen: // Service, Tür offen:
uint16_t ServCoinsInserted[16]; // nur für Wechsler, soviel wurde eingeworfen uint16_t ServCoinsInserted[16]; // nur für Wechsler, soviel wurde eingeworfen
uint16_t ServCoinsReturned[6]; // nur für Wechsler, Anzahl Münzen pro Typ, soviel wurde zurückgegeben uint16_t ServCoinsReturned[6]; // nur für Wechsler, Anzahl Münzen pro Typ, soviel wurde zurückgegeben
uint16_t resint3; uint16_t resint3;
uint16_t resint4; uint16_t resint4;
uint16_t currentTubeContent[6]; // nur für Wechsler, aktueller Füllstand uint16_t currentTubeContent[6]; // nur für Wechsler, aktueller Füllstand
uint16_t resint5; uint16_t resint5;
uint16_t resint6; uint16_t resint6;
// 56 // 56
@ -167,30 +176,29 @@ struct T_moduleCondition
// 100..150 = WARNING // 100..150 = WARNING
// 200..250 = ERROR // 200..250 = ERROR
uint8_t structStart; // always first!!! uint8_t ram;
uint8_t ram; // v uint8_t intEe;
uint8_t intEe; // v uint8_t extEe;
uint8_t extEe; // v
uint8_t rtc; // 1: time/date OK 100: time not plausible 200: hardware error uint8_t rtc; // 1: time/date OK 100: time not plausible 200: hardware error
uint8_t boardHw; // v uint8_t boardHw;
uint8_t printer; // v uint8_t printer;
uint8_t modem; // v uint8_t modem;
uint8_t signal; // 1...99 uint8_t signal; // 1...99
uint8_t regist; // 100:not 1:reg 2:ping OK 3:gotTime uint8_t regist; // 100:not 1:reg 2:ping OK 3:gotTime
uint8_t mdbBus; uint8_t mdbBus;
uint8_t coinChecker; // EMP, OMP or mei-cashflow uint8_t coinChecker; // EMP, OMP or mei-cashflow
uint8_t coinEscrow; // v uint8_t coinEscrow;
uint8_t mifareReader; // v uint8_t mifareReader;
uint8_t creditTerm; // not available uint8_t creditTerm;
uint8_t coinReject; // v uint8_t coinReject;
uint8_t coinSafe; // v uint8_t coinSafe;
uint8_t billSafe; // v uint8_t billSafe;
uint8_t voltage; // v // 1:11..14V uint8_t voltage; // 1:11..14V
uint8_t temper; // v uint8_t temper;
uint8_t poweronTest; uint8_t poweronTest;
uint8_t doorState; // 1: alles zu 200: t?r offen + bit1(S) +bit2(CB) + bit3(CB) uint8_t doorState; // 1: alles zu 200: t?r offen + bit1(S) +bit2(CB) + bit3(CB)
@ -211,62 +219,132 @@ struct T_moduleCondition
struct T_dynamicCondition struct T_dynamicCondition
{ {
// dynamic conditions, change rapidly and frequently char allDoorsDebounced;
// these are values for the Heartbeat char openedAuthorized;
uint8_t CBinDebounced; // 0:fehlt 1:drin
// T?rschalter entprellt: char upperDoor; // 99: undefined 0:closed 1:open
char upperDoor; // 0:fehlt 1:drin char middleDoor; // 99: undefined 0:closed 1:open
char middleDoor; char lowerDoor; // 99: undefined 0:closed 1:open
char lowerDoor; char reserve;
char coinBox;
char billBox; char billBox;
char modeAbrech; char modeAbrech;
char onAlarm; char onAlarm; // 0:alarm aus 1:alarm 2:alarm mit Sirene 3: Sirenentest
char nowCardTest; char nowCardTest;
char nowPayment; // not used, always 0
char nowPayment;
char lastMifCardType; char lastMifCardType;
char openedAuthorized;
char allDoorsDebounced;
uint8_t lastSDoorState; uint8_t lastSDoorState;
uint8_t lastVDoorState; uint8_t lastVDoorState;
uint8_t CBinDebounced;
uint8_t lastCBstate; uint8_t lastCBstate;
char paymentInProgress; char paymentInProgress;
char res1; // 0: stopped by timeout
char res2; // 1: running 2: wait4lastCoin
char res3; // 3: payment stopped manually, coins in Escrow
// 4: payment stopped autom, amount collected, coins in Escrow
// 5: payment stopped, escrow full, coins in Escrow
// 6: coins encashed 7:coins returned
// 8: CoinChecker or MDB on Error
char res1;
uint16_t U_Batt; uint16_t U_Batt;
uint16_t Temperatur; uint16_t Temperatur;
uint16_t cash_storedaccNumbers[8]; // List all stored accounting numbers in ext. eeprom
uint16_t nrCoinsInBox; uint16_t nrCoinsInBox;
uint16_t resui1;
uint32_t amountInBox; uint32_t amountInBox;
uint32_t amountJustPaid;
uint16_t lastInsCoinType; // wahrscheinlich uchar
uint16_t resui2;
uint32_t totalTransVolume; uint32_t totalTransVolume;
uint32_t totalNrOfVends; uint32_t totalNrOfVends;
char jsonValid_config;
char jsonValid_device;
char jsonValid_cash;
char jsonValid_print;
char jsonValid_serial;
char jsonValid_time;
char lastFileType;
// 44
uint8_t MifCardHolder[8];
uint8_t resultOfLastTemplPrint;
// 0: unknown or printing in progress
// 1: OK, doc was printed 2: error, doc was not printed
uint8_t lastPrinterStatus;
// 0: printer OK
// bit0: near paper end bit1: no paper
// bit2: temperature error bit3: error head open
// bit4: paper jam in cutter
// bit6: no response bit7: serial rec. error
// bit5: printer not ready
uint8_t startupTestIsRunning;
//54
};
struct T_extTime
{
uint8_t Hours;
uint8_t Min;
uint8_t Sec;
uint8_t Year;
uint8_t Month;
uint8_t Day;
uint8_t DOW;
uint8_t res1;
uint16_t MinOfDay;
uint16_t res2;
uint32_t SecOfDay;
uint8_t isLeapYear;
uint8_t nxtLeapYear;
uint8_t lastLeapYear;
uint8_t hoursOfThisWeek;
uint16_t minutesOfThisWeek;
uint16_t hoursOfThisMonth;
uint16_t daysOfThisYear;
uint16_t GetHoursOfYear;
uint16_t res3;
uint32_t GetMinutesOfYear;
uint8_t getWakeIntvSec;
uint8_t res4;
uint16_t res5;
uint32_t MinutesOfMillenium;
}; };
typedef uint8_t UCHAR;
typedef uint16_t UINT;
struct T_devices
{
// set by master, used(1) or notused (0) or type 2....20
UCHAR kindOfPrinter; // 0:off 1:Gebe
UCHAR kindOfCoinChecker; // 0: without 1=EMP820 2=EMP900 3=currenza c² (MW)
UCHAR kindOfMifareReader; // by now only stronglink SL025 =1
UCHAR suppressSleepMode; // 0:sleep allowed 1: no sleep
UCHAR kindOfModem; // 0:off 1:Sunlink
UCHAR kindOfCreditcard; // 0:off 1:Feig NFC
UCHAR CoinEscrow;
UCHAR CoinRejectUnit;
UCHAR CoinShutter;
UCHAR BillAcceptor;
UCHAR usevaultLock;
UCHAR autoAlarm; // 1: switch on siren for 1min in doors opened unauthorized
UCHAR autoOpen; // 1: open door covers after valid ATBcard
UCHAR printAccReceipt; // 0/1
UCHAR printDoorReceipt;
UCHAR printTokenTicket;
UINT VaultFullWarnLevel;
UINT VaultFullErrorLevel;
};
class hwinf class hwinf
{ {
public: public:
enum class DownloadResult {OK, ERROR, TIMEOUT, NOP};
enum class FileTypeJson {CONFIG=1, DEVICE, CASH, SERIAL, TIME, PRINTER};
virtual ~hwinf() {} virtual ~hwinf() {}
@ -286,7 +364,7 @@ public:
// ComName: for example "COM48" // ComName: for example "COM48"
// connect: 0, 1 // connect: 0, 1
virtual bool dc_closeSerial(void) const = 0; virtual void dc_closeSerial(void) const =0;
// Command: close serial interface in order to save power while power down // Command: close serial interface in order to save power while power down
// or if another port must be used // or if another port must be used
@ -301,21 +379,7 @@ public:
virtual bool test_serialIsOn(void) const =0; virtual bool test_serialIsOn(void) const =0;
virtual bool dc_updateDC(QString binFileName,
QString baudrate,
QString comPort) const = 0;
// download binary file down into device controller
virtual bool dc_updatePrinterTemplate(enum FileTypeJson type,
QVector<int> templateIdx,
QVector<QString> fnames,
QString br,
QString serial) const = 0;
virtual bool dc_printTemplate(enum FileTypeJson type,
QVector<int> templateIdx,
QString br,
QString serial) const = 0;
virtual void dc_autoRequest(bool on) const =0; virtual void dc_autoRequest(bool on) const =0;
// on = true: select that all READ-Requests are sent automatically // on = true: select that all READ-Requests are sent automatically
@ -332,7 +396,7 @@ public:
// get data back in "payLoad", max 64 byte, can be used for diagnosis // get data back in "payLoad", max 64 byte, can be used for diagnosis
// retval = nr of bytes received. If host buffer too small then // retval = nr of bytes received. If host buffer too small then
// only plBufSiz bytes are copied to "payLoad" // only plBufSiz bytes are copied to "payLoad"
// plBufSiz­z=size of host buffer // plBufSiz­z=size of host buffer
virtual void dc_requTestResponse() const =0; virtual void dc_requTestResponse() const =0;
// tell DC2 to send a test-string, useful to see if cable and baudrate is OK // tell DC2 to send a test-string, useful to see if cable and baudrate is OK
@ -453,10 +517,10 @@ public:
// Analog values: // Analog values:
virtual uint32_t dc_getTemperature(void) const =0; virtual uint32_t dc_getTemperature(void) const =0;
// in Sax-Format 0...400 (0=-50,0°C 100=0,0°C 141=20,5°C 400=150,0°C) // in Sax-Format 0...400 (0=-50,0°C 100=0,0°C 141=20,5°C 400=150,0°C)
virtual QString dc_getTemperaturStr(void) const =0; virtual QString dc_getTemperaturStr(void) const =0;
// as string like "-12,5°C" // as string like "-12,5°C"
virtual uint32_t dc_getVoltage(void) const =0; virtual uint32_t dc_getVoltage(void) const =0;
// as value in mV, 0...65,535V // as value in mV, 0...65,535V
@ -611,7 +675,7 @@ public:
uint8_t kindOfModem, uint8_t kindOfCredit ) const =0; uint8_t kindOfModem, uint8_t kindOfCredit ) const =0;
// enable hardware in device controller: // enable hardware in device controller:
// kindOfPrinter: 0:off 1: GPT4672 (only this one implemented) // kindOfPrinter: 0:off 1: GPT4672 (only this one implemented)
// kindOfCoinChecker: 0:off 1:EMP820 2:EMP900 3: C²_changer // kindOfCoinChecker: 0:off 1:EMP820 2:EMP900 3: C²_changer
// kindOfMifareReader: 0:off 1: SL025 (only this one implemented) // kindOfMifareReader: 0:off 1: SL025 (only this one implemented)
// suppressSleep: 0:sleep allowed 1: sleep surpressed for special reason // suppressSleep: 0:sleep allowed 1: sleep surpressed for special reason
// kindOfModem: 0:off 1: ATB_Sunlink_LTE (not yet implemented) // kindOfModem: 0:off 1: ATB_Sunlink_LTE (not yet implemented)
@ -717,7 +781,7 @@ public:
// send 5 byte: byte 0,1: speed 5...250 mm/s // send 5 byte: byte 0,1: speed 5...250 mm/s
// byte2: density 0....(25)....50 // byte2: density 0....(25)....50
// byte3: alignment 'l', 'c', 'r' = left, center, right // byte3: alignment 'l', 'c', 'r' = left, center, right
// byte4: orientation 0, 90, 180 = 0°, 90°, 180° rotation (by now not supported!) // byte4: orientation 0, 90, 180 = 0°, 90°, 180° rotation (by now not supported!)
// not batched! don't use twice within 100ms // not batched! don't use twice within 100ms
virtual void prn_movePaper(uint8_t wayInMm, uint8_t direction) const =0; virtual void prn_movePaper(uint8_t wayInMm, uint8_t direction) const =0;
@ -775,29 +839,36 @@ public:
// up to 8 dynamic values can be defined in the template ("print val3 here") and will be sent with printing command // up to 8 dynamic values can be defined in the template ("print val3 here") and will be sent with printing command
// example: print current time at this point (the time of printing not the storage time!!) // example: print current time at this point (the time of printing not the storage time!!)
virtual void pri_startTicketDesign(void) const =0; // obsolete
//virtual void pri_startTicketDesign(void) const =0;
// start for every new printer document, reseting collecting buffer // start for every new printer document, reseting collecting buffer
// all further functions write/append text, numbers and command to the ticket-buffer, up to 1278 bytes allowed // all further functions write/append text, numbers and command to the ticket-buffer, up to 1278 bytes allowed
// return val of the appending functions: true=ok false=too long, buffer full // return val of the appending functions: true=ok false=too long, buffer full
virtual int pri_TD_getCurrentSize(void) const =0; // obsolete
//virtual int pri_TD_getCurrentSize(void) const =0;
// retval: 0...1278 // retval: 0...1278
virtual bool pri_TD_addText(QByteArray text) const =0; // obsolete
//virtual bool pri_TD_addText(QByteArray text) const =0;
// example: pri_TD_addText("Hello") const =0; // example: pri_TD_addText("Hello") const =0;
// example: pri_TD_addText(tempStr) const =0; // example: pri_TD_addText(tempStr) const =0;
// retval: true=ok false=too long, buffer full // retval: true=ok false=too long, buffer full
virtual bool pri_TD_addValue(int val) const =0; // obsolete
//virtual bool pri_TD_addValue(int val) const =0;
// +/- 0...2^(31) // +/- 0...2^(31)
virtual bool pri_TD_addNewLine(void) const =0; // obsolete
//virtual bool pri_TD_addNewLine(void) const =0;
virtual bool pri_TD_addSign(char sign) const =0; // obsolete
//virtual bool pri_TD_addSign(char sign) const =0;
// example: '.' ' ' 0x20 'W' '$' // example: '.' ' ' 0x20 'W' '$'
virtual bool pri_TD_addCommand(char group, char attribute, char p1, char p2, char p3, char p4, char p5) const =0; // obsolete
//virtual bool pri_TD_addCommand(char group, char attribute, char p1, char p2, char p3, char p4, char p5) const =0;
// always add 8 byte to the ticket layout: ESC & group & attribute & parameter1...5 // always add 8 byte to the ticket layout: ESC & group & attribute & parameter1...5
/* complete list of possible commands: /* complete list of possible commands:
group 50 : paper group 50 : paper
@ -838,11 +909,13 @@ public:
*/ */
virtual char prn_clearDocument(uint8_t documentNumber) const =0; // obsolete
//virtual char prn_clearDocument(uint8_t documentNumber) const =0;
// clear memory buffer for ONE document // clear memory buffer for ONE document
// function takes a second! don't send right before "store doc" // function takes a second! don't send right before "store doc"
virtual bool prn_store_Document(uint8_t documentNumber ) const =0; // obsolete
//virtual bool prn_store_Document(uint8_t documentNumber ) const =0;
// send the predefined Layout (generated with above TD functions) to DeviceController to save // send the predefined Layout (generated with above TD functions) to DeviceController to save
// documentNumber=0...15 // documentNumber=0...15
// maximal 1280 bytes each // maximal 1280 bytes each
@ -853,7 +926,8 @@ public:
// the place in the ticket layout is predefined (already in DC memory) // the place in the ticket layout is predefined (already in DC memory)
// the dynamics are first calculated at printing time // the dynamics are first calculated at printing time
virtual bool prn_printDocument(uint8_t documentNumber, struct T_dynDat *dynTicketData) const =0; // obsolete
//virtual bool prn_printDocument(uint8_t documentNumber, struct T_dynDat *dynTicketData) const =0;
// 36 // 36
@ -1248,7 +1322,7 @@ public:
virtual void bl_startBL(void) const =0; virtual void bl_startBL(void) const =0;
// send command within 4s after DC power-on, otherwise bl is left // send command within 4s after DC power-on, otherwise bl is left
virtual bool bl_checkBL(void) const = 0; virtual void bl_checkBL(void) const =0;
// send command to verify if bl is up // send command to verify if bl is up
virtual bool bl_isUp(void) const =0; virtual bool bl_isUp(void) const =0;
@ -1285,7 +1359,7 @@ public:
// Komplett-schreib Funktion, noch nicht getestet // Komplett-schreib Funktion, noch nicht getestet
// Nachteil: keine Rückmeldung wie lang's noch dauert // Nachteil: keine Rückmeldung wie lang's noch dauert
//virtual void bl_startSending(void) const=0; //virtual void bl_startSending(void) const=0;
// call once after BL is working and file is loaded // call once after BL is working and file is loaded
//virtual void bl_sendFile(void) const=0; //virtual void bl_sendFile(void) const=0;
@ -1311,7 +1385,7 @@ public:
buf[4]=GlobTime.Month; buf[4]=GlobTime.Month;
buf[5]=GlobTime.Day; buf[5]=GlobTime.Day;
buf[6]=GlobTime.DOW; buf[6]=GlobTime.DOW;
buf[7]=' '; // immer auf 32bit auffüllen sonst Speicherproblem beim Master! buf[7]=' '; // immer auf 32bit auffüllen sonst Speicherproblem beim Master!
uitmp=GlobTime.MinOfDay; uitmp=GlobTime.MinOfDay;
buf[8]=swl_getOneByteFromUint(uitmp, 0); buf[8]=swl_getOneByteFromUint(uitmp, 0);
buf[9]=swl_getOneByteFromUint(uitmp, 1); buf[9]=swl_getOneByteFromUint(uitmp, 1);
@ -1371,6 +1445,8 @@ public:
*/ */
virtual bool rtc_getExtendedTime(struct T_extTime *exTime) const=0;
virtual bool sys_runCompleteTest(void) const=0; virtual bool sys_runCompleteTest(void) const=0;
// warning: lasts 20s in one pace // warning: lasts 20s in one pace
// return true if sending, false if cmd-stack is full // return true if sending, false if cmd-stack is full
@ -1395,15 +1471,18 @@ public:
// nr = 1..32 // nr = 1..32
// return true if sending, false if cmd-stack is full // return true if sending, false if cmd-stack is full
virtual void log_getHoldAccountNumbers(uint32_t *accNr ) const=0; virtual void log_getHoldAccountNumbers(uint8_t *nrOfVals, uint16_t *accNr ) const=0;
// returns all acc nrs of the backuped vault records // returns all acc nrs of the backuped vault records
// use: uint32_t backupedAccNumbers[8] // use: uint16_t backupedAccNumbers[8]
virtual bool log_selectVaultRecord(uint16_t accountNr ) const=0; virtual bool log_selectVaultRecord(uint16_t accountNr ) const=0;
// return true if sending, false if cmd-stack is full // return true if sending, false if cmd-stack is full
// and trigger transfer
//request, isAvailable virtual bool log_chkIfVaultRecordAvailable(void) const=0;
virtual void log_getVaultRecord(struct T_vaultRecord *retVR) const=0; // return true if completly received
virtual bool log_getVaultRecord(struct T_vaultRecord *retVR) const=0;
// which was selected by: log_selectVaultRecord() // which was selected by: log_selectVaultRecord()
// to be forwarded to Ismas // to be forwarded to Ismas
@ -1413,7 +1492,19 @@ virtual void log_getVaultRecord(struct T_vaultRecord *retVR) const=0;
virtual bool prn_printTestTicket(void) const=0; virtual bool prn_printTestTicket(void) const=0;
// return true if sending to DC OK, false if cmd-stack is full // return true if sending to DC OK, false if cmd-stack is full
virtual bool cash_startPayment(uint16_t amount) const=0; virtual bool cash_startPayment(uint32_t amount) const=0;
// 17.4.23TS: extended to 32bit
virtual uint8_t cash_paymentProcessing(void) const=0;
// run this function periodically while coin payment process to generate necessary signals
// return value:
// 0: stopped 1: starting up 2: coin collection
// 3: finished by User (Push button) 4: finished, Max-Value collected
// 5: finished by escrow
// 10,11: error cannot start
// 12: timeout while payment, coins returned
// 13: stopped by unexpected error
virtual uint32_t getInsertedAmount(void) const=0; virtual uint32_t getInsertedAmount(void) const=0;
@ -1437,18 +1528,23 @@ virtual void log_getVaultRecord(struct T_vaultRecord *retVR) const=0;
// conclude payment process and return all inserted coins // conclude payment process and return all inserted coins
virtual uint8_t mif_getCardType(QString *cardholder) const=0;
virtual uint8_t mif_getCardType(QString cardholder) const=0;
// return 1,2,3,4 = upper, lower access card, printer test, coin test // return 1,2,3,4 = upper, lower access card, printer test, coin test
// cardholder: 7byte Name-String // cardholder: 7byte Name-String
virtual uint64_t sys_getWakeSource(void) const =0; virtual uint64_t sys_getWakeSource(void) const =0;
// retval: 6 bytes, bit coded, 1=event keeps DC awake // retval: 6 bytes, bit coded, 1=event keeps DC awake
//virtual void sys_getDeviceConditions(struct T_moduleCondition *devCond) const=0; virtual uint8_t sys_getWakeReason(void) const=0;
// Master was woken by following reason:
// 1: MDB Event
// 2: Coin Event
// ( 3: Master Event) - will not set the wake line
// ( 4: 32s pulse) - will not set the wake line
// 5: Door Event
// ( 6: Diag Event) - will not set the wake line
// 7: 30min-Pulse for HB
virtual void sys_getDeviceConditions(uint8_t *leng, uint8_t *data) const=0; virtual void sys_getDeviceConditions(uint8_t *leng, uint8_t *data) const=0;
/* /*
@ -1485,8 +1581,9 @@ virtual void log_getVaultRecord(struct T_vaultRecord *retVR) const=0;
*/ */
virtual void sys_getDeviceConditions(struct T_moduleCondition *devCond) const=0;
//virtual void sys_getDynMachineConditions(struct T_dynamicCondition *dynMachCond) const=0;
virtual void sys_getDynMachineConditions(uint8_t *leng, uint8_t *data) const=0; virtual void sys_getDynMachineConditions(uint8_t *leng, uint8_t *data) const=0;
/* /*
@ -1552,6 +1649,70 @@ virtual void log_getVaultRecord(struct T_vaultRecord *retVR) const=0;
*/ */
virtual void sys_getDynMachineConditions(struct T_dynamicCondition *dynMachCond) const=0;
// content of Cashbox
virtual uint32_t cash_getAmountInVault(void) const=0;
virtual uint16_t cash_getNrCoinsInVault(void) const=0;
virtual uint8_t prn_getPrintResult() const=0;
// return: 0: unknown
// 1: OK - last template was printed succesful
// 2: error - last template was not printed
// in case of print-error get detailed error:
virtual uint8_t prn_getCurrentPrinterState() const=0;
// 0: printer OK
// bit0: near paper end bit1: no paper
// bit2: temperature error bit3: error head open
// bit4: paper jam in cutter
// bit6: no response bit7: serial rec. error
// bit5: printer not ready
virtual void sys_sendDeviceParameter(struct T_devices *deviceSettings) const=0;
virtual void sys_restoreDeviceParameter(struct T_devices *deviceSettings) const=0;
virtual bool sys_areDCdataValid(void) const=0;
virtual bool sys_sendingTest(void) const =0;
virtual void prn_requestCurrentDynData(void) const =0;
virtual bool prn_getCurrentDynamicPrnValuesFromDC(uint8_t *dynPrnVal ) const =0;
// which was sent with: bool prn_sendDynamicPrnValues(uint8_t *dynPrnVal ) const override;
virtual bool prn_dynDataAreEqual(uint8_t *buf) const =0;
virtual bool prn_printKombiticket(uint8_t nrOfKombi) const=0;
// print four of the templates loaded by Json prior
// nr = 1..8
virtual void lock_triggerUpperSolenoid(void) const =0;
virtual void lock_triggerLowerSolenoid(void) const =0;
signals:
virtual void hwapi_templatePrintFinished_OK(void) const=0;
virtual void hwapi_templatePrintFinished_Err(void) const=0;
virtual void hwapi_coinCollectionJustStarted(void) const=0;
virtual void hwapi_coinCollectionAborted(void) const=0;
virtual void hwapi_gotNewCoin(void) const=0;
virtual void hwapi_payStopByMax(void) const=0;
virtual void hwapi_payStopByPushbutton(void) const=0;
virtual void hwapi_payStopByEscrow(void) const=0;
virtual void hwapi_payStopByError(void) const=0;
virtual void hwapi_payStopByTimeout(void) const=0;
virtual void hwapi_payCancelled(void) const=0;
virtual void hwapi_coinProcessJustStopped(void) const=0;
}; };
@ -1569,10 +1730,22 @@ virtual void log_getVaultRecord(struct T_vaultRecord *retVR) const=0;
// 29.03.2023: V3.1 some extensions for PSA1256_ptu5, // 29.03.2023: V3.1 some extensions for PSA1256_ptu5,
// V3.2 Bootloader improvement // V3.2 Bootloader improvement
// 12.04.2023: V3.3 new features extended: loading and using Json-files, cash-collection, cash-data-logging // 12.04.2023: V3.3 new features extended: loading and using Json-files, cash-collection, cash-data-logging
// 14.04.2023: V3.4 new features extended: sys_getDynMachineConditions, sys_getDeviceConditions and
// rtc_getExtendedTime return struct in addition. New function to select and get VaultRecord
//
// 19.04.2023: V3.5 new function: sys_getWakeReason();
// 17.05.2023: V3.6 new function: cash_isCollectionActive(), cash_isPayProcessActive()
// new signals: hwapi_coinCollectionJustStopped, hwapi_coinCollectionJustStarted
// getAllInsertedCoins() fixed, also in datif and storeINdata
//#define HWINF_iid "Atb.Psa2020.software.HWapi/3.1" //#define HWINF_iid "Atb.Psa2020.software.HWapi/3.1"
//#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.1" //#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.1"
#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.3" //#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.3"
//#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.4"
//#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.5"
#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.6"

View File

@ -93,34 +93,29 @@ T_com::~T_com()
void T_com::ser_ISR100ms() void T_com::ser_ISR100ms()
{ {
//qDebug() << "~~>LIB" << "ENTER...";
// call every 100ms to check if user(HMI) wants to connect or disconnect // call every 100ms to check if user(HMI) wants to connect or disconnect
//qDebug() << "~~>LIB" << "checking connect button... " ;
uint8_t chkConn = gpi_getSerialConn(); // from global GUI buffer (Sdata) uint8_t chkConn = gpi_getSerialConn(); // from global GUI buffer (Sdata)
//qDebug() << "~~>LIB" << "checking connect button... " << chkConn;
switch (chkConn) switch (chkConn)
{ {
case 0: // 0 button "connect" was just released case 0: // 0 button "connect" was just released
//qDebug() << "close serial port" << chkConn;
closeSerialPort(); closeSerialPort();
gpi_serialChanged(); // set chkConn to 2, thus getting edge gpi_serialChanged(); // set chkConn to 2, thus getting edge
break; break;
case 1: // 1 button "connect" was just pressed case 1: // 1 button "connect" was just pressed
//qDebug() << "open serial port" << chkConn;
open_Serial_Port(); open_Serial_Port();
gpi_serialChanged(); // set chkConn to 2, thus getting edge gpi_serialChanged(); // set chkConn to 2, thus getting edge
break; break;
} }
if (CatSerial->isOpen()) { if (CatSerial->isOpen())
gpi_serialIsOpen(true); gpi_serialIsOpen(true);
} else { else
gpi_serialIsOpen(false); gpi_serialIsOpen(false);
}
//qDebug() << "LEAVE " << chkConn;
} }
// ------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------
@ -129,24 +124,17 @@ void T_com::ser_ISR100ms()
char T_com::open_Serial_Port() char T_com::open_Serial_Port()
{ {
//qDebug() << "ENTER";
bool ret; bool ret;
QString myString=nullptr, myPortName=nullptr, myBaudStr=nullptr; QString myString=nullptr, myPortName=nullptr, myBaudStr=nullptr;
int myBaudNr; int myBaudNr;
if (CatSerial->isOpen()) { if (CatSerial->isOpen())
qDebug() << "!!!IS OPEN!!!";
return 0; // opening twice is not allowed return 0; // opening twice is not allowed
}
//qDebug() << "connecting..." << myPortName; //qDebug() << "connecting..." << myPortName;
myPortName=gpi_getComPortName(); // was selected and stored from GUI myPortName=gpi_getComPortName(); // was selected and stored from GUI
CatSerial->setPortName(myPortName); CatSerial->setPortName(myPortName);
myBaudNr=gpi_getBaudNr(); // was selected and stored from GUI myBaudNr=gpi_getBaudNr(); // was selected and stored from GUI
//qDebug() << "myPortName" << myPortName << ", myBaudNr" << myBaudNr;
switch (myBaudNr) switch (myBaudNr)
{ {
// 0:1200 1:9600 2:19200 3:38400 4:57600 5:115200 // 0:1200 1:9600 2:19200 3:38400 4:57600 5:115200
@ -179,9 +167,6 @@ char T_com::open_Serial_Port()
myString.append(CatSerial->errorString()); myString.append(CatSerial->errorString());
qDebug() << myString; qDebug() << myString;
gpi_setTxt4comStateLine(myString); gpi_setTxt4comStateLine(myString);
//qDebug() << "LEAVE";
return 0; return 0;
} else } else
{ {
@ -197,14 +182,11 @@ char T_com::open_Serial_Port()
} }
//qDebug() << "LEAVE";
return 0; return 0;
} }
void T_com::closeSerialPort() void T_com::closeSerialPort()
{ {
//qDebug() << "ENTER";
if (CatSerial->isOpen()) if (CatSerial->isOpen())
{ {
qDebug() << "closing connection"; qDebug() << "closing connection";
@ -213,8 +195,6 @@ void T_com::closeSerialPort()
gpi_setTxt4RsDiagWin("closed"); gpi_setTxt4RsDiagWin("closed");
} }
//qDebug() << "LEAVE";
} }

View File

@ -1,110 +1,134 @@
#include <stdint.h> #include <stdint.h>
#include <algorithm>
#include <QString> #include <QString>
#include <QDebug> #include <QDebug>
#include "tslib.h" #include "tslib.h"
#include "shared_mem_buffer.h" //#include "controlBus.h"
// /////////////////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////////
// control serial interface gui <--> serial // 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, static QString rs_comportName; // z.B. "COM48"
sizeof(SharedMemBuffer::getData()->rs.baudStr)); static QString rs_baudStr; // z.B. "19200"
strncpy(SharedMemBuffer::getData()->rs.baudStr, static int rs_baudNr; //0...5 oder -1
BaudStr.toStdString().c_str(), static uint8_t rs_connect; // 0,1
sizeof(SharedMemBuffer::getData()->rs.baudStr)-1);
void epi_setSerial(int BaudNr, QString BaudStr, QString ComName, uint8_t connect)
{
rs_comportName = ComName;
rs_baudStr = BaudStr;
rs_baudNr = BaudNr; // 0=1200 1=9600 2=19200 3=38400 4=57600 5=115200 oder -1
rs_connect = connect; // 0/1
SharedMemBuffer::getData()->rs.baudNr = BaudNr;
SharedMemBuffer::getData()->rs.connect = connect;
} }
void epi_closeSerial(void) { void epi_closeSerial(void)
SharedMemBuffer::getData()->rs.connect = 0; {
rs_connect=0;
} }
void gpi_serialChanged(void) {
void gpi_serialChanged(void)
{
// serial confirms that port was closed or opened // serial confirms that port was closed or opened
// rs_connect=2; // Flanke, nur 1x öffnen/schließen rs_connect=2; // Flanke, nur 1x öffnen/schließen
SharedMemBuffer::getData()->rs.connect = 2;
} }
uint8_t gpi_getSerialConn(void) { uint8_t gpi_getSerialConn(void)
return SharedMemBuffer::getDataConst()->rs.connect; {
return rs_connect;
} }
int gpi_getBaudNr(void) {
return SharedMemBuffer::getDataConst()->rs.baudNr; int gpi_getBaudNr(void)
{
return rs_baudNr;
} }
QString gpi_getComPortName(void) { QString gpi_getComPortName(void)
return SharedMemBuffer::getDataConst()->rs.comportName; {
return rs_comportName;
} }
void gpi_serialIsOpen(bool offen) { static bool rs_portIsOpen;
SharedMemBuffer::getData()->rs.portIsOpen = offen;
void gpi_serialIsOpen(bool offen)
{
rs_portIsOpen=offen;
} }
bool epi_isSerialPortOpen() { bool epi_isSerialPortOpen()
{
// true: port is open false: port is closed // true: port is open false: port is closed
return SharedMemBuffer::getDataConst()->rs.portIsOpen; return rs_portIsOpen;
} }
// /////////////////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////////
// Control transfer gui <--> serial // Control transfer gui <--> serial
// /////////////////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////////
void epi_startEmmision(char start) {
SharedMemBuffer::getData()->AutoEmissionOn = start; static char AutoEmissionOn; // 1: zyklisch Anfragen zum Slave senden
void epi_startEmmision(char start)
{
AutoEmissionOn=start;
} }
bool gpi_isEmmisionOn(void) { bool gpi_isEmmisionOn(void)
return SharedMemBuffer::getDataConst()->AutoEmissionOn; {
return AutoEmissionOn;
} }
uint16_t gpi_getPeriodicSendTimeVal() { //-----------------------------------------------------
SharedMemBuffer::getData()->datif.sendingPer_changed = 0;
if ((SharedMemBuffer::getDataConst()->datif.sendingPeriod < 3) || static uint16_t datif_sendingPeriod;
(SharedMemBuffer::getDataConst()->datif.sendingPeriod > 10000)) { static bool datif_sendingPer_changed;
uint16_t gpi_getPeriodicSendTimeVal()
{
datif_sendingPer_changed=0;
if (datif_sendingPeriod<3 || datif_sendingPeriod>10000)
return 130; // ms, default return 130; // ms, default
} else
return SharedMemBuffer::getDataConst()->datif.sendingPeriod; return datif_sendingPeriod;
} }
void epi_setPeriodicSendTimeVal(uint16_t val) { void epi_setPeriodicSendTimeVal(uint16_t val)
if (val>=3 && val<10000) { {
SharedMemBuffer::getData()->datif.sendingPer_changed = 1; if (val>=3 && val<10000)
SharedMemBuffer::getData()->datif.sendingPeriod = val; {
datif_sendingPer_changed=1;
datif_sendingPeriod=val;
} }
} }
bool gpi_PeriodicSendTimeHasChanged() { bool gpi_PeriodicSendTimeHasChanged()
return SharedMemBuffer::getDataConst()->datif.sendingPer_changed; {
return datif_sendingPer_changed;
} }
//-----------------------------------------------------
//-----------------------------------------------------
// /////////////////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////////
// Status Display gui <--> serial // Status Display gui <--> serial
// /////////////////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////////
// linke Spalte, über Connect Button // linke Spalte, über Connect Button
static QString txt4comStateLine; static QString txt4comStateLine;
QString epi_getTxt4comStateLine(void) { QString epi_getTxt4comStateLine(void)
{
// GUI: get Text for serial Comport-State Line // GUI: get Text for serial Comport-State Line
return txt4comStateLine; return txt4comStateLine;
} }
void gpi_setTxt4comStateLine(QString txtline) { void gpi_setTxt4comStateLine(QString txtline) // gpi
{
// serial: write Text to be displayed in serial Comport-State line (like "connected") // serial: write Text to be displayed in serial Comport-State line (like "connected")
txt4comStateLine.clear(); txt4comStateLine.clear();
if (txtline=="") if (txtline=="")
@ -113,20 +137,26 @@ void gpi_setTxt4comStateLine(QString txtline) {
txt4comStateLine=txtline; txt4comStateLine=txtline;
} }
void epi_clrTxt4comStateLine() { void epi_clrTxt4comStateLine()
{
txt4comStateLine.clear(); txt4comStateLine.clear();
} }
//---------------------------------------------------------------------------------------------
// rechte Spalte, oberste Statuszeile // rechte Spalte, oberste Statuszeile
// I) "Handshakes" (serial Control) flow.cpp // I) "Handshakes" (serial Control) flow.cpp
// geht überhaupt was raus? kommt überhaupt was zurück? // geht überhaupt was raus? kommt überhaupt was zurück?
static QString txt4HsStateLine; static QString txt4HsStateLine;
QString epi_getTxt4HsStateLine(void) { QString epi_getTxt4HsStateLine(void)
{
return txt4HsStateLine; return txt4HsStateLine;
} }
void gpi_setTxt4HsStateLine(QString txtline) { void gpi_setTxt4HsStateLine(QString txtline)
{
txt4HsStateLine.clear(); txt4HsStateLine.clear();
if (txtline=="") if (txtline=="")
txt4HsStateLine.clear(); txt4HsStateLine.clear();
@ -134,19 +164,26 @@ void gpi_setTxt4HsStateLine(QString txtline) {
txt4HsStateLine=txtline; txt4HsStateLine=txtline;
} }
void epi_clrTxt4HsStateLine() { void epi_clrTxt4HsStateLine()
{
txt4HsStateLine.clear(); txt4HsStateLine.clear();
} }
//---------------------------------------------------------------------------------------------
// II) Master receive state (empfangenes Telgramm OK? crc? length? ) // II) Master receive state (empfangenes Telgramm OK? crc? length? )
// Statuszeile Auswertung der SlaveResponse (serial Frame, CRC usw) (prot.cpp) // Statuszeile Auswertung der SlaveResponse (serial Frame, CRC usw) (prot.cpp)
static QString txt4masterStateLine; static QString txt4masterStateLine;
QString epi_getTxt4masterStateLine(void) { QString epi_getTxt4masterStateLine(void)
{
return txt4masterStateLine; return txt4masterStateLine;
} }
void gpi_setTxt4masterStateLine(QString txtline) { void gpi_setTxt4masterStateLine(QString txtline)
{
txt4masterStateLine.clear(); txt4masterStateLine.clear();
if (txtline=="") if (txtline=="")
txt4masterStateLine.clear(); txt4masterStateLine.clear();
@ -154,10 +191,13 @@ void gpi_setTxt4masterStateLine(QString txtline) {
txt4masterStateLine=txtline; txt4masterStateLine=txtline;
} }
void epi_clrTxt4masterStateLine() { void epi_clrTxt4masterStateLine()
{
txt4masterStateLine.clear(); txt4masterStateLine.clear();
} }
//--------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------
// III Slave receive (from Master) OK? if then show results, if not then show errors // III Slave receive (from Master) OK? if then show results, if not then show errors
@ -167,11 +207,13 @@ void epi_clrTxt4masterStateLine() {
static QString txt4resultStateLine; static QString txt4resultStateLine;
QString epi_getTxt4resultStateLine(void) { QString epi_getTxt4resultStateLine(void)
{
return txt4resultStateLine; return txt4resultStateLine;
} }
void gpi_setTxt4resultStateLine(QString txtline) { void gpi_setTxt4resultStateLine(QString txtline)
{
txt4resultStateLine.clear(); txt4resultStateLine.clear();
if (txtline=="") if (txtline=="")
txt4resultStateLine.clear(); txt4resultStateLine.clear();
@ -179,22 +221,26 @@ void gpi_setTxt4resultStateLine(QString txtline) {
txt4resultStateLine=txtline; txt4resultStateLine=txtline;
} }
void epi_clrTxt4resultStateLine() { void epi_clrTxt4resultStateLine()
{
txt4resultStateLine.clear(); txt4resultStateLine.clear();
} }
//--------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------
// IV Statuszeile Empfangsdaten // IV Statuszeile Empfangsdaten
static QString txt4dataLine; static QString txt4dataLine;
QString epi_getTxt4dataStateLine(void) { QString epi_getTxt4dataStateLine(void)
{
// GUI: get Text for serial Comport-State Line // GUI: get Text for serial Comport-State Line
return txt4dataLine; return txt4dataLine;
} }
void gpi_setTxt4dataStateLine(QString txtline) { void gpi_setTxt4dataStateLine(QString txtline)
{
// serial: write Text to be displayed in serial Comport-State line (like "connected") // serial: write Text to be displayed in serial Comport-State line (like "connected")
txt4dataLine.clear(); txt4dataLine.clear();
if (txtline=="") if (txtline=="")
@ -203,7 +249,8 @@ void gpi_setTxt4dataStateLine(QString txtline) {
txt4dataLine=txtline; txt4dataLine=txtline;
} }
void epi_clrTxt4dataStateLine() { void epi_clrTxt4dataStateLine()
{
txt4dataLine.clear(); txt4dataLine.clear();
} }
@ -213,11 +260,16 @@ void epi_clrTxt4dataStateLine() {
static QString txt4datifReceive; static QString txt4datifReceive;
QString epi_getTxt4datifLine(void) { QString epi_getTxt4datifLine(void)
{
return txt4datifReceive; return txt4datifReceive;
} }
void gpi_setTxt4datifLine(QString txtline) { void gpi_setTxt4datifLine(QString txtline)
{
txt4datifReceive.clear(); txt4datifReceive.clear();
if (txtline=="") if (txtline=="")
txt4datifReceive.clear(); txt4datifReceive.clear();
@ -225,7 +277,8 @@ void gpi_setTxt4datifLine(QString txtline) {
txt4datifReceive=txtline; txt4datifReceive=txtline;
} }
void epi_clrTxt4datifLine() { void epi_clrTxt4datifLine()
{
txt4datifReceive.clear(); txt4datifReceive.clear();
} }
@ -234,11 +287,14 @@ void epi_clrTxt4datifLine() {
static QString txt4diagWindow; static QString txt4diagWindow;
QString epi_getTxt4RsDiagWin(void) { QString epi_getTxt4RsDiagWin(void)
{
return txt4diagWindow; return txt4diagWindow;
} }
void gpi_setTxt4RsDiagWin(QString txtline) { void gpi_setTxt4RsDiagWin(QString txtline)
{
txt4diagWindow.clear(); txt4diagWindow.clear();
if (txtline=="") if (txtline=="")
txt4diagWindow.clear(); txt4diagWindow.clear();
@ -246,7 +302,8 @@ void gpi_setTxt4RsDiagWin(QString txtline) {
txt4diagWindow=txtline; txt4diagWindow=txtline;
} }
void epi_clrTxt4RsDiagWin() { void epi_clrTxt4RsDiagWin()
{
txt4diagWindow.clear(); txt4diagWindow.clear();
} }
@ -254,11 +311,14 @@ void epi_clrTxt4RsDiagWin() {
static QString sndTxt4diagWindow; static QString sndTxt4diagWindow;
QString epi_get2ndTxt4RsDiagWin(void) { QString epi_get2ndTxt4RsDiagWin(void)
{
return sndTxt4diagWindow; return sndTxt4diagWindow;
} }
void gpi_set2ndTxt4RsDiagWin(QString txtline) { void gpi_set2ndTxt4RsDiagWin(QString txtline)
{
sndTxt4diagWindow.clear(); sndTxt4diagWindow.clear();
if (txtline=="") if (txtline=="")
sndTxt4diagWindow.clear(); sndTxt4diagWindow.clear();
@ -266,61 +326,174 @@ void gpi_set2ndTxt4RsDiagWin(QString txtline) {
sndTxt4diagWindow=txtline; sndTxt4diagWindow=txtline;
} }
void epi_clr2ndTxt4RsDiagWin() { void epi_clr2ndTxt4RsDiagWin()
{
sndTxt4diagWindow.clear(); sndTxt4diagWindow.clear();
} }
// /////////////////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////////
// Memory for Slave responses, common data // Memory for Slave responses, common data
// /////////////////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////////
void gpi_storeResult_serialTestOK(bool wasOk) {
SharedMemBuffer::getData()->Sdata.serialTestResult = wasOk;
static bool Sdata_serialTestResult;
void gpi_storeResult_serialTestOK(bool wasOk)
{
Sdata_serialTestResult=wasOk;
} }
bool epi_getResult_serialTestOK() { bool epi_getResult_serialTestOK()
{
// retval: true: test was successful, got right response // retval: true: test was successful, got right response
return SharedMemBuffer::getDataConst()->Sdata.serialTestResult; return Sdata_serialTestResult;
} }
// /////////////////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////////
// Store received data for hwapi // Store received data for hwapi
// /////////////////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////////
void gpi_startNewRequest() {
SharedMemBuffer::getData()->Sdata.pProtResultOk = 0;
static uint8_t Sdata_pProtResultOk;
void gpi_startNewRequest()
{
Sdata_pProtResultOk=0;
} }
void gpi_storeResultOfLastRequest(bool answisok) { void gpi_storeResultOfLastRequest(bool answisok)
SharedMemBuffer::getData()->Sdata.pProtResultOk = answisok ? 1 : 2; {
if (answisok)
Sdata_pProtResultOk=1;
else
Sdata_pProtResultOk=2;
} }
uint8_t epi_getResultOfLastRequest() { uint8_t epi_getResultOfLastRequest()
{
// retval: 0: in progress 1: OK 2: error // retval: 0: in progress 1: OK 2: error
return SharedMemBuffer::getDataConst()->Sdata.pProtResultOk; return 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]), static uint16_t Sdata_receivedDataLength;
0x00, sizeof(SharedMemBuffer::getData()->Sdata.receivedDataBlock)); static uint8_t Sdata_receivedDataBlock[64];
strncpy((char *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
(char const *)receivedData, void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t *receivedData)
sizeof(SharedMemBuffer::getData()->Sdata.receivedDataBlock)-1); {
Sdata_receivedDataLength=uint16_t(RdDlen);
if (Sdata_receivedDataLength>64)
Sdata_receivedDataLength=64;
tslib_strclr(Sdata_receivedDataBlock,0,64);
tslib_strcpy(receivedData, Sdata_receivedDataBlock, Sdata_receivedDataLength);
} }
uint16_t epi_getLastPayLoad(uint16_t plBufSiz, uint8_t *payLoad) { uint16_t epi_getLastPayLoad(uint16_t plBufSiz, uint8_t *payLoad)
{
// get data back in *pl, max 64 byte // get data back in *pl, max 64 byte
// retval = nr of bytes received. If host buffer too small then // retval = nr of bytes received. If host buffer too small then
// only plBufSíz bytes are copied to pl // only plBufSíz bytes are copied to pl
// plBufSíz=size of host buffer // plBufSíz=size of host buffer
uint16_t ml = std::min(plBufSiz, (uint16_t)(64)); uint16_t ml=plBufSiz;
if (SharedMemBuffer::getDataConst()->Sdata.receivedDataLength < ml) { if (ml>64) ml=64;
ml = SharedMemBuffer::getDataConst()->Sdata.receivedDataLength; if (Sdata_receivedDataLength<ml)
ml=Sdata_receivedDataLength;
tslib_strcpy(Sdata_receivedDataBlock, payLoad, ml);
return Sdata_receivedDataLength;
} }
strncpy((char *)payLoad,
(char const *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
ml);
return SharedMemBuffer::getDataConst()->Sdata.receivedDataLength;
static uint8_t ndbs, pari, nsb, br;
void gpi_storeSlaveSerParams(uint8_t slaveBaudRate, uint8_t NrDataBits,
uint8_t parity, uint8_t NrStopBits)
{
// store numbers
ndbs=NrDataBits;
pari=parity;
nsb=NrStopBits;
br=slaveBaudRate;
} }
void epi_getSlaveSerParams(uint8_t *slaveBaudRate, uint8_t *NrDataBits,
uint8_t *parity, uint8_t *NrStopBits)
{
*NrDataBits=ndbs;
*parity=pari;
*NrStopBits=nsb;
*slaveBaudRate=br;
}
/*
void gpi_storeSlaveSerParams(uint8_t slaveBaudRate, uint8_t NrDataBits,
uint8_t parity, uint8_t NrStopBits) {
// store numbers
SharedMemBuffer::write()->ndbs = NrDataBits;
SharedMemBuffer::write()->pari = parity;
SharedMemBuffer::write()->nsb = NrStopBits;
SharedMemBuffer::write()->br = slaveBaudRate;
}
void epi_getSlaveSerParams(uint8_t *slaveBaudRate, uint8_t *NrDataBits,
uint8_t *parity, uint8_t *NrStopBits) {
*NrDataBits = SharedMemBuffer::read()->ndbs;
*parity = SharedMemBuffer::read()->pari;
*NrStopBits = SharedMemBuffer::read()->nsb;
*slaveBaudRate = SharedMemBuffer::read()->br;
}
*/
QString epi_getSlaveParamSTR()
{
QString mySt;
char ctmp;
// uint8_t ndbs;
// uint8_t pari;
// uint8_t nsb;
// uint8_t br;
mySt.clear();
// br=SharedMemBuffer::read()->br;
// ndbs=SharedMemBuffer::read()->ndbs;
// pari =SharedMemBuffer::read()->pari;
// nsb=SharedMemBuffer::read()->nsb;
switch (br)
{
case 1: mySt="1200 ";break;
case 2: mySt="9600 ";break;
case 3: mySt="19200 ";break;
case 4: mySt="38400 ";break;
case 5: mySt="57600 ";break;
case 6: mySt="115200 ";break;
}
ctmp=ndbs;
ctmp+=0x30;
mySt.append(ctmp);
ctmp=pari;
mySt.append(ctmp);
ctmp=nsb;
ctmp+=0x30;
mySt.append(ctmp);
//mySt="Hallo";
return mySt;
}

View File

@ -3,13 +3,16 @@
#include "controlBus.h" #include "controlBus.h"
#include "storeINdata.h" #include "storeINdata.h"
#include <QDebug> #include <QDebug>
#include <datei.h>
#include <QDir>
// called from MainWindow() // called from MainWindow()
#define DATIF_MAXCMDS 16 #define DATIF_MAXCMDS 16
static uint8_t dif_dataStep; static uint8_t dif_dataStep;
static uint8_t dif_scanStep, RDBLKNR; static uint8_t dif_scanStep; //, RDBLKNR;
static uint8_t datif_OutCmdpara1, datif_OutCmdpara2, datif_OutCmdpara3, datif_OutCmdpara4; static uint8_t datif_OutCmdpara1, datif_OutCmdpara2, datif_OutCmdpara3, datif_OutCmdpara4;
@ -19,6 +22,11 @@ static uint8_t cycl_running;
T_datif::T_datif(QWidget *parent) : QMainWindow(parent) T_datif::T_datif(QWidget *parent) : QMainWindow(parent)
{ {
QByteArray myBA;
QDir myDir("../dmd");
if (!myDir.exists())
myDir.mkdir("../dmd");
myDCIF = new T_prot(); myDCIF = new T_prot();
@ -32,7 +40,7 @@ T_datif::T_datif(QWidget *parent) : QMainWindow(parent)
datif_trigger = new QTimer(); datif_trigger = new QTimer();
connect(datif_trigger, SIGNAL(timeout()), this, SLOT(datif_cycleSend())); connect(datif_trigger, SIGNAL(timeout()), this, SLOT(datif_cycleSend()));
datif_trigger->setSingleShot(false); datif_trigger->setSingleShot(false);
datif_trigger->start(10); // in ms, 80 gut, default 100 50....200 datif_trigger->start(10); // in ms,
// passing Signal through // passing Signal through
//connect(myDCIF, SIGNAL(framerecieved()), this, SLOT( ResponseRecieved() )); //connect(myDCIF, SIGNAL(framerecieved()), this, SLOT( ResponseRecieved() ));
@ -46,6 +54,30 @@ T_datif::T_datif(QWidget *parent) : QMainWindow(parent)
dif_scanStep=0; dif_scanStep=0;
selectedSlaveAddr=FIX_SLAVE_ADDR; selectedSlaveAddr=FIX_SLAVE_ADDR;
cycl_running=0; cycl_running=0;
gpi_storeDcDataValid(0);
datif_noResponseCtr=0;
// neu, 24.5.23: Alle Daten zusätzlich in Datei speichern
// if (datei_ifFileExists(FILENAME_SHAREDDATA))
// {
// myBA.clear();
// myBA=datei_readFromFile(FILENAME_SHAREDDATA);
// }
// Testfile ereugen:
csv_startCreatingFile();
csv_addUintToFile(0);
csv_addUintToFile(1);
csv_addUintToFile(2);
csv_addUintToFile(3);
csv_addUintToFile(4);
csv_addUintToFile(5);
myBA=csv_readbackArray();
datei_clearFile(FILENAME_SHAREDDATA);
datei_writeToFile(FILENAME_SHAREDDATA, myBA);
} }
void T_datif::resetChain(void) void T_datif::resetChain(void)
@ -65,6 +97,11 @@ char T_datif::datif_cycleSend()
uint8_t length, data[66]; uint8_t length, data[66];
bool b_ret; bool b_ret;
datif_noResponseCtr++; // inc every 10ms fehlt noch in SysCont
if (datif_noResponseCtr>500) // seit 5s kein Lebenszeichen von DC2
gpi_storeDcDataValid(0);
if (cycl_running) if (cycl_running)
{ {
// request is still running, wait for response before next sending // request is still running, wait for response before next sending
@ -95,7 +132,23 @@ char T_datif::datif_cycleSend()
//void myDCIF->sendUserData(uint16_t slaveAdr); //void myDCIF->sendUserData(uint16_t slaveAdr);
if (check4FDshortCmd()) if (checkNextFDcmd()==2)
{
b_ret=longFDcmd_get(&nextWrCmd, &nextRdCmd, &blockNum, &length, data);
if (b_ret)
{
myDCIF->setUserWriteData(nextWrCmd, blockNum, length, data);
myDCIF->setUserReadData(nextRdCmd);
myDCIF->sendUserData(selectedSlaveAddr);
//qDebug()<<"Datif send long cmd "<<nextWrCmd<< " " <<nextRdCmd<< " " <<length << " " << data[0]<< " " << data[1]
// << " " << data[2]<< " " << data[3]<< " " << data[4]<< " " << data[5]<< " " << data[6]<< " " << data[7]
// << " " << data[8]<< " " << data[9]<< " " << data[10]<< " " << data[11]<< " " << data[12];
}
cycl_running=1;
return 0;
} else
if (checkNextFDcmd()==1)
{ {
b_ret=sendFDcmd_get(&nextWrCmd, &nextRdCmd, &blockNum, &dat1, &dat2, &dat3, &dat4); b_ret=sendFDcmd_get(&nextWrCmd, &nextRdCmd, &blockNum, &dat1, &dat2, &dat3, &dat4);
if (b_ret) if (b_ret)
@ -104,19 +157,18 @@ char T_datif::datif_cycleSend()
myDCIF->setUserWriteData(nextWrCmd, blockNum, 4, data); myDCIF->setUserWriteData(nextWrCmd, blockNum, 4, data);
myDCIF->setUserReadData(nextRdCmd); myDCIF->setUserReadData(nextRdCmd);
myDCIF->sendUserData(selectedSlaveAddr); myDCIF->sendUserData(selectedSlaveAddr);
//qDebug()<<"Datif send short cmd "<<nextWrCmd<< " " <<nextRdCmd;
} }
cycl_running=1;
return 0;
} }
if (check4FDlongCmd())
{
b_ret=longFDcmd_get(&nextWrCmd, &nextRdCmd, &blockNum, &length, data);
if (b_ret)
{
myDCIF->setUserWriteData(nextWrCmd, blockNum, length, data);
myDCIF->setUserReadData(nextRdCmd);
myDCIF->sendUserData(selectedSlaveAddr);
}
}
// direct commands have highest prio (setting OUTPUTS) // direct commands have highest prio (setting OUTPUTS)
nxtAsCmd=sendWRcmd_getSendCommand0(); // command was stored by Gui nxtAsCmd=sendWRcmd_getSendCommand0(); // command was stored by Gui
@ -210,7 +262,10 @@ char T_datif::datif_cycleSend()
sendINrequestsAutomatic(); // sendCyclicCmd(); // request all cyclic data sequential sendINrequestsAutomatic(); // sendCyclicCmd(); // request all cyclic data sequential
} }
else else
{
dif_scanStep=0; // always start from beginning dif_scanStep=0; // always start from beginning
gpi_storeDcDataValid(0); // fehlt in SysCont
}
} }
#ifdef USEHANDSHAKES #ifdef USEHANDSHAKES
else else
@ -221,6 +276,7 @@ char T_datif::datif_cycleSend()
} else } else
{ {
//qDebug() << "com port not available"; // wird ununterbrochen ausgegeben //qDebug() << "com port not available"; // wird ununterbrochen ausgegeben
gpi_storeDcDataValid(0); // fehlt in SysCont
} }
return 0; return 0;
@ -306,6 +362,7 @@ void T_datif::sendWRcommand(uint16_t nextWrCmd)
datif_sendIOrequest(CMD2DC_FAN, CMD2DC_RdBkAllOutputs, 1); datif_sendIOrequest(CMD2DC_FAN, CMD2DC_RdBkAllOutputs, 1);
break; break;
case SENDDIRCMD_LAERM: case SENDDIRCMD_LAERM:
//qDebug()<<"datif switch siren";
datif_sendIOrequest(CMD2DC_SIREN, CMD2DC_RdBkAllOutputs, 1); datif_sendIOrequest(CMD2DC_SIREN, CMD2DC_RdBkAllOutputs, 1);
break; break;
case SENDDIRCMD_REL1: case SENDDIRCMD_REL1:
@ -728,7 +785,7 @@ char T_datif::sendINrequestsAutomatic(void)
break; break;
case 12: case 12:
if (indat_isPrinterOn()) //if (indat_isPrinterOn())
datif_sendIOrequest(0, CMD2DC_RdBk_AllPrnData, 0); // 27 datif_sendIOrequest(0, CMD2DC_RdBk_AllPrnData, 0); // 27
// datif_sendIOrequest(0, CMD2DC_RdBk_PrnState, 0); // datif_sendIOrequest(0, CMD2DC_RdBk_PrnState, 0);
break; break;
@ -738,7 +795,7 @@ char T_datif::sendINrequestsAutomatic(void)
break; break;
case 14: case 14:
if (indat_isMifareOn()) //if (indat_isMifareOn())
{ {
datif_sendIOrequest(0, CMD2DC_RdBk_MifState, 0); // 109 datif_sendIOrequest(0, CMD2DC_RdBk_MifState, 0); // 109
//qDebug()<<"requesting MIF reader state"; //qDebug()<<"requesting MIF reader state";
@ -751,6 +808,7 @@ char T_datif::sendINrequestsAutomatic(void)
break; break;
case 16: case 16:
/*
if (indat_isMifareOn()) if (indat_isMifareOn())
{ {
datif_OutCmdpara1=0; // data block number 0 contains the Mifare-ID datif_OutCmdpara1=0; // data block number 0 contains the Mifare-ID
@ -760,7 +818,8 @@ char T_datif::sendINrequestsAutomatic(void)
RDBLKNR=0; RDBLKNR=0;
datif_OutCmdpara1=RDBLKNR; datif_OutCmdpara1=RDBLKNR;
} break; }*/
break;
case 17: case 17:
//datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0); //datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
@ -768,7 +827,7 @@ char T_datif::sendINrequestsAutomatic(void)
break; break;
case 18: case 18:
if (indat_isMdbOn()) //if (indat_isMdbOn())
datif_sendIOrequest(0, CMD2DC_MDB_GET_STATE, 0); // 107 datif_sendIOrequest(0, CMD2DC_MDB_GET_STATE, 0); // 107
//else //else
// dif_scanStep=24; unsinn // dif_scanStep=24; unsinn
@ -815,7 +874,7 @@ char T_datif::sendINrequestsAutomatic(void)
dif_scanStep++; dif_scanStep++;
if (dif_scanStep>26) if (dif_scanStep>26)
dif_scanStep=5; dif_scanStep=0; // dif_scanStep=5;
return 0; return 0;
@ -838,6 +897,7 @@ char T_datif::isPortOpen(void)
void T_datif::StoredRecData() void T_datif::StoredRecData()
{ {
datif_noResponseCtr=0;
//qDebug() << "StoreRecData called"; //qDebug() << "StoreRecData called";
// call automatically by T_prot // call automatically by T_prot
//if (myDCIF->ifDataReceived()) //if (myDCIF->ifDataReceived())
@ -847,7 +907,10 @@ void T_datif::StoredRecData()
// "neu" is the same as "INdataValid" // "neu" is the same as "INdataValid"
loadRecDataFromFrame(); loadRecDataFromFrame();
} }
cycl_running=0; //cycl_running=0; // send next cmd immediately
cycl_running=9; // send next cmd after 10ms
// wichtig! bei 0 werden Telegramme verschluckt! 24.5.2023
// 9 ergibt 16ms Formel: gap = 110ms (Zeile 80) - cycl_running*10ms
} }
char T_datif::loadRecDataFromFrame() char T_datif::loadRecDataFromFrame()
@ -1021,7 +1084,7 @@ char T_datif::loadRecDataFromFrame()
//<< receivedData[3] << " " << receivedData[4] << " " << receivedData[5]; //<< receivedData[3] << " " << receivedData[4] << " " << receivedData[5];
uctmp=receivedData[0]; uctmp=receivedData[0];
// qDebug()<<"datif single bits: "<< (uctmp&1) << (uctmp&2) << (uctmp&4); //qDebug()<<"datif DOOR bits: "<< (uctmp&1) << (uctmp&2) << (uctmp&4);
gpi_storeDI_doorSwitches(uctmp&1, uctmp&2, uctmp&4); gpi_storeDI_doorSwitches(uctmp&1, uctmp&2, uctmp&4);
gpi_storeDI_vaultSwitches(uctmp&8, uctmp&16); gpi_storeDI_vaultSwitches(uctmp&8, uctmp&16);
@ -1050,8 +1113,6 @@ char T_datif::loadRecDataFromFrame()
gpi_storeDI_GsmPowerIsOn(uctmp&16); gpi_storeDI_GsmPowerIsOn(uctmp&16);
gpi_storeDI_CreditPowerIsOn(uctmp&32); gpi_storeDI_CreditPowerIsOn(uctmp&32);
gpi_storeDI_PrinterPowerIsOn(uctmp&64); gpi_storeDI_PrinterPowerIsOn(uctmp&64);
//gpi_storeMdbState(uctmp&4, uctmp&128, uctmp&4); // hat ein eigenes Cmd weiter unten!
gpi_storeDI_MdbPowerIsOn(uctmp&128); gpi_storeDI_MdbPowerIsOn(uctmp&128);
gpi_storeDI_paperLow(receivedData[5]); gpi_storeDI_paperLow(receivedData[5]);
@ -1179,10 +1240,11 @@ char T_datif::loadRecDataFromFrame()
case CMD2DC_MDB_GET_STATE: //107 case CMD2DC_MDB_GET_STATE: //107
// DB0: mdb_bus_ready (switched on) // DB0: mdb_bus_ready (switched on)
// DB1: rdBackV12devicePower // DB1: rdBackV12devicePower
// DB2: rdBackV5busPwr // DB2: rdBackV5busPwr kommt immer mit 1
//qDebug() << "got MDB state " << receivedData[0] << " " << receivedData[1] << " " << receivedData[2]; //qDebug() << "got MDB state " << receivedData[0] << " " << receivedData[1] << " " << receivedData[2];
gpi_storeMdbState(receivedData[0],receivedData[1],receivedData[2]); gpi_storeMdbState(receivedData[0],receivedData[1],receivedData[2]);
break; break;
case CMD2DC_MDB_GETRESP: //22 case CMD2DC_MDB_GETRESP: //22
@ -1206,6 +1268,15 @@ char T_datif::loadRecDataFromFrame()
// DB1: last coin signal (value / scale) // DB1: last coin signal (value / scale)
// DB2,3: last coin value // DB2,3: last coin value
// DB4: lastError from Emp // DB4: lastError from Emp
// 0: nr of stored coins
// 1: got 2:type 3:err 4=valL 5=valH
// qDebug() << "got emp coin "<< " " << receivedData[0] <<" " << receivedData[1]
// << " " << receivedData[2]<< " " << receivedData[3]
// << " " << receivedData[4]<< " " << receivedData[5]
// << " " << receivedData[6]<< " " << receivedData[7];
gpi_storeEmpCoinSignal(receivedData[0], &receivedData[1]); gpi_storeEmpCoinSignal(receivedData[0], &receivedData[1]);
break; break;
@ -1361,13 +1432,19 @@ char T_datif::loadRecDataFromFrame()
newInsertedAmount=uchar2ulong(receivedData[3],receivedData[2],receivedData[1],receivedData[0]); newInsertedAmount=uchar2ulong(receivedData[3],receivedData[2],receivedData[1],receivedData[0]);
uitmp=uchar2uint(receivedData[5],receivedData[4]); uitmp=uchar2uint(receivedData[5],receivedData[4]);
uit2=uchar2uint(receivedData[7],receivedData[6]); uit2=uchar2uint(receivedData[7],receivedData[6]);
if (uitmp>0) // nur 1x bei neuer Münze
{
gpi_storeCurrentPayment(newInsertedAmount, uitmp, uit2); gpi_storeCurrentPayment(newInsertedAmount, uitmp, uit2);
//void gpi_storeCurrentPayment(uint32_t insertedAmount, uint16_t lastCoinType, uint16_t lastCoinValue)
if (newInsertedAmount != lastInsertedAmount) if (newInsertedAmount != lastInsertedAmount)
{ {
emit datif_gotNewCoin(); emit datif_gotNewCoin();
//qDebug()<<"emit new coin";
lastInsertedAmount=newInsertedAmount; lastInsertedAmount=newInsertedAmount;
} }
qDebug()<<" store new coin"<<newInsertedAmount<<" "<<uitmp<<" "<<uit2;
}
break; break;
case 113: // get wake source, 8byte case 113: // get wake source, 8byte
@ -1477,6 +1554,9 @@ char T_datif::loadRecDataFromFrame()
outBuf[pBuf++]=0; outBuf[pBuf++]=0;
*/ */
if (RdDleng>40)
//datif_DCdataValid=1; // das hier sind die wichtigsten Daten, deshalb hierrein!
gpi_storeDcDataValid(1);
gpi_storeDynMachineConditions(RdDleng, receivedData); gpi_storeDynMachineConditions(RdDleng, receivedData);
@ -1577,7 +1657,13 @@ struct T_vaultRecord
gpi_storeVaultRecord(readAddress, receivedData ); // always 64byte gpi_storeVaultRecord(readAddress, receivedData ); // always 64byte
break; break;
case 39:
gpi_storeDynData(receivedData);
break;
} }
readSource=0; // 17.05.2023: to avoid multiple recording
return 0; return 0;
} }

943
src/datei.cpp Normal file
View File

@ -0,0 +1,943 @@
// written by Thomas Sax, Jan.2022
#include "datei.h"
// -------------------------------------------------------------------------------------------------
// ------------------------------------------------------ create csv file -------------------------------
// -------------------------------------------------------------------------------------------------
QByteArray datei_writeArray, datei_tempArray;
void csv_startCreatingFile(void)
{
datei_writeArray.clear();
datei_tempArray.clear();
}
void csv_addTextToFile(QString myText)
{
datei_writeArray.append(myText.toLatin1());
datei_writeArray.append(FILESEPERATOR);
}
void csv_addIntToFile(int myValue)
{
//qulonglong ullt=12345678901234567890; // max 1,844 x10^19
datei_tempArray.setNum(myValue,10); // accepted types: short, ushort, int, uint,
// qlonglong, qulonglong, float, double
// numerbase can be 2...36(!),10=dec
datei_writeArray.append(datei_tempArray);
datei_writeArray.append(FILESEPERATOR);
}
void csv_addUintToFile(uint myValue)
{
datei_tempArray.setNum(myValue,10);
datei_writeArray.append(datei_tempArray);
datei_writeArray.append(FILESEPERATOR);
}
void csv_addLongvalToFile(qlonglong myValue)
{
datei_tempArray.setNum(myValue,10);
datei_writeArray.append(datei_tempArray);
datei_writeArray.append(FILESEPERATOR);
}
void csv_addUlongvalToFile(qulonglong myValue)
{
datei_tempArray.setNum(myValue,10);
datei_writeArray.append(datei_tempArray);
datei_writeArray.append(FILESEPERATOR);
}
/*
void csv_addCurrentTimeToFile(void)
{
uint8_t hour, minute, sec, ui8buf[20];
char buf[20];
config_getSysTime(&hour, &minute, &sec);
GetTimeString(hour, minute, sec, 0, 1, ui8buf);
for (uint8_t nn=0; nn<20; nn++)
buf[nn]=char(ui8buf[nn]);
datei_writeArray.append(buf,8); // time string
datei_writeArray.append(FILESEPERATOR);
}
void csv_addCurrentDateToFile(void)
{
uint16_t year;
uint8_t month, day, ui8buf[20];
char buf[20];
config_getSystemDate(&year, &month, &day);
//qDebug()<<"date year: "<<year;
GetDateString(day, month, 0x20, uint8_t(year%100), 0, 0, ui8buf);
for (uint8_t nn=0; nn<20; nn++)
buf[nn]=char(ui8buf[nn]);
datei_writeArray.append(buf, 10); // date string
datei_writeArray.append(NEWLINEINFILE);
}
*/
void csv_addNewlineToFile(void)
{
datei_writeArray.chop(1); // Komma weg
datei_writeArray.append(NEWLINEINFILE);
}
QByteArray csv_readbackArray(void)
{
return datei_writeArray;
}
/*
QByteArray csv_writeContent_testValues(void)
{
QByteArray myBA, tmpBA;
uint8_t modCount=5, modAddr=23;
uint8_t hour, minute, sec, month, day, ui8buf[20];
uint16_t year, modType=45678;
char buf[20];
uint32_t modNrDIs=1234567890;
uint8_t modNrAIs=4, modNrCtr=2, modNrDOs=8;
int modNrAOs=-2;
myBA.clear();
tmpBA.clear();
myBA.append("scan time");
myBA.append(FILESEPERATOR);
datei_getSysTime(&hour, &minute, &sec);
GetTimeString(hour, minute, sec, 0, 1, ui8buf);
for (uint8_t nn=0; nn<20; nn++)
buf[nn]=char(ui8buf[nn]);
myBA.append(buf,8); // time string
myBA.append(FILESEPERATOR);
datei_getSystemDate(&year, &month, &day);
//qDebug()<<"date year: "<<year;
GetDateString(day, month, 0x20, uint8_t(year%100), 0, 0, ui8buf);
for (uint8_t nn=0; nn<20; nn++)
buf[nn]=char(ui8buf[nn]);
myBA.append(buf, 10); // date string
myBA.append(NEWLINEINFILE);
myBA.append("number of modules");
myBA.append(FILESEPERATOR);
tmpBA.setNum(modCount,10); //2nd para = number base 2, 8, 10 or 16 (bin, oct, dec, hex)
myBA.append(tmpBA);
myBA.append(NEWLINEINFILE);
myBA.append("busaddr");
myBA.append(FILESEPERATOR);
myBA.append("type");
myBA.append(FILESEPERATOR);
myBA.append("NrOfDI");
myBA.append(FILESEPERATOR);
myBA.append("NrOfAI");
myBA.append(FILESEPERATOR);
myBA.append("NrOfCtrIn");
myBA.append(FILESEPERATOR);
myBA.append("NrOfDO");
myBA.append(FILESEPERATOR);
myBA.append("NrOfAO");
myBA.append(NEWLINEINFILE);
tmpBA.setNum(modAddr,10);
myBA.append(tmpBA);
myBA.append(FILESEPERATOR);
tmpBA.setNum(modType,10);
myBA.append(tmpBA);
myBA.append(FILESEPERATOR);
tmpBA.setNum(modNrDIs,10);
myBA.append(tmpBA);
myBA.append(FILESEPERATOR);
tmpBA.setNum(modNrAIs,10);
myBA.append(tmpBA);
myBA.append(FILESEPERATOR);
tmpBA.setNum(modNrCtr,10);
myBA.append(tmpBA);
myBA.append(FILESEPERATOR);
tmpBA.setNum(modNrDOs,10);
myBA.append(tmpBA);
myBA.append(FILESEPERATOR);
tmpBA.setNum(modNrAOs,10);
myBA.append(tmpBA);
myBA.append(NEWLINEINFILE);
return myBA;
}
*/
// -------------------------------------------------------------------------------------------------
// ------------------------------------------------------ parse csv file -------------------------------
// -------------------------------------------------------------------------------------------------
// first: QByteArray datei_readFromFile(QString filename);
uint32_t csv_nrOfEntriesInFile(QByteArray readFromFile)
{
// count sequences between FILESEPERATOR and NEWLINEINFILE
uint32_t filSize=0, pp=0;
char oneByt=0;
int filLen=readFromFile.size();
if(filLen>1)
filSize=uint32_t(filLen);
else
return 0;
// 1) find position of seperators
for (uint32_t ii=0; ii<filSize; ii++)
{
oneByt=readFromFile[ii];
if (oneByt==FILESEP1 || oneByt==FILESEP2 || oneByt==NEWLINEINFILE)
pp++;
}
// now: pp = number of seperators
// oneByt = last byte in file. If it's not a seperator then
// there's one more entry (last entry without termination)
if (oneByt !=FILESEP1 && oneByt !=FILESEP2 && oneByt !=NEWLINEINFILE)
pp++;
//qDebug()<<"csv: nr of sequences="<< pp;
return pp;
}
QByteArray csv_getOneFileSequence(QByteArray sourceFile, uint32_t sequNr)
{
// seperate file content in single sequences between FILESEPERATOR and NEWLINEINFILE
// and return "entryNr" - entry
// for this first step leave data type QByteArray
// 2nd step can change in numbers and strings
QByteArray sequence;
uint32_t sepPos[MAXNUMBEROFSEQUENCES];
uint32_t filSize=0, pp=0, ii, start=0, ende=0;
char oneByt;
int filLen, mm;
filLen=sourceFile.size();
//qDebug()<<"fillen="<< filLen;
if(filLen<10)
return "";
filSize=uint32_t(filLen);
if (sequNr>MAXNUMBEROFSEQUENCES)
return "";
// 1) find position of seperators
for (ii=0; ii<filSize; ii++)
{
oneByt=sourceFile[ii];
if (oneByt==FILESEP1 || oneByt==FILESEP2 || oneByt==NEWLINEINFILE)
{
sepPos[pp++]=ii;
}
}
// now: pp = number of entries
//qDebug()<<"nr of seperators="<< pp;
if (sequNr>=pp)
return "";
// 2) get sequence
if (sequNr==0)
{
start=0;
ende=sepPos[sequNr];
} else
if (sequNr>0)
{
start=sepPos[sequNr-1]+1;
ende=sepPos[sequNr];
}
//qDebug()<<"datei getOneFileSequence start/ende: "<<start << " " << ende;
if (start>=ende)
return "";
//return "-err3-";
sequence.clear();
//batmp.clear();
pp=0;
for (ii=start; ii<ende; ii++)
{
mm=int(ii);
if (mm>=int(filSize))
mm=0;
oneByt=sourceFile.at(mm);
sequence.append(oneByt);
}
return sequence;
}
int csv_getEntryAsInt(QByteArray sourceFile, uint32_t sequNr)
{
QByteArray myBA, myVA;
int entry=0;
bool ok;
myVA.clear();
myBA = csv_getOneFileSequence(sourceFile, sequNr);
//qDebug()<<"datei getEntryAsInt, sequence: " << myBA;
entry=myBA.toInt(&ok,16);
if (ok)
{
//qDebug()<<"datei getEntryAsInt, number: " << entry;
return entry;
}
//qDebug()<<"datei getEntryAsInt, error " << myBA;
return 0;
}
int32_t csv_getEntryAsLong(QByteArray sourceFile, uint32_t sequNr)
{
QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
long entry=0;
bool ok;
entry=myBA.toLong(&ok,10);
if (ok)
return entry;
return 0;
}
uint8_t csv_getEntryAsUshort(QByteArray sourceFile, uint32_t sequNr)
{
QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
uint8_t entry=0;
bool ok;
entry=uint8_t(myBA.toUShort(&ok,10));
if (ok)
return entry;
return 0;
}
uint16_t csv_getEntryAsUint(QByteArray sourceFile, uint32_t sequNr)
{
QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
uint16_t entry=0;
bool ok;
entry=uint16_t(myBA.toUInt(&ok,10));
if (ok)
return entry;
return 0;
}
uint32_t csv_getEntryAsUlong(QByteArray sourceFile, uint32_t sequNr)
{
QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
uint32_t entry=0;
bool ok;
entry=myBA.toULong(&ok,10);
if (ok)
return entry;
return 0;
}
uint64_t csv_getEntryAs2Ulong(QByteArray sourceFile, uint32_t sequNr)
{
QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
uint64_t entry=0;
bool ok;
entry=myBA.toULongLong(&ok,10);
if (ok)
return entry;
return 0;
}
QString csv_getEntryAsString(QByteArray sourceFile, uint32_t sequNr)
{
QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
QString entry;
//qDebug()<<"datei getEntryAsString, sequence: " << myBA;
entry=myBA.toStdString().c_str();
return entry;
}
// -------------------------------------------------------------------------------------------------
// ------------------------------------------------------ create Json file -------------------------------
// -------------------------------------------------------------------------------------------------
/*
example
QString str = "{"
" \"Herausgeber\": \"Xema\","
" \"Nummer\": \"1234-5678-9012-3456\","
" \"Deckung\": 2e+6,"
" \"Währung\": \"EURO\","
" \"Inhaber\": {"
" \"Name\": \"Mustermann\","
" \"Vorname\": \"Max\","
" \"männlich\": true,"
" \"Hobbys\": [ \"Reiten\", \"Golfen\", \"Lesen\" ],"
" \"Alter\": 42,"
" \"Kinder\": [],"
" \"Partner\": null"
" }"
"}";
*/
QString myJsonCon;
QString tmpStr;
void json_startRecord(void)
{
myJsonCon.clear();
tmpStr.clear();
myJsonCon.append('{');
}
void json_enterIntToRecord(QString attribute, ulong i_value)
{
tmpStr.clear();
myJsonCon.append('"');
myJsonCon.append(attribute);
myJsonCon.append('"');
myJsonCon.append(':');
tmpStr.setNum(i_value);
myJsonCon.append(tmpStr);
myJsonCon.append(',');
myJsonCon.append(NEWLINEINFILE);
}
void json_enterTextToRecord(QString attribute, QString txt_value)
{
myJsonCon.append('"');
myJsonCon.append(attribute);
myJsonCon.append('"');
myJsonCon.append(':');
myJsonCon.append('"');
myJsonCon.append(txt_value);
myJsonCon.append('"');
myJsonCon.append(',');
myJsonCon.append(NEWLINEINFILE);
}
/*
void json_addCurrentTimeToRecord(QString attribute)
{
uint8_t hour, minute, sec, ui8buf[20];
//char buf[20];
myJsonCon.append('"');
myJsonCon.append(attribute);
myJsonCon.append('"');
myJsonCon.append(':');
myJsonCon.append('"');
datei_getSysTime(&hour, &minute, &sec);
GetTimeString(hour, minute, sec, 0, 1, ui8buf);
for (uint8_t nn=0; nn<8; nn++)
myJsonCon.append(ui8buf[nn]);
myJsonCon.append('"');
myJsonCon.append(',');
myJsonCon.append(NEWLINEINFILE);
}
void json_addCurrentDateToRecord(QString attribute)
{
uint16_t year;
uint8_t month, day, ui8buf[20];
//char buf[20];
myJsonCon.append('"');
myJsonCon.append(attribute);
myJsonCon.append('"');
myJsonCon.append(':');
myJsonCon.append('"');
datei_getSystemDate(&year, &month, &day);
GetDateString(day, month, 0x20, uint8_t(year%100), 0, 0, ui8buf);
for (uint8_t nn=0; nn<10; nn++)
myJsonCon.append(ui8buf[nn]);
myJsonCon.append('"');
myJsonCon.append(',');
myJsonCon.append(NEWLINEINFILE);
}
*/
void json_enterArrayToRecord(QString attribute, uint8_t *buf, ulong nrofVals)
{
// add array of numbers with "nrofVals" elements
myJsonCon.append('"');
myJsonCon.append(attribute);
myJsonCon.append('"');
myJsonCon.append(':');
myJsonCon.append('['); // eckig!!!
for (ulong ul=0; ul<nrofVals; ul++)
{
tmpStr.setNum(buf[ul]);
myJsonCon.append(tmpStr);
myJsonCon.append(',');
}
myJsonCon.chop(1); // Komma weg
myJsonCon.append(']'); // eckig!!!
myJsonCon.append(',');
myJsonCon.append(NEWLINEINFILE);
}
void json_enterStructToRecord(QString attribute)
{
// every call must be concluded with "json_finishFile()"
myJsonCon.append('"');
myJsonCon.append(attribute);
myJsonCon.append('"');
myJsonCon.append(':');
myJsonCon.append('{'); // geschweift!!
myJsonCon.append(NEWLINEINFILE);
}
void json_finishStruct(void)
{
myJsonCon.chop(2); // remove , and \r from the end
myJsonCon.append('}');
myJsonCon.append(',');
myJsonCon.append(NEWLINEINFILE);
}
void json_finishRecord(void)
{
myJsonCon.chop(2); // remove , and \r from the end
myJsonCon.append(NEWLINEINFILE);
myJsonCon.append('}');
myJsonCon.append(NEWLINEINFILE);
}
QString json_readbackRecordStr(void)
{
return myJsonCon;
}
QByteArray json_readbackRecordBa(void)
{
return myJsonCon.toLatin1();
}
// -------------------------------------------------------------------------------------------------
// ------------------------------------------------------ parse Json file -------------------------------
// -------------------------------------------------------------------------------------------------
/*
example Json File:
{"temperature":28,
"snow":"no",
"Zeit":"16_21_45",
"sunny":"12h",
"humidity":75,
"wann ":"24.01.2022",
"unterstruktur":{
"day of week":"tuesday",
"year":22,
"month":1,
"day":24},
"fast am":"Ende",
"Puffer":[8,3,9,2,10]
}
*/
// first: QByteArray datei_readFromFile(QString filename);
int json_nrOfPairsInFile(QByteArray filename)
{
QJsonDocument jdoc = QJsonDocument::fromJson(filename);
QJsonObject jobj = jdoc.object();
// key value pair consisting of key (unique string) and value (QJsonValue)
int nrOfPairs=jobj.size();
qDebug() << "my Json file has got: " << nrOfPairs<< "pairs";
return nrOfPairs;
}
bool json_exists(QByteArray filename, QString searchForKey)
{
// look for "searchForKey" =name of the pair (left of : )
QJsonDocument jdoc = QJsonDocument::fromJson(filename);
QJsonObject jobj = jdoc.object();
if (jobj.contains(searchForKey))
return true;
return false;
}
bool json_remove(QByteArray filename, QString searchFor)
{
// look for "searchFor" =name of the pair (left of : ) and remove the record from file
QJsonDocument jdoc = QJsonDocument::fromJson(filename);
QJsonObject jobj = jdoc.object();
if (jobj.contains(searchFor))
{
jobj.remove(searchFor);
return true;
}
return false;
}
QString json_searchForStringInFile(QByteArray filename, QString searchFor)
{
// look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
QJsonDocument jdoc = QJsonDocument::fromJson(filename);
QJsonObject jobj = jdoc.object();
if (jobj.contains(searchFor))
{
return jobj[searchFor].toString(); // toObject(); toArray();
} else
{
//qDebug() << "pairname not found in Json file";
return "";
}
}
int json_searchForIntInFile(QByteArray filename, QString searchFor)
{
// look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
QJsonDocument jdoc = QJsonDocument::fromJson(filename);
QJsonObject jobj = jdoc.object();
if (jobj.contains(searchFor))
{
return jobj[searchFor].toInt(); // toObject(); toArray();
} else
{
//qDebug() << "number not found in Json file";
return 0;
}
}
bool json_searchForObjectInFile(QByteArray filename, QString searchFor, QJsonObject *oneObject)
{
// return an object from the json file
QJsonDocument jdoc = QJsonDocument::fromJson(filename);
QJsonObject jobj = jdoc.object();
if (jobj.contains(searchFor))
{
*oneObject = jobj[searchFor].toObject();
return true;
} else
{
//qDebug() << "Object not found in Json file";
return false;
}
}
int json_nrOfPairsInObject(QJsonObject objname)
{
int nrOfPairs=objname.size();
qDebug() << "my Json Object has got: " << nrOfPairs<< "pairs";
return nrOfPairs;
}
QString json_searchForStringInObject(QJsonObject objname, QString searchFor)
{
// look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
if (objname.contains(searchFor))
{
return objname[searchFor].toString();
} else
{
//qDebug() << "string not found in Json object";
return "";
}
}
int json_searchForIntInObject(QJsonObject objname, QString searchFor)
{
// look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
if (objname.contains(searchFor))
{
return objname[searchFor].toInt();
} else
{
//qDebug() << "number not found in Json file";
return 0;
}
}
bool json_searchForArrayInFile(QByteArray filename, QString searchFor, QJsonArray *oneArray)
{
// look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
QJsonDocument jdoc = QJsonDocument::fromJson(filename);
QJsonObject jobj = jdoc.object();
if (jobj.contains(searchFor))
{
*oneArray = jobj[searchFor].toArray();
return true;
} else
{
//qDebug() << "Array not found in Json file";
return false;
}
}
int json_nrOfValuesInArray(QJsonArray arrayname)
{
int nrOfPairs=arrayname.size();
qDebug() << "my Json Array has got: " << nrOfPairs<< "values";
return nrOfPairs;
}
bool json_getValuesOfArray(QJsonArray arrayname, int *buf, int MaxBufferSize)
{
// assuming that the array consists of integers
/* copy to local buffer:
#define MAXNROFARRAYVALUES 100
int buf[MAXNROFARRAYVALUES], ii;
int nrOfPairs=arrayname.size();
if (nrOfPairs>MAXNROFARRAYVALUES)
nrOfPairs=MAXNROFARRAYVALUES;
for (ii=0; ii<nrOfPairs; ii++)
buf[ii]=arrayname[ii].toInt();
*/
// copy to host buffer:
bool ok=true;
int nrOfPairs=arrayname.size();
if (nrOfPairs>MaxBufferSize)
{
ok=false; // got not all
nrOfPairs=MaxBufferSize;
}
for (int ii=0; ii<nrOfPairs; ii++)
buf[ii]=arrayname[ii].toInt();
return ok;
}
/*
void datei_json_readTestFile(QString filename)
{
QByteArray my2Ba;
QString my2Str;
my2Str.clear();
my2Ba=datei_readFromFile(filename);
QJsonDocument jdoc = QJsonDocument::fromJson(my2Ba);
QJsonObject jobj = jdoc.object();
//QJsonParseError jerror;
QJsonObject myObj;
QJsonArray myArray;
// key value pair consisting of key (unique string) and value (QJsonValue)
int nrOfPairs=jobj.size();
qDebug() << "my Json file has got: " << nrOfPairs<< "pairs";
if (jobj.contains("Zeit"))
qDebug() << "my Json file: " << jobj["Zeit"].toString(); // toObject(); toArray();
else
qDebug() << "my Json file contains no Zeit";
if (jobj.contains("Humidity"))
qDebug() << "my Json file: " << jobj["humidity"].toInt();
else
qDebug() << "my Json file contains no Humidity";
if (jobj.contains("month"))
qDebug() << "my Json file: " << jobj["month"].toObject(); // anzeige QJsonObject()
else
qDebug() << "my Json file contains no month";
myObj=jobj["unterstruktur"].toObject();
qDebug() << "my unterstruktur: " << myObj["month"].toInt();
qDebug() << "my unterstruktur: " << myObj["day of week"].toString();
//if (jerror.error == QJsonParseError::NoError)
// qDebug() << "no error";
qDebug() << "my Month: " << myObj["Month"].toInt();
//if (myObj["Month"] == QJsonValue::Undefined)
// qDebug() << "no found"; geht nicht
//if (jerror.error != QJsonParseError::NoError)
// qDebug() << "no found";
myArray=jobj["Puffer"].toArray();
qDebug() << "my array " <<myArray[2].toInt();
//if (jerror.error != QJsonParseError::NoError)
// qDebug() << "no found";
if ( !jobj.contains("Puffer"))
qDebug() << "no Puffer found";
if ( !myArray.contains(20))
qDebug() << "no entry found";
} */
// -------------------------------------------------------------------------------------------------
// ------------------------------------------------------ read, write, copy files -------------------
// -------------------------------------------------------------------------------------------------
void datei_closeFile(QString filename)
{
QFile file(filename);
file.close();
}
QByteArray datei_readFromFile(QString filename)
{
//QFile file("/own/H2B/dc2.hex");
//QFile file(FILENAME_STRUCTURE);
QFile file;
file.setFileName(filename);
QByteArray myBA;
myBA.clear();
if (!file.exists())
{
qDebug()<<"file not exists";
return myBA;
} else
{
if (!file.open(QIODevice::ReadOnly) )
{
qDebug()<<"cannot open";
} else
{
//qDebug()<<"loading file with " << file.size() <<"byte";
myBA = file.readAll();
//qDebug()<<"datei read: " << myBA;
file.close();
}
}
return myBA;
}
bool datei_ifFileExists(QString filename)
{
QFile file;
file.setFileName(filename);
if (file.exists())
return true;
return false;
}
char datei_writeToFile(QString filename, QByteArray content)
{
// retval=0 if successful 1: no write access allowed 2:cannot open to append 3:cannot create new file
QFile file(filename);
QFileInfo myFI(filename);
//if (!myFI.isWritable()) //geht nur bei NTFS, weg.
//{
//file.setPermissions(filename, QFile::WriteOther); geht nicht :(
// qDebug()<<"datei_writeToFile: writing not allowed. set attributes first!";
// return 1;
//}
if (file.exists())
{
if (!file.open(QIODevice::Append))
{
qDebug()<<"datei_writeToFile cannot open to append";
return 2;
} else
{
// add new object to the end of the file
file.write(content);
file.close();
return 0; // OK
}
} else
{
if (!file.open(QIODevice::WriteOnly))
{
qDebug()<<"datei_writeToFile cannot open new";
return 3;
} else
{
qDebug()<<"create new file";
// write first lines into file
file.write(content);
file.close();
return 0; // OK
}
}
return 0;
}
bool datei_copyFile(QString currentFileName, QString newFileName)
{
// retval=true if successful
QFile file;
file.setFileName(currentFileName);
return file.copy(newFileName);
}
bool datei_clearFile(QString filename)
{
// retval=true if successful
QFile file;
file.setFileName(filename);
file.remove(); // 3.2.22 erst ganz löschen wegen Schreibrechten
if (!file.open(QIODevice::WriteOnly))
{
qDebug()<<"datei_clearFile cannot open file to delete";
return false;
} else
{
file.write(0);
file.close();
return true;
}
}

File diff suppressed because it is too large Load Diff

9
src/main.cpp Normal file
View File

@ -0,0 +1,9 @@
#include <QCoreApplication>
#include "tslib.h"
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
return a.exec();
}

View File

@ -14,7 +14,7 @@ void sendWRcmd_INI(void)
sendWRcmd_clrCmdStack(); sendWRcmd_clrCmdStack();
sendWRcmd_clrCmd4Stack(); sendWRcmd_clrCmd4Stack();
sendFDcmd_clrStack(); sendFDcmd_clrStack();
longFDcmd_clrStack();
} }
// Command Stack for commands without parameters // Command Stack for commands without parameters
@ -456,18 +456,23 @@ uint8_t gpi_chk4remainingText(void)
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
// 11.4.23 neu, Kommando direkt an "FastDevice"-protokoll senden, nicht mehr umsetzen // 11.4.23 neu, Kommando direkt an "FastDevice"-protokoll senden, nicht mehr umsetzen
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
// header
// short command, 4 data bytes
static uint8_t nextFDwrCmd[FDCMD_STACKDEPTH]; static uint8_t nextFDwrCmd[FDCMD_STACKDEPTH];
static uint8_t nextFDrdCmd[FDCMD_STACKDEPTH]; static uint8_t nextFDrdCmd[FDCMD_STACKDEPTH];
static uint8_t nextFDblkNr[FDCMD_STACKDEPTH]; static uint8_t nextFDblkNr[FDCMD_STACKDEPTH];
static uint8_t nextFDshort[FDCMD_STACKDEPTH];
// short data
static uint8_t nextFDpara1[FDCMD_STACKDEPTH]; static uint8_t nextFDpara1[FDCMD_STACKDEPTH];
static uint8_t nextFDpara2[FDCMD_STACKDEPTH]; static uint8_t nextFDpara2[FDCMD_STACKDEPTH];
static uint8_t nextFDpara3[FDCMD_STACKDEPTH]; static uint8_t nextFDpara3[FDCMD_STACKDEPTH];
static uint8_t nextFDpara4[FDCMD_STACKDEPTH]; static uint8_t nextFDpara4[FDCMD_STACKDEPTH];
// lon data:
static uint8_t longFDlength[FDCMD_STACKDEPTH];
static uint8_t longFDpara[FDCMD_STACKDEPTH][64];
static uint8_t p_nextFDcmdsInQueue; static uint8_t p_nextFDcmdsInQueue;
/* convention: use simple (not rotating) FIFO Stack: /* convention: use simple (not rotating) FIFO Stack:
Example: nrOfCmdsInQueue=4 then Example: nrOfCmdsInQueue=4 then
nextAsynchsendCmd0[0]=cmd1 // was stored as first nextAsynchsendCmd0[0]=cmd1 // was stored as first
@ -492,16 +497,21 @@ void sendFDcmd_clrStack(void)
nextFDwrCmd[nn]=0; nextFDwrCmd[nn]=0;
nextFDrdCmd[nn]=0; nextFDrdCmd[nn]=0;
nextFDblkNr[nn]=0; nextFDblkNr[nn]=0;
nextFDshort[nn]=0;
nextFDpara1[nn]=0; nextFDpara1[nn]=0;
nextFDpara2[nn]=0; nextFDpara2[nn]=0;
nextFDpara3[nn]=0; nextFDpara3[nn]=0;
nextFDpara4[nn]=0; nextFDpara4[nn]=0;
longFDlength[nn]=0;
memset(&longFDpara[nn][0],0,64);
} }
p_nextFDcmdsInQueue=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) 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 // write Command to memory, wait for transport
if (p_nextFDcmdsInQueue>=FDCMD_STACKDEPTH) if (p_nextFDcmdsInQueue>=FDCMD_STACKDEPTH)
{ {
@ -518,13 +528,68 @@ bool sendFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8
//qDebug() << "data with 4 data byte saved, pp=" << nrOfCmds4InQueue; //qDebug() << "data with 4 data byte saved, pp=" << nrOfCmds4InQueue;
//qDebug() << " dat1=" << nextCmd4para1[nrOfCmds4InQueue] << " dat2=" << nextCmd4para2[nrOfCmds4InQueue] //qDebug() << " dat1=" << nextCmd4para1[nrOfCmds4InQueue] << " dat2=" << nextCmd4para2[nrOfCmds4InQueue]
// << " dat3=" << nextCmd4para3[nrOfCmds4InQueue] << " dat4=" << nextCmd4para4[nrOfCmds4InQueue]; // << " dat3=" << nextCmd4para3[nrOfCmds4InQueue] << " dat4=" << nextCmd4para4[nrOfCmds4InQueue];
nextFDshort[p_nextFDcmdsInQueue]=1; // 1=short
p_nextFDcmdsInQueue++;
/*
int nn;
if (p_nextFDcmdsInQueue==2)
{
qDebug() << "sendFDcmd_set, stack has 2 elements: " << p_nextFDcmdsInQueue;
for (nn=0; nn<16; nn++)
{
qDebug() << "header: " << nextFDwrCmd[nn] << " / " << nextFDrdCmd[nn] << " / "<< nextFDblkNr[nn] << " / " << nextFDshort[nn];
}
}
*/
/*
if (p_nextFDcmdsInQueue>15)
{
qDebug() << "sendFDcmd_set, stack is full now: " << p_nextFDcmdsInQueue;
for (nn=0; nn<16; nn++)
{
qDebug() << "header: " << nextFDwrCmd[nn] << " / " << nextFDrdCmd[nn] << " / "<< nextFDblkNr[nn] << " / " << nextFDpara1[nn] << " / " << nextFDpara2[nn] << " / " << nextFDpara3[nn] << " / " << nextFDpara4[nn];
qDebug() << " long data: " << nextFDshort[nn] << " / "<< longFDlength[nn] << " / "<< longFDpara[nn][0] << " / "<< longFDpara[nn][1]
<< " / "<< longFDpara[nn][2] << " / "<< longFDpara[nn][3] << " / "<< longFDpara[nn][4];
}
}
*/
return true; // ok, will be sent
}
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_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;
longFDlength[p_nextFDcmdsInQueue]=length;
for (nn=0; nn<64; nn++)
longFDpara[p_nextFDcmdsInQueue][nn]=data[nn];
nextFDshort[p_nextFDcmdsInQueue]=2;
p_nextFDcmdsInQueue++; p_nextFDcmdsInQueue++;
return true; // ok, will be sent 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) 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; uint8_t nn, ll, mm;
if (p_nextFDcmdsInQueue==0 || p_nextFDcmdsInQueue>FDCMD_STACKDEPTH) if (p_nextFDcmdsInQueue==0 || p_nextFDcmdsInQueue>FDCMD_STACKDEPTH)
return false; // not possible return false; // not possible
@ -536,7 +601,7 @@ bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, ui
*dat2=nextFDpara2[0]; *dat2=nextFDpara2[0];
*dat3=nextFDpara3[0]; *dat3=nextFDpara3[0];
*dat4=nextFDpara4[0]; *dat4=nextFDpara4[0];
//qDebug() << "cmd4 restored to send from [0]; pp=" << nrOfCmds4InQueue; //qDebug() << "sendFDcmd_get [0]; pp=" << p_nextFDcmdsInQueue;
//qDebug() << " data1: " << nextCmd4para1[0] << " data2: " << nextCmd4para2[0] << //qDebug() << " data1: " << nextCmd4para1[0] << " data2: " << nextCmd4para2[0] <<
// " data3: " << nextCmd4para3[0] << " data4: " << nextCmd4para4[0]; // " data3: " << nextCmd4para3[0] << " data4: " << nextCmd4para4[0];
@ -550,17 +615,74 @@ bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, ui
nextFDwrCmd[nn]=nextFDwrCmd[nn+1]; nextFDwrCmd[nn]=nextFDwrCmd[nn+1];
nextFDrdCmd[nn]=nextFDrdCmd[nn+1]; nextFDrdCmd[nn]=nextFDrdCmd[nn+1];
nextFDblkNr[nn]=nextFDblkNr[nn+1]; nextFDblkNr[nn]=nextFDblkNr[nn+1];
nextFDpara1[nn]=nextFDpara1[nn+1]; nextFDpara1[nn]=nextFDpara1[nn+1];
nextFDpara2[nn]=nextFDpara2[nn+1]; nextFDpara2[nn]=nextFDpara2[nn+1];
nextFDpara3[nn]=nextFDpara3[nn+1]; nextFDpara3[nn]=nextFDpara3[nn+1];
nextFDpara4[nn]=nextFDpara4[nn+1]; nextFDpara4[nn]=nextFDpara4[nn+1];
nextFDshort[nn] = nextFDshort[nn+1];
longFDlength[nn] = longFDlength[nn+1];
for (mm=0; mm<64; mm++)
longFDpara[nn][mm] = longFDpara[nn+1][mm];
} }
if (p_nextFDcmdsInQueue>0) if (p_nextFDcmdsInQueue>0)
p_nextFDcmdsInQueue--; p_nextFDcmdsInQueue--;
//qDebug() << "cmd4 after push down: pp=" << nrOfCmds4InQueue; //qDebug() << "cmd4 after push down: pp=" << nrOfCmds4InQueue;
// clear released buffer:
for (nn=p_nextFDcmdsInQueue; 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;
nextFDshort[nn]=0;
longFDlength[nn]=0;
for (mm=0; mm<64; mm++)
longFDpara[nn][mm] = 0;
}
/*
qDebug() << "sendFDcmd_set, stack now: " << p_nextFDcmdsInQueue;
for (nn=0; nn<16; nn++)
{
qDebug() << "header: " << nextFDwrCmd[nn] << " / " << nextFDrdCmd[nn] << " / "<< nextFDblkNr[nn] << " / " << nextFDshort[nn];
qDebug() << " short data: " << nextFDpara1[nn] << " / "<< nextFDpara2[nn] << " / "<< nextFDpara3[nn]<< " / "<< nextFDpara4[nn];
qDebug() << " long data: " << longFDlength[nn] << " / "<< longFDpara[nn][0] << " / "<< longFDpara[nn][1]
<< " / "<< longFDpara[nn][2] << " / "<< longFDpara[nn][3] << " / "<< longFDpara[nn][4];
}
*/
return true; // ok, will be sent return true; // ok, will be sent
} }
uint8_t checkNextFDcmd(void)
{
// return 0: no command waiting
// 1: short cmd
// 2: long cmd
//qDebug() << "chk nxt fd cmd: "<<p_nextFDcmdsInQueue<<" "<<nextFDshort[0]<<" "<<nextFDshort[1]<<" "<<nextFDshort[2]<<" "<<nextFDshort[3];
if (p_nextFDcmdsInQueue==0)
return 0;
if (nextFDshort[0]==1)
return 1;
return 2;
}
uint8_t check4FDshortCmd(void) uint8_t check4FDshortCmd(void)
{ {
// returns number of waiting command, max FDCMD_STACKDEPTH // returns number of waiting command, max FDCMD_STACKDEPTH
@ -576,15 +698,15 @@ uint8_t check4freeFDshortCmd(void)
// long command, 64 data bytes // long command, 64 data bytes
static uint8_t longFDwrCmd[FDLONG_STACKDEPTH]; //static uint8_t longFDwrCmd[FDLONG_STACKDEPTH];
static uint8_t longFDrdCmd[FDLONG_STACKDEPTH]; //static uint8_t longFDrdCmd[FDLONG_STACKDEPTH];
static uint8_t longFDblkNr[FDLONG_STACKDEPTH]; //static uint8_t longFDblkNr[FDLONG_STACKDEPTH];
static uint8_t longFDlength[FDLONG_STACKDEPTH]; //static uint8_t longFDlength[FDLONG_STACKDEPTH];
static uint8_t longFDpara[FDLONG_STACKDEPTH][64];
static uint8_t p_longFDcmdsInQueue;
//static uint8_t longFDpara[FDLONG_STACKDEPTH][64];
//static uint8_t p_longFDcmdsInQueue;
/*
void longFDcmd_clrStack(void) void longFDcmd_clrStack(void)
{ {
uint8_t nn, mm; uint8_t nn, mm;
@ -598,66 +720,74 @@ void longFDcmd_clrStack(void)
longFDpara[nn][mm]=0; longFDpara[nn][mm]=0;
} }
p_longFDcmdsInQueue=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) bool longFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *length, uint8_t *data)
{ {
uint8_t nn, mm, ll; uint8_t nn, mm, ll;
//p_nextFDcmdsInQueue; nn<FDCMD_STACKDEPTH
if (p_longFDcmdsInQueue==0 || p_longFDcmdsInQueue>FDLONG_STACKDEPTH) if (p_nextFDcmdsInQueue==0 || p_nextFDcmdsInQueue>FDCMD_STACKDEPTH)
return false; // not possible return false; // not possible
*nextWrCmd= longFDwrCmd[0]; *nextWrCmd=nextFDwrCmd[0];
*nextRdCmd= longFDrdCmd[0]; *nextRdCmd=nextFDrdCmd[0];
*blockNum = longFDblkNr[0]; *blockNum=nextFDblkNr[0];
*length = longFDlength[0]; *length = longFDlength[0];
for (mm=0; mm<64; mm++) for (mm=0; mm<64; mm++)
data[mm] = longFDpara[0][mm]; data[mm] = longFDpara[0][mm];
// move Puffer down by one element // move Puffer down by one element
if (FDLONG_STACKDEPTH>0) if (FDCMD_STACKDEPTH>0)
ll=FDLONG_STACKDEPTH-1; ll=FDCMD_STACKDEPTH-1;
else else
ll=0; ll=0;
for (nn=0; nn<ll; nn++) for (nn=0; nn<ll; nn++)
{ {
longFDwrCmd[nn] = longFDwrCmd[nn+1]; nextFDwrCmd[nn]=nextFDwrCmd[nn+1];
longFDrdCmd[nn] = longFDrdCmd[nn+1]; nextFDrdCmd[nn]=nextFDrdCmd[nn+1];
longFDblkNr[nn] = longFDblkNr[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];
nextFDshort[nn] = nextFDshort[nn+1];
longFDlength[nn] = longFDlength[nn+1]; longFDlength[nn] = longFDlength[nn+1];
for (mm=0; mm<64; mm++) for (mm=0; mm<64; mm++)
longFDpara[nn][mm] = longFDpara[nn+1][mm]; longFDpara[nn][mm] = longFDpara[nn+1][mm];
} }
if (p_longFDcmdsInQueue>0) if (p_nextFDcmdsInQueue>0)
p_longFDcmdsInQueue--; p_nextFDcmdsInQueue--;
// clear released buffer:
for (nn=p_nextFDcmdsInQueue; 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;
nextFDshort[nn]=0;
longFDlength[nn]=0;
for (mm=0; mm<64; mm++)
longFDpara[nn][mm] = 0;
}
return true; // ok, will be sent return true; // ok, will be sent
} }
/*
uint8_t check4FDlongCmd(void) uint8_t check4FDlongCmd(void)
{ {
// returns number of waiting command // returns number of waiting command
@ -669,5 +799,33 @@ uint8_t check4freeFDlongCmd(void)
// returns number of free places in command stack // returns number of free places in command stack
return FDLONG_STACKDEPTH - p_longFDcmdsInQueue; 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

@ -9,16 +9,23 @@
// macro will be defined. -> we use SystemV shared memory // macro will be defined. -> we use SystemV shared memory
#error "QT_POSIX_IPC defined" #error "QT_POSIX_IPC defined"
#else #else
#ifdef __linux__
#include <sys/ipc.h> // ftok #include <sys/ipc.h> // ftok
#endif #endif
#endif
// std::atomic_bool SharedMemBuffer::__sharedMemLocked{false}; // std::atomic_bool SharedMemBuffer::__sharedMemLocked{false};
QSharedMemory *SharedMemBuffer::getShm(std::size_t size) { QSharedMemory *SharedMemBuffer::getShm(std::size_t size) {
static QSharedMemory shMem; static QSharedMemory shMem;
if (size > 0) { if (size > 0) {
#ifdef __linux__
static const long nativeKey = ftok("/etc/os-release", 'H'); static const long nativeKey = ftok("/etc/os-release", 'H');
static const QString fkey = std::to_string(nativeKey).c_str(); static const QString fkey = std::to_string(nativeKey).c_str();
#else
static const QString fkey = "0123456?000=9";
#endif
shMem.setKey(fkey); shMem.setKey(fkey);
if (!shMem.isAttached()) { if (!shMem.isAttached()) {
if (shMem.create(size)) { if (shMem.create(size)) {

File diff suppressed because it is too large Load Diff