GerhardHoffmann/DCPlugin
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Checking to test compilation

Browse Source
This commit is contained in:
Gerhard Hoffmann
2023-04-26 14:39:32 +02:00
parent d992ee3fad
commit fb75074955
15 changed files with 1520 additions and 1633 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/dcBL.h
View File

@@ -78,7 +78,7 @@ uint8_t dcBL_getResult(void);
#define RAW_BL_DATALEN 150
void gpi_storeRawReceivedData(uint8_t RdDlen, uint8_t *receivedData);
void gpi_storeRawReceivedData(uint8_t RdDlen, uint8_t const *receivedData);
uint8_t epi_getRawReceivedData(uint8_t *receivedData);
// retval=length, will be zeroed after first reading

22
include/sendWRcmd.h
View File

@@ -148,21 +148,23 @@
// highest priority
#define CMDSTACKDEPTH 16
// #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);
bool sendWRcmd_setSendCommand0(uint16_t nextCmd, uint8_t dat1=0, uint8_t dat2=0,
uint8_t dat3=0, uint8_t dat4=0);
// GUI or app sends a command to DC transfered by serial
uint16_t sendWRcmd_getSendCommand0(void);
uint16_t sendWRcmd_getSendCommand0(uint8_t *dat1=0, uint8_t *dat2=0,
uint8_t *dat3=0, uint8_t *dat4=0);
// lower priority
#define CMD4STACKDEPTH 8
// #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
// #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);
@@ -171,7 +173,7 @@ uint16_t sendWRcmd_getSendCommand8(uint8_t *dat1, uint8_t *dat2, uint16_t *dat3,
// lowest priority
// wait for resonse before send next!
bool sendWRcmd_setSendBlock160(uint8_t leng, uint8_t *buf);
bool sendWRcmd_setSendBlock160(uint8_t leng, uint8_t const *buf);
uint8_t sendWRcmd_getSendBlock160(uint8_t *leng, uint8_t *buf);
// retval = *leng
@@ -179,7 +181,7 @@ void sendWRcmd_INI(void);
uint8_t epi_store64ByteSendData(uint8_t length, uint8_t *buf);
uint8_t epi_store64ByteSendData(uint8_t length, uint8_t const *buf);
// HWapi writes data to be forwarded to DC and further to mdb-device
// not batched! don't use twice within 100ms
@@ -211,7 +213,7 @@ uint8_t gpi_getUserOfSendingTextBuffer(uint8_t *para1, uint8_t *para2, uint8_t *
// user=1: Text-Print is using this buffer
// 2: QR-code-Printer is using this buffer
#define FDCMD_STACKDEPTH 16
//#define FDCMD_STACKDEPTH 16
void sendFDcmd_clrStack(void);
bool sendFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4);
// write Command to memory, wait for transport
@@ -223,9 +225,9 @@ uint8_t check4FDshortCmd(void);
uint8_t check4freeFDshortCmd(void);
// returns number of free places in short-command stack
#define FDLONG_STACKDEPTH 16
//#define FDLONG_STACKDEPTH 16
void longFDcmd_clrStack(void);
bool longFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t length, uint8_t *data);
bool longFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t length, uint8_t const *data);
// write Command to memory, wait for transport
// data buffer size always 64! data[64], padded with 0
bool longFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *length, uint8_t *data);

22
include/serial_port_thread.h Normal file
View File

@@ -0,0 +1,22 @@
#ifndef SERIAL_PORT_THREAD_H_INCLUDED
#define SERIAL_PORT_THREAD_H_INCLUDED
#include <QThread>
#include <QString>
#include <QEventLoop>
class SerialPortThread : public QThread {
Q_OBJECT
QEventLoop m_loop;
public:
SerialPortThread(QObject *parent = nullptr);
virtual ~SerialPortThread();
virtual void run() override;
QEventLoop &getEventLoop() { return m_loop; }
};
#endif // SERIAL_PORT_THREAD_H_INCLUDED

121
include/serial_port_worker.h Normal file
View File

