Compare commits

...

70 Commits

Author SHA1 Message Date
18ff5d42a7
Merge branch 'pu/integration' into pu/accountRequest 2023-06-19 16:41:08 +02:00
ac9486879e
Update interfaces.h (20230619_1623) 2023-06-19 16:40:12 +02:00
1467530e3c
Add debug output for account request 2023-06-19 16:27:20 +02:00
414dda009e
Proposal for getting account data from CAlib/DeviceController 2023-06-19 16:26:33 +02:00
74753ce644
Add utils-class for static utils methods 2023-06-19 15:07:05 +02:00
c4cbf89182
TEST: try to track currentCashState
... but this is currently useless because we can not detect overpayment
here.
2023-06-16 15:50:25 +02:00
0baad4689a
Add note about TODO: TicketNumber 2023-06-16 15:49:56 +02:00
a4a746658c
TEST: use QueuedConnection for hwapi signals 2023-06-16 11:21:24 +02:00
7e65c4feda
onPrinterDataPrepared: increase time for fake signal onPrinterFinishedOk 2023-06-16 11:17:38 +02:00
e236fc8bce
Update interfaces.h (20230616_08006_08006_08006_08006_08006_0800) 2023-06-16 11:14:30 +02:00
76e67dbbaa
Fix: return, if CashAgentLib could not be loaded 2023-06-16 10:53:27 +02:00
b52de16dbc
Workaround for CashAgent: onCashVendStopByMax()
Wait 500ms until we call hw->getInsertedAmount().
2023-06-15 18:49:59 +02:00
cade03b400
Log output from hw->getInsertedAmount() 2023-06-15 18:49:29 +02:00
7a9f837b88
Refactoring 2023-06-15 18:49:13 +02:00
b10e597e59
Workaround for CashAgent: send 'vend_failed()' on program start 2023-06-15 14:18:32 +02:00
4cc4247744
CashAgent: update errorCodes 2023-06-15 14:16:03 +02:00
59432735d0
CashAgent: changed name: CAmaster 2023-06-15 14:15:13 +02:00
1f0720e52b
Update interfaces.h 2023-06-15 13:45:19 +02:00
5f3e0babb1
Load CashAgentLib: print errorString if load fails 2023-06-15 10:54:32 +02:00
f2637e3af8
dc_autoRequest is allways switched on 2023-06-15 09:48:25 +02:00
ac6331e5a7
Update interfaces.h (20230615) 2023-06-15 09:47:17 +02:00
7ccbc8bb23
Proposal for requestAccount() (does not work)
... because of random signal from DeviceController.
... and wrong handling of DeviceController methods.
2023-06-14 14:38:24 +02:00
017543dd5b
Door Events: Update log outputs 2023-06-14 14:37:34 +02:00
d5d2b8917a
Add handling door events 2023-06-13 17:00:17 +02:00
9d686ae48d
Update DeviceControllerInterface (door events) 2023-06-13 16:59:20 +02:00
a037626d6d
Update interface.h (door events) 2023-06-13 16:58:17 +02:00
a3f32b576e
Set dateTime on plugin init 2023-06-12 09:51:34 +02:00
668b10e55d
Add interface for programmode switch 2023-06-12 09:51:16 +02:00
596cf3ed25
TicketPrint: select ticket to print
dependent on printingData.
2023-06-09 11:19:39 +02:00
c330be4f30
TicketPrint: use interface method 'prn_printKombiticket()'
... instead of printing templates.
2023-06-09 11:18:39 +02:00
3722dd4d28
Merge branch 'pu/use_cashAgentLib' into pu/integration 2023-06-06 10:14:42 +02:00
f5568f6f81
Add comment 2023-06-05 18:07:12 +02:00
98ef7b7b26
Send cashInputFinished(), when cash input is finished 2023-06-05 18:04:34 +02:00
2717c614e3
Update interface hwapi 3.6 2023-06-05 12:51:55 +02:00
de1dc88e51
Use CashAgentLib 2023-06-05 12:49:20 +02:00
50bf7e8b52
Add stubs for Account-Task 2023-06-01 16:30:50 +02:00
d8d315cd49
Update ATBAPP/DeviceControlllerInterface 2023-06-01 16:21:37 +02:00
84859064a3
Workaround: prevent signaling irregular coin inputs 2023-05-24 10:51:20 +02:00
ff4c52ddc9
Fix: remove debug output 2023-05-23 15:46:34 +02:00
f4be010e1a
Fix: set flag in datIf_cycleSend() 2023-05-23 15:45:18 +02:00
75b597586f
Remove dependency to QWidget / QMainWindow
This not GUI library!
2023-05-23 14:41:09 +02:00
88cc71e05f
Merge branch 'pu/coinIntegration_TS18052023' into pu/integration 2023-05-23 14:36:41 +02:00
6f00d5b356
Workaround: do not use printer signals...
... this signals are sent presumably after printing first template.
As we print currently 3 templates and we use this signals to create an
event in main application this lead to an error:
Subsequent DCPlugin operations failed sometimes because DC needs a time
gap between to operations.
2023-05-23 14:29:24 +02:00
1f9cc3b8c0
Add debug output 2023-05-23 10:23:04 +02:00
584e3af035
Start CashInput with UINT_MAX (PayUp) 2023-05-23 10:21:00 +02:00
2ac0f5b275
Delay printing ...
... printing day tickets need this delay
2023-05-23 10:17:46 +02:00
a97ef4ea04
SwitchOn dc feature autorequest
This is necessary for receiving coint input events
2023-05-22 11:21:08 +02:00
30d790b84f
Connect all hwapi signals 2023-05-22 11:20:28 +02:00
ca5e43e0d7
Add debug output 2023-05-19 15:34:28 +02:00
3ac91305d4
Fix: for load as plugin on target device 2023-05-19 15:33:52 +02:00
d0445949d2
Merge changes from T.Sax DC_plugin 18.5.23 2023-05-19 13:57:17 +02:00
91d9280a4a
Speed up ticket printing 2023-05-18 14:01:07 +02:00
48d6a34b16
ATBAPP: Rework for ticket printing 2023-05-18 11:57:54 +02:00
e32142cd62
Implement cash input interface 2023-05-04 14:28:38 +02:00
f611e07dcf
Implement printing ticket 2023-05-04 13:21:14 +02:00
6478eda581
TS: pr_printTemplate(): send 'longFDcmd_set()' 2023-05-03 13:19:01 +02:00
1663d09d3a
Merge with TS 21.04.23 2023-05-03 13:06:57 +02:00
080c00eda1
Set serialPort name from config 2023-05-02 17:39:38 +02:00
bbce2b02e3
Test printing ticket 2023-05-02 17:10:17 +02:00
8ff17a2e00
DeviceControllerInterface: erroCode is a string 2023-05-02 17:09:53 +02:00
c6574280ac
Project: including DCPlugin.pri globally 2023-05-02 10:08:16 +02:00
f0f0493d19
hwapi: remove unused dependency to QWidget 2023-05-02 10:07:42 +02:00
9bf99c5515
Fix: make plugin compile 2023-04-28 13:53:14 +02:00
8ff8faf007
Fix: warning 2023-04-19 16:55:38 +02:00
09a80498e4
Merge branch 'master' into pu/integration 2023-04-19 16:28:26 +02:00
01f8c1e49c
First compiling version for high level vending interface 2023-04-19 16:26:12 +02:00
3029b8da04
Rename TARGET name 2023-04-19 16:24:53 +02:00
2143801900
Configure project for PTU5-YOCTO 2023-04-18 17:07:28 +02:00
6f6d3b7491
Add atb/qt gitignore 2023-04-18 17:06:13 +02:00
4cfb8f1804
Add auto version generation script 2023-04-18 17:04:51 +02:00
34 changed files with 2729 additions and 17673 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

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

