624 lines
20 KiB
C++
624 lines
20 KiB
C++
#include "prot.h"
|
|
#include <QDebug>
|
|
#include "controlBus.h"
|
|
#include "dcBL.h"
|
|
#include "interfaces.h"
|
|
|
|
|
|
T_prot::T_prot()
|
|
{
|
|
|
|
mySerialPort = new T_com();
|
|
connect(mySerialPort, SIGNAL(receivingFinished()), this, SLOT( analyseRecData() ));
|
|
//connect(mySerialPort, SIGNAL(sendingFinished()), this, SLOT(sendeFin()));
|
|
|
|
for (int nn=0; nn<FRAME_DATALEN; nn++)
|
|
{
|
|
chOut_Data[nn]=0;
|
|
ui8OutputData[nn]=0;
|
|
InputData[nn]=0;
|
|
}
|
|
for (int nn=0; nn<BL_DATA_LEN; nn++)
|
|
{
|
|
ui8BLsendData[nn]=0;
|
|
}
|
|
WriteCommand=0;
|
|
WriteAddr=0;
|
|
WrDataLength=0;
|
|
SendDataValid=0;
|
|
kindOfData=0;
|
|
slaveAddr=0;
|
|
ReadCommand=0;
|
|
//ReadAddr=0;
|
|
reserve =0;
|
|
RecSlaveAddr =0;
|
|
INdataValid=0;
|
|
readSource =0;
|
|
readAddress=0;
|
|
RdDataLength=0;
|
|
BLsendDataLength=0;
|
|
|
|
prot_storeResult=0xFF;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------------------------------------
|
|
// sending.....
|
|
// ---------------------------------------------------------------------------------------------------------
|
|
|
|
bool T_prot::isPortOpen(void)
|
|
{
|
|
return mySerialPort->isPortOpen();
|
|
}
|
|
|
|
bool T_prot::isSerialFree(void)
|
|
{
|
|
return true; // ohne HS's kann er nicht blockiert sein
|
|
}
|
|
|
|
|
|
// 14.9.23 Fehler!!!!!
|
|
// hier wird vorausgesetzt dasss die Empfangslaenge von Sendetelegramm abh. ist.
|
|
// also cmd>=100 ist kurze Antwort. das stimmt aber nicht, ist unabh. Wahr ist: cmd>=100 = kurzes Sendetelegramm
|
|
|
|
// Laenge des request-telegramms (PTU-->DC) ist nur abh. vom WRcmd, die Antwort auf WR ist immer kurz (nur result byte)
|
|
// WRcmd kurz oder lang: Antwort immer kurz
|
|
// RDcmd kurz oder lang: Antwort genauso
|
|
// Also Korrektur dieser Funktion: nur der Variablenname "WriteCmd" -> "ReadCmd"
|
|
|
|
void T_prot::setRecLen(uint16_t ReadCmd)
|
|
{
|
|
if (ReadCmd<100)
|
|
{
|
|
RdDataLength=DATALEN_RECEIVE_LONG; // 64, store here already because it's no longer returned from slave
|
|
mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_LONG); // 68
|
|
} else
|
|
{
|
|
RdDataLength=DATALEN_RECEIVE_FAST; // 8
|
|
mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_FAST); // 12
|
|
}
|
|
}
|
|
|
|
/*
|
|
* void T_prot::setRecLen(uint16_t WriteCmd)
|
|
{
|
|
if (WriteCmd<100)
|
|
{
|
|
RdDataLength=DATALEN_RECEIVE_LONG; // store here already because it's no longer
|
|
// returned from slave
|
|
mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_LONG); // 68
|
|
} else
|
|
{
|
|
RdDataLength=DATALEN_RECEIVE_FAST;
|
|
mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_FAST); // 12
|
|
}
|
|
}
|
|
*/
|
|
|
|
void T_prot::setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr, uint8_t WrDatLen, uint8_t *data)
|
|
{
|
|
WriteCommand=WriteCmd;
|
|
WriteAddr=WrAddr;
|
|
WrDataLength=WrDatLen;
|
|
if (WrDataLength>FRAME_DATALEN)
|
|
WrDataLength=FRAME_DATALEN;
|
|
|
|
for (int nn=0; nn<WrDataLength; nn++)
|
|
ui8OutputData[nn]=data[nn];
|
|
SendDataValid=1; // always set WR first
|
|
kindOfData=0; // 0: binaries, 1:text
|
|
this->setRecLen(100); // default: short response
|
|
|
|
}
|
|
|
|
void T_prot::setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr)
|
|
{
|
|
WriteCommand=WriteCmd;
|
|
WriteAddr=WrAddr;
|
|
WrDataLength=0;
|
|
for (int nn=0; nn<FRAME_DATALEN; nn++)
|
|
ui8OutputData[nn]=0;
|
|
SendDataValid=1; // always set WR first
|
|
kindOfData=0; // 0: binaries, 1:text
|
|
this->setRecLen(100); // default: short response
|
|
|
|
}
|
|
|
|
void T_prot::setUserWriteData(uint16_t WriteCmd)
|
|
{
|
|
WriteCommand=WriteCmd;
|
|
WriteAddr=0;
|
|
WrDataLength=0;
|
|
for (int nn=0; nn<FRAME_DATALEN; nn++)
|
|
ui8OutputData[nn]=0;
|
|
SendDataValid=1; // always set WR first
|
|
kindOfData=0; // 0: binaries, 1:text
|
|
this->setRecLen(100); // default: short response
|
|
|
|
}
|
|
|
|
void T_prot::setUserWrite1DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val)
|
|
{
|
|
// wie oben, jedoch einfachere Datenübergabe
|
|
WriteCommand=WriteCmd;
|
|
WriteAddr=WrAddr;
|
|
WrDataLength=1;
|
|
ui8OutputData[0]=val;
|
|
SendDataValid=1; // always set WR first
|
|
kindOfData=0; // 0: binaries, 1:text
|
|
this->setRecLen(100); // default: short response
|
|
|
|
}
|
|
|
|
void T_prot::setUserWrite2DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val0, uint8_t val1)
|
|
{
|
|
WriteCommand=WriteCmd;
|
|
WriteAddr=WrAddr;
|
|
WrDataLength=2;
|
|
ui8OutputData[0]=val0;
|
|
ui8OutputData[1]=val1;
|
|
SendDataValid=1; // always set WR first
|
|
kindOfData=0; // 0: binaries, 1:text
|
|
this->setRecLen(100); // default: short response
|
|
|
|
}
|
|
|
|
void T_prot::setUserWriteText(uint16_t WriteCmd, uint16_t WrAddr, uint8_t WrDatLen, char *data)
|
|
{
|
|
WriteCommand=WriteCmd;
|
|
WriteAddr=WrAddr;
|
|
WrDataLength=WrDatLen;
|
|
if (WrDataLength>FRAME_DATALEN)
|
|
WrDataLength=FRAME_DATALEN;
|
|
|
|
for (int nn=0; nn<WrDataLength; nn++)
|
|
chOut_Data[nn]=data[nn];
|
|
SendDataValid=1; // always set WR first
|
|
kindOfData=1; // 0: binaries, 1:text
|
|
this->setRecLen(100); // default: short response
|
|
|
|
}
|
|
|
|
void T_prot::setUserReadData( uint16_t ReadCmd)
|
|
{
|
|
ReadCommand=ReadCmd;
|
|
//ReadAddr=WriteAddr;
|
|
reserve=0;
|
|
SendDataValid |=2;
|
|
readAddress=WriteAddr; // store here already because it's no longer returned from slave
|
|
|
|
//qDebug()<<"prot_setUserReadData, read address : " << readAddress;
|
|
|
|
this->setRecLen(ReadCmd); // long response (68byte) only for ReadCmd < 100
|
|
readSource=ReadCmd;
|
|
}
|
|
|
|
void T_prot::setBLsendData( uint8_t len, uint8_t *buf)
|
|
{
|
|
for (int nn=0; nn<BL_DATA_LEN; nn++)
|
|
ui8BLsendData[nn]=0;
|
|
|
|
BLsendDataLength=len;
|
|
if ( BLsendDataLength>BL_DATA_LEN) BLsendDataLength=BL_DATA_LEN;
|
|
for (int nn=0; nn<BLsendDataLength; nn++)
|
|
ui8BLsendData[nn]=buf[nn];
|
|
WriteCommand=0xFFFF;
|
|
this->setRecLen(100);
|
|
|
|
|
|
//qDebug()<<"prot: got BL data " << len << "bytes, ";
|
|
//for (int i=0; i<len; ++i) {
|
|
// printf("%02x ", (unsigned char)buf[i]);
|
|
//} printf("\n");
|
|
|
|
/*
|
|
qDebug()<<buf[0] <<buf[1] <<buf[2] <<buf[3] <<buf[4] <<buf[5] <<buf[6] <<buf[7];
|
|
qDebug() <<buf[8] <<buf[9] <<buf[10] <<buf[11] <<buf[12] <<buf[13]<<buf[14]<<buf[15];
|
|
qDebug() <<buf[16] <<buf[17] <<buf[18] <<buf[19] <<buf[20] <<buf[21]<<buf[22]<<buf[23];
|
|
qDebug() <<buf[24] <<buf[25] <<buf[26] <<buf[27] <<buf[28] <<buf[29]<<buf[30]<<buf[31];
|
|
qDebug() <<buf[32] <<buf[33] <<buf[34] <<buf[35] <<buf[36] <<buf[37]<<buf[38]<<buf[39];
|
|
qDebug() <<buf[40] <<buf[41] <<buf[42] <<buf[43] <<buf[44] <<buf[45]<<buf[46]<<buf[47];
|
|
qDebug() <<buf[48] <<buf[49] <<buf[50] <<buf[51] <<buf[52] <<buf[53] <<buf[54]<<buf[55];
|
|
qDebug() <<buf[56] <<buf[57] <<buf[58] <<buf[59] <<buf[60] <<buf[61] <<buf[62]<<buf[63];
|
|
qDebug() <<buf[64] <<buf[65] <<buf[66] <<buf[67] <<buf[68] <<buf[69] <<buf[70]<<buf[71];
|
|
qDebug() <<buf[72] <<buf[73] <<buf[74] <<buf[75] <<buf[76] <<buf[77] <<buf[78]<<buf[79];
|
|
*/
|
|
|
|
}
|
|
|
|
void T_prot::receiveFixLen(int64_t nrOfbytesToReceive)
|
|
{
|
|
mySerialPort->receiveFixLen(nrOfbytesToReceive);
|
|
}
|
|
|
|
void T_prot::sendUserData(uint16_t slaveAdr)
|
|
{
|
|
// man könnte hier noch "SendDataValid" abfragen,
|
|
// muss immer 3 sein, muss man aber nicht
|
|
|
|
//qDebug() << "prot send user data "<<slaveAdr;
|
|
QByteArray packBuf_2;
|
|
slaveAddr=slaveAdr;
|
|
|
|
if (WriteCommand==0xFFFF)
|
|
{
|
|
// Bypass for bootloader, no protocol frame but send as is...
|
|
packBuf_2.clear();
|
|
for (int nn=0; nn<BLsendDataLength; nn++)
|
|
{
|
|
// packBuf_2[nn]=char(ui8BLsendData[nn]); // program crash, 4.9.23
|
|
packBuf_2.append(ui8BLsendData[nn]);
|
|
|
|
}
|
|
mySerialPort->writeToSerial(packBuf_2, BLsendDataLength);
|
|
|
|
} else
|
|
startFastPacking(); // quicker since 15.12.21TS
|
|
//startPacking();
|
|
}
|
|
|
|
void T_prot::startFastPacking(void)
|
|
{
|
|
uint16_t mycrc;
|
|
uint16_t sendLen;
|
|
uint8_t uctmp, nn, pp, CrcLp;
|
|
char sendBuffer[FRAME_MAXLEN], ctmp;
|
|
|
|
//qDebug() << "prot start fast packing "<<slaveAddr;
|
|
|
|
for (int nn=0; nn<FRAME_MAXLEN; nn++)
|
|
sendBuffer[nn]=0;
|
|
|
|
if (WriteCommand>9 && WriteCommand<100)
|
|
{
|
|
// long command 10...99
|
|
// WriteCommand==0 if only read request, then use short sending
|
|
sendBuffer[0]=STARTSIGN_SEND_LONG;
|
|
WrDataLength=DATALEN_SEND_LONG; // immer
|
|
//qDebug() << "send long cmd, len: " << WrDataLength;
|
|
} else
|
|
{
|
|
// fast command
|
|
sendBuffer[0]=STARTSIGN_SEND_FAST;
|
|
WrDataLength=DATALEN_SEND_FAST; // immer
|
|
//qDebug() << "send fast cmd, len: " << WrDataLength;
|
|
}
|
|
sendBuffer[1]= uint8_t(WriteCommand);
|
|
sendBuffer[2]= uint8_t(ReadCommand);
|
|
//if (WriteAddr>0)
|
|
sendBuffer[3]= char(WriteAddr); // bei fast nur EINE adresse, wr hat Vorrang
|
|
//else
|
|
// sendBuffer[3]= char(ReadAddr);
|
|
// beim Fast prot. ist das reserve dann ists egal was drin steht
|
|
|
|
if (kindOfData) // 0: binaries, 1:text
|
|
{
|
|
for (nn=0; nn<WrDataLength; nn++)
|
|
{
|
|
pp=HEADERLEN_SEND+nn;
|
|
ctmp=(chOut_Data[nn]); // text
|
|
sendBuffer[pp]= char(ctmp);
|
|
}
|
|
|
|
} else
|
|
{
|
|
for (nn=0; nn<WrDataLength; nn++)
|
|
{
|
|
pp=HEADERLEN_SEND+nn;
|
|
uctmp=(ui8OutputData[nn]); // bin
|
|
sendBuffer[pp]= char(uctmp);
|
|
}
|
|
}
|
|
|
|
CrcLp= HEADERLEN_SEND + WrDataLength;
|
|
mycrc=0;
|
|
for (nn=0; nn<CrcLp; nn++)
|
|
{
|
|
uctmp=sendBuffer[nn];
|
|
mycrc+=uint16_t(uctmp);
|
|
//qDebug() << mycrc;
|
|
}
|
|
sendBuffer[CrcLp]=char(mycrc);
|
|
mycrc>>=8;
|
|
sendBuffer[CrcLp+1]=char(mycrc);
|
|
sendLen=CrcLp+2;
|
|
|
|
// send to VCP:
|
|
QByteArray packBuff;
|
|
packBuff.clear();
|
|
packBuff.append(sendBuffer, sendLen); // ohne sendLen wird beim ersten \0 abgeschnitten!!!
|
|
mySerialPort->writeToSerial(packBuff, sendLen);
|
|
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------------------------------------
|
|
// receiving.....
|
|
// ---------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
void T_prot::analyseRecData(void)
|
|
{
|
|
// Aufruf per connect aus serialcontrol wenn Daten empfangen wurden
|
|
// getRecData(QByteArray &data, uint16_t &sendLength);
|
|
|
|
QByteArray Indata;
|
|
QString myString, tempStr;
|
|
//char recBuffer[FRAME_MAXLEN];
|
|
uint8_t recBuffer[FRAME_MAXLEN];
|
|
|
|
uint16_t recLength;
|
|
|
|
INdataValid=false;
|
|
|
|
gpi_setTxt4HsStateLine("");
|
|
gpi_setTxt4masterStateLine("");
|
|
gpi_setTxt4resultStateLine("");
|
|
gpi_setTxt4dataStateLine("");
|
|
gpi_setTxt4datifLine("");
|
|
|
|
// read from "VCP":
|
|
mySerialPort->readFromSerial(Indata, recLength);
|
|
//qDebug()<<"prot: got data " << recLength;
|
|
if (recLength>FRAME_MAXLEN)
|
|
recLength=FRAME_MAXLEN;
|
|
for (int nn=0; nn<recLength; nn++)
|
|
recBuffer[nn]=uint8_t(Indata.at(nn));
|
|
|
|
myString.clear();
|
|
tempStr.clear();
|
|
uint8_t result=FastCheckInData(recBuffer, recLength); // check input data (response from slave)
|
|
if (result>0)
|
|
{
|
|
// dann anzeige
|
|
switch (result)
|
|
{
|
|
case 1: gpi_setTxt4masterStateLine("wrong length received"); break;
|
|
case 2: gpi_setTxt4masterStateLine("wrong start sign received"); break;
|
|
case 3: gpi_setTxt4masterStateLine("received datalen too big"); break;
|
|
case 4: gpi_setTxt4masterStateLine("wrong data len received"); break;
|
|
case 5: gpi_setTxt4masterStateLine("wrong crc received"); break;
|
|
case 6: gpi_setTxt4masterStateLine("slave: master cmd was wrong"); break;
|
|
case 7: gpi_setTxt4masterStateLine("slave: could not write/read data"); break;
|
|
|
|
}
|
|
myString.setNum(result);
|
|
|
|
// qDebug()<<"T_prot_analyseRecData: got BL data"<< recLength <<
|
|
// recBuffer[0]<< recBuffer[1]<< recBuffer[2]<< recBuffer[3] <<
|
|
// recBuffer[4]<< recBuffer[5]<< recBuffer[6]<< recBuffer[7];
|
|
|
|
// Daten abspeichern, könnten vom BL sein:
|
|
gpi_storeRawReceivedData(uint8_t(recLength), recBuffer);
|
|
INdataValid=false;
|
|
emit rawDataRecieved();
|
|
} else
|
|
{
|
|
gpi_setTxt4masterStateLine("slave response OK");
|
|
INdataValid=true;
|
|
ShowFastInData(recBuffer); // Eingangs-Daten des Slaves anzeigen
|
|
}
|
|
prot_storeResult=result;
|
|
emit framerecieved(); // always emit, no matter if data valid or not
|
|
|
|
}
|
|
|
|
|
|
uint8_t T_prot::FastCheckInData(uint8_t *Inbuf, uint16_t LL)
|
|
{
|
|
|
|
uint16_t rawInLen=LL, crcL_Addr, recCrc, myCrc, nn, datalen, nxt;
|
|
|
|
|
|
if (Inbuf[0]!=STARTSIGN_RECEIVE_FAST && Inbuf[0]!=STARTSIGN_RECEIVE_LONG)
|
|
{
|
|
//qDebug() << "prot: got wrong start sign: " << Inbuf[0];
|
|
return 2; // wrong start sign
|
|
}
|
|
if ( (rawInLen<TELEGRAMLEN_RECEIVE_FAST && Inbuf[0]==STARTSIGN_RECEIVE_FAST) ||
|
|
(rawInLen<TELEGRAMLEN_RECEIVE_LONG && Inbuf[0]==STARTSIGN_RECEIVE_LONG) )
|
|
{
|
|
//qDebug("prot: got %d bytes only", rawInLen);
|
|
return 1; // wrong length
|
|
}
|
|
if (Inbuf[0]==0x5F)
|
|
datalen=DATALEN_RECEIVE_FAST;
|
|
else
|
|
datalen=DATALEN_RECEIVE_LONG;
|
|
|
|
crcL_Addr=datalen+HEADERLEN_RECEIVE; // weil im definierten protocol 2 bytes vor den Daten stehen
|
|
recCrc=0;
|
|
recCrc=uchar2uint(uint8_t(Inbuf[crcL_Addr+1]), uint8_t(Inbuf[crcL_Addr]));
|
|
myCrc=0;
|
|
for (nn=0; nn<crcL_Addr; nn++)
|
|
{
|
|
nxt=uint16_t (Inbuf[nn]);
|
|
nxt &=0x00FF; // the casting makes 0xFFFF out of 0xFF !!!!!!!!!
|
|
myCrc+=nxt;
|
|
//qDebug("CRC: nxt: %d sum: %d", nxt, myCrc);
|
|
}
|
|
|
|
if (myCrc != recCrc)
|
|
{
|
|
//qDebug() << "crc does not match"; //: mycrc=" << myCrc<< " receivedCRC=" << recCrc;
|
|
//qDebug("calculated over %d bytes", crcL_Addr);
|
|
return 5; // crc wrong
|
|
}
|
|
|
|
uint8_t result=Inbuf[1];
|
|
// slave reports that 0: OK
|
|
// bit 2,1,0: master command was wrong
|
|
// bit 4,3: could not write data
|
|
// bit 6,5: could not read data
|
|
|
|
|
|
// NEU 17.7.23:
|
|
if (result & 0x07)
|
|
return 6; // slave: master cmd was wrong
|
|
if (result & 0x78)
|
|
return 7; // slave: could not write/read data
|
|
|
|
//if (result>0) schmarrn, kann nie kommen
|
|
// qDebug() << "prot, got DC-result: "<< result;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
uint8_t T_prot::CheckInResult(uint8_t *Inbuf)
|
|
{
|
|
char slaveresult;
|
|
QString myString=nullptr, tempStr=nullptr;
|
|
|
|
// slave results anzeigen
|
|
|
|
slaveresult=Inbuf[2]; // hier steht das "Command Result" des slaves,
|
|
// d.h das Ergebnis der Protokol-Prüfung (Master->Slave)
|
|
switch (slaveresult)
|
|
{
|
|
// received message (from master) analysis:
|
|
// 0: got valid request
|
|
// this errors can only come back from a single device (not bus)
|
|
// or from a bus slave in local mode
|
|
// 1: wrong start 2: wrong length
|
|
// 3: wrong crc 4: wrong addr
|
|
|
|
case 1: gpi_setTxt4resultStateLine("slave got wrong start sign"); break;
|
|
case 2: gpi_setTxt4resultStateLine("slave got wrong length"); break;
|
|
case 3: gpi_setTxt4resultStateLine("slave got wrong crc"); break;
|
|
case 4: gpi_setTxt4resultStateLine("slave got wrong addr"); break;
|
|
|
|
case 10: gpi_setTxt4resultStateLine("slave is in local mode"); break;
|
|
case 13: gpi_setTxt4resultStateLine("local mode with wrong crc"); break;
|
|
case 14: gpi_setTxt4resultStateLine("local mode with wrong addr"); break;
|
|
// wenn 1..4 dann konnte der Slave das Mastertelegramm gar nicht verwenden, also hier Stoppen
|
|
}
|
|
if (slaveresult>0 && slaveresult<10)
|
|
return 1;
|
|
|
|
// Slave hat gültiges Kommando empfangen:
|
|
// 2.result auswerten:
|
|
// recBuffer[3]; // Write result, d.h. Ergebnis des Schreibvorganges (z.B. DOs) des Slaves
|
|
// recBuffer[4]; // Read result, d.h. Ergebnis des Lesevorganges (z.B. DIs) des Slaves
|
|
// bisher nicht bekannt welche Fehlercodes es gibt, also den code direkt ausgeben.
|
|
// bisher bekannt: 0=OK
|
|
|
|
myString.clear();
|
|
myString = "Slave OUT and IN Result: ";
|
|
tempStr.setNum(Inbuf[3],16);
|
|
myString.append(tempStr);
|
|
myString.append(" ");
|
|
tempStr.setNum(Inbuf[4],16);
|
|
myString.append(tempStr);
|
|
gpi_setTxt4resultStateLine(myString);
|
|
return 0;
|
|
}
|
|
*/
|
|
|
|
|
|
uint8_t T_prot::ShowFastInData(uint8_t *recBuffer)
|
|
{
|
|
QString myString=nullptr, tempStr=nullptr;
|
|
uint8_t result;
|
|
|
|
RecSlaveAddr=0;
|
|
result=recBuffer[1]; // total result
|
|
result &=0x60; // only read result (bit 5,6)
|
|
|
|
if (result==0) // read result =OK,
|
|
// dann sind die Eingangsdaten gültig
|
|
{
|
|
myString.append("valid INdata: ");
|
|
//INdataValid=true; // 17.7. hier raus!
|
|
//readSource already set with sending
|
|
//readAddress=0; großer Fehler!!!! raus am 17.7
|
|
// RdDataLength already set with sending
|
|
if (RdDataLength>FRAME_DATALEN)
|
|
RdDataLength=FRAME_DATALEN;
|
|
for (int ii=0; ii<RdDataLength; ii++)
|
|
InputData[ii]=uint8_t(recBuffer[ii+HEADERLEN_RECEIVE]);
|
|
|
|
tempStr.setNum(readSource,16);
|
|
myString.append(tempStr);
|
|
myString.append(" add:");
|
|
|
|
tempStr.setNum(readAddress);
|
|
myString.append(tempStr);
|
|
//myString.append(" wakeSrc:");
|
|
//tempStr.setNum(lastWakeSrc);
|
|
//myString.append(tempStr);
|
|
myString.append(" Dlen:");
|
|
tempStr.setNum(RdDataLength);
|
|
myString.append(tempStr);
|
|
|
|
} else
|
|
{
|
|
myString=" "; // Eingangsdaten nicht gültig, sieht man aber weiter oben schon
|
|
|
|
}
|
|
|
|
gpi_setTxt4dataStateLine(myString);
|
|
//qDebug() << myString;
|
|
//qDebug("prot_checkInData_bindata: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d ",
|
|
// InputData[0], InputData[1], InputData[2], InputData[3],
|
|
// InputData[4], InputData[5], InputData[6], InputData[7],
|
|
// InputData[8], InputData[9], InputData[10], InputData[11],
|
|
// InputData[12], InputData[13], InputData[14], InputData[15]);
|
|
return 0;
|
|
}
|
|
|
|
|
|
uint8_t T_prot::ifDataReceived()
|
|
{
|
|
// return: 0xFF: result unknown 0=OK
|
|
// 1= wrong length 2=wrong start sign 5= wrong crc
|
|
// 6= slave: master cmd was wrong 7: slave: could not write/read data
|
|
return prot_storeResult;
|
|
|
|
}
|
|
|
|
bool T_prot::getReceivedInData(uint8_t *SlavAddr, uint16_t *readSrc, uint16_t *readAddr,
|
|
uint8_t *RdDlen, uint8_t *receivedData)
|
|
{
|
|
uint8_t nn;
|
|
*SlavAddr=RecSlaveAddr;
|
|
*readSrc=readSource; // diese (Eingangs-)Daten stehen im Puffer
|
|
*readAddr=readAddress; // von dieser Adr wurden die Daten gelesen
|
|
|
|
//qDebug()<<"prot_get_ReceivedInData, read address : " << readAddress;
|
|
|
|
//*lastWakSourc=lastWakeSrc; // falls der Slave den Master geweckt hat
|
|
*RdDlen=RdDataLength;
|
|
for (nn=0; nn<FRAME_DATALEN; nn++)
|
|
receivedData[nn]=0;
|
|
for (nn=0; nn<RdDataLength; nn++)
|
|
receivedData[nn]=InputData[nn];
|
|
|
|
// neu, 17.10.23: lokalen Puffer löschen
|
|
//for (nn=0; nn<FRAME_DATALEN; nn++)
|
|
// {
|
|
// InputData[nn]=0;
|
|
//}
|
|
// wieder raus, keinen Vorteil erkannt. Unklar ob das irgendwo Probleme macht! (bootloader?)
|
|
|
|
RdDataLength=0;
|
|
//-------------------------------------------
|
|
|
|
return INdataValid; // nur true wenn CommandState OK und readState OK
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|