@@ -0,0 +1,121 @@
#ifndef SERIAL_PORT_WORKER_H_INCLUDED
#define SERIAL_PORT_WORKER_H_INCLUDED
#include <QObject>
#include <QString>
#include <QTimer>
#include <QSerialPort>
#include <QSerialPortInfo>
#include <QThread>
#include <assert.h>
#include <condition_variable>
#include <mutex>
#include <queue>
#include <deque>
#include <iostream>
#include <atomic>
struct Command {
enum : uint16_t {PRIORITY_1, PRIORITY_2, PRIORITY_3, PRIORITY_4, END_MARK};
enum : uint16_t {QUIT_SENTINEL = 0x1000, SEND_BLOCK_SIZE = 160};
uint32_t m_priority;
uint16_t m_priorityClass;
uint16_t m_cmdId;
char *m_sendBuffer;
char *m_recvBuffer;
uint8_t m_sendBufferLength;
uint8_t m_recvBufferLength; // expected result length
static std::atomic<uint8_t> m_nextSendBufferIndex;
static std::atomic<uint8_t> m_nextRecvBufferIndex;
static char m_sendBuffers[256][SEND_BLOCK_SIZE];
static char m_recvBuffers[256][SEND_BLOCK_SIZE];
static uint32_t getNextCommandPriority(uint8_t cmdType);
static char *getNextSendBuffer();
static char *getNextRecvBuffer();
public:
Command(uint16_t cmdId, uint8_t sendBufferLength, uint8_t recvBufferLength, uint8_t priorityClass);
Command();
friend bool operator< (Command const& lhs, Command const& rhs) {
return lhs.m_priority < rhs.m_priority;
}
friend std::ostream& operator<< (std::ostream& os, Command const& cmd) {
return os << "{ " << cmd.m_priority << ", '" << cmd.m_priority << "' } ";
}
};
/// \brief SerialPortWorker
///
/// SerialPortWorker sends and receives data from serial port
///
class SerialPortWorker : public QThread {
Q_OBJECT
/// \brief Internal serial port.
QSerialPort m_serialPort;
/// \brief Internal serial port info.
QSerialPortInfo m_serialPortInfo;
/// \brief Flag indicating if serial port is opened.
bool m_serialPortOpened;
/// \brief Port name of serial port.
QString m_portName;
/// \brief Baudrate of internal serial port.
enum QSerialPort::BaudRate m_baudRate;
std::priority_queue<Command, std::deque<Command>> m_sendQueue;
std::deque<Command> m_recvQueue;
std::mutex m_sendQueueMutex;
std::mutex m_recvQueueMutex;
std::condition_variable m_sendQueueCondVar;
std::condition_variable m_recvQueueCondVar;
std::atomic<uint32_t> m_bytesWritten;
std::atomic<uint32_t> m_bytesAvailable;
SerialPortWorker(QString portName, QSerialPort::BaudRate baudRate, QObject *parent = nullptr);
Command getNextCommand();
void insertResult(Command const &result);
enum : uint16_t {TIMEOUT = 100, WAIT_TIME_MAX = 1000};
public:
~SerialPortWorker();
SerialPortWorker(SerialPortWorker const &) = delete;
void operator=(SerialPortWorker const &) = delete;
// serial port im plugin anlegen. erst dann kann getInstance() benutzt werden
static SerialPortWorker &getInstance(QString portName, QSerialPort::BaudRate baudRate, QObject *parent = nullptr) {
static SerialPortWorker serialPortWorker(portName, baudRate, parent);
return serialPortWorker;
}
bool openSerialPort();
void closeSerialPort();
bool isPortOpen() const { return m_serialPortOpened; }
void insertCommand(Command const &cmd);
bool getNextResult(Command &result, int timeout = 1000);
virtual void run() override;
void quit();
private slots:
void getBytesAvailable();
bool getNumberOfBytesWritten(qint64);
};
#endif // SERIAL_PORT_WORKER_H_INCLUDED

232
include/shared_mem_buffer.h
View File

