DCPlugin/src/controlBus.cpp

401 lines
10 KiB
C++
Raw Normal View History

2023-03-17 11:22:09 +01:00
#include <stdint.h>
#include <QString>
#include <QDebug>
#include "tslib.h"
#include "shared_mem_buffer.h"
2023-03-17 11:22:09 +01:00
//#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
2023-03-17 11:22:09 +01:00
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);
2023-03-17 11:22:09 +01:00
SharedMemBuffer::getData()->rs.baudNr = BaudNr;
SharedMemBuffer::getData()->rs.connect = connect;
2023-03-17 11:22:09 +01:00
}
void epi_closeSerial(void) {
SharedMemBuffer::getData()->rs.connect = 0;
2023-03-17 11:22:09 +01:00
}
void gpi_serialChanged(void) {
2023-03-17 11:22:09 +01:00
// serial confirms that port was closed or opened
// rs_connect=2; // Flanke, nur 1x öffnen/schließen
SharedMemBuffer::getData()->rs.connect = 2;
2023-03-17 11:22:09 +01:00
}
uint8_t gpi_getSerialConn(void) {
return SharedMemBuffer::getDataConst()->rs.connect;
2023-03-17 11:22:09 +01:00
}
int gpi_getBaudNr(void) {
return SharedMemBuffer::getDataConst()->rs.baudNr;
2023-03-17 11:22:09 +01:00
}
QString gpi_getComPortName(void) {
return SharedMemBuffer::getDataConst()->rs.comportName;
2023-03-17 11:22:09 +01:00
}
void gpi_serialIsOpen(bool offen) {
SharedMemBuffer::getData()->rs.portIsOpen = offen;
2023-03-17 11:22:09 +01:00
}
bool epi_isSerialPortOpen() {
2023-03-17 11:22:09 +01:00
// true: port is open false: port is closed
return SharedMemBuffer::getDataConst()->rs.portIsOpen;
2023-03-17 11:22:09 +01:00
}
// ///////////////////////////////////////////////////////////////////////////////////
// Control transfer gui <--> serial
// ///////////////////////////////////////////////////////////////////////////////////
void epi_startEmmision(char start) {
SharedMemBuffer::getData()->AutoEmissionOn = start;
2023-03-17 11:22:09 +01:00
}
bool gpi_isEmmisionOn(void) {
return SharedMemBuffer::getDataConst()->AutoEmissionOn;
2023-03-17 11:22:09 +01:00
}
uint16_t gpi_getPeriodicSendTimeVal() {
SharedMemBuffer::getData()->datif.sendingPer_changed = 0;
if ((SharedMemBuffer::getDataConst()->datif.sendingPeriod < 3) ||
(SharedMemBuffer::getDataConst()->datif.sendingPeriod > 10000)) {
2023-03-17 11:22:09 +01:00
return 130; // ms, default
}
return SharedMemBuffer::getDataConst()->datif.sendingPeriod;
2023-03-17 11:22:09 +01:00
}
void epi_setPeriodicSendTimeVal(uint16_t val) {
if (val>=3 && val<10000) {
SharedMemBuffer::getData()->datif.sendingPer_changed = 1;
SharedMemBuffer::getData()->datif.sendingPeriod = val;
2023-03-17 11:22:09 +01:00
}
}
bool gpi_PeriodicSendTimeHasChanged() {
return SharedMemBuffer::getDataConst()->datif.sendingPer_changed;
2023-03-17 11:22:09 +01:00
}
// ///////////////////////////////////////////////////////////////////////////////////
// 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;
}