From a9a52100299864b44eef3d65d6a066cb5e7f3b13 Mon Sep 17 00:00:00 2001 From: Gerhard Hoffmann Date: Fri, 17 Mar 2023 11:21:55 +0100 Subject: [PATCH] Adding header files (sax) --- include/com.h | 103 ++++ include/controlBus.h | 194 +++++++ include/datIf.h | 223 ++++++++ include/dcBL.h | 93 ++++ include/hwapi.h | 1177 +++++++++++++++++++++++++++++++++++++++++ include/interfaces.h | 850 +++++++++++++++++++++++++++++ include/prot.h | 101 ++++ include/sendWRcmd.h | 217 ++++++++ include/storeINdata.h | 489 +++++++++++++++++ include/tslib.h | 84 +++ 10 files changed, 3531 insertions(+) create mode 100644 include/com.h create mode 100644 include/controlBus.h create mode 100644 include/datIf.h create mode 100644 include/dcBL.h create mode 100644 include/hwapi.h create mode 100644 include/interfaces.h create mode 100644 include/prot.h create mode 100644 include/sendWRcmd.h create mode 100644 include/storeINdata.h create mode 100644 include/tslib.h diff --git a/include/com.h b/include/com.h new file mode 100644 index 0000000..249864e --- /dev/null +++ b/include/com.h @@ -0,0 +1,103 @@ +//CAT is always master, no receive before request + +#ifndef SER_H +#define SER_H +#include +#include +#include +#include +#include +#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(); + + +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); + + 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 + + + + + + + + + + + + diff --git a/include/controlBus.h b/include/controlBus.h new file mode 100644 index 0000000..6619e6e --- /dev/null +++ b/include/controlBus.h @@ -0,0 +1,194 @@ +#ifndef CONTROLBUS_H +#define CONTROLBUS_H + + +#include +#include "tslib.h" +#include + + +// /////////////////////////////////////////////////////////////////////////////////// +// 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 *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 + + + + + + + + + + diff --git a/include/datIf.h b/include/datIf.h new file mode 100644 index 0000000..75ddb99 --- /dev/null +++ b/include/datIf.h @@ -0,0 +1,223 @@ +// 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 +#include "tslib.h" +#include "prot.h" +#include "dcBL.h" + + +#include +#include +#include +#include +#include +#include +#include + + +// 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_MifReader 0x2902 +#define CMD2DC_RdBk_Mifcard 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); + + 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 + +}; + +#endif // CI_H diff --git a/include/dcBL.h b/include/dcBL.h new file mode 100644 index 0000000..096ff06 --- /dev/null +++ b/include/dcBL.h @@ -0,0 +1,93 @@ +#ifndef DCBL_H +#define DCBL_H +#include +#include "qbytearray.h" +#include "qstring.h" +#include + +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); + + +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(); + + + + + + + +#endif // DCBL_H diff --git a/include/hwapi.h b/include/hwapi.h new file mode 100644 index 0000000..ecad915 --- /dev/null +++ b/include/hwapi.h @@ -0,0 +1,1177 @@ +/* + +PSA1259 hardware control using the DeviceController DC2 + +covering enclosure (switches and doors) and money devices, +controls mifare card to access or program +optional it can control printer, modem, bar code reader and credit card + + * API to the PSA1259 Hardware + * All data come in from device controller via serial interface and will be stored + * in "PI" = peripheral image + * PI is updated every 100ms (up to 30ms possible) + * This api uses stored pi data and returns them in the following functions + * created: Q1/2020 TS + * + +The devices, connected to device controller2 (DC2) can be controlled in different access levels. +Level 1: + direct connection to DC2, check versions, state and parameters + control serial interfaces + digital/analog IO's + read and write to connected devices on lowest level, this is a kind of fall-back-level + in case higher levels fail or do not support the needed (new) function + Example: send a specific printer command, several bytes that need to be conform to + printer manual. This command is routed to the printer through the DC2 without + any action of the DC. You can write your own device driver that way. + Level 1 is flexible but complicated + +Level 2: + The DC controls the connected devices containing a device driver. The DC offers + usage of the device by simple commands, + Example: "Printer on", "set Font size 3" "print "hello world"", "cut" + In opposite to level 1 where you had to send a set of numbers and letters. + In other words: you "talk" to the device controller, not to the device itself. + +Level 3: + start/stop complete processes. + Example: 1) print (predefined) document nr 3 with Text, letter size, font set, cut. + Also power up/down the printer, check if paper ok and so on. + */ + +/* +Another access example: control the coin unit + +Level 1): read digital inputs to detect coin, + switch digital output which opens coin slot + communicate with coin checker by certain mdb-commands (manual conform) + poll coin checker for inserted coins + close coin slot after 3seconds by setting DO to 0.... + +Level 2): get message of attached coin from DC + send command "initialize coin checker" to DC + send command "open slot for 3s" + poll DC for inserted coins, DC polls coin checker in right way, no need + to know the data sheet of the coin checker or mdb-bus + command to DC "open coin escrow's return flap for 1s" + +Level 3): send command: "start payment process" + all coin devices are started up + coin blocker opens for 3s if a coin is attached + coin checker summarizes inserted value and reports sum + later send command "stop payment process" (puts coins to vault) or + send command "cancel payment process" (returns coins to user) + +*/ + +#ifndef hwapi_H +#define hwapi_H + +#include +#include +#include +#include +#include "interfaces.h" +#include "datIf.h" + + + +//public QWidget, + +/* +struct Tprn_hw_state +{ + // hardware (IO's) + bool powerRdBk; // prn pwr is on + bool rsSwOk; // serial switch (printer or modem) is set to printer + bool rsDrvOk; // RS232 converter for PTU, Printer and Modem in on + + bool ReadyLine; // HW signal from printer showing ready + bool inIdle; // powered and free from errors + bool paperNearEnd; // paper roll runs out + bool noPaper; + bool ErrorTemp; + bool HeadOpen; + bool cutterJam; + bool noResponse; // printer is not connected, cable broken, wrong baudrate + bool badResponse; +}; + +struct Tprn_currentSettings +{ + uint8_t currFont; + uint8_t currSize; + uint8_t currHeigth; + uint8_t currWidth; + bool nowBold; + bool nowInvers; + bool nowUnderlined; + uint8_t currDensity; + uint8_t currSpeed; + bool nowAligned; +}; + +struct T_dynDat +{ + uint8_t licensePlate[8]; + uint8_t vendingPrice[8]; + uint8_t parkingEnd[8]; + uint8_t currentTime[8]; + uint8_t currentDate[8]; + uint8_t dynDat5[8]; + uint8_t dynDat6[8]; + uint8_t dynDat7[8]; +}; + + +struct T_emp +{ + + // Fixdata from EMP: + uint8_t shaft; // = changer level + uint16_t countryCode; + uint8_t scale; + uint8_t decimals; + uint8_t coinValues[16]; + uint16_t routing; + + // Master specs: + uint8_t gotSetup; // 1: got specifications from master 0: no specs + uint16_t coinAccept; // bit 0 = coin1 bit H=accept + uint8_t tokenChannel; + uint16_t denomination[16]; + + // dynamic: + uint8_t state; // step counter of EMP (electronic coin checker) FSM (finite state machine): + // 0=Emp & Bus power off, 1=powered, poll off 2=polling on + // 3=device responded, requesting status + // 4=waiting for status 5=have status, + // 6: IDLE, have paramters from master, polling running, ready for payment + // Master can stop/start polling and acceptance + // 7: end of transaction, polling on, accept off, reporting coins, (wait for last coin) + // 8: transaction running, polling on, acceptance on, reporting coins, + + uint8_t pollingRunning; + uint8_t paymentRunning; + +}; +*/ + + +class hwapi : public QObject, + public hwinf +{ + Q_OBJECT + //Q_PLUGIN_METADATA(IID "Atb.Psa2020.software.HWapi/1.0" ) //FILE "HWapi.json") + //Q_INTERFACES(hwinf) + +public: + explicit hwapi(QWidget *parent = nullptr); + + T_datif *myDatif; + + + // ------------------------------------------------------------------------------ + // Level 0 commands, interface + // open, close, change serial interface + // actually not neccessary as it is opened automatically on program start + // start automatic READ requests + // ------------------------------------------------------------------------------ + + void dc_openSerial(int BaudNr, QString BaudStr, QString ComName, uint8_t connect) const override; + // BaudNr: 0:1200 1:9600 2:19200 3:38400 4:57600 5:115200 + // BaudStr: for exapmle "19200" + // ComName: for example "COM48" + // connect: 0, 1 + + void dc_closeSerial(void) const override; + + bool dc_isPortOpen(void) const override ; + + void dc_autoRequest(bool on) const override ; + // select if READ-Requests are sent manually one by one or automatically + // automatically request ALL digital and analog sensors, get time/date, get status information + + + + // ------------------------------------------------------------------------------ + // Level 1, control device-controller (functions of µC) + // check serial connection to deviceController + // read response from DC2 (input data) + // some test function for serial communication + // also Bootloader is here + // ------------------------------------------------------------------------------ + + void dc_requTestResponse() const override; + // tell DC2 to return his TestString in order + // to test the serial and the baudrate + // must always be triggered manually, is never sent automatically + + bool dc_readAnswTestResponse() const override; + // retval: true: test was successful, got right response + + uint8_t dc_isRequestDone(void) const override; + // retval: 0: request is still in progress + // 1: answer from DC2 was OK + // 2: wrong answer from DC2 + + uint16_t dc_getCompletePayLoad(uint16_t plBufSiz, uint8_t *payLoad) const override; + // get data back in *pl, max 64 byte, can be used for diagnosis + // 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 + + void dc_setWakeFrequency(uint8_t period) const override; + // RTC wakes DC2 (and PTU) by hardware signal every 32seconds + // change wake signal period to 1...64s + + void dc_OrderToReset(void) const override; + // want DC2 to reset (in order to start Bootloader) + + QString dc_getSerialState(void) const override; + void dc_clrSerialStateText(void) const override; + + void bl_sendDataDirectly(uint8_t length, uint8_t *buf) const override; + // send without protocol frame, needed for the DC bootloader + + uint8_t getRawRecLength(void) const override; + + uint8_t getRawReceivedData(uint8_t *receivedData) const override; + + QString dc_getSerialParams(void) const override; + + QString dc_getHWversion(void) const override; + + QString dc_getSWversion(void) const override; + + QString dc_getState(void) const override; + + + + + + + + + + + // neu, 25.8.21 + QString dc_getTxt4RsDiagWin(void) const override; + void dc_clrTxt4RsDiagWin(void) const override; + QString dc_get2ndTxt4RsDiagWin(void) const override; + void dc_clr2ndTxt4RsDiagWin(void) const override; + QString dc_getTxt4HsStateLine(void) const override; + void dc_clrTxt4HsStateLine(void) const override; + QString dc_getTxt4masterStateLine(void) const override; + void dc_clrTxt4masterStateLine(void) const override; + QString dc_getTxt4resultStateLine(void) const override; + void dc_clrTxt4resultStateLine(void) const override; + QString dc_getdataStateLine(void) const override; + void dc_clrTxt4dataStateLine(void) const override; + QString dc_getdatifLine(void) const override; + void dc_clrTxt4datifLine(void) const override; + + // using DC2 Bootloader + void bl_iniChain(void) const override; + bool bl_importBinFile(QByteArray readBinFile, uint32_t fileSize, char withDispl) const override; + uint8_t bl_activatBootloader(uint8_t *sendData) const override; + uint8_t bl_startChain(void) const override; + uint8_t bl_readBLversion(uint8_t *sendData) const override; + // minimum size of sendData-buffer: 5byte retval: length + uint8_t bl_readFWversion(uint8_t *sendData) const override; + // minimum size of sendData-buffer: 5byte retval: length + + uint8_t bl_prepareDC_BLcmd(uint8_t Cmd, uint8_t SendDataLength, uint8_t *sendData, uint8_t *outBuf) const override; + // 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 bl_exitBL(uint8_t *sendData) const override; + // minimum size of sendData-buffer: 5byte retval: length + + + + + + + + + // ------------------------------------------------------------------------------ + // Level 2 DC2-onboard devices + // WR: set time + // RD. get time, get measure, get test results + // ------------------------------------------------------------------------------ + + // get UID, get time/date test results memory, RTC analog values +/* + struct Trtc_DateTime + { + uint8_t rtc_hour; + uint8_t rtc_min; + uint8_t rtc_sec; + uint8_t rtc_dayOfMonth; + uint8_t rtc_month; + uint8_t rtc_year; + uint8_t rtc_dayOfWeek; + }; +*/ + uint8_t rtc_getDateTime(struct Trtc_DateTime *rtc_DateTime) const override; + + uint8_t rtc_setDateTime(void) const override; + // synch DC2 with PC or PTU system time and date + + void rtc_getTime(uint8_t *hh, uint8_t *mm, uint8_t *ss) const override; + // get time directly + + void rtc_getDate(uint8_t *yy, uint8_t *mm, uint8_t *dd) const override; + // get date directly + + uint8_t rtc_getToday(uint8_t *dow, uint16_t *minOfToday, uint32_t *secOfToday) const override; + // dow=day of week, 1=monday...7 + // minOfToday: 0=midnight...1439= 23:59 + // secOfToday: 0=midnight...86399= 23:59:59 + + bool rtc_isLeapYear(uint8_t *lastLeapYear, uint8_t *NextLeapYear) const override; + // retval true: this year is leap year + + bool rtc_isLeapYear() const override; + + void rtc_getWeek(uint8_t *DayOfWeek, uint8_t *HoursOfWeek, uint16_t *MinutesOfWeek) const override; + // DayOfWeek: 1=monday...7 + // HoursOfWeek: 0=Monday 0:00 o'clock...167=Sunday 23:00 + // MinutesOfWeek: 0=Monday 0:00 o'clock...10079=Sunday 23:59 + + void rtc_getMonth(uint8_t *DayOfMonth, uint16_t *HoursOfMonth, uint16_t *MinutesOfMonth) const override; + // DayOfMonth: 1...31 + // HoursOfMonth: 0 = 0:00o'clock of 1.day in month up to 743 + // MinutesOfMonth:0 = 0:00o'clock of 1.day in month up to 44639 + + void rtc_getYear(uint16_t *DayOfYear, uint16_t *HoursOfYear, uint32_t *MinutesOfYear) const override; + // DayOfYear: 1...366 1= 1.Jan of this current year + // HoursOfYear: 0=1.Jan 0:00o'clock ...8783=31.12 23 o'clock + // MinutesOfYear: 0=1.Jan 0:00o'clock ...527039=31.12 23:59 o'clock + + QString rtc_getTimStr(void) const override; + QString rtc_getDatStr(void) const override; + QString rtc_getTimDatStr(void) const override; + + // UID + void dc_getUID8byte(uint8_t *buf8byteUid) const override; + QString dc_getUIDstr() const override; + uint64_t dc_getUIDnumber(void) const override; + + + // Analog inputs: + uint32_t dc_getTemperature(void) const override; // in Sax-Format 0...400 (0=-50,0°C 100=0,0°C 141=20,5°C 400=150,0°C) + QString dc_getTemperaturStr(void) const override; + + uint32_t dc_getVoltage(void) const override; // in mV, 0...65,535V + QString dc_getVoltagStr(void) const override; + + bool dc_mainFuseIsOk(void) const ; // override + + // ------------------------------------------------------------------------------ + // Level 3: digital outputs and simple switching of connected devices + // simple processes like flashing a led or open flap for 1s + // ------------------------------------------------------------------------------ + + void lock_switchContactPower(bool on) const override; + + // Locks move until stop cmd (0) + uint8_t lock_switchUpperLock(uint8_t dir) const override; + // dir 0=off 1=up 2=down + uint8_t lock_switchLowerLock(uint8_t dir) const override; + // dir 0=off 1=up 2=down + void lock_switchVaultDoor(void) const; // override; + + void coin_switchRejectMotor(uint8_t dir) const; // override; + + void coin_rejectCoins(void) const; // override; + + // LEDs + void led_switchLedIllumination(uint8_t on) const override; + void led_switchLedService(uint8_t on) const override; + void led_switchLedPaper(uint8_t on, uint8_t ton, uint8_t tof) const override; + void led_switchLedPinPad(uint8_t on, uint8_t ton, uint8_t tof) const override; + void led_switchLedStart(uint8_t on, uint8_t ton, uint8_t tof) const override; + void led_switchLedCoinbassin(uint8_t on, uint8_t ton, uint8_t tof) const override; + + void fan_switchFan(bool on) const override; + void laerm_switchSiren(bool on) const override; + void bar_OpenBarrier(bool open) const override; + void ptu_switchWake(bool WAKEACTIVE) const override; + + void prn_switchPower(bool on) const override; + + void mif_readerOn(bool on) const override; + + void shut_move(bool open) const override; + void esc_moveFlaps(uint8_t flap ) const override; + // 0: close both 1: open take-flap 2: open return + + void mdb_switchPower(bool on) const override; + void mdb_switchWake(bool WAKEACTIVE) const override; + + void mod_switchPower(bool on) const override; + void credit_switchPower(bool on) const override; + + void aux_power(bool on) const override; + void aux_setUsage(uint8_t PinDirection) const override; + void aux_setOutputs(uint8_t PinIsHigh) const override; + + + void mod_switchWake(bool WAKEACTIVE) const override; + + void credit_switchWake(bool WAKEACTIVE) const override; + + + + + // ------------------------------------------------------------------------------ + // Level 3: digital inputs of connected devices + // ------------------------------------------------------------------------------ + + bool door_isContactPowerOn(void) const override; + + uint8_t door_getSwitches(void) const override; + // retval: bit0: upper door 1: low door 2:vault door + + bool door_isUpperDoorOpen(void) const override; + + bool door_isLowerDoorOpen(void) const override; + + bool vault_isVaultDoorOpen(void) const override; + + uint8_t vault_getSwitches(void) const override; + // retval bit0: cash box, bit 1: bill box + + bool vault_isCoinVaultIn(void) const override; + + bool vault_isBillVaultIn(void) const override; + + uint8_t door_getLocks(void) const override; + // retval bit0: upper lever is up + // bit1: upper lever is down + // bit2: lower lever is up + // bit3: lower lever is down + + bool door_upperDoorIsLocked(void) const override; + + bool door_upperDoorIsUnlocked(void) const override; + + bool door_lowerDoorIsLocked(void) const override; + + bool door_lowerDoorIsUnlocked(void) const override; + + bool bar_optoIn1isOn(void) const override; + + bool bar_optoIn2isOn(void) const override; + + bool ptu_WakeINisActive(void) const override; + + bool prn_isPrinterPowerOn(void) const override; + uint8_t prn_PrnFuseIsOk(void) const; // override; + //retval: 0: fuse blown 1: fuse OK 2:unknown as printer power is off + + bool prn_readyINisActive(void) const override; + + bool mif_cardIsAttached(void) const override; + bool mif_isMifarePowerOn(void) const override; + + bool mdb_WakeINisActive(void) const override; + bool mdb_testIsmdbTxDon(void) const override; + bool mdb_isMdbPowerOn(void) const override; + + bool coid_isAttached(void) const override; + bool coin_escrowIsOpen(void) const override; + + bool aux_isAuxPowerOn(void) const override; + + uint8_t aux_getAuxInputs(void) const override; + + bool mod_isGsmPowerOn(void) const override; + + bool cred_isCreditPowerOn(void) const override; + + bool cash_getRejectMotorHomePos(void) const; // override; + + bool cash_getLowPaperSensor(void) const; // override; + + + + // ------------------------------------------------------------------------------ + // Level1,2,3 RD request commands + // ------------------------------------------------------------------------------ + + // all read-requests can be sent manually by the following functions + // or automatically in background by: void hwapi::dc_autoRequest(bool on) + // in other words: + // if automatic-reading is on, then there's no need to send any of these commands, + // but it's allowed to send them in order to speed up the refreshing of the inputs + + void request_DC2serialConfig() const override; + void request_DC2_HWversion() const override; + void request_DC2_SWversion() const override; + void request_DC2_condition() const override; + void request_DC2_UID() const override; + void request_DC2_TimeAndDate() const override; + void request_DC2_analogues() const override; + void request_DC2_digitalInputs() const override; + void request_DC2_digitalOutputs() const override; + + // ------------------------------------------------------------------------------ + // the folowing device state requests are deploed only if device is powered up: + void request_PrinterHwState() const override; + void request_PrinterCurrentFonts() const override; + void request_PrinterStateComplete() const override; + + void request_MifareReaderState() const override; + void request_MifareCardType() const override; + void request_MifareAtbType() const override; + void request_MifareData() const override; + + void request_MDB_Status() const override; + void request_MDB_lastResponse() const override; + void request_EMP_allParameters() const override; + void request_EMP_lastCoin() const override; + + + + // ------------------------------------------------------------------------------ + // Level 3: readback digital outputs of connected devices + // these functions are not needed for normal operation + // but can be used to test and verify conditions + + // There are two options: + // 1) the important things like power-outputs and wake lines are + // measured at DC2-terminals (after transistors) and come as input to DC-board + // 2) others like Leds are read from µC-pins by DC-board + // ------------------------------------------------------------------------------ + + bool test_getDO_mdbRXtst(void) const override; + + uint8_t lock_getDO_motors(void) const override; + // bit0: upper lock forward bit 1 backward + // bit2: lower lock forward bit 3 backward + + uint8_t test_serialState(void) const override; + // test on-board signals for the serials + // serial drv on/off, Serial mux1, Serial mux2 + bool test_serialIsOn(void) const override; + bool test_serialMux1isSetToPrinter(void) const override; + bool test_serialMux1isSetToModem(void) const override; + bool test_serialMux2isSetToCredit(void) const override; + bool test_serialMux2isSetToMifare(void) const override; + + bool led_coinIsOn(void) const override; + bool led_frontIsOn(void) const override; + bool led_ticketIsOn(void) const override; + bool led_pinIsOn(void) const override; + bool led_StartIsOn(void) const override; + bool led_insideIsOn(void) const override; + + bool fan_isOn(void) const override; + bool siren_isOn(void) const override; + bool bar_relayIsOn(void) const override; + bool ptu_WakeOutIsOn(void) const override; + + bool aux_powerIsOn(void) const override; + + bool coin_shutterIsOpen(void) const override; + bool coin_shutterTestOutput(void) const override; + + uint8_t coin_escrowFlapOpened(void) const override; + // retval: 1:return flap is open 2:take flap is open 0:closed + + + + // ------------------------------------------------------------------------------ + // Level4 ( Timer processes, device supervision by DC, processes with more then one devices + // WRITE + // ------------------------------------------------------------------------------ + + + void sendDeviceSettings(uint8_t kindOfPrinter, uint8_t kindOfCoinChecker, + uint8_t kindOfMifareReader, uint8_t suppressSleep, + uint8_t kindOfModem, uint8_t kindOfCredit ) const override; + + void request_ReadbackDeviceSettings() const override; + + void readback_DeviceSettings(uint8_t *length, uint8_t *data) const override; + // refer to DC2 manual for exact content + // state 5.5.21: byte[0]=kindOfPrinter byte[1]=kindOfCoinChecker + // byte[2]=kindOfMifarereadr byte[3]=suppress sleep mode + // byte[4]=kindOfModem byte[5]=kind of cc terminal + + uint8_t emp_returnLastCoin(uint16_t *value, uint8_t *signal) const override; + // use for changer + + void sendMachineID(uint16_t customerNr, uint16_t machineNr, + uint16_t borough, uint16_t zone, + uint16_t alias, char *location) const override; + + void request_ReadbackMachineID() const override; + + void readback_machineIDdata(uint8_t *length, uint8_t *data) const override; + // state 5.5.21: byte[0,1]=customer number byte[2,3]=machine number + // byte[4,5]=borough byte[6,7]=zone byte[8,9]=alias name + // byte[10...41]=location + + + // Locks stops automatically at end switch or by timeout + uint8_t lock_openUpperDoor(void) const override; + uint8_t lock_closeUpperDoor(void) const override; + + uint8_t lock_openLowerDoor(void) const override; + //uint8_t lock_closeLowerDoor(void) const override; + + + void shut_openOnce(void) const override; + // and close automatic after shutter time + + void shut_openForCoin(bool start) const override; + // open flap if coin is attached + // once process is started it runs until stop command + + void shut_sendOpeningTime(uint16_t timeIn_ms ) const override; + // after this time without retrigger the flap is closed + + void esc_takeMoney(void) const override; + // and close automatically after escrow time (1s) + + void esc_returnMoney(void) const override; + // and close automatically after escrow time (1s) + + void mif_creatAtbCard(uint8_t cardType) const override; + + + // ------------------------------------------------------------------------------ + // read response from DC2 (input data) + // ------------------------------------------------------------------------------ + + + + /* 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 "ATB25-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 mif_returnReaderStateAndCardType(uint8_t *buf, uint8_t maxBufferSize) const override; + // retval 0=OK 1=error host buffer too small + + bool mif_readerIsOK(void) const override; + + bool mif_cardAttached(void) const override; + + uint8_t mif_readResult(void) const override; + // result: 0: unknown or still in progress + // 1: card read successful + // 2: reading error + + QString mif_cardUID(void) const override; + + uint8_t mif_getCardDataDec(uint8_t blkNr, uint8_t *buf, uint8_t maxBufferSize) const override; + + QString mif_getCardDataStr(uint8_t blockNumber) const override; + // with blockNumber=0...11 + + + + + // ---------------------------------------------------------------------------------------------------------- + // --------------------------------------------- PRINTER ---------------------------------------------------- + // ---------------------------------------------------------------------------------------------------------- + + // read printer condition and settings + + uint8_t prn_getHwState(struct Tprn_hw_state *prn_hw_state) const override; + // retval: status byte + // byte 0 = 0: prnter OK, >0: error + // bit0: paper low 1: no paper 2: temperature error + // 3: head open 4: paper jam in cutter + // 6: no response 7: bad response from printer + // and return struct "Tprn_hw_state" + + bool prn_isUpAndReady(void) const override; + // true: printer is powered, serial is ok, no error, printer is connected and resonding + + void prn_getCurrentFontSetting(struct Tprn_currentSettings *prn_fonts) const override; + + + // send Commands to printer: + + void prn_sendText(QByteArray *buf) const override; + // up to 1280 bytes + + void prn_sendPrnSysCmd(uint8_t para1, uint8_t para2, uint32_t para3) const override; + // send three byte through to printer, see printers manual + + void prn_sendPrnEscCmd(uint8_t para1, uint8_t para2, uint8_t para3, uint8_t para4) const override; + // send four byte through to printer, see printers manual + + + void prn_sendPrnSetup(uint16_t paperSpeed, uint8_t density, uint8_t alignment, uint8_t orientation) const override; + // send 5 byte: byte 0,1: speed 5...250 mm/s + // byte2: density 0....(25)....50 + // byte3: alignment 'l', 'c', 'r' = left, center, right + // byte4: orientation 0, 90, 180 = 0°, 90°, 180° rotation (by now not supported!) + // not batched! don't use twice within 100ms + + void prn_movePaper(uint8_t wayInMm, uint8_t direction) const override; + //direction: 1=forward 2=backward + // + void prn_setFonts(uint8_t font, uint8_t size, uint8_t width, uint8_t height) const override; + // font = kind of font 5...11 (0..22) + // size = 6...20, 9..9: too tiny 10: small ...12 = normal size ...20=huge + // width: 0...4 0=1x 1=2x 2=4x (huge!) 3=8x 4=16x (3,4 make no sense) + // heigth: 0...7 = 1x...8x only 0,1,2,(3) make sense + + void prn_setLetters(uint8_t bold, uint8_t invers, uint8_t underlined) const override; + // bold: 0/1 + // invers: 0/1 + // underlined: 0/1 + + void prn_cut(uint8_t kindof) const override; + // kindof: 1=full cut 2=partial cut 3=eject (5xLF + full cut) + + void prn_newLine(uint8_t nrOfLines) const override; + + void prn_printCompleteFontTable(void) const override; + + + void prn_printBarcode(uint8_t kindOf, uint8_t withText, uint8_t offset, uint8_t rotation, uint8_t dataLeng, uint8_t *data) const override; + // kind of barcode: 0=Code39 1=Code128 2=EAN13 3= 2/5interleaved 4=UPC-A 5=EAN8 + // withText: print readable text below + // offset: move by pixel from left border + // rotation + // dataLeng in byte + + void prn_sendQRdata(QByteArray *buf) const override; + // maximal 150 alphanummeric bytes + + void prn_printQRcode(void) const override; + // QRcode may have 1...150 alphanummeric data, must be transfered in advance + + + void prn_printLogo(uint8_t nrOfLogo, uint8_t offset ) const override; + // nrOfLogo: 1..4 in flash 5...8 in Ram + // offset: in mm form left border + + + + // ......................................................... + // Parking Ticket (print-out document) designer TD + // ......................................................... + + // Predefine document Layout (e.g. parking ticket) in advance and stroe it for quick and easy use + // in opposite to the above "single" commands you need only one or a few commands at vending time. + // Stored text is just send to printer once the printing command is issued + // stored commands within the text are interpreted and executed right at the place (in ticket) they are + // example: start bold, , stop bold + // Predefinition of up to 16 ticket Layouts is possible, 0...1280 byte each + // Number 0..15, al keept non-volatile + // up to 8 dynamic values can be defined in the template ("print val3 here") and will be sent with printing command + // example: print current time at this point (the time of printing not the storage time!!) + + void pri_startTicketDesign(void) const override; + // start for every new printer document, reseting collecting buffer + + // all further functions write/append text, numbers and command to the ticket-buffer, up to 1278 bytes allowed + // return val of the appending functions: true=ok false=too long, buffer full + + int pri_TD_getCurrentSize(void) const override; + // retval: 0...1278 + + bool pri_TD_addText(QByteArray text) const override; + // example: pri_TD_addText("Hello") const override; + // example: pri_TD_addText(tempStr) const override; + // retval: true=ok false=too long, buffer full + + bool pri_TD_addValue(int val) const override; + // +/- 0...2^(31) + + bool pri_TD_addNewLine(void) const override; + + bool pri_TD_addSign(char sign) const override; + // example: '.' ' ' 0x20 'W' '$' + + bool pri_TD_addCommand(char group, char attribute, char p1, char p2, char p3, char p4, char p5) const override; + // always add 8 byte to the ticket layout: ESC & group & attribute & parameter1...5 + /* complete list of possible commands: + group 50 : paper + attribute 10 : move forward + p1: wayInMm p2: direction + attribute 11 : cut + p1: kind of, 1=full 2=partial, 3=eject + attribute 12 : new line(s) + p1: nr of lines 1...100 + + group 51 : fonts + attribute 10 : kind of font see description above + p1: 0...8 + attribute 11 : font size + p1: 6...20 + attribute 12 : font width + p1: 0...4 + attribute 13 : font heigth + p1: 0...7 + attribute 14 : switch bold print on/off + p1: 0=off 1=on + attribute 15 : switch invers print on/off + p1: 0=off 1=on + attribute 16 : switch underlined print on/off + p1: 0=off 1=on + + group 52 : print graphics + attribute 10 : print barcode with dynamic data 6 and 7 + p1...p5 = kindOf, withText, offset, rotation, dataLeng, see description above + attribute 11 : print QRcode with preset data + + attribute 12 : print Logo + p1=nrOfLogo, p2=offset + + group 53 : print dynamics + attribute 10 : + p1: 1...8 = print dynData 0..7 at this place + + */ + + char prn_clearDocument(uint8_t documentNumber) const override; + // clear memory buffer for ONE document + // function takes a second! don't send right before "store doc" + + bool prn_store_Document(uint8_t documentNumber ) const override; + + // send the predefined Layout (generated with above TD functions) to DeviceController to save + // documentNumber=0...15 + // maximal 1280 bytes each + // allowed: 0x20...0xFF, 0x0A, 0x0C, 0x1B (LF, CR, Esc) + // 0x1B=start of embedded command (next 7bytes = command) + + // with a print command a set of 8 dynamic strings can be sent + // the place in the ticket layout is predefined (already in DC memory) + // the dynamics are first calculated at printing time + + bool prn_printDocument(uint8_t documentNumber, struct T_dynDat *dynTicketData) const override; + + + + + + // ---------------------------------------------------------------------------------------------------------- + // --------------------------------------------- MDB Bus ---------------------------------------------------- + // ---------------------------------------------------------------------------------------------------------- + + //void mdb_switchPower(bool on) const override; defined above + //void mdb_switchWake(bool WAKEACTIVE) const override; defined above +// bool mdb_WakeINisActive(void) const override; +// bool mdb_testIsmdbTxDon(void) const override; +// bool mdb_isMdbPowerOn(void) const override; +// void request_MDB_Status() const override; +// void request_MDB_lastResponse() const override; + + + void mdb_sendBusReset(void) const override; + + void mdb_sendCommand(uint8_t toMdbDevice, uint8_t mdbCommand) const override; + // send one bus command directly over mdb bus, refer to mdb manual for commands + // this command is not needed in normal operation, just for new or special things + + void mdb_sendMessage(uint8_t toMdbDevice, uint8_t mdbCommand, uint8_t nrOfData, uint8_t *dataBuffer) const override; + // nrOfData = sizeOf(dataBuffer) maximal 34 byte according mdb specs + // same as mdb_sendCommand, just with data + + bool mdb_busIsReadyToWork() const override; + + bool mdb_deviceVoltageOK() const override; + + bool mdb_busVoltageOk() const override; + + uint8_t mdb_getLastDeviceResponse(uint8_t *fromDevice, uint8_t *lastRequest, + uint8_t *responseLength, uint8_t *responseBuffer) const override; + // fromDevice: device nr from which data was requested 0,1,2,3 + // lastRequest: sent mdb command + // responseLength: nr of payload data (after mdb-ack) 0...34 + // responseBuffer holds payload data (answer from mdb device) + // return val: mdb result of this request: 1=got ACK 2=got 3xNAK 3=no or bad response 4:got Data (after ACK) + + + + + + // ---------------------------------------------------------------------------------------------------------- + // ---------------------------------- Electronic Coin Validator EMP ----------------------------------------- + // ---------------------------------------------------------------------------------------------------------- + + + void emp_sendSettings(uint16_t coinAcceptance, uint8_t tokenChannel, uint16_t *coinDenomination ) const override; + // coinAcceptance: bit0=coin1 (lowest donomination) bit15=coin16 bitH=accept bit L = deny coin (no validation) + // tokenChannel 0...31: if this signal comes from emp then a token was inserted + // coinDenomination = array of 16 coin values (e.g. 5, 10, 20...) + + void emp_pollingOnOff(uint8_t on) const override; + + void emp_startCoinAcceptance(void) const override; + + void emp_stopCoinAcceptance(void) const override; + + void emp_getAllParameters(struct T_emp *emp) const override; + // see struct in hwapi.h + // usage example: + // hwapi *HWaccess const override; + // HWaccess = new hwapi() const override; + // struct T_emp myEmp const override; + // HWaccess->emp_getAllParameters(&myEmp) const override; + // readval=myEmp.pollingRunning const override; + + uint8_t emp_chkIfCoinInserted(void) const override; + // retval: 0...16 coins left in FIFO + + void emp_getNewCoinRecord(uint8_t *valid, uint8_t *signal, uint8_t *error, uint16_t *value) const override; + // with every call ONE coin is taken out of FIFO and pointer decremented + // valid: should be 1 + // signal: comes right from coin checker, 0...15 (0=first programmed coin type) 0xFF=no signal + // error: was reported from EMP as dynamic signal right after coin insertion (instead of + // coin signal), example: 3=unknown coin 4=coin is blocked by host. 0xFF=no error + // value: of the coin. Depends on parameter "coinDenomination" in function "emp_sendSettings" + // if coinDenomination[coin 0..15] = 0 then the value programmed in coin checker is taken + // if coinDenomination > 0 then this value is taken. + // Useful in case of two currencies (adapt to local currency) or for token. + + // function gives more details as "emp getLastCoin()" but "emp getLastCoin()" is easier to use + + // alternativ to emp_getNewCoinRecord( ): + uint8_t emp_giveLastCoin(uint16_t *value, uint8_t *signal) const override; + // retval: 0: NO coin stored 1: valid coin 2: got wrong coin or coin denied + // value: if retval1: value of the coin if reval=2: error number + // 0xFF means NO error or NO signal (as 0 is a valid error/signal) + // signal: channel nr reported from checker 0...15 + + +/* + + // neu, 25.8.21 + QString dc_getTxt4RsDiagWin(void) const override; + void dc_clrTxt4RsDiagWin(void) const override; + QString dc_get2ndTxt4RsDiagWin(void) const override; + void dc_clr2ndTxt4RsDiagWin(void) const override; + QString dc_getTxt4HsStateLine(void) const override; + void dc_clrTxt4HsStateLine(void) const override; + QString dc_getTxt4masterStateLine(void) const override; + void dc_clrTxt4masterStateLine(void) const override; + QString dc_getTxt4resultStateLine(void) const override; + void dc_clrTxt4resultStateLine(void) const override; + QString dc_getdataStateLine(void) const override; + void dc_clrTxt4dataStateLine(void) const override; + QString dc_getdatifLine(void) const override; + void dc_clrTxt4datifLine(void) const override; + + // using DC2 Bootloader + void bl_iniChain(void) const override; + bool bl_importBinFile(QByteArray readBinFile, uint32_t fileSize, char withDispl) const override; + uint8_t bl_activatBootloader(uint8_t *sendData) const override; + uint8_t bl_startChain(void) const override; + uint8_t bl_readBLversion(uint8_t *sendData) const override; + // minimum size of sendData-buffer: 5byte retval: length + uint8_t bl_readFWversion(uint8_t *sendData) const override; + // minimum size of sendData-buffer: 5byte retval: length + + uint8_t bl_prepareDC_BLcmd(uint8_t Cmd, uint8_t SendDataLength, uint8_t *sendData, uint8_t *outBuf) const override; + // 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 bl_exitBL(uint8_t *sendData) const override; + // minimum size of sendData-buffer: 5byte retval: length +*/ + + /* + uint8_t emp_getInsertedCoinSignal(void) const override; + // can be called one time after each coin + // emp_chkIfCoinInserted() must be called before! + + uint16_t emp_getInsertedCoinValue(void) const override; + // can be called one time after each coin + // emp_chkIfCoinInserted() must be called before! + + uint8_t emp_getCoinError(void) const override; + // can be called one time after each coin + // emp_chkIfCoinInserted() must be called before! + */ + + +private: + void sub_storeSendingText(QByteArray *buf) const; + + + + + +/* + // Modem: + + uint8_t mod_power(bool on) const override; + uint8_t mod_getHwState(struct Tmod_hw_state *mod_hw_state) const override; + uint8_t mod_setCondition(uint16_t chgCmd) const override; // e.g. change to state registered, sleep, open, off.... + uint16_t mod_getCondition(void) const override; // e.g. now socket open + bool mod_sendBufferFree(void) const override; // sending allowed (before writing) and sending finished (after writing) + uint8_t mod_sendDataBlk(uint16_t len, uint8_t *buf) const override; + void mod_wantReadData(uint16_t nrOfData) const override; // start reading + uint16_t mod_gotData(void) const override; // return nr of received bytes + uint8_t mod_loadDataBlk(uint16_t len, uint8_t *buf) const override; + uint8_t mod_setupSerial(struct TserialParams serialParameter) const override; + uint8_t mod_getCurrentSerialSettings(struct TserialParams *serialParameter) const override; + + // Credit Card Terminal: + + uint8_t cc_power(bool on) const override; + uint8_t cc_getHwState(struct Tcc_hw_state *cc_hw_state) const override; + +*/ + +}; + + +#endif + + + + + +/* + // Coin checker and changer mdb4.2 / section 5 + // Level 2 Commands (predefined device msg acc. mdb manual and auto-poll) + uint8_t mdb_coin_startPolling(bool on) const override; // send ether one command (from list below) + // or a poll command in the proper polling grid (e.g. every 100ms) + uint8_t mdb_coin_reset() const override; + uint8_t mdb_coin_setup() const override; + uint8_t mdb_coin_tubestatus() const override; + uint8_t mdb_coin_pollManually(void) const override; + uint8_t mdb_coin_type(uint16_t coinEnable, uint16_t dispenseEnable) const override; + uint8_t mdb_coin_dispense(uint8_t disp) const override; + uint8_t mdb_coin_expansion(uint8_t subCmd, uint8_t send[32]) const override; + uint8_t mdb_coin_getResponse(void) const override; + // 0: no response 1: got ACK 2: got NAK 3 got ACK with additional data + uint8_t mdb_coin_getDataLen(void) const override; + // return nr of byte received from any mdb device + uint8_t mdb_coin_getData(uint8_t *mdb_data, uint8_t maxBufferSize) const override; + + + + // Bill validator // section 6 + uint8_t mdb_bill_startPolling(bool on) const override; + uint8_t mdb_bill_reset() const override; + uint8_t mdb_bill_setup() const override; + uint8_t mdb_bill_security(uint16_t secLevel) const override; + uint8_t mdb_bill_pollManually(void) const override; + uint8_t mdb_bill_billType(uint16_t billEnable, uint16_t escrowEnable) const override; + uint8_t mdb_bill_escrow(uint8_t action) const override; + uint16_t mdb_bill_stacker(void) const override; + uint8_t mdb_bill_expansion(uint8_t subCmd, uint8_t send[32]) const override; + uint8_t mdb_bill_gotPollResponse(void) const override; + // 0: no response 1: got ACK 2: got NAK 3 got ACK with additional data + uint8_t mdb_bill_getDataLen(void) const override; + uint8_t mdb_bill_getPollData(uint8_t *mdb_data, uint8_t maxBufferSize) const override; + + + + // Level 3 Commands - all cash devices are used together and automatically + // -->easiest way to use + + // setting up payment: + uint8_t cash_getAcceptance(struct Tcash_state *cash_state) const override; + // return device specific parameters, (e.g. which tubes are installed) + // to be requested before/after payment + uint8_t cash_setMaxReturn(uint32_t amount) const override; // Security Limit + uint8_t cash_setMaxAcceptance(uint32_t amount) const override; // can pay up to this amount + // example: set to 12€ (=max price step), then the 3rd 5€ bill would be kept in escrow + // or with coins: max. insertable = 13,95€ (11,95€ is still <12€, plus a 2€-coin) + uint8_t cash_setCoinsToBeAccepted(uint16_t coinVal[2][16]) const override; + // up to 16 coins per currency in one or two currencies + // [0]=first currency, e.g. Huf [1]=2nd, like euros + uint8_t cash_setBillsToBeAccepted(uint32_t billVal[2][16]) const override; + uint8_t cash_setOpeningTime(uint16_t opentime_100ms) const override; // coin slot is opening/closing automatically + uint8_t cash_setWaitForLastCoinTime(uint16_t lastCoinTime_100ms) const override; + // while this time coin/bill aceptance is still active after "disable payment" command + uint8_t cash_getAllsettings(struct TcashSettings cashSettings) const override; + // return all above set own parameters + + // starting payment + uint8_t cash_powerUp(bool on) const override; // power up/down devices (bill takes up to 3s) + uint8_t cash_enablePayment(bool start) const override; // start/stop accepting bills and coins + + // running payment + bool gotNewCoinBill(void) const override; // true on every insertion, only once + uint8_t cash_getInserted(struct Tcash_pay *payment_state) const override; + + // finishing payment + uint8_t cash_coinEscrowTake(void) const override; + uint8_t cash_coinEscrowReturn(void) const override; + uint8_t cash_return(uint32_t amount) const override; +*/ + + +/* + uint8_t cc_setCondition(uint16_t chgCmd) const override; // e.g. change to state registered, sleep, open, off.... + uint16_t cc_getCondition(void) const override; // e.g. now socket open + bool cc_sendBufferFree(void) const override; // sending allowed (before writing) and sending finished (after writing) + uint8_t cc_sendDataBlk(uint16_t len, uint8_t *buf) const override; + void cc_wantReadData(uint16_t nrOfData) const override; // start reading + uint16_t cc_gotData(void) const override; // return nr of received bytes + uint8_t cc_loadDataBlk(uint16_t len, uint8_t *buf) const override; + uint8_t cc_getWorkFlow(void) const override; + // off, activated, gotStart_wait4card, wait4pin, gotPin, callingBank, CardAccepted..... + uint8_t cc_setupSerial(struct TserialParams serialParameter) const override; + uint8_t cc_getCurrentSerialSettings(struct TserialParams *serialParameter) const override; +*/ + + +/* + +struct TcashSettings +{ + uint32_t MaxReturnAmount const override; + uint32_t MaxAcceptAmount const override; + uint32_t CoinsAcceptedCur[2][16] const override; + uint32_t BillsAcceptedCur[2][16] const override; + uint32_t availableReturnAmount const override; + +} const override; + + +struct Tcc_hw_state +{ + bool powerRdBk const override; // prn pwr is on + bool rsSwOk const override; // serial switch (printer or modem) is set to CreditCard (iUC) + bool rsDrvOk const override; // RS232 converter for PTU, Printer and Modem in on + uint8_t HwState const override; // idle, off, on, ready + bool gotAnswer const override; // cable OK? + uint8_t moduleType const override; + uint8_t protocolType const override; + +} const override; + + +*/ + + diff --git a/include/interfaces.h b/include/interfaces.h new file mode 100644 index 0000000..aaadf5f --- /dev/null +++ b/include/interfaces.h @@ -0,0 +1,850 @@ +#ifndef INTERFACE_H +#define INTERFACE_H + +//#include + + + struct Tprn_hw_state +{ + // hardware (IO's) + bool powerRdBk; // prn pwr is on + bool rsSwOk; // serial switch (printer or modem) is set to printer + bool rsDrvOk; // RS232 converter for PTU, Printer and Modem in on + + bool ReadyLine; // HW signal from printer showing ready + bool inIdle; // powered and free from errors + bool paperNearEnd; // paper roll runs out + bool noPaper; + bool ErrorTemp; + bool HeadOpen; + bool cutterJam; + bool noResponse; // printer is not connected, cable broken, wrong baudrate + bool badResponse; +}; + + struct Tprn_currentSettings +{ + uint8_t currFont; + uint8_t currSize; + uint8_t currHeigth; + uint8_t currWidth; + bool nowBold; + bool nowInvers; + bool nowUnderlined; + uint8_t currDensity; + uint8_t currSpeed; + bool nowAligned; +}; + + struct T_dynDat +{ + uint8_t licensePlate[8]; + uint8_t vendingPrice[8]; + uint8_t parkingEnd[8]; + uint8_t currentTime[8]; + uint8_t currentDate[8]; + uint8_t dynDat5[8]; + uint8_t dynDat6[8]; + uint8_t dynDat7[8]; +}; + + + struct T_emp +{ + + // Fixdata from EMP: + uint8_t shaft; // = changer level + uint16_t countryCode; + uint8_t scale; + uint8_t decimals; + uint8_t coinValues[16]; + uint16_t routing; + + // Master specs: + uint8_t gotSetup; // 1: got specifications from master 0: no specs + uint16_t coinAccept; // bit 0 = coin1 bit H=accept + uint8_t tokenChannel; + uint16_t denomination[16]; + + // dynamic: + uint8_t state; // step counter of EMP (electronic coin checker) FSM (finite state machine): + // 0=Emp & Bus power off, 1=powered, poll off 2=polling on + // 3=device responded, requesting status + // 4=waiting for status 5=have status, + // 6: IDLE, have paramters from master, polling running, ready for payment + // Master can stop/start polling and acceptance + // 7: end of transaction, polling on, accept off, reporting coins, (wait for last coin) + // 8: transaction running, polling on, acceptance on, reporting coins, + + uint8_t pollingRunning; + uint8_t paymentRunning; + +}; + + + + +class hwinf +{ + +public: + virtual ~hwinf() {} + + virtual void dc_openSerial(int BaudNr, QString BaudStr, QString ComName, uint8_t connect) const =0; + + virtual void dc_closeSerial(void) const =0; + + virtual bool dc_isPortOpen(void) const =0; + + virtual void dc_autoRequest(bool on) const =0; + // select if READ-Requests are sent manually one by one or automatically + // automatically request ALL digital and analog sensors, get time/date, get status information + + virtual void dc_requTestResponse() const =0; + + + virtual bool dc_readAnswTestResponse() const =0; + // retval: true: test was successful, got right response + + virtual uint8_t dc_isRequestDone(void) const =0; + // retval: 0: request is still in progress + // 1: answer from DC2 was OK + // 2: wrong answer from DC2 + + virtual uint16_t dc_getCompletePayLoad(uint16_t plBufSiz, uint8_t *payLoad) const =0; + // get data back in *pl, max 64 byte, can be used for diagnosis + // 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 + + virtual void dc_setWakeFrequency(uint8_t period) const =0; + // RTC wakes DC2 (and PTU) by hardware signal every 32seconds + // change wake signal period to 1...64s + + virtual void dc_OrderToReset(void) const =0; + // want DC2 to reset (in order to start Bootloader) + + virtual QString dc_getSerialState(void) const =0; + virtual void dc_clrSerialStateText(void) const =0; + + virtual void bl_sendDataDirectly(uint8_t length, uint8_t *buf) const =0; + // send without protocol frame, needed for the DC bootloader + + virtual uint8_t getRawRecLength(void) const =0; + + virtual uint8_t getRawReceivedData(uint8_t *receivedData) const =0; + + virtual QString dc_getSerialParams(void) const =0; + + virtual QString dc_getHWversion(void) const =0; + + virtual QString dc_getSWversion(void) const =0; + + virtual QString dc_getState(void) const =0; + + virtual QString dc_getTxt4RsDiagWin(void) const =0; + virtual void dc_clrTxt4RsDiagWin(void) const =0; + virtual QString dc_get2ndTxt4RsDiagWin(void) const =0; + virtual void dc_clr2ndTxt4RsDiagWin(void) const =0; + virtual QString dc_getTxt4HsStateLine(void) const =0; + virtual void dc_clrTxt4HsStateLine(void) const =0; + virtual QString dc_getTxt4masterStateLine(void) const =0; + virtual void dc_clrTxt4masterStateLine(void) const =0; + virtual QString dc_getTxt4resultStateLine(void) const =0; + virtual void dc_clrTxt4resultStateLine(void) const =0; + virtual QString dc_getdataStateLine(void) const =0; + virtual void dc_clrTxt4dataStateLine(void) const =0; + virtual QString dc_getdatifLine(void) const =0; + virtual void dc_clrTxt4datifLine(void) const =0; + + // using DC2 Bootloader + virtual void bl_iniChain(void) const =0; + virtual bool bl_importBinFile(QByteArray readBinFile, uint32_t fileSize, char withDispl) const =0; + virtual uint8_t bl_activatBootloader(uint8_t *sendData) const =0; + virtual uint8_t bl_startChain(void) const =0; + virtual uint8_t bl_readBLversion(uint8_t *sendData) const =0; + // minimum size of sendData-buffer: 5byte retval: length + virtual uint8_t bl_readFWversion(uint8_t *sendData) const =0; + // minimum size of sendData-buffer: 5byte retval: length + + virtual uint8_t bl_prepareDC_BLcmd(uint8_t Cmd, uint8_t SendDataLength, uint8_t *sendData, uint8_t *outBuf) const =0; + // 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 + + virtual uint8_t bl_exitBL(uint8_t *sendData) const =0; + // minimum size of sendData-buffer: 5byte retval: length + + + + + + + + + // ------------------------------------------------------------------------------ + // Level 2 DC2-onboard devices + // WR: set time + // RD. get time, get measure, get test results + // ------------------------------------------------------------------------------ + + // get UID, get time/date test results memory, RTC analog values + + struct Trtc_DateTime + { + uint8_t rtc_hour; + uint8_t rtc_min; + uint8_t rtc_sec; + uint8_t rtc_dayOfMonth; + uint8_t rtc_month; + uint8_t rtc_year; + uint8_t rtc_dayOfWeek; + }; + + virtual uint8_t rtc_getDateTime(struct Trtc_DateTime *rtc_DateTime) const =0; + + virtual uint8_t rtc_setDateTime(void) const =0; + // synch DC2 with PC or PTU system time and date + + virtual void rtc_getTime(uint8_t *hh, uint8_t *mm, uint8_t *ss) const =0; + // get time directly + + virtual void rtc_getDate(uint8_t *yy, uint8_t *mm, uint8_t *dd) const =0; + // get date directly + + virtual uint8_t rtc_getToday(uint8_t *dow, uint16_t *minOfToday, uint32_t *secOfToday) const =0; + // dow=day of week, 1=monday...7 + // minOfToday: 0=midnight...1439= 23:59 + // secOfToday: 0=midnight...86399= 23:59:59 + + virtual bool rtc_isLeapYear(uint8_t *lastLeapYear, uint8_t *NextLeapYear) const =0; + // retval true: this year is leap year + + virtual bool rtc_isLeapYear() const =0; + + virtual void rtc_getWeek(uint8_t *DayOfWeek, uint8_t *HoursOfWeek, uint16_t *MinutesOfWeek) const =0; + // DayOfWeek: 1=monday...7 + // HoursOfWeek: 0=Monday 0:00 o'clock...167=Sunday 23:00 + // MinutesOfWeek: 0=Monday 0:00 o'clock...10079=Sunday 23:59 + + virtual void rtc_getMonth(uint8_t *DayOfMonth, uint16_t *HoursOfMonth, uint16_t *MinutesOfMonth) const =0; + // DayOfMonth: 1...31 + // HoursOfMonth: 0 = 0:00o'clock of 1.day in month up to 743 + // MinutesOfMonth:0 = 0:00o'clock of 1.day in month up to 44639 + + virtual void rtc_getYear(uint16_t *DayOfYear, uint16_t *HoursOfYear, uint32_t *MinutesOfYear) const =0; + // DayOfYear: 1...366 1= 1.Jan of this current year + // HoursOfYear: 0=1.Jan 0:00o'clock ...8783=31.12 23 o'clock + // MinutesOfYear: 0=1.Jan 0:00o'clock ...527039=31.12 23:59 o'clock + + virtual QString rtc_getTimStr(void) const =0; + virtual QString rtc_getDatStr(void) const =0; + virtual QString rtc_getTimDatStr(void) const =0; + + // UID + virtual void dc_getUID8byte(uint8_t *buf8byteUid) const =0; + virtual QString dc_getUIDstr() const =0; + virtual uint64_t dc_getUIDnumber(void) const =0; + + + // Analog inputs: + virtual uint32_t dc_getTemperature(void) const =0; // in Sax-Format 0...400 (0=-50,0°C 100=0,0°C 141=20,5°C 400=150,0°C) + virtual QString dc_getTemperaturStr(void) const =0; + + virtual uint32_t dc_getVoltage(void) const =0; // in mV, 0...65,535V + virtual QString dc_getVoltagStr(void) const =0; + + + + // ------------------------------------------------------------------------------ + // Level 3: digital outputs and simple switching of connected devices + // simple processes like flashing a led or open flap for 1s + // ------------------------------------------------------------------------------ + + virtual void lock_switchContactPower(bool on) const =0; + + // Locks move until stop cmd (0) + virtual uint8_t lock_switchUpperLock(uint8_t dir) const =0; + // dir 0=off 1=up 2=down + virtual uint8_t lock_switchLowerLock(uint8_t dir) const =0; + // dir 0=off 1=up 2=down + + // LEDs + virtual void led_switchLedIllumination(uint8_t on) const =0; + virtual void led_switchLedService(uint8_t on) const =0; + virtual void led_switchLedPaper(uint8_t on, uint8_t ton, uint8_t tof) const =0; + virtual void led_switchLedPinPad(uint8_t on, uint8_t ton, uint8_t tof) const =0; + virtual void led_switchLedStart(uint8_t on, uint8_t ton, uint8_t tof) const =0; + virtual void led_switchLedCoinbassin(uint8_t on, uint8_t ton, uint8_t tof) const =0; + + virtual void fan_switchFan(bool on) const =0; + virtual void laerm_switchSiren(bool on) const =0; + virtual void bar_OpenBarrier(bool open) const =0; + virtual void ptu_switchWake(bool WAKEACTIVE) const =0; + + virtual void prn_switchPower(bool on) const =0; + + virtual void mif_readerOn(bool on) const =0; + + virtual void shut_move(bool open) const =0; + virtual void esc_moveFlaps(uint8_t flap ) const =0; + // 0: close both 1: open take-flap 2: open return + + virtual void mdb_switchPower(bool on) const =0; + virtual void mdb_switchWake(bool WAKEACTIVE) const =0; + + virtual void mod_switchPower(bool on) const =0; + virtual void credit_switchPower(bool on) const =0; + + virtual void aux_power(bool on) const =0; + virtual void aux_setUsage(uint8_t PinDirection) const =0; + virtual void aux_setOutputs(uint8_t PinIsHigh) const =0; + + + virtual void mod_switchWake(bool WAKEACTIVE) const =0; + + virtual void credit_switchWake(bool WAKEACTIVE) const =0; + + + + + // ------------------------------------------------------------------------------ + // Level 3: digital inputs of connected devices + // ------------------------------------------------------------------------------ + + virtual bool door_isContactPowerOn(void) const =0; + + virtual uint8_t door_getSwitches(void) const =0; + // retval: bit0: upper door 1: low door 2:vault door + + virtual bool door_isUpperDoorOpen(void) const =0; + + virtual bool door_isLowerDoorOpen(void) const =0; + + virtual bool vault_isVaultDoorOpen(void) const =0; + + virtual uint8_t vault_getSwitches(void) const =0; + // retval bit0: cash box, bit 1: bill box + + virtual bool vault_isCoinVaultIn(void) const =0; + + virtual bool vault_isBillVaultIn(void) const =0; + + virtual uint8_t door_getLocks(void) const =0; + // retval bit0: upper lever is up + // bit1: upper lever is down + // bit2: lower lever is up + // bit3: lower lever is down + + virtual bool door_upperDoorIsLocked(void) const =0; + + virtual bool door_upperDoorIsUnlocked(void) const =0; + + virtual bool door_lowerDoorIsLocked(void) const =0; + + virtual bool door_lowerDoorIsUnlocked(void) const =0; + + virtual bool bar_optoIn1isOn(void) const =0; + + virtual bool bar_optoIn2isOn(void) const =0; + + virtual bool ptu_WakeINisActive(void) const =0; + + virtual bool prn_isPrinterPowerOn(void) const =0; + virtual bool prn_readyINisActive(void) const =0; + + virtual bool mif_cardIsAttached(void) const =0; + virtual bool mif_isMifarePowerOn(void) const =0; + + virtual bool mdb_WakeINisActive(void) const =0; + virtual bool mdb_testIsmdbTxDon(void) const =0; + virtual bool mdb_isMdbPowerOn(void) const =0; + + virtual bool coid_isAttached(void) const =0; + virtual bool coin_escrowIsOpen(void) const =0; + + virtual bool aux_isAuxPowerOn(void) const =0; + + virtual uint8_t aux_getAuxInputs(void) const =0; + + virtual bool mod_isGsmPowerOn(void) const =0; + + virtual bool cred_isCreditPowerOn(void) const =0; + + + + + + // ------------------------------------------------------------------------------ + // Level1,2,3 RD request commands + // ------------------------------------------------------------------------------ + + // all read-requests can be sent manually by the following functions + // or automatically in background by: void hwapi::dc_autoRequest(bool on) + // in other words: + // if automatic-reading is on, then there's no need to send any of these commands, + // but it's allowed to send them in order to speed up the refreshing of the inputs + + virtual void request_DC2serialConfig() const =0; + virtual void request_DC2_HWversion() const =0; + virtual void request_DC2_SWversion() const =0; + virtual void request_DC2_condition() const =0; + virtual void request_DC2_UID() const =0; + virtual void request_DC2_TimeAndDate() const =0; + virtual void request_DC2_analogues() const =0; + virtual void request_DC2_digitalInputs() const =0; + virtual void request_DC2_digitalOutputs() const =0; + + // ------------------------------------------------------------------------------ + // the folowing device state requests are deploed only if device is powered up: + virtual void request_PrinterHwState() const =0; + virtual void request_PrinterCurrentFonts() const =0; + virtual void request_PrinterStateComplete() const =0; + + virtual void request_MifareReaderState() const =0; + virtual void request_MifareCardType() const =0; + virtual void request_MifareAtbType() const =0; + virtual void request_MifareData() const =0; + + virtual void request_MDB_Status() const =0; + virtual void request_MDB_lastResponse() const =0; + virtual void request_EMP_allParameters() const =0; + virtual void request_EMP_lastCoin() const =0; + + + + // ------------------------------------------------------------------------------ + // Level 3: readback digital outputs of connected devices + // these functions are not needed for normal operation + // but can be used to test and verify conditions + + // There are two options: + // 1) the important things like power-outputs and wake lines are + // measured at DC2-terminals (after transistors) and come as input to DC-board + // 2) others like Leds are read from µC-pins by DC-board + // ------------------------------------------------------------------------------ + + virtual bool test_getDO_mdbRXtst(void) const =0; + + virtual uint8_t lock_getDO_motors(void) const =0; + // bit0: upper lock forward bit 1 backward + // bit2: lower lock forward bit 3 backward + + virtual uint8_t test_serialState(void) const =0; + // test on-board signals for the serials + // serial drv on/off, Serial mux1, Serial mux2 + virtual bool test_serialIsOn(void) const =0; + virtual bool test_serialMux1isSetToPrinter(void) const =0; + virtual bool test_serialMux1isSetToModem(void) const =0; + virtual bool test_serialMux2isSetToCredit(void) const =0; + virtual bool test_serialMux2isSetToMifare(void) const =0; + + virtual bool led_coinIsOn(void) const =0; + virtual bool led_frontIsOn(void) const =0; + virtual bool led_ticketIsOn(void) const =0; + virtual bool led_pinIsOn(void) const =0; + virtual bool led_StartIsOn(void) const =0; + virtual bool led_insideIsOn(void) const =0; + + virtual bool fan_isOn(void) const =0; + virtual bool siren_isOn(void) const =0; + virtual bool bar_relayIsOn(void) const =0; + virtual bool ptu_WakeOutIsOn(void) const =0; + + virtual bool aux_powerIsOn(void) const =0; + + virtual bool coin_shutterIsOpen(void) const =0; + virtual bool coin_shutterTestOutput(void) const =0; + + virtual uint8_t coin_escrowFlapOpened(void) const =0; + // retval: 1:return flap is open 2:take flap is open 0:closed + + + + // ------------------------------------------------------------------------------ + // Level4 ( Timer processes, device supervision by DC, processes with more then one devices + // WRITE + // ------------------------------------------------------------------------------ + + + virtual void sendDeviceSettings(uint8_t kindOfPrinter, uint8_t kindOfCoinChecker, + uint8_t kindOfMifareReader, uint8_t suppressSleep, + uint8_t kindOfModem, uint8_t kindOfCredit ) const =0; + + virtual void request_ReadbackDeviceSettings() const =0; + + virtual void readback_DeviceSettings(uint8_t *length, uint8_t *data) const =0; + // refer to DC2 manual for exact content + // state 5.5.21: byte[0]=kindOfPrinter byte[1]=kindOfCoinChecker + // byte[2]=kindOfMifarereadr byte[3]=suppress sleep mode + // byte[4]=kindOfModem byte[5]=kind of cc terminal + + virtual uint8_t emp_returnLastCoin(uint16_t *value, uint8_t *signal) const =0; + // use for changer + + virtual void sendMachineID(uint16_t customerNr, uint16_t machineNr, + uint16_t borough, uint16_t zone, + uint16_t alias, char *location) const =0; + + virtual void request_ReadbackMachineID() const =0; + + virtual void readback_machineIDdata(uint8_t *length, uint8_t *data) const =0; + // state 5.5.21: byte[0,1]=customer number byte[2,3]=machine number + // byte[4,5]=borough byte[6,7]=zone byte[8,9]=alias name + // byte[10...41]=location + + + // Locks stops automatically at end switch or by timeout + virtual uint8_t lock_openUpperDoor(void) const =0; + virtual uint8_t lock_closeUpperDoor(void) const =0; + + virtual uint8_t lock_openLowerDoor(void) const =0; + virtual uint8_t lock_closeLowerDoor(void) const =0; + + + virtual void shut_openOnce(void) const =0; + // and close automatic after shutter time + + virtual void shut_openForCoin(bool start) const =0; + // open flap if coin is attached + // once process is started it runs until stop command + + virtual void shut_sendOpeningTime(uint16_t timeIn_ms ) const =0; + // after this time without retrigger the flap is closed + + virtual void esc_takeMoney(void) const =0; + // and close automatically after escrow time (1s) + + virtual void esc_returnMoney(void) const =0; + // and close automatically after escrow time (1s) + + virtual void mif_creatAtbCard(uint8_t cardType) const =0; + + + // ------------------------------------------------------------------------------ + // read response from DC2 (input data) + // ------------------------------------------------------------------------------ + + + + /* 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 "ATB25-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 + */ + virtual uint8_t mif_returnReaderStateAndCardType(uint8_t *buf, uint8_t maxBufferSize) const =0; + // retval 0=OK 1=error host buffer too small + + virtual bool mif_readerIsOK(void) const =0; + + virtual bool mif_cardAttached(void) const =0; + + virtual uint8_t mif_readResult(void) const =0; + // result: 0: unknown or still in progress + // 1: card read successful + // 2: reading error + + virtual QString mif_cardUID(void) const =0; + + virtual uint8_t mif_getCardDataDec(uint8_t blkNr, uint8_t *buf, uint8_t maxBufferSize) const =0; + + virtual QString mif_getCardDataStr(uint8_t blockNumber) const =0; + // with blockNumber=0...11 + + + + + // ---------------------------------------------------------------------------------------------------------- + // --------------------------------------------- PRINTER ---------------------------------------------------- + // ---------------------------------------------------------------------------------------------------------- + + // read printer condition and settings + + virtual uint8_t prn_getHwState(struct Tprn_hw_state *prn_hw_state) const =0; + // retval: status byte + // byte 0 = 0: prnter OK, >0: error + // bit0: paper low 1: no paper 2: temperature error + // 3: head open 4: paper jam in cutter + // 6: no response 7: bad response from printer + // and return struct "Tprn_hw_state" + + virtual bool prn_isUpAndReady(void) const =0; + // true: printer is powered, serial is ok, no error, printer is connected and resonding + + virtual void prn_getCurrentFontSetting(struct Tprn_currentSettings *prn_fonts) const =0; + + + // send Commands to printer: + + virtual void prn_sendText(QByteArray *buf) const =0; + // up to 1280 bytes + + virtual void prn_sendPrnSysCmd(uint8_t para1, uint8_t para2, uint32_t para3) const =0; + // send three byte through to printer, see printers manual + + virtual void prn_sendPrnEscCmd(uint8_t para1, uint8_t para2, uint8_t para3, uint8_t para4) const =0; + // send four byte through to printer, see printers manual + + + virtual void prn_sendPrnSetup(uint16_t paperSpeed, uint8_t density, uint8_t alignment, uint8_t orientation) const =0; + // send 5 byte: byte 0,1: speed 5...250 mm/s + // byte2: density 0....(25)....50 + // byte3: alignment 'l', 'c', 'r' = left, center, right + // byte4: orientation 0, 90, 180 = 0°, 90°, 180° rotation (by now not supported!) + // not batched! don't use twice within 100ms + + virtual void prn_movePaper(uint8_t wayInMm, uint8_t direction) const =0; + //direction: 1=forward 2=backward + // + virtual void prn_setFonts(uint8_t font, uint8_t size, uint8_t width, uint8_t height) const =0; + // font = kind of font 5...11 (0..22) + // size = 6...20, 9..9: too tiny 10: small ...12 = normal size ...20=huge + // width: 0...4 0=1x 1=2x 2=4x (huge!) 3=8x 4=16x (3,4 make no sense) + // heigth: 0...7 = 1x...8x only 0,1,2,(3) make sense + + virtual void prn_setLetters(uint8_t bold, uint8_t invers, uint8_t underlined) const =0; + // bold: 0/1 + // invers: 0/1 + // underlined: 0/1 + + virtual void prn_cut(uint8_t kindof) const =0; + // kindof: 1=full cut 2=partial cut 3=eject (5xLF + full cut) + + virtual void prn_newLine(uint8_t nrOfLines) const =0; + + virtual void prn_printCompleteFontTable(void) const =0; + + + virtual void prn_printBarcode(uint8_t kindOf, uint8_t withText, uint8_t offset, uint8_t rotation, uint8_t dataLeng, uint8_t *data) const =0; + // kind of barcode: 0=Code39 1=Code128 2=EAN13 3= 2/5interleaved 4=UPC-A 5=EAN8 + // withText: print readable text below + // offset: move by pixel from left border + // rotation + // dataLeng in byte + + virtual void prn_sendQRdata(QByteArray *buf) const =0; + // maximal 150 alphanummeric bytes + + virtual void prn_printQRcode(void) const =0; + // QRcode may have 1...150 alphanummeric data, must be transfered in advance + + + virtual void prn_printLogo(uint8_t nrOfLogo, uint8_t offset ) const =0; + // nrOfLogo: 1..4 in flash 5...8 in Ram + // offset: in mm form left border + + + + // ......................................................... + // Parking Ticket (print-out document) designer TD + // ......................................................... + + // Predefine document Layout (e.g. parking ticket) in advance and stroe it for quick and easy use + // in opposite to the above "single" commands you need only one or a few commands at vending time. + // Stored text is just send to printer once the printing command is issued + // stored commands within the text are interpreted and executed right at the place (in ticket) they are + // example: start bold, , stop bold + // Predefinition of up to 16 ticket Layouts is possible, 0...1280 byte each + // Number 0..15, al keept non-volatile + // up to 8 dynamic values can be defined in the template ("print val3 here") and will be sent with printing command + // example: print current time at this point (the time of printing not the storage time!!) + + virtual void pri_startTicketDesign(void) const =0; + // start for every new printer document, reseting collecting buffer + + // all further functions write/append text, numbers and command to the ticket-buffer, up to 1278 bytes allowed + // return val of the appending functions: true=ok false=too long, buffer full + + virtual int pri_TD_getCurrentSize(void) const =0; + // retval: 0...1278 + + virtual bool pri_TD_addText(QByteArray text) const =0; + // example: pri_TD_addText("Hello") const =0; + // example: pri_TD_addText(tempStr) const =0; + // retval: true=ok false=too long, buffer full + + virtual bool pri_TD_addValue(int val) const =0; + // +/- 0...2^(31) + + virtual bool pri_TD_addNewLine(void) const =0; + + virtual bool pri_TD_addSign(char sign) const =0; + // example: '.' ' ' 0x20 'W' '$' + + virtual bool pri_TD_addCommand(char group, char attribute, char p1, char p2, char p3, char p4, char p5) const =0; + // always add 8 byte to the ticket layout: ESC & group & attribute & parameter1...5 + /* complete list of possible commands: + group 50 : paper + attribute 10 : move forward + p1: wayInMm p2: direction + attribute 11 : cut + p1: kind of, 1=full 2=partial, 3=eject + attribute 12 : new line(s) + p1: nr of lines 1...100 + + group 51 : fonts + attribute 10 : kind of font see description above + p1: 0...8 + attribute 11 : font size + p1: 6...20 + attribute 12 : font width + p1: 0...4 + attribute 13 : font heigth + p1: 0...7 + attribute 14 : switch bold print on/off + p1: 0=off 1=on + attribute 15 : switch invers print on/off + p1: 0=off 1=on + attribute 16 : switch underlined print on/off + p1: 0=off 1=on + + group 52 : print graphics + attribute 10 : print barcode with dynamic data 6 and 7 + p1...p5 = kindOf, withText, offset, rotation, dataLeng, see description above + attribute 11 : print QRcode with preset data + + attribute 12 : print Logo + p1=nrOfLogo, p2=offset + + group 53 : print dynamics + attribute 10 : + p1: 1...8 = print dynData 0..7 at this place + + */ + + virtual char prn_clearDocument(uint8_t documentNumber) const =0; + // clear memory buffer for ONE document + // function takes a second! don't send right before "store doc" + + virtual bool prn_store_Document(uint8_t documentNumber ) const =0; + // send the predefined Layout (generated with above TD functions) to DeviceController to save + // documentNumber=0...15 + // maximal 1280 bytes each + // allowed: 0x20...0xFF, 0x0A, 0x0C, 0x1B (LF, CR, Esc) + // 0x1B=start of embedded command (next 7bytes = command) + + // with a print command a set of 8 dynamic strings can be sent + // the place in the ticket layout is predefined (already in DC memory) + // the dynamics are first calculated at printing time + + virtual bool prn_printDocument(uint8_t documentNumber, struct T_dynDat *dynTicketData) const =0; + + + + + + // ---------------------------------------------------------------------------------------------------------- + // --------------------------------------------- MDB Bus ---------------------------------------------------- + // ---------------------------------------------------------------------------------------------------------- + + //void mdb_switchPower(bool on) const =0; defined above + //void mdb_switchWake(bool WAKEACTIVE) const =0; defined above +// bool mdb_WakeINisActive(void) const =0; +// bool mdb_testIsmdbTxDon(void) const =0; +// bool mdb_isMdbPowerOn(void) const =0; +// void request_MDB_Status() const =0; +// void request_MDB_lastResponse() const =0; + + + virtual void mdb_sendBusReset(void) const =0; + + virtual void mdb_sendCommand(uint8_t toMdbDevice, uint8_t mdbCommand) const =0; + // send one bus command directly over mdb bus, refer to mdb manual for commands + // this command is not needed in normal operation, just for new or special things + + virtual void mdb_sendMessage(uint8_t toMdbDevice, uint8_t mdbCommand, uint8_t nrOfData, uint8_t *dataBuffer) const =0; + // nrOfData = sizeOf(dataBuffer) maximal 34 byte according mdb specs + // same as mdb_sendCommand, just with data + + virtual bool mdb_busIsReadyToWork() const =0; + + virtual bool mdb_deviceVoltageOK() const =0; + + virtual bool mdb_busVoltageOk() const =0; + + virtual uint8_t mdb_getLastDeviceResponse(uint8_t *fromDevice, uint8_t *lastRequest, + uint8_t *responseLength, uint8_t *responseBuffer) const =0; + // fromDevice: device nr from which data was requested 0,1,2,3 + // lastRequest: sent mdb command + // responseLength: nr of payload data (after mdb-ack) 0...34 + // responseBuffer holds payload data (answer from mdb device) + // return val: mdb result of this request: 1=got ACK 2=got 3xNAK 3=no or bad response 4:got Data (after ACK) + + + + + + // ---------------------------------------------------------------------------------------------------------- + // ---------------------------------- Electronic Coin Validator EMP ----------------------------------------- + // ---------------------------------------------------------------------------------------------------------- + + + virtual void emp_sendSettings(uint16_t coinAcceptance, uint8_t tokenChannel, uint16_t *coinDenomination ) const =0; + // coinAcceptance: bit0=coin1 (lowest donomination) bit15=coin16 bitH=accept bit L = deny coin (no validation) + // tokenChannel 0...31: if this signal comes from emp then a token was inserted + // coinDenomination = array of 16 coin values (e.g. 5, 10, 20...) + + virtual void emp_pollingOnOff(uint8_t on) const =0; + + virtual void emp_startCoinAcceptance(void) const =0; + + virtual void emp_stopCoinAcceptance(void) const =0; + + virtual void emp_getAllParameters(struct T_emp *emp) const =0; + // see struct in hwapi.h + // usage example: + // hwapi *HWaccess const =0; + // HWaccess = new hwapi() const =0; + // struct T_emp myEmp const =0; + // HWaccess->emp_getAllParameters(&myEmp) const =0; + // readval=myEmp.pollingRunning const =0; + + virtual uint8_t emp_chkIfCoinInserted(void) const =0; + // retval: 0...16 coins left in FIFO + + virtual void emp_getNewCoinRecord(uint8_t *valid, uint8_t *signal, uint8_t *error, uint16_t *value) const =0; + // with every call ONE coin is taken out of FIFO and pointer decremented + // valid: should be 1 + // signal: comes right from coin checker, 0...15 (0=first programmed coin type) 0xFF=no signal + // error: was reported from EMP as dynamic signal right after coin insertion (instead of + // coin signal), example: 3=unknown coin 4=coin is blocked by host. 0xFF=no error + // value: of the coin. Depends on parameter "coinDenomination" in function "emp_sendSettings" + // if coinDenomination[coin 0..15] = 0 then the value programmed in coin checker is taken + // if coinDenomination > 0 then this value is taken. + // Useful in case of two currencies (adapt to local currency) or for token. + + // function gives more details as "emp getLastCoin()" but "emp getLastCoin()" is easier to use + + // alternativ to emp_getNewCoinRecord( ): + virtual uint8_t emp_giveLastCoin(uint16_t *value, uint8_t *signal) const =0; + // retval: 0: NO coin stored 1: valid coin 2: got wrong coin or coin denied + // value: if retval1: value of the coin if reval=2: error number + // 0xFF means NO error or NO signal (as 0 is a valid error/signal) + // signal: channel nr reported from checker 0...15 + + + +}; + + +#endif + + + diff --git a/include/prot.h b/include/prot.h new file mode 100644 index 0000000..9bca6c2 --- /dev/null +++ b/include/prot.h @@ -0,0 +1,101 @@ + +#ifndef SERIAL_FRAME_H +#define SERIAL_FRAME_H + +#include +#include +#include +#include +#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 + +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); + uint8_t FramecheckInData(uint8_t *Inbuf, uint16_t LL); + uint8_t CheckInResult(uint8_t *Inbuf); + uint8_t CheckInData(uint8_t *recBuffer); + +private slots: + void analyseRecData(void); + +public: + 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 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 diff --git a/include/sendWRcmd.h b/include/sendWRcmd.h new file mode 100644 index 0000000..a986f82 --- /dev/null +++ b/include/sendWRcmd.h @@ -0,0 +1,217 @@ + +#ifndef SENDWRCMDS_DEFS_H +#define SENDWRCMDS_DEFS_H + +#include +#include "tslib.h" +#include + +// 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_MIFREADER 123 + // Type and state of reader + +#define SEND_REQU_MIFCARD 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 + + +#endif + + diff --git a/include/storeINdata.h b/include/storeINdata.h new file mode 100644 index 0000000..5f8f4a3 --- /dev/null +++ b/include/storeINdata.h @@ -0,0 +1,489 @@ + +#ifndef STOREINDATA_H +#define STOREINDATA_H + +#include +#include "tslib.h" +#include + + +#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 *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); +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 + +void gpi_storeDI_auxIn(uint8_t indatAuxIn); + // Aux0...5 + +uint8_t epi_getDI_auxIn(void); + // bit0: auxin 1 ... 5: auxin 6 + +void gpi_storeDI_ptuWake(uint8_t indat); + +bool epi_getDI_ptuWake(void); + +void gpi_storeDI_mbdWake(uint8_t indat); + +bool epi_getDI_mdbWake(void); + +void gpi_storeDI_prnReady(uint8_t indat); + +bool epi_getDI_prnReady(void); + +void gpi_storeDI_CoinAttach(uint8_t indat); + +bool epi_getDI_CoinAttach(void); + +void gpi_storeDI_CoinEscrow(uint8_t indat); + +bool epi_getDI_CoinEscrow(void); + +void gpi_storeDI_mifareCardTapped(uint8_t indat); + +bool epi_getDI_mifareCardTapped(void); + +void gpi_storeDI_modemWake(uint8_t indat); + +bool epi_getDI_modemWake(void); + + +void gpi_storeDI_contactPowerIsOn(bool di_contact_PwrOn); + +bool epi_getDI_contactPwr(void); + +void gpi_storeDI_MifarePowerIsOn(bool di_mifare_PwrOn); + +bool epi_getDI_mifarePwr(void); + +void gpi_storeDI_readbackMdbTxD(bool di_rdbkMdbTxd); + +bool epi_getDI_mdbTxd(void); + +void gpi_storeDI_AuxPowerIsOn(bool di_Aux_PwrOn); + +bool epi_getDI_auxPwr(void); + +void gpi_storeDI_GsmPowerIsOn(bool di_gsm_PwrOn); + +bool epi_getDI_gsmPwr(void); + +void gpi_storeDI_CreditPowerIsOn(bool di_credit_PwrOn); + +bool epi_getDI_creditPwr(void); + +void gpi_storeDI_PrinterPowerIsOn(bool di_printer_PwrOn); + +bool epi_getDI_printerPwr(void); + +void gpi_storeDI_MdbPowerIsOn(bool di_mdb_PwrOn); + +bool epi_getDI_mdbPwr(void); + + +void gpi_storeDI_rejMot_home(bool di); + +bool epi_getDI_rejectMotor_homepos(void); + +void gpi_storeDI_paperLow(bool di); + +bool epi_getDI_npe_sensor(void); + + + + + + + + + + + + + + + + + +// /////////////////////////////////////////////////////////////////////////////////// +// readback digital outputs +// /////////////////////////////////////////////////////////////////////////////////// + +void gpi_storeDO_mdbRxTst(uint8_t do_mbdRxTst); + +bool epi_getDO_mdbRxTestOut(void); + + +void 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 + + +void 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 + + +void 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); + +void gpi_storeDO_sirenAndRelay(uint8_t sirenRelay); + +bool epi_getDO_sirene(void); + +bool epi_getDO_relay(void); + +void gpi_storeDO_ptuWake(uint8_t state); + +bool epi_getDO_ptuWake(void); + +void gpi_storeDO_auxPower(uint8_t pwr); + +bool epi_getDO_auxPower(void); + + +void gpi_storeDO_coinShutter(uint8_t state); + +bool epi_getDO_coinShutterOpen(void); + +bool epi_getDO_coinShutterTest(void); + + +void 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 + + +void 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 *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 + +void gpi_storeMifCardData(uint8_t blkNr, uint8_t *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] + + + + +#define pi_prnStateArraySize 20 +#define pi_prnFontArraySize 20 + +void epi_restorePrinterState(uint8_t *buf); + +void gpi_storePrinterState(uint8_t *buf); + +void epi_restorePrinterFonts(uint8_t *buf); + +void gpi_storePrinterFonts(uint8_t *buf); + + + + +void gpi_storeMdbState(uint8_t busReady, uint8_t V12on, uint8_t V5on ); + +bool epi_restoreMdbBusReady(void); + +bool epi_restoreMdbV12Ready(void); + +bool epi_restoreMdbV5Ready(void); + + +void gpi_storeMdbResponse(uint8_t leng, uint8_t *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 *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(); +*/ + +#define MEMDEPTH_GOTCOINS 16 + +void gpi_storeEmpCoinSignal(uint8_t leng, uint8_t *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_storeDeviceSettings(uint8_t leng, uint8_t *data); + +void epi_restoreDeviceSettings(uint8_t *leng, uint8_t *data); + +void gpi_storeMachineIDsettings(uint8_t leng, uint8_t *data); + +void epi_restoreMachineIDsettings(uint8_t *leng, uint8_t *data); + + +#endif + + + diff --git a/include/tslib.h b/include/tslib.h new file mode 100644 index 0000000..ec24fae --- /dev/null +++ b/include/tslib.h @@ -0,0 +1,84 @@ +#ifndef TSLIB_H +#define TSLIB_H +#include +#include + + +#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); + + +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); + +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); + + + +#endif // TSLIB_H