@@ -6,7 +6,33 @@
#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"
@@ -18,109 +44,130 @@ struct SharedMemBuffer {
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;
#if 0
// controlBus.cpp
char txt4comStateLine[32];
char txt4HsStateLine[32];
char txt4masterStateLine[32];
char txt4resultStateLine[32];
char txt4dataLine[32];
char txt4datifReceive[32];
char txt4diagWindow[32];
char sndTxt4diagWindow[32];
bool Sdata_serialTestResult[32];
uint8_t Sdata_pProtResultOk[32];
uint16_t Sdata_receivedDataLength[32];
uint8_t Sdata_receivedDataBlock[64];
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;
// datif.cpp
uint8_t dif_dataStep;
uint8_t dif_scanStep;
uint8_t RDBLKNR;
uint8_t datif_OutCmdpara1;
uint8_t datif_OutCmdpara2;
uint8_t datif_OutCmdpara3;
uint8_t datif_OutCmdpara4;
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;
uint16_t datif_OutCmdpara5;
uint32_t datif_OutCmdpara6;
uint8_t cycl_running;
struct {
uint16_t shutterTime;
char ticketTemplate[1024];
} hwapi;
// dcBL.cpp
uint8_t dcBL_LastBLcmd; // stored the last sent cmd in order to analys response
uint8_t dcBL_AtbBinFile[300000];
uint32_t dcBL_fileSize;
uint16_t dcBL_nrOfBlocks;
uint16_t dcBL_fileCrc;
uint8_t dcBL_myBuf[300000]; // same content like "dcBL_AtbBinFile" but bytewise
struct {
uint8_t sendAsynchDataBuf[160]; // no stack, only ONE buffer
uint8_t sendAsyDatLen;
} next;
char BlResp[50][32];
uint8_t dcBL_step;
uint8_t dcBL_state;
uint16_t dcBL_BlkCtr;
uint16_t dcBL_cyclCtr;
uint16_t repeatCtr;
uint8_t Sdata_rawData[150];
uint8_t Sdata_LengthRawData;
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;
// hwapi.cpp
uint16_t hwapi_shutterTime;
char ticketTemplate[1024];
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;
// sendWRcmd.cpp
uint16_t nextAsynchsendCmd0[16];
uint8_t nrOfCmdsInQueue;
uint16_t nextAsynchsendCmd4[8];
uint8_t nextCmd4para1[8];
uint8_t nextCmd4para2[8];
uint8_t nextCmd4para3[8];
uint8_t nextCmd4para4[8];
uint8_t nrOfCmds4InQueue;
uint16_t nextAsynchsendCmd8[4];
uint8_t nextCmd8para1[4];
uint8_t nextCmd8para2[4];
uint16_t nextCmd8para3[4];
uint32_t nextCmd8para4[4];
uint8_t nrOfCmds8InQueue;
uint8_t sendAsynchDataBuf[160]; // no stack, only ONE buffer
uint8_t sendAsyDatLen;
uint8_t Sdata_mdbSendBuffer[64];
uint8_t Sdata_mdbSendLen;
uint8_t prnDataParameters[4];
uint8_t prnDataBufferUser;
char Sdata_PRN_TEXT[20][64];
uint8_t pPrnDataBuff; // points to next PRINTER_BLOCK
uint8_t nextFDwrCmd[16];
uint8_t nextFDrdCmd[16];
uint8_t nextFDblkNr[16];
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;
uint8_t nextFDpara1[16];
uint8_t nextFDpara2[16];
uint8_t nextFDpara3[16];
uint8_t nextFDpara4[16];
uint8_t p_nextFDcmdsInQueue;
uint8_t longFDwrCmd[16];
uint8_t longFDrdCmd[16];
uint8_t longFDblkNr[16];
uint8_t longFDlength[16];
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;
uint8_t longFDpara[16][64];
uint8_t p_longFDcmdsInQueue;
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;
// storeInData.cpp
bool indat_savePrnPwr;
bool indat_saveMifPwr;
bool indat_MdbIsOn;
#endif
struct {
uint8_t DataParameters[4];
uint8_t DataBufferUser;
uint8_t pDataBuff; // points to next PRINTER_BLOCK
} prn;
uint8_t ndbs;
uint8_t pari;
uint8_t nsb;
uint8_t br;
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];
@@ -170,10 +217,13 @@ struct SharedMemBuffer {
#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;
@@ -193,6 +243,10 @@ struct SharedMemBuffer {
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;