348 lines
9.2 KiB
C++
348 lines
9.2 KiB
C++
#ifndef SHARED_MEM_BUFFER_INCLUDED_H
|
|
#define SHARED_MEM_BUFFER_INCLUDED_H
|
|
|
|
#include <cinttypes>
|
|
#include <atomic>
|
|
|
|
#include <QSharedMemory>
|
|
|
|
// TODO: pid eintragen und convars/mutexe eintragen
|
|
|
|
#ifdef __linux__
|
|
|
|
|
|
#include <pthread.h>
|
|
|
|
// PTHREAD_PROCESS_SHARED
|
|
|
|
#else
|
|
// WIN32
|
|
#endif
|
|
|
|
struct SharedMemBuffer {
|
|
int init;
|
|
char appName[32];
|
|
pid_t pid;
|
|
pthread_condattr_t sndCndA;
|
|
pthread_cond_t sndCndV;
|
|
pthread_mutexattr_t sndMtxA;
|
|
pthread_mutex_t sndMtx;
|
|
|
|
pthread_condattr_t rcvCndA;
|
|
pthread_cond_t rcvCndV;
|
|
pthread_mutexattr_t rcvMtxA;
|
|
pthread_mutex_t rcvMtx;
|
|
|
|
struct rs {
|
|
char comportName[16]; // z.B. "COM48"
|
|
char baudStr[16]; // z.B. "19200"
|
|
int baudNr; // 0...5 oder -1
|
|
uint8_t connect; // 0,1
|
|
bool portIsOpen;
|
|
} rs;
|
|
|
|
char AutoEmissionOn; // 1: zyklisch Anfragen zum Slave senden
|
|
|
|
struct datif {
|
|
#define DATIF_MAXCMDS 16
|
|
uint16_t sendingPeriod;
|
|
bool sendingPer_changed;
|
|
uint8_t OutCmdpara1;
|
|
uint8_t OutCmdpara2;
|
|
uint8_t OutCmdpara3;
|
|
uint8_t OutCmdpara4;
|
|
uint16_t OutCmdpara5;
|
|
uint32_t OutCmdpara6;
|
|
uint8_t dataStep;
|
|
uint8_t scanStep;
|
|
uint8_t RDBLKNR;
|
|
uint8_t cycl_running;
|
|
} datif;
|
|
|
|
struct txt4 {
|
|
char comStateLine[32];
|
|
char HsStateLine[32];
|
|
char masterStateLine[32];
|
|
char resultStateLine[32];
|
|
char dataLine[32];
|
|
char datifReceive[32];
|
|
char diagWindow[32];
|
|
char sndDiagWindow[32];
|
|
} txt4;
|
|
|
|
struct dcBL {
|
|
#define SIZEBLRESP 50
|
|
#define RAW_BL_DATALEN 150
|
|
uint8_t LastBLcmd; // stored the last sent cmd in order to analys response
|
|
uint8_t AtbBinFile[300000];
|
|
uint32_t fileSize;
|
|
uint16_t nrOfBlocks;
|
|
uint16_t fileCrc;
|
|
uint8_t myBuf[300000]; // same content like "dcBL_AtbBinFile" but bytewise
|
|
char Resp[SIZEBLRESP][32];
|
|
int pResp;
|
|
uint8_t step;
|
|
uint8_t state;
|
|
uint16_t BlkCtr;
|
|
uint16_t cyclCtr;
|
|
uint16_t repeatCtr;
|
|
} dcBL;
|
|
|
|
struct {
|
|
uint16_t shutterTime;
|
|
char ticketTemplate[1024];
|
|
} hwapi;
|
|
|
|
struct {
|
|
uint8_t sendAsynchDataBuf[160]; // no stack, only ONE buffer
|
|
uint8_t sendAsyDatLen;
|
|
} next;
|
|
|
|
struct { // highest priority
|
|
#define CMDSTACKDEPTH 16
|
|
// up to 16 cmd can be stored. They are issued one by one every 100ms
|
|
uint16_t AsynchSend[CMDSTACKDEPTH];
|
|
uint8_t para1[CMDSTACKDEPTH]; /* used to streamline source */
|
|
uint8_t para2[CMDSTACKDEPTH]; /* used to streamline source */
|
|
uint8_t para3[CMDSTACKDEPTH]; /* used to streamline source */
|
|
uint8_t para4[CMDSTACKDEPTH]; /* used to streamline source */
|
|
uint8_t nrOfCmdsInQueue;
|
|
} Cmd0;
|
|
|
|
struct { // lower priority
|
|
// Command Stack for commands with 4 parameters
|
|
#define CMD4STACKDEPTH 8
|
|
uint16_t AsynchSend[CMD4STACKDEPTH];
|
|
uint8_t para1[CMD4STACKDEPTH];
|
|
uint8_t para2[CMD4STACKDEPTH];
|
|
uint8_t para3[CMD4STACKDEPTH];
|
|
uint8_t para4[CMD4STACKDEPTH];
|
|
uint8_t nrOfCmdsInQueue;
|
|
} Cmd4;
|
|
|
|
struct {
|
|
#define CMD8STACKDEPTH 4
|
|
uint16_t AsynchSend[CMD8STACKDEPTH];
|
|
uint8_t para1[CMD8STACKDEPTH];
|
|
uint8_t para2[CMD8STACKDEPTH];
|
|
uint16_t para3[CMD8STACKDEPTH];
|
|
uint32_t para4[CMD8STACKDEPTH];
|
|
uint8_t nrOfCmdsInQueue;
|
|
} Cmd8;
|
|
|
|
struct { // short command, 4 data bytes
|
|
#define FDCMD_STACKDEPTH 16
|
|
uint8_t wrCmd[FDCMD_STACKDEPTH];
|
|
uint8_t rdCmd[FDCMD_STACKDEPTH];
|
|
uint8_t blkNr[FDCMD_STACKDEPTH];
|
|
uint8_t para1[FDCMD_STACKDEPTH];
|
|
uint8_t para2[FDCMD_STACKDEPTH];
|
|
uint8_t para3[FDCMD_STACKDEPTH];
|
|
uint8_t para4[FDCMD_STACKDEPTH];
|
|
uint8_t cmdsInQueue;
|
|
} FDShort;
|
|
|
|
struct { // long command, 64 data bytes
|
|
#define FDLONG_STACKDEPTH 16
|
|
uint8_t wrCmd[FDLONG_STACKDEPTH];
|
|
uint8_t rdCmd[FDLONG_STACKDEPTH];
|
|
uint8_t blkNr[FDLONG_STACKDEPTH];
|
|
uint8_t length[FDLONG_STACKDEPTH];
|
|
uint8_t para[FDLONG_STACKDEPTH][64];
|
|
uint8_t cmdsInQueue;
|
|
} FDLong;
|
|
|
|
struct {
|
|
uint8_t DataParameters[4];
|
|
uint8_t DataBufferUser;
|
|
uint8_t pDataBuff; // points to next PRINTER_BLOCK
|
|
} prn;
|
|
|
|
struct {
|
|
bool savePrnPwr;
|
|
bool saveMifPwr;
|
|
bool MdbIsOn;
|
|
} indat;
|
|
|
|
uint8_t ndbs;
|
|
uint8_t pari;
|
|
uint8_t nsb;
|
|
uint8_t br;
|
|
|
|
#define MAXNROF_GENSTR 16
|
|
char genStrings[MAXNROF_GENSTR][64];
|
|
|
|
#define MAXNROF_AI 4
|
|
uint16_t AI_val[MAXNROF_AI];
|
|
|
|
struct DigitalInputs {
|
|
uint8_t doorSwitch;
|
|
uint8_t vaultSwitch;
|
|
uint8_t lockSwitch;
|
|
uint8_t opto;
|
|
uint8_t aux;
|
|
bool wakeFromPtu;
|
|
bool wakeFromMdb;
|
|
bool wakeFromModem;
|
|
bool PrnReady;
|
|
bool CoinAttach;
|
|
bool CoinEscrowOpen;
|
|
bool mifCardTap;
|
|
bool contactPwrOn;
|
|
bool mifarePwrOn;
|
|
bool rdbk_mdbTxd;
|
|
bool AuxPwrOn;
|
|
bool gsmPwrOn;
|
|
bool creditPwrOn;
|
|
bool printerPwrOn;
|
|
bool mdbPwrOn;
|
|
bool rejMot_home;
|
|
uint8_t npe_sensor;
|
|
} din;
|
|
|
|
struct DigitalOutputs {
|
|
uint8_t mbdRxTst;
|
|
uint8_t motorBits;
|
|
uint8_t serialSwitch; // serial drv on/off, Serial mux1, Serial mux2
|
|
uint8_t ledsAndFan;
|
|
uint8_t laermUndRelay;
|
|
uint8_t ptuWake;
|
|
uint8_t auxPower;
|
|
uint8_t coinShutter;
|
|
uint8_t coinEscrow;
|
|
uint8_t printerPower;
|
|
} dout;
|
|
|
|
struct Sdata {
|
|
#define NROFMIFSTATEBYTES 40
|
|
#define PRN_STATE_ARRAY_SIZE 20
|
|
#define PRN_STATE_FONT_SIZE 20
|
|
#define MAXNROF_PRNBYTES 64
|
|
#define MAXNROF_PRNBLOCKS 20
|
|
uint8_t MIF_STATE[NROFMIFSTATEBYTES];
|
|
uint8_t MIF_DATA[12][64];
|
|
uint8_t PRN_STATE[PRN_STATE_ARRAY_SIZE];
|
|
uint8_t PRN_FONTS[PRN_STATE_FONT_SIZE];
|
|
char PRN_TEXT[MAXNROF_PRNBLOCKS][MAXNROF_PRNBYTES];
|
|
bool mdb_busRdy;
|
|
bool mdb_V12on;
|
|
bool mdb_V5on;
|
|
uint8_t mdbNrOfRecData;
|
|
uint8_t RecBuff[40];
|
|
uint8_t empNrOfsettings;
|
|
uint8_t emp_settingsBuff[66];
|
|
uint8_t NrOfDeviceSetting;
|
|
uint8_t DeviceSettingBuff[66];
|
|
uint8_t NrOfMachineIDSetting;
|
|
uint8_t NrOfMachineIDBuff[66];
|
|
uint64_t slaveUID;
|
|
uint8_t UIDstr[8];
|
|
#define MAXNROF_MEASURE 4
|
|
uint32_t measurement[MAXNROF_MEASURE];
|
|
bool serialTestResult;
|
|
uint8_t pProtResultOk;
|
|
uint16_t receivedDataLength;
|
|
uint8_t receivedDataBlock[64];
|
|
uint8_t rawData[150];
|
|
uint8_t LengthRawData;
|
|
uint8_t mdbSendBuffer[64];
|
|
uint8_t mdbSendLen;
|
|
} Sdata;
|
|
|
|
uint8_t mif_cardType;
|
|
uint8_t mif_cardHolder[8];
|
|
|
|
#define MEMDEPTH_GOTCOINS (16)
|
|
struct T_coin {
|
|
uint8_t valid;
|
|
uint8_t signal;
|
|
uint8_t error;
|
|
uint8_t pad;
|
|
uint16_t value;
|
|
} gotCoin[MEMDEPTH_GOTCOINS];
|
|
uint8_t ctr_gotCoin;
|
|
|
|
struct store {
|
|
uint32_t insertedAmount;
|
|
uint16_t lastCoinType[64];
|
|
uint16_t lastCoinValue[64];
|
|
uint64_t wakeSrc;
|
|
uint8_t rbDevParamLen;
|
|
uint8_t rbDevParams[66];
|
|
uint8_t deviceCondLen;
|
|
uint8_t deviceCond[66];
|
|
uint8_t machCondLen;
|
|
uint8_t machCond[66];
|
|
uint8_t DcBackupNrOfAccNr;
|
|
uint16_t DcBackupAccNr[16]; // z.Z. nur 8
|
|
uint8_t gotNrBlocksOfVaultRec;
|
|
uint8_t vaultrecord[360];
|
|
uint32_t amount;
|
|
uint16_t nrOfCoins;
|
|
} store;
|
|
|
|
struct T_globTime {
|
|
// Reihenfolge nicht vertauschen!!!!!
|
|
uint8_t hour;
|
|
uint8_t minute;
|
|
uint8_t second;
|
|
uint8_t Year;
|
|
uint8_t Month;
|
|
uint8_t DayOfMonth;
|
|
uint8_t DayOfWeek; // 1=monday...7
|
|
uint8_t reserve1;
|
|
|
|
uint16_t MinutesOfToday;
|
|
uint16_t reserve2;
|
|
|
|
uint32_t SecondsOfToday;
|
|
|
|
uint8_t IsLeapyear;
|
|
uint8_t nextLeap;
|
|
uint8_t lastLeap;
|
|
uint8_t hoursOfWeek;
|
|
|
|
uint16_t minOfWeek;
|
|
uint16_t hoursOfMonth;
|
|
uint16_t minOfMonth;
|
|
uint16_t dayOfYear;
|
|
uint16_t hoursOfYear;
|
|
uint16_t reserve3;
|
|
|
|
uint32_t minOfYear;
|
|
|
|
uint8_t squareOutMode;
|
|
uint8_t free1;
|
|
uint16_t reserve4;
|
|
uint32_t minOfMillenium;
|
|
// bis hierher 44byts
|
|
uint32_t free2;
|
|
uint32_t free3;
|
|
uint32_t free4;
|
|
} getGlobalTime;
|
|
|
|
static QSharedMemory *getShm(std::size_t s = 0);
|
|
static SharedMemBuffer *getData() {
|
|
return (SharedMemBuffer *)getShm()->data();
|
|
}
|
|
static SharedMemBuffer const *getDataConst() {
|
|
return (SharedMemBuffer const *)getShm()->data();
|
|
}
|
|
|
|
#if 0
|
|
static std::atomic<bool> __sharedMemLocked;
|
|
|
|
static bool sharedMemLocked() {
|
|
return __sharedMemLocked;
|
|
}
|
|
static void setSharedMemLocked() {
|
|
__sharedMemLocked = true;
|
|
}
|
|
static void setSharedMemUnlocked() {
|
|
__sharedMemLocked = false;
|
|
}
|
|
#endif
|
|
};
|
|
|
|
#endif // SHARED_MEM_BUFFER_INCLUDED_H
|