View File

@ -4,7 +4,7 @@ CONFIG += plugin
#CONFIG -= app_bundle #CONFIG -= app_bundle
#QT += widgets #QT += widgets
QT -= gui QT -= gui
QT += widgets serialport QT += serialport
INCLUDEPATH += $${PWD}/plugins INCLUDEPATH += $${PWD}/plugins
INCLUDEPATH += $${PWD}/include INCLUDEPATH += $${PWD}/include
@ -14,6 +14,7 @@ QMAKE_CXXFLAGS += -Wno-deprecated-copy
# default # default
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
@ -21,7 +22,6 @@ contains( CONFIG, DesktopLinux ) {
# 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
include(DCPlugin.pri)
} }
contains( CONFIG, PTU5 ) { contains( CONFIG, PTU5 ) {
@ -31,22 +31,23 @@ contains( CONFIG, PTU5 ) {
linux-clang { QMAKE_CXXFLAGS += -Qunused-arguments } linux-clang { QMAKE_CXXFLAGS += -Qunused-arguments }
CONFIG += link_pkgconfig CONFIG += link_pkgconfig
ARCH = PTU5 ARCH = PTU5
# NOTE: include contents of DCPlugin.pri. Also used by ATBQT.
# Add new files in DCPlugin.pri.
include(DCPlugin.pri)
} }
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
#LIBS += -lQt5Qmqtt #LIBS += -lQt5Qmqtt
} }
TARGET = CashAgentLib TARGET = ATBDeviceControllerPlugin
DESTDIR = ../plugins #DESTDIR = ../plugins
INTERFACE = DeviceController
INTERFACE_DEFINITION = $${PWD}/include/ATBAPP/DeviceControllerInterface.h
DEFINES += DEVICECONTROLLERPLUGIN_LIBRARY
# The following define makes your compiler emit warnings if you use # The following define makes your compiler emit warnings if you use
# any Qt feature that has been marked deprecated (the exact warnings # any Qt feature that has been marked deprecated (the exact warnings
@ -66,3 +67,30 @@ 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
# ATBAPP interface
HEADERS += \
include/interfaces.h \
src/ATBAPP/ATBAPPplugin.h \
src/ATBAPP/DeviceControllerInterface.h \
src/ATBAPP/ATBHealthEvent.h \
src/ATBAPP/ATBDeviceControllerPlugin.h \
src/ATBAPP/Utils.h
SOURCES += \
src/ATBAPP/ATBHealthEvent.cpp \
src/ATBAPP/ATBDeviceControllerPlugin.cpp \
src/ATBAPP/Utils.cpp
DISTFILES += \
generate-version.sh
# Define how to create version.h
VERSION_H = $$PWD/include/version.h
version.output = $$PWD/include/version.h
version.commands = $$PWD/generate-version.sh $${ARCH} $${TARGET} $${INTERFACE} $${INTERFACE_DEFINITION} $${VERSION_H}
version.depends = FORCE
version.input = VERSION_H
version.variable_out = HEADERS
QMAKE_EXTRA_COMPILERS += version
QMAKE_CLEAN += $${PWD}/include/version.h

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

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

