Compare commits
	
		
			3 Commits
		
	
	
		
	
	| Author | SHA1 | Date | |
|---|---|---|---|
| 
						
						
							
						
						e8438f341e
	
				 | 
					
					
						|||
| 
						
						
							
						
						3f3911e573
	
				 | 
					
					
						|||
| 
						
						
							
						
						9744db7838
	
				 | 
					
					
						
@@ -90,9 +90,7 @@ HEADERS += \
 | 
			
		||||
    $${PWD}/include/sendWRcmd.h \
 | 
			
		||||
    $${PWD}/include/storeINdata.h \
 | 
			
		||||
    $${PWD}/include/tslib.h \
 | 
			
		||||
    $${PWD}/include/shared_mem_buffer.h \
 | 
			
		||||
    $${PWD}/include/reporting_thread.h \
 | 
			
		||||
    $${PWD}/include/download_thread.h
 | 
			
		||||
    $${PWD}/include/shared_mem_buffer.h
 | 
			
		||||
 | 
			
		||||
SOURCES += \
 | 
			
		||||
    $${PWD}/src/datei.cpp \
 | 
			
		||||
@@ -103,9 +101,7 @@ SOURCES += \
 | 
			
		||||
    $${PWD}/src/sendWRcmd.cpp \
 | 
			
		||||
    $${PWD}/src/storeINdata.cpp \
 | 
			
		||||
    $${PWD}/src/tslib.cpp \
 | 
			
		||||
    $${PWD}/src/shared_mem_buffer.cpp \
 | 
			
		||||
    $${PWD}/src/reporting_thread.cpp \
 | 
			
		||||
    $${PWD}/src/download_thread.cpp
 | 
			
		||||
    $${PWD}/src/shared_mem_buffer.cpp
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
# INTERFACE = DeviceController
 | 
			
		||||
 
 | 
			
		||||
@@ -64,8 +64,7 @@ public:
 | 
			
		||||
    bool readFromSerial(QByteArray &data, uint16_t &sendLength);
 | 
			
		||||
        // retval: true: data available
 | 
			
		||||
 | 
			
		||||
    uint32_t getWriteCount() { return writeCount; }
 | 
			
		||||
 | 
			
		||||
    void flushPort(void);
 | 
			
		||||
/*
 | 
			
		||||
    uint8_t getAllPortPins(void);
 | 
			
		||||
        // rs232pins: all signals bitwise coded in one byte:
 | 
			
		||||
 
 | 
			
		||||
@@ -69,6 +69,8 @@ bool dcBL_sendOneBlockCpl(uint16_t blockNumber);
 | 
			
		||||
 | 
			
		||||
int8_t dcBL_getBlockResult(void);
 | 
			
		||||
 | 
			
		||||
void dcBL_cancelSending(void);
 | 
			
		||||
 | 
			
		||||
char dcBL_cycle(void);
 | 
			
		||||
    // to be called cyclic every 100ms
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -1,37 +0,0 @@
 | 
			
		||||
#ifndef DOWNLOAD_THREAD_H_INCLUDED
 | 
			
		||||
#define DOWNLOAD_THREAD_H_INCLUDED
 | 
			
		||||
 | 
			
		||||
#include <QThread>
 | 
			
		||||
#include <QString>
 | 
			
		||||
#include <QByteArray>
 | 
			
		||||
 | 
			
		||||
class hwinf;
 | 
			
		||||
class DownloadThread : public QThread {
 | 
			
		||||
    Q_OBJECT
 | 
			
		||||
 | 
			
		||||
public:
 | 
			
		||||
    enum class DownloadResult {OK, ERROR, TIMEOUT, NOP};
 | 
			
		||||
 | 
			
		||||
    DownloadThread(hwinf *hw);
 | 
			
		||||
    ~DownloadThread();
 | 
			
		||||
 | 
			
		||||
protected:
 | 
			
		||||
    // download thread does not have a running event queue, and therefore
 | 
			
		||||
    // no slots. signals work the usual way.
 | 
			
		||||
    void run() override;
 | 
			
		||||
 | 
			
		||||
private:
 | 
			
		||||
    DownloadResult sendStatus(int ret) const;
 | 
			
		||||
    DownloadResult sendNextAddress(int bNum) const;
 | 
			
		||||
    DownloadResult sendNextDataBlock(QByteArray const &binary, int bNum) const;
 | 
			
		||||
    bool startBootloader() const;
 | 
			
		||||
    bool stopBootloader() const;
 | 
			
		||||
    QByteArray loadBinaryDCFile(QString dcFileName) const;
 | 
			
		||||
    bool resetDeviceController() const;
 | 
			
		||||
    DownloadResult dcDownloadBinary(QByteArray const &b) const;
 | 
			
		||||
 | 
			
		||||
    hwinf *m_hw;
 | 
			
		||||
    QString m_fileToDownload;
 | 
			
		||||
};
 | 
			
		||||
 | 
			
		||||
#endif // DOWNLOAD_THREAD_H_INCLUDED
 | 
			
		||||
@@ -41,6 +41,8 @@ V4.0  6.9.2023: activating DC-Bootloader in slve-lib (SM)
 | 
			
		||||
        several new functions for "direct ticket print", without the dueway loading jsons to DC and cmd DC to print
 | 
			
		||||
        The same rules as before apply to the json, but it can have any arbitrary length
 | 
			
		||||
 | 
			
		||||
8.10.2024 extension in dc_autoRequest()
 | 
			
		||||
 | 
			
		||||
*/
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@@ -1352,16 +1354,6 @@ public:
 | 
			
		||||
    bool dcDownloadReportRunning() const override;
 | 
			
		||||
    bool dcDownloadReportFinished() override;
 | 
			
		||||
 | 
			
		||||
    bool dcDownloadThreadStart() override;
 | 
			
		||||
    bool dcDownloadThreadRunning() const override;
 | 
			
		||||
    void dcDownloadThreadFinalize(DownloadThread *) override;
 | 
			
		||||
    bool dcDownloadThreadFinished() const override;
 | 
			
		||||
    bool dcDownloadReportThreadStart() override;
 | 
			
		||||
    bool dcDownloadReportThreadRunning() const override;
 | 
			
		||||
    void dcDownloadReportThreadFinalize() override;
 | 
			
		||||
    void dcDownloadReportThreadQuit() override;
 | 
			
		||||
    bool dcDownloadReportThreadFinished() const override;
 | 
			
		||||
 | 
			
		||||
    QString dcDownloadFileName() const override;
 | 
			
		||||
    bool dcDownloadSetRequested(bool) override;
 | 
			
		||||
    bool dcDownloadSetRunning(bool) override;
 | 
			
		||||
 
 | 
			
		||||
@@ -122,6 +122,8 @@ public:
 | 
			
		||||
                           uint8_t  *RdDlen, uint8_t *receivedData);
 | 
			
		||||
        // retval: data valid, only one time true
 | 
			
		||||
 | 
			
		||||
    void flushPort(void);
 | 
			
		||||
    
 | 
			
		||||
    uint16_t getReadSource() { return readSource; } // readSource contains last command sent to device controller
 | 
			
		||||
    T_com *getSerialPort() { return mySerialPort; } // utility function
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -1,25 +0,0 @@
 | 
			
		||||
#ifndef REPORTING_THREAD_H_INCLUDED
 | 
			
		||||
#define REPORTING_THREAD_H_INCLUDED
 | 
			
		||||
 | 
			
		||||
#include <QThread>
 | 
			
		||||
#include <QString>
 | 
			
		||||
 | 
			
		||||
class hwapi;
 | 
			
		||||
class ReportingThread : public QThread {
 | 
			
		||||
    Q_OBJECT
 | 
			
		||||
 | 
			
		||||
public:
 | 
			
		||||
    ReportingThread(hwapi *hw);
 | 
			
		||||
    ~ReportingThread();
 | 
			
		||||
 | 
			
		||||
protected:
 | 
			
		||||
    // reporting thread does not have a running event queue, and therefore
 | 
			
		||||
    // no slots. signals work the usual way.
 | 
			
		||||
    void run() override;
 | 
			
		||||
 | 
			
		||||
private:
 | 
			
		||||
    hwapi *m_hw;
 | 
			
		||||
    QString m_fileToDownload;
 | 
			
		||||
};
 | 
			
		||||
 | 
			
		||||
#endif // REPORTING_THREAD_H_INCLUDED
 | 
			
		||||
@@ -52,6 +52,7 @@ class T_runProc : public QObject
 | 
			
		||||
private slots:
 | 
			
		||||
    void runProc_slotProcess(void);
 | 
			
		||||
    bool bl_performComplStart(void);
 | 
			
		||||
    bool bl_waitForRdyMsg(void);
 | 
			
		||||
 | 
			
		||||
public:
 | 
			
		||||
    T_runProc();
 | 
			
		||||
@@ -70,9 +71,11 @@ public:
 | 
			
		||||
    void bl_rebootDC(void);
 | 
			
		||||
    void bl_startBL(void);
 | 
			
		||||
    void bl_checkBL(void);
 | 
			
		||||
    bool bl_isUp(void);
 | 
			
		||||
 | 
			
		||||
    // new from 21.5.24 ..................................................................
 | 
			
		||||
    //uint8_t bl_isUp(void);  neuere Sax-Version, bisher nicht verwendet
 | 
			
		||||
        // return 1: BL is up   2: BL error  0: stopped
 | 
			
		||||
    bool bl_isUp(void);	    
 | 
			
		||||
        
 | 
			
		||||
    void resetBLvari(void);
 | 
			
		||||
 | 
			
		||||
    uint16_t sys_getCustomerNumber(void);
 | 
			
		||||
    uint16_t sys_getMachineNumber(void);
 | 
			
		||||
 
 | 
			
		||||
@@ -241,6 +241,8 @@ struct SharedMem
 | 
			
		||||
    bool    Sdata_coinPaymentNow;
 | 
			
		||||
    bool    Sdata_bootloadingNow;
 | 
			
		||||
 | 
			
		||||
    bool    Sdata_ptuInSleep;
 | 
			
		||||
    bool    Sdata_dcInSleep;
 | 
			
		||||
 | 
			
		||||
    // ------------------ Data OUTPUT --------------------------------
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -115,6 +115,10 @@ long tslib_atol( char *AscString);
 | 
			
		||||
    // AscString must be 0-terminated!
 | 
			
		||||
    // a leading '-' is ignored, a'.' or a ',' stops calculation
 | 
			
		||||
 | 
			
		||||
void swl_returnWeekdayStr(char dow, char language, char *buf);
 | 
			
		||||
    // dow=1...7
 | 
			
		||||
    // always returns 10byte
 | 
			
		||||
    // languages: 1=german  2=english
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -379,6 +379,11 @@ bool T_com::isPortOpen(void)
 | 
			
		||||
    return false;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
