DCPlugin/src/controlBus.cpp

#include <stdint.h>
#include <QString>
#include <QDebug>
#include "tslib.h"
#include "shared_mem_buffer.h"
//#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) {
    memset(&SharedMemBuffer::getData()->rs.comportName[0], 0x00,
           sizeof(SharedMemBuffer::getData()->rs.comportName));
    strncpy(SharedMemBuffer::getData()->rs.comportName,
            ComName.toStdString().c_str(),
            sizeof(SharedMemBuffer::getData()->rs.comportName)-1);

    memset(&SharedMemBuffer::getData()->rs.baudStr[0], 0x00,
           sizeof(SharedMemBuffer::getData()->rs.baudStr));
    strncpy(SharedMemBuffer::getData()->rs.baudStr,
            BaudStr.toStdString().c_str(),
            sizeof(SharedMemBuffer::getData()->rs.baudStr)-1);

    SharedMemBuffer::getData()->rs.baudNr = BaudNr;
    SharedMemBuffer::getData()->rs.connect = connect;
}

void epi_closeSerial(void) {
    SharedMemBuffer::getData()->rs.connect = 0;
}


void gpi_serialChanged(void) {
    // serial confirms that port was closed or opened
    // rs_connect=2;   // Flanke, nur 1x öffnen/schließen
    SharedMemBuffer::getData()->rs.connect = 2;
}

uint8_t gpi_getSerialConn(void) {
    return SharedMemBuffer::getDataConst()->rs.connect;
}


int gpi_getBaudNr(void) {
    return SharedMemBuffer::getDataConst()->rs.baudNr;
}

QString gpi_getComPortName(void) {
    return SharedMemBuffer::getDataConst()->rs.comportName;
}

void gpi_serialIsOpen(bool offen) {
    SharedMemBuffer::getData()->rs.portIsOpen = offen;
}

bool epi_isSerialPortOpen() {
    // true: port is open   false: port is closed
    return SharedMemBuffer::getDataConst()->rs.portIsOpen;
}

// ///////////////////////////////////////////////////////////////////////////////////
//          Control transfer   gui <--> serial
// ///////////////////////////////////////////////////////////////////////////////////

void epi_startEmmision(char start) {
    SharedMemBuffer::getData()->AutoEmissionOn = start;
}

bool gpi_isEmmisionOn(void) {
    return SharedMemBuffer::getDataConst()->AutoEmissionOn;
}

uint16_t gpi_getPeriodicSendTimeVal() {
    SharedMemBuffer::getData()->datif.sendingPer_changed = 0;
    if ((SharedMemBuffer::getDataConst()->datif.sendingPeriod < 3) ||
        (SharedMemBuffer::getDataConst()->datif.sendingPeriod > 10000)) {
        return 130;         // ms, default
    }
    return SharedMemBuffer::getDataConst()->datif.sendingPeriod;
}

void epi_setPeriodicSendTimeVal(uint16_t val) {
    if (val>=3 && val<10000) {
        SharedMemBuffer::getData()->datif.sendingPer_changed = 1;
        SharedMemBuffer::getData()->datif.sendingPeriod = val;
    }
}

bool gpi_PeriodicSendTimeHasChanged() {
    return SharedMemBuffer::getDataConst()->datif.sendingPer_changed;
}

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

bool epi_getResult_serialTestOK()
{
    // retval: true: test was successful, got right response
    return Sdata_serialTestResult;
}



// ///////////////////////////////////////////////////////////////////////////////////
//          Store received data for hwapi
// ///////////////////////////////////////////////////////////////////////////////////



static uint8_t Sdata_pProtResultOk;

void gpi_startNewRequest()
{
    Sdata_pProtResultOk=0;
}

void gpi_storeResultOfLastRequest(bool answisok)
{
    if (answisok)
        Sdata_pProtResultOk=1;
    else
        Sdata_pProtResultOk=2;
}

uint8_t epi_getResultOfLastRequest()
{
    // retval: 0: in progress  1: OK  2: error
    return Sdata_pProtResultOk;
}




static uint16_t Sdata_receivedDataLength;
static uint8_t Sdata_receivedDataBlock[64];

void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t *receivedData)
{
    Sdata_receivedDataLength=uint16_t(RdDlen);
    if (Sdata_receivedDataLength>64)
        Sdata_receivedDataLength=64;
    tslib_strclr(Sdata_receivedDataBlock,0,64);
    tslib_strcpy(receivedData, Sdata_receivedDataBlock, 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;
    if (ml>64) ml=64;
    if (Sdata_receivedDataLength<ml)
        ml=Sdata_receivedDataLength;
    tslib_strcpy(Sdata_receivedDataBlock, payLoad, ml);
    return Sdata_receivedDataLength;
}