View File

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

View File

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

View File

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

File diff suppressed because it is too large Load Diff

2966
include/interfaces.h Normal file → Executable file

File diff suppressed because it is too large Load Diff

View File

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

View File

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

View File

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

View File

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

View File

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

File diff suppressed because it is too large Load Diff

22
src/ATBAPP/ATBAPPplugin.h Normal file
View File

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

View File

@ -0,0 +1,684 @@
#include "src/ATBAPP/ATBDeviceControllerPlugin.h"
#include "src/ATBAPP/ATBHealthEvent.h"
#include "src/ATBAPP/Utils.h"
#include <QTimer>
#include <QTextCodec>
#include <QDebug>
#include <QPluginLoader>
#include <QDateTime>
#include <QFileInfo>
#include <cstdlib>
ATBDeviceControllerPlugin::ATBDeviceControllerPlugin(QObject *parent) : QObject(parent),
pluginState(PLUGIN_STATE::NOT_INITIALIZED)
{
this->pluginInfo = QString::fromUtf8(pluginInfoString.c_str());
if (!this->private_loadCashAgentLib("")) {
return;
}
//connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_templatePrintFinished_OK()), this, SLOT(onPrintFinishedOK()), Qt::QueuedConnection);
//connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_templatePrintFinished_Err()), this, SLOT(onPrintFinishedERR()), Qt::QueuedConnection);
connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_gotNewCoin()), this, SLOT(onCashGotCoin()), Qt::QueuedConnection);
connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByMax()), this, SLOT(onCashPayStopByMax()), Qt::QueuedConnection);
connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByEscrow()), this, SLOT(onCashPayStopByEscrow()), Qt::QueuedConnection);
connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByError()), this, SLOT(onCashPayStopByError()), Qt::QueuedConnection);
connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByTimeout()), this, SLOT(onCashPayStopByTimeout()), Qt::QueuedConnection);
connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorServiceDoorOpened()), this, SLOT(onServiceDoorOpened()), Qt::QueuedConnection); // switch to ModeSERVICE
connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorVaultDoorOpened()), this, SLOT(onVaultDoorOpened()), Qt::QueuedConnection); // Screen?? with message
connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorCoinBoxRemoved()), this, SLOT(onCoinBoxRemoved()), Qt::QueuedConnection); // Create/Send Account
connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorCoinBoxInserted()), this, SLOT(onCoinBoxInserted()), Qt::QueuedConnection);
//connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorCBinAndAllDoorsClosed()), this, SLOT( ??? )), Qt::QueuedConnection);
connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorAllDoorsClosed()), this, SLOT(onAllDoorsClosed()), Qt::QueuedConnection); // check for errors, switch to mode IDLE
this->currentSelectedTicketType = 0;
this->currentCashState = CASH_STATE::CACHE_EMPTY;
}
ATBDeviceControllerPlugin::~ATBDeviceControllerPlugin() {}
PLUGIN_STATE ATBDeviceControllerPlugin::initDCPlugin(QObject *healthEventReceiver, const QSettings & settings)
{
this->healthEventReceiver = healthEventReceiver;
// read variables from setting
QString serialPort = settings.value("DEVICE_CONTROLLER/serialPort", "ttymxc2").toString();
QByteArray printerEncoding = settings.value("DEVICE_CONTROLLER/printerEnconding", "ISO 8859-2").toString().toLatin1();
// open serial port
hw->dc_openSerial(5, "115200", serialPort, 1);
hw->dc_autoRequest(true);
hw->rtc_setDateTime();
// this is necessary to init the CashAgentLib (!)
hw->vend_failed();
// text encoding for printer
this->codec = QTextCodec::codecForName(printerEncoding);
this->pluginState = PLUGIN_STATE::INITIALIZED;
return pluginState;
}
// Handle Mode-Changes --------------------------------------------------------
void ATBDeviceControllerPlugin::onChangedProgramModeToSELL()
{
//hw->dc_autoRequest(true);
}
void ATBDeviceControllerPlugin::onChangedProgramModeToSERVICE()
{
//hw->dc_autoRequest(true);
}
void ATBDeviceControllerPlugin::onChangedProgramModeToIDLE()
{
//hw->dc_autoRequest(false); // <-- TODO: ???
}
void ATBDeviceControllerPlugin::onChangedProgramModeToOOO()
{
}
// TASKS: Cash handling -------------------------------------------------------
void ATBDeviceControllerPlugin::requestStartCashInput(const QString & amount)
{
qCritical() << "Start Cash vending with amount = " << amount;
uint32_t amountInt = static_cast<uint32_t>(amount.toUInt());
if (amountInt == 0) amountInt = UINT_MAX;
hw->cash_startPayment(amountInt);
}
void ATBDeviceControllerPlugin::requestStopCashInput()
{
hw->cash_stopPayment();
// we need new cash value in application...
QTimer::singleShot(500, this, SLOT(onCashPayStopedSuccess()));
}
void ATBDeviceControllerPlugin::cashCollect()
{
hw->vend_success();
this->currentCashState = CASH_STATE::CACHE_EMPTY;
}
void ATBDeviceControllerPlugin::cashAbort()
{
hw->vend_failed();
this->currentCashState = CASH_STATE::CACHE_EMPTY;
}
// TASKS: Account -------------------------------------------------------------
// for an external account request, e.g. by an ui-button:
void ATBDeviceControllerPlugin::requestAccount()
{
qCritical() << "ATBDeviceControllerPlugin::requestAccount()";
this->private_startAccount();
}
void ATBDeviceControllerPlugin::private_startAccount()
{
uint16_t backupedAccNumbers[8]; // array of account numbers
uint8_t nrOfVals; // number of saved accounts
// it is not defined which one is the latest account
hw->log_getHoldAccountNumbers(&nrOfVals, backupedAccNumbers);
// DEBUG
qCritical() << "Start account: ";
qCritical() << " nrOfVals = " << nrOfVals;
for (int i=0; i<nrOfVals; ++i) {
qCritical() << " backupedAccNumbers[" << i << "] = " << backupedAccNumbers[0];
}
qsort( backupedAccNumbers, nrOfVals, sizeof (uint16_t), Utils::compare );
uint16_t latestAccountNumber = backupedAccNumbers[nrOfVals-1];
// DEBUG
qCritical() << " latestAccountNumber = " << latestAccountNumber;
hw->log_selectVaultRecord(latestAccountNumber);
this->accountCheckCounter = 0;
QTimer::singleShot(500, this, SLOT(private_checkAccountData()));
}
void ATBDeviceControllerPlugin::private_checkAccountData()
{
// DEBUG
qCritical() << " --> private_checkAccountData()";
if (hw->log_chkIfVaultRecordAvailable()) {
this->private_getAccountData();
}
else {
if (this->accountCheckCounter < 10) {
this->accountCheckCounter++;
QTimer::singleShot(500, this, SLOT(private_checkAccountData()));
}
else {
// cannot get accountData within ~10*500ms
qCritical() << "checkAccountData() failed";
// TODO: create and send an HealthEvent...
}
}
}
void ATBDeviceControllerPlugin::private_getAccountData()
{
// DEBUG
qCritical() << " --> private_getAccountData()";
struct T_vaultRecord retVR;
hw->log_getVaultRecord(&retVR);
QHash<QString, QVariant> accountData;
accountData.insert("AccountingNumber", QString::number(retVR.AccountingNumber));
for (uint i = 0; i < sizeof(retVR.coinsInVault); ++i) {
accountData.insert("COIN_" + QString::number(i) + "_Quantity", retVR.coinsInVault[i]);
accountData.insert("COIN_" + QString::number(i) + "_Value", retVR.coinDenomination[i]);
// DEBUG
qCritical() << "COIN_" + QString::number(i) + "_Quantity = " << accountData["COIN_" + QString::number(i) + "_Quantity"];
qCritical() << "COIN_" + QString::number(i) + "_Value = " << accountData["COIN_" + QString::number(i) + "_Value"];
}
emit requestAccountResponse(accountData);
}
// Door Events / Hardware contacts --------------------------------------------
void ATBDeviceControllerPlugin::onServiceDoorOpened()
{
qCritical() << "ATBDeviceControllerPlugin::onServiceDoorOpened()";
// switch to mode service
emit this->requestModeSERVICE();
// TODO:
// - create an HealthEvent (-> ISMAS-Event)
}
void ATBDeviceControllerPlugin::onVaultDoorOpened()
{
// TODO:
// - show special screen / message on screen
// - create an HealthEvent (-> ISMAS-Event)
qCritical() << "ATBDeviceControllerPlugin::onVaultDoorOpened()";
}
void ATBDeviceControllerPlugin::onCoinBoxRemoved()
{
qCritical() << "ATBDeviceControllerPlugin::onCoinBoxRemoved()";
this->private_startAccount();
}
void ATBDeviceControllerPlugin::onCoinBoxInserted()
{
qCritical() << "ATBDeviceControllerPlugin::onCoinBoxInserted()";
}
void ATBDeviceControllerPlugin::onAllDoorsClosed()
{
// TODO:
// - check for errors, switch to mode IDLE
qCritical() << "ATBDeviceControllerPlugin::onAllDoorsClosed()";
emit this->requestModeIDLE();
}
// TASKS: printing ------------------------------------------------------------
void ATBDeviceControllerPlugin::requestPrintTicket(const QHash<QString, QVariant> & printingData)
{
struct T_dynDat *dynTicketData = new T_dynDat;
memset(dynTicketData, 0, sizeof(*dynTicketData));
qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket( " << endl
<< " licenseplate = " << printingData["licenseplate"] << endl
<< " amount = " << printingData["amount"] << endl
<< " parkingEnd = " << printingData["parkingEnd"] << endl
<< " currentDateTime = " << printingData["currentDateTime"] << endl;
QDateTime parkingEndDateTime = QDateTime::fromString(printingData["parkingEnd"].toString(), Qt::ISODate);
QDateTime currentDateTime = QDateTime::fromString(printingData["currentDateTime"].toString(), Qt::ISODate);
/* -----------------------------------------------------------------------------------------
* note: the following highly depends on printer template files!
* -----------------------------------------------------------------------------------------
*/
// set dynamic printer data:
QByteArray ba_licenseplate = codec->fromUnicode(printingData["licenseplate"].toString());
memcpy((char*)dynTicketData->licensePlate, ba_licenseplate.data(), std::min(ba_licenseplate.size(),8));
QByteArray ba_amount = codec->fromUnicode(printingData["amount"].toString());
memcpy((char*)dynTicketData->vendingPrice, ba_amount.data(), std::min(ba_amount.size(),8));
QByteArray ba_parkingEndTime = codec->fromUnicode(parkingEndDateTime.toString("hh:mm"));
memcpy((char*)dynTicketData->parkingEnd, ba_parkingEndTime.data(), std::min(ba_parkingEndTime.size(),8));
QByteArray ba_parkingEndDate = codec->fromUnicode(parkingEndDateTime.toString("dd.MM.yy"));
memcpy((char*)dynTicketData->currentTime, ba_parkingEndDate.data(), std::min(ba_parkingEndDate.size(),8));
// ! and yes... 'ParkingEndDate' is 'currentTime'
QByteArray ba_currentDate = codec->fromUnicode(currentDateTime.toString("dd.MM.yy"));
memcpy((char*)dynTicketData->currentDate, ba_currentDate.data(), std::min(ba_currentDate.size(),8));
// DEBUG
/*
uint8_t* buf = dynTicketData->licensePlate;
int length = 64;
for (int i = 0; i < length; ++i) {
fprintf(stderr, "%d %02x %c\n", i, buf[i], buf[i]);
}
fprintf(stderr, "\n");
*/
// DEBUG
qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket()";
if (!this->hw->dc_isPortOpen()) {
qCritical() << " ... serial port is not open!";
this->onPrintFinishedERR();
return;
}
// TODO: wird hier nur 'licensePlate' gedruckt?
if (!this->hw->prn_sendDynamicPrnValues(dynTicketData->licensePlate)) {
this->errorCode = "hwapi::prn_sendDynamicPrnValues";
this->errorDescription = "hwapi method 'hwapi::prn_sendDynamicPrnValues' result is false";
qCritical() << "ERROR:";
qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket( " << endl
<< " licenseplate = " << printingData["licenseplate"] << endl
<< " amount = " << printingData["amount"] << endl
<< " parkingEnd = " << printingData["parkingEnd"] << endl
<< " currentTime = " << printingData["currentTime"] << endl
<< " currentDate = " << printingData["currentDate"] << endl;
this->onPrintFinishedERR();
return;
}
// set ticket type:
// 00281 - Szeged:
// 1 - Cash / ShortTimeParking
// 2 - Card / ShortTimeParking
// 3 - Cash / DayTicket
// 4 - Card / DayTicket
QString paymentType = printingData["paymentType"].toString(); // must be "CASH" | "CARD"
QString productName = printingData["product"].toString(); // must be "ShortTimeParking" | "DayTicket"
if ( (paymentType == "CASH") && (productName == "ShortTimeParking") ) {
this->currentSelectedTicketType = 1;
}
else
if ( (paymentType == "CARD") && (productName == "ShortTimeParking") ) {
this->currentSelectedTicketType = 2;
}
else
if ( (paymentType == "CASH") && (productName == "DayTicket") ) {
this->currentSelectedTicketType = 3;
}
else
if ( (paymentType == "CARD") && (productName == "DayTicket") ) {
this->currentSelectedTicketType = 4;
}
else {
qCritical() << "ERROR: requestPrintTicket(): invalid payment data:";
qCritical() << " paymentType = " << paymentType << endl
<< " productName = " << productName << endl;
this->onPrintFinishedERR();
return;
}
QTimer::singleShot(1000, this, SLOT(onPrinterDataPrepared()));
}
void ATBDeviceControllerPlugin::onPrinterDataPrepared()
{
this->hw->prn_printKombiticket(this->currentSelectedTicketType);
// FAKE SIGNAL:
QTimer::singleShot(4000, this, SLOT(onPrintFinishedOK()));
// old: use printer templates:
// this->currentTemplate = 1;
// this->onPrinterPrintNextTemplate();
}
void ATBDeviceControllerPlugin::onPrinterPrintNextTemplate()
{
qCritical() << " ... print template " << this->currentTemplate;
if (!this->hw->prn_printTemplate(this->currentTemplate)) {
this->errorCode = "hwapi::prn_printTemplate";
this->errorDescription = QString("hwapi method 'hwapi::onPrinterPrintNextTemplate(%1)' result is false").arg(this->currentTemplate);
this->onPrintFinishedERR();
return;
}
if (this->currentTemplate >= 3) {
// all templates are printed
this->currentTemplate = 0;
// FAKE SIGNAL:
QTimer::singleShot(500, this, SLOT(onPrintFinishedOK()));
}
else {
// print next template
this->currentTemplate++;
QTimer::singleShot(2000, this, SLOT(onPrinterPrintNextTemplate()));
}
}
/************************************************************************************************
* private slots, interface to low level hwapi
*
*/
void ATBDeviceControllerPlugin::onPrintFinishedOK()
{
// DEBUG
qCritical() << "ATBDeviceControllerPlugin::onPrintFinishedOK()";
emit this->printTicketFinished(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
// TODO: TicketNumber
"",
"");
}
void ATBDeviceControllerPlugin::onPrintFinishedERR()
{
// DEBUG
qCritical() << "ATBDeviceControllerPlugin::onPrintFinishedERR()";
this->errorCode = "PRINTER"; // TODO: get more detailed error code from low level API
this->errorDescription = "Printer error"; // TODO: get more detailed error description from low level API
emit this->printTicketFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
this->errorCode,
this->errorDescription);
}
/************************************************************************************************
* cash payment
*/
void ATBDeviceControllerPlugin::onCashGotCoin()
{
// DEBUG
qCritical() << "ATBDeviceControllerPlugin::onGotCoin()";
this->currentCashState = CASH_STATE::CACHE_INPUT;
uint32_t amountInt = this->hw->getInsertedAmount();
QString amountString = QString::number(amountInt);
emit this->cashInputEvent(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
nsDeviceControllerInterface::CASH_STATE::CACHE_INPUT,
amountString,
"",
"");
}
void ATBDeviceControllerPlugin::onCashPayStopByMax()
{
// DEBUG
qCritical() << "ATBDeviceControllerPlugin::onCashVendStopByMax()";
// we need new cash value in application...
QTimer::singleShot(500, this, SLOT(onCashPayStopedSuccess()));
}
void ATBDeviceControllerPlugin::onCashPayStopByEscrow()
{
// DEBUG
qCritical() << "ATBDeviceControllerPlugin::onCashPayStopByEscrow()";
uint32_t amountInt = this->hw->getInsertedAmount();
QString amountString = QString::number(amountInt);
emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
amountString,
"",
"");
}
void ATBDeviceControllerPlugin::onCashPayStopByError()
{
// DEBUG
qCritical() << "ATBDeviceControllerPlugin::onCashPayStopByError()";
uint32_t amountInt = this->hw->getInsertedAmount();
QString amountString = QString::number(amountInt);
emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
amountString,
"",
"");
}
void ATBDeviceControllerPlugin::onCashPayStopByTimeout()
{
// DEBUG
qCritical() << "ATBDeviceControllerPlugin::onCashPayStopByTimeout()";
uint32_t amountInt = this->hw->getInsertedAmount();
QString amountString = QString::number(amountInt);
emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
amountString,
"",
"");
}
void ATBDeviceControllerPlugin::onCashPayStopedSuccess()
{
// DEBUG
qCritical() << "ATBDeviceControllerPlugin::onCashPayStoped()";
uint32_t amountInt = this->hw->getInsertedAmount();
QString amountString = QString::number(amountInt);
qCritical() << " insertedAmount (int) = " << amountInt;
qCritical() << " insertedAmount = " << amountString;
emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
amountString,
"",
"");
}
/**
* Load CashAgentLib
* @brief ATBDeviceControllerPlugin::private_loadCashAgentLib
* @param pluginName
* @return
*/
bool ATBDeviceControllerPlugin::private_loadCashAgentLib(QString pluginName)
{
if (pluginName == "") {
// search list for plugin (.so) file:
QStringList pluginNameList;
pluginNameList << "/usr/lib/libCAmaster.so"
<< "/usr/lib/libCashAgentLib.so";
// using C++11 range based loop:
for (const auto& filename : pluginNameList) {
if (QFileInfo(filename).isReadable()) {
pluginName = filename;
break;
}
}
if (pluginName == "") {
qCritical() << "ATBDeviceControllerPlugin: CashAgentLib not installed!";
this->errorCode = "CashAgentLib::NOT_FOUND";
this->errorDescription = "ERROR: no CashAgentLib: ";
return false;
}
}
if (!QLibrary::isLibrary(pluginName)) {
qCritical() << "ATBDeviceControllerPlugin: can not load CashAgentLib: " << pluginName;
this->errorCode = "CashAgentLib::NO_LIBRARY";
this->errorDescription = "ERROR: can not load CashAgentLib: " + pluginName;
return false;
}
QPluginLoader* pluginLoader = new QPluginLoader();
pluginLoader->setFileName(pluginName);
QObject* plugin = pluginLoader->instance();
if (!pluginLoader->isLoaded()) {
qCritical() << "ATBDeviceControllerPlugin: can not instantiate CashAgentLib: " << pluginName;
qCritical() << " error: " << pluginLoader->errorString();
this->errorCode = "CashAgentLib::NO_INSTANCE";
this->errorDescription = "ERROR: can not instantiate CashAgentLib: " + pluginName;
return false;
}
if (plugin == nullptr) {
qCritical() << "ATBDeviceControllerPlugin: plugin is NULL";
this->errorCode = "CashAgentLib::INSTANCE_IS_NULL";
this->errorDescription = "ERROR: CashAgentLib instance is NULL: " + pluginName;
}
qCritical() << "ATBDeviceControllerPlugin: instantiate CashAgentLib: " << pluginName;
this->hw = qobject_cast<hwinf*>(plugin);
if (this->hw == nullptr) {
qCritical() << "ATBDeviceControllerPlugin: hw is NULL";
this->errorCode = "CashAgentLib::HW_IS_NULL";
this->errorDescription = "ERROR: CashAgentLib object_cast is NULL: " + pluginName;
return false;
}
qCritical() << "ATBDeviceControllerPlugin: loaded CashAgentLib";
return true;
}
/************************************************************************************************
* Mandatory plugin methods
*
*/
PLUGIN_STATE ATBDeviceControllerPlugin::getState()
{
return this->pluginState;
}
QString & ATBDeviceControllerPlugin::getLastError()
{
return this->errorCode;
}
const QString & ATBDeviceControllerPlugin::getLastErrorDescription()
{
return this->errorDescription;
}
const QString & ATBDeviceControllerPlugin::getPluginInfo()
{
return this->pluginInfo;
}
const QString ATBDeviceControllerPlugin::getString(nsDeviceControllerInterface::RESULT_STATE resultState)
{
QString str;
switch (resultState) {
case nsDeviceControllerInterface::RESULT_STATE::SUCCESS:
str = QString("RESULT_STATE::SUCCESS");
break;
case nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND:
str = QString("RESULT_STATE::ERROR_BACKEND");
break;
case nsDeviceControllerInterface::RESULT_STATE::ERROR_TIMEOUT:
str = QString("RESULT_STATE::ERROR_TIMEOUT");
break;
case nsDeviceControllerInterface::RESULT_STATE::ERROR_PROCESS:
str = QString("RESULT_STATE::ERROR_PROCESS");
break;
case nsDeviceControllerInterface::RESULT_STATE::ERROR_RETRY:
str = QString("RESULT_STATE::ERROR_RETRY");
break;
case nsDeviceControllerInterface::RESULT_STATE::INFO:
str = QString("RESULT_STATE::INFO");
break;
}
return str;
}
/************************************************************************************************
* ... end
*/
#if QT_VERSION < 0x050000
Q_EXPORT_PLUGIN2( ATBDeviceControllerPlugin, ATBDeviceControllerPlugin )
#endif

