forked from GerhardHoffmann/DCLibraries
Start repository
This commit is contained in:
429
src/com.cpp
Normal file
429
src/com.cpp
Normal file
@@ -0,0 +1,429 @@
|
||||
#include "com.h"
|
||||
#include <QDebug>
|
||||
//#include "controlBus.h"
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
///
|
||||
/// serial hardware layer
|
||||
///
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
|
||||
static int64_t com_want2read;
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
// --------- PUBLIC --------------------------------------------------------------------------------------------
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
|
||||
void T_com::writeToSerial(const QByteArray &data, uint16_t sendLength)
|
||||
{
|
||||
sendBuffer=data;
|
||||
sendLen=sendLength;
|
||||
if (CatSerial->isOpen())
|
||||
{
|
||||
//qDebug() << "sending..." << sendBuffer;
|
||||
CatSerial->write(sendBuffer);
|
||||
} else
|
||||
qDebug() << "error sending, port is not open";
|
||||
|
||||
}
|
||||
|
||||
|
||||
bool T_com::readFromSerial(QByteArray &data, uint16_t &sendLength)
|
||||
{
|
||||
// return one time true if new data (completly) read.
|
||||
// return new data in &data and &sendLength to other objects
|
||||
uint16_t ll=rawInLen;
|
||||
if (!CatSerial->isOpen())
|
||||
return false;
|
||||
data.clear();
|
||||
data.append(rawInput);
|
||||
sendLength=ll;
|
||||
rawInLen=0; // beim 2. Aufruf 0 zurück weil nichts neues da
|
||||
if (ll>0)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
// --------- PRIVATES --------------------------------------------------------------------------------------
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
|
||||
|
||||
T_com::T_com(QObject *parent) : QObject(parent)
|
||||
{
|
||||
// port settings come from tabCom->Sdata->serial
|
||||
|
||||
gpi_serialChanged();
|
||||
CatSerial = new QSerialPort(); // PortHW object for Control&Analyse Tool
|
||||
//CatSerial->clear();
|
||||
//CatSerial->clearError();
|
||||
|
||||
connect(CatSerial, &QSerialPort::readyRead, this, &T_com::readSomeBytes);
|
||||
// still reading, not sure if complete, undefined number of calls while reading
|
||||
|
||||
connect(CatSerial, &QSerialPort::bytesWritten, this, &T_com::serialSendComplete);
|
||||
// system confirms sending complete
|
||||
|
||||
//connect(CatSerial, &QSerialPort::dataTerminalReadyChanged, this, &T_com::incomingWake);
|
||||
//connect(CatSerial, &QSerialPort::requestToSendChanged, this, &T_com::incomingWake);
|
||||
|
||||
// timer detects time gap in input flow
|
||||
serRecTime = new QTimer();
|
||||
connect(serRecTime, SIGNAL(timeout()), this, SLOT(receiveTO()));
|
||||
serRecTime->setSingleShot(true); // single shot! only one impulse if receive complete
|
||||
serRecTime->stop(); // on hold
|
||||
|
||||
// check COM-TAB periodic if user wants to connect or disconnect
|
||||
QTimer *ChkConnectTimer = new QTimer();
|
||||
connect(ChkConnectTimer, SIGNAL(timeout()), this, SLOT(ser_ISR100ms()));
|
||||
ChkConnectTimer->setSingleShot(false);
|
||||
ChkConnectTimer->start(100); // in ms
|
||||
com_want2read=0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
T_com::~T_com()
|
||||
{
|
||||
if (CatSerial->isOpen())
|
||||
CatSerial->close();
|
||||
}
|
||||
|
||||
|
||||
void T_com::ser_ISR100ms()
|
||||
{
|
||||
// call every 100ms to check if user(HMI) wants to connect or disconnect
|
||||
|
||||
//qDebug() << "~~>LIB" << "checking connect button... " ;
|
||||
|
||||
uint8_t chkConn = gpi_getSerialConn(); // from global GUI buffer (Sdata)
|
||||
switch (chkConn)
|
||||
{
|
||||
case 0: // 0 button "connect" was just released
|
||||
closeSerialPort();
|
||||
gpi_serialChanged(); // set chkConn to 2, thus getting edge
|
||||
break;
|
||||
case 1: // 1 button "connect" was just pressed
|
||||
open_Serial_Port();
|
||||
gpi_serialChanged(); // set chkConn to 2, thus getting edge
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
if (CatSerial->isOpen())
|
||||
gpi_serialIsOpen(true);
|
||||
else
|
||||
gpi_serialIsOpen(false);
|
||||
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
|
||||
char T_com::open_Serial_Port()
|
||||
{
|
||||
bool ret;
|
||||
QString myString=nullptr, myPortName=nullptr, myBaudStr=nullptr;
|
||||
int myBaudNr;
|
||||
|
||||
if (CatSerial->isOpen())
|
||||
return 0; // opening twice is not allowed
|
||||
|
||||
//qDebug() << "connecting..." << myPortName;
|
||||
myPortName=gpi_getComPortName(); // was selected and stored from GUI
|
||||
CatSerial->setPortName(myPortName);
|
||||
myBaudNr=gpi_getBaudNr(); // was selected and stored from GUI
|
||||
switch (myBaudNr)
|
||||
{
|
||||
// 0:1200 1:9600 2:19200 3:38400 4:57600 5:115200
|
||||
case 0: CatSerial->setBaudRate(QSerialPort::Baud1200); myBaudStr="1200"; break;
|
||||
case 1: CatSerial->setBaudRate(QSerialPort::Baud9600); myBaudStr="9600"; break;
|
||||
case 2: CatSerial->setBaudRate(QSerialPort::Baud19200); myBaudStr="19200"; break;
|
||||
case 3: CatSerial->setBaudRate(QSerialPort::Baud38400); myBaudStr="38400"; break;
|
||||
case 4: CatSerial->setBaudRate(QSerialPort::Baud57600); myBaudStr="57600"; break;
|
||||
case 5: CatSerial->setBaudRate(QSerialPort::Baud115200); myBaudStr="115200"; break;
|
||||
}
|
||||
|
||||
CatSerial->setDataBits(QSerialPort::Data8);
|
||||
// alt: QSerialPort::Data5,6,7,8
|
||||
|
||||
CatSerial->setParity(QSerialPort::NoParity);
|
||||
// alt: EvenParity, OddParity, NoParity
|
||||
|
||||
CatSerial->setStopBits(QSerialPort::OneStop);
|
||||
// alternative: OneStop, TwoStop, OneAndHalfStop
|
||||
|
||||
CatSerial->setFlowControl(QSerialPort::NoFlowControl);
|
||||
// alt: HardwareControl, SoftwareControl, NoFlowControl
|
||||
|
||||
ret=CatSerial->open(QIODevice::ReadWrite);
|
||||
// alt: QIODevice::ReadWrite QIODevice::ReadOnly QIODevice::WriteOnly
|
||||
if (!ret)
|
||||
{
|
||||
myString.clear();
|
||||
myString = "error ";
|
||||
myString.append(CatSerial->errorString());
|
||||
qDebug() << myString;
|
||||
gpi_setTxt4comStateLine(myString);
|
||||
return 0;
|
||||
} else
|
||||
{
|
||||
myString.clear();
|
||||
myString.append(myPortName);
|
||||
//lang=myString.size();
|
||||
myString.append(" opened with ");
|
||||
myString.append(myBaudStr);
|
||||
myString.append(" 8N1");
|
||||
qDebug() << myString;
|
||||
gpi_setTxt4comStateLine(myString);
|
||||
gpi_setTxt4RsDiagWin(myString+"\n");
|
||||
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void T_com::closeSerialPort()
|
||||
{
|
||||
if (CatSerial->isOpen())
|
||||
{
|
||||
qDebug() << "closing connection";
|
||||
CatSerial->close();
|
||||
gpi_setTxt4comStateLine("closed");
|
||||
gpi_setTxt4RsDiagWin("closed");
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void T_com::readSomeBytes(void)
|
||||
{
|
||||
// called by serial-read-detection
|
||||
// restart off-time as input flow is ongoing
|
||||
|
||||
// timer for slow receive
|
||||
// and serves as timeout for fast receive is msg is shorter as expected
|
||||
serRecTime->stop();
|
||||
serRecTime->start(20); // in ms
|
||||
|
||||
//qDebug()<< "com-rec read some bytes";
|
||||
|
||||
this->receiveByLength(); // since 14.12.21: fast receive
|
||||
}
|
||||
|
||||
void T_com::receiveFixLen(int64_t nrOfbytesToReceive)
|
||||
{
|
||||
// call this before sending a request to slave
|
||||
// then we know exactly when reception is complete -> much faster
|
||||
com_want2read=nrOfbytesToReceive;
|
||||
// since 14.12.21: FastDevice Protocol has two lengthen:
|
||||
// fast: 12byte reception long: 68byte
|
||||
}
|
||||
|
||||
void T_com::receiveByLength(void)
|
||||
{
|
||||
|
||||
if (CatSerial->isOpen())
|
||||
{
|
||||
QString myString=nullptr, tmpStr=nullptr;
|
||||
int64_t nrOfBytesreceived = CatSerial->bytesAvailable(); // nr of received bytes
|
||||
|
||||
//qDebug()<< "com-rec current Len: "<< nrOfBytesreceived;
|
||||
|
||||
if (nrOfBytesreceived >= com_want2read)
|
||||
{
|
||||
QByteArray data = CatSerial->readAll(); // erst auslesen wenn alles da! löscht den Empfangspuffer
|
||||
serRecTime->stop(); // stop timeout to avoid 2nd emit
|
||||
rawInLen=uint16_t (nrOfBytesreceived);
|
||||
rawInput.clear();
|
||||
rawInput.append(data);
|
||||
//qDebug()<< "com-recFinished by Len "<< rawInLen;
|
||||
gpi_set2ndTxt4RsDiagWin(myString); // 4.10.23 hier neu
|
||||
emit receivingFinished();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void T_com::receiveTO(void)
|
||||
{
|
||||
// no new input data for 20ms, --> assuming frame complete
|
||||
// save data in private "rawInput"-buffer
|
||||
|
||||
if (CatSerial->isOpen())
|
||||
{
|
||||
|
||||
QString myString=nullptr, tmpStr=nullptr;
|
||||
int64_t nrOfBytesreceived = CatSerial->bytesAvailable(); // nr of received bytes
|
||||
QByteArray data = CatSerial->readAll();
|
||||
|
||||
rawInLen=uint16_t (nrOfBytesreceived);
|
||||
rawInput.clear();
|
||||
rawInput.append(data);
|
||||
//rawInput[rawInLen]=0; // Zwangsterminierung bei QByteArray nicht nötig
|
||||
|
||||
// diag display in serial in/out window and debug window
|
||||
myString.clear();
|
||||
myString.setNum(rawInLen);
|
||||
myString.append(" in: ");
|
||||
//myString.append(rawInput);
|
||||
for (int ii=0; ii<rawInLen; ii++)
|
||||
{
|
||||
tmpStr.clear();
|
||||
tmpStr.setNum(rawInput[ii],16); // problem: wenn >0x80 dann wird EIN Byte 16 stellig angezeigt
|
||||
int ll=tmpStr.length();
|
||||
if (ll>2)
|
||||
{
|
||||
myString.append(tmpStr[ll-2]);
|
||||
myString.append(tmpStr[ll-1]);
|
||||
} else
|
||||
{
|
||||
myString.append(tmpStr);
|
||||
}
|
||||
myString.append(" ");
|
||||
}
|
||||
myString.append("\n");
|
||||
#ifdef PRINTALLDEBUGS
|
||||
qDebug() << "VCP:" << myString; // display all inputs and outputs in output window
|
||||
#endif
|
||||
//gpi_setTxt4RsDiagWin(myString);
|
||||
gpi_set2ndTxt4RsDiagWin(myString); // 4.10.23: diese verwenden weil die gpi_setTxt4RsDiagWin() durch Ausgabe ueberschrieben wird
|
||||
//qDebug()<< "com-recFinished by TO";
|
||||
emit receivingFinished();
|
||||
}
|
||||
}
|
||||
|
||||
void T_com::serialSendComplete(void)
|
||||
{
|
||||
// system confirms sending complete, diag display
|
||||
QString myString=nullptr, tmpStr=nullptr;
|
||||
|
||||
myString.clear();
|
||||
myString.setNum(sendLen);
|
||||
myString.append(" out: ");
|
||||
|
||||
for (int ii=0; ii<sendLen; ii++)
|
||||
{
|
||||
tmpStr.clear();
|
||||
tmpStr.setNum(sendBuffer[ii],16); // problem: wenn >0x80 dann 16stellig
|
||||
int ll=tmpStr.length();
|
||||
if (ll>2)
|
||||
{
|
||||
//qDebug() << "long_string" << ll << "\n";
|
||||
myString.append(tmpStr[ll-2]);
|
||||
myString.append(tmpStr[ll-1]);
|
||||
|
||||
} else
|
||||
{
|
||||
myString.append(tmpStr);
|
||||
}
|
||||
myString.append(" ");
|
||||
}
|
||||
|
||||
#ifdef PRINTALLDEBUGS
|
||||
myString.append("\n");
|
||||
qDebug() << myString; // display all output data in out-window
|
||||
#endif
|
||||
|
||||
gpi_setTxt4RsDiagWin(myString);
|
||||
|
||||
emit sendingFinished(); // for whom it may interest
|
||||
}
|
||||
|
||||
|
||||
bool T_com::isPortOpen(void)
|
||||
{
|
||||
if (CatSerial->isOpen())
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
|
||||
/*
|
||||
uint8_t T_com::getAllPortPins(void)
|
||||
{
|
||||
uint8_t rs232pins=0;
|
||||
rs232pins= uint8_t(CatSerial->pinoutSignals());
|
||||
// rs232pins: all signals bitwise coded in one byte:
|
||||
// readback output: bit 0=TxD(=output) bit2=DTR (=output) bit 6=RTS (=output)
|
||||
// unused inputs: bit1=RxD bit 3=DCD bit 5 = RING
|
||||
// handshake inputs: bit 4=DSR (0x10) bit 7=CTS (0x80)
|
||||
//qDebug()<<"serial port pins: " << rs232pins;
|
||||
return rs232pins;
|
||||
}
|
||||
|
||||
bool T_com::getHSin_CTS(void)
|
||||
{
|
||||
// return the used Handshake IN (CTS, alt. DSR): true= high level (+8V)
|
||||
|
||||
uint8_t rs232pins=0;
|
||||
|
||||
rs232pins= uint8_t(CatSerial->pinoutSignals());
|
||||
// rs232pins: all signals bitwise coded in one byte:
|
||||
// readback output: bit 0=TxD(=output) bit2=DTR (=output) bit 6=RTS (=output)
|
||||
// unused inputs: bit1=RxD bit 3=DCD bit 5 = RING
|
||||
// handshake inputs: bit 4=DSR (0x10) bit 7=CTS (0x80)
|
||||
|
||||
if (rs232pins & 0x80) // CTS
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool T_com::getHSin_DSR(void)
|
||||
{
|
||||
uint8_t rs232pins=0;
|
||||
rs232pins= uint8_t(CatSerial->pinoutSignals());
|
||||
if (rs232pins & 0x10) // DSR
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
void T_com::incomingWake(void) //(bool LevelOfTheBit)
|
||||
{
|
||||
emit wasWokenBySerialHandshake();
|
||||
}
|
||||
|
||||
bool T_com::setHSout_RTS(bool hsout)
|
||||
{
|
||||
// hsout true=positiv voltage +12V false= -12V
|
||||
// retval: true=setting OK
|
||||
|
||||
bool cc;
|
||||
// 10.5.19, am Windows-PC nachgemessen, funktioniert gut
|
||||
// false ergibt -12V true ergibt +12V
|
||||
|
||||
cc=CatSerial->setRequestToSend(hsout); // RTS out
|
||||
// retval true means "setting was successful"
|
||||
|
||||
// alternative: use DTR as Handshake:
|
||||
//cc=CatSerial->setDataTerminalReady(false); // DTR out
|
||||
// retval true means "setting was successful"
|
||||
//qDebug()<<"RTS " <<cc;
|
||||
return cc;
|
||||
}
|
||||
|
||||
bool T_com::setHSout_DTR(bool hsout)
|
||||
{
|
||||
// hsout true=positiv voltage +12V false= -12V
|
||||
// retval: true=setting OK
|
||||
|
||||
bool cc;
|
||||
// 10.5.19, am Windows-PC nachgemessen, funktioniert gut
|
||||
// false ergibt -12V true ergibt +12V
|
||||
|
||||
cc=CatSerial->setDataTerminalReady(hsout); // DTR out
|
||||
// retval true means "setting was successful"
|
||||
//qDebug()<<"DTR " <<cc;
|
||||
return cc;
|
||||
}
|
||||
*/
|
||||
510
src/controlBus.cpp
Normal file
510
src/controlBus.cpp
Normal file
@@ -0,0 +1,510 @@
|
||||
#include "controlBus.h"
|
||||
|
||||
|
||||
// ///////////////////////////////////////////////////////////////////////////////////
|
||||
// control serial interface gui <--> serial
|
||||
// ///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
|
||||
static QString rs_comportName; // z.B. "COM48"
|
||||
static QString rs_baudStr; // z.B. "19200"
|
||||
static int rs_baudNr; //0...5 oder -1
|
||||
static uint8_t rs_connect; // 0,1
|
||||
|
||||
void epi_setSerial(int BaudNr, QString BaudStr, QString ComName, uint8_t connect)
|
||||
{
|
||||
rs_comportName = ComName;
|
||||
rs_baudStr = BaudStr;
|
||||
rs_baudNr = BaudNr; // 0=1200 1=9600 2=19200 3=38400 4=57600 5=115200 oder -1
|
||||
rs_connect = connect; // 0/1
|
||||
|
||||
}
|
||||
|
||||
void epi_closeSerial(void)
|
||||
{
|
||||
rs_connect=0;
|
||||
}
|
||||
|
||||
void gpi_serialChanged(void)
|
||||
{
|
||||
// serial confirms that port was closed or opened
|
||||
rs_connect=2; // Flanke, nur 1x öffnen/schließen
|
||||
}
|
||||
|
||||
uint8_t gpi_getSerialConn(void)
|
||||
{
|
||||
return rs_connect;
|
||||
}
|
||||
|
||||
int gpi_getBaudNr(void)
|
||||
{
|
||||
return rs_baudNr;
|
||||
}
|
||||
|
||||
QString gpi_getComPortName(void)
|
||||
{
|
||||
return rs_comportName;
|
||||
}
|
||||
|
||||
//#endif
|
||||
|
||||
void gpi_serialIsOpen(bool offen)
|
||||
{
|
||||
SharedMem::write()->rs_portIsOpen=offen;
|
||||
|
||||
}
|
||||
|
||||
bool epi_isSerialPortOpen()
|
||||
{
|
||||
// true: port is open false: port is closed
|
||||
return SharedMem::read()->rs_portIsOpen;
|
||||
}
|
||||
|
||||
// ///////////////////////////////////////////////////////////////////////////////////
|
||||
// Control transfer gui <--> serial
|
||||
// ///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
void epi_startEmmision(bool start)
|
||||
{
|
||||
SharedMem::write()->AutoEmissionOn=start;
|
||||
}
|
||||
|
||||
bool gpi_isEmmisionOn(void)
|
||||
{
|
||||
// used in HWapi
|
||||
return SharedMem::read()->AutoEmissionOn;
|
||||
}
|
||||
|
||||
// ///////////////////////////////////////////////////////////////////////////////////
|
||||
// Status Display gui <--> serial
|
||||
// ///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
// linke Spalte, über Connect Button
|
||||
static QString txt4comStateLine;
|
||||
|
||||
QString epi_getTxt4comStateLine(void)
|
||||
{
|
||||
// GUI: get Text for serial Comport-State Line
|
||||
return txt4comStateLine;
|
||||
}
|
||||
|
||||
void gpi_setTxt4comStateLine(QString txtline) // gpi
|
||||
{
|
||||
// serial: write Text to be displayed in serial Comport-State line (like "connected")
|
||||
txt4comStateLine.clear();
|
||||
if (txtline=="")
|
||||
txt4comStateLine.clear();
|
||||
else
|
||||
txt4comStateLine=txtline;
|
||||
}
|
||||
|
||||
void epi_clrTxt4comStateLine()
|
||||
{
|
||||
txt4comStateLine.clear();
|
||||
}
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------------------------
|
||||
|
||||
// rechte Spalte, oberste Statuszeile
|
||||
// I) "Handshakes" (serial Control) flow.cpp
|
||||
// geht überhaupt was raus? kommt überhaupt was zurück?
|
||||
static QString txt4HsStateLine;
|
||||
|
||||
QString epi_getTxt4HsStateLine(void)
|
||||
{
|
||||
return txt4HsStateLine;
|
||||
}
|
||||
|
||||
void gpi_setTxt4HsStateLine(QString txtline)
|
||||
{
|
||||
txt4HsStateLine.clear();
|
||||
if (txtline=="")
|
||||
txt4HsStateLine.clear();
|
||||
else
|
||||
txt4HsStateLine=txtline;
|
||||
}
|
||||
|
||||
void epi_clrTxt4HsStateLine()
|
||||
{
|
||||
txt4HsStateLine.clear();
|
||||
}
|
||||
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------------------------
|
||||
|
||||
// II) Master receive state (empfangenes Telgramm OK? crc? length? )
|
||||
// Statuszeile Auswertung der SlaveResponse (serial Frame, CRC usw) (prot.cpp)
|
||||
static QString txt4masterStateLine;
|
||||
|
||||
QString epi_getTxt4masterStateLine(void)
|
||||
{
|
||||
return txt4masterStateLine;
|
||||
}
|
||||
|
||||
void gpi_setTxt4masterStateLine(QString txtline)
|
||||
{
|
||||
txt4masterStateLine.clear();
|
||||
if (txtline=="")
|
||||
txt4masterStateLine.clear();
|
||||
else
|
||||
txt4masterStateLine=txtline;
|
||||
}
|
||||
|
||||
void epi_clrTxt4masterStateLine()
|
||||
{
|
||||
txt4masterStateLine.clear();
|
||||
}
|
||||
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------------------------
|
||||
|
||||
// III Slave receive (from Master) OK? if then show results, if not then show errors
|
||||
// entweder Empfangsfehler anzeigen (crc? length?) oder result OUT-OK, OUT_ERR, IN_OK, IN_ERR
|
||||
// Hintergrund: wenn der Slave Fehler im Master-Telegramm gefunden hat, dann kann er es auch
|
||||
// nicht verwenden und nichts ausgeben oder einlesen
|
||||
|
||||
static QString txt4resultStateLine;
|
||||
|
||||
QString epi_getTxt4resultStateLine(void)
|
||||
{
|
||||
return txt4resultStateLine;
|
||||
}
|
||||
|
||||
void gpi_setTxt4resultStateLine(QString txtline)
|
||||
{
|
||||
txt4resultStateLine.clear();
|
||||
if (txtline=="")
|
||||
txt4resultStateLine.clear();
|
||||
else
|
||||
txt4resultStateLine=txtline;
|
||||
}
|
||||
|
||||
void epi_clrTxt4resultStateLine()
|
||||
{
|
||||
txt4resultStateLine.clear();
|
||||
}
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------------------------
|
||||
|
||||
// IV Statuszeile Empfangsdaten
|
||||
static QString txt4dataLine;
|
||||
|
||||
QString epi_getTxt4dataStateLine(void)
|
||||
{
|
||||
// GUI: get Text for serial Comport-State Line
|
||||
return txt4dataLine;
|
||||
|
||||
}
|
||||
|
||||
void gpi_setTxt4dataStateLine(QString txtline)
|
||||
{
|
||||
// serial: write Text to be displayed in serial Comport-State line (like "connected")
|
||||
txt4dataLine.clear();
|
||||
if (txtline=="")
|
||||
txt4dataLine.clear();
|
||||
else
|
||||
txt4dataLine=txtline;
|
||||
}
|
||||
|
||||
void epi_clrTxt4dataStateLine()
|
||||
{
|
||||
txt4dataLine.clear();
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------------------
|
||||
|
||||
// 5. Zeile: Datif Ergebnis, Daten brauchbar?
|
||||
|
||||
static QString txt4datifReceive;
|
||||
|
||||
QString epi_getTxt4datifLine(void)
|
||||
{
|
||||
|
||||
return txt4datifReceive;
|
||||
|
||||
}
|
||||
|
||||
void gpi_setTxt4datifLine(QString txtline)
|
||||
{
|
||||
|
||||
txt4datifReceive.clear();
|
||||
if (txtline=="")
|
||||
txt4datifReceive.clear();
|
||||
else
|
||||
txt4datifReceive=txtline;
|
||||
}
|
||||
|
||||
void epi_clrTxt4datifLine()
|
||||
{
|
||||
txt4datifReceive.clear();
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------------------------
|
||||
|
||||
static QString txt4diagWindow;
|
||||
|
||||
QString epi_getTxt4RsDiagWin(void)
|
||||
{
|
||||
return txt4diagWindow;
|
||||
|
||||
}
|
||||
|
||||
void gpi_setTxt4RsDiagWin(QString txtline)
|
||||
{
|
||||
txt4diagWindow.clear();
|
||||
if (txtline=="")
|
||||
txt4diagWindow.clear();
|
||||
else
|
||||
txt4diagWindow=txtline;
|
||||
}
|
||||
|
||||
void epi_clrTxt4RsDiagWin()
|
||||
{
|
||||
txt4diagWindow.clear();
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------------------
|
||||
|
||||
static QString sndTxt4diagWindow;
|
||||
|
||||
QString epi_get2ndTxt4RsDiagWin(void)
|
||||
{
|
||||
return sndTxt4diagWindow;
|
||||
|
||||
}
|
||||
|
||||
void gpi_set2ndTxt4RsDiagWin(QString txtline)
|
||||
{
|
||||
sndTxt4diagWindow.clear();
|
||||
if (txtline=="")
|
||||
sndTxt4diagWindow.clear();
|
||||
else
|
||||
sndTxt4diagWindow=txtline;
|
||||
}
|
||||
|
||||
void epi_clr2ndTxt4RsDiagWin()
|
||||
{
|
||||
sndTxt4diagWindow.clear();
|
||||
}
|
||||
|
||||
|
||||
// ///////////////////////////////////////////////////////////////////////////////////
|
||||
// Memory for Slave responses, common data
|
||||
// ///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//static bool Sdata_serialTestResult;
|
||||
|
||||
void gpi_storeResult_serialTestOK(bool wasOk)
|
||||
{
|
||||
//Sdata_serialTestResult=wasOk;
|
||||
SharedMem::write()->Sdata_serialTestResult=wasOk;
|
||||
}
|
||||
|
||||
bool epi_getResult_serialTestOK()
|
||||
{
|
||||
// retval: true: test was successful, got right response
|
||||
//return Sdata_serialTestResult;
|
||||
return SharedMem::read()->Sdata_serialTestResult;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// ///////////////////////////////////////////////////////////////////////////////////
|
||||
// Store received data for hwapi
|
||||
// ///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//static uint8_t Sdata_pProtResultOk;
|
||||
|
||||
void gpi_startNewRequest()
|
||||
{
|
||||
//Sdata_pProtResultOk=0;
|
||||
SharedMem::write()->Sdata_pProtResultOk=0;
|
||||
SharedMem::write()->Sdata_lastResult=0;
|
||||
}
|
||||
|
||||
void gpi_storeResultOfLastRequest(bool answisok)
|
||||
{
|
||||
if (answisok)
|
||||
//Sdata_pProtResultOk=1;
|
||||
SharedMem::write()->Sdata_pProtResultOk=1;
|
||||
else
|
||||
//Sdata_pProtResultOk=2;
|
||||
SharedMem::write()->Sdata_pProtResultOk=2;
|
||||
}
|
||||
|
||||
uint8_t epi_getResultOfLastRequest()
|
||||
{
|
||||
// retval: 0: in progress 1: OK 2: error
|
||||
//return Sdata_pProtResultOk;
|
||||
return SharedMem::read()->Sdata_pProtResultOk;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//static uint16_t Sdata_receivedDataLength;
|
||||
//static uint8_t Sdata_receivedDataBlock[64];
|
||||
|
||||
void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t *receivedData)
|
||||
{
|
||||
SharedMem::write()->Sdata_receivedDataLength=uint16_t(RdDlen);
|
||||
if (SharedMem::read()->Sdata_receivedDataLength>64)
|
||||
SharedMem::write()->Sdata_receivedDataLength=64;
|
||||
tslib_strclr(SharedMem::write()->Sdata_receivedDataBlock,0,64);
|
||||
tslib_strcpy(receivedData, SharedMem::write()->Sdata_receivedDataBlock, SharedMem::read()->Sdata_receivedDataLength);
|
||||
|
||||
}
|
||||
|
||||
uint16_t epi_getLastPayLoad(uint16_t plBufSiz, uint8_t *payLoad)
|
||||
{
|
||||
// get data back in *pl, max 64 byte
|
||||
// retval = nr of bytes received. If host buffer too small then
|
||||
// only plBufSíz bytes are copied to pl
|
||||
// plBufSíz=size of host buffer
|
||||
|
||||
uint16_t ml=plBufSiz, nn;
|
||||
if (ml>64) ml=64;
|
||||
if (SharedMem::read()->Sdata_receivedDataLength<ml)
|
||||
ml=SharedMem::read()->Sdata_receivedDataLength;
|
||||
|
||||
//tslib_strcpy(SharedMem::read()->Sdata_receivedDataBlock, payLoad, ml);
|
||||
for (nn=0; nn<ml; nn++)
|
||||
payLoad[nn]=SharedMem::read()->Sdata_receivedDataBlock[nn];
|
||||
|
||||
return SharedMem::read()->Sdata_receivedDataLength;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//static uint8_t ndbs, pari, nsb, br;
|
||||
|
||||
void gpi_storeSlaveSerParams(uint8_t slaveBaudRate, uint8_t NrDataBits,
|
||||
uint8_t parity, uint8_t NrStopBits)
|
||||
{
|
||||
// store numbers
|
||||
SharedMem::write()->ndbs=NrDataBits;
|
||||
SharedMem::write()->pari=parity;
|
||||
SharedMem::write()->nsb=NrStopBits;
|
||||
SharedMem::write()->br=slaveBaudRate;
|
||||
}
|
||||
|
||||
void epi_getSlaveSerParams(uint8_t *slaveBaudRate, uint8_t *NrDataBits,
|
||||
uint8_t *parity, uint8_t *NrStopBits)
|
||||
{
|
||||
*NrDataBits=SharedMem::read()->ndbs;
|
||||
*parity=SharedMem::read()->pari;
|
||||
*NrStopBits=SharedMem::read()->nsb;
|
||||
*slaveBaudRate=SharedMem::read()->br;
|
||||
|
||||
}
|
||||
|
||||
|
||||
QString epi_getSlaveParamSTR()
|
||||
{
|
||||
QString mySt;
|
||||
char ctmp;
|
||||
// uint8_t ndbs;
|
||||
// uint8_t pari;
|
||||
// uint8_t nsb;
|
||||
// uint8_t br;
|
||||
|
||||
mySt.clear();
|
||||
// br=SharedMemBuffer::read()->br;
|
||||
// ndbs=SharedMemBuffer::read()->ndbs;
|
||||
// pari =SharedMemBuffer::read()->pari;
|
||||
// nsb=SharedMemBuffer::read()->nsb;
|
||||
|
||||
switch (SharedMem::read()->br)
|
||||
{
|
||||
case 1: mySt="1200 ";break;
|
||||
case 2: mySt="9600 ";break;
|
||||
case 3: mySt="19200 ";break;
|
||||
case 4: mySt="38400 ";break;
|
||||
case 5: mySt="57600 ";break;
|
||||
case 6: mySt="115200 ";break;
|
||||
}
|
||||
|
||||
|
||||
ctmp=SharedMem::read()->ndbs;
|
||||
ctmp+=0x30;
|
||||
mySt.append(ctmp);
|
||||
ctmp=SharedMem::read()->pari;
|
||||
mySt.append(ctmp);
|
||||
ctmp=SharedMem::read()->nsb;
|
||||
ctmp+=0x30;
|
||||
mySt.append(ctmp);
|
||||
//mySt="Hallo";
|
||||
return mySt;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//void gpi_startNewRequest(): SharedMem::write()->Sdata_lastResult=0;
|
||||
|
||||
void gpi_storeLastResult(uint8_t letzteAntwort)
|
||||
{
|
||||
SharedMem::write()->Sdata_lastResult=letzteAntwort;
|
||||
}
|
||||
|
||||
uint8_t epi_getLastResult()
|
||||
{
|
||||
|
||||
return SharedMem::read()->Sdata_lastResult;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void epi_startSupervision()
|
||||
{
|
||||
SharedMem::write()->Sdata_startSV=true;
|
||||
}
|
||||
|
||||
bool gpi_wantToResetSupervision()
|
||||
{
|
||||
bool chk=SharedMem::read()->Sdata_startSV;
|
||||
SharedMem::write()->Sdata_startSV=false;
|
||||
return chk;
|
||||
}
|
||||
|
||||
|
||||
void gpi_storeOverallResult(uint8_t letzteAntwort)
|
||||
{
|
||||
SharedMem::write()->Sdata_OverallResult=letzteAntwort;
|
||||
}
|
||||
|
||||
uint8_t epi_getBatchResult()
|
||||
{
|
||||
|
||||
return SharedMem::read()->Sdata_OverallResult;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
1333
src/datIf.cpp
Normal file
1333
src/datIf.cpp
Normal file
File diff suppressed because it is too large
Load Diff
943
src/datei.cpp
Normal file
943
src/datei.cpp
Normal file
@@ -0,0 +1,943 @@
|
||||
// written by Thomas Sax, Jan.2022
|
||||
#include "datei.h"
|
||||
|
||||
|
||||
// -------------------------------------------------------------------------------------------------
|
||||
// ------------------------------------------------------ create csv file -------------------------------
|
||||
// -------------------------------------------------------------------------------------------------
|
||||
|
||||
QByteArray datei_writeArray, datei_tempArray;
|
||||
|
||||
void csv_startCreatingFile(void)
|
||||
{
|
||||
datei_writeArray.clear();
|
||||
datei_tempArray.clear();
|
||||
}
|
||||
|
||||
void csv_addTextToFile(QString myText)
|
||||
{
|
||||
datei_writeArray.append(myText.toLatin1());
|
||||
datei_writeArray.append(FILESEPERATOR);
|
||||
}
|
||||
|
||||
void csv_addIntToFile(int myValue)
|
||||
{
|
||||
//qulonglong ullt=12345678901234567890; // max 1,844 x10^19
|
||||
datei_tempArray.setNum(myValue,10); // accepted types: short, ushort, int, uint,
|
||||
// qlonglong, qulonglong, float, double
|
||||
// numerbase can be 2...36(!),10=dec
|
||||
|
||||
datei_writeArray.append(datei_tempArray);
|
||||
datei_writeArray.append(FILESEPERATOR);
|
||||
}
|
||||
|
||||
void csv_addUintToFile(uint myValue)
|
||||
{
|
||||
datei_tempArray.setNum(myValue,10);
|
||||
datei_writeArray.append(datei_tempArray);
|
||||
datei_writeArray.append(FILESEPERATOR);
|
||||
}
|
||||
|
||||
|
||||
void csv_addLongvalToFile(qlonglong myValue)
|
||||
{
|
||||
datei_tempArray.setNum(myValue,10);
|
||||
datei_writeArray.append(datei_tempArray);
|
||||
datei_writeArray.append(FILESEPERATOR);
|
||||
}
|
||||
|
||||
void csv_addUlongvalToFile(qulonglong myValue)
|
||||
{
|
||||
datei_tempArray.setNum(myValue,10);
|
||||
datei_writeArray.append(datei_tempArray);
|
||||
datei_writeArray.append(FILESEPERATOR);
|
||||
}
|
||||
|
||||
/*
|
||||
void csv_addCurrentTimeToFile(void)
|
||||
{
|
||||
uint8_t hour, minute, sec, ui8buf[20];
|
||||
char buf[20];
|
||||
|
||||
config_getSysTime(&hour, &minute, &sec);
|
||||
GetTimeString(hour, minute, sec, 0, 1, ui8buf);
|
||||
for (uint8_t nn=0; nn<20; nn++)
|
||||
buf[nn]=char(ui8buf[nn]);
|
||||
datei_writeArray.append(buf,8); // time string
|
||||
datei_writeArray.append(FILESEPERATOR);
|
||||
|
||||
}
|
||||
|
||||
void csv_addCurrentDateToFile(void)
|
||||
{
|
||||
uint16_t year;
|
||||
uint8_t month, day, ui8buf[20];
|
||||
char buf[20];
|
||||
|
||||
config_getSystemDate(&year, &month, &day);
|
||||
//qDebug()<<"date year: "<<year;
|
||||
GetDateString(day, month, 0x20, uint8_t(year%100), 0, 0, ui8buf);
|
||||
for (uint8_t nn=0; nn<20; nn++)
|
||||
buf[nn]=char(ui8buf[nn]);
|
||||
datei_writeArray.append(buf, 10); // date string
|
||||
datei_writeArray.append(NEWLINEINFILE);
|
||||
|
||||
}
|
||||
*/
|
||||
|
||||
void csv_addNewlineToFile(void)
|
||||
{
|
||||
datei_writeArray.chop(1); // Komma weg
|
||||
datei_writeArray.append(NEWLINEINFILE);
|
||||
}
|
||||
|
||||
QByteArray csv_readbackArray(void)
|
||||
{
|
||||
return datei_writeArray;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
QByteArray csv_writeContent_testValues(void)
|
||||
{
|
||||
QByteArray myBA, tmpBA;
|
||||
uint8_t modCount=5, modAddr=23;
|
||||
uint8_t hour, minute, sec, month, day, ui8buf[20];
|
||||
uint16_t year, modType=45678;
|
||||
char buf[20];
|
||||
uint32_t modNrDIs=1234567890;
|
||||
uint8_t modNrAIs=4, modNrCtr=2, modNrDOs=8;
|
||||
int modNrAOs=-2;
|
||||
|
||||
myBA.clear();
|
||||
tmpBA.clear();
|
||||
myBA.append("scan time");
|
||||
myBA.append(FILESEPERATOR);
|
||||
|
||||
datei_getSysTime(&hour, &minute, &sec);
|
||||
GetTimeString(hour, minute, sec, 0, 1, ui8buf);
|
||||
for (uint8_t nn=0; nn<20; nn++)
|
||||
buf[nn]=char(ui8buf[nn]);
|
||||
myBA.append(buf,8); // time string
|
||||
myBA.append(FILESEPERATOR);
|
||||
|
||||
datei_getSystemDate(&year, &month, &day);
|
||||
//qDebug()<<"date year: "<<year;
|
||||
GetDateString(day, month, 0x20, uint8_t(year%100), 0, 0, ui8buf);
|
||||
for (uint8_t nn=0; nn<20; nn++)
|
||||
buf[nn]=char(ui8buf[nn]);
|
||||
myBA.append(buf, 10); // date string
|
||||
myBA.append(NEWLINEINFILE);
|
||||
|
||||
myBA.append("number of modules");
|
||||
myBA.append(FILESEPERATOR);
|
||||
tmpBA.setNum(modCount,10); //2nd para = number base 2, 8, 10 or 16 (bin, oct, dec, hex)
|
||||
myBA.append(tmpBA);
|
||||
myBA.append(NEWLINEINFILE);
|
||||
|
||||
myBA.append("busaddr");
|
||||
myBA.append(FILESEPERATOR);
|
||||
myBA.append("type");
|
||||
myBA.append(FILESEPERATOR);
|
||||
myBA.append("NrOfDI");
|
||||
myBA.append(FILESEPERATOR);
|
||||
myBA.append("NrOfAI");
|
||||
myBA.append(FILESEPERATOR);
|
||||
myBA.append("NrOfCtrIn");
|
||||
myBA.append(FILESEPERATOR);
|
||||
myBA.append("NrOfDO");
|
||||
myBA.append(FILESEPERATOR);
|
||||
myBA.append("NrOfAO");
|
||||
myBA.append(NEWLINEINFILE);
|
||||
|
||||
tmpBA.setNum(modAddr,10);
|
||||
myBA.append(tmpBA);
|
||||
myBA.append(FILESEPERATOR);
|
||||
tmpBA.setNum(modType,10);
|
||||
myBA.append(tmpBA);
|
||||
myBA.append(FILESEPERATOR);
|
||||
tmpBA.setNum(modNrDIs,10);
|
||||
myBA.append(tmpBA);
|
||||
myBA.append(FILESEPERATOR);
|
||||
tmpBA.setNum(modNrAIs,10);
|
||||
myBA.append(tmpBA);
|
||||
myBA.append(FILESEPERATOR);
|
||||
tmpBA.setNum(modNrCtr,10);
|
||||
myBA.append(tmpBA);
|
||||
myBA.append(FILESEPERATOR);
|
||||
tmpBA.setNum(modNrDOs,10);
|
||||
myBA.append(tmpBA);
|
||||
myBA.append(FILESEPERATOR);
|
||||
tmpBA.setNum(modNrAOs,10);
|
||||
myBA.append(tmpBA);
|
||||
myBA.append(NEWLINEINFILE);
|
||||
return myBA;
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
// -------------------------------------------------------------------------------------------------
|
||||
// ------------------------------------------------------ parse csv file -------------------------------
|
||||
// -------------------------------------------------------------------------------------------------
|
||||
|
||||
// first: QByteArray datei_readFromFile(QString filename);
|
||||
|
||||
|
||||
uint32_t csv_nrOfEntriesInFile(QByteArray readFromFile)
|
||||
{
|
||||
// count sequences between FILESEPERATOR and NEWLINEINFILE
|
||||
uint32_t filSize=0, pp=0;
|
||||
char oneByt=0;
|
||||
|
||||
int filLen=readFromFile.size();
|
||||
if(filLen>1)
|
||||
filSize=uint32_t(filLen);
|
||||
else
|
||||
return 0;
|
||||
|
||||
// 1) find position of seperators
|
||||
for (uint32_t ii=0; ii<filSize; ii++)
|
||||
{
|
||||
oneByt=readFromFile[ii];
|
||||
if (oneByt==FILESEP1 || oneByt==FILESEP2 || oneByt==NEWLINEINFILE)
|
||||
pp++;
|
||||
}
|
||||
// now: pp = number of seperators
|
||||
// oneByt = last byte in file. If it's not a seperator then
|
||||
// there's one more entry (last entry without termination)
|
||||
if (oneByt !=FILESEP1 && oneByt !=FILESEP2 && oneByt !=NEWLINEINFILE)
|
||||
pp++;
|
||||
//qDebug()<<"csv: nr of sequences="<< pp;
|
||||
return pp;
|
||||
}
|
||||
|
||||
QByteArray csv_getOneFileSequence(QByteArray sourceFile, uint32_t sequNr)
|
||||
{
|
||||
// seperate file content in single sequences between FILESEPERATOR and NEWLINEINFILE
|
||||
// and return "entryNr" - entry
|
||||
// for this first step leave data type QByteArray
|
||||
// 2nd step can change in numbers and strings
|
||||
QByteArray sequence;
|
||||
uint32_t sepPos[MAXNUMBEROFSEQUENCES];
|
||||
uint32_t filSize=0, pp=0, ii, start=0, ende=0;
|
||||
char oneByt;
|
||||
int filLen, mm;
|
||||
|
||||
filLen=sourceFile.size();
|
||||
//qDebug()<<"fillen="<< filLen;
|
||||
if(filLen<10)
|
||||
return "";
|
||||
filSize=uint32_t(filLen);
|
||||
|
||||
if (sequNr>MAXNUMBEROFSEQUENCES)
|
||||
return "";
|
||||
|
||||
// 1) find position of seperators
|
||||
for (ii=0; ii<filSize; ii++)
|
||||
{
|
||||
oneByt=sourceFile[ii];
|
||||
if (oneByt==FILESEP1 || oneByt==FILESEP2 || oneByt==NEWLINEINFILE)
|
||||
{
|
||||
sepPos[pp++]=ii;
|
||||
}
|
||||
}
|
||||
// now: pp = number of entries
|
||||
//qDebug()<<"nr of seperators="<< pp;
|
||||
|
||||
if (sequNr>=pp)
|
||||
return "";
|
||||
|
||||
// 2) get sequence
|
||||
if (sequNr==0)
|
||||
{
|
||||
start=0;
|
||||
ende=sepPos[sequNr];
|
||||
} else
|
||||
if (sequNr>0)
|
||||
{
|
||||
start=sepPos[sequNr-1]+1;
|
||||
ende=sepPos[sequNr];
|
||||
}
|
||||
|
||||
//qDebug()<<"datei getOneFileSequence start/ende: "<<start << " " << ende;
|
||||
if (start>=ende)
|
||||
return "";
|
||||
//return "-err3-";
|
||||
sequence.clear();
|
||||
//batmp.clear();
|
||||
pp=0;
|
||||
for (ii=start; ii<ende; ii++)
|
||||
{
|
||||
mm=int(ii);
|
||||
if (mm>=int(filSize))
|
||||
mm=0;
|
||||
oneByt=sourceFile.at(mm);
|
||||
sequence.append(oneByt);
|
||||
}
|
||||
return sequence;
|
||||
}
|
||||
|
||||
int csv_getEntryAsInt(QByteArray sourceFile, uint32_t sequNr)
|
||||
{
|
||||
QByteArray myBA, myVA;
|
||||
int entry=0;
|
||||
bool ok;
|
||||
|
||||
myVA.clear();
|
||||
myBA = csv_getOneFileSequence(sourceFile, sequNr);
|
||||
//qDebug()<<"datei getEntryAsInt, sequence: " << myBA;
|
||||
|
||||
entry=myBA.toInt(&ok,16);
|
||||
if (ok)
|
||||
{
|
||||
//qDebug()<<"datei getEntryAsInt, number: " << entry;
|
||||
return entry;
|
||||
}
|
||||
//qDebug()<<"datei getEntryAsInt, error " << myBA;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t csv_getEntryAsLong(QByteArray sourceFile, uint32_t sequNr)
|
||||
{
|
||||
QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
|
||||
long entry=0;
|
||||
bool ok;
|
||||
|
||||
entry=myBA.toLong(&ok,10);
|
||||
if (ok)
|
||||
return entry;
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint8_t csv_getEntryAsUshort(QByteArray sourceFile, uint32_t sequNr)
|
||||
{
|
||||
QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
|
||||
uint8_t entry=0;
|
||||
bool ok;
|
||||
|
||||
entry=uint8_t(myBA.toUShort(&ok,10));
|
||||
if (ok)
|
||||
return entry;
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint16_t csv_getEntryAsUint(QByteArray sourceFile, uint32_t sequNr)
|
||||
{
|
||||
QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
|
||||
uint16_t entry=0;
|
||||
bool ok;
|
||||
|
||||
entry=uint16_t(myBA.toUInt(&ok,10));
|
||||
if (ok)
|
||||
return entry;
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t csv_getEntryAsUlong(QByteArray sourceFile, uint32_t sequNr)
|
||||
{
|
||||
QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
|
||||
uint32_t entry=0;
|
||||
bool ok;
|
||||
|
||||
entry=myBA.toULong(&ok,10);
|
||||
if (ok)
|
||||
return entry;
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint64_t csv_getEntryAs2Ulong(QByteArray sourceFile, uint32_t sequNr)
|
||||
{
|
||||
QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
|
||||
uint64_t entry=0;
|
||||
bool ok;
|
||||
|
||||
entry=myBA.toULongLong(&ok,10);
|
||||
if (ok)
|
||||
return entry;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
QString csv_getEntryAsString(QByteArray sourceFile, uint32_t sequNr)
|
||||
{
|
||||
QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
|
||||
QString entry;
|
||||
|
||||
//qDebug()<<"datei getEntryAsString, sequence: " << myBA;
|
||||
entry=myBA.toStdString().c_str();
|
||||
return entry;
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------------------------------
|
||||
// ------------------------------------------------------ create Json file -------------------------------
|
||||
// -------------------------------------------------------------------------------------------------
|
||||
|
||||
/*
|
||||
example
|
||||
QString str = "{"
|
||||
" \"Herausgeber\": \"Xema\","
|
||||
" \"Nummer\": \"1234-5678-9012-3456\","
|
||||
" \"Deckung\": 2e+6,"
|
||||
" \"Währung\": \"EURO\","
|
||||
" \"Inhaber\": {"
|
||||
" \"Name\": \"Mustermann\","
|
||||
" \"Vorname\": \"Max\","
|
||||
" \"männlich\": true,"
|
||||
" \"Hobbys\": [ \"Reiten\", \"Golfen\", \"Lesen\" ],"
|
||||
" \"Alter\": 42,"
|
||||
" \"Kinder\": [],"
|
||||
" \"Partner\": null"
|
||||
" }"
|
||||
"}";
|
||||
|
||||
*/
|
||||
|
||||
QString myJsonCon;
|
||||
QString tmpStr;
|
||||
|
||||
void json_startRecord(void)
|
||||
{
|
||||
myJsonCon.clear();
|
||||
tmpStr.clear();
|
||||
myJsonCon.append('{');
|
||||
}
|
||||
|
||||
void json_enterIntToRecord(QString attribute, ulong i_value)
|
||||
{
|
||||
tmpStr.clear();
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(attribute);
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(':');
|
||||
tmpStr.setNum(i_value);
|
||||
myJsonCon.append(tmpStr);
|
||||
myJsonCon.append(',');
|
||||
myJsonCon.append(NEWLINEINFILE);
|
||||
}
|
||||
|
||||
void json_enterTextToRecord(QString attribute, QString txt_value)
|
||||
{
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(attribute);
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(':');
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(txt_value);
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(',');
|
||||
myJsonCon.append(NEWLINEINFILE);
|
||||
}
|
||||
/*
|
||||
void json_addCurrentTimeToRecord(QString attribute)
|
||||
{
|
||||
uint8_t hour, minute, sec, ui8buf[20];
|
||||
//char buf[20];
|
||||
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(attribute);
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(':');
|
||||
myJsonCon.append('"');
|
||||
|
||||
datei_getSysTime(&hour, &minute, &sec);
|
||||
GetTimeString(hour, minute, sec, 0, 1, ui8buf);
|
||||
for (uint8_t nn=0; nn<8; nn++)
|
||||
myJsonCon.append(ui8buf[nn]);
|
||||
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(',');
|
||||
myJsonCon.append(NEWLINEINFILE);
|
||||
|
||||
}
|
||||
|
||||
void json_addCurrentDateToRecord(QString attribute)
|
||||
{
|
||||
uint16_t year;
|
||||
uint8_t month, day, ui8buf[20];
|
||||
//char buf[20];
|
||||
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(attribute);
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(':');
|
||||
myJsonCon.append('"');
|
||||
|
||||
datei_getSystemDate(&year, &month, &day);
|
||||
GetDateString(day, month, 0x20, uint8_t(year%100), 0, 0, ui8buf);
|
||||
for (uint8_t nn=0; nn<10; nn++)
|
||||
myJsonCon.append(ui8buf[nn]);
|
||||
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(',');
|
||||
myJsonCon.append(NEWLINEINFILE);
|
||||
|
||||
}
|
||||
*/
|
||||
|
||||
void json_enterArrayToRecord(QString attribute, uint8_t *buf, ulong nrofVals)
|
||||
{
|
||||
// add array of numbers with "nrofVals" elements
|
||||
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(attribute);
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(':');
|
||||
myJsonCon.append('['); // eckig!!!
|
||||
for (ulong ul=0; ul<nrofVals; ul++)
|
||||
{
|
||||
tmpStr.setNum(buf[ul]);
|
||||
myJsonCon.append(tmpStr);
|
||||
myJsonCon.append(',');
|
||||
}
|
||||
myJsonCon.chop(1); // Komma weg
|
||||
myJsonCon.append(']'); // eckig!!!
|
||||
myJsonCon.append(',');
|
||||
myJsonCon.append(NEWLINEINFILE);
|
||||
}
|
||||
|
||||
void json_enterStructToRecord(QString attribute)
|
||||
{
|
||||
// every call must be concluded with "json_finishFile()"
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(attribute);
|
||||
myJsonCon.append('"');
|
||||
myJsonCon.append(':');
|
||||
myJsonCon.append('{'); // geschweift!!
|
||||
myJsonCon.append(NEWLINEINFILE);
|
||||
}
|
||||
|
||||
void json_finishStruct(void)
|
||||
{
|
||||
myJsonCon.chop(2); // remove , and \r from the end
|
||||
myJsonCon.append('}');
|
||||
myJsonCon.append(',');
|
||||
myJsonCon.append(NEWLINEINFILE);
|
||||
|
||||
}
|
||||
|
||||
void json_finishRecord(void)
|
||||
{
|
||||
myJsonCon.chop(2); // remove , and \r from the end
|
||||
myJsonCon.append(NEWLINEINFILE);
|
||||
myJsonCon.append('}');
|
||||
myJsonCon.append(NEWLINEINFILE);
|
||||
|
||||
}
|
||||
|
||||
|
||||
QString json_readbackRecordStr(void)
|
||||
{
|
||||
return myJsonCon;
|
||||
}
|
||||
|
||||
QByteArray json_readbackRecordBa(void)
|
||||
{
|
||||
return myJsonCon.toLatin1();
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------------------------------
|
||||
// ------------------------------------------------------ parse Json file -------------------------------
|
||||
// -------------------------------------------------------------------------------------------------
|
||||
|
||||
/*
|
||||
example Json File:
|
||||
{"temperature":28,
|
||||
"snow":"no",
|
||||
"Zeit":"16_21_45",
|
||||
"sunny":"12h",
|
||||
"humidity":75,
|
||||
"wann ":"24.01.2022",
|
||||
"unterstruktur":{
|
||||
"day of week":"tuesday",
|
||||
"year":22,
|
||||
"month":1,
|
||||
"day":24},
|
||||
"fast am":"Ende",
|
||||
"Puffer":[8,3,9,2,10]
|
||||
}
|
||||
*/
|
||||
// first: QByteArray datei_readFromFile(QString filename);
|
||||
|
||||
|
||||
int json_nrOfPairsInFile(QByteArray filename)
|
||||
{
|
||||
QJsonDocument jdoc = QJsonDocument::fromJson(filename);
|
||||
QJsonObject jobj = jdoc.object();
|
||||
|
||||
// key value pair consisting of key (unique string) and value (QJsonValue)
|
||||
int nrOfPairs=jobj.size();
|
||||
|
||||
qDebug() << "my Json file has got: " << nrOfPairs<< "pairs";
|
||||
return nrOfPairs;
|
||||
}
|
||||
|
||||
bool json_exists(QByteArray filename, QString searchForKey)
|
||||
{
|
||||
// look for "searchForKey" =name of the pair (left of : )
|
||||
QJsonDocument jdoc = QJsonDocument::fromJson(filename);
|
||||
QJsonObject jobj = jdoc.object();
|
||||
|
||||
if (jobj.contains(searchForKey))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool json_remove(QByteArray filename, QString searchFor)
|
||||
{
|
||||
// look for "searchFor" =name of the pair (left of : ) and remove the record from file
|
||||
QJsonDocument jdoc = QJsonDocument::fromJson(filename);
|
||||
QJsonObject jobj = jdoc.object();
|
||||
|
||||
if (jobj.contains(searchFor))
|
||||
{
|
||||
jobj.remove(searchFor);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
QString json_searchForStringInFile(QByteArray filename, QString searchFor)
|
||||
{
|
||||
// look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
|
||||
QJsonDocument jdoc = QJsonDocument::fromJson(filename);
|
||||
QJsonObject jobj = jdoc.object();
|
||||
|
||||
if (jobj.contains(searchFor))
|
||||
{
|
||||
return jobj[searchFor].toString(); // toObject(); toArray();
|
||||
} else
|
||||
{
|
||||
//qDebug() << "pairname not found in Json file";
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
int json_searchForIntInFile(QByteArray filename, QString searchFor)
|
||||
{
|
||||
// look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
|
||||
QJsonDocument jdoc = QJsonDocument::fromJson(filename);
|
||||
QJsonObject jobj = jdoc.object();
|
||||
|
||||
if (jobj.contains(searchFor))
|
||||
{
|
||||
return jobj[searchFor].toInt(); // toObject(); toArray();
|
||||
} else
|
||||
{
|
||||
//qDebug() << "number not found in Json file";
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
bool json_searchForObjectInFile(QByteArray filename, QString searchFor, QJsonObject *oneObject)
|
||||
{
|
||||
// return an object from the json file
|
||||
QJsonDocument jdoc = QJsonDocument::fromJson(filename);
|
||||
QJsonObject jobj = jdoc.object();
|
||||
|
||||
if (jobj.contains(searchFor))
|
||||
{
|
||||
*oneObject = jobj[searchFor].toObject();
|
||||
return true;
|
||||
} else
|
||||
{
|
||||
//qDebug() << "Object not found in Json file";
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
int json_nrOfPairsInObject(QJsonObject objname)
|
||||
{
|
||||
int nrOfPairs=objname.size();
|
||||
qDebug() << "my Json Object has got: " << nrOfPairs<< "pairs";
|
||||
return nrOfPairs;
|
||||
}
|
||||
|
||||
QString json_searchForStringInObject(QJsonObject objname, QString searchFor)
|
||||
{
|
||||
// look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
|
||||
|
||||
if (objname.contains(searchFor))
|
||||
{
|
||||
return objname[searchFor].toString();
|
||||
} else
|
||||
{
|
||||
//qDebug() << "string not found in Json object";
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
int json_searchForIntInObject(QJsonObject objname, QString searchFor)
|
||||
{
|
||||
// look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
|
||||
|
||||
if (objname.contains(searchFor))
|
||||
{
|
||||
return objname[searchFor].toInt();
|
||||
} else
|
||||
{
|
||||
//qDebug() << "number not found in Json file";
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
bool json_searchForArrayInFile(QByteArray filename, QString searchFor, QJsonArray *oneArray)
|
||||
{
|
||||
// look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
|
||||
QJsonDocument jdoc = QJsonDocument::fromJson(filename);
|
||||
QJsonObject jobj = jdoc.object();
|
||||
|
||||
if (jobj.contains(searchFor))
|
||||
{
|
||||
*oneArray = jobj[searchFor].toArray();
|
||||
return true;
|
||||
} else
|
||||
{
|
||||
//qDebug() << "Array not found in Json file";
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
int json_nrOfValuesInArray(QJsonArray arrayname)
|
||||
{
|
||||
int nrOfPairs=arrayname.size();
|
||||
qDebug() << "my Json Array has got: " << nrOfPairs<< "values";
|
||||
return nrOfPairs;
|
||||
}
|
||||
|
||||
|
||||
|
||||
bool json_getValuesOfArray(QJsonArray arrayname, int *buf, int MaxBufferSize)
|
||||
{
|
||||
// assuming that the array consists of integers
|
||||
|
||||
/* copy to local buffer:
|
||||
#define MAXNROFARRAYVALUES 100
|
||||
int buf[MAXNROFARRAYVALUES], ii;
|
||||
int nrOfPairs=arrayname.size();
|
||||
|
||||
if (nrOfPairs>MAXNROFARRAYVALUES)
|
||||
nrOfPairs=MAXNROFARRAYVALUES;
|
||||
|
||||
for (ii=0; ii<nrOfPairs; ii++)
|
||||
buf[ii]=arrayname[ii].toInt();
|
||||
*/
|
||||
// copy to host buffer:
|
||||
bool ok=true;
|
||||
int nrOfPairs=arrayname.size();
|
||||
|
||||
if (nrOfPairs>MaxBufferSize)
|
||||
{
|
||||
ok=false; // got not all
|
||||
nrOfPairs=MaxBufferSize;
|
||||
}
|
||||
for (int ii=0; ii<nrOfPairs; ii++)
|
||||
buf[ii]=arrayname[ii].toInt();
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
/*
|
||||
void datei_json_readTestFile(QString filename)
|
||||
{
|
||||
QByteArray my2Ba;
|
||||
QString my2Str;
|
||||
|
||||
my2Str.clear();
|
||||
my2Ba=datei_readFromFile(filename);
|
||||
|
||||
QJsonDocument jdoc = QJsonDocument::fromJson(my2Ba);
|
||||
QJsonObject jobj = jdoc.object();
|
||||
//QJsonParseError jerror;
|
||||
QJsonObject myObj;
|
||||
QJsonArray myArray;
|
||||
|
||||
// key value pair consisting of key (unique string) and value (QJsonValue)
|
||||
int nrOfPairs=jobj.size();
|
||||
qDebug() << "my Json file has got: " << nrOfPairs<< "pairs";
|
||||
|
||||
if (jobj.contains("Zeit"))
|
||||
qDebug() << "my Json file: " << jobj["Zeit"].toString(); // toObject(); toArray();
|
||||
else
|
||||
qDebug() << "my Json file contains no Zeit";
|
||||
|
||||
if (jobj.contains("Humidity"))
|
||||
qDebug() << "my Json file: " << jobj["humidity"].toInt();
|
||||
else
|
||||
qDebug() << "my Json file contains no Humidity";
|
||||
|
||||
if (jobj.contains("month"))
|
||||
qDebug() << "my Json file: " << jobj["month"].toObject(); // anzeige QJsonObject()
|
||||
else
|
||||
qDebug() << "my Json file contains no month";
|
||||
|
||||
|
||||
myObj=jobj["unterstruktur"].toObject();
|
||||
qDebug() << "my unterstruktur: " << myObj["month"].toInt();
|
||||
qDebug() << "my unterstruktur: " << myObj["day of week"].toString();
|
||||
//if (jerror.error == QJsonParseError::NoError)
|
||||
// qDebug() << "no error";
|
||||
|
||||
qDebug() << "my Month: " << myObj["Month"].toInt();
|
||||
//if (myObj["Month"] == QJsonValue::Undefined)
|
||||
// qDebug() << "no found"; geht nicht
|
||||
|
||||
//if (jerror.error != QJsonParseError::NoError)
|
||||
// qDebug() << "no found";
|
||||
|
||||
myArray=jobj["Puffer"].toArray();
|
||||
qDebug() << "my array " <<myArray[2].toInt();
|
||||
//if (jerror.error != QJsonParseError::NoError)
|
||||
// qDebug() << "no found";
|
||||
|
||||
if ( !jobj.contains("Puffer"))
|
||||
qDebug() << "no Puffer found";
|
||||
|
||||
if ( !myArray.contains(20))
|
||||
qDebug() << "no entry found";
|
||||
} */
|
||||
|
||||
|
||||
|
||||
// -------------------------------------------------------------------------------------------------
|
||||
// ------------------------------------------------------ read, write, copy files -------------------
|
||||
// -------------------------------------------------------------------------------------------------
|
||||
|
||||
void datei_closeFile(QString filename)
|
||||
{
|
||||
QFile file(filename);
|
||||
file.close();
|
||||
}
|
||||
|
||||
QByteArray datei_readFromFile(QString filename)
|
||||
{
|
||||
//QFile file("/own/H2B/dc2.hex");
|
||||
//QFile file(FILENAME_STRUCTURE);
|
||||
QFile file;
|
||||
file.setFileName(filename);
|
||||
QByteArray myBA;
|
||||
|
||||
myBA.clear();
|
||||
if (!file.exists())
|
||||
{
|
||||
qDebug()<<"file not exists";
|
||||
return myBA;
|
||||
} else
|
||||
{
|
||||
if (!file.open(QIODevice::ReadOnly) )
|
||||
{
|
||||
qDebug()<<"cannot open";
|
||||
|
||||
} else
|
||||
{
|
||||
//qDebug()<<"loading file with " << file.size() <<"byte";
|
||||
myBA = file.readAll();
|
||||
//qDebug()<<"datei read: " << myBA;
|
||||
file.close();
|
||||
}
|
||||
}
|
||||
return myBA;
|
||||
}
|
||||
|
||||
bool datei_ifFileExists(QString filename)
|
||||
{
|
||||
|
||||
QFile file;
|
||||
file.setFileName(filename);
|
||||
|
||||
if (file.exists())
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
char datei_writeToFile(QString filename, QByteArray content)
|
||||
{
|
||||
// retval=0 if successful 1: no write access allowed 2:cannot open to append 3:cannot create new file
|
||||
QFile file(filename);
|
||||
QFileInfo myFI(filename);
|
||||
|
||||
//if (!myFI.isWritable()) //geht nur bei NTFS, weg.
|
||||
//{
|
||||
//file.setPermissions(filename, QFile::WriteOther); geht nicht :(
|
||||
// qDebug()<<"datei_writeToFile: writing not allowed. set attributes first!";
|
||||
// return 1;
|
||||
//}
|
||||
|
||||
if (file.exists())
|
||||
{
|
||||
if (!file.open(QIODevice::Append))
|
||||
{
|
||||
qDebug()<<"datei_writeToFile cannot open to append";
|
||||
return 2;
|
||||
} else
|
||||
{
|
||||
// add new object to the end of the file
|
||||
file.write(content);
|
||||
file.close();
|
||||
return 0; // OK
|
||||
}
|
||||
} else
|
||||
{
|
||||
if (!file.open(QIODevice::WriteOnly))
|
||||
{
|
||||
qDebug()<<"datei_writeToFile cannot open new";
|
||||
return 3;
|
||||
} else
|
||||
{
|
||||
qDebug()<<"create new file";
|
||||
// write first lines into file
|
||||
file.write(content);
|
||||
file.close();
|
||||
return 0; // OK
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool datei_copyFile(QString currentFileName, QString newFileName)
|
||||
{
|
||||
// retval=true if successful
|
||||
QFile file;
|
||||
file.setFileName(currentFileName);
|
||||
return file.copy(newFileName);
|
||||
}
|
||||
|
||||
bool datei_clearFile(QString filename)
|
||||
{
|
||||
// retval=true if successful
|
||||
QFile file;
|
||||
file.setFileName(filename);
|
||||
|
||||
file.remove(); // 3.2.22 erst ganz löschen wegen Schreibrechten
|
||||
if (!file.open(QIODevice::WriteOnly))
|
||||
{
|
||||
qDebug()<<"datei_clearFile cannot open file to delete";
|
||||
return false;
|
||||
} else
|
||||
{
|
||||
file.write(0);
|
||||
file.close();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
1528
src/dcBL.cpp
Normal file
1528
src/dcBL.cpp
Normal file
File diff suppressed because it is too large
Load Diff
0
src/dc_plugin_error.cpp
Normal file
0
src/dc_plugin_error.cpp
Normal file
91
src/dc_result.cpp
Normal file
91
src/dc_result.cpp
Normal file
@@ -0,0 +1,91 @@
|
||||
#include "dc_result.h"
|
||||
#include <QMetaType>
|
||||
|
||||
struct DCResultInit {
|
||||
DCResultInit() {
|
||||
qRegisterMetaType<DCResult>();
|
||||
}
|
||||
};
|
||||
|
||||
static DCResultInit initMetaTypeDCResult;
|
||||
|
||||
DCResult::DCResult()
|
||||
: m_pluginState(PLUGIN_STATE::NOT_INITIALIZED)
|
||||
, m_errorCode("NOT-INITIALIZED")
|
||||
, m_errorDescription("NOT-INITIALIZED") {
|
||||
}
|
||||
|
||||
DCResult::DCResult(PLUGIN_STATE pState, RESULT_STATE rState,
|
||||
QString errorCode, QString errorDescription,
|
||||
QString cashValue)
|
||||
: m_pluginState(pState)
|
||||
, m_resultState(rState)
|
||||
, m_errorCode(errorCode)
|
||||
, m_errorDescription(errorDescription)
|
||||
, m_newCashValue(cashValue) {
|
||||
}
|
||||
|
||||
DCResult::DCResult(PLUGIN_STATE pState, RESULT_STATE rState,
|
||||
CASH_STATE cState, QString errorCode,
|
||||
QString errorDescription, QString cashValue)
|
||||
: m_pluginState(pState)
|
||||
, m_resultState(rState)
|
||||
, m_cashState(cState)
|
||||
, m_errorCode(errorCode)
|
||||
, m_errorDescription(errorDescription)
|
||||
, m_newCashValue(cashValue) {
|
||||
}
|
||||
|
||||
QDebug operator<<(QDebug d, DCResult const &result) {
|
||||
|
||||
d << "\n";
|
||||
|
||||
switch(result.m_pluginState) {
|
||||
case DCResult::PLUGIN_STATE::INITIALIZED:
|
||||
d << "DC-PLUGIN-STATE ... INITIALIZED\n";
|
||||
break;
|
||||
case DCResult::PLUGIN_STATE::NOT_INITIALIZED:
|
||||
d << "DC-PLUGIN-STATE ... NOT-INITIALIZED\n";
|
||||
break;
|
||||
}
|
||||
|
||||
switch(result.m_resultState) {
|
||||
case DCResult::RESULT_STATE::SUCCESS:
|
||||
d << "DC-RESULT-STATE ... SUCCESS\n";
|
||||
break;
|
||||
case DCResult::RESULT_STATE::ERROR_BACKEND:
|
||||
d << "DC-RESULT-STATE ... ERROR_BACKEND\n";
|
||||
break;
|
||||
case DCResult::RESULT_STATE::ERROR_TIMEOUT:
|
||||
d << "DC-RESULT-STATE ... ERROR_TIMEOUT\n";
|
||||
break;
|
||||
case DCResult::RESULT_STATE::ERROR_PROCESS:
|
||||
d << "DC-RESULT-STATE ... ERROR_PROCESS\n";
|
||||
break;
|
||||
case DCResult::RESULT_STATE::ERROR_RETRY:
|
||||
d << "DC-RESULT-STATE ... ERROR_RETRY\n";
|
||||
break;
|
||||
case DCResult::RESULT_STATE::INFO:
|
||||
d << "DC-RESULT-STATE ... INFO\n";
|
||||
break;
|
||||
}
|
||||
|
||||
switch(result.m_cashState) {
|
||||
case DCResult::CASH_STATE::CACHE_EMPTY:
|
||||
d << "DC-CASH-STATE ... CASH-EMPTY\n";
|
||||
break;
|
||||
case DCResult::CASH_STATE::CACHE_INPUT:
|
||||
d << "DC-CASH-STATE ... CASH-INPUT\n";
|
||||
break;
|
||||
case DCResult::CASH_STATE::OVERPAYED:
|
||||
d << "DC-CASH-STATE ... OVERPAYED\n";
|
||||
break;
|
||||
case DCResult::CASH_STATE::NOT_AVAILABLE:
|
||||
break;
|
||||
}
|
||||
|
||||
d << "DC-ERROR-CODE ..." << result.m_errorCode << "\n";
|
||||
d << "DC-ERROR-DESC ..." << result.m_errorDescription << "\n";
|
||||
|
||||
return d;
|
||||
}
|
||||
4236
src/hwapi.cpp
Normal file
4236
src/hwapi.cpp
Normal file
File diff suppressed because it is too large
Load Diff
9
src/main.cpp
Normal file
9
src/main.cpp
Normal file
@@ -0,0 +1,9 @@
|
||||
#include <QCoreApplication>
|
||||
#include "tslib.h"
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
QCoreApplication a(argc, argv);
|
||||
|
||||
return a.exec();
|
||||
}
|
||||
623
src/prot.cpp
Normal file
623
src/prot.cpp
Normal file
@@ -0,0 +1,623 @@
|
||||
#include "prot.h"
|
||||
#include <QDebug>
|
||||
#include "controlBus.h"
|
||||
#include "dcBL.h"
|
||||
#include "interfaces.h"
|
||||
|
||||
|
||||
T_prot::T_prot()
|
||||
{
|
||||
|
||||
mySerialPort = new T_com();
|
||||
connect(mySerialPort, SIGNAL(receivingFinished()), this, SLOT( analyseRecData() ));
|
||||
//connect(mySerialPort, SIGNAL(sendingFinished()), this, SLOT(sendeFin()));
|
||||
|
||||
for (int nn=0; nn<FRAME_DATALEN; nn++)
|
||||
{
|
||||
chOut_Data[nn]=0;
|
||||
ui8OutputData[nn]=0;
|
||||
InputData[nn]=0;
|
||||
}
|
||||
for (int nn=0; nn<BL_DATA_LEN; nn++)
|
||||
{
|
||||
ui8BLsendData[nn]=0;
|
||||
}
|
||||
WriteCommand=0;
|
||||
WriteAddr=0;
|
||||
WrDataLength=0;
|
||||
SendDataValid=0;
|
||||
kindOfData=0;
|
||||
slaveAddr=0;
|
||||
ReadCommand=0;
|
||||
//ReadAddr=0;
|
||||
reserve =0;
|
||||
RecSlaveAddr =0;
|
||||
INdataValid=0;
|
||||
readSource =0;
|
||||
readAddress=0;
|
||||
RdDataLength=0;
|
||||
BLsendDataLength=0;
|
||||
|
||||
prot_storeResult=0xFF;
|
||||
}
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------------------------------------------
|
||||
// sending.....
|
||||
// ---------------------------------------------------------------------------------------------------------
|
||||
|
||||
bool T_prot::isPortOpen(void)
|
||||
{
|
||||
return mySerialPort->isPortOpen();
|
||||
}
|
||||
|
||||
bool T_prot::isSerialFree(void)
|
||||
{
|
||||
return true; // ohne HS's kann er nicht blockiert sein
|
||||
}
|
||||
|
||||
|
||||
// 14.9.23 Fehler!!!!!
|
||||
// hier wird vorausgesetzt dasss die Empfangslaenge von Sendetelegramm abh. ist.
|
||||
// also cmd>=100 ist kurze Antwort. das stimmt aber nicht, ist unabh. Wahr ist: cmd>=100 = kurzes Sendetelegramm
|
||||
|
||||
// Laenge des request-telegramms (PTU-->DC) ist nur abh. vom WRcmd, die Antwort auf WR ist immer kurz (nur result byte)
|
||||
// WRcmd kurz oder lang: Antwort immer kurz
|
||||
// RDcmd kurz oder lang: Antwort genauso
|
||||
// Also Korrektur dieser Funktion: nur der Variablenname "WriteCmd" -> "ReadCmd"
|
||||
|
||||
void T_prot::setRecLen(uint16_t ReadCmd)
|
||||
{
|
||||
if (ReadCmd<100)
|
||||
{
|
||||
RdDataLength=DATALEN_RECEIVE_LONG; // 64, store here already because it's no longer returned from slave
|
||||
mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_LONG); // 68
|
||||
} else
|
||||
{
|
||||
RdDataLength=DATALEN_RECEIVE_FAST; // 8
|
||||
mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_FAST); // 12
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* void T_prot::setRecLen(uint16_t WriteCmd)
|
||||
{
|
||||
if (WriteCmd<100)
|
||||
{
|
||||
RdDataLength=DATALEN_RECEIVE_LONG; // store here already because it's no longer
|
||||
// returned from slave
|
||||
mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_LONG); // 68
|
||||
} else
|
||||
{
|
||||
RdDataLength=DATALEN_RECEIVE_FAST;
|
||||
mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_FAST); // 12
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
void T_prot::setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr, uint8_t WrDatLen, uint8_t *data)
|
||||
{
|
||||
WriteCommand=WriteCmd;
|
||||
WriteAddr=WrAddr;
|
||||
WrDataLength=WrDatLen;
|
||||
if (WrDataLength>FRAME_DATALEN)
|
||||
WrDataLength=FRAME_DATALEN;
|
||||
|
||||
for (int nn=0; nn<WrDataLength; nn++)
|
||||
ui8OutputData[nn]=data[nn];
|
||||
SendDataValid=1; // always set WR first
|
||||
kindOfData=0; // 0: binaries, 1:text
|
||||
this->setRecLen(100); // default: short response
|
||||
|
||||
}
|
||||
|
||||
void T_prot::setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr)
|
||||
{
|
||||
WriteCommand=WriteCmd;
|
||||
WriteAddr=WrAddr;
|
||||
WrDataLength=0;
|
||||
for (int nn=0; nn<FRAME_DATALEN; nn++)
|
||||
ui8OutputData[nn]=0;
|
||||
SendDataValid=1; // always set WR first
|
||||
kindOfData=0; // 0: binaries, 1:text
|
||||
this->setRecLen(100); // default: short response
|
||||
|
||||
}
|
||||
|
||||
void T_prot::setUserWriteData(uint16_t WriteCmd)
|
||||
{
|
||||
WriteCommand=WriteCmd;
|
||||
WriteAddr=0;
|
||||
WrDataLength=0;
|
||||
for (int nn=0; nn<FRAME_DATALEN; nn++)
|
||||
ui8OutputData[nn]=0;
|
||||
SendDataValid=1; // always set WR first
|
||||
kindOfData=0; // 0: binaries, 1:text
|
||||
this->setRecLen(100); // default: short response
|
||||
|
||||
}
|
||||
|
||||
void T_prot::setUserWrite1DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val)
|
||||
{
|
||||
// wie oben, jedoch einfachere Datenübergabe
|
||||
WriteCommand=WriteCmd;
|
||||
WriteAddr=WrAddr;
|
||||
WrDataLength=1;
|
||||
ui8OutputData[0]=val;
|
||||
SendDataValid=1; // always set WR first
|
||||
kindOfData=0; // 0: binaries, 1:text
|
||||
this->setRecLen(100); // default: short response
|
||||
|
||||
}
|
||||
|
||||
void T_prot::setUserWrite2DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val0, uint8_t val1)
|
||||
{
|
||||
WriteCommand=WriteCmd;
|
||||
WriteAddr=WrAddr;
|
||||
WrDataLength=2;
|
||||
ui8OutputData[0]=val0;
|
||||
ui8OutputData[1]=val1;
|
||||
SendDataValid=1; // always set WR first
|
||||
kindOfData=0; // 0: binaries, 1:text
|
||||
this->setRecLen(100); // default: short response
|
||||
|
||||
}
|
||||
|
||||
void T_prot::setUserWriteText(uint16_t WriteCmd, uint16_t WrAddr, uint8_t WrDatLen, char *data)
|
||||
{
|
||||
WriteCommand=WriteCmd;
|
||||
WriteAddr=WrAddr;
|
||||
WrDataLength=WrDatLen;
|
||||
if (WrDataLength>FRAME_DATALEN)
|
||||
WrDataLength=FRAME_DATALEN;
|
||||
|
||||
for (int nn=0; nn<WrDataLength; nn++)
|
||||
chOut_Data[nn]=data[nn];
|
||||
SendDataValid=1; // always set WR first
|
||||
kindOfData=1; // 0: binaries, 1:text
|
||||
this->setRecLen(100); // default: short response
|
||||
|
||||
}
|
||||
|
||||
void T_prot::setUserReadData( uint16_t ReadCmd)
|
||||
{
|
||||
ReadCommand=ReadCmd;
|
||||
//ReadAddr=WriteAddr;
|
||||
reserve=0;
|
||||
SendDataValid |=2;
|
||||
readAddress=WriteAddr; // store here already because it's no longer returned from slave
|
||||
|
||||
//qDebug()<<"prot_setUserReadData, read address : " << readAddress;
|
||||
|
||||
this->setRecLen(ReadCmd); // long response (68byte) only for ReadCmd < 100
|
||||
readSource=ReadCmd;
|
||||
}
|
||||
|
||||
void T_prot::setBLsendData( uint8_t len, uint8_t *buf)
|
||||
{
|
||||
for (int nn=0; nn<BL_DATA_LEN; nn++)
|
||||
ui8BLsendData[nn]=0;
|
||||
|
||||
BLsendDataLength=len;
|
||||
if ( BLsendDataLength>BL_DATA_LEN) BLsendDataLength=BL_DATA_LEN;
|
||||
for (int nn=0; nn<BLsendDataLength; nn++)
|
||||
ui8BLsendData[nn]=buf[nn];
|
||||
WriteCommand=0xFFFF;
|
||||
this->setRecLen(100);
|
||||
|
||||
|
||||
//qDebug()<<"prot: got BL data " << len << "bytes, ";
|
||||
//for (int i=0; i<len; ++i) {
|
||||
// printf("%02x ", (unsigned char)buf[i]);
|
||||
//} printf("\n");
|
||||
|
||||
/*
|
||||
qDebug()<<buf[0] <<buf[1] <<buf[2] <<buf[3] <<buf[4] <<buf[5] <<buf[6] <<buf[7];
|
||||
qDebug() <<buf[8] <<buf[9] <<buf[10] <<buf[11] <<buf[12] <<buf[13]<<buf[14]<<buf[15];
|
||||
qDebug() <<buf[16] <<buf[17] <<buf[18] <<buf[19] <<buf[20] <<buf[21]<<buf[22]<<buf[23];
|
||||
qDebug() <<buf[24] <<buf[25] <<buf[26] <<buf[27] <<buf[28] <<buf[29]<<buf[30]<<buf[31];
|
||||
qDebug() <<buf[32] <<buf[33] <<buf[34] <<buf[35] <<buf[36] <<buf[37]<<buf[38]<<buf[39];
|
||||
qDebug() <<buf[40] <<buf[41] <<buf[42] <<buf[43] <<buf[44] <<buf[45]<<buf[46]<<buf[47];
|
||||
qDebug() <<buf[48] <<buf[49] <<buf[50] <<buf[51] <<buf[52] <<buf[53] <<buf[54]<<buf[55];
|
||||
qDebug() <<buf[56] <<buf[57] <<buf[58] <<buf[59] <<buf[60] <<buf[61] <<buf[62]<<buf[63];
|
||||
qDebug() <<buf[64] <<buf[65] <<buf[66] <<buf[67] <<buf[68] <<buf[69] <<buf[70]<<buf[71];
|
||||
qDebug() <<buf[72] <<buf[73] <<buf[74] <<buf[75] <<buf[76] <<buf[77] <<buf[78]<<buf[79];
|
||||
*/
|
||||
|
||||
}
|
||||
|
||||
void T_prot::receiveFixLen(int64_t nrOfbytesToReceive)
|
||||
{
|
||||
mySerialPort->receiveFixLen(nrOfbytesToReceive);
|
||||
}
|
||||
|
||||
void T_prot::sendUserData(uint16_t slaveAdr)
|
||||
{
|
||||
// man könnte hier noch "SendDataValid" abfragen,
|
||||
// muss immer 3 sein, muss man aber nicht
|
||||
|
||||
//qDebug() << "prot send user data "<<slaveAdr;
|
||||
QByteArray packBuf_2;
|
||||
slaveAddr=slaveAdr;
|
||||
|
||||
if (WriteCommand==0xFFFF)
|
||||
{
|
||||
// Bypass for bootloader, no protocol frame but send as is...
|
||||
packBuf_2.clear();
|
||||
for (int nn=0; nn<BLsendDataLength; nn++)
|
||||
{
|
||||
// packBuf_2[nn]=char(ui8BLsendData[nn]); // program crash, 4.9.23
|
||||
packBuf_2.append(ui8BLsendData[nn]);
|
||||
|
||||
}
|
||||
mySerialPort->writeToSerial(packBuf_2, BLsendDataLength);
|
||||
|
||||
} else
|
||||
startFastPacking(); // quicker since 15.12.21TS
|
||||
//startPacking();
|
||||
}
|
||||
|
||||
void T_prot::startFastPacking(void)
|
||||
{
|
||||
uint16_t mycrc;
|
||||
uint16_t sendLen;
|
||||
uint8_t uctmp, nn, pp, CrcLp;
|
||||
char sendBuffer[FRAME_MAXLEN], ctmp;
|
||||
|
||||
//qDebug() << "prot start fast packing "<<slaveAddr;
|
||||
|
||||
for (int nn=0; nn<FRAME_MAXLEN; nn++)
|
||||
sendBuffer[nn]=0;
|
||||
|
||||
if (WriteCommand>9 && WriteCommand<100)
|
||||
{
|
||||
// long command 10...99
|
||||
// WriteCommand==0 if only read request, then use short sending
|
||||
sendBuffer[0]=STARTSIGN_SEND_LONG;
|
||||
WrDataLength=DATALEN_SEND_LONG; // immer
|
||||
//qDebug() << "send long cmd, len: " << WrDataLength;
|
||||
} else
|
||||
{
|
||||
// fast command
|
||||
sendBuffer[0]=STARTSIGN_SEND_FAST;
|
||||
WrDataLength=DATALEN_SEND_FAST; // immer
|
||||
//qDebug() << "send fast cmd, len: " << WrDataLength;
|
||||
}
|
||||
sendBuffer[1]= uint8_t(WriteCommand);
|
||||
sendBuffer[2]= uint8_t(ReadCommand);
|
||||
//if (WriteAddr>0)
|
||||
sendBuffer[3]= char(WriteAddr); // bei fast nur EINE adresse, wr hat Vorrang
|
||||
//else
|
||||
// sendBuffer[3]= char(ReadAddr);
|
||||
// beim Fast prot. ist das reserve dann ists egal was drin steht
|
||||
|
||||
if (kindOfData) // 0: binaries, 1:text
|
||||
{
|
||||
for (nn=0; nn<WrDataLength; nn++)
|
||||
{
|
||||
pp=HEADERLEN_SEND+nn;
|
||||
ctmp=(chOut_Data[nn]); // text
|
||||
sendBuffer[pp]= char(ctmp);
|
||||
}
|
||||
|
||||
} else
|
||||
{
|
||||
for (nn=0; nn<WrDataLength; nn++)
|
||||
{
|
||||
pp=HEADERLEN_SEND+nn;
|
||||
uctmp=(ui8OutputData[nn]); // bin
|
||||
sendBuffer[pp]= char(uctmp);
|
||||
}
|
||||
}
|
||||
|
||||
CrcLp= HEADERLEN_SEND + WrDataLength;
|
||||
mycrc=0;
|
||||
for (nn=0; nn<CrcLp; nn++)
|
||||
{
|
||||
uctmp=sendBuffer[nn];
|
||||
mycrc+=uint16_t(uctmp);
|
||||
//qDebug() << mycrc;
|
||||
}
|
||||
sendBuffer[CrcLp]=char(mycrc);
|
||||
mycrc>>=8;
|
||||
sendBuffer[CrcLp+1]=char(mycrc);
|
||||
sendLen=CrcLp+2;
|
||||
|
||||
// send to VCP:
|
||||
QByteArray packBuff;
|
||||
packBuff.clear();
|
||||
packBuff.append(sendBuffer, sendLen); // ohne sendLen wird beim ersten \0 abgeschnitten!!!
|
||||
mySerialPort->writeToSerial(packBuff, sendLen);
|
||||
|
||||
}
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------------------------------------------
|
||||
// receiving.....
|
||||
// ---------------------------------------------------------------------------------------------------------
|
||||
|
||||
|
||||
void T_prot::analyseRecData(void)
|
||||
{
|
||||
// Aufruf per connect aus serialcontrol wenn Daten empfangen wurden
|
||||
// getRecData(QByteArray &data, uint16_t &sendLength);
|
||||
|
||||
QByteArray Indata;
|
||||
QString myString, tempStr;
|
||||
//char recBuffer[FRAME_MAXLEN];
|
||||
uint8_t recBuffer[FRAME_MAXLEN];
|
||||
|
||||
uint16_t recLength;
|
||||
|
||||
INdataValid=false;
|
||||
|
||||
gpi_setTxt4HsStateLine("");
|
||||
gpi_setTxt4masterStateLine("");
|
||||
gpi_setTxt4resultStateLine("");
|
||||
gpi_setTxt4dataStateLine("");
|
||||
gpi_setTxt4datifLine("");
|
||||
|
||||
// read from "VCP":
|
||||
mySerialPort->readFromSerial(Indata, recLength);
|
||||
//qDebug()<<"prot: got data " << recLength;
|
||||
if (recLength>FRAME_MAXLEN)
|
||||
recLength=FRAME_MAXLEN;
|
||||
for (int nn=0; nn<recLength; nn++)
|
||||
recBuffer[nn]=uint8_t(Indata.at(nn));
|
||||
|
||||
myString.clear();
|
||||
tempStr.clear();
|
||||
uint8_t result=FastCheckInData(recBuffer, recLength); // check input data (response from slave)
|
||||
if (result>0)
|
||||
{
|
||||
// dann anzeige
|
||||
switch (result)
|
||||
{
|
||||
case 1: gpi_setTxt4masterStateLine("wrong length received"); break;
|
||||
case 2: gpi_setTxt4masterStateLine("wrong start sign received"); break;
|
||||
case 3: gpi_setTxt4masterStateLine("received datalen too big"); break;
|
||||
case 4: gpi_setTxt4masterStateLine("wrong data len received"); break;
|
||||
case 5: gpi_setTxt4masterStateLine("wrong crc received"); break;
|
||||
case 6: gpi_setTxt4masterStateLine("slave: master cmd was wrong"); break;
|
||||
case 7: gpi_setTxt4masterStateLine("slave: could not write/read data"); break;
|
||||
|
||||
}
|
||||
myString.setNum(result);
|
||||
|
||||
// qDebug()<<"T_prot_analyseRecData: got BL data"<< recLength <<
|
||||
// recBuffer[0]<< recBuffer[1]<< recBuffer[2]<< recBuffer[3] <<
|
||||
// recBuffer[4]<< recBuffer[5]<< recBuffer[6]<< recBuffer[7];
|
||||
|
||||
// Daten abspeichern, könnten vom BL sein:
|
||||
gpi_storeRawReceivedData(uint8_t(recLength), recBuffer);
|
||||
INdataValid=false;
|
||||
emit rawDataRecieved();
|
||||
} else
|
||||
{
|
||||
gpi_setTxt4masterStateLine("slave response OK");
|
||||
INdataValid=true;
|
||||
ShowFastInData(recBuffer); // Eingangs-Daten des Slaves anzeigen
|
||||
}
|
||||
prot_storeResult=result;
|
||||
emit framerecieved(); // always emit, no matter if data valid or not
|
||||
|
||||
}
|
||||
|
||||
|
||||
uint8_t T_prot::FastCheckInData(uint8_t *Inbuf, uint16_t LL)
|
||||
{
|
||||
|
||||
uint16_t rawInLen=LL, crcL_Addr, recCrc, myCrc, nn, datalen, nxt;
|
||||
|
||||
|
||||
if (Inbuf[0]!=STARTSIGN_RECEIVE_FAST && Inbuf[0]!=STARTSIGN_RECEIVE_LONG)
|
||||
{
|
||||
//qDebug() << "prot: got wrong start sign: " << Inbuf[0];
|
||||
return 2; // wrong start sign
|
||||
}
|
||||
if ( (rawInLen<TELEGRAMLEN_RECEIVE_FAST && Inbuf[0]==STARTSIGN_RECEIVE_FAST) ||
|
||||
(rawInLen<TELEGRAMLEN_RECEIVE_LONG && Inbuf[0]==STARTSIGN_RECEIVE_LONG) )
|
||||
{
|
||||
//qDebug("prot: got %d bytes only", rawInLen);
|
||||
return 1; // wrong length
|
||||
}
|
||||
if (Inbuf[0]==0x5F)
|
||||
datalen=DATALEN_RECEIVE_FAST;
|
||||
else
|
||||
datalen=DATALEN_RECEIVE_LONG;
|
||||
|
||||
crcL_Addr=datalen+HEADERLEN_RECEIVE; // weil im definierten protocol 2 bytes vor den Daten stehen
|
||||
recCrc=0;
|
||||
recCrc=uchar2uint(uint8_t(Inbuf[crcL_Addr+1]), uint8_t(Inbuf[crcL_Addr]));
|
||||
myCrc=0;
|
||||
for (nn=0; nn<crcL_Addr; nn++)
|
||||
{
|
||||
nxt=uint16_t (Inbuf[nn]);
|
||||
nxt &=0x00FF; // the casting makes 0xFFFF out of 0xFF !!!!!!!!!
|
||||
myCrc+=nxt;
|
||||
//qDebug("CRC: nxt: %d sum: %d", nxt, myCrc);
|
||||
}
|
||||
|
||||
if (myCrc != recCrc)
|
||||
{
|
||||
//qDebug() << "crc does not match"; //: mycrc=" << myCrc<< " receivedCRC=" << recCrc;
|
||||
//qDebug("calculated over %d bytes", crcL_Addr);
|
||||
return 5; // crc wrong
|
||||
}
|
||||
|
||||
uint8_t result=Inbuf[1];
|
||||
// slave reports that 0: OK
|
||||
// bit 2,1,0: master command was wrong
|
||||
// bit 4,3: could not write data
|
||||
// bit 6,5: could not read data
|
||||
|
||||
|
||||
// NEU 17.7.23:
|
||||
if (result & 0x07)
|
||||
return 6; // slave: master cmd was wrong
|
||||
if (result & 0x78)
|
||||
return 7; // slave: could not write/read data
|
||||
|
||||
//if (result>0) schmarrn, kann nie kommen
|
||||
// qDebug() << "prot, got DC-result: "<< result;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
uint8_t T_prot::CheckInResult(uint8_t *Inbuf)
|
||||
{
|
||||
char slaveresult;
|
||||
QString myString=nullptr, tempStr=nullptr;
|
||||
|
||||
// slave results anzeigen
|
||||
|
||||
slaveresult=Inbuf[2]; // hier steht das "Command Result" des slaves,
|
||||
// d.h das Ergebnis der Protokol-Prüfung (Master->Slave)
|
||||
switch (slaveresult)
|
||||
{
|
||||
// received message (from master) analysis:
|
||||
// 0: got valid request
|
||||
// this errors can only come back from a single device (not bus)
|
||||
// or from a bus slave in local mode
|
||||
// 1: wrong start 2: wrong length
|
||||
// 3: wrong crc 4: wrong addr
|
||||
|
||||
case 1: gpi_setTxt4resultStateLine("slave got wrong start sign"); break;
|
||||
case 2: gpi_setTxt4resultStateLine("slave got wrong length"); break;
|
||||
case 3: gpi_setTxt4resultStateLine("slave got wrong crc"); break;
|
||||
case 4: gpi_setTxt4resultStateLine("slave got wrong addr"); break;
|
||||
|
||||
case 10: gpi_setTxt4resultStateLine("slave is in local mode"); break;
|
||||
case 13: gpi_setTxt4resultStateLine("local mode with wrong crc"); break;
|
||||
case 14: gpi_setTxt4resultStateLine("local mode with wrong addr"); break;
|
||||
// wenn 1..4 dann konnte der Slave das Mastertelegramm gar nicht verwenden, also hier Stoppen
|
||||
}
|
||||
if (slaveresult>0 && slaveresult<10)
|
||||
return 1;
|
||||
|
||||
// Slave hat gültiges Kommando empfangen:
|
||||
// 2.result auswerten:
|
||||
// recBuffer[3]; // Write result, d.h. Ergebnis des Schreibvorganges (z.B. DOs) des Slaves
|
||||
// recBuffer[4]; // Read result, d.h. Ergebnis des Lesevorganges (z.B. DIs) des Slaves
|
||||
// bisher nicht bekannt welche Fehlercodes es gibt, also den code direkt ausgeben.
|
||||
// bisher bekannt: 0=OK
|
||||
|
||||
myString.clear();
|
||||
myString = "Slave OUT and IN Result: ";
|
||||
tempStr.setNum(Inbuf[3],16);
|
||||
myString.append(tempStr);
|
||||
myString.append(" ");
|
||||
tempStr.setNum(Inbuf[4],16);
|
||||
myString.append(tempStr);
|
||||
gpi_setTxt4resultStateLine(myString);
|
||||
return 0;
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
uint8_t T_prot::ShowFastInData(uint8_t *recBuffer)
|
||||
{
|
||||
QString myString=nullptr, tempStr=nullptr;
|
||||
uint8_t result;
|
||||
|
||||
RecSlaveAddr=0;
|
||||
result=recBuffer[1]; // total result
|
||||
result &=0x60; // only read result (bit 5,6)
|
||||
|
||||
if (result==0) // read result =OK,
|
||||
// dann sind die Eingangsdaten gültig
|
||||
{
|
||||
myString.append("valid INdata: ");
|
||||
//INdataValid=true; // 17.7. hier raus!
|
||||
//readSource already set with sending
|
||||
//readAddress=0; großer Fehler!!!! raus am 17.7
|
||||
// RdDataLength already set with sending
|
||||
if (RdDataLength>FRAME_DATALEN)
|
||||
RdDataLength=FRAME_DATALEN;
|
||||
for (int ii=0; ii<RdDataLength; ii++)
|
||||
InputData[ii]=uint8_t(recBuffer[ii+HEADERLEN_RECEIVE]);
|
||||
|
||||
tempStr.setNum(readSource,16);
|
||||
myString.append(tempStr);
|
||||
myString.append(" add:");
|
||||
|
||||
tempStr.setNum(readAddress);
|
||||
myString.append(tempStr);
|
||||
//myString.append(" wakeSrc:");
|
||||
//tempStr.setNum(lastWakeSrc);
|
||||
//myString.append(tempStr);
|
||||
myString.append(" Dlen:");
|
||||
tempStr.setNum(RdDataLength);
|
||||
myString.append(tempStr);
|
||||
|
||||
} else
|
||||
{
|
||||
myString=" "; // Eingangsdaten nicht gültig, sieht man aber weiter oben schon
|
||||
|
||||
}
|
||||
|
||||
gpi_setTxt4dataStateLine(myString);
|
||||
//qDebug() << myString;
|
||||
//qDebug("prot_checkInData_bindata: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d ",
|
||||
// InputData[0], InputData[1], InputData[2], InputData[3],
|
||||
// InputData[4], InputData[5], InputData[6], InputData[7],
|
||||
// InputData[8], InputData[9], InputData[10], InputData[11],
|
||||
// InputData[12], InputData[13], InputData[14], InputData[15]);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
uint8_t T_prot::ifDataReceived()
|
||||
{
|
||||
// return: 0xFF: result unknown 0=OK
|
||||
// 1= wrong length 2=wrong start sign 5= wrong crc
|
||||
// 6= slave: master cmd was wrong 7: slave: could not write/read data
|
||||
return prot_storeResult;
|
||||
|
||||
}
|
||||
|
||||
bool T_prot::getReceivedInData(uint8_t *SlavAddr, uint16_t *readSrc, uint16_t *readAddr,
|
||||
uint8_t *RdDlen, uint8_t *receivedData)
|
||||
{
|
||||
uint8_t nn;
|
||||
*SlavAddr=RecSlaveAddr;
|
||||
*readSrc=readSource; // diese (Eingangs-)Daten stehen im Puffer
|
||||
*readAddr=readAddress; // von dieser Adr wurden die Daten gelesen
|
||||
|
||||
//qDebug()<<"prot_get_ReceivedInData, read address : " << readAddress;
|
||||
|
||||
//*lastWakSourc=lastWakeSrc; // falls der Slave den Master geweckt hat
|
||||
*RdDlen=RdDataLength;
|
||||
for (nn=0; nn<FRAME_DATALEN; nn++)
|
||||
receivedData[nn]=0;
|
||||
for (nn=0; nn<RdDataLength; nn++)
|
||||
receivedData[nn]=InputData[nn];
|
||||
|
||||
// neu, 17.10.23: lokalen Puffer löschen
|
||||
//for (nn=0; nn<FRAME_DATALEN; nn++)
|
||||
// {
|
||||
// InputData[nn]=0;
|
||||
//}
|
||||
// wieder raus, keinen Vorteil erkannt. Unklar ob das irgendwo Probleme macht! (bootloader?)
|
||||
|
||||
RdDataLength=0;
|
||||
//-------------------------------------------
|
||||
|
||||
return INdataValid; // nur true wenn CommandState OK und readState OK
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
748
src/runProc.cpp
Executable file
748
src/runProc.cpp
Executable file
@@ -0,0 +1,748 @@
|
||||
#include "runProc.h"
|
||||
#include <QDebug>
|
||||
#include "controlBus.h"
|
||||
#include "dcBL.h"
|
||||
#include "interfaces.h"
|
||||
|
||||
static uint32_t hwapi_lastStartAmount;
|
||||
static uint32_t hwapi_lastTotalAmount;
|
||||
static uint8_t hwapi_cash_lastCollectionState;
|
||||
static uint8_t hwapi_paymentStarted;
|
||||
static uint8_t hwapi_lastDoorState;
|
||||
static uint8_t bl_startupStep;
|
||||
|
||||
|
||||
|
||||
T_runProc::T_runProc()
|
||||
{
|
||||
|
||||
hwapi_TimerPayment = new QTimer();
|
||||
hwapi_TimerPayment->setSingleShot(true);
|
||||
|
||||
hwapi_lastStartAmount=0;
|
||||
hwapi_lastTotalAmount=0;
|
||||
hwapi_cash_lastCollectionState=0;
|
||||
hwapi_paymentStarted=0;
|
||||
hwapi_lastDoorState=0;
|
||||
bl_startupStep=0;
|
||||
|
||||
QTimer *runProc_callProcesses = new QTimer();
|
||||
connect(runProc_callProcesses, SIGNAL(timeout()), this, SLOT(runProc_slotProcess()));
|
||||
runProc_callProcesses->setSingleShot(false);
|
||||
runProc_callProcesses->start(100); // in ms
|
||||
|
||||
hwapi_lastDoorState=0; // default: all doors (should be) closed, coin box inserted
|
||||
// bit0: upper door 1:middle 2:lower 3=cash-box out
|
||||
|
||||
hwapi_triggerBL = new QTimer();
|
||||
connect(hwapi_triggerBL, SIGNAL(timeout()), this, SLOT(bl_performComplStart()));
|
||||
hwapi_triggerBL->setSingleShot(false);
|
||||
hwapi_triggerBL->stop();
|
||||
|
||||
}
|
||||
|
||||
|
||||
void T_runProc::runProc_slotProcess(void)
|
||||
{
|
||||
cash_paymentProcessing();
|
||||
doors_supervise();
|
||||
dcBL_cycle();
|
||||
|
||||
}
|
||||
|
||||
bool T_runProc::cash_startPayment(uint32_t amount)
|
||||
{
|
||||
uint8_t dat1, dat2, dat3, dat4;
|
||||
|
||||
hwapi_lastStartAmount=amount;
|
||||
epi_clearCurrentPayment();
|
||||
dat1=ulong2uchar(amount, 0);
|
||||
dat2=ulong2uchar(amount, 1);
|
||||
dat3=ulong2uchar(amount, 2);
|
||||
dat4=ulong2uchar(amount, 3);
|
||||
hwapi_cash_lastCollectionState=0;
|
||||
sendFDcmd_set(155, 0,0, dat1,dat2,dat3,dat4);
|
||||
// wird im DC auf 65500 gesetzt wenn 0 (Maximalwert 0 macht keinen Sinn!)
|
||||
|
||||
hwapi_paymentStarted=1;
|
||||
|
||||
hwapi_TimerPayment->start(5000); // in ms
|
||||
hwapi_lastTotalAmount=0;
|
||||
epi_setNowCoinPay(true); // new since 20.9.23
|
||||
qDebug() << "payment started with " << amount ;
|
||||
return true;
|
||||
|
||||
}
|
||||
|
||||
uint8_t T_runProc::cash_paymentProcessing(void)
|
||||
{
|
||||
// run this function periodically while coin payment process to generate necessary signals:
|
||||
|
||||
// am 5.10.23 umgebaut, geht jetzt auch fuer MW. Für EMP und MW getestet
|
||||
|
||||
// 12.10.23: epi_store64BdevParameter() MUSS vorher aufgerufen werden zur Unterscheidung EMP / MW !!!!!
|
||||
|
||||
// return value:
|
||||
// 0: stopped 1: starting up 2: coin collection
|
||||
// 3: finished by User (Push button) 4: finished, Max-Value collected
|
||||
// 5: finished by escrow
|
||||
// 6: money encashed
|
||||
// 7: cancelled
|
||||
// 10,11: error cannot start
|
||||
// 12: timeout while payment, coins returned
|
||||
// 13: stopped by unexpected error
|
||||
|
||||
struct T_emp empStat;
|
||||
struct T_changer chgrStat;
|
||||
|
||||
struct T_dynamicCondition myDynMachCond;
|
||||
struct T_devices devParameter;
|
||||
|
||||
uint8_t collActiv=0, payInProg, empState, kcc;
|
||||
uint32_t newSum;
|
||||
|
||||
if (hwapi_paymentStarted<1)
|
||||
return 0; // off
|
||||
|
||||
collActiv=1; // starting up payment
|
||||
devParameter.kindOfCoinChecker=0;
|
||||
restoreDeviceParameter(&devParameter);
|
||||
kcc=devParameter.kindOfCoinChecker;
|
||||
/*
|
||||
buf66[0]=devPara.kindOfPrinter;
|
||||
buf66[1]=devPara.kindOfCoinChecker;
|
||||
buf66[2]=devPara.kindOfMifareReader;
|
||||
buf66[3]=devPara.suppressSleepMode;
|
||||
buf66[4]=devPara.kindOfModem;
|
||||
buf66[5]=devPara.kindOfCreditcard;
|
||||
buf66[6]=devPara.CoinEscrow;
|
||||
buf66[7]=devPara.CoinRejectUnit;
|
||||
buf66[8]=devPara.CoinShutter;
|
||||
buf66[9]=devPara.BillAcceptor;
|
||||
buf66[10]=devPara.usevaultLock;
|
||||
buf66[11]=devPara.autoAlarm;
|
||||
buf66[12]=devPara.autoOpen;
|
||||
buf66[13]=devPara.printAccReceipt;
|
||||
buf66[14]=devPara.printDoorReceipt;
|
||||
buf66[15]=devPara.printTokenTicket;
|
||||
uitmp=devPara.VaultFullWarnLevel;
|
||||
buf66[16]=swl_getOneByteFromUint(uitmp, GETLOWBYT);
|
||||
buf66[17]=swl_getOneByteFromUint(uitmp, GETHIGHBYT);
|
||||
uitmp=devPara.VaultFullErrorLevel;
|
||||
buf66[18]=swl_getOneByteFromUint(uitmp, GETLOWBYT);
|
||||
buf66[19]=swl_getOneByteFromUint(uitmp, GETHIGHBYT);
|
||||
|
||||
*/
|
||||
if (kcc<3)
|
||||
{
|
||||
sub_emp_getAllParameters(&empStat);
|
||||
empState=empStat.state;
|
||||
} else
|
||||
{
|
||||
changer_getAllParameters(&chgrStat);
|
||||
empState=chgrStat.state;
|
||||
}
|
||||
|
||||
// 0=start command
|
||||
// 1=powered, do emp ini, send reset
|
||||
// 2=delay
|
||||
// 3=wait for response, requesting status after response
|
||||
// 4,5 through, startup
|
||||
// 6: wait for status
|
||||
// 7: through, startup
|
||||
// 8: IDLE state. EMP is up and ready, polling is running
|
||||
// 9: polling on, payment not yet on
|
||||
// 10: payment, check coins
|
||||
// 11: through
|
||||
// 12: wait 1s for last coin
|
||||
// 90: stop all, 1s delay
|
||||
// 99: off, all stopped
|
||||
|
||||
sub_getDynMachineConditions(&myDynMachCond);
|
||||
payInProg= myDynMachCond.paymentInProgress;
|
||||
// 0: stopped by timeout
|
||||
// 1: running 2: wait4lastCoin
|
||||
// 3: payment stopped manually, coins in Escrow
|
||||
// 4: payment stopped autom, amount collected, coins in Escrow
|
||||
// 5: payment stopped, escrow full, coins in Escrow
|
||||
// 6: coins encashed
|
||||
// 7: coins returned 2 cases: due to cancel-button or printer-error
|
||||
// 8: CoinChecker or MDB on Error
|
||||
|
||||
// qCritical() << "emitting signal payCancelled";
|
||||
// emit runProc_payCancelled();
|
||||
|
||||
if (payInProg==8)
|
||||
{
|
||||
// coin checker faulty, cannot start
|
||||
if (hwapi_paymentStarted==1)
|
||||
{
|
||||
hwapi_paymentStarted=90; // stop due to error
|
||||
qCritical() << "emitting signal coinCollectionAborted 1";
|
||||
emit runProc_coinCollectionAborted();
|
||||
//sendFDcmd_set(156, 0,0, 2,0,0,0); // cancel payment
|
||||
}
|
||||
|
||||
return 10; // error cannot start
|
||||
}
|
||||
|
||||
if (empState>=10 && empState<=12 && (payInProg==1 || payInProg==2) )
|
||||
{
|
||||
// coin acceptance is active now:
|
||||
if (hwapi_paymentStarted==1) // && (( payInProg==0) || ( payInProg>5))) //16.6.23
|
||||
{ // 1=wait for coin checker being ready
|
||||
hwapi_paymentStarted=2; // coins can be inserted now
|
||||
qCritical() << "emitting signal coinCollectionJustStarted";
|
||||
emit runProc_coinCollectionJustStarted();
|
||||
}
|
||||
}
|
||||
|
||||
if (hwapi_paymentStarted==2)
|
||||
{
|
||||
// coins can be inserted now, wait for end
|
||||
collActiv=2; // coin collection active
|
||||
|
||||
newSum=epi_CurrentPaymentGetAmount();
|
||||
if (newSum>hwapi_lastTotalAmount)
|
||||
{
|
||||
hwapi_lastTotalAmount=newSum;
|
||||
qCritical() << "emitting signal gotNewCoin";
|
||||
emit runProc_gotNewCoin();
|
||||
}
|
||||
|
||||
if (payInProg==0) // timeout, coins returned by DC
|
||||
{
|
||||
hwapi_paymentStarted=90;
|
||||
collActiv=12; // stop by timeout
|
||||
qCritical() << "emitting signal payStopByTimeout";
|
||||
emit runProc_payStopByTimeout();
|
||||
|
||||
} else
|
||||
|
||||
if (payInProg==3) // user pressed "Next/Continue", keep coin
|
||||
{
|
||||
hwapi_paymentStarted++;
|
||||
collActiv=3;
|
||||
qCritical() << "emitting signal payStopByPushbutton 1";
|
||||
emit runProc_payStopByPushbutton();
|
||||
} else
|
||||
|
||||
if (payInProg==4) // max achieved, keep coins
|
||||
{
|
||||
hwapi_paymentStarted++;
|
||||
collActiv=4;
|
||||
qCritical() << "emitting signal payStopByMax";
|
||||
emit runProc_payStopByMax();
|
||||
} else
|
||||
|
||||
if (payInProg==5) // escrow full, keep coins
|
||||
{
|
||||
hwapi_paymentStarted++;
|
||||
collActiv=5;
|
||||
qCritical() << "emitting signal payStopByEscrow";
|
||||
emit runProc_payStopByEscrow();
|
||||
}
|
||||
|
||||
/* 5.10.23 raus, geht auf 99 wenn Betrag erreicht, ist aber kein fehler
|
||||
if ( (empState<10) || (empState>12)) // error
|
||||
{
|
||||
collActiv=13;
|
||||
hwapi_paymentStarted=90;
|
||||
qCritical() << "emitting signal payStopByError" << empState;
|
||||
emit runProc_payStopByError();
|
||||
} */
|
||||
|
||||
}
|
||||
|
||||
if (hwapi_paymentStarted==3)
|
||||
{
|
||||
// coin collection finished, but coins kept until printing done
|
||||
collActiv=2;
|
||||
if (payInProg==6) // coins encashed
|
||||
{
|
||||
collActiv=6;
|
||||
hwapi_paymentStarted++;
|
||||
qCritical() << "emitting signal coinProcessJustStopped";
|
||||
emit runProc_coinProcessJustStopped();
|
||||
} else
|
||||
|
||||
if (payInProg==7) // coins returned, printing failed
|
||||
{
|
||||
collActiv=7;
|
||||
hwapi_paymentStarted++;
|
||||
qCritical() << "emitting signal payCancelled";
|
||||
emit runProc_payCancelled();
|
||||
}
|
||||
}
|
||||
|
||||
if (hwapi_paymentStarted==4)
|
||||
{
|
||||
// transaction finished
|
||||
hwapi_paymentStarted=0;
|
||||
}
|
||||
|
||||
//if ( (empState<8) || (empState>12))
|
||||
// epi_clearCurrentPayment(); // to avoid wrong "got-coin" messages
|
||||
|
||||
if (hwapi_paymentStarted==90 )
|
||||
{
|
||||
// EMP error, wait till process finished
|
||||
// everything stopped, no more coins in escrow
|
||||
hwapi_paymentStarted=0;
|
||||
}
|
||||
|
||||
return collActiv;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void T_runProc::sub_emp_getAllParameters(struct T_emp *emp)
|
||||
{
|
||||
uint8_t leng, data[66], ii, pp;
|
||||
epi_restoreEmpSettings(&leng, data); // expected length = 64 byte
|
||||
|
||||
// get 64 bytes about EMP: see h-file
|
||||
|
||||
emp->gotSetup = data[0];
|
||||
emp->state = data[1];
|
||||
emp->shaft = data[2];
|
||||
emp->countryCode= uchar2uint(data[4], data[3]);
|
||||
emp->scale = data[5];
|
||||
emp->decimals = data[6];
|
||||
for (ii=0; ii<16; ii++)
|
||||
emp->coinValues[ii] = data[7+ii];
|
||||
emp->coinAccept = uchar2uint(data[24], data[23]);
|
||||
emp->tokenChannel = data[25];
|
||||
emp->pollingRunning = data[26];
|
||||
emp->paymentRunning = data[27];
|
||||
|
||||
pp=28;
|
||||
for (ii=0; ii<16; ii++)
|
||||
{
|
||||
emp->denomination[ii] = uchar2uint(data[pp+1], data[pp]);
|
||||
pp+=2;
|
||||
}
|
||||
emp->routing= uchar2uint(data[61], data[60]);
|
||||
|
||||
}
|
||||
|
||||
void T_runProc::changer_getAllParameters(struct T_changer *mw)
|
||||
{
|
||||
// requested automatically with 23, same like EMP
|
||||
|
||||
uint8_t leng, data[66], pp, nn;
|
||||
epi_restoreEmpSettings(&leng, data); // expected length = 64 byte
|
||||
|
||||
// get 64 bytes about Changer (mw), see interfaces.h-file
|
||||
mw->setup = data[0];
|
||||
mw->state = data[1];
|
||||
mw->level = data[2];
|
||||
mw->countryCode = uchar2uint(data[4], data[3]);
|
||||
mw->scale = data[5];
|
||||
mw->decimals= data[6];
|
||||
|
||||
for (nn=0; nn<16; nn++)
|
||||
mw->coinSetup[nn]= data[nn+7]; // 7...22
|
||||
mw->intendedAcceptance = uchar2uint(data[24], data[23]);
|
||||
mw->tokenChannel= data[25];
|
||||
mw->pollingRunning= data[26];
|
||||
mw->paymentRunning= data[27];
|
||||
pp=28;
|
||||
for (nn=0; nn<16; nn++)
|
||||
{
|
||||
mw->denomination[nn] = uchar2uint(data[pp+1], data[pp]);
|
||||
pp+=2;
|
||||
}
|
||||
// bis pp=60
|
||||
mw->availableTubes = uchar2uint(data[61], data[60]);
|
||||
}
|
||||
|
||||
|
||||
void T_runProc::sub_getDynMachineConditions(struct T_dynamicCondition *dynMachCond)
|
||||
{
|
||||
|
||||
uint16_t LL, nn;
|
||||
char *start;
|
||||
uint8_t buf[70], leng;
|
||||
|
||||
epi_restoreDynMachineConditions(&leng, buf);
|
||||
// Puffer in struct eintragen:
|
||||
LL=sizeof(struct T_dynamicCondition);
|
||||
start = &dynMachCond->allDoorsDebounced;
|
||||
nn=0;
|
||||
do
|
||||
{
|
||||
*start = buf[nn];
|
||||
start++;
|
||||
} while(++nn<LL);
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
static uint8_t Sdata_DeviceParameter[64];
|
||||
static uint8_t Sdata_DevParaLen;
|
||||
|
||||
uint8_t T_runProc::epi_store64BdevParameter(uint8_t length, uint8_t *buf)
|
||||
{
|
||||
// HWapi writes data to be stored
|
||||
uint8_t nn;
|
||||
for (nn=0; nn<length; nn++)
|
||||
Sdata_DeviceParameter[nn]=buf[nn];
|
||||
for (nn=length; nn<64; nn++)
|
||||
Sdata_DeviceParameter[nn]=0;
|
||||
|
||||
Sdata_DevParaLen=length;
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint8_t T_runProc::epi_restore64BdevParameter(uint8_t *length, uint8_t *buf)
|
||||
{
|
||||
|
||||
for (uint8_t nn=0; nn<Sdata_DevParaLen; nn++)
|
||||
buf[nn]=Sdata_DeviceParameter[nn];
|
||||
*length=Sdata_DevParaLen;
|
||||
|
||||
return 0;
|
||||
}
|
||||
*/
|
||||
|
||||
void T_runProc::restoreDeviceParameter(struct T_devices *deviceSettings)
|
||||
{
|
||||
// attention: only applies if function "sys_sendDeviceParameter()" was used to send this settings before
|
||||
// cannot be used to see settings programmed by JsonFile
|
||||
uint8_t buf[64];
|
||||
uint8_t LL, nn;
|
||||
tslib_strclr(buf,0,64);
|
||||
uint8_t *start;
|
||||
|
||||
//epi_restore64BdevParameter(&LL, buf); schmarrn
|
||||
|
||||
epi_restoreRbDeviceSettings(&LL, buf);
|
||||
// Puffer in struct eintragen:
|
||||
start = &deviceSettings->kindOfPrinter;
|
||||
nn=0;
|
||||
do
|
||||
{
|
||||
*start = buf[nn];
|
||||
start++;
|
||||
} while(++nn<LL);
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
bool T_runProc::doors_supervise(void)
|
||||
{
|
||||
// new from 2023.06.12, generate some signals:
|
||||
//virtual void hwapi_ doorServiceDoorOpened(void) const=0;
|
||||
//virtual void hwapi_ doorVaultDoorOpened(void) const=0;
|
||||
//virtual void hwapi_ doorCBinAndAllDoorsClosed(void) const=0;
|
||||
//virtual void hwapi_ doorAllDoorsClosed(void) const=0;
|
||||
//virtual void hwapi_ doorCoinBoxRemoved(void) const=0;
|
||||
|
||||
//hwapi_lastDoorState: // bit0=1: upper door open bit1:middle bit2:lower bit3=1: cash-box out
|
||||
|
||||
struct T_dynamicCondition myDynMachCond;
|
||||
uint8_t uctmp, doorTemp;
|
||||
|
||||
sub_getDynMachineConditions(&myDynMachCond);
|
||||
//uint8_t CBinDebounced; // 0:fehlt 1:drin
|
||||
//char upperDoor; // 99: undefined 0:closed 1:open
|
||||
//char middleDoor; // 99: undefined 0:closed 1:open
|
||||
//char lowerDoor; // 99: undefined 0:closed 1:open
|
||||
//char billBox;
|
||||
|
||||
// PlausiCheck mit analogwerten:
|
||||
if ( (myDynMachCond.U_Batt<8000) || (myDynMachCond.U_Batt>16000)) // 8...16V erlaubt
|
||||
return false; // Fehler
|
||||
|
||||
if ((myDynMachCond.Temperatur<40) || (myDynMachCond.Temperatur>260)) // -30°C...80°C erleubt
|
||||
return false; // Fehler
|
||||
|
||||
uctmp=(hwapi_lastDoorState & 1); // 0: upper door is closed
|
||||
if (uctmp==0 && myDynMachCond.upperDoor>0)
|
||||
{
|
||||
hwapi_lastDoorState |= 1;
|
||||
qCritical()<<"hwapi emitting signal ServiceDoorOpened";
|
||||
emit runProc_doorServiceDoorOpened();
|
||||
}
|
||||
|
||||
uctmp=(hwapi_lastDoorState & 2);
|
||||
if (uctmp==0 && myDynMachCond.middleDoor>0)
|
||||
{
|
||||
hwapi_lastDoorState |= 2;
|
||||
qCritical()<<"hwapi emitting signal VaultDoorOpened ";
|
||||
emit runProc_doorVaultDoorOpened();
|
||||
}
|
||||
|
||||
uctmp=(hwapi_lastDoorState & 4);
|
||||
if (uctmp==0 && myDynMachCond.lowerDoor>0)
|
||||
{
|
||||
hwapi_lastDoorState |= 4;
|
||||
qCritical()<<"hwapi emitting signal ServiceDoorOpened (Batt)";
|
||||
emit runProc_doorServiceDoorOpened();
|
||||
}
|
||||
|
||||
uctmp=(hwapi_lastDoorState & 8); // 0: cash box was in
|
||||
if (uctmp==0 && myDynMachCond.CBinDebounced==0) // 0:fehlt 1:drin
|
||||
{
|
||||
// wurde gerade entnommen
|
||||
hwapi_lastDoorState |= 8;
|
||||
qCritical()<<"hwapi emitting signal CoinBoxRemoved ";
|
||||
emit runProc_doorCoinBoxRemoved();
|
||||
}
|
||||
|
||||
uctmp=(hwapi_lastDoorState & 8);
|
||||
if (uctmp>0 && myDynMachCond.CBinDebounced>0) // 0:fehlt 1:drin
|
||||
{
|
||||
// war draussen, ist wieder drin
|
||||
hwapi_lastDoorState &= ~0x08;
|
||||
qCritical()<<"hwapi emitting signal CoinBoxInserted";
|
||||
emit runProc_doorCoinBoxInserted();
|
||||
}
|
||||
|
||||
uctmp=(hwapi_lastDoorState & 0x07);
|
||||
doorTemp=0;
|
||||
if (myDynMachCond.upperDoor>0) doorTemp |=1;
|
||||
if (myDynMachCond.middleDoor>0) doorTemp |=2;
|
||||
if (myDynMachCond.lowerDoor>0) doorTemp |=4;
|
||||
|
||||
if (uctmp>0 && doorTemp==0) // vorher war mind. EINE Tuer offen UND jetzt sind alle zu
|
||||
{
|
||||
hwapi_lastDoorState &= ~0x07;
|
||||
|
||||
// soeben wurde die letzte Tür geschlossen, prüfe ob Kasse eingesetzt wurde:
|
||||
if (myDynMachCond.CBinDebounced)
|
||||
{
|
||||
qCritical()<<"hwapi emitting signal CBinAndAllDoorsClosed";
|
||||
emit runProc_doorCBinAndAllDoorsClosed();
|
||||
hwapi_lastDoorState &=~0x08; // keine Wirkung
|
||||
} else
|
||||
{
|
||||
qCritical()<<"hwapi emitting signal AllDoorsClosed";
|
||||
emit runProc_doorAllDoorsClosed();
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
}
|
||||
|
||||
|
||||
uint8_t T_runProc::prn_getHwState(struct Tprn_hw_state *prn_hw_state)
|
||||
{
|
||||
// return printer hardware state: power is on? rs-driver on? rs_switch ok? hw-ready-line ok?
|
||||
// printer on error or ok?
|
||||
uint8_t prnHWstate[20];
|
||||
|
||||
epi_restorePrinterState(prnHWstate);
|
||||
// byte 1...6 come right from printer, see printer manual
|
||||
// byte 0 = all important infos:
|
||||
// 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
|
||||
|
||||
prn_hw_state->powerRdBk = epi_getDI_printerPwr();
|
||||
prn_hw_state->rsSwOk = epi_getDO_serialMux1isSetToPrinter(); // mux1 off: serial is switched to printer
|
||||
prn_hw_state->rsDrvOk = epi_getDO_serialDriverIsOn();
|
||||
prn_hw_state->ReadyLine = epi_getDI_prnReady();
|
||||
|
||||
if (prnHWstate[0]==0)
|
||||
prn_hw_state->inIdle = true; // no errors
|
||||
else
|
||||
prn_hw_state->inIdle = false; // off or errors
|
||||
|
||||
if (prnHWstate[0] & 1)
|
||||
prn_hw_state->paperNearEnd=true;
|
||||
else
|
||||
prn_hw_state->paperNearEnd = false;
|
||||
|
||||
if (prnHWstate[0] & 2)
|
||||
prn_hw_state->noPaper=true;
|
||||
else
|
||||
prn_hw_state->noPaper = false;
|
||||
|
||||
if (prnHWstate[0] & 4)
|
||||
prn_hw_state->ErrorTemp=true;
|
||||
else
|
||||
prn_hw_state->ErrorTemp = false;
|
||||
|
||||
if (prnHWstate[0] & 8)
|
||||
prn_hw_state->HeadOpen=true;
|
||||
else
|
||||
prn_hw_state->HeadOpen = false;
|
||||
|
||||
if (prnHWstate[0] & 16)
|
||||
prn_hw_state->cutterJam=true;
|
||||
else
|
||||
prn_hw_state->cutterJam = false;
|
||||
|
||||
|
||||
if (prnHWstate[0] & 64)
|
||||
prn_hw_state->noResponse=true;
|
||||
else
|
||||
prn_hw_state->noResponse = false;
|
||||
|
||||
if (prnHWstate[0] & 128)
|
||||
prn_hw_state->badResponse=true;
|
||||
else
|
||||
prn_hw_state->badResponse = false;
|
||||
return prnHWstate[0];
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void T_runProc::dc_autoRequest(bool on)
|
||||
{
|
||||
// automatically request ALL digital and analog sensors, get time/date, get status information
|
||||
epi_startEmmision(on);
|
||||
}
|
||||
|
||||
void T_runProc::bl_rebootDC(void)
|
||||
{
|
||||
// send command to normal DC-Program requesting a restart
|
||||
// BL is working for 5s after power-on-reset.
|
||||
|
||||
uint8_t len, buf[20];
|
||||
|
||||
len=dcBL_restartDC(buf);
|
||||
sendWRcmd_setSendBlock160(len, buf);
|
||||
}
|
||||
|
||||
void T_runProc::bl_startBL(void)
|
||||
{
|
||||
// use this function within the first 5s after reboot to startup the BL,
|
||||
// otherwise the BL jumps to normal DC application
|
||||
uint8_t len, buf[20];
|
||||
|
||||
len=dcBL_activatBootloader(buf);
|
||||
sendWRcmd_setSendBlock160(len, buf);
|
||||
epi_setNowIsBootload(true);
|
||||
}
|
||||
|
||||
void T_runProc::bl_checkBL(void)
|
||||
{
|
||||
// call this function in order to get information, afterwards use "bl_isUp()"
|
||||
uint8_t len, buf[20];
|
||||
|
||||
len=dcBL_readFWversion(buf);
|
||||
sendWRcmd_setSendBlock160(len, buf);
|
||||
}
|
||||
|
||||
bool T_runProc::bl_isUp(void)
|
||||
{
|
||||
uint8_t receivedData[160];
|
||||
uint8_t LL, nn;
|
||||
|
||||
for (nn=0; nn<160; nn++) receivedData[nn]=0;
|
||||
LL=epi_getRawRecLength();
|
||||
if (LL>0)
|
||||
{
|
||||
epi_getRawReceivedData(receivedData);
|
||||
|
||||
// response to "readFWversion"
|
||||
if (receivedData[0]==2 && receivedData[1]==146 && receivedData[2]==45 &&
|
||||
receivedData[3]==45 && receivedData[4] ==95 && receivedData[5]==176)
|
||||
{
|
||||
qDebug() << "got BL response to readFWversion";
|
||||
epi_clrRawReceivedString();
|
||||
return true;
|
||||
}
|
||||
// response to "start BL"
|
||||
if (receivedData[0]==2 && receivedData[1]==101 && receivedData[2]==48 &&
|
||||
receivedData[3]==223 && receivedData[4] ==131 )
|
||||
{
|
||||
qDebug() << "hwapi_bl_isUp: got BL response to start";
|
||||
epi_clrRawReceivedString();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
void T_runProc::bl_completeStart(void)
|
||||
{
|
||||
bl_startupStep=1;
|
||||
}
|
||||
|
||||
bool T_runProc::bl_performComplStart(void)
|
||||
{
|
||||
// must be called cyclic by timer
|
||||
static uint8_t retryCtr;
|
||||
|
||||
if ((bl_startupStep<1) || (bl_startupStep>10))
|
||||
return false;
|
||||
|
||||
if (bl_startupStep==1)
|
||||
{
|
||||
dc_autoRequest(false);
|
||||
bl_startupStep++;
|
||||
} else
|
||||
|
||||
if (bl_startupStep==2)
|
||||
{
|
||||
bl_rebootDC();
|
||||
hwapi_triggerBL->stop();
|
||||
hwapi_triggerBL->start(1000); // call next step in 1s
|
||||
retryCtr=0;
|
||||
bl_startupStep++;
|
||||
} else
|
||||
|
||||
if (bl_startupStep==3)
|
||||
{
|
||||
//qDebug()<<"starting BL";
|
||||
bl_startBL();
|
||||
hwapi_triggerBL->stop();
|
||||
hwapi_triggerBL->start(100);
|
||||
bl_startupStep++;
|
||||
|
||||
} else
|
||||
|
||||
if (bl_startupStep==4)
|
||||
{
|
||||
//if (!myTO->isActive())
|
||||
//{
|
||||
bl_checkBL();
|
||||
hwapi_triggerBL->stop();
|
||||
hwapi_triggerBL->start(100);
|
||||
bl_startupStep++;
|
||||
|
||||
//}
|
||||
|
||||
} else
|
||||
|
||||
if (bl_startupStep==5)
|
||||
{
|
||||
hwapi_triggerBL->stop();
|
||||
if (bl_isUp())
|
||||
{
|
||||
bl_startupStep=99;
|
||||
// BL is up and running
|
||||
} else
|
||||
{
|
||||
retryCtr++; // start again
|
||||
if (retryCtr>=15)
|
||||
{
|
||||
bl_startupStep=99;
|
||||
//qDebug()<<"BL error!!!";
|
||||
} else
|
||||
{
|
||||
bl_startupStep=3;
|
||||
//qDebug()<<"BL retry...";
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
811
src/sendWRcmd sm.cpp
Executable file
811
src/sendWRcmd sm.cpp
Executable file
@@ -0,0 +1,811 @@
|
||||
#include <stdint.h>
|
||||
#include <QString>
|
||||
#include <QDebug>
|
||||
#include <QDateTime>
|
||||
#include "tslib.h"
|
||||
#include "sendWRcmd.h"
|
||||
#include "shared_mem_buffer.h"
|
||||
|
||||
|
||||
void indat_PrnPwr(void);
|
||||
|
||||
|
||||
void sendWRcmd_INI(void)
|
||||
{
|
||||
|
||||
sendWRcmd_clrCmdStack();
|
||||
sendWRcmd_clrCmd4Stack();
|
||||
sendFDcmd_clrStack();
|
||||
|
||||
}
|
||||
|
||||
// Command Stack for commands without parameters
|
||||
|
||||
|
||||
//static uint16_t nextAsynchsendCmd0[CMDSTACKDEPTH];
|
||||
//static uint8_t nrOfCmdsInQueue;
|
||||
|
||||
/* convention: use simple (not rotating) FIFO Stack:
|
||||
Example: nrOfCmdsInQueue=4 then
|
||||
nextAsynchsendCmd0[0]=cmd1 // was stored as first
|
||||
nextAsynchsendCmd0[1]=cmd2
|
||||
nextAsynchsendCmd0[2]=cmd3
|
||||
nextAsynchsendCmd0[3]=cmd4 // came in as last
|
||||
|
||||
Send: [0] first, then move buffer 1 down:
|
||||
nextAsynchsendCmd0[0]=cmd2
|
||||
nextAsynchsendCmd0[1]=cmd3
|
||||
nextAsynchsendCmd0[2]=cmd4
|
||||
nextAsynchsendCmd0[3]=0;
|
||||
nrOfCmdsInQueue=3 now
|
||||
*/
|
||||
|
||||
void sendWRcmd_clrCmdStack(void)
|
||||
{
|
||||
uint8_t nn;
|
||||
for (nn=0; nn<CMDSTACKDEPTH; nn++)
|
||||
SharedMem::write()->nextAsynchsendCmd0[nn]=0;
|
||||
SharedMem::write()->nrOfCmdsInQueue=0;
|
||||
}
|
||||
|
||||
bool sendWRcmd_setSendCommand0(uint16_t nextCmd)
|
||||
{
|
||||
// write Command to memory, wait for transport
|
||||
uint8_t ciq=SharedMem::read()->nrOfCmdsInQueue;
|
||||
if (ciq>=CMDSTACKDEPTH)
|
||||
{
|
||||
qDebug() << "cannot save cmd because stack is full";
|
||||
return false; // not possible
|
||||
}
|
||||
|
||||
SharedMem::write()->nextAsynchsendCmd0[ciq++]=nextCmd;
|
||||
SharedMem::write()->nrOfCmdsInQueue=ciq;
|
||||
|
||||
//qDebug() << "PI cmd queued:"<< nextCmd << ", saved, pp=" << nrOfCmdsInQueue;
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
uint16_t sendWRcmd_getSendCommand0(void)
|
||||
{
|
||||
uint16_t nxtAsynchCmd, data;
|
||||
uint8_t nn, ll;
|
||||
uint8_t ciq=SharedMem::read()->nrOfCmdsInQueue;
|
||||
|
||||
if (ciq==0 || ciq>CMDSTACKDEPTH)
|
||||
return 0; // error
|
||||
nxtAsynchCmd=SharedMem::read()->nextAsynchsendCmd0[0];
|
||||
|
||||
// move Puffer down by one element
|
||||
if (ciq>0)
|
||||
ll=ciq-1;
|
||||
else
|
||||
ll=0;
|
||||
for (nn=0; nn<ll; nn++)
|
||||
{
|
||||
data=SharedMem::read()->nextAsynchsendCmd0[nn+1];
|
||||
SharedMem::write()->nextAsynchsendCmd0[nn]=data;
|
||||
}
|
||||
SharedMem::write()->nrOfCmdsInQueue=ciq;
|
||||
//qDebug() << "PI cmd queued:"<< nxtAsynchCmd << ", restored, pp now =" << nrOfCmdsInQueue;
|
||||
return nxtAsynchCmd;
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------------------------------------------------
|
||||
// Command Stack for commands with 4 parameters
|
||||
|
||||
|
||||
/*
|
||||
static uint16_t nextAsynchsendCmd4[CMD4STACKDEPTH];
|
||||
static uint8_t nextCmd4para1[CMD4STACKDEPTH];
|
||||
static uint8_t nextCmd4para2[CMD4STACKDEPTH];
|
||||
static uint8_t nextCmd4para3[CMD4STACKDEPTH];
|
||||
static uint8_t nextCmd4para4[CMD4STACKDEPTH];
|
||||
static uint8_t nrOfCmds4InQueue;
|
||||
*/
|
||||
|
||||
|
||||
void sendWRcmd_clrCmd4Stack(void)
|
||||
{
|
||||
uint8_t nn;
|
||||
for (nn=0; nn<CMD4STACKDEPTH; nn++)
|
||||
{
|
||||
SharedMem::write()->nextAsynchsendCmd4[nn]=0;
|
||||
SharedMem::write()->nextCmd4para1[nn]=0;
|
||||
SharedMem::write()->nextCmd4para2[nn]=0;
|
||||
SharedMem::write()->nextCmd4para3[nn]=0;
|
||||
SharedMem::write()->nextCmd4para4[nn]=0;
|
||||
}
|
||||
SharedMem::write()->nrOfCmds4InQueue=0;
|
||||
}
|
||||
|
||||
|
||||
bool sendWRcmd_setSendCommand4(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4)
|
||||
{
|
||||
// write Command to memory, wait for transport
|
||||
uint8_t ciq;
|
||||
ciq=SharedMem::read()->nrOfCmds4InQueue;
|
||||
|
||||
if (ciq>=CMD4STACKDEPTH)
|
||||
{
|
||||
qDebug() << "cannot save cmd because stack is full";
|
||||
return false; // not possible
|
||||
}
|
||||
|
||||
SharedMem::write()->nextAsynchsendCmd4[ciq]=nextCmd;
|
||||
SharedMem::write()->nextCmd4para1[ciq]=dat1;
|
||||
SharedMem::write()->nextCmd4para2[ciq]=dat2;
|
||||
SharedMem::write()->nextCmd4para3[ciq]=dat3;
|
||||
SharedMem::write()->nextCmd4para4[ciq]=dat4;
|
||||
ciq++;
|
||||
SharedMem::write()->nrOfCmds4InQueue=ciq;
|
||||
|
||||
//qDebug() << QDateTime::currentDateTime().time()
|
||||
// << "sendWRcmd 4 byte saved, pp=" << nextCmd
|
||||
// << " para: " << SharedMem::getDataConst()->nextCmd4para1[pp];
|
||||
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
/*
|
||||
uint16_t sendWRcmd_getSendCommand4(uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4)
|
||||
{
|
||||
uint16_t nxtAsynchCmd;
|
||||
uint8_t nn, ll;
|
||||
|
||||
if (nrOfCmds4InQueue==0 || nrOfCmds4InQueue>CMD4STACKDEPTH)
|
||||
return 0; // error
|
||||
nxtAsynchCmd=nextAsynchsendCmd4[0];
|
||||
*dat1=nextCmd4para1[0];
|
||||
*dat2=nextCmd4para2[0];
|
||||
*dat3=nextCmd4para3[0];
|
||||
*dat4=nextCmd4para4[0];
|
||||
//qDebug() << "cmd4 restored to send from [0]; pp=" << nrOfCmds4InQueue;
|
||||
//qDebug() << " data1: " << nextCmd4para1[0] << " data2: " << nextCmd4para2[0] <<
|
||||
// " data3: " << nextCmd4para3[0] << " data4: " << nextCmd4para4[0];
|
||||
|
||||
// move Puffer down by one element
|
||||
if (CMD4STACKDEPTH>0)
|
||||
ll=CMD4STACKDEPTH-1;
|
||||
else
|
||||
ll=0;
|
||||
for (nn=0; nn<ll; nn++)
|
||||
{
|
||||
nextAsynchsendCmd4[nn]=nextAsynchsendCmd4[nn+1];
|
||||
nextCmd4para1[nn]=nextCmd4para1[nn+1];
|
||||
nextCmd4para2[nn]=nextCmd4para2[nn+1];
|
||||
nextCmd4para3[nn]=nextCmd4para3[nn+1];
|
||||
nextCmd4para4[nn]=nextCmd4para4[nn+1];
|
||||
}
|
||||
if (nrOfCmds4InQueue>0)
|
||||
nrOfCmds4InQueue--;
|
||||
//qDebug() << "cmd4 after push down: pp=" << nrOfCmds4InQueue;
|
||||
return nxtAsynchCmd;
|
||||
}
|
||||
|
||||
|
||||
*/
|
||||
|
||||
uint16_t sendWRcmd_getSendCommand4(uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4)
|
||||
{
|
||||
uint16_t nxtAsynchCmd, data;
|
||||
uint8_t nn;
|
||||
uint8_t ciq=SharedMem::read()->nrOfCmds4InQueue;
|
||||
|
||||
if (ciq==0 || ciq > CMD4STACKDEPTH)
|
||||
return 0; // error
|
||||
|
||||
nxtAsynchCmd=SharedMem::read()->nextAsynchsendCmd4[0];
|
||||
*dat1=SharedMem::read()->nextCmd4para1[0];
|
||||
*dat2=SharedMem::read()->nextCmd4para2[0];
|
||||
*dat3=SharedMem::read()->nextCmd4para3[0];
|
||||
*dat4=SharedMem::read()->nextCmd4para4[0];
|
||||
//qDebug() << "cmd4 restored to send from [0]; pp=" << nrOfCmds4InQueue;
|
||||
//qDebug() << " data1: " << nextCmd4para1[0] << " data2: " << nextCmd4para2[0] <<
|
||||
// " data3: " << nextCmd4para3[0] << " data4: " << nextCmd4para4[0];
|
||||
|
||||
// move Puffer down by one element
|
||||
if (ciq>0) ciq--;
|
||||
|
||||
for (nn=0; nn<ciq; nn++)
|
||||
{
|
||||
data=SharedMem::read()->nextAsynchsendCmd4[nn+1];
|
||||
SharedMem::write()->nextAsynchsendCmd4[nn]=data;
|
||||
data=SharedMem::read()->nextCmd4para1[nn+1];
|
||||
SharedMem::write()->nextCmd4para1[nn]=data;
|
||||
data=SharedMem::read()->nextCmd4para2[nn+1];
|
||||
SharedMem::write()->nextCmd4para2[nn]=data;
|
||||
data=SharedMem::read()->nextCmd4para3[nn+1];
|
||||
SharedMem::write()->nextCmd4para3[nn]=data;
|
||||
data=SharedMem::read()->nextCmd4para4[nn+1];
|
||||
SharedMem::write()->nextCmd4para4[nn]=data;
|
||||
}
|
||||
|
||||
SharedMem::write()->nrOfCmds4InQueue=ciq;
|
||||
return nxtAsynchCmd;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void sendWRcmd_clrCmd8Stack(void)
|
||||
{
|
||||
uint8_t nn;
|
||||
for (nn=0; nn<CMD8STACKDEPTH; nn++)
|
||||
{
|
||||
SharedMem::write()->nextAsynchsendCmd8[nn]=0;
|
||||
SharedMem::write()->nextCmd8para1[nn]=0;
|
||||
SharedMem::write()->nextCmd8para2[nn]=0;
|
||||
SharedMem::write()->nextCmd8para3[nn]=0;
|
||||
SharedMem::write()->nextCmd8para4[nn]=0;
|
||||
}
|
||||
SharedMem::write()->nrOfCmds8InQueue=0;
|
||||
}
|
||||
|
||||
bool sendWRcmd_setSendCommand8(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uint16_t dat3, uint32_t dat4)
|
||||
{
|
||||
// write Command to memory, wait for transport
|
||||
uint8_t ciq;
|
||||
ciq=SharedMem::read()->nrOfCmds8InQueue;
|
||||
|
||||
if (ciq>=CMD8STACKDEPTH)
|
||||
{
|
||||
qDebug() << "cannot save cmd because stack is full";
|
||||
return false; // not possible
|
||||
}
|
||||
SharedMem::write()->nextAsynchsendCmd8[ciq]=nextCmd;
|
||||
SharedMem::write()->nextCmd8para1[ciq]=dat1;
|
||||
SharedMem::write()->nextCmd8para2[ciq]=dat2;
|
||||
SharedMem::write()->nextCmd8para3[ciq]=dat3;
|
||||
SharedMem::write()->nextCmd8para4[ciq]=dat4;
|
||||
ciq++;
|
||||
SharedMem::write()->nrOfCmds8InQueue=ciq;
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
uint16_t sendWRcmd_getSendCommand8(uint8_t *dat1, uint8_t *dat2, uint16_t *dat3, uint32_t *dat4)
|
||||
{
|
||||
uint16_t nxtAsynchCmd, data;
|
||||
uint8_t nn;
|
||||
|
||||
uint8_t ciq=SharedMem::read()->nrOfCmds8InQueue;
|
||||
|
||||
if (ciq==0 || ciq > CMD8STACKDEPTH)
|
||||
return 0; // error
|
||||
|
||||
nxtAsynchCmd=SharedMem::read()->nextAsynchsendCmd8[0];
|
||||
*dat1=SharedMem::read()->nextCmd8para1[0];
|
||||
*dat2=SharedMem::read()->nextCmd8para2[0];
|
||||
*dat3=SharedMem::read()->nextCmd8para3[0];
|
||||
*dat4=SharedMem::read()->nextCmd8para4[0];
|
||||
|
||||
// move buffer down by one element
|
||||
if (ciq>0) ciq--;
|
||||
|
||||
for (nn=0; nn<ciq; nn++)
|
||||
{
|
||||
data=SharedMem::read()->nextAsynchsendCmd8[nn+1];
|
||||
SharedMem::write()->nextAsynchsendCmd8[nn]=data;
|
||||
data=SharedMem::read()->nextCmd8para1[nn+1];
|
||||
SharedMem::write()->nextCmd8para1[nn]=data;
|
||||
data=SharedMem::read()->nextCmd8para2[nn+1];
|
||||
SharedMem::write()->nextCmd8para2[nn]=data;
|
||||
data=SharedMem::read()->nextCmd8para3[nn+1];
|
||||
SharedMem::write()->nextCmd8para3[nn]=data;
|
||||
data=SharedMem::read()->nextCmd8para4[nn+1];
|
||||
SharedMem::write()->nextCmd8para4[nn]=data;
|
||||
}
|
||||
SharedMem::write()->nrOfCmds8InQueue=ciq;
|
||||
return nxtAsynchCmd;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//static uint8_t sendAsynchDataBuf[160]; // no stack, only ONE buffer
|
||||
//static uint8_t sendAsyDatLen;
|
||||
|
||||
bool sendWRcmd_setSendBlock160(uint8_t leng, uint8_t *buf)
|
||||
{
|
||||
if (leng>SENDASYDAT_BUFFSIZE) leng=SENDASYDAT_BUFFSIZE;
|
||||
SharedMem::write()->sendAsyDatLen=leng;
|
||||
tslib_strclr(SharedMem::write()->sendAsynchDataBuf, 0, SENDASYDAT_BUFFSIZE);
|
||||
for (uint8_t nn=0; nn<leng; nn++)
|
||||
SharedMem::write()->sendAsynchDataBuf[nn]=buf[nn];
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
uint8_t sendWRcmd_getSendBlock160(uint8_t *leng, uint8_t *buf)
|
||||
{
|
||||
|
||||
uint8_t dl=SharedMem::read()->sendAsyDatLen;
|
||||
*leng=dl;
|
||||
for (uint8_t nn=0; nn<dl; nn++)
|
||||
buf[nn]=SharedMem::read()->sendAsynchDataBuf[nn];
|
||||
SharedMem::write()->sendAsyDatLen=0;
|
||||
//tslib_strclr(SharedMem::write()->sendAsynchDataBuf, 0, SENDASYDAT_BUFFSIZE);
|
||||
return *leng;
|
||||
}
|
||||
|
||||
|
||||
// ------------------------------------------------------------------------------------
|
||||
// MDB Sendind Data are store here for next transport to DC (Device Controller)
|
||||
// Transport to Slave runs every 100ms, answer from mdb-slave (e.g. coin changer) comes rigth
|
||||
// with next slave answer
|
||||
|
||||
// start with: SENDDIRCMD_EXCHGMDB,
|
||||
// send crude data from here to DC, DC to mdb slaves, mdb answer, return here within 50ms
|
||||
|
||||
|
||||
//static uint8_t Sdata_mdbSendBuffer[MDBSEND_BUFFSIZE];
|
||||
//static uint8_t Sdata_mdbSendLen;
|
||||
|
||||
uint8_t epi_store64ByteSendData(uint8_t length, uint8_t *buf)
|
||||
{
|
||||
if (length>MDBSEND_BUFFSIZE) length=MDBSEND_BUFFSIZE;
|
||||
|
||||
// HWapi writes data to be forwarded to DC and further to mdb-device
|
||||
for (uint8_t nn=0; nn<length; nn++)
|
||||
SharedMem::write()->Sdata_mdbSendBuffer[nn]=buf[nn];
|
||||
SharedMem::write()->Sdata_mdbSendLen=length;
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint8_t gpi_restore64ByteSendData(uint8_t *length, uint8_t *buf)
|
||||
{
|
||||
// datif reads data to forward to dc
|
||||
uint8_t dl=SharedMem::read()->Sdata_mdbSendLen;
|
||||
|
||||
for (uint8_t nn=0; nn<dl; nn++)
|
||||
buf[nn]=SharedMem::read()->Sdata_mdbSendBuffer[nn];
|
||||
*length=dl;
|
||||
SharedMem::write()->Sdata_mdbSendLen=0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
//------------------------------------------------------------------------------------
|
||||
//---------------------------------------- Printer Text Fifo -------------------------
|
||||
//static uint8_t prnDataParameters[];
|
||||
//static uint8_t prnDataBufferUser;
|
||||
|
||||
void epi_storeUserOfSendingTextBuffer(uint8_t user, uint8_t para1, uint8_t para2, uint8_t para3, uint8_t para4 )
|
||||
{
|
||||
// user=1: Text-Print is using this buffer
|
||||
// 2: QR-code-Printer is using this buffer
|
||||
SharedMem::write()->prnDataBufferUser=user;
|
||||
SharedMem::write()->prnDataParameters[0]=para1;
|
||||
SharedMem::write()->prnDataParameters[1]=para2;
|
||||
SharedMem::write()->prnDataParameters[2]=para3;
|
||||
SharedMem::write()->prnDataParameters[3]=para4;
|
||||
|
||||
// qDebug() << "new user stored: " << user;
|
||||
|
||||
}
|
||||
|
||||
uint8_t gpi_getUserOfSendingTextBuffer(uint8_t *para1, uint8_t *para2, uint8_t *para3, uint8_t *para4)
|
||||
{
|
||||
// user=1: Text-Print is using this buffer
|
||||
// 2: QR-code-Printer is using this buffer
|
||||
//qDebug() << "returning user "<< prnDataBufferUser;
|
||||
|
||||
*para1=SharedMem::read()->prnDataParameters[0];
|
||||
*para2=SharedMem::read()->prnDataParameters[1];
|
||||
*para3=SharedMem::read()->prnDataParameters[2];
|
||||
*para4=SharedMem::read()->prnDataParameters[3];
|
||||
return SharedMem::read()->prnDataBufferUser;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// Sending Text Fifo
|
||||
// ONE printer doc consists of 20 x 64 byte
|
||||
// #define MAXNROF_PRNBYTES 64
|
||||
// #define MAXNROF_PRNBLOCKS 20
|
||||
//static char Sdata_PRN_TEXT[MAXNROF_PRNBLOCKS][MAXNROF_PRNBYTES];
|
||||
//static uint8_t pPrnDataBuff; // points to next PRINTER_BLOCK
|
||||
//static uint8_t pPrnDataBuff; // points to next waiting printer text
|
||||
// defined above, needed if more then one text is stored (before sent)
|
||||
// every block will be sent after 100ms, if 8 blocks are stored within this 100ms
|
||||
// then pointer goes up to 8. Important: FIFO!!!!!!!!
|
||||
|
||||
void epi_resetPrinterStack(void)
|
||||
{
|
||||
SharedMem::write()->pPrnDataBuff=0;
|
||||
}
|
||||
|
||||
uint8_t epi_storePrnText(char *buf, uint8_t leng)
|
||||
{
|
||||
// store text from Gui in next higher free memory 0....9
|
||||
|
||||
uint16_t len;
|
||||
uint8_t pp, nn;
|
||||
|
||||
pp=SharedMem::read()->pPrnDataBuff; // next free memory block with 64byte each
|
||||
if (pp>=MAXNROF_PRNBLOCKS)
|
||||
return 1; // not possible, no free mem
|
||||
|
||||
//len=tslib_strlen(buf); // kennt keine Binärzeichen!!!!!!
|
||||
len=leng;
|
||||
if (len>MAXNROF_PRNBYTES)
|
||||
len=MAXNROF_PRNBYTES;
|
||||
|
||||
tslib_strclr(SharedMem::write()->Sdata_PRN_TEXT[pp], 0, MAXNROF_PRNBYTES);
|
||||
|
||||
for (nn=0; nn<len; nn++)
|
||||
SharedMem::write()->Sdata_PRN_TEXT[pp][nn]=buf[nn]; // copy new text into buffer
|
||||
|
||||
if (SharedMem::read()->pPrnDataBuff<MAXNROF_PRNBLOCKS)
|
||||
SharedMem::write()->pPrnDataBuff++; // inc pointer if end not yet reached
|
||||
return 0; // OK
|
||||
}
|
||||
|
||||
|
||||
|
||||
uint8_t gpi_restorePrnText(uint8_t *retbuf)
|
||||
{
|
||||
// read printer text and send to slave, size of retbuf == 64
|
||||
|
||||
// always read from [0] because this is the oldest (Fifo)
|
||||
// then move all text lines down by one and dec pointer
|
||||
|
||||
uint8_t nn, mm, pp=SharedMem::read()->pPrnDataBuff;
|
||||
char buf[MAXNROF_PRNBYTES];
|
||||
|
||||
if (pp==0) // next free memory block with 64byte each
|
||||
return 1; // no text in buffer
|
||||
|
||||
// example: pp=5: then buffers [0...4] are occupied
|
||||
|
||||
for (nn=0; nn<MAXNROF_PRNBYTES; nn++)
|
||||
retbuf[nn] = uint8_t (SharedMem::read()->Sdata_PRN_TEXT[0][nn]); // restore oldest text
|
||||
|
||||
// now copy textline [1] to [0], then
|
||||
// copy textline [2] to [1], then
|
||||
// copy textline [3] to [2] .... upto [pp-1] to [pp-2]
|
||||
// hint: copying from 9....0 would delete all strings!!!!!!
|
||||
for (nn=0; nn<(pp-1); nn++)
|
||||
{
|
||||
for (mm=0; mm<MAXNROF_PRNBYTES; mm++)
|
||||
buf[mm]=SharedMem::read()->Sdata_PRN_TEXT[nn+1][mm];
|
||||
for (mm=0; mm<MAXNROF_PRNBYTES; mm++)
|
||||
SharedMem::write()->Sdata_PRN_TEXT[nn][mm]=buf[mm];
|
||||
}
|
||||
if (pp>0) pp--;
|
||||
SharedMem::write()->pPrnDataBuff=pp;
|
||||
|
||||
// example: pp=4: then buffers [0...3] are still occupied, pp=0: all buffers empty
|
||||
|
||||
// now clear highest copyed line (which became free now)
|
||||
tslib_strclr(SharedMem::write()->Sdata_PRN_TEXT[pp], 0, MAXNROF_PRNBYTES);
|
||||
|
||||
// optionally: clear all remaining higher lines:
|
||||
for (nn=(pp+1); nn<MAXNROF_PRNBLOCKS; nn++)
|
||||
tslib_strclr(SharedMem::write()->Sdata_PRN_TEXT[nn], 0, MAXNROF_PRNBYTES);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint8_t gpi_chk4remainingText(void)
|
||||
{
|
||||
// retval: 0: no more textline left (to send) >0: nr of 64byte-blocks
|
||||
return (SharedMem::read()->pPrnDataBuff);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------------------
|
||||
// 11.4.23 neu, Kommando direkt an "FastDevice"-protokoll senden, nicht mehr umsetzen
|
||||
// ---------------------------------------------------------------------------------
|
||||
/*
|
||||
// header
|
||||
static uint8_t nextFDwrCmd[FDCMD_STACKDEPTH];
|
||||
static uint8_t nextFDrdCmd[FDCMD_STACKDEPTH];
|
||||
static uint8_t nextFDblkNr[FDCMD_STACKDEPTH];
|
||||
static uint8_t nextFDshort[FDCMD_STACKDEPTH];
|
||||
|
||||
// short data
|
||||
static uint8_t nextFDpara1[FDCMD_STACKDEPTH];
|
||||
static uint8_t nextFDpara2[FDCMD_STACKDEPTH];
|
||||
static uint8_t nextFDpara3[FDCMD_STACKDEPTH];
|
||||
static uint8_t nextFDpara4[FDCMD_STACKDEPTH];
|
||||
// long data:
|
||||
static uint8_t longFDlength[FDCMD_STACKDEPTH];
|
||||
static uint8_t longFDpara[FDCMD_STACKDEPTH][64];
|
||||
|
||||
static uint8_t p_nextFDcmdsInQueue;
|
||||
*/
|
||||
|
||||
/* convention: use simple (not rotating) FIFO Stack:
|
||||
Example: nrOfCmdsInQueue=4 then
|
||||
nextAsynchsendCmd0[0]=cmd1 // was stored as first
|
||||
nextAsynchsendCmd0[1]=cmd2
|
||||
nextAsynchsendCmd0[2]=cmd3
|
||||
nextAsynchsendCmd0[3]=cmd4 // came in as last
|
||||
|
||||
Send: [0] first, then move buffer 1 down:
|
||||
nextAsynchsendCmd0[0]=cmd2
|
||||
nextAsynchsendCmd0[1]=cmd3
|
||||
nextAsynchsendCmd0[2]=cmd4
|
||||
nextAsynchsendCmd0[3]=0;
|
||||
nrOfCmdsInQueue=3 now
|
||||
*/
|
||||
|
||||
|
||||
void sendFDcmd_clrStack(void)
|
||||
{
|
||||
uint8_t nn;
|
||||
for (nn=0; nn<FDCMD_STACKDEPTH; nn++)
|
||||
{
|
||||
SharedMem::write()->nextFDwrCmd[nn]=0;
|
||||
SharedMem::write()->nextFDrdCmd[nn]=0;
|
||||
SharedMem::write()->nextFDblkNr[nn]=0;
|
||||
SharedMem::write()->nextFDshort[nn]=0;
|
||||
SharedMem::write()->nextFDpara1[nn]=0;
|
||||
SharedMem::write()->nextFDpara2[nn]=0;
|
||||
SharedMem::write()->nextFDpara3[nn]=0;
|
||||
SharedMem::write()->nextFDpara4[nn]=0;
|
||||
SharedMem::write()->longFDlength[nn]=0;
|
||||
memset(&SharedMem::write()->longFDpara[nn][0],0,64);
|
||||
}
|
||||
|
||||
SharedMem::write()->p_nextFDcmdsInQueue=0;
|
||||
}
|
||||
|
||||
bool sendFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4)
|
||||
{
|
||||
|
||||
// write Command to memory, wait for transport
|
||||
uint8_t pFDcmd=SharedMem::read()->p_nextFDcmdsInQueue;
|
||||
|
||||
if (pFDcmd >=FDCMD_STACKDEPTH)
|
||||
{
|
||||
qDebug() << "cannot save cmd because stack is full";
|
||||
return false; // not possible
|
||||
}
|
||||
SharedMem::write()->nextFDwrCmd[pFDcmd]=nextWrCmd;
|
||||
SharedMem::write()->nextFDrdCmd[pFDcmd]=nextRdCmd;
|
||||
SharedMem::write()->nextFDblkNr[pFDcmd]=blockNum;
|
||||
SharedMem::write()->nextFDpara1[pFDcmd]=dat1;
|
||||
SharedMem::write()->nextFDpara2[pFDcmd]=dat2;
|
||||
SharedMem::write()->nextFDpara3[pFDcmd]=dat3;
|
||||
SharedMem::write()->nextFDpara4[pFDcmd]=dat4;
|
||||
//qDebug() << "data with 4 data byte saved, pp=" << pFDcmd;
|
||||
//qDebug() << " dat1=" << nextCmd4para1[pFDcmd] << " dat2=" << nextCmd4para2[pFDcmd]
|
||||
// << " dat3=" << nextCmd4para3[pFDcmd] << " dat4=" << nextCmd4para4[pFDcmd];
|
||||
SharedMem::write()->nextFDshort[pFDcmd]=1; // 1=short
|
||||
pFDcmd++;
|
||||
SharedMem::write()->p_nextFDcmdsInQueue=pFDcmd;
|
||||
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
|
||||
bool longFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t length, uint8_t *data)
|
||||
{
|
||||
// write Command to memory, wait for transport
|
||||
// data buffer size always 64! data[64], padded with 0
|
||||
uint8_t nn;
|
||||
uint8_t pFDcmd=SharedMem::read()->p_nextFDcmdsInQueue;
|
||||
|
||||
if (pFDcmd>=FDCMD_STACKDEPTH)
|
||||
{
|
||||
qDebug() << "cannot save cmd because stack is full";
|
||||
return false; // not possible
|
||||
}
|
||||
SharedMem::write()->nextFDwrCmd[pFDcmd]=nextWrCmd;
|
||||
SharedMem::write()->nextFDrdCmd[pFDcmd]=nextRdCmd;
|
||||
SharedMem::write()->nextFDblkNr[pFDcmd]=blockNum;
|
||||
|
||||
SharedMem::write()->longFDlength[pFDcmd]=length;
|
||||
|
||||
for (nn=0; nn<64; nn++)
|
||||
SharedMem::write()->longFDpara[pFDcmd][nn]=data[nn];
|
||||
|
||||
SharedMem::write()->nextFDshort[pFDcmd]=2;
|
||||
pFDcmd++;
|
||||
SharedMem::write()->p_nextFDcmdsInQueue=pFDcmd;
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
|
||||
bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4)
|
||||
{
|
||||
uint8_t nn, mm, data; // ll
|
||||
uint8_t pFDcmd=SharedMem::read()->p_nextFDcmdsInQueue;
|
||||
|
||||
if (pFDcmd==0 || pFDcmd>FDCMD_STACKDEPTH)
|
||||
return false; // not possible
|
||||
|
||||
*nextWrCmd=SharedMem::read()->nextFDwrCmd[0];
|
||||
*nextRdCmd=SharedMem::read()->nextFDrdCmd[0];
|
||||
*blockNum=SharedMem::read()->nextFDblkNr[0];
|
||||
*dat1=SharedMem::read()->nextFDpara1[0];
|
||||
*dat2=SharedMem::read()->nextFDpara2[0];
|
||||
*dat3=SharedMem::read()->nextFDpara3[0];
|
||||
*dat4=SharedMem::read()->nextFDpara4[0];
|
||||
//qDebug() << "sendFDcmd_get [0]; pp=" << SharedMem::read()->p_nextFDcmdsInQueue;
|
||||
//qDebug() << " data1: " << SharedMem::read()->nextCmd4para1[0] << " data2: " << SharedMem::read()->nextCmd4para2[0] <<
|
||||
// " data3: " << SharedMem::read()->nextCmd4para3[0] << " data4: " << SharedMem::read()->nextCmd4para4[0];
|
||||
|
||||
// move Puffer down by one element
|
||||
//if (FDCMD_STACKDEPTH>0)
|
||||
// ll=FDCMD_STACKDEPTH-1;
|
||||
//else
|
||||
// ll=0;
|
||||
|
||||
if (pFDcmd>0) pFDcmd--; else pFDcmd=0;
|
||||
|
||||
//for (nn=0; nn<ll; nn++)
|
||||
for (nn=0; nn<pFDcmd; nn++)
|
||||
{
|
||||
data=SharedMem::read()->nextFDwrCmd[nn+1];
|
||||
SharedMem::write()->nextFDwrCmd[nn]=data;
|
||||
data=SharedMem::read()->nextFDrdCmd[nn+1];
|
||||
SharedMem::write()->nextFDrdCmd[nn]=data;
|
||||
data=SharedMem::read()->nextFDblkNr[nn+1];
|
||||
SharedMem::write()->nextFDblkNr[nn]=data;
|
||||
data=SharedMem::read()->nextFDpara1[nn+1];
|
||||
SharedMem::write()->nextFDpara1[nn]=data;
|
||||
data=SharedMem::read()->nextFDpara2[nn+1];
|
||||
SharedMem::write()->nextFDpara2[nn]=data;
|
||||
data=SharedMem::read()->nextFDpara3[nn+1];
|
||||
SharedMem::write()->nextFDpara3[nn]=data;
|
||||
data=SharedMem::read()->nextFDpara4[nn+1];
|
||||
SharedMem::write()->nextFDpara4[nn]=data;
|
||||
|
||||
data=SharedMem::read()->nextFDshort[nn+1];
|
||||
SharedMem::write()->nextFDshort[nn] = data;
|
||||
|
||||
data=SharedMem::read()->longFDlength[nn+1];
|
||||
SharedMem::write()->longFDlength[nn] = data;
|
||||
|
||||
for (mm=0; mm<64; mm++)
|
||||
{
|
||||
SharedMem::write()->longFDpara[nn][mm] = SharedMem::read()->longFDpara[nn+1][mm];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
SharedMem::write()->p_nextFDcmdsInQueue=pFDcmd;
|
||||
//qDebug() << "cmd4 after push down: pp=" << nrOfCmds4InQueue;
|
||||
|
||||
// clear released buffer:
|
||||
//for (nn=p_nextFDcmdsInQueue; nn<FDCMD_STACKDEPTH; nn++)
|
||||
//{
|
||||
SharedMem::write()->nextFDwrCmd[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDrdCmd[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDblkNr[pFDcmd]=0;
|
||||
|
||||
SharedMem::write()->nextFDpara1[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDpara2[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDpara3[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDpara4[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDshort[pFDcmd]=0;
|
||||
SharedMem::write()->longFDlength[pFDcmd]=0;
|
||||
for (mm=0; mm<64; mm++)
|
||||
SharedMem::write()->longFDpara[pFDcmd][mm] = 0;
|
||||
//}
|
||||
|
||||
/*
|
||||
qDebug() << "sendFDcmd_set, stack now: " << p_nextFDcmdsInQueue;
|
||||
for (nn=0; nn<16; nn++)
|
||||
{
|
||||
qDebug() << "header: " << nextFDwrCmd[nn] << " / " << nextFDrdCmd[nn] << " / "<< nextFDblkNr[nn] << " / " << nextFDshort[nn];
|
||||
|
||||
qDebug() << " short data: " << nextFDpara1[nn] << " / "<< nextFDpara2[nn] << " / "<< nextFDpara3[nn]<< " / "<< nextFDpara4[nn];
|
||||
|
||||
qDebug() << " long data: " << longFDlength[nn] << " / "<< longFDpara[nn][0] << " / "<< longFDpara[nn][1]
|
||||
<< " / "<< longFDpara[nn][2] << " / "<< longFDpara[nn][3] << " / "<< longFDpara[nn][4];
|
||||
}
|
||||
*/
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
uint8_t checkNextFDcmd(void)
|
||||
{
|
||||
// return 0: no command waiting
|
||||
// 1: short cmd
|
||||
// 2: long cmd
|
||||
//qDebug() << "chk nxt fd cmd: "<<p_nextFDcmdsInQueue<<" "<<nextFDshort[0]<<" "<<nextFDshort[1]<<" "<<nextFDshort[2]<<" "<<nextFDshort[3];
|
||||
if (SharedMem::read()->p_nextFDcmdsInQueue==0)
|
||||
return 0;
|
||||
if (SharedMem::read()->nextFDshort[0]==1)
|
||||
return 1;
|
||||
return 2;
|
||||
}
|
||||
|
||||
uint8_t check4FDshortCmd(void)
|
||||
{
|
||||
// returns number of waiting command, max FDCMD_STACKDEPTH
|
||||
return SharedMem::read()->p_nextFDcmdsInQueue;
|
||||
}
|
||||
|
||||
|
||||
uint8_t check4freeFDshortCmd(void)
|
||||
{
|
||||
// returns number of free places in short-command stack
|
||||
return FDCMD_STACKDEPTH - SharedMem::read()->p_nextFDcmdsInQueue;
|
||||
}
|
||||
|
||||
bool longFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *length, uint8_t *data)
|
||||
{
|
||||
uint8_t nn, mm, uctmp;
|
||||
uint8_t pFDcmd=SharedMem::read()->p_nextFDcmdsInQueue;
|
||||
|
||||
if (pFDcmd==0 || pFDcmd>FDCMD_STACKDEPTH)
|
||||
return false; // not possible
|
||||
|
||||
*nextWrCmd=SharedMem::read()->nextFDwrCmd[0];
|
||||
*nextRdCmd=SharedMem::read()->nextFDrdCmd[0];
|
||||
*blockNum=SharedMem::read()->nextFDblkNr[0];
|
||||
*length = SharedMem::read()->longFDlength[0];
|
||||
for (mm=0; mm<64; mm++)
|
||||
data[mm] = SharedMem::read()->longFDpara[0][mm];
|
||||
|
||||
if (pFDcmd>0) pFDcmd--; else pFDcmd=0;
|
||||
|
||||
//for (nn=0; nn<ll; nn++)
|
||||
for (nn=0; nn<pFDcmd; nn++)
|
||||
{
|
||||
uctmp=SharedMem::read()->nextFDwrCmd[nn+1];
|
||||
SharedMem::write()->nextFDwrCmd[nn]=uctmp;
|
||||
uctmp=SharedMem::read()->nextFDrdCmd[nn+1];
|
||||
SharedMem::write()->nextFDrdCmd[nn]=uctmp;
|
||||
uctmp=SharedMem::read()->nextFDblkNr[nn+1];
|
||||
SharedMem::write()->nextFDblkNr[nn]=uctmp;
|
||||
|
||||
uctmp=SharedMem::read()->nextFDpara1[nn+1];
|
||||
SharedMem::write()->nextFDpara1[nn]=uctmp;
|
||||
uctmp=SharedMem::read()->nextFDpara2[nn+1];
|
||||
SharedMem::write()->nextFDpara2[nn]=uctmp;
|
||||
uctmp=SharedMem::read()->nextFDpara3[nn+1];
|
||||
SharedMem::write()->nextFDpara3[nn]=uctmp;
|
||||
uctmp=SharedMem::read()->nextFDpara4[nn+1];
|
||||
SharedMem::write()->nextFDpara4[nn]=uctmp;
|
||||
|
||||
uctmp=SharedMem::read()->nextFDshort[nn+1];
|
||||
SharedMem::write()->nextFDshort[nn]=uctmp;
|
||||
uctmp=SharedMem::read()->longFDlength[nn+1];
|
||||
SharedMem::write()->longFDlength[nn]=uctmp;
|
||||
|
||||
for (mm=0; mm<64; mm++)
|
||||
{
|
||||
SharedMem::write()->longFDpara[nn][mm] = SharedMem::read()->longFDpara[nn+1][mm];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
SharedMem::write()->p_nextFDcmdsInQueue=pFDcmd;
|
||||
// clear released buffer:
|
||||
SharedMem::write()->nextFDwrCmd[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDrdCmd[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDblkNr[pFDcmd]=0;
|
||||
|
||||
SharedMem::write()->nextFDpara1[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDpara2[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDpara3[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDpara4[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDshort[pFDcmd]=0;
|
||||
SharedMem::write()->longFDlength[pFDcmd]=0;
|
||||
for (mm=0; mm<64; mm++)
|
||||
SharedMem::write()->longFDpara[pFDcmd][mm] = 0;
|
||||
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
|
||||
|
||||
842
src/sendWRcmd.cpp
Normal file
842
src/sendWRcmd.cpp
Normal file
@@ -0,0 +1,842 @@
|
||||
#include <stdint.h>
|
||||
#include <QString>
|
||||
#include <QDebug>
|
||||
#include <QDateTime>
|
||||
#include "tslib.h"
|
||||
#include "sendWRcmd.h"
|
||||
#include "shared_mem_buffer.h"
|
||||
|
||||
|
||||
void indat_PrnPwr(void);
|
||||
|
||||
|
||||
void sendWRcmd_INI(void)
|
||||
{
|
||||
|
||||
//sendWRcmd_clrCmdStack();
|
||||
//sendWRcmd_clrCmd4Stack();
|
||||
sendFDcmd_clrStack();
|
||||
|
||||
}
|
||||
|
||||
// Command Stack for commands without parameters
|
||||
|
||||
|
||||
//static uint16_t nextAsynchsendCmd0[CMDSTACKDEPTH];
|
||||
//static uint8_t nrOfCmdsInQueue;
|
||||
|
||||
/* convention: use simple (not rotating) FIFO Stack:
|
||||
Example: nrOfCmdsInQueue=4 then
|
||||
nextAsynchsendCmd0[0]=cmd1 // was stored as first
|
||||
nextAsynchsendCmd0[1]=cmd2
|
||||
nextAsynchsendCmd0[2]=cmd3
|
||||
nextAsynchsendCmd0[3]=cmd4 // came in as last
|
||||
|
||||
Send: [0] first, then move buffer 1 down:
|
||||
nextAsynchsendCmd0[0]=cmd2
|
||||
nextAsynchsendCmd0[1]=cmd3
|
||||
nextAsynchsendCmd0[2]=cmd4
|
||||
nextAsynchsendCmd0[3]=0;
|
||||
nrOfCmdsInQueue=3 now
|
||||
*/
|
||||
|
||||
void sendWRcmd_clrCmdStack(void)
|
||||
{
|
||||
uint8_t nn;
|
||||
for (nn=0; nn<CMDSTACKDEPTH; nn++)
|
||||
SharedMem::write()->nextAsynchsendCmd0[nn]=0;
|
||||
SharedMem::write()->nrOfCmdsInQueue=0;
|
||||
}
|
||||
|
||||
bool sendWRcmd_setSendCommand0(uint16_t nextCmd)
|
||||
{
|
||||
// write Command to memory, wait for transport
|
||||
uint8_t ciq=SharedMem::read()->nrOfCmdsInQueue;
|
||||
if (ciq>=CMDSTACKDEPTH)
|
||||
{
|
||||
qDebug() << "cannot save cmd because stack is full";
|
||||
return false; // not possible
|
||||
}
|
||||
|
||||
SharedMem::write()->nextAsynchsendCmd0[ciq++]=nextCmd;
|
||||
SharedMem::write()->nrOfCmdsInQueue=ciq;
|
||||
|
||||
//qDebug() << "PI cmd queued:"<< nextCmd << ", saved, pp=" << nrOfCmdsInQueue;
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
uint16_t sendWRcmd_getSendCommand0(void)
|
||||
{
|
||||
uint16_t nxtAsynchCmd, data;
|
||||
uint8_t nn;
|
||||
uint8_t ciq=SharedMem::read()->nrOfCmdsInQueue;
|
||||
|
||||
if (ciq==0 || ciq>CMDSTACKDEPTH)
|
||||
return 0; // error
|
||||
nxtAsynchCmd=SharedMem::read()->nextAsynchsendCmd0[0];
|
||||
|
||||
// move Puffer down by one element
|
||||
if (ciq>0) ciq--;
|
||||
for (nn=0; nn<ciq; nn++)
|
||||
{
|
||||
data=SharedMem::read()->nextAsynchsendCmd0[nn+1];
|
||||
SharedMem::write()->nextAsynchsendCmd0[nn]=data;
|
||||
}
|
||||
SharedMem::write()->nrOfCmdsInQueue=ciq;
|
||||
//qDebug() << "PI cmd queued:"<< nxtAsynchCmd << ", restored, pp now =" << nrOfCmdsInQueue;
|
||||
return nxtAsynchCmd;
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------------------------------------------------
|
||||
// Command Stack for commands with 4 parameters
|
||||
|
||||
|
||||
/*
|
||||
static uint16_t nextAsynchsendCmd4[CMD4STACKDEPTH];
|
||||
static uint8_t nextCmd4para1[CMD4STACKDEPTH];
|
||||
static uint8_t nextCmd4para2[CMD4STACKDEPTH];
|
||||
static uint8_t nextCmd4para3[CMD4STACKDEPTH];
|
||||
static uint8_t nextCmd4para4[CMD4STACKDEPTH];
|
||||
static uint8_t nrOfCmds4InQueue;
|
||||
*/
|
||||
|
||||
/*
|
||||
void sendWRcmd_clrCmd4Stack(void)
|
||||
{
|
||||
uint8_t nn;
|
||||
for (nn=0; nn<CMD4STACKDEPTH; nn++)
|
||||
{
|
||||
SharedMem::write()->nextAsynchsendCmd4[nn]=0;
|
||||
SharedMem::write()->nextCmd4para1[nn]=0;
|
||||
SharedMem::write()->nextCmd4para2[nn]=0;
|
||||
SharedMem::write()->nextCmd4para3[nn]=0;
|
||||
SharedMem::write()->nextCmd4para4[nn]=0;
|
||||
}
|
||||
SharedMem::write()->nrOfCmds4InQueue=0;
|
||||
}
|
||||
|
||||
|
||||
bool sendWRcmd_setSendCommand4(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4)
|
||||
{
|
||||
// write Command to memory, wait for transport
|
||||
uint8_t ciq;
|
||||
ciq=SharedMem::read()->nrOfCmds4InQueue;
|
||||
|
||||
if (ciq>=CMD4STACKDEPTH)
|
||||
{
|
||||
qDebug() << "cannot save cmd because stack is full";
|
||||
return false; // not possible
|
||||
}
|
||||
|
||||
SharedMem::write()->nextAsynchsendCmd4[ciq]=nextCmd;
|
||||
SharedMem::write()->nextCmd4para1[ciq]=dat1;
|
||||
SharedMem::write()->nextCmd4para2[ciq]=dat2;
|
||||
SharedMem::write()->nextCmd4para3[ciq]=dat3;
|
||||
SharedMem::write()->nextCmd4para4[ciq]=dat4;
|
||||
ciq++;
|
||||
SharedMem::write()->nrOfCmds4InQueue=ciq;
|
||||
|
||||
//qDebug() << QDateTime::currentDateTime().time()
|
||||
// << "sendWRcmd 4 byte saved, pp=" << nextCmd
|
||||
// << " para: " << SharedMem::getDataConst()->nextCmd4para1[pp];
|
||||
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
*/
|
||||
/*
|
||||
uint16_t sendWRcmd_getSendCommand4(uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4)
|
||||
{
|
||||
uint16_t nxtAsynchCmd;
|
||||
uint8_t nn, ll;
|
||||
|
||||
if (nrOfCmds4InQueue==0 || nrOfCmds4InQueue>CMD4STACKDEPTH)
|
||||
return 0; // error
|
||||
nxtAsynchCmd=nextAsynchsendCmd4[0];
|
||||
*dat1=nextCmd4para1[0];
|
||||
*dat2=nextCmd4para2[0];
|
||||
*dat3=nextCmd4para3[0];
|
||||
*dat4=nextCmd4para4[0];
|
||||
//qDebug() << "cmd4 restored to send from [0]; pp=" << nrOfCmds4InQueue;
|
||||
//qDebug() << " data1: " << nextCmd4para1[0] << " data2: " << nextCmd4para2[0] <<
|
||||
// " data3: " << nextCmd4para3[0] << " data4: " << nextCmd4para4[0];
|
||||
|
||||
// move Puffer down by one element
|
||||
if (CMD4STACKDEPTH>0)
|
||||
ll=CMD4STACKDEPTH-1;
|
||||
else
|
||||
ll=0;
|
||||
for (nn=0; nn<ll; nn++)
|
||||
{
|
||||
nextAsynchsendCmd4[nn]=nextAsynchsendCmd4[nn+1];
|
||||
nextCmd4para1[nn]=nextCmd4para1[nn+1];
|
||||
nextCmd4para2[nn]=nextCmd4para2[nn+1];
|
||||
nextCmd4para3[nn]=nextCmd4para3[nn+1];
|
||||
nextCmd4para4[nn]=nextCmd4para4[nn+1];
|
||||
}
|
||||
if (nrOfCmds4InQueue>0)
|
||||
nrOfCmds4InQueue--;
|
||||
//qDebug() << "cmd4 after push down: pp=" << nrOfCmds4InQueue;
|
||||
return nxtAsynchCmd;
|
||||
}
|
||||
|
||||
|
||||
*/
|
||||
/*
|
||||
uint16_t sendWRcmd_getSendCommand4(uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4)
|
||||
{
|
||||
uint16_t nxtAsynchCmd, data;
|
||||
uint8_t nn;
|
||||
uint8_t ciq=SharedMem::read()->nrOfCmds4InQueue;
|
||||
|
||||
if (ciq==0 || ciq > CMD4STACKDEPTH)
|
||||
return 0; // error
|
||||
|
||||
nxtAsynchCmd=SharedMem::read()->nextAsynchsendCmd4[0];
|
||||
*dat1=SharedMem::read()->nextCmd4para1[0];
|
||||
*dat2=SharedMem::read()->nextCmd4para2[0];
|
||||
*dat3=SharedMem::read()->nextCmd4para3[0];
|
||||
*dat4=SharedMem::read()->nextCmd4para4[0];
|
||||
//qDebug() << "cmd4 restored to send from [0]; pp=" << nrOfCmds4InQueue;
|
||||
//qDebug() << " data1: " << nextCmd4para1[0] << " data2: " << nextCmd4para2[0] <<
|
||||
// " data3: " << nextCmd4para3[0] << " data4: " << nextCmd4para4[0];
|
||||
|
||||
// move Puffer down by one element
|
||||
if (ciq>0) ciq--;
|
||||
|
||||
for (nn=0; nn<ciq; nn++)
|
||||
{
|
||||
data=SharedMem::read()->nextAsynchsendCmd4[nn+1];
|
||||
SharedMem::write()->nextAsynchsendCmd4[nn]=data;
|
||||
data=SharedMem::read()->nextCmd4para1[nn+1];
|
||||
SharedMem::write()->nextCmd4para1[nn]=data;
|
||||
data=SharedMem::read()->nextCmd4para2[nn+1];
|
||||
SharedMem::write()->nextCmd4para2[nn]=data;
|
||||
data=SharedMem::read()->nextCmd4para3[nn+1];
|
||||
SharedMem::write()->nextCmd4para3[nn]=data;
|
||||
data=SharedMem::read()->nextCmd4para4[nn+1];
|
||||
SharedMem::write()->nextCmd4para4[nn]=data;
|
||||
}
|
||||
|
||||
SharedMem::write()->nrOfCmds4InQueue=ciq;
|
||||
return nxtAsynchCmd;
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
void sendWRcmd_clrCmd8Stack(void)
|
||||
{
|
||||
uint8_t nn;
|
||||
for (nn=0; nn<CMD8STACKDEPTH; nn++)
|
||||
{
|
||||
SharedMem::write()->nextAsynchsendCmd8[nn]=0;
|
||||
SharedMem::write()->nextCmd8para1[nn]=0;
|
||||
SharedMem::write()->nextCmd8para2[nn]=0;
|
||||
SharedMem::write()->nextCmd8para3[nn]=0;
|
||||
SharedMem::write()->nextCmd8para4[nn]=0;
|
||||
}
|
||||
SharedMem::write()->nrOfCmds8InQueue=0;
|
||||
}
|
||||
|
||||
bool sendWRcmd_setSendCommand8(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uint16_t dat3, uint32_t dat4)
|
||||
{
|
||||
// write Command to memory, wait for transport
|
||||
uint8_t ciq;
|
||||
ciq=SharedMem::read()->nrOfCmds8InQueue;
|
||||
|
||||
if (ciq>=CMD8STACKDEPTH)
|
||||
{
|
||||
qDebug() << "cannot save cmd because stack is full";
|
||||
return false; // not possible
|
||||
}
|
||||
SharedMem::write()->nextAsynchsendCmd8[ciq]=nextCmd;
|
||||
SharedMem::write()->nextCmd8para1[ciq]=dat1;
|
||||
SharedMem::write()->nextCmd8para2[ciq]=dat2;
|
||||
SharedMem::write()->nextCmd8para3[ciq]=dat3;
|
||||
SharedMem::write()->nextCmd8para4[ciq]=dat4;
|
||||
ciq++;
|
||||
SharedMem::write()->nrOfCmds8InQueue=ciq;
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
uint16_t sendWRcmd_getSendCommand8(uint8_t *dat1, uint8_t *dat2, uint16_t *dat3, uint32_t *dat4)
|
||||
{
|
||||
uint16_t nxtAsynchCmd, data;
|
||||
uint8_t nn;
|
||||
|
||||
uint8_t ciq=SharedMem::read()->nrOfCmds8InQueue;
|
||||
|
||||
if (ciq==0 || ciq > CMD8STACKDEPTH)
|
||||
return 0; // error
|
||||
|
||||
nxtAsynchCmd=SharedMem::read()->nextAsynchsendCmd8[0];
|
||||
*dat1=SharedMem::read()->nextCmd8para1[0];
|
||||
*dat2=SharedMem::read()->nextCmd8para2[0];
|
||||
*dat3=SharedMem::read()->nextCmd8para3[0];
|
||||
*dat4=SharedMem::read()->nextCmd8para4[0];
|
||||
|
||||
// move buffer down by one element
|
||||
if (ciq>0) ciq--;
|
||||
|
||||
for (nn=0; nn<ciq; nn++)
|
||||
{
|
||||
data=SharedMem::read()->nextAsynchsendCmd8[nn+1];
|
||||
SharedMem::write()->nextAsynchsendCmd8[nn]=data;
|
||||
data=SharedMem::read()->nextCmd8para1[nn+1];
|
||||
SharedMem::write()->nextCmd8para1[nn]=data;
|
||||
data=SharedMem::read()->nextCmd8para2[nn+1];
|
||||
SharedMem::write()->nextCmd8para2[nn]=data;
|
||||
data=SharedMem::read()->nextCmd8para3[nn+1];
|
||||
SharedMem::write()->nextCmd8para3[nn]=data;
|
||||
data=SharedMem::read()->nextCmd8para4[nn+1];
|
||||
SharedMem::write()->nextCmd8para4[nn]=data;
|
||||
}
|
||||
SharedMem::write()->nrOfCmds8InQueue=ciq;
|
||||
return nxtAsynchCmd;
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
//static uint8_t sendAsynchDataBuf[160]; // no stack, only ONE buffer
|
||||
//static uint8_t sendAsyDatLen;
|
||||
|
||||
bool sendWRcmd_setSendBlock160(uint8_t leng, uint8_t *buf)
|
||||
{
|
||||
if (leng>SENDASYDAT_BUFFSIZE) leng=SENDASYDAT_BUFFSIZE;
|
||||
SharedMem::write()->sendAsyDatLen=leng;
|
||||
tslib_strclr(SharedMem::write()->sendAsynchDataBuf, 0, SENDASYDAT_BUFFSIZE);
|
||||
for (uint8_t nn=0; nn<leng; nn++)
|
||||
SharedMem::write()->sendAsynchDataBuf[nn]=buf[nn];
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
uint8_t sendWRcmd_getSendBlock160(uint8_t *leng, uint8_t *buf)
|
||||
{
|
||||
|
||||
uint8_t dl=SharedMem::read()->sendAsyDatLen;
|
||||
*leng=dl;
|
||||
for (uint8_t nn=0; nn<dl; nn++)
|
||||
buf[nn]=SharedMem::read()->sendAsynchDataBuf[nn];
|
||||
SharedMem::write()->sendAsyDatLen=0;
|
||||
//tslib_strclr(SharedMem::write()->sendAsynchDataBuf, 0, SENDASYDAT_BUFFSIZE);
|
||||
return *leng;
|
||||
}
|
||||
|
||||
|
||||
// ------------------------------------------------------------------------------------
|
||||
// MDB Sendind Data are store here for next transport to DC (Device Controller)
|
||||
// Transport to Slave runs every 100ms, answer from mdb-slave (e.g. coin changer) comes rigth
|
||||
// with next slave answer
|
||||
|
||||
// start with: SENDDIRCMD_EXCHGMDB,
|
||||
// send crude data from here to DC, DC to mdb slaves, mdb answer, return here within 50ms
|
||||
|
||||
|
||||
//static uint8_t Sdata_mdbSendBuffer[MDBSEND_BUFFSIZE];
|
||||
//static uint8_t Sdata_mdbSendLen;
|
||||
/*
|
||||
uint8_t epi_store64ByteSendData(uint8_t length, uint8_t *buf)
|
||||
{
|
||||
if (length>MDBSEND_BUFFSIZE) length=MDBSEND_BUFFSIZE;
|
||||
|
||||
// HWapi writes data to be forwarded to DC and further to mdb-device
|
||||
for (uint8_t nn=0; nn<length; nn++)
|
||||
SharedMem::write()->Sdata_mdbSendBuffer[nn]=buf[nn];
|
||||
SharedMem::write()->Sdata_mdbSendLen=length;
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint8_t gpi_restore64ByteSendData(uint8_t *length, uint8_t *buf)
|
||||
{
|
||||
// datif reads data to forward to dc
|
||||
uint8_t dl=SharedMem::read()->Sdata_mdbSendLen;
|
||||
|
||||
for (uint8_t nn=0; nn<dl; nn++)
|
||||
buf[nn]=SharedMem::read()->Sdata_mdbSendBuffer[nn];
|
||||
*length=dl;
|
||||
SharedMem::write()->Sdata_mdbSendLen=0;
|
||||
return 0;
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
//------------------------------------------------------------------------------------
|
||||
//---------------------------------------- Printer Text Fifo -------------------------
|
||||
//static uint8_t prnDataParameters[];
|
||||
//static uint8_t prnDataBufferUser;
|
||||
|
||||
/*
|
||||
void epi_storeUserOfSendingTextBuffer(uint8_t user, uint8_t para1, uint8_t para2, uint8_t para3, uint8_t para4 )
|
||||
{
|
||||
// user=1: Text-Print is using this buffer
|
||||
// 2: QR-code-Printer is using this buffer
|
||||
SharedMem::write()->prnDataBufferUser=user;
|
||||
SharedMem::write()->prnDataParameters[0]=para1;
|
||||
SharedMem::write()->prnDataParameters[1]=para2;
|
||||
SharedMem::write()->prnDataParameters[2]=para3;
|
||||
SharedMem::write()->prnDataParameters[3]=para4;
|
||||
|
||||
// qDebug() << "new user stored: " << user;
|
||||
|
||||
}
|
||||
|
||||
uint8_t gpi_getUserOfSendingTextBuffer(uint8_t *para1, uint8_t *para2, uint8_t *para3, uint8_t *para4)
|
||||
{
|
||||
// user=1: Text-Print is using this buffer
|
||||
// 2: QR-code-Printer is using this buffer
|
||||
//qDebug() << "returning user "<< prnDataBufferUser;
|
||||
|
||||
*para1=SharedMem::read()->prnDataParameters[0];
|
||||
*para2=SharedMem::read()->prnDataParameters[1];
|
||||
*para3=SharedMem::read()->prnDataParameters[2];
|
||||
*para4=SharedMem::read()->prnDataParameters[3];
|
||||
return SharedMem::read()->prnDataBufferUser;
|
||||
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// Sending Text Fifo
|
||||
// ONE printer doc consists of 20 x 64 byte
|
||||
// #define MAXNROF_PRNBYTES 64
|
||||
// #define MAXNROF_PRNBLOCKS 20
|
||||
//static char Sdata_PRN_TEXT[MAXNROF_PRNBLOCKS][MAXNROF_PRNBYTES];
|
||||
//static uint8_t pPrnDataBuff; // points to next PRINTER_BLOCK
|
||||
//static uint8_t pPrnDataBuff; // points to next waiting printer text
|
||||
// defined above, needed if more then one text is stored (before sent)
|
||||
// every block will be sent after 100ms, if 8 blocks are stored within this 100ms
|
||||
// then pointer goes up to 8. Important: FIFO!!!!!!!!
|
||||
/*
|
||||
void epi_resetPrinterStack(void)
|
||||
{
|
||||
SharedMem::write()->pPrnDataBuff=0;
|
||||
}
|
||||
|
||||
uint8_t epi_storePrnText(char *buf, uint8_t leng)
|
||||
{
|
||||
// store text from Gui in next higher free memory 0....9
|
||||
|
||||
uint16_t len;
|
||||
uint8_t pp, nn;
|
||||
|
||||
pp=SharedMem::read()->pPrnDataBuff; // next free memory block with 64byte each
|
||||
if (pp>=MAXNROF_PRNBLOCKS)
|
||||
return 1; // not possible, no free mem
|
||||
|
||||
//len=tslib_strlen(buf); // kennt keine Binärzeichen!!!!!!
|
||||
len=leng;
|
||||
if (len>MAXNROF_PRNBYTES)
|
||||
len=MAXNROF_PRNBYTES;
|
||||
|
||||
tslib_strclr(SharedMem::write()->Sdata_PRN_TEXT[pp], 0, MAXNROF_PRNBYTES);
|
||||
|
||||
for (nn=0; nn<len; nn++)
|
||||
SharedMem::write()->Sdata_PRN_TEXT[pp][nn]=buf[nn]; // copy new text into buffer
|
||||
|
||||
if (SharedMem::read()->pPrnDataBuff<MAXNROF_PRNBLOCKS)
|
||||
SharedMem::write()->pPrnDataBuff++; // inc pointer if end not yet reached
|
||||
return 0; // OK
|
||||
}
|
||||
|
||||
|
||||
|
||||
uint8_t gpi_restorePrnText(uint8_t *retbuf)
|
||||
{
|
||||
// read printer text and send to slave, size of retbuf == 64
|
||||
|
||||
// always read from [0] because this is the oldest (Fifo)
|
||||
// then move all text lines down by one and dec pointer
|
||||
|
||||
uint8_t nn, mm, pp=SharedMem::read()->pPrnDataBuff;
|
||||
char buf[MAXNROF_PRNBYTES];
|
||||
|
||||
if (pp==0) // next free memory block with 64byte each
|
||||
return 1; // no text in buffer
|
||||
|
||||
// example: pp=5: then buffers [0...4] are occupied
|
||||
|
||||
for (nn=0; nn<MAXNROF_PRNBYTES; nn++)
|
||||
retbuf[nn] = uint8_t (SharedMem::read()->Sdata_PRN_TEXT[0][nn]); // restore oldest text
|
||||
|
||||
// now copy textline [1] to [0], then
|
||||
// copy textline [2] to [1], then
|
||||
// copy textline [3] to [2] .... upto [pp-1] to [pp-2]
|
||||
// hint: copying from 9....0 would delete all strings!!!!!!
|
||||
for (nn=0; nn<(pp-1); nn++)
|
||||
{
|
||||
for (mm=0; mm<MAXNROF_PRNBYTES; mm++)
|
||||
buf[mm]=SharedMem::read()->Sdata_PRN_TEXT[nn+1][mm];
|
||||
for (mm=0; mm<MAXNROF_PRNBYTES; mm++)
|
||||
SharedMem::write()->Sdata_PRN_TEXT[nn][mm]=buf[mm];
|
||||
}
|
||||
if (pp>0) pp--;
|
||||
SharedMem::write()->pPrnDataBuff=pp;
|
||||
|
||||
// example: pp=4: then buffers [0...3] are still occupied, pp=0: all buffers empty
|
||||
|
||||
// now clear highest copyed line (which became free now)
|
||||
tslib_strclr(SharedMem::write()->Sdata_PRN_TEXT[pp], 0, MAXNROF_PRNBYTES);
|
||||
|
||||
// optionally: clear all remaining higher lines:
|
||||
for (nn=(pp+1); nn<MAXNROF_PRNBLOCKS; nn++)
|
||||
tslib_strclr(SharedMem::write()->Sdata_PRN_TEXT[nn], 0, MAXNROF_PRNBYTES);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint8_t gpi_chk4remainingText(void)
|
||||
{
|
||||
// retval: 0: no more textline left (to send) >0: nr of 64byte-blocks
|
||||
return (SharedMem::read()->pPrnDataBuff);
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------------------
|
||||
// 11.4.23 neu, Kommando direkt an "FastDevice"-protokoll senden, nicht mehr umsetzen
|
||||
// ---------------------------------------------------------------------------------
|
||||
/*
|
||||
// header
|
||||
static uint8_t nextFDwrCmd[FDCMD_STACKDEPTH];
|
||||
static uint8_t nextFDrdCmd[FDCMD_STACKDEPTH];
|
||||
static uint8_t nextFDblkNr[FDCMD_STACKDEPTH];
|
||||
static uint8_t nextFDshort[FDCMD_STACKDEPTH];
|
||||
|
||||
// short data
|
||||
static uint8_t nextFDpara1[FDCMD_STACKDEPTH];
|
||||
static uint8_t nextFDpara2[FDCMD_STACKDEPTH];
|
||||
static uint8_t nextFDpara3[FDCMD_STACKDEPTH];
|
||||
static uint8_t nextFDpara4[FDCMD_STACKDEPTH];
|
||||
// long data:
|
||||
static uint8_t longFDlength[FDCMD_STACKDEPTH];
|
||||
static uint8_t longFDpara[FDCMD_STACKDEPTH][64];
|
||||
|
||||
static uint8_t p_nextFDcmdsInQueue;
|
||||
*/
|
||||
|
||||
/* convention: use simple (not rotating) FIFO Stack:
|
||||
Example: nrOfCmdsInQueue=4 then
|
||||
nextAsynchsendCmd0[0]=cmd1 // was stored as first
|
||||
nextAsynchsendCmd0[1]=cmd2
|
||||
nextAsynchsendCmd0[2]=cmd3
|
||||
nextAsynchsendCmd0[3]=cmd4 // came in as last
|
||||
|
||||
Send: [0] first, then move buffer 1 down:
|
||||
nextAsynchsendCmd0[0]=cmd2
|
||||
nextAsynchsendCmd0[1]=cmd3
|
||||
nextAsynchsendCmd0[2]=cmd4
|
||||
nextAsynchsendCmd0[3]=0;
|
||||
nrOfCmdsInQueue=3 now
|
||||
*/
|
||||
|
||||
|
||||
void sendFDcmd_clrStack(void)
|
||||
{
|
||||
uint8_t nn;
|
||||
for (nn=0; nn<FDCMD_STACKDEPTH; nn++)
|
||||
{
|
||||
SharedMem::write()->nextFDwrCmd[nn]=0;
|
||||
SharedMem::write()->nextFDrdCmd[nn]=0;
|
||||
SharedMem::write()->nextFDblkNr[nn]=0;
|
||||
SharedMem::write()->nextFDshort[nn]=0;
|
||||
SharedMem::write()->nextFDpara1[nn]=0;
|
||||
SharedMem::write()->nextFDpara2[nn]=0;
|
||||
SharedMem::write()->nextFDpara3[nn]=0;
|
||||
SharedMem::write()->nextFDpara4[nn]=0;
|
||||
SharedMem::write()->longFDlength[nn]=0;
|
||||
memset(&SharedMem::write()->longFDpara[nn][0],0,64);
|
||||
}
|
||||
|
||||
SharedMem::write()->p_nextFDcmdsInQueue=0;
|
||||
}
|
||||
|
||||
bool sendFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4)
|
||||
{
|
||||
|
||||
// write Command to memory, wait for transport
|
||||
uint8_t pFDcmd=SharedMem::read()->p_nextFDcmdsInQueue;
|
||||
|
||||
if (pFDcmd >=FDCMD_STACKDEPTH)
|
||||
{
|
||||
qDebug() << "cannot save cmd because stack is full";
|
||||
return false; // not possible
|
||||
}
|
||||
SharedMem::write()->nextFDwrCmd[pFDcmd]=nextWrCmd;
|
||||
SharedMem::write()->nextFDrdCmd[pFDcmd]=nextRdCmd;
|
||||
SharedMem::write()->nextFDblkNr[pFDcmd]=blockNum;
|
||||
SharedMem::write()->nextFDpara1[pFDcmd]=dat1;
|
||||
SharedMem::write()->nextFDpara2[pFDcmd]=dat2;
|
||||
SharedMem::write()->nextFDpara3[pFDcmd]=dat3;
|
||||
SharedMem::write()->nextFDpara4[pFDcmd]=dat4;
|
||||
//qDebug() << "data with 4 data byte saved, pp=" << pFDcmd;
|
||||
//qDebug() << " dat1=" << nextCmd4para1[pFDcmd] << " dat2=" << nextCmd4para2[pFDcmd]
|
||||
// << " dat3=" << nextCmd4para3[pFDcmd] << " dat4=" << nextCmd4para4[pFDcmd];
|
||||
SharedMem::write()->nextFDshort[pFDcmd]=1; // 1=short
|
||||
pFDcmd++;
|
||||
SharedMem::write()->p_nextFDcmdsInQueue=pFDcmd;
|
||||
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
|
||||
bool longFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t length, uint8_t *data)
|
||||
{
|
||||
// write Command to memory, wait for transport
|
||||
// data buffer size always 64! data[64], padded with 0
|
||||
uint8_t nn;
|
||||
uint8_t pFDcmd=SharedMem::read()->p_nextFDcmdsInQueue;
|
||||
|
||||
if (pFDcmd>=FDCMD_STACKDEPTH)
|
||||
{
|
||||
qDebug() << "cannot save cmd because stack is full";
|
||||
return false; // not possible
|
||||
}
|
||||
SharedMem::write()->nextFDwrCmd[pFDcmd]=nextWrCmd;
|
||||
SharedMem::write()->nextFDrdCmd[pFDcmd]=nextRdCmd;
|
||||
SharedMem::write()->nextFDblkNr[pFDcmd]=blockNum;
|
||||
|
||||
SharedMem::write()->longFDlength[pFDcmd]=length;
|
||||
|
||||
for (nn=0; nn<64; nn++)
|
||||
SharedMem::write()->longFDpara[pFDcmd][nn]=data[nn];
|
||||
|
||||
SharedMem::write()->nextFDshort[pFDcmd]=2;
|
||||
pFDcmd++;
|
||||
SharedMem::write()->p_nextFDcmdsInQueue=pFDcmd;
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
|
||||
bool longFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t length, QByteArray *data)
|
||||
{
|
||||
// write Command to memory, wait for transport
|
||||
// data buffer size always 64! data[64], padded with 0
|
||||
uint8_t nn;
|
||||
uint8_t pFDcmd=SharedMem::read()->p_nextFDcmdsInQueue;
|
||||
char ctmp;
|
||||
|
||||
if (pFDcmd>=FDCMD_STACKDEPTH)
|
||||
{
|
||||
qDebug() << "cannot save cmd because stack is full";
|
||||
return false; // not possible
|
||||
}
|
||||
SharedMem::write()->nextFDwrCmd[pFDcmd]=nextWrCmd;
|
||||
SharedMem::write()->nextFDrdCmd[pFDcmd]=nextRdCmd;
|
||||
SharedMem::write()->nextFDblkNr[pFDcmd]=blockNum;
|
||||
|
||||
SharedMem::write()->longFDlength[pFDcmd]=length;
|
||||
|
||||
for (nn=0; nn<64; nn++)
|
||||
{
|
||||
ctmp=data->at(nn);
|
||||
SharedMem::write()->longFDpara[pFDcmd][nn]=ctmp;
|
||||
}
|
||||
|
||||
SharedMem::write()->nextFDshort[pFDcmd]=2;
|
||||
pFDcmd++;
|
||||
SharedMem::write()->p_nextFDcmdsInQueue=pFDcmd;
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
|
||||
bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4)
|
||||
{
|
||||
uint8_t nn, mm, data; // ll
|
||||
uint8_t pFDcmd=SharedMem::read()->p_nextFDcmdsInQueue;
|
||||
|
||||
if (pFDcmd==0 || pFDcmd>FDCMD_STACKDEPTH)
|
||||
return false; // not possible
|
||||
|
||||
*nextWrCmd=SharedMem::read()->nextFDwrCmd[0];
|
||||
*nextRdCmd=SharedMem::read()->nextFDrdCmd[0];
|
||||
*blockNum=SharedMem::read()->nextFDblkNr[0];
|
||||
*dat1=SharedMem::read()->nextFDpara1[0];
|
||||
*dat2=SharedMem::read()->nextFDpara2[0];
|
||||
*dat3=SharedMem::read()->nextFDpara3[0];
|
||||
*dat4=SharedMem::read()->nextFDpara4[0];
|
||||
//qDebug() << "sendFDcmd_get [0]; pp=" << SharedMem::read()->p_nextFDcmdsInQueue;
|
||||
//qDebug() << " data1: " << SharedMem::read()->nextCmd4para1[0] << " data2: " << SharedMem::read()->nextCmd4para2[0] <<
|
||||
// " data3: " << SharedMem::read()->nextCmd4para3[0] << " data4: " << SharedMem::read()->nextCmd4para4[0];
|
||||
|
||||
// move Puffer down by one element
|
||||
//if (FDCMD_STACKDEPTH>0)
|
||||
// ll=FDCMD_STACKDEPTH-1;
|
||||
//else
|
||||
// ll=0;
|
||||
|
||||
if (pFDcmd>0) pFDcmd--; else pFDcmd=0;
|
||||
|
||||
//for (nn=0; nn<ll; nn++)
|
||||
for (nn=0; nn<pFDcmd; nn++)
|
||||
{
|
||||
data=SharedMem::read()->nextFDwrCmd[nn+1];
|
||||
SharedMem::write()->nextFDwrCmd[nn]=data;
|
||||
data=SharedMem::read()->nextFDrdCmd[nn+1];
|
||||
SharedMem::write()->nextFDrdCmd[nn]=data;
|
||||
data=SharedMem::read()->nextFDblkNr[nn+1];
|
||||
SharedMem::write()->nextFDblkNr[nn]=data;
|
||||
data=SharedMem::read()->nextFDpara1[nn+1];
|
||||
SharedMem::write()->nextFDpara1[nn]=data;
|
||||
data=SharedMem::read()->nextFDpara2[nn+1];
|
||||
SharedMem::write()->nextFDpara2[nn]=data;
|
||||
data=SharedMem::read()->nextFDpara3[nn+1];
|
||||
SharedMem::write()->nextFDpara3[nn]=data;
|
||||
data=SharedMem::read()->nextFDpara4[nn+1];
|
||||
SharedMem::write()->nextFDpara4[nn]=data;
|
||||
|
||||
data=SharedMem::read()->nextFDshort[nn+1];
|
||||
SharedMem::write()->nextFDshort[nn] = data;
|
||||
|
||||
data=SharedMem::read()->longFDlength[nn+1];
|
||||
SharedMem::write()->longFDlength[nn] = data;
|
||||
|
||||
for (mm=0; mm<64; mm++)
|
||||
{
|
||||
SharedMem::write()->longFDpara[nn][mm] = SharedMem::read()->longFDpara[nn+1][mm];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
SharedMem::write()->p_nextFDcmdsInQueue=pFDcmd;
|
||||
//qDebug() << "cmd4 after push down: pp=" << nrOfCmds4InQueue;
|
||||
|
||||
// clear released buffer:
|
||||
//for (nn=p_nextFDcmdsInQueue; nn<FDCMD_STACKDEPTH; nn++)
|
||||
//{
|
||||
SharedMem::write()->nextFDwrCmd[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDrdCmd[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDblkNr[pFDcmd]=0;
|
||||
|
||||
SharedMem::write()->nextFDpara1[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDpara2[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDpara3[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDpara4[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDshort[pFDcmd]=0;
|
||||
SharedMem::write()->longFDlength[pFDcmd]=0;
|
||||
for (mm=0; mm<64; mm++)
|
||||
SharedMem::write()->longFDpara[pFDcmd][mm] = 0;
|
||||
//}
|
||||
|
||||
/*
|
||||
qDebug() << "sendFDcmd_set, stack now: " << p_nextFDcmdsInQueue;
|
||||
for (nn=0; nn<16; nn++)
|
||||
{
|
||||
qDebug() << "header: " << nextFDwrCmd[nn] << " / " << nextFDrdCmd[nn] << " / "<< nextFDblkNr[nn] << " / " << nextFDshort[nn];
|
||||
|
||||
qDebug() << " short data: " << nextFDpara1[nn] << " / "<< nextFDpara2[nn] << " / "<< nextFDpara3[nn]<< " / "<< nextFDpara4[nn];
|
||||
|
||||
qDebug() << " long data: " << longFDlength[nn] << " / "<< longFDpara[nn][0] << " / "<< longFDpara[nn][1]
|
||||
<< " / "<< longFDpara[nn][2] << " / "<< longFDpara[nn][3] << " / "<< longFDpara[nn][4];
|
||||
}
|
||||
*/
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
uint8_t checkNextFDcmd(void)
|
||||
{
|
||||
// return 0: no command waiting
|
||||
// 1: short cmd
|
||||
// 2: long cmd
|
||||
//qDebug() << "chk nxt fd cmd: "<<p_nextFDcmdsInQueue<<" "<<nextFDshort[0]<<" "<<nextFDshort[1]<<" "<<nextFDshort[2]<<" "<<nextFDshort[3];
|
||||
if (SharedMem::read()->p_nextFDcmdsInQueue==0)
|
||||
return 0;
|
||||
if (SharedMem::read()->nextFDshort[0]==1)
|
||||
return 1;
|
||||
return 2;
|
||||
}
|
||||
|
||||
uint8_t check4usedFDstack(void)
|
||||
{
|
||||
// returns number of waiting command, max FDCMD_STACKDEPTH
|
||||
return SharedMem::read()->p_nextFDcmdsInQueue;
|
||||
}
|
||||
|
||||
|
||||
uint8_t check4freeFDstack(void)
|
||||
{
|
||||
// returns number of free places in command stack
|
||||
return FDCMD_STACKDEPTH - SharedMem::read()->p_nextFDcmdsInQueue;
|
||||
}
|
||||
|
||||
bool longFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *length, uint8_t *data)
|
||||
{
|
||||
uint8_t nn, mm, uctmp;
|
||||
uint8_t pFDcmd=SharedMem::read()->p_nextFDcmdsInQueue;
|
||||
|
||||
if (pFDcmd==0 || pFDcmd>FDCMD_STACKDEPTH)
|
||||
return false; // not possible
|
||||
|
||||
*nextWrCmd=SharedMem::read()->nextFDwrCmd[0];
|
||||
*nextRdCmd=SharedMem::read()->nextFDrdCmd[0];
|
||||
*blockNum=SharedMem::read()->nextFDblkNr[0];
|
||||
*length = SharedMem::read()->longFDlength[0];
|
||||
for (mm=0; mm<64; mm++)
|
||||
data[mm] = SharedMem::read()->longFDpara[0][mm];
|
||||
|
||||
if (pFDcmd>0) pFDcmd--; else pFDcmd=0;
|
||||
|
||||
//for (nn=0; nn<ll; nn++)
|
||||
for (nn=0; nn<pFDcmd; nn++)
|
||||
{
|
||||
uctmp=SharedMem::read()->nextFDwrCmd[nn+1];
|
||||
SharedMem::write()->nextFDwrCmd[nn]=uctmp;
|
||||
uctmp=SharedMem::read()->nextFDrdCmd[nn+1];
|
||||
SharedMem::write()->nextFDrdCmd[nn]=uctmp;
|
||||
uctmp=SharedMem::read()->nextFDblkNr[nn+1];
|
||||
SharedMem::write()->nextFDblkNr[nn]=uctmp;
|
||||
|
||||
uctmp=SharedMem::read()->nextFDpara1[nn+1];
|
||||
SharedMem::write()->nextFDpara1[nn]=uctmp;
|
||||
uctmp=SharedMem::read()->nextFDpara2[nn+1];
|
||||
SharedMem::write()->nextFDpara2[nn]=uctmp;
|
||||
uctmp=SharedMem::read()->nextFDpara3[nn+1];
|
||||
SharedMem::write()->nextFDpara3[nn]=uctmp;
|
||||
uctmp=SharedMem::read()->nextFDpara4[nn+1];
|
||||
SharedMem::write()->nextFDpara4[nn]=uctmp;
|
||||
|
||||
uctmp=SharedMem::read()->nextFDshort[nn+1];
|
||||
SharedMem::write()->nextFDshort[nn]=uctmp;
|
||||
uctmp=SharedMem::read()->longFDlength[nn+1];
|
||||
SharedMem::write()->longFDlength[nn]=uctmp;
|
||||
|
||||
for (mm=0; mm<64; mm++)
|
||||
{
|
||||
SharedMem::write()->longFDpara[nn][mm] = SharedMem::read()->longFDpara[nn+1][mm];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
SharedMem::write()->p_nextFDcmdsInQueue=pFDcmd;
|
||||
// clear released buffer:
|
||||
SharedMem::write()->nextFDwrCmd[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDrdCmd[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDblkNr[pFDcmd]=0;
|
||||
|
||||
SharedMem::write()->nextFDpara1[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDpara2[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDpara3[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDpara4[pFDcmd]=0;
|
||||
SharedMem::write()->nextFDshort[pFDcmd]=0;
|
||||
SharedMem::write()->longFDlength[pFDcmd]=0;
|
||||
for (mm=0; mm<64; mm++)
|
||||
SharedMem::write()->longFDpara[pFDcmd][mm] = 0;
|
||||
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
|
||||
|
||||
101
src/shared_mem_buffer.cpp
Normal file
101
src/shared_mem_buffer.cpp
Normal file
@@ -0,0 +1,101 @@
|
||||
#include "shared_mem_buffer.h"
|
||||
|
||||
#include <QDebug>
|
||||
#include <atomic>
|
||||
|
||||
#ifdef QT_POSIX_IPC
|
||||
// The POSIX backend can be explicitly selected using the -feature-ipc_posix
|
||||
// option to the Qt configure script. If it is enabled, the QT_POSIX_IPC
|
||||
// macro will be defined. -> we use SystemV shared memory
|
||||
#error "QT_POSIX_IPC defined"
|
||||
#else
|
||||
#ifdef __linux__
|
||||
#include <sys/ipc.h> // ftok
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//static bool shdMemFirstUse;
|
||||
|
||||
|
||||
//QSharedMemory *SharedMemBuffer::getShm(std::size_t size) {
|
||||
QSharedMemory *SharedMem::getShm(std::size_t size) {
|
||||
static QSharedMemory shMem;
|
||||
if (size > 0) {
|
||||
#ifdef __linux__
|
||||
//static const long nativeKey = ftok("/etc/os-release", 'H');
|
||||
//static const QString fkey = std::to_string(nativeKey).c_str();
|
||||
static const QString fkey = "0123456?000=7";
|
||||
#else
|
||||
static const QString fkey = "0123456?000=9";
|
||||
#endif
|
||||
|
||||
shMem.setKey(fkey);
|
||||
if (!shMem.isAttached()) {
|
||||
if (shMem.create(size)) {
|
||||
return &shMem;
|
||||
} else {
|
||||
if (shMem.error() == QSharedMemory::AlreadyExists) {
|
||||
if (shMem.attach()) {
|
||||
return &shMem;
|
||||
}
|
||||
}
|
||||
}
|
||||
qCritical() << shMem.nativeKey() << shMem.key() << shMem.data()
|
||||
<< shMem.error() << shMem.errorString();
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
return &shMem;
|
||||
}
|
||||
|
||||
|
||||
// std::atomic_bool SharedMemBuffer::__sharedMemLocked{false};
|
||||
/*
|
||||
//QSharedMemory *SharedMemBuffer::getShm(std::size_t size) {
|
||||
QSharedMemory *SharedMem::getShm(std::size_t size) {
|
||||
|
||||
static QSharedMemory shMem;
|
||||
if (size > 0) {
|
||||
#ifdef __linux__
|
||||
static const long nativeKey = ftok("/etc/os-release", 'H');
|
||||
static const QString fkey = std::to_string(nativeKey).c_str();
|
||||
#else
|
||||
static const QString fkey = "0123456?000=9";
|
||||
#endif
|
||||
shdMemFirstUse=false;
|
||||
shMem.setKey(fkey);
|
||||
if (!shMem.isAttached())
|
||||
{
|
||||
if (shMem.create(size))
|
||||
{
|
||||
// sm was created successful, did not exist before
|
||||
shdMemFirstUse=true;
|
||||
return &shMem;
|
||||
} else
|
||||
{
|
||||
// create was false because mem already existed
|
||||
if (shMem.error() == QSharedMemory::AlreadyExists)
|
||||
{
|
||||
if (shMem.attach())
|
||||
{
|
||||
return &shMem;
|
||||
}
|
||||
}
|
||||
}
|
||||
qCritical() << shMem.nativeKey() << shMem.key() << shMem.data()
|
||||
<< shMem.error() << shMem.errorString();
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
return &shMem;
|
||||
}
|
||||
|
||||
|
||||
bool shdMem_firstUse(void)
|
||||
{
|
||||
return shdMemFirstUse;
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
|
||||
2053
src/storeINdata sm.cpp
Executable file
2053
src/storeINdata sm.cpp
Executable file
File diff suppressed because it is too large
Load Diff
2344
src/storeINdata.cpp
Normal file
2344
src/storeINdata.cpp
Normal file
File diff suppressed because it is too large
Load Diff
612
src/tslib.cpp
Normal file
612
src/tslib.cpp
Normal file
@@ -0,0 +1,612 @@
|
||||
#include "tslib.h"
|
||||
#include <QThread>
|
||||
|
||||
//tslib::tslib()
|
||||
//{
|
||||
|
||||
|
||||
//}
|
||||
|
||||
|
||||
/*
|
||||
uint16_t tslib::uchar2uint(uint8_t Highbyte, uint8_t Lowbyte)
|
||||
{
|
||||
uint16_t uitmp;
|
||||
uitmp=0;
|
||||
uitmp |= uint8_t(Highbyte);
|
||||
uitmp<<=8;
|
||||
uitmp |= uint8_t(Lowbyte);
|
||||
return uitmp;
|
||||
}
|
||||
|
||||
uint8_t tslib::uint2uchar(uint16_t uival, bool getHighB)
|
||||
{
|
||||
// getHighB: low=GetLowByte
|
||||
uint16_t uitmp=uival;
|
||||
if (getHighB==0)
|
||||
return uint8_t(uitmp);
|
||||
uitmp>>=8;
|
||||
return uint8_t(uitmp);
|
||||
|
||||
}*/
|
||||
|
||||
uint16_t uchar2uint(char Highbyte, char Lowbyte)
|
||||
{
|
||||
uint16_t uitmp;
|
||||
uitmp=0;
|
||||
uitmp |= uint8_t(Highbyte);
|
||||
uitmp<<=8;
|
||||
uitmp |= uint8_t(Lowbyte);
|
||||
return uitmp;
|
||||
}
|
||||
|
||||
uint16_t uchar2uint(uint8_t Highbyte, uint8_t Lowbyte)
|
||||
{
|
||||
uint16_t uitmp;
|
||||
uitmp=0;
|
||||
uitmp |= uint8_t(Highbyte);
|
||||
uitmp<<=8;
|
||||
uitmp |= uint8_t(Lowbyte);
|
||||
return uitmp;
|
||||
}
|
||||
|
||||
uint32_t uchar2ulong(uint8_t Highbyte, uint8_t MHbyte, uint8_t MLbyte, uint8_t Lowbyte)
|
||||
{
|
||||
uint32_t ultmp=0;
|
||||
|
||||
ultmp |= uint8_t(Highbyte);
|
||||
ultmp<<=8;
|
||||
ultmp |= uint8_t(MHbyte);
|
||||
ultmp<<=8;
|
||||
ultmp |= uint8_t(MLbyte);
|
||||
ultmp<<=8;
|
||||
ultmp |= uint8_t(Lowbyte);
|
||||
return ultmp;
|
||||
}
|
||||
|
||||
uint8_t uint2uchar(uint16_t uival, bool getHighB)
|
||||
{
|
||||
// getHighB: low=GetLowByte
|
||||
uint16_t uitmp=uival;
|
||||
if (getHighB==0)
|
||||
return uint8_t(uitmp);
|
||||
uitmp>>=8;
|
||||
return uint8_t(uitmp);
|
||||
|
||||
}
|
||||
|
||||
|
||||
uint8_t ulong2uchar(uint32_t ulval, uint8_t getBytNr)
|
||||
{
|
||||
// getBytNr: 0=LSB 3=MSB
|
||||
uint32_t ultmp=ulval;
|
||||
if (getBytNr==0)
|
||||
return uint8_t(ultmp);
|
||||
ultmp>>=8;
|
||||
if (getBytNr==1)
|
||||
return uint8_t(ultmp);
|
||||
ultmp>>=8;
|
||||
if (getBytNr==2)
|
||||
return uint8_t(ultmp);
|
||||
ultmp>>=8;
|
||||
return uint8_t(ultmp);
|
||||
|
||||
}
|
||||
|
||||
void delay(uint16_t MilliSec)
|
||||
{
|
||||
QThread::msleep(uint32_t(MilliSec));
|
||||
}
|
||||
|
||||
|
||||
void GetTimeString(uint8_t hours, uint8_t minutes, uint8_t seconds, uint8_t System12h, uint8_t ShowSec, uint8_t *buf)
|
||||
{
|
||||
// Zahlenwerte in String wandeln, 12/24h-Format // 12byte für buf!
|
||||
uint8_t usa;
|
||||
uint16_t jj;
|
||||
uint8_t hh, mm, ss, with_sec;
|
||||
|
||||
// buf[0]= ganz linkes Zeichen
|
||||
hh=hours;
|
||||
mm=minutes;
|
||||
ss=seconds;
|
||||
|
||||
// 15.10.12, Plausibilitätsprüfung --------------------------------------------------
|
||||
if (hh>23) hh=0;
|
||||
if (mm>59) mm=0;
|
||||
if (ss>59) ss=0;
|
||||
|
||||
with_sec=ShowSec;
|
||||
for (jj=0; jj<12; jj++) buf[jj]=0;
|
||||
usa = System12h; // 1:12h 0:24h
|
||||
|
||||
// Stunden:
|
||||
if (usa)
|
||||
{
|
||||
// 12h System
|
||||
if (hh==0 || hh==12)
|
||||
{
|
||||
// 12AM (Mitternacht) oder 12PM (Mittag)
|
||||
buf[0]=0x31;
|
||||
buf[1]=0x32;
|
||||
} else
|
||||
if (hh<12)
|
||||
{
|
||||
// 1..11AM
|
||||
buf[0]=hh/10+0x30;
|
||||
buf[1]=hh%10+0x30;
|
||||
} else
|
||||
{
|
||||
//13:00 bis 23Uhr
|
||||
buf[0]=(hh-12)/10+0x30;
|
||||
buf[1]=(hh-12)%10+0x30;
|
||||
}
|
||||
} else
|
||||
{
|
||||
// 24h System
|
||||
buf[0]=hh/10+0x30;
|
||||
buf[1]=hh%10+0x30;
|
||||
}
|
||||
|
||||
// Minuten:
|
||||
buf[2]=':';
|
||||
buf[3]=mm/10+0x30;
|
||||
buf[4]=mm%10+0x30;
|
||||
|
||||
jj=5;
|
||||
if (with_sec)
|
||||
{
|
||||
buf[jj++]=':';
|
||||
buf[jj++]=ss/10+0x30;
|
||||
buf[jj++]=ss%10+0x30;
|
||||
}
|
||||
if (usa)
|
||||
{
|
||||
buf[jj++]=' ';
|
||||
if (hh<12)
|
||||
buf[jj++]='A';
|
||||
else
|
||||
buf[jj++]='P';
|
||||
buf[jj++]='M';
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// ------------------- ********************************************************************************
|
||||
|
||||
void GetDateString(uint8_t day, uint8_t month, uint8_t yearhigh, uint8_t yearlow, uint8_t format, uint8_t sep, uint8_t *buf)
|
||||
{
|
||||
// generate date as ascii string from integers day/month/year
|
||||
// yearhigh: 10..29, in europe always 20 (not in arabia!) comes as hex number, e.g. 0x20
|
||||
// format= 0: dd.mm.yyyy (deutsch)
|
||||
// 1: mm.dd.yyyy (amerika)
|
||||
// 2: yyyy.mm.dd (Iran, Dubai)
|
||||
// 3: dd.yyyy.mm
|
||||
// 4: mm.yyyy.dd
|
||||
// 5: yyyy.dd.mm
|
||||
// sep: 0: use . as seperator 1: use / as seperator
|
||||
// return String in *buf // 11byte für buf!
|
||||
|
||||
|
||||
uint8_t tag, mon, jahr, d10, d1, m10, m1, y1000, y100, y10, y1;
|
||||
uint8_t slash;
|
||||
|
||||
|
||||
y100= (yearhigh & 0x0F)+0x30;
|
||||
y1000=((yearhigh & 0xF0)>>4)+0x30;
|
||||
// if (yearhigh>=20)
|
||||
// {
|
||||
// y1000='2';
|
||||
// y100=28+yearhigh; // '0' + (yearhigh-20)
|
||||
// } else
|
||||
// if (yearhigh<20)
|
||||
// {
|
||||
// y1000='1';
|
||||
// y100=38-yearhigh; // '9' - (19-yearhigh)
|
||||
// }
|
||||
|
||||
tag=day;
|
||||
mon=month;
|
||||
jahr=yearlow;
|
||||
|
||||
if (mon>12 || mon==0) mon=1; // 23.10.12
|
||||
if (tag>31 || tag==0) tag=1;
|
||||
if (jahr>50 || jahr<11) jahr=1;
|
||||
|
||||
if (sep==0)
|
||||
slash='.'; // slash==0
|
||||
else if (sep==1)
|
||||
slash='/';
|
||||
else
|
||||
if (sep>=0x20)
|
||||
slash=sep;
|
||||
else
|
||||
slash='.';
|
||||
|
||||
d10 =tag/10;
|
||||
d1 =tag%10;
|
||||
m10 =mon/10;
|
||||
m1 =mon%10;
|
||||
y10 =jahr/10;
|
||||
y1 =jahr%10;
|
||||
|
||||
d10 +=0x30; // in Asccii wandeln
|
||||
d1 +=0x30;
|
||||
m10 +=0x30;
|
||||
m1 +=0x30;
|
||||
y10 +=0x30;
|
||||
y1 +=0x30;
|
||||
|
||||
switch (format)
|
||||
{
|
||||
// 0: dd.mm.yyyy
|
||||
case 0: buf[0]=d10; buf[1]=d1; buf[2]=slash; buf[3]=m10; buf[4]=m1; buf[5]=slash;
|
||||
buf[6]=y1000; buf[7]=y100; buf[8]=y10; buf[9]=y1; break;
|
||||
|
||||
// 1: mm.dd.yyyy
|
||||
case 1: buf[0]=m10; buf[1]=m1; buf[2]=slash; buf[3]=d10; buf[4]=d1; buf[5]=slash;
|
||||
buf[6]=y1000; buf[7]=y100; buf[8]=y10; buf[9]=y1; break;
|
||||
|
||||
// 2: yyyy.mm.dd
|
||||
case 2: buf[0]=y1000; buf[1]=y100; buf[2]=y10; buf[3]=y1; buf[4]=slash; buf[5]=m10;
|
||||
buf[6]=m1; buf[7]=slash; buf[8]=d10; buf[9]=d1; break;
|
||||
|
||||
// 3: dd.yyyy.mm
|
||||
case 3: buf[0]=d10; buf[1]=d1; buf[2]=slash; buf[3]=y1000; buf[4]=y100;
|
||||
buf[5]=y10; buf[6]=y1; buf[7]=slash; buf[8]=m10; buf[9]=m1; break;
|
||||
|
||||
// 4: mm.yyyy.dd
|
||||
case 4: buf[0]=m10; buf[1]=m1; buf[2]=slash; buf[3]=y1000; buf[4]=y100;
|
||||
buf[5]=y10; buf[6]=y1; buf[7]=slash; buf[8]=d10; buf[9]=d1; break;
|
||||
|
||||
// 5: yyyy.dd.mm
|
||||
case 5: buf[0]=y1000; buf[1]=y100; buf[2]=y10; buf[3]=y1; buf[4]=slash; buf[5]=d10;
|
||||
buf[6]=d1; buf[7]=slash; buf[8]=m10; buf[9]=m1; break;
|
||||
|
||||
}
|
||||
buf[10]=0;
|
||||
|
||||
|
||||
}
|
||||
|
||||
// ------------------- ********************************************************************************
|
||||
|
||||
void GetShortDateString(uint8_t day, uint8_t month, uint8_t yearlow, uint8_t format, uint8_t sep, uint8_t *buf)
|
||||
{
|
||||
// generate date as ascii string from integers day/month/year
|
||||
// format= 0: dd.mm.yy (deutsch)
|
||||
// 1: mm.dd.yy (amerika)
|
||||
// 2: yy.mm.dd (Iran, Dubai)
|
||||
// 3: dd.yy.mm
|
||||
// 4: mm.yy.dd
|
||||
// 5: yy.dd.mm
|
||||
// sep: 0: use . as seperator 1: use / as seperator
|
||||
// return String in *buf // 11byte für buf!
|
||||
|
||||
|
||||
uint8_t tag, mon, jahr, d10, d1, m10, m1, y10, y1;
|
||||
uint8_t slash;
|
||||
|
||||
|
||||
tag=day;
|
||||
mon=month;
|
||||
jahr=yearlow;
|
||||
|
||||
if (mon>12 || mon==0) mon=1; // 23.10.12
|
||||
if (tag>31 || tag==0) tag=1;
|
||||
if (jahr>50 || jahr<11) jahr=1;
|
||||
|
||||
if (sep==0)
|
||||
slash='.'; // slash==0
|
||||
else if (sep==1)
|
||||
slash='/';
|
||||
else if (sep>=0x20)
|
||||
slash=sep;
|
||||
else
|
||||
slash='.';
|
||||
|
||||
d10 =tag/10;
|
||||
d1 =tag%10;
|
||||
m10 =mon/10;
|
||||
m1 =mon%10;
|
||||
y10 =jahr/10;
|
||||
y1 =jahr%10;
|
||||
|
||||
d10 +=0x30; // in Asccii wandeln
|
||||
d1 +=0x30;
|
||||
m10 +=0x30;
|
||||
m1 +=0x30;
|
||||
y10 +=0x30;
|
||||
y1 +=0x30;
|
||||
|
||||
switch (format)
|
||||
{
|
||||
// 0: dd.mm.yyyy
|
||||
case 0: buf[0]=d10; buf[1]=d1; buf[2]=slash; buf[3]=m10; buf[4]=m1; buf[5]=slash;
|
||||
buf[6]=y10; buf[7]=y1; break;
|
||||
|
||||
// 1: mm.dd.yyyy
|
||||
case 1: buf[0]=m10; buf[1]=m1; buf[2]=slash; buf[3]=d10; buf[4]=d1; buf[5]=slash;
|
||||
buf[6]=y10; buf[7]=y1; break;
|
||||
|
||||
// 2: yyyy.mm.dd
|
||||
case 2: buf[0]=y10; buf[1]=y1; buf[2]=slash; buf[3]=m10;
|
||||
buf[4]=m1; buf[5]=slash; buf[6]=d10; buf[7]=d1; break;
|
||||
|
||||
// 3: dd.yyyy.mm
|
||||
case 3: buf[0]=d10; buf[1]=d1; buf[2]=slash;
|
||||
buf[3]=y10; buf[4]=y1; buf[5]=slash; buf[6]=m10; buf[7]=m1; break;
|
||||
|
||||
// 4: mm.yyyy.dd
|
||||
case 4: buf[0]=m10; buf[1]=m1; buf[2]=slash;
|
||||
buf[3]=y10; buf[4]=y1; buf[5]=slash; buf[6]=d10; buf[7]=d1; break;
|
||||
|
||||
// 5: yyyy.dd.mm
|
||||
case 5: buf[0]=y10; buf[1]=y1; buf[2]=slash; buf[3]=d10;
|
||||
buf[4]=d1; buf[5]=slash; buf[6]=m10; buf[7]=m1; break;
|
||||
|
||||
}
|
||||
buf[8]=0;
|
||||
|
||||
|
||||
}
|
||||
|
||||
uint16_t tslib_strlen(char *buf)
|
||||
{
|
||||
uint16_t nn;
|
||||
|
||||
for (nn=0; nn<0xFFF0; nn++)
|
||||
if (buf[nn]==0)
|
||||
return nn;
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint16_t tslib_strlen(uint8_t *buf)
|
||||
{
|
||||
uint16_t nn;
|
||||
|
||||
for (nn=0; nn<0xFFF0; nn++)
|
||||
if (buf[nn]==0)
|
||||
return nn;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void tslib_strclr(char *buf, char clrsign, uint16_t len)
|
||||
{
|
||||
uint16_t nn;
|
||||
|
||||
for (nn=0; nn<len; nn++)
|
||||
buf[nn]=clrsign;
|
||||
|
||||
}
|
||||
|
||||
void tslib_strclr(uint8_t *buf, char clrsign, uint16_t len)
|
||||
{
|
||||
uint16_t nn;
|
||||
|
||||
for (nn=0; nn<len; nn++)
|
||||
buf[nn]=uint8_t (clrsign);
|
||||
|
||||
}
|
||||
|
||||
|
||||
void tslib_strcpy(char *srcbuf, char *destbuf, uint16_t len)
|
||||
{
|
||||
uint16_t nn;
|
||||
|
||||
for (nn=0; nn<len; nn++)
|
||||
destbuf[nn]=srcbuf[nn];
|
||||
|
||||
}
|
||||
|
||||
void tslib_strcpy(char *srcbuf, uint8_t *destbuf, uint16_t len)
|
||||
{
|
||||
uint16_t nn;
|
||||
|
||||
for (nn=0; nn<len; nn++)
|
||||
destbuf[nn]=uint8_t(srcbuf[nn]);
|
||||
|
||||
}
|
||||
|
||||
void tslib_strcpy(uint8_t *srcbuf, uint8_t *destbuf, uint16_t len)
|
||||
{
|
||||
uint16_t nn;
|
||||
|
||||
for (nn=0; nn<len; nn++)
|
||||
destbuf[nn]=srcbuf[nn];
|
||||
|
||||
}
|
||||
|
||||
bool tslib_isDecAsciiNumber(char sign)
|
||||
{
|
||||
if (sign>=0x30 && sign<=0x39)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool tslib_isHexAsciiNumber(char sign)
|
||||
{
|
||||
if (sign>=0x30 && sign<=0x39)
|
||||
return true;
|
||||
if (sign>=0x61 && sign<=0x66) // a...f
|
||||
return true;
|
||||
if (sign>=0x41 && sign<=0x46) // A...F
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
int tslib_getMinimum(int val1, int val2)
|
||||
{
|
||||
if (val1<val2)
|
||||
return val1;
|
||||
return val2;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void tslib_text2array(QByteArray text, char *aray, uint16_t maxArayLen)
|
||||
{
|
||||
QByteArray sloc;
|
||||
int ii, LL=text.length();
|
||||
|
||||
if (LL>maxArayLen) LL=maxArayLen;
|
||||
for (ii=0; ii<LL; ii++)
|
||||
{
|
||||
aray[ii]=text.at(ii);
|
||||
}
|
||||
if (LL==maxArayLen)
|
||||
aray[LL-1]=0;
|
||||
else
|
||||
aray[LL]=0;
|
||||
}
|
||||
|
||||
|
||||
// -----------------------------------------------------------------------------------------------
|
||||
// functions for DeviceController's Bootloader ---------------------------------------------------
|
||||
// -----------------------------------------------------------------------------------------------
|
||||
/*
|
||||
uint16_t tslib_calcCrcCcitt(uint16_t BufLength, uint8_t *buf)
|
||||
{
|
||||
uint8_t nn, B15H, element;
|
||||
uint16_t crc = 0x84cf;
|
||||
|
||||
while (BufLength--)
|
||||
{
|
||||
element = *buf++;
|
||||
for (nn = 0; nn < 8; nn++)
|
||||
{
|
||||
B15H = 0;
|
||||
if(crc & 0x8000)
|
||||
B15H = 1;
|
||||
crc = (crc << 1) | ((element >> (7 - nn)) & 0x01);
|
||||
if (B15H)
|
||||
{
|
||||
crc ^= 0x1021;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (nn = 0; nn < 16; nn++)
|
||||
{
|
||||
B15H = 0;
|
||||
if(crc & 0x8000)
|
||||
B15H = 1;
|
||||
crc = (crc << 1) | 0x00;
|
||||
if (B15H)
|
||||
{
|
||||
crc ^= 0x1021;
|
||||
}
|
||||
}
|
||||
return crc;
|
||||
|
||||
}
|
||||
|
||||
static uint8_t LastBLcmd; // stored the last sent cmd in order to analys response
|
||||
// cmd echo'ed: error cmd or'ed with 0x80: OK
|
||||
|
||||
uint8_t tslib_prepareDC_BLcmd(uint8_t Cmd, uint8_t SendDataLength, uint8_t *sendData, uint8_t *outBuf)
|
||||
{
|
||||
// make BL protocol, retval = outbuf length (5...133)
|
||||
// bring data in correct form: start always with 0x02 finish with 0x03 and append checksum
|
||||
// 0x02 Cmd < ...sendData ..> CRC CRC 0x03
|
||||
// Data length = 0...64
|
||||
// special conversion: if data contain 2 or 3 (STX, ETX) then write two bytes: 0x1B (=ESC) and data|0x80
|
||||
// so maxlength = 5 + 2 x 64 (if all data are 2 or 3) without 2,3: maxlength = 5 + 64
|
||||
|
||||
uint8_t myBuf[140], pp=0, nn, uctmp, currLen=0;
|
||||
uint16_t calcCrc;
|
||||
|
||||
tslib_strclr(myBuf, 0, 140);
|
||||
|
||||
myBuf[pp++]=2; // STX
|
||||
myBuf[pp++]=Cmd;
|
||||
LastBLcmd=Cmd;
|
||||
|
||||
// append data:
|
||||
for (nn=0; nn<SendDataLength; nn++)
|
||||
{
|
||||
uctmp=sendData[nn];
|
||||
if (uctmp==2 || uctmp==3) // STX or ETX in normal data!
|
||||
{
|
||||
myBuf[pp++]=0x1B; // ESC
|
||||
myBuf[pp++]=uctmp | 0x80;
|
||||
} else
|
||||
myBuf[pp++]=uctmp;
|
||||
}
|
||||
currLen=pp;
|
||||
|
||||
// calc crc: (over cmd and data, without STX)
|
||||
calcCrc=tslib_calcCrcCcitt(uint16_t(currLen), myBuf);
|
||||
myBuf[pp++]=uint8_t(calcCrc & 0x00FF);
|
||||
myBuf[pp++]=uint8_t((calcCrc>>8) & 0x00FF);
|
||||
myBuf[pp++]=3;
|
||||
currLen=pp;
|
||||
|
||||
return currLen;
|
||||
}
|
||||
|
||||
// some special commands (right out of bootloader manual)
|
||||
uint8_t tslib_readBLversion(uint8_t *sendData)
|
||||
{
|
||||
// minimum size of sendData-buffer: 5byte retval: length
|
||||
uint8_t myBuf[2];
|
||||
tslib_strclr(myBuf, 0, 2);
|
||||
return tslib_prepareDC_BLcmd(0x11, 0, myBuf, sendData);
|
||||
}
|
||||
|
||||
uint8_t tslib_readFWversion(uint8_t *sendData)
|
||||
{
|
||||
// minimum size of sendData-buffer: 5byte retval: length
|
||||
uint8_t myBuf[2];
|
||||
tslib_strclr(myBuf, 0, 2);
|
||||
return tslib_prepareDC_BLcmd(0x12, 0, myBuf, sendData);
|
||||
}
|
||||
|
||||
uint8_t tslib_exitBL(uint8_t *sendData)
|
||||
{
|
||||
// minimum size of sendData-buffer: 5byte retval: length
|
||||
uint8_t myBuf[2];
|
||||
tslib_strclr(myBuf, 0, 2);
|
||||
return tslib_prepareDC_BLcmd(0x18, 0, myBuf, sendData);
|
||||
}
|
||||
|
||||
uint8_t tslib_sendFlashStartAddr2BL(uint32_t startAddr, uint8_t *sendData)
|
||||
{
|
||||
// minimum size of sendData-buffer: 13byte retval: length (9...13)
|
||||
uint8_t myBuf[2];
|
||||
tslib_strclr(myBuf, 0, 2);
|
||||
return tslib_prepareDC_BLcmd(0x11, 0, myBuf, sendData);
|
||||
}
|
||||
*/
|
||||
|
||||
// -----------------------------------------------------------------------------------------------
|
||||
|
||||
|
||||
void biox_CopyBlock(uint8_t *src, uint16_t srcPos, uint8_t *dest, uint16_t destPos, uint16_t len)
|
||||
{
|
||||
// both buffers starting from pos 0
|
||||
uint16_t xx,yy,zz,ii;
|
||||
|
||||
xx = srcPos;
|
||||
yy = destPos;
|
||||
zz = len;
|
||||
|
||||
for (ii = 0; ii < zz; ++ii)
|
||||
{
|
||||
dest[yy + ii] = src[xx + ii];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool tslib_strComp(uint8_t *buf, char *compStr)
|
||||
{
|
||||
uint16_t strLen=tslib_strlen(compStr), pp;
|
||||
|
||||
for (pp=0; pp<strLen; pp++)
|
||||
{
|
||||
if (buf[pp] != compStr[pp])
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user