DCLibraries/src/controlBus.cpp

#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;
}