View File

@ -0,0 +1,166 @@
#ifndef ATBDEVICECONTROLLERPLUGIN_H
#define ATBDEVICECONTROLLERPLUGIN_H
#include <QObject>
#include "src/ATBAPP/DeviceControllerInterface.h"
#include "src/ATBAPP/ATBAPPplugin.h"
#include "version.h"
#include "interfaces.h"
#include <unistd.h>
#include <thread>
#include <memory>
#include <QSharedMemory>
class QTextCodec;
using namespace nsDeviceControllerInterface;
class QSettings;
class ATBDeviceControllerPlugin : public QObject,
public DeviceControllerInterface
{
Q_OBJECT
Q_INTERFACES(ATBAPPplugin)
Q_INTERFACES(DeviceControllerInterface)
#if QT_VERSION >= 0x050000
Q_PLUGIN_METADATA( IID "ATBDeviceControllerPlugin" )
#endif
public:
explicit ATBDeviceControllerPlugin(QObject *parent = nullptr);
~ATBDeviceControllerPlugin();
// ----------------------------------------------------------------------------
// interface:
PLUGIN_STATE initDCPlugin(QObject *healthEventReceiver, const QSettings & settings);
// TASKS: Cash handling -------------------------------------------------------
void requestStartCashInput(const QString & amount);
void requestStopCashInput();
void cashCollect();
void cashAbort();
// TASKS: printing ------------------------------------------------------------
void requestPrintTicket(const QHash<QString, QVariant> & printingData);
// TASKS: Account -------------------------------------------------------------
void requestAccount();
// mandantory ATBAPP plugin methods: ------------------------------------------
nsDeviceControllerInterface::PLUGIN_STATE getState();
QString & getLastError();
const QString & getLastErrorDescription();
const QString & getPluginInfo();
// helpers e.g. for debug / log
const QString getString(nsDeviceControllerInterface::RESULT_STATE resultState);;
public slots:
void onChangedProgramModeToSELL();
void onChangedProgramModeToSERVICE();
void onChangedProgramModeToIDLE();
void onChangedProgramModeToOOO();
signals:
void printTicketFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
const QString & errorCode,
const QString & errorDescription);
void cashInputEvent(nsDeviceControllerInterface::RESULT_STATE resultState,
nsDeviceControllerInterface::CASH_STATE cashState,
const QString & newCashValue,
const QString & errorCode,
const QString & errorDescription);
void cashInputFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
const QString & newCashValue,
const QString & errorCode,
const QString & errorDescription);
void requestModeSERVICE();
void requestModeIDLE();
void requestModeOOO();
void requestAccountResponse(const QHash<QString, QVariant> & accountData);
void Error(
const QString & errorCode,
const QString & errorDescription);
private:
QString errorCode;
QString errorDescription;
QString pluginInfo;
int currentTemplate;
bool useDebug;
PLUGIN_STATE pluginState;
QObject* healthEventReceiver;
hwinf* hw;
QTextCodec *codec;
bool private_loadCashAgentLib(QString pluginName);
quint8 currentSelectedTicketType;
nsDeviceControllerInterface::CASH_STATE currentCashState;
// counts failed hw->log_chkIfVaultRecordAvailable()
int accountCheckCounter;
private slots:
// printer
void onPrinterDataPrepared();
void onPrinterPrintNextTemplate();
void onPrintFinishedOK();
void onPrintFinishedERR();
// cash payment
void onCashGotCoin();
void onCashPayStopedSuccess();
void onCashPayStopByMax();
void onCashPayStopByEscrow();
void onCashPayStopByError();
void onCashPayStopByTimeout();
// doors and hardware contacts
void onServiceDoorOpened();
void onVaultDoorOpened();
void onCoinBoxRemoved();
void onCoinBoxInserted();
void onAllDoorsClosed();
// account handling
void private_startAccount();
void private_checkAccountData();
void private_getAccountData();
};
#endif // ATBDEVICECONTROLLERPLUGIN_H

View File

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

View File

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

View File

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

18
src/ATBAPP/Utils.cpp Normal file
View File

@ -0,0 +1,18 @@
#include "Utils.h"
Utils::Utils(QObject *parent) : QObject(parent)
{
}
int Utils::compare(const void* a, const void* b)
{
int int_a = * ( (int*) a );
int int_b = * ( (int*) b );
if ( int_a == int_b ) return 0;
else if ( int_a < int_b ) return -1;
else return 1;
}

23
src/ATBAPP/Utils.h Normal file
View File

@ -0,0 +1,23 @@
#ifndef UTILS_H
#define UTILS_H
#include <QObject>
class Utils : public QObject
{
Q_OBJECT
public:
static int compare(const void* a, const void* b);
private:
explicit Utils(QObject *parent = nullptr);
signals:
};
#endif // UTILS_H

View File

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

View File

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

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

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

View File

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

View File

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

File diff suppressed because it is too large Load Diff

View File

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