void T_com::flushPort(void)
 | 
			
		||||
{
 | 
			
		||||
    if (CatSerial->isOpen())
 | 
			
		||||
        CatSerial->clear();
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
// -------------------------------------------------------------------------------------------------------------
 | 
			
		||||
// -------------------------------------------------------------------------------------------------------------
 | 
			
		||||
 
 | 
			
		||||
@@ -496,6 +496,31 @@ uint8_t epi_getBatchResult()
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
// 8.10.2024 new, control power up/down
 | 
			
		||||
/*
 | 
			
		||||
void gpi_storePowerState(bool ptu_sleep, bool ptu_wake, bool dc_sleep, bool dc_wake)
 | 
			
		||||
{
 | 
			
		||||
    if (ptu_sleep)
 | 
			
		||||
        SharedMem::write()->Sdata_ptuInSleep=true;
 | 
			
		||||
    if (ptu_wake)
 | 
			
		||||
        SharedMem::write()->Sdata_ptuInSleep=false;
 | 
			
		||||
    if (dc_sleep)
 | 
			
		||||
        SharedMem::write()->Sdata_dcInSleep=true;
 | 
			
		||||
    if (dc_wake)
 | 
			
		||||
        SharedMem::write()->Sdata_dcInSleep=false;
 | 
			
		||||
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
bool epi_getPowerState_ptu()
 | 
			
		||||
{
 | 
			
		||||
    return SharedMem::read()->Sdata_ptuInSleep;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
bool epi_getPowerState_dc()
 | 
			
		||||
{
 | 
			
		||||
    return SharedMem::read()->Sdata_dcInSleep;
 | 
			
		||||
}
 | 
			
		||||
*/
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
							
								
								
									
										201
									
								
								src/datIf.cpp
									
									
									
									
									
								
							
							
						
						
									
										201
									
								
								src/datIf.cpp
									
									
									
									
									
								
							@@ -45,6 +45,8 @@ static uint8_t datif_repeatCtr;
 | 
			
		||||
static uint8_t datif_kindOfCmd;
 | 
			
		||||
 | 
			
		||||
static uint8_t datif_pNextCmd, datif_sendSlowCmd;
 | 
			
		||||
static char testSerial;
 | 
			
		||||
static bool autoRequestWasOnBeforePowerDown;
 | 
			
		||||
 | 
			
		||||
//#define     DATIF_MAXTO_WAIT4RESP       80      //20 erhöht am 17.7 geht viel besser
 | 
			
		||||
    // höchster gemessener Wert (bei 20ms): 6
 | 
			
		||||
@@ -122,11 +124,11 @@ T_datif::T_datif(QObject *parent) : QObject(parent)
 | 
			
		||||
    datei_clearFile(FILENAME_SHAREDDATA);
 | 
			
		||||
    datei_writeToFile(FILENAME_SHAREDDATA, myBA);
 | 
			
		||||
*/
 | 
			
		||||
    doRepeat=true;
 | 
			
		||||
    doRepeat=false;
 | 
			
		||||
    datif_pNextCmd=0;
 | 
			
		||||
    datif_sendSlowCmd=0;
 | 
			
		||||
 | 
			
		||||
    readCount = 0;
 | 
			
		||||
    testSerial=99;
 | 
			
		||||
    autoRequestWasOnBeforePowerDown=false;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
void T_datif::resetChain(void)
 | 
			
		||||
@@ -164,22 +166,23 @@ char T_datif::datif_cycleSend()
 | 
			
		||||
 | 
			
		||||
    // supervise if DC data are valid
 | 
			
		||||
    datif_noResponseCtr++;         // inc every 20ms
 | 
			
		||||
    if (datif_noResponseCtr>250)   // no life sign from device controller (DC) for about 20ms x 250 = 5000ms = 5s
 | 
			
		||||
     {
 | 
			
		||||
    if (datif_noResponseCtr>250)   // no life sign from device controller (DC) for about a sec
 | 
			
		||||
     {                              // 10.7.2025: timeout increased 50-->250 (1s-->5s)
 | 
			
		||||
        epi_resetDcDataValid(3);    // DC data has not updated for >=5s -> no longer valid!
 | 
			
		||||
        datif_nowNewDyns=0;
 | 
			
		||||
        datif_nowNewStats=0;
 | 
			
		||||
 | 
			
		||||
        testSerial=0;               // New, 11.10.20TS
 | 
			
		||||
        datif_noResponseCtr=0;      // New, 11.10.20TS
 | 
			
		||||
    }
 | 
			
		||||
    // 24.7.24 new, data are valid if dynamic machine conditions AND dyn machine states came in
 | 
			
		||||
    if (datif_nowNewDyns && datif_nowNewStats && !epi_areDcDataValid() )
 | 
			
		||||
        epi_setDcDataValid();
 | 
			
		||||
 | 
			
		||||
    // Ueberwachung ob ein oder mehrere Commands am Stueck erfolgreich waren
 | 
			
		||||
    if (gpi_wantToResetSupervision())
 | 
			
		||||
    {
 | 
			
		||||
        gpi_storeOverallResult(0xFF);
 | 
			
		||||
    }
 | 
			
		||||
    //if (gpi_wantToResetSupervision())
 | 
			
		||||
    //{
 | 
			
		||||
     //   gpi_storeOverallResult(0xFF);
 | 
			
		||||
    //}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@@ -219,16 +222,7 @@ char T_datif::datif_cycleSend()
 | 
			
		||||
            gpi_storeLastResult(8);
 | 
			
		||||
            return 0;
 | 
			
		||||
        }
 | 
			
		||||
/*
 | 
			
		||||
 * Unsinn, wird nie durchlaufen
 | 
			
		||||
        if (cycl_running>=(RESPONSEWAITTIME+6))  // 3.7.24: 101-->110
 | 
			
		||||
        {
 | 
			
		||||
            // Antwort ist gekommen, also nach kurzer Luecke naechstes (datif_cmdWasPerformed==1)
 | 
			
		||||
            //      oder nochmal gleiches (datif_cmdWasPerformed==2) Kommando senden
 | 
			
		||||
            //qDebug()<< "datif got any response";
 | 
			
		||||
            cycl_running=0;            
 | 
			
		||||
        }
 | 
			
		||||
*/
 | 
			
		||||
 | 
			
		||||
        // hier stoppen, weil Antwort des letzten Cmds noch nicht da
 | 
			
		||||
        return 0;
 | 
			
		||||
    }
 | 
			
		||||
@@ -366,19 +360,53 @@ char T_datif::datif_cycleSend()
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    // if no direct comands need to be sent then send input requests
 | 
			
		||||
 | 
			
		||||
    // new, 8.10.2024, avoid wrong messages right after wake-up
 | 
			
		||||
    if ( testSerial==1)
 | 
			
		||||
    {
 | 
			
		||||
        myDCIF->setUserWriteData(0, 0,0, data);
 | 
			
		||||
        myDCIF->setUserReadData(CMD2DC_TestSerial);
 | 
			
		||||
        myDCIF->sendUserData(selectedSlaveAddr);
 | 
			
		||||
        // request fixed string from DC and thus wait until DC is ready
 | 
			
		||||
        cycl_running=1;     // 1: start transmission
 | 
			
		||||
        datif_kindOfCmd=0;
 | 
			
		||||
        datif_repeatCtr=0;
 | 
			
		||||
        doRepeat=false;
 | 
			
		||||
    } else
 | 
			
		||||
    if ( testSerial==2)
 | 
			
		||||
    {
 | 
			
		||||
        if (autoRequestWasOnBeforePowerDown)
 | 
			
		||||
            epi_startEmmision(true);
 | 
			
		||||
        testSerial++;
 | 
			
		||||
    } else
 | 
			
		||||
 | 
			
		||||
    if (gpi_isEmmisionOn())     // auto send button is pressed
 | 
			
		||||
    {
 | 
			
		||||
        //qDebug() << "auto request is on";
 | 
			
		||||
        datif_kindOfCmd=0;
 | 
			
		||||
        sendINrequestsAutomatic();        // request all cyclic data sequential
 | 
			
		||||
    }
 | 
			
		||||
    else
 | 
			
		||||
        if (testSerial==0)
 | 
			
		||||
        {
 | 
			
		||||
            // start with test command after wakeup
 | 
			
		||||
            testSerial=1;
 | 
			
		||||
        } else
 | 
			
		||||
        {
 | 
			
		||||
            sendINrequestsAutomatic();        // request all cyclic data sequential
 | 
			
		||||
            autoRequestWasOnBeforePowerDown=true;
 | 
			
		||||
        }
 | 
			
		||||
    } else
 | 
			
		||||
    {
 | 
			
		||||
        // new: after stopping auto-request flush com port ONE time, 6.11.24TS
 | 
			
		||||
        // why? to get boot loader response correct at first request
 | 
			
		||||
        // without flushing we got the response of last cyclic data request in buffer
 | 
			
		||||
        if (autoRequestWasOnBeforePowerDown)
 | 
			
		||||
            myDCIF->flushPort();
 | 
			
		||||
 | 
			
		||||
        dif_scanStep=0;         // always start from beginning
 | 
			
		||||
        epi_resetDcDataValid(4);
 | 
			
		||||
        datif_nowNewDyns=0;
 | 
			
		||||
        datif_nowNewStats=0;
 | 
			
		||||
 | 
			
		||||
        autoRequestWasOnBeforePowerDown=false;
 | 
			
		||||
        testSerial=0;
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    datif_cmdWasPerformed=0;    // 0: no response by now
 | 
			
		||||
@@ -403,8 +431,11 @@ char T_datif::sendINrequestsAutomatic(void)
 | 
			
		||||
    uint8_t datif_maxNrCommands=35, datif_sendNow;
 | 
			
		||||
 | 
			
		||||
    // send quicker while transaction is ongoing:
 | 
			
		||||
    uint8_t datif_vendRequCommandList[15]={102,107,108,110,112,115,116,30,31,32,40,41,42,23,0};
 | 
			
		||||
    uint8_t datif_maxVendingCmds=13;
 | 
			
		||||
    //uint8_t datif_vendRequCommandList[15]={102,107,108,110,112,115,116,31,32,40,41,42,23,0,0};
 | 
			
		||||
    //uint8_t datif_maxVendingCmds=13;
 | 
			
		||||
	// 30 muss drin sein um coin attach zu erkennen:
 | 
			
		||||
    uint8_t datif_vendRequCommandList[15]={102,107,108,110,112,115,116, 30, 31,32,40,41,42,23,0};
 | 
			
		||||
    uint8_t datif_maxVendingCmds=14;
 | 
			
		||||
 | 
			
		||||
    // special commands:
 | 
			
		||||
    // 102: get IOs run constantly!!!
 | 
			
		||||
@@ -620,117 +651,7 @@ char T_datif::loadRecDataFromFrame()
 | 
			
		||||
 | 
			
		||||
    gpi_storeRecPayLoad(RdDleng, receivedData); //  save for host (user of hwapi)
 | 
			
		||||
 | 
			
		||||
    if (myDCIF && myDCIF->getSerialPort()) {
 | 
			
		||||
        uint32_t writeCount = myDCIF->getSerialPort()->getWriteCount();
 | 
			
		||||
        if ((readCount + 1) == writeCount) { // there can be only one command sent to the DC
 | 
			
		||||
            readCount = writeCount;
 | 
			
		||||
            if (readSource != myDCIF->getReadSource()) {
 | 
			
		||||
                qCritical() << __func__ << ":" << __LINE__ << ": ERROR length" << RdDleng << ", ignore data"
 | 
			
		||||
                            << QByteArray(reinterpret_cast<char const *>(receivedData), RdDleng).toHex(':');
 | 
			
		||||
                qCritical() << __func__ << ":" << __LINE__ << "would be interpretated as" << readSource << myDCIF->getReadSource();
 | 
			
		||||
                return 0;
 | 
			
		||||
            } else {
 | 
			
		||||
                // only for debugging
 | 
			
		||||
                // qCritical() << __func__ << ":" << __LINE__ << QDateTime::currentDateTime().time().toString(Qt::ISODateWithMs) << readSource << myDCIF->getReadSource();
 | 
			
		||||
                if (readSource == 30) {
 | 
			
		||||
                    T_moduleCondition const *modCond = reinterpret_cast<T_moduleCondition const *>(receivedData);
 | 
			
		||||
 | 
			
		||||
                    if(modCond->rtc >= 200) {
 | 
			
		||||
                        dump(modCond);
 | 
			
		||||
                        qCritical() << __func__ << ":" << __LINE__ << ": ERROR E002 (modCond->rtc >= 200)"
 | 
			
		||||
                            << QByteArray(reinterpret_cast<char const *>(receivedData), RdDleng).toHex(':');
 | 
			
		||||
                    }
 | 
			
		||||
                    if (modCond->printer == 200 || modCond->printer == 201) {
 | 
			
		||||
                        dump(modCond);
 | 
			
		||||
                        qCritical() << __func__ << ":" << __LINE__ << ": ERROR E020 (modCond->printer == 200 || modCond->printer == 201)"
 | 
			
		||||
                            << QByteArray(reinterpret_cast<char const *>(receivedData), RdDleng).toHex(':');
 | 
			
		||||
                    }
 | 
			
		||||
                    if (modCond->printer == 202) {
 | 
			
		||||
                        dump(modCond);
 | 
			
		||||
                        qCritical() << __func__ << ":" << __LINE__ << ": ERROR E018 (modCond->printer == 202)"
 | 
			
		||||
                            << QByteArray(reinterpret_cast<char const *>(receivedData), RdDleng).toHex(':');
 | 
			
		||||
                    }
 | 
			
		||||
                    if (modCond->coinBlocker >= 200) {
 | 
			
		||||
                        dump(modCond);
 | 
			
		||||
                        qCritical() << __func__ << ":" << __LINE__ << ": ERROR E025 (modCond->coinBlocker >= 200)"
 | 
			
		||||
                            << QByteArray(reinterpret_cast<char const *>(receivedData), RdDleng).toHex(':');
 | 
			
		||||
                    }
 | 
			
		||||
                    if (modCond->mdbBus >= 200) {
 | 
			
		||||
                        dump(modCond);
 | 
			
		||||
                        qCritical() << __func__ << ":" << __LINE__ << ": ERROR E034 (modCond->mdbBus >= 200)"
 | 
			
		||||
                            << QByteArray(reinterpret_cast<char const *>(receivedData), RdDleng).toHex(':');
 | 
			
		||||
                    }
 | 
			
		||||
                    if (modCond->intEe >= 200) {
 | 
			
		||||
                        dump(modCond);
 | 
			
		||||
                        qCritical() << __func__ << ":" << __LINE__ << ": ERROR E011 (modCond->intEe >= 200)"
 | 
			
		||||
                            << QByteArray(reinterpret_cast<char const *>(receivedData), RdDleng).toHex(':');
 | 
			
		||||
                    }
 | 
			
		||||
                    if (modCond->voltage >= 200) {
 | 
			
		||||
                        dump(modCond);
 | 
			
		||||
                        qCritical() << __func__ << ":" << __LINE__ << ": ERROR E003 (modCond->voltage >= 200)"
 | 
			
		||||
                            << QByteArray(reinterpret_cast<char const *>(receivedData), RdDleng).toHex(':');
 | 
			
		||||
                    }
 | 
			
		||||
                    if (modCond->changer >= 200) {
 | 
			
		||||
                        dump(modCond);
 | 
			
		||||
                        qCritical() << __func__ << ":" << __LINE__ << ": ERROR E026 (modCond->changer >= 200)"
 | 
			
		||||
                            << QByteArray(reinterpret_cast<char const *>(receivedData), RdDleng).toHex(':');
 | 
			
		||||
                    }
 | 
			
		||||
                    if (modCond->coinSafe == 201) {
 | 
			
		||||
                        dump(modCond);
 | 
			
		||||
                        qCritical() << __func__ << ":" << __LINE__ << ": ERROR E007 (modCond->coinSafe == 201)"
 | 
			
		||||
                            << QByteArray(reinterpret_cast<char const *>(receivedData), RdDleng).toHex(':');
 | 
			
		||||
                    }
 | 
			
		||||
                    if (modCond->coinSafe == 200) {
 | 
			
		||||
                        dump(modCond);
 | 
			
		||||
                        qCritical() << __func__ << ":" << __LINE__ << ": ERROR E009 (modCond->coinSafe == 200)"
 | 
			
		||||
                            << QByteArray(reinterpret_cast<char const *>(receivedData), RdDleng).toHex(':');
 | 
			
		||||
                    }
 | 
			
		||||
                }
 | 
			
		||||
 | 
			
		||||
                if (readSource == 31) {
 | 
			
		||||
                    T_dynamicCondition const *dynCond = reinterpret_cast<T_dynamicCondition const *>(receivedData);
 | 
			
		||||
 | 
			
		||||
                    if (dynCond->modeAbrech > 0) {
 | 
			
		||||
                        dump(dynCond);
 | 
			
		||||
                        qCritical() << __func__ << ":" << __LINE__ << ": ERROR E011 (dynCond->modeAbrech > 0)"
 | 
			
		||||
                            << QByteArray(reinterpret_cast<char const *>(receivedData), RdDleng).toHex(':');
 | 
			
		||||
                    }
 | 
			
		||||
                    if (dynCond->nowCardTest > 0) {
 | 
			
		||||
                        dump(dynCond);
 | 
			
		||||
                        qCritical() << __func__ << ":" << __LINE__ << ": ERROR E072 (dynCond->nowCardTest > 0)"
 | 
			
		||||
                            << QByteArray(reinterpret_cast<char const *>(receivedData), RdDleng).toHex(':');
 | 
			
		||||
                    }
 | 
			
		||||
                    if (dynCond->startupTestIsRunning > 0) {
 | 
			
		||||
                        dump(dynCond);
 | 
			
		||||
                        qCritical() << __func__ << ":" << __LINE__ << ": ERROR E073 (dynCond->startupTestIsRunning > 0)"
 | 
			
		||||
                            << QByteArray(reinterpret_cast<char const *>(receivedData), RdDleng).toHex(':');
 | 
			
		||||
                    }
 | 
			
		||||
                }
 | 
			
		||||
            }
 | 
			
		||||
        } else {
 | 
			
		||||
            qCritical() << __func__ << ":" << __LINE__ << QString(": ERROR readCount + 1 != writeCount: %1 != %2").arg(readCount + 1).arg(writeCount);
 | 
			
		||||
            qCritical() << __func__ << ":" << __LINE__ << ": ERROR length" << RdDleng << ", ignore data"
 | 
			
		||||
                        << QByteArray((char const *)receivedData, RdDleng).toHex(':');
 | 
			
		||||
            qCritical() << __func__ << ":" << __LINE__ << "would be interpretated as" << readSource << myDCIF->getReadSource();
 | 
			
		||||
 | 
			
		||||
            if (readSource == 30) {
 | 
			
		||||
                T_moduleCondition const *modCond = reinterpret_cast<T_moduleCondition const *>(receivedData);
 | 
			
		||||
                dump(modCond);
 | 
			
		||||
            }
 | 
			
		||||
            if (readSource == 31) {
 | 
			
		||||
                T_dynamicCondition const *dynCond = reinterpret_cast<T_dynamicCondition const *>(receivedData);
 | 
			
		||||
                dump(dynCond);
 | 
			
		||||
                if (dynCond->coinAttached > 0) {
 | 
			
		||||
                    qCritical() << __func__ << ":" << __LINE__ << ": dynCond->coinAttached"
 | 
			
		||||
                        << QByteArray(reinterpret_cast<char const *>(receivedData), RdDleng).toHex(':');
 | 
			
		||||
                }
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            readCount = writeCount;
 | 
			
		||||
            return 0;
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    //sub_gerhardsDiagnose();
 | 
			
		||||
    // uint8_t nn;
 | 
			
		||||
    //qDebug() << "\n datif: got valid data, rdsrc:" << readSource << "  rdadd:" << readAddress
 | 
			
		||||
     //        << "  rdlen:" << RdDleng;
 | 
			
		||||
@@ -773,8 +694,11 @@ char T_datif::loadRecDataFromFrame()
 | 
			
		||||
            ret=verifyLineTestresponse(RdDleng, receivedData);
 | 
			
		||||
            gpi_storeResult_serialTestOK(ret);
 | 
			
		||||
            if (ret==true)
 | 
			
		||||
            {
 | 
			
		||||
                gpi_setTxt4datifLine("correct");
 | 
			
		||||
            else
 | 
			
		||||
                if ( testSerial==1) testSerial=2;   // nach wake kam richtige Antwort
 | 
			
		||||
 | 
			
		||||
            } else
 | 
			
		||||
                gpi_setTxt4datifLine("false");
 | 
			
		||||
            break;
 | 
			
		||||
 | 
			
		||||
@@ -1198,7 +1122,6 @@ char T_datif::loadRecDataFromFrame()
 | 
			
		||||
        uit2=uchar2uint(receivedData[7],receivedData[6]);  //  value of last coin
 | 
			
		||||
        //if (uitmp>0) // nur 1x bei neuer Münze  6.10.23 aendern:
 | 
			
		||||
                        // beim Wechsler hat die kleinste Muenze immer coin type 0!
 | 
			
		||||
 | 
			
		||||
        if (uitmp>10000 || uit2>10000)
 | 
			
		||||
        {
 | 
			
		||||
            uitmp=0;
 | 
			
		||||
 
 | 
			
		||||
							
								
								
									
										132
									
								
								src/dcBL.cpp
									
									
									
									
									
								
							
							
						
						
									
										132
									
								
								src/dcBL.cpp
									
									
									
									
									
								
							@@ -242,11 +242,7 @@ uint8_t dcBL_sendFlashStartAddr2BL(uint32_t startAddr, uint8_t *sendData)
 | 
			
		||||
    myBuf[2]=ulongTOuchar(startAddr, GETMIDLOWBYTE);
 | 
			
		||||
    myBuf[3]=ulongTOuchar(startAddr, GETLOWBYTE);
 | 
			
		||||
    myBuf[4]=0;
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
qDebug()<<"dcBL_sendFlashStartAddr2BL "<<myBuf[0]<<" "<<myBuf[1]<<" "<<myBuf[2]<<" "<<myBuf[3];
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
    //qDebug()<<"dcBL_sendFlashStartAddr2BL "<<myBuf[0]<<" "<<myBuf[1]<<" "<<myBuf[2]<<" "<<myBuf[3];
 | 
			
		||||
    return dcBL_prepareDC_BLcmd(0x21, 4, myBuf, sendData);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
@@ -258,9 +254,9 @@ uint8_t dcBL_writeLastPage(uint8_t *sendData)
 | 
			
		||||
    strclr(myBuf, 0, 2);
 | 
			
		||||
    ret=dcBL_prepareDC_BLcmd(0x22, 0, myBuf, sendData);
 | 
			
		||||
 | 
			
		||||
qDebug()<<"dcBL just sending last block command, ret: "<<ret<<" "<<sendData[0]
 | 
			
		||||
    <<" "<<sendData[1]<<" "<<sendData[2]<<" "<<sendData[3]<<" "<<sendData[4]
 | 
			
		||||
    <<" "<<sendData[5]<<" "<<sendData[6]<<" "<<sendData[7];
 | 
			
		||||
//qDebug()<<"dcBL just sending last block command, ret: "<<ret<<" "<<sendData[0]
 | 
			
		||||
//    <<" "<<sendData[1]<<" "<<sendData[2]<<" "<<sendData[3]<<" "<<sendData[4]
 | 
			
		||||
//    <<" "<<sendData[5]<<" "<<sendData[6]<<" "<<sendData[7];
 | 
			
		||||
 | 
			
		||||
        return ret;
 | 
			
		||||
}
 | 
			
		||||
@@ -332,7 +328,12 @@ uint8_t dcBL_getResponse(uint8_t *respBuff)
 | 
			
		||||
        //dcBL_writeText("dcBL gotResponse");
 | 
			
		||||
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    if (recLen>=150)
 | 
			
		||||
    {
 | 
			
		||||
        dcBL_writeText("dcBL rec.buff. overflow");
 | 
			
		||||
        epi_clrRawReceivedString();
 | 
			
		||||
        recLen=0;
 | 
			
		||||
    }
 | 
			
		||||
    return recLen;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
@@ -402,8 +403,8 @@ uint8_t dcBL_sendSuccess(uint8_t lastCommand)
 | 
			
		||||
    if (recLen==0)
 | 
			
		||||
        return 0;    // no response by now
 | 
			
		||||
 | 
			
		||||
//    qDebug()<<"dcBL_sendSuccess: got BL data"<< recLen <<
 | 
			
		||||
//        Indata[0]<< Indata[1]<<  Indata[2]<<  Indata[3] << Indata[4]<< Indata[5]<< Indata[6]<< Indata[7];
 | 
			
		||||
    qDebug()<<"dcBL_sendSuccess: got BL data"<< recLen <<
 | 
			
		||||
        Indata[0]<< Indata[1]<<  Indata[2]<<  Indata[3] << Indata[4]<< Indata[5]<< Indata[6]<< Indata[7];
 | 
			
		||||
 | 
			
		||||
    if (Indata[0]==2 && Indata[1]==(lastCommand | 0x80) )
 | 
			
		||||
        return 10;    //  OK
 | 
			
		||||
@@ -663,8 +664,8 @@ void dcBL_sendAddress(uint16_t blockNumber)
 | 
			
		||||
        dcBL_BlkCtr*=64;
 | 
			
		||||
        len=dcBL_sendFlashStartAddr2BL(dcBL_BlkCtr, buf);   // make command string
 | 
			
		||||
 | 
			
		||||
//qDebug()<<"dcBL_bl_sendAddress "<<buf[0]<<" "<<buf[1]<<" "<<buf[2]<<" "<<buf[3]<<" "
 | 
			
		||||
//         <<buf[4]<<" "<<buf[5]<<" "<<buf[6]<<" ";
 | 
			
		||||
        qDebug()<<"dcBL_bl_sendAddress "<<buf[0]<<" "<<buf[1]<<" "<<buf[2]<<" "<<buf[3]<<" "
 | 
			
		||||
         <<buf[4]<<" "<<buf[5]<<" "<<buf[6]<<" ";
 | 
			
		||||
 | 
			
		||||
        sendWRcmd_setSendBlock160(len, buf);        // send command to BL
 | 
			
		||||
    }
 | 
			
		||||
@@ -695,7 +696,7 @@ uint8_t dcBL_getFileBlock(uint16_t blockPointer, uint8_t *buf)
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
static uint16_t block2beSentNow, blTimeOutCounter;
 | 
			
		||||
static uint8_t  blChainStep, blChainResult, blRepeatCounter;
 | 
			
		||||
static uint8_t  blChainStep, blChainResult, blRepeatCounter, blRepeatOnErrorCtr;
 | 
			
		||||
 | 
			
		||||
bool dcBL_sendOneBlockCpl(uint16_t blockNumber)
 | 
			
		||||
{
 | 
			
		||||
@@ -712,6 +713,7 @@ bool dcBL_sendOneBlockCpl(uint16_t blockNumber)
 | 
			
		||||
    blChainResult=0;
 | 
			
		||||
    blTimeOutCounter=0;
 | 
			
		||||
    blRepeatCounter=0;
 | 
			
		||||
    blRepeatOnErrorCtr=0;
 | 
			
		||||
    return true;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
@@ -725,10 +727,17 @@ int8_t dcBL_getBlockResult(void)
 | 
			
		||||
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
void dcBL_cancelSending(void)
 | 
			
		||||
{
 | 
			
		||||
    blChainStep=99;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
char dcBL_cycle(void)
 | 
			
		||||
{
 | 
			
		||||
    // to be called cyclic every 100ms
 | 
			
		||||
    // to be called cyclic every 10ms
 | 
			
		||||
    // this step chain sends ONE data block (64byte) and repeats if neccesary
 | 
			
		||||
    // stop on timeout, 3xerror or success
 | 
			
		||||
 | 
			
		||||
    uint8_t buf[70], sendBuf[160], ret, sendLen;
 | 
			
		||||
 | 
			
		||||
    if (blChainStep==1)
 | 
			
		||||
@@ -737,9 +746,10 @@ char dcBL_cycle(void)
 | 
			
		||||
        if (block2beSentNow==0 || block2beSentNow==1024 || block2beSentNow==2048
 | 
			
		||||
                               || block2beSentNow==3072 || block2beSentNow==4096 )
 | 
			
		||||
        {
 | 
			
		||||
 | 
			
		||||
            epi_clrRawReceivedString();
 | 
			
		||||
            dcBL_sendAddress(block2beSentNow);
 | 
			
		||||
            blChainStep++;
 | 
			
		||||
            blTimeOutCounter=0;
 | 
			
		||||
            //qDebug()<<"dcBL_cycle sending address and wait for response";
 | 
			
		||||
            return 0;   // continue in 100ms
 | 
			
		||||
        } else
 | 
			
		||||
@@ -757,7 +767,8 @@ char dcBL_cycle(void)
 | 
			
		||||
 | 
			
		||||
            blChainStep=10;     // OK, continue with data
 | 
			
		||||
            blTimeOutCounter=0;
 | 
			
		||||
            return 0;   // continue in 100ms
 | 
			
		||||
            blRepeatOnErrorCtr=0;
 | 
			
		||||
            return 0;   // continue in 10ms
 | 
			
		||||
        }
 | 
			
		||||
        if (ret==1)
 | 
			
		||||
        {
 | 
			
		||||
@@ -770,28 +781,32 @@ char dcBL_cycle(void)
 | 
			
		||||
                blChainStep=1;      // repeat
 | 
			
		||||
            else
 | 
			
		||||
            {
 | 
			
		||||
                qDebug()<<"dcBL cancel, wrong resp. to addr";
 | 
			
		||||
                blChainResult=3;    // error timeout, no response from DC-BL
 | 
			
		||||
                blChainStep=99;
 | 
			
		||||
                return 0;
 | 
			
		||||
            }
 | 
			
		||||
            return 0;   // continue in 100ms
 | 
			
		||||
        }
 | 
			
		||||
        // noch keine Antwort:
 | 
			
		||||
        blTimeOutCounter++;
 | 
			
		||||
        if (blTimeOutCounter>=3)    // wait 3 cycles (3x100ms) for response
 | 
			
		||||
        if (blTimeOutCounter>=20)    // wait 5 cycles (5x10ms) for response
 | 
			
		||||
        {
 | 
			
		||||
            //qDebug()<<"dcBL_cycle TO";
 | 
			
		||||
 | 
			
		||||
            blChainResult=3;    // error timeout, no response from DC-BL
 | 
			
		||||
            blChainStep=99;
 | 
			
		||||
            return 0;
 | 
			
		||||
        } else
 | 
			
		||||
        {
 | 
			
		||||
            // ein oder zweimal keine Antwort
 | 
			
		||||
            blChainStep=1;      // repeat
 | 
			
		||||
 | 
			
		||||
            //qDebug()<<"dcBL_cycle no response";
 | 
			
		||||
 | 
			
		||||
            return 0;   // continue in 100ms
 | 
			
		||||
            blRepeatOnErrorCtr++;
 | 
			
		||||
            if (blRepeatOnErrorCtr<5)
 | 
			
		||||
            {
 | 
			
		||||
                // keine Antwort, nochmal senden
 | 
			
		||||
                blChainStep=1;      // repeat
 | 
			
		||||
                //qDebug()<<"dcBL_cycle no response";
 | 
			
		||||
                return 0;   // continue in 100ms
 | 
			
		||||
            } else
 | 
			
		||||
            {
 | 
			
		||||
                // 5x keine Antwort, Abbruch
 | 
			
		||||
                qDebug()<<"dcBL cancel, no resp. to addr";
 | 
			
		||||
                blChainResult=3;    // error timeout, no response from DC-BL
 | 
			
		||||
                blChainStep=99;
 | 
			
		||||
                return 0;
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
@@ -799,6 +814,7 @@ char dcBL_cycle(void)
 | 
			
		||||
    if (blChainStep==10)
 | 
			
		||||
    {
 | 
			
		||||
        // send data block or conclusion
 | 
			
		||||
        epi_clrRawReceivedString();
 | 
			
		||||
        if (block2beSentNow == dcBL_nrOfBlocks)
 | 
			
		||||
        {
 | 
			
		||||
            // very last blocknumber, send conclusion
 | 
			
		||||
@@ -808,14 +824,28 @@ char dcBL_cycle(void)
 | 
			
		||||
        {
 | 
			
		||||
            // send data...
 | 
			
		||||
            dcBL_getFileBlock(block2beSentNow, buf);
 | 
			
		||||
 | 
			
		||||
            //qDebug()<<"dcBL sending data block"<<block2beSentNow;
 | 
			
		||||
 | 
			
		||||
            sendLen=dcBL_prepareDC_BLcmd(0x22, 64, buf, sendBuf);   // pack into protocol frame
 | 
			
		||||
 | 
			
		||||
            //sendBuf[sendLen-1]=0;   // testweise ETX verbiegen um Fehlerreaktion zu testen
 | 
			
		||||
            // tested 2024.11.11: send without ETX, got no response, sending is repeated 4x, correct
 | 
			
		||||
 | 
			
		||||
            //   sendBuf[sendLen-2]=0;   // testweise crc verbiegen
 | 
			
		||||
            // tested 2024.11.11: send with wrong crc, got error-response, repeat 4x, OK
 | 
			
		||||
 | 
			
		||||
            //if (blRepeatCounter<3)
 | 
			
		||||
             //   sendBuf[sendLen-2]=0;   // testweise crc 3x verbiegen, bei 4. mal richtig senden
 | 
			
		||||
            // tested 2024.11.11: send with wrong crc, got error-response,  OK
 | 
			
		||||
 | 
			
		||||
            //sendBuf[50]=0;   // testweise nur die Haelft senden
 | 
			
		||||
            // tested 2024.11.11: send incomplete, is repeated 4x then stop, everything correct
 | 
			
		||||
 | 
			
		||||
            sendWRcmd_setSendBlock160(sendLen, sendBuf);            // send up to 140 bytes
 | 
			
		||||
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        blChainStep++;
 | 
			
		||||
        blTimeOutCounter=0;
 | 
			
		||||
    } else
 | 
			
		||||
 | 
			
		||||
    if (blChainStep==11)
 | 
			
		||||
@@ -829,36 +859,44 @@ char dcBL_cycle(void)
 | 
			
		||||
            blChainResult=1;        // block sent succesful
 | 
			
		||||
            if (block2beSentNow == dcBL_nrOfBlocks)
 | 
			
		||||
                blChainResult=2;    // transfer complete
 | 
			
		||||
 | 
			
		||||
            blTimeOutCounter=0;
 | 
			
		||||
            return 0;   // continue in 100ms
 | 
			
		||||
            blRepeatOnErrorCtr=0;
 | 
			
		||||
        return 0;   // continue in 10ms
 | 
			
		||||
        }
 | 
			
		||||
        if (ret==1)
 | 
			
		||||
        {
 | 
			
		||||
            // we got response but BL reports an error
 | 
			
		||||
            blTimeOutCounter=0;
 | 
			
		||||
            blRepeatCounter++;
 | 
			
		||||
            if (blRepeatCounter<3)
 | 
			
		||||
            if (blRepeatCounter<5)
 | 
			
		||||
                blChainStep=10;      // repeat
 | 
			
		||||
            else
 | 
			
		||||
            {
 | 
			
		||||
                qDebug()<<"dcBL cancel, wrong resp to datablock";
 | 
			
		||||
                blChainResult=3;    // error timeout, no response from DC-BL
 | 
			
		||||
                blChainStep=99;
 | 
			
		||||
                return 0;
 | 
			
		||||
            }
 | 
			
		||||
            return 0;   // continue in 100ms
 | 
			
		||||
            return 0;   // continue in 10ms
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        // noch keine Antwort:
 | 
			
		||||
        blTimeOutCounter++;
 | 
			
		||||
        if (blTimeOutCounter>=3)    // wait 3 cycles (3x100ms) for response
 | 
			
		||||
        {
 | 
			
		||||
            blChainResult=3;    // error timeout, no response from DC-BL
 | 
			
		||||
            blChainStep=99;
 | 
			
		||||
            return 0;
 | 
			
		||||
        } else
 | 
			
		||||
        {
 | 
			
		||||
            // ein oder zweimal keine Antwort
 | 
			
		||||
            blChainStep=10;      // repeat
 | 
			
		||||
            return 0;   // continue in 100ms
 | 
			
		||||
        if (blTimeOutCounter>=20)    // wait 200ms for response, normal value=40...70ms
 | 
			
		||||
        {        
 | 
			
		||||
            // no response after 50ms
 | 
			
		||||
           blRepeatOnErrorCtr++;
 | 
			
		||||
            if (blRepeatOnErrorCtr<5)
 | 
			
		||||
            {
 | 
			
		||||
                blChainStep=10;      // repeat
 | 
			
		||||
                return 0;           // continue in 10ms
 | 
			
		||||
            } else
 | 
			
		||||
            {
 | 
			
		||||
                qDebug()<<"dcBL cancel, no resp to datablock";
 | 
			
		||||
               blChainResult=3;    // error timeout, no response from DC-BL
 | 
			
		||||
               blChainStep=99;
 | 
			
		||||
               return 0;
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -1,320 +0,0 @@
 | 
			
		||||
#include "download_thread.h"
 | 
			
		||||
#include "shared_mem_buffer.h"
 | 
			
		||||
#include "hwapi.h"
 | 
			
		||||
 | 
			
		||||
#include <QDebug>
 | 
			
		||||
#include <QDateTime>
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
DownloadThread::DownloadThread(hwinf *hw)
 | 
			
		||||
  : m_hw(hw)
 | 
			
		||||
  , m_fileToDownload(m_hw->dcDownloadFileName()) {
 | 
			
		||||
    // connect(this, &QThread::finished,
 | 
			
		||||
    //        dynamic_cast<QObject const *>(m_hw), &QThread::deleteLater);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
DownloadThread::~DownloadThread() {
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/*
 | 
			
		||||
 ///////////////////////////////////////////////////////////////////////////////
 | 
			
		||||
 //
 | 
			
		||||
 //                        USING THE DC BOOTLOADER
 | 
			
		||||
 //
 | 
			
		||||
 ///////////////////////////////////////////////////////////////////////////////
 | 
			
		||||
 | 
			
		||||
 1  :   bl_reboot()     // send to application, want DC2 to reset (in order to
 | 
			
		||||
                        // start the bootloader)
 | 
			
		||||
                        //
 | 
			
		||||
                        // NOTE: this function is NOT reliable !!! Sometimes it
 | 
			
		||||
                        // simply does not work, in which case bl_startBL,
 | 
			
		||||
                        // bl_checkBL and bl_isUp do not work as well.
 | 
			
		||||
                        // Alas, there is no feedback if bl_reboot worked!
 | 
			
		||||
                        //
 | 
			
		||||
                        // NOTE: this function can be called only once per
 | 
			
		||||
                        // minute, because once called again, the controller
 | 
			
		||||
                        // performs some self-checks consuming some time.
 | 
			
		||||
                        //
 | 
			
		||||
                        // NOTE: after a successful bl_reboot(), the device is
 | 
			
		||||
                        // waiting about 4 seconds in the bootloader. To stay in
 | 
			
		||||
                        // the bootloader, we have to send the command
 | 
			
		||||
                        // bl_startBL(), which is kind of a misnomer, as it
 | 
			
		||||
                        // should be bl_doNotLeaveBL().
 | 
			
		||||
                        //
 | 
			
		||||
 2  :   bl_startBL():   // send within 4s after DC power-on, otherwise
 | 
			
		||||
                        // bootloader is left.
 | 
			
		||||
                        //
 | 
			
		||||
                        // NOTE: a running bootloader is a MUST for the download
 | 
			
		||||
                        // process of a device controller firmware as it does
 | 
			
		||||
                        // the actual writing of the memory (the bl_reboot()
 | 
			
		||||
                        // from above erases the available memory).
 | 
			
		||||
                        //
 | 
			
		||||
 3  :   bl_check():     // send command to verify if bl is up
 | 
			
		||||
                        //
 | 
			
		||||
                        // NOTE: this command is kind of a request that we want
 | 
			
		||||
                        // to check if the bootloader is up. The device
 | 
			
		||||
                        // (actually the bootloader) responds with its version.
 | 
			
		||||
                        //
 | 
			
		||||
 4  :   bl_isUp():      // returns true if bl is up and running
 | 
			
		||||
                        //
 | 
			
		||||
                        // NOTE: we know what the bootloader version actually is
 | 
			
		||||
                        // as the bootloader does not change. By comparing the
 | 
			
		||||
                        // string received in the previous step with this known
 | 
			
		||||
                        // version string we know if the bootloader is up.
 | 
			
		||||
                        //
 | 
			
		||||
                        // NOTE FOR ALL PREVIOUS STEPS: execute them in their
 | 
			
		||||
                        // own slots each to be sure to receive any possible
 | 
			
		||||
                        // responds from the device.
 | 
			
		||||
                        //
 | 
			
		||||
 5  :   bl_sendAddress(blockNumber)
 | 
			
		||||
                        // send start address, nr of 64-byte block, start with 0
 | 
			
		||||
                        // will be sent only for following block-numbers:
 | 
			
		||||
                        // 0, 1024, 2048, 3072 and 4096, so basically every
 | 
			
		||||
                        // 64kByte.
 | 
			
		||||
                        // for other addresses nothing happens
 | 
			
		||||
 | 
			
		||||
 6  :   bl_wasSendingAddOK()
 | 
			
		||||
                        // return val:  0: no response by now
 | 
			
		||||
                        //              1: error
 | 
			
		||||
                        //             10: OK
 | 
			
		||||
 | 
			
		||||
 7  :   bl_sendDataBlock()
 | 
			
		||||
                        // send 64 byte from bin file
 | 
			
		||||
 | 
			
		||||
 8  :   bl_sendLastBlock()
 | 
			
		||||
                        // send this command after all data are transferred
 | 
			
		||||
 | 
			
		||||
 9  :   bl_wasSendingDataOK()
 | 
			
		||||
                        // return val:  0: no response by now
 | 
			
		||||
                        //              1: error
 | 
			
		||||
                        //             10: OK
 | 
			
		||||
 | 
			
		||||
 10 :   bl_stopBL()     // leave bl and start (the new) application
 | 
			
		||||
                        //
 | 
			
		||||
                        // NOTE: this function MUST work under all conditions.
 | 
			
		||||
                        // Alas, there is no direct result for this command, so
 | 
			
		||||
                        // the only way of knowing it was successful is to ask
 | 
			
		||||
                        // the device if the bootloader is still running.
 | 
			
		||||
                        // There is no problem to repeat this command until the
 | 
			
		||||
                        // bootloader is really not running anymore.
 | 
			
		||||
 */
 | 
			
		||||
void DownloadThread::run() {
 | 
			
		||||
    // download thread running in ca-master sends the dc-file down to firmware
 | 
			
		||||
    // TODO: send the json files as well
 | 
			
		||||
 | 
			
		||||
    m_hw->dcDownloadRequestAck();
 | 
			
		||||
 | 
			
		||||
    qCritical() << "DownloadThread::run(): DOWNLOAD THREAD STARTED";
 | 
			
		||||
 | 
			
		||||
    // load binary device controller file into memory
 | 
			
		||||
    QByteArray ba = loadBinaryDCFile(m_hw->dcDownloadFileName());
 | 
			
		||||
    if (ba.size() > 0) {
 | 
			
		||||
        uint16_t const totalBlocks = (((ba.size())%64)==0) ? (ba.size()/64) : (ba.size()/64)+1;
 | 
			
		||||
        m_hw->dcDownloadSetTotalBlockNumber(totalBlocks);
 | 
			
		||||
 | 
			
		||||
        // fill last block of data to be sent with 0xFF
 | 
			
		||||
        ba = ba.leftJustified(totalBlocks*64, (char)(0xFF));
 | 
			
		||||
 | 
			
		||||
        resetDeviceController();
 | 
			
		||||
        if (startBootloader()) {
 | 
			
		||||
 | 
			
		||||
            qCritical() << "DownloadThread::run(): TOTAL NUMBER OF BYTES TO SEND TO DC" << ba.size();
 | 
			
		||||
            qCritical() << "DownloadThread::run(): TOTAL NUMBER OF BLOCKS" << totalBlocks;
 | 
			
		||||
 | 
			
		||||
            int currentBlock = 0;
 | 
			
		||||
            DownloadResult res = DownloadResult::OK;
 | 
			
		||||
            qCritical() << "64-byte block " << currentBlock;
 | 
			
		||||
            while (res != DownloadResult::ERROR &&  currentBlock < totalBlocks) {
 | 
			
		||||
                if ((res = sendNextAddress(currentBlock)) != DownloadResult::ERROR) {
 | 
			
		||||
                    if ((res = sendNextDataBlock(ba, currentBlock)) != DownloadResult::ERROR) {
 | 
			
		||||
                        m_hw->dcDownloadSetCurrentBlockNumber(currentBlock);
 | 
			
		||||
                        currentBlock += 1;
 | 
			
		||||
                    }
 | 
			
		||||
                }
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            qCritical() << "DownloadThread::run(): last 64-byte block %04d" << currentBlock;
 | 
			
		||||
 | 
			
		||||
            int const rest = ba.size() % 64;
 | 
			
		||||
            int const offset = ba.size() - rest;
 | 
			
		||||
            char const *startAddress = ba.constData() + offset;
 | 
			
		||||
 | 
			
		||||
            if (rest > 0) {
 | 
			
		||||
                // SHOULD NEVER HAPPEN !!!
 | 
			
		||||
                uint8_t local[66];
 | 
			
		||||
                memset(local, 0xFF, sizeof(local));
 | 
			
		||||
                memcpy(local, startAddress, rest);
 | 
			
		||||
                qCritical() << "DownloadThread::run(): ERROR SEND REMAINING" << rest << "BYTES";
 | 
			
		||||
                m_hw->bl_sendDataBlock(64, local);
 | 
			
		||||
            } else {
 | 
			
		||||
                m_hw->bl_sendLastBlock();
 | 
			
		||||
                m_hw->dcDownloadSetCurrentBlockNumber(currentBlock);
 | 
			
		||||
            }
 | 
			
		||||
            qCritical() << "DownloadThread::run(): last result" << (int)sendStatus(m_hw->bl_wasSendingDataOK());
 | 
			
		||||
        }
 | 
			
		||||
        stopBootloader();   // there is no harm in stopping the bootloader even
 | 
			
		||||
    }                       // if it was not started at all
 | 
			
		||||
 | 
			
		||||
#if 0
 | 
			
		||||
    // test code:
 | 
			
		||||
    uint16_t const totalBlocks = 100;
 | 
			
		||||
    m_hw->dcDownloadSetTotalBlockNumber(totalBlocks);
 | 
			
		||||
 | 
			
		||||
    for (uint16_t currentBlock = 0; currentBlock <= totalBlocks; ++currentBlock) {
 | 
			
		||||
        m_hw->dcDownloadSetCurrentBlockNumber(currentBlock);
 | 
			
		||||
        QThread::msleep(100);
 | 
			
		||||
    }
 | 
			
		||||
#endif
 | 
			
		||||
 | 
			
		||||
    m_hw->dcDownloadSetRunning(false);
 | 
			
		||||
    m_hw->dcDownloadSetFinished(true);
 | 
			
		||||
 | 
			
		||||
    qCritical() << QDateTime::currentDateTime().toString(Qt::ISODate) + "DOWNLOAD THREAD FINISHED";
 | 
			
		||||
 | 
			
		||||
    // the object deletes itself ! This is the last line in run().
 | 
			
		||||
    // Never touch the object after this statement
 | 
			
		||||
    // m_hw->dcDownloadThreadFinalize(this);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
DownloadThread::DownloadResult DownloadThread::sendStatus(int ret) const {
 | 
			
		||||
    switch (ret) {                  // return values of dc are:
 | 
			
		||||
    case 0:                         // 0: no answer by now
 | 
			
		||||
        return DownloadResult::NOP; // 1: error
 | 
			
		||||
    case 10:                        // 10: success
 | 
			
		||||
        return DownloadResult::OK;
 | 
			
		||||
    default:;
 | 
			
		||||
    }
 | 
			
		||||
    return DownloadResult::ERROR;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
DownloadThread::DownloadResult
 | 
			
		||||
DownloadThread::sendNextAddress(int bNum) const {
 | 
			
		||||
    // sends address only if blockNumber is one of 0, 1024, 2048, 3072, 4096
 | 
			
		||||
    int noAnswerCount = 0;
 | 
			
		||||
    int errorCount = 0;
 | 
			
		||||
    if ( bNum==0 || bNum==1024 || bNum==2048 || bNum==3072 || bNum==4096 ) {
 | 
			
		||||
        // qDebug() << "addr-block" << bNum << "...";
 | 
			
		||||
        while (noAnswerCount <= 250) {
 | 
			
		||||
            m_hw->bl_sendAddress(bNum);
 | 
			
		||||
            QThread::msleep(100);
 | 
			
		||||
            DownloadResult const res = sendStatus(m_hw->bl_wasSendingAddOK());
 | 
			
		||||
            if (res != DownloadResult::NOP) {
 | 
			
		||||
                if (res == DownloadResult::ERROR) {
 | 
			
		||||
                    if (++errorCount >= 10) {
 | 
			
		||||
                        qCritical() << "addr-block" << bNum << "...FAILED";
 | 
			
		||||
                        return res;
 | 
			
		||||
                    }
 | 
			
		||||
                } else { // res == DownloadResult::OK
 | 
			
		||||
                    // qInfo() << "addr-block" << bNum << "...OK";
 | 
			
		||||
 | 
			
		||||
                        // TODO: hier ins shared-mem schreiben
 | 
			
		||||
 | 
			
		||||
                    return res;
 | 
			
		||||
                }
 | 
			
		||||
            } else {
 | 
			
		||||
                noAnswerCount += 1; // no answer by now
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
        // wait max. about 3 seconds
 | 
			
		||||
        return DownloadResult::TIMEOUT;
 | 
			
		||||
    }
 | 
			
		||||
    // blockNumber is not one of 0, 1024, 2048, 3072, 4096 -> do nothing
 | 
			
		||||
    return DownloadResult::NOP;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
DownloadThread::DownloadResult
 | 
			
		||||
DownloadThread::sendNextDataBlock(QByteArray const &binary, int bNum) const {
 | 
			
		||||
    uint8_t local[66];
 | 
			
		||||
    int const bAddr = bNum * 64;
 | 
			
		||||
    int noAnswerCount = 0;
 | 
			
		||||
    int errorCount = 0;
 | 
			
		||||
 | 
			
		||||
    memcpy(local, binary.constData() + bAddr, 64);
 | 
			
		||||
    local[64] = local[65] = 0x00;
 | 
			
		||||
 | 
			
		||||
    // QByteArray b((const char *)(&local[0]), 64);
 | 
			
		||||
    // qCritical() << "SNDB" << bNum << b.size() << b.toHex();
 | 
			
		||||
 | 
			
		||||
    while (noAnswerCount <= 250) {
 | 
			
		||||
        m_hw->bl_sendDataBlock(64, local);
 | 
			
		||||
        QThread::msleep(10);
 | 
			
		||||
        DownloadResult const res = sendStatus(m_hw->bl_wasSendingDataOK());
 | 
			
		||||
        if (res != DownloadResult::NOP) {
 | 
			
		||||
            if (res == DownloadResult::ERROR) {
 | 
			
		||||
                if (++errorCount >= 10) {
 | 
			
		||||
                    qCritical() << "data for block" << bNum << "...FAILED";
 | 
			
		||||
                    return res;
 | 
			
		||||
                }
 | 
			
		||||
            } else {
 | 
			
		||||
                // qInfo() << "data for block" << bNum << "OK";
 | 
			
		||||
 | 
			
		||||
                    // TODO: hier ins shared mem schreiben
 | 
			
		||||
 | 
			
		||||
                return res;
 | 
			
		||||
            }
 | 
			
		||||
        } else {
 | 
			
		||||
            noAnswerCount += 1; // no answer by now
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
    // wait max. about 3 seconds
 | 
			
		||||
    return DownloadResult::TIMEOUT;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
bool DownloadThread::startBootloader() const {
 | 
			
		||||
    qDebug() << "starting bootloader...";
 | 
			
		||||
    int nTry = 5;
 | 
			
		||||
    while (--nTry >= 0) {
 | 
			
		||||
        m_hw->bl_startBL();
 | 
			
		||||
        QThread::msleep(5000);
 | 
			
		||||
        m_hw->bl_checkBL();
 | 
			
		||||
        if (m_hw->bl_isUp()) {
 | 
			
		||||
            qInfo() << "starting bootloader...OK";
 | 
			
		||||
            QThread::msleep(5000);
 | 
			
		||||
            return true;
 | 
			
		||||
        } else {
 | 
			
		||||
            qCritical() << "bootloader not up (" << nTry << ")";
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
    qCritical() << "starting bootloader...FAILED";
 | 
			
		||||
    return false;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
bool DownloadThread::stopBootloader() const {
 | 
			
		||||
    qDebug() << "stopping bootloader...";
 | 
			
		||||
    int nTry = 5;
 | 
			
		||||
    while (--nTry >= 0) {
 | 
			
		||||
        m_hw->bl_stopBL();
 | 
			
		||||
        QThread::msleep(500);
 | 
			
		||||
        if (!m_hw->bl_isUp()) {
 | 
			
		||||
            qInfo() << "stopping bootloader...OK";
 | 
			
		||||
            return true;
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
    qCritical() << "stopping bootloader...FAILED";
 | 
			
		||||
    return false;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
bool DownloadThread::resetDeviceController() const {
 | 
			
		||||
    qDebug() << "resetting device controller...";
 | 
			
		||||
    m_hw->bl_rebootDC();
 | 
			
		||||
    // wait maximally 3 seconds, before starting bootloader
 | 
			
		||||
    QThread::sleep(1);
 | 
			
		||||
    qInfo() << "resetting device controller...OK";
 | 
			
		||||
    return true;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
QByteArray DownloadThread::loadBinaryDCFile(QString filename) const {
 | 
			
		||||
    qDebug() << "loading dc binary" << filename << "...";
 | 
			
		||||
 | 
			
		||||
    QFile file(filename); // closed in destructor call
 | 
			
		||||
    if (!file.exists()) {
 | 
			
		||||
        qCritical() << file.fileName() << "does not exist";
 | 
			
		||||
        return QByteArray();
 | 
			
		||||
    }
 | 
			
		||||
    if (!file.open(QIODevice::ReadOnly)) {
 | 
			
		||||
        qCritical() << "cannot open file" << file.fileName();
 | 
			
		||||
        return QByteArray();
 | 
			
		||||
    }
 | 
			
		||||
    qInfo() << "loading dc binary" << filename << "...OK";
 | 
			
		||||
    return file.readAll();
 | 
			
		||||
}
 | 
			
		||||
@@ -9,8 +9,6 @@
 | 
			
		||||
*/
 | 
			
		||||
 | 
			
		||||
#include "hwapi.h"
 | 
			
		||||
#include "download_thread.h"
 | 
			
		||||
#include "reporting_thread.h"
 | 
			
		||||
 | 
			
		||||
#include <cstring>
 | 
			
		||||
#include <QThread>
 | 
			
		||||
@@ -325,7 +323,14 @@ bool hwapi::dc_isPortOpen(void) const
 | 
			
		||||
void hwapi::dc_autoRequest(bool on) const
 | 
			
		||||
{
 | 
			
		||||
    // automatically request ALL digital and analog sensors, get time/date, get status information
 | 
			
		||||
 | 
			
		||||
    // call this with on=false before power down !!   new, 8.10.2024TS
 | 
			
		||||
 | 
			
		||||
    epi_startEmmision(on);
 | 
			
		||||
 | 
			
		||||
    if (!on)
 | 
			
		||||
         gpi_storeDcDataValid(0);   // new, 8.10.2024TS
 | 
			
		||||
    // right after wake-up from power down the DC data are not yet valid
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@@ -2625,6 +2630,8 @@ void hwapi::bl_stopBL(void) const     // tested 26.09.2023
 | 
			
		||||
    len=dcBL_exitBL(buf);
 | 
			
		||||
    sendWRcmd_setSendBlock160(len, buf);
 | 
			
		||||
    epi_setNowIsBootload(false);
 | 
			
		||||
    runProcess->resetBLvari();
 | 
			
		||||
    dcBL_cancelSending();
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@@ -4441,11 +4448,6 @@ bool hwapi::dcDownloadRunning() const {
 | 
			
		||||
    return false;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
void hwapi::dcDownloadThreadFinalize(DownloadThread *dthread) {
 | 
			
		||||
    delete dthread;
 | 
			
		||||
    m_downloadThread = nullptr;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
bool hwapi::dcDownloadFinished() {
 | 
			
		||||
    SharedMem const *data = SharedMem::getDataConst();
 | 
			
		||||
    if (data) {
 | 
			
		||||
@@ -4465,73 +4467,6 @@ bool hwapi::dcDownloadFinished() {
 | 
			
		||||
    return false;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
// download thread
 | 
			
		||||
 | 
			
		||||
bool hwapi::dcDownloadThreadStart() {
 | 
			
		||||
    m_downloadThread = new DownloadThread(this);
 | 
			
		||||
    if (m_downloadThread) {
 | 
			
		||||
        m_downloadThread->start();
 | 
			
		||||
        int cnt  = 10;
 | 
			
		||||
        while (--cnt > 0 && !dcDownloadThreadRunning()) {
 | 
			
		||||
            QThread::msleep(200);
 | 
			
		||||
        }
 | 
			
		||||
        return (cnt > 0);
 | 
			
		||||
    }
 | 
			
		||||
    return false;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
bool hwapi::dcDownloadThreadRunning() const {
 | 
			
		||||
    return (dcDownloadGetRunning() == true)
 | 
			
		||||
        && (dcDownloadGetFinished() == false);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
bool hwapi::dcDownloadThreadFinished() const {
 | 
			
		||||
    return (dcDownloadThreadRunning() == false);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
// report thread
 | 
			
		||||
bool hwapi::dcDownloadReportThreadStart() { // only start reporting thread
 | 
			
		||||
    int cnt = 10;                           // if download thread is running
 | 
			
		||||
    while (--cnt > 0 && !dcDownloadRunning()) {
 | 
			
		||||
        QThread::msleep(500);
 | 
			
		||||
    }
 | 
			
		||||
    if (cnt > 0) {
 | 
			
		||||
        m_reportingThread = new ReportingThread(this);
 | 
			
		||||
        if (m_reportingThread) {
 | 
			
		||||
            m_reportingThread->start();
 | 
			
		||||
            cnt  = 10;
 | 
			
		||||
            while (--cnt > 0 && !dcDownloadReportThreadRunning()) {
 | 
			
		||||
                QThread::msleep(200);
 | 
			
		||||
            }
 | 
			
		||||
            return (cnt > 0);
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
    return false;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
bool hwapi::dcDownloadReportThreadRunning() const {
 | 
			
		||||
    return m_reportingThread ? m_reportingThread->isRunning() : false;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
void hwapi::dcDownloadReportThreadFinalize() {
 | 
			
		||||
    if (m_reportingThread) {
 | 
			
		||||
        if (m_reportingThread->isFinished()) {
 | 
			
		||||
            delete m_reportingThread;
 | 
			
		||||
            m_reportingThread = nullptr;
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
void hwapi::dcDownloadReportThreadQuit() {
 | 
			
		||||
    if (m_reportingThread) {
 | 
			
		||||
        m_reportingThread->quit();
 | 
			
		||||
    }
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
bool hwapi::dcDownloadReportThreadFinished() const {
 | 
			
		||||
    return m_reportingThread ? m_reportingThread->isFinished() : false;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
bool hwapi::dcDownloadReportStart() const {
 | 
			
		||||
    int cnt = 10;
 | 
			
		||||
 
 | 
			
		||||
@@ -618,8 +618,10 @@ bool T_prot::getReceivedInData(uint8_t  *SlavAddr, uint16_t *readSrc, uint16_t *
 | 
			
		||||
    return INdataValid;           // nur true wenn CommandState OK und readState OK
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
void T_prot::flushPort(void)
 | 
			
		||||
{
 | 
			
		||||
    mySerialPort->flushPort();
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -1,155 +0,0 @@
 | 
			
		||||
#include "reporting_thread.h"
 | 
			
		||||
#include "shared_mem_buffer.h"
 | 
			
		||||
#include "hwapi.h"
 | 
			
		||||
 | 
			
		||||
#include <QDateTime>
 | 
			
		||||
#include <QDebug>
 | 
			
		||||
 | 
			
		||||
ReportingThread::ReportingThread(hwapi *hw)
 | 
			
		||||
  : m_hw(hw)
 | 
			
		||||
  , m_fileToDownload(m_hw->dcDownloadFileName()) {
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
ReportingThread::~ReportingThread() {
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
// download thread running in ca-slave sends reports of download process to
 | 
			
		||||
// each component which has connects for the corresponding signals.
 | 
			
		||||
void ReportingThread::run() {
 | 
			
		||||
 | 
			
		||||
    qCritical() << QDateTime::currentDateTime() << "START DOWNLOAD THREAD";
 | 
			
		||||
 | 
			
		||||
    static QString report("");
 | 
			
		||||
 | 
			
		||||
    int cnt = 5;
 | 
			
		||||
    while (!m_hw->dcDownloadGetRunning()) {
 | 
			
		||||
        if (--cnt > 0) {
 | 
			
		||||
            report =  QString("%1 waiting for download to start %2")
 | 
			
		||||
                            .arg(QDateTime::currentDateTime().toString(Qt::ISODate))
 | 
			
		||||
                            .arg(cnt);
 | 
			
		||||
            qCritical() << __LINE__ << "STATUS" << report;
 | 
			
		||||
            emit m_hw->hwapi_reportDCDownloadStatus(report);
 | 
			
		||||
            QThread::sleep(1);
 | 
			
		||||
        } else break;
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
#if 0
 | 
			
		||||
    if (cnt == 0) {
 | 
			
		||||
        m_hw->dcDownloadResetRequest();
 | 
			
		||||
        status = QString("%1 reset download request")
 | 
			
		||||
                        .arg(QDateTime::currentDateTime().toString(Qt::ISODate));
 | 
			
		||||
        qCritical() << __LINE__ << "STATUS" << status;
 | 
			
		||||
        emit m_hw->hwapi_reportDCDownloadStatus(status);
 | 
			
		||||
 | 
			
		||||
        cnt = 5;
 | 
			
		||||
        while (!m_hw->dcDownloadRunning()) {
 | 
			
		||||
            if (--cnt > 0) {
 | 
			
		||||
                QThread::sleep(1);
 | 
			
		||||
            } else break;
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        if (cnt == 0) {
 | 
			
		||||
            status = QString("%1 download request failure")
 | 
			
		||||
                            .arg(QDateTime::currentDateTime().toString(Qt::ISODate));
 | 
			
		||||
            qCritical() << __LINE__ << "STATUS" << status;
 | 
			
		||||
            emit m_hw->hwapi_reportDCDownloadFailure(status);
 | 
			
		||||
            return;
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    uint16_t const tnr = 1750;
 | 
			
		||||
    uint16_t cnr = 0;
 | 
			
		||||
 | 
			
		||||
    while (cnr <= tnr) {
 | 
			
		||||
        QThread::msleep(100);
 | 
			
		||||
        QString report("");
 | 
			
		||||
 | 
			
		||||
        if (cnr > 0) {
 | 
			
		||||
            double percent = ((double)cnr / (double)tnr) * 100.0;
 | 
			
		||||
            report = QString(": total blocks %1, current block %2 [%3]")
 | 
			
		||||
                    .arg(tnr).arg(cnr).arg(percent, 0, 'f', 2);
 | 
			
		||||
        } else {
 | 
			
		||||
            report = QString(": total blocks %1, current block %2 [0]")
 | 
			
		||||
                    .arg(tnr).arg(cnr);
 | 
			
		||||
        }
 | 
			
		||||
        status = QDateTime::currentDateTime().toString(Qt::ISODate) + report;
 | 
			
		||||
 | 
			
		||||
        qCritical() << "STATUS" << status;
 | 
			
		||||
 | 
			
		||||
        emit m_hw->hwapi_reportDCDownloadStatus(status);
 | 
			
		||||
        cnr += 1;
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    if (tnr == cnr) {
 | 
			
		||||
        m_hw->hwapi_reportDCDownloadSuccess(
 | 
			
		||||
            QString("SUCCESS DOWNLOADING") + m_fileToDownload);
 | 
			
		||||
    } else {
 | 
			
		||||
        m_hw->hwapi_reportDCDownloadFailure(
 | 
			
		||||
            QString("ERROR DOWNLOADING %1 (total blocks=%2, sent blocks=%3)")
 | 
			
		||||
                .arg(m_fileToDownload).arg(tnr).arg(cnr));
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
#endif
 | 
			
		||||
 | 
			
		||||
    uint16_t const totalBlocks = m_hw->dcDownloadGetTotalBlockNumber();
 | 
			
		||||
 | 
			
		||||
    qCritical() << QDateTime::currentDateTime() << "TOTAL BLOCKS" << totalBlocks;
 | 
			
		||||
 | 
			
		||||
    if (totalBlocks) {
 | 
			
		||||
        qint64 const start = QDateTime::currentMSecsSinceEpoch();
 | 
			
		||||
        double durationMillis = 0;
 | 
			
		||||
        uint16_t currentBlockNumber = 0;
 | 
			
		||||
 | 
			
		||||
        while (m_hw->dcDownloadGetRunning()) {
 | 
			
		||||
            currentBlockNumber = m_hw->dcDownloadGetCurrentBlockNumber();
 | 
			
		||||
 | 
			
		||||
            durationMillis += QDateTime::currentMSecsSinceEpoch() - start;
 | 
			
		||||
 | 
			
		||||
            double const timeAveragePerBlock = (currentBlockNumber > 0) ? (durationMillis / currentBlockNumber) : durationMillis;
 | 
			
		||||
            double const estimatedSecondsLeft = (timeAveragePerBlock * (totalBlocks - currentBlockNumber)) / 1000.0;
 | 
			
		||||
 | 
			
		||||
            double percent = ((double)currentBlockNumber / (double)totalBlocks) * 100.0;
 | 
			
		||||
            report = QString(": total blocks %1, current block %2 [%3] (est. time left: %4s)")
 | 
			
		||||
                        .arg(totalBlocks)
 | 
			
		||||
                        .arg(currentBlockNumber)
 | 
			
		||||
                        .arg(percent, 0, 'f', 2)
 | 
			
		||||
                        .arg(estimatedSecondsLeft, 0, 'f', 2);
 | 
			
		||||
 | 
			
		||||
            qCritical() << "RT report" << report;
 | 
			
		||||
 | 
			
		||||
            emit m_hw->hwapi_reportDCDownloadStatus(report);
 | 
			
		||||
            QThread::msleep(100);
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        QThread::msleep(100);
 | 
			
		||||
 | 
			
		||||
        if (totalBlocks == currentBlockNumber) {
 | 
			
		||||
            m_hw->hwapi_reportDCDownloadSuccess(
 | 
			
		||||
                QString("SUCCESS DOWNLOADING") + m_fileToDownload);
 | 
			
		||||
        } else {
 | 
			
		||||
            m_hw->hwapi_reportDCDownloadFailure(
 | 
			
		||||
                QString("ERROR DOWNLOADING %1 (total blocks=%2, sent blocks=%3)")
 | 
			
		||||
                    .arg(m_fileToDownload).arg(totalBlocks).arg(currentBlockNumber));
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    qCritical() << QDateTime::currentDateTime() << __PRETTY_FUNCTION__
 | 
			
		||||
                << QString("line=%1 REPORT THREAD ABOUT TO FINISH").arg(__LINE__);
 | 
			
		||||
 | 
			
		||||
    cnt = 10;
 | 
			
		||||
 | 
			
		||||
    bool running = m_hw->dcDownloadGetRunning();
 | 
			
		||||
    bool finished = m_hw->dcDownloadGetFinished();
 | 
			
		||||
 | 
			
		||||
    while (--cnt > 0 && (running && !finished)) {
 | 
			
		||||
        qCritical() << QDateTime::currentDateTime() << __PRETTY_FUNCTION__
 | 
			
		||||
                    << QString("line=%1 REPORT THREAD: WAIT FOR END OF DOWNLOAD THREAD %2 %3 (%4)")
 | 
			
		||||
            .arg(__LINE__).arg(running).arg(finished).arg(cnt);
 | 
			
		||||
        QThread::sleep(1);
 | 
			
		||||
        running = m_hw->dcDownloadGetRunning();
 | 
			
		||||
        finished = m_hw->dcDownloadGetFinished();
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    qCritical() << QDateTime::currentDateTime() << __PRETTY_FUNCTION__
 | 
			
		||||
                << QString("line=%1 FINISH REPORT THREAD").arg(__LINE__);
 | 
			
		||||
}
 | 
			
		||||
							
								
								
									
										191
									
								
								src/runProc.cpp
									
									
									
									
									
								
							
							
						
						
									
										191
									
								
								src/runProc.cpp
									
									
									
									
									
								
							@@ -9,7 +9,7 @@ static uint8_t  hwapi_cash_lastCollectionState;
 | 
			
		||||
static uint8_t  hwapi_paymentStarted;
 | 
			
		||||
static uint8_t  hwapi_lastDoorState;
 | 
			
		||||
static uint8_t  bl_startupStep;
 | 
			
		||||
 | 
			
		||||
static uint8_t  runProc_BLisStarted;
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
T_runProc::T_runProc()
 | 
			
		||||
@@ -643,6 +643,7 @@ void T_runProc::bl_completeStart(void)
 | 
			
		||||
    bl_startupStep=1;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
bool T_runProc::bl_performComplStart(void)
 | 
			
		||||
{
 | 
			
		||||
    bool result;
 | 
			
		||||
@@ -727,7 +728,12 @@ bool T_runProc::bl_performComplStart(void)
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
void T_runProc::resetBLvari(void)
 | 
			
		||||
{
 | 
			
		||||
    // reset with BL-stop command
 | 
			
		||||
    runProc_BLisStarted=0;
 | 
			
		||||
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
// new from 21.5.24 ..................................................................
 | 
			
		||||
@@ -1328,6 +1334,7 @@ void T_runProc::sub_changeStyle(char *valueStr)
 | 
			
		||||
                // 10th:height  1th=width
 | 
			
		||||
    "styl":"align c"	// 'l' 'c' 'r'    // left  center  right
 | 
			
		||||
    "styl":"density25";	//  0....[25]...50   0=blass
 | 
			
		||||
    "styl":"csiz 12"    // character size 6..20, new 26.7.2024
 | 
			
		||||
    */
 | 
			
		||||
 | 
			
		||||
    uint8_t val;
 | 
			
		||||
@@ -1397,7 +1404,16 @@ void T_runProc::sub_changeStyle(char *valueStr)
 | 
			
		||||
        val=uint8_t(tslib_atol(&valueStr[7]));
 | 
			
		||||
        runProc_prnCmdSeq[runProc_pointPrnCmd]=19;
 | 
			
		||||
        runProc_prnCmdPara[runProc_pointPrnCmd++]=val;
 | 
			
		||||
    } else
 | 
			
		||||
 | 
			
		||||
    if ( memcmp(valueStr, "csiz ", 5) ==0 )
 | 
			
		||||
    {
 | 
			
		||||
        valueStr[7]=0;
 | 
			
		||||
        val=uint8_t(tslib_atol(&valueStr[5]));
 | 
			
		||||
        runProc_prnCmdSeq[runProc_pointPrnCmd]=20;
 | 
			
		||||
        runProc_prnCmdPara[runProc_pointPrnCmd++]=val;
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    // "prn_papSped" comes with feed-cmd, not with "styl" !!
 | 
			
		||||
 | 
			
		||||
}
 | 
			
		||||
@@ -1619,51 +1635,25 @@ bool T_runProc::subGetVariStr(char *valueStr, char *returnStr)
 | 
			
		||||
 | 
			
		||||
    if ( memcmp(valueStr, "wday eng shor", 13) ==0 )
 | 
			
		||||
    {
 | 
			
		||||
        switch (dow)
 | 
			
		||||
        {
 | 
			
		||||
 | 
			
		||||
        case 1:
 | 
			
		||||
            returnStr[0]='m'; returnStr[1]='o';
 | 
			
		||||
            break;
 | 
			
		||||
        case 2:
 | 
			
		||||
            returnStr[0]='t'; returnStr[1]='u';
 | 
			
		||||
            break;
 | 
			
		||||
        case 3:
 | 
			
		||||
            returnStr[0]='w'; returnStr[1]='e';
 | 
			
		||||
            break;
 | 
			
		||||
        case 4:
 | 
			
		||||
            returnStr[0]='t'; returnStr[1]='h';
 | 
			
		||||
            break;
 | 
			
		||||
        case 5:
 | 
			
		||||
            returnStr[0]='f'; returnStr[1]='r';
 | 
			
		||||
            break;
 | 
			
		||||
        case 6:
 | 
			
		||||
            returnStr[0]='s'; returnStr[1]='a';
 | 
			
		||||
            break;
 | 
			
		||||
        case 7:
 | 
			
		||||
            returnStr[0]='s'; returnStr[1]='u';
 | 
			
		||||
            break;
 | 
			
		||||
        default:
 | 
			
		||||
            returnStr[0]='-'; returnStr[1]='-';
 | 
			
		||||
            break;
 | 
			
		||||
        }
 | 
			
		||||
        swl_returnWeekdayStr(dow, 2, returnStr);
 | 
			
		||||
        returnStr[2]=0;
 | 
			
		||||
        return true;
 | 
			
		||||
    }
 | 
			
		||||
    if ( memcmp(valueStr, "wday eng long", 13) ==0 )
 | 
			
		||||
    {
 | 
			
		||||
 | 
			
		||||
        swl_returnWeekdayStr(dow, 2, returnStr);
 | 
			
		||||
        return true;
 | 
			
		||||
    }
 | 
			
		||||
    if ( memcmp(valueStr, "wday deu shor", 13) ==0 )
 | 
			
		||||
    {
 | 
			
		||||
 | 
			
		||||
        swl_returnWeekdayStr(dow, 1, returnStr);
 | 
			
		||||
        returnStr[2]=0;
 | 
			
		||||
        return true;
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    if ( memcmp(valueStr, "wday deu long", 13) ==0 )
 | 
			
		||||
    {
 | 
			
		||||
 | 
			
		||||
        swl_returnWeekdayStr(dow, 1, returnStr);
 | 
			
		||||
        return true;
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
@@ -1987,7 +1977,6 @@ void T_runProc::runProc_subPerformPrintCmds(uint8_t nextCmd, uint8_t nextPara)
 | 
			
		||||
            prn_fontInv=0;
 | 
			
		||||
            sendFDcmd_set(CMD2DC_PRI_SETLETTER, 0, 0, prn_fontBold, prn_fontInv, prn_underLine, 0);
 | 
			
		||||
            break;
 | 
			
		||||
 | 
			
		||||
        case 16:
 | 
			
		||||
            prn_fontTyp=nextPara;      // kind of font 5...11 (0..22)
 | 
			
		||||
            sendFDcmd_set(CMD2DC_PRI_SETFONT, 0,0, prn_fontTyp, prn_fontSiz, prn_width, prn_hei);
 | 
			
		||||
@@ -2008,12 +1997,14 @@ void T_runProc::runProc_subPerformPrintCmds(uint8_t nextCmd, uint8_t nextPara)
 | 
			
		||||
            prn_density=nextPara;
 | 
			
		||||
            prn_sendPrnSetup(prn_papSped, prn_density,  prn_alignment, prn_orient);
 | 
			
		||||
            break;
 | 
			
		||||
 | 
			
		||||
        case 20:
 | 
			
		||||
            prn_fontSiz=nextPara;
 | 
			
		||||
            sendFDcmd_set(CMD2DC_PRI_SETFONT, 0,0, prn_fontTyp, prn_fontSiz, prn_width, prn_hei);
 | 
			
		||||
            break;
 | 
			
		||||
        case 30:    // cut
 | 
			
		||||
            // kindof = 1: full cut  2: partial cut   3=eject (5xLF + full cut)
 | 
			
		||||
            sendFDcmd_set(CMD2DC_PRI_CUT, 0,0, 1,0,0,0);
 | 
			
		||||
            break;
 | 
			
		||||
 | 
			
		||||
        case 31:    // part
 | 
			
		||||
            // kindof = 1: full cut  2: partial cut   3=eject (5xLF + full cut)
 | 
			
		||||
            sendFDcmd_set(CMD2DC_PRI_CUT, 0,0, 2,0,0,0);
 | 
			
		||||
@@ -2333,3 +2324,133 @@ char T_runProc::prn_directTicket_cycle(void)
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
// neuere TS Version, wurde aber von Gerhard nicht verwendet:
 | 
			
		||||
/*
 | 
			
		||||
bool T_runProc::bl_waitForRdyMsg(void)		// vorher:   bl_isUp()
 | 
			
		||||
{
 | 
			
		||||
    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() << "*** runProc, 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() << "runProc, got BL response to start";
 | 
			
		||||
            //epi_clrRawReceivedString();
 | 
			
		||||
            return true;
 | 
			
		||||
        }
 | 
			
		||||
        //qDebug() << "runProc, got "<<LL<<" wrong bytes"<<receivedData[0]<<" "
 | 
			
		||||
        //    <<receivedData[1]<<" "<<receivedData[2]<<" "<<receivedData[3]<<" "
 | 
			
		||||
         //   <<receivedData[4]<<" "<<receivedData[5]<<" "<<receivedData[6];
 | 
			
		||||
    }
 | 
			
		||||
    return false;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
uint8_t T_runProc::bl_isUp(void)
 | 
			
		||||
{
 | 
			
		||||
    // return 1: BL is up   2: BL error  0: unknown
 | 
			
		||||
    return runProc_BLisStarted;
 | 
			
		||||
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
bool T_runProc::bl_performComplStart(void)
 | 
			
		||||
{
 | 
			
		||||
    bool result;
 | 
			
		||||
 | 
			
		||||
    static uint8_t retryCtr;
 | 
			
		||||
 | 
			
		||||
    if ((bl_startupStep<1) || (bl_startupStep>10))
 | 
			
		||||
        return false;
 | 
			
		||||
 | 
			
		||||
    if (bl_startupStep==1)
 | 
			
		||||
    {
 | 
			
		||||
        dc_autoRequest(false);  // and clear serial input buffer
 | 
			
		||||
        runProc_BLisStarted=0;
 | 
			
		||||
        bl_startupStep++;
 | 
			
		||||
    } else
 | 
			
		||||
 | 
			
		||||
    if (bl_startupStep==2)
 | 
			
		||||
    {
 | 
			
		||||
        qDebug()<<"rebooting";
 | 
			
		||||
        bl_rebootDC();
 | 
			
		||||
        myTO->stop();
 | 
			
		||||
        myTO->start(500);
 | 
			
		||||
        retryCtr=0;
 | 
			
		||||
        bl_startupStep++;
 | 
			
		||||
    } else
 | 
			
		||||
 | 
			
		||||
    if (bl_startupStep==3)
 | 
			
		||||
    {
 | 
			
		||||
        if (!myTO->isActive())
 | 
			
		||||
        {
 | 
			
		||||
            qDebug()<<"starting BL";
 | 
			
		||||
            epi_clrRawReceivedString();
 | 
			
		||||
            bl_startBL();
 | 
			
		||||
            myTO->stop();
 | 
			
		||||
            myTO->start(500);
 | 
			
		||||
            bl_startupStep++;
 | 
			
		||||
        }
 | 
			
		||||
    } else
 | 
			
		||||
 | 
			
		||||
    if (bl_startupStep==4)
 | 
			
		||||
    {
 | 
			
		||||
        if (!myTO->isActive())
 | 
			
		||||
        {
 | 
			
		||||
            qDebug()<<"checking BL";
 | 
			
		||||
            bl_checkBL();
 | 
			
		||||
            myTO->stop();
 | 
			
		||||
            myTO->start(1000);
 | 
			
		||||
            bl_startupStep++;
 | 
			
		||||
        }
 | 
			
		||||
    } else
 | 
			
		||||
 | 
			
		||||
    if (bl_startupStep==5)
 | 
			
		||||
    {
 | 
			
		||||
        result = bl_waitForRdyMsg();
 | 
			
		||||
        if (result==true)
 | 
			
		||||
        {
 | 
			
		||||
            bl_startupStep++;
 | 
			
		||||
            qDebug()<<"BL is working now...";       //  BL is up and running
 | 
			
		||||
            runProc_BLisStarted=1;      // ok
 | 
			
		||||
            return true;
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        if (!myTO->isActive())
 | 
			
		||||
        {
 | 
			
		||||
            qDebug()<<"no resp. from BL"<< result;
 | 
			
		||||
            retryCtr++;    // start again
 | 
			
		||||
            if (retryCtr>=3)
 | 
			
		||||
            {
 | 
			
		||||
                bl_startupStep=99;
 | 
			
		||||
                qDebug()<<"BL error!!!";
 | 
			
		||||
            } else
 | 
			
		||||
            {
 | 
			
		||||
                bl_startupStep=3;
 | 
			
		||||
                runProc_BLisStarted=2;      // error
 | 
			
		||||
                myTO->stop();
 | 
			
		||||
                myTO->start(1);
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
    }
 | 
			
		||||
    return false;
 | 
			
		||||
}
 | 
			
		||||
*/
 | 
			
		||||
 
 | 
			
		||||
@@ -981,3 +981,62 @@ unsigned int tslib_ah2ui( char *AscString)
 | 
			
		||||
    return(uitmp);
 | 
			
		||||
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
// *****************************************************************************************
 | 
			
		||||
 | 
			
		||||
void swl_returnWeekdayStr(char dow, char language, char *buf)
 | 
			
		||||
{
 | 
			
		||||
    // dow=1...7
 | 
			
		||||
    // always returns 10byte
 | 
			
		||||
    // languages: 1=german  2=english
 | 
			
		||||
 | 
			
		||||
    memset(buf,0,10);
 | 
			
		||||
    switch (dow)
 | 
			
		||||
    {
 | 
			
		||||
        case 1: // monday
 | 
			
		||||
                if (language==1) tslib_text2array("Montag", buf,10);
 | 
			
		||||
                else if (language==2) tslib_text2array("Monday", buf,10);
 | 
			
		||||
                break;
 | 
			
		||||
        case 2:
 | 
			
		||||
                if (language==1) tslib_text2array("Dienstag", buf,10);
 | 
			
		||||
                else if (language==2) tslib_text2array("Tuesday", buf,10);
 | 
			
		||||
                break;
 | 
			
		||||
        case 3:
 | 
			
		||||
                if (language==1) tslib_text2array("Mittwoch", buf,10);
 | 
			
		||||
                else if (language==2) tslib_text2array("Wednesday", buf,10);
 | 
			
		||||
                break;
 | 
			
		||||
        case 4:
 | 
			
		||||
                if (language==1) tslib_text2array("Donnerstag", buf,10);
 | 
			
		||||
                else if (language==2) tslib_text2array("Thursday", buf,10);
 | 
			
		||||
                break;
 | 
			
		||||
        case 5:
 | 
			
		||||
                if (language==1) tslib_text2array("Freitag", buf,10);
 | 
			
		||||
                else if (language==2) tslib_text2array("Friday", buf,10);
 | 
			
		||||
                break;
 | 
			
		||||
        case 6:
 | 
			
		||||
                if (language==1) tslib_text2array("Samstag", buf,10);
 | 
			
		||||
                else if (language==2) tslib_text2array("Saturday", buf,10);
 | 
			
		||||
                break;
 | 
			
		||||
        case 7:
 | 
			
		||||
                if (language==1) tslib_text2array("Sonntag", buf,10);
 | 
			
		||||
                else if (language==2) tslib_text2array("Sunday", buf,10);
 | 
			
		||||
                break;
 | 
			
		||||
        default:   tslib_text2array("----", buf,10);
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
		Reference in New Issue
	
	Block a user