Adding src files (sax)
This commit is contained in:
parent
a9a5210029
commit
f51062010e
389
src/com.cpp
Normal file
389
src/com.cpp
Normal file
|
|
@ -0,0 +1,389 @@
|
|||
#include "com.h"
|
||||
#include <QDebug>
|
||||
//#include "controlBus.h"
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
///
|
||||
/// serial hardware layer
|
||||
///
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
// --------- PUBLIC --------------------------------------------------------------------------------------------
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
|
||||
void T_com::writeToSerial(const QByteArray &data, uint16_t sendLength)
|
||||
{
|
||||
sendBuffer=data;
|
||||
sendLen=sendLength;
|
||||
if (CatSerial->isOpen())
|
||||
{
|
||||
//qDebug() << "sending..." << sendBuffer;
|
||||
CatSerial->write(sendBuffer);
|
||||
} else
|
||||
qDebug() << "error sending, port is not open";
|
||||
|
||||
}
|
||||
|
||||
|
||||
bool T_com::readFromSerial(QByteArray &data, uint16_t &sendLength)
|
||||
{
|
||||
// return one time true if new data (completly) read.
|
||||
// return new data in &data and &sendLength to other objects
|
||||
uint16_t ll=rawInLen;
|
||||
if (!CatSerial->isOpen())
|
||||
return false;
|
||||
data.clear();
|
||||
data.append(rawInput);
|
||||
sendLength=ll;
|
||||
rawInLen=0; // beim 2. Aufruf 0 zurück weil nichts neues da
|
||||
if (ll>0)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
// --------- PRIVATES --------------------------------------------------------------------------------------
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
|
||||
|
||||
T_com::T_com(QWidget *parent) : QMainWindow(parent)
|
||||
{
|
||||
// port settings come from tabCom->Sdata->serial
|
||||
|
||||
gpi_serialChanged();
|
||||
CatSerial = new QSerialPort(); // PortHW object for Control&Analyse Tool
|
||||
//CatSerial->clear();
|
||||
//CatSerial->clearError();
|
||||
|
||||
connect(CatSerial, &QSerialPort::readyRead, this, &T_com::readSomeBytes);
|
||||
// still reading, not sure if complete, undefined number of calls while reading
|
||||
|
||||
connect(CatSerial, &QSerialPort::bytesWritten, this, &T_com::serialSendComplete);
|
||||
// system confirms sending complete
|
||||
|
||||
//connect(CatSerial, &QSerialPort::dataTerminalReadyChanged, this, &T_com::incomingWake);
|
||||
//connect(CatSerial, &QSerialPort::requestToSendChanged, this, &T_com::incomingWake);
|
||||
|
||||
// timer detects time gap in input flow
|
||||
serRecTime = new QTimer();
|
||||
connect(serRecTime, SIGNAL(timeout()), this, SLOT(receiveTO()));
|
||||
serRecTime->setSingleShot(true); // single shot! only one impulse if receive complete
|
||||
serRecTime->stop(); // on hold
|
||||
|
||||
// check COM-TAB periodic if user wants to connect or disconnect
|
||||
QTimer *ChkConnectTimer = new QTimer();
|
||||
connect(ChkConnectTimer, SIGNAL(timeout()), this, SLOT(ser_ISR100ms()));
|
||||
ChkConnectTimer->setSingleShot(false);
|
||||
ChkConnectTimer->start(100); // in ms
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
T_com::~T_com()
|
||||
{
|
||||
if (CatSerial->isOpen())
|
||||
CatSerial->close();
|
||||
}
|
||||
|
||||
|
||||
void T_com::ser_ISR100ms()
|
||||
{
|
||||
// call every 100ms to check if user(HMI) wants to connect or disconnect
|
||||
|
||||
//qDebug() << "~~>LIB" << "checking connect button... " ;
|
||||
|
||||
uint8_t chkConn = gpi_getSerialConn(); // from global GUI buffer (Sdata)
|
||||
switch (chkConn)
|
||||
{
|
||||
case 0: // 0 button "connect" was just released
|
||||
closeSerialPort();
|
||||
gpi_serialChanged(); // set chkConn to 2, thus getting edge
|
||||
break;
|
||||
case 1: // 1 button "connect" was just pressed
|
||||
open_Serial_Port();
|
||||
gpi_serialChanged(); // set chkConn to 2, thus getting edge
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
if (CatSerial->isOpen())
|
||||
gpi_serialIsOpen(true);
|
||||
else
|
||||
gpi_serialIsOpen(false);
|
||||
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
|
||||
char T_com::open_Serial_Port()
|
||||
{
|
||||
bool ret;
|
||||
QString myString=nullptr, myPortName=nullptr, myBaudStr=nullptr;
|
||||
int myBaudNr;
|
||||
|
||||
if (CatSerial->isOpen())
|
||||
return 0; // opening twice is not allowed
|
||||
|
||||
//qDebug() << "connecting..." << myPortName;
|
||||
myPortName=gpi_getComPortName(); // was selected and stored from GUI
|
||||
CatSerial->setPortName(myPortName);
|
||||
myBaudNr=gpi_getBaudNr(); // was selected and stored from GUI
|
||||
switch (myBaudNr)
|
||||
{
|
||||
// 0:1200 1:9600 2:19200 3:38400 4:57600 5:115200
|
||||
case 0: CatSerial->setBaudRate(QSerialPort::Baud1200); myBaudStr="1200"; break;
|
||||
case 1: CatSerial->setBaudRate(QSerialPort::Baud9600); myBaudStr="9600"; break;
|
||||
case 2: CatSerial->setBaudRate(QSerialPort::Baud19200); myBaudStr="19200"; break;
|
||||
case 3: CatSerial->setBaudRate(QSerialPort::Baud38400); myBaudStr="38400"; break;
|
||||
case 4: CatSerial->setBaudRate(QSerialPort::Baud57600); myBaudStr="57600"; break;
|
||||
case 5: CatSerial->setBaudRate(QSerialPort::Baud115200); myBaudStr="115200"; break;
|
||||
}
|
||||
|
||||
CatSerial->setDataBits(QSerialPort::Data8);
|
||||
// alt: QSerialPort::Data5,6,7,8
|
||||
|
||||
CatSerial->setParity(QSerialPort::NoParity);
|
||||
// alt: EvenParity, OddParity, NoParity
|
||||
|
||||
CatSerial->setStopBits(QSerialPort::OneStop);
|
||||
// alternative: OneStop, TwoStop, OneAndHalfStop
|
||||
|
||||
CatSerial->setFlowControl(QSerialPort::NoFlowControl);
|
||||
// alt: HardwareControl, SoftwareControl, NoFlowControl
|
||||
|
||||
ret=CatSerial->open(QIODevice::ReadWrite);
|
||||
// alt: QIODevice::ReadWrite QIODevice::ReadOnly QIODevice::WriteOnly
|
||||
if (!ret)
|
||||
{
|
||||
myString.clear();
|
||||
myString = "error ";
|
||||
myString.append(CatSerial->errorString());
|
||||
qDebug() << myString;
|
||||
gpi_setTxt4comStateLine(myString);
|
||||
return 0;
|
||||
} else
|
||||
{
|
||||
myString.clear();
|
||||
myString.append(myPortName);
|
||||
//lang=myString.size();
|
||||
myString.append(" opened with ");
|
||||
myString.append(myBaudStr);
|
||||
myString.append(" 8N1");
|
||||
qDebug() << myString;
|
||||
gpi_setTxt4comStateLine(myString);
|
||||
gpi_setTxt4RsDiagWin(myString+"\n");
|
||||
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void T_com::closeSerialPort()
|
||||
{
|
||||
if (CatSerial->isOpen())
|
||||
{
|
||||
qDebug() << "closing connection";
|
||||
CatSerial->close();
|
||||
gpi_setTxt4comStateLine("closed");
|
||||
gpi_setTxt4RsDiagWin("closed");
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void T_com::readSomeBytes(void)
|
||||
{
|
||||
// called by serial-read-detection
|
||||
// restart off-time as input flow is ongoing
|
||||
serRecTime->stop();
|
||||
serRecTime->start(20); // in ms
|
||||
|
||||
}
|
||||
|
||||
void T_com::receiveTO(void)
|
||||
{
|
||||
// no new input data for 20ms, --> assuming frame complete
|
||||
// save data in private "rawInput"-buffer
|
||||
|
||||
if (CatSerial->isOpen())
|
||||
{
|
||||
|
||||
QString myString=nullptr, tmpStr=nullptr;
|
||||
int64_t nrOfBytesreceived = CatSerial->bytesAvailable(); // nr of received bytes
|
||||
QByteArray data = CatSerial->readAll();
|
||||
|
||||
rawInLen=uint16_t (nrOfBytesreceived);
|
||||
rawInput.clear();
|
||||
rawInput.append(data);
|
||||
//rawInput[rawInLen]=0; // Zwangsterminierung bei QByteArray nicht nötig
|
||||
|
||||
// diag display in serial in/out window and debug window
|
||||
myString.clear();
|
||||
myString.setNum(rawInLen);
|
||||
myString.append(" in: ");
|
||||
//myString.append(rawInput);
|
||||
for (int ii=0; ii<rawInLen; ii++)
|
||||
{
|
||||
tmpStr.clear();
|
||||
tmpStr.setNum(rawInput[ii],16); // problem: wenn >0x80 dann wird EIN Byte 16 stellig angezeigt
|
||||
int ll=tmpStr.length();
|
||||
if (ll>2)
|
||||
{
|
||||
myString.append(tmpStr[ll-2]);
|
||||
myString.append(tmpStr[ll-1]);
|
||||
} else
|
||||
{
|
||||
myString.append(tmpStr);
|
||||
}
|
||||
myString.append(" ");
|
||||
}
|
||||
myString.append("\n");
|
||||
#ifdef PRINTALLDEBUGS
|
||||
qDebug() << "VCP:" << myString; // display all inputs and outputs in output window
|
||||
#endif
|
||||
gpi_setTxt4RsDiagWin(myString);
|
||||
//gpi_set2ndTxt4RsDiagWin(myString);
|
||||
|
||||
// report "new data received" to other objects
|
||||
emit receivingFinished();
|
||||
}
|
||||
}
|
||||
|
||||
void T_com::serialSendComplete(void)
|
||||
{
|
||||
// system confirms sending complete, diag display
|
||||
QString myString=nullptr, tmpStr=nullptr;
|
||||
|
||||
myString.clear();
|
||||
myString.setNum(sendLen);
|
||||
myString.append(" out: ");
|
||||
|
||||
for (int ii=0; ii<sendLen; ii++)
|
||||
{
|
||||
tmpStr.clear();
|
||||
tmpStr.setNum(sendBuffer[ii],16); // problem: wenn >0x80 dann 16stellig
|
||||
int ll=tmpStr.length();
|
||||
if (ll>2)
|
||||
{
|
||||
//qDebug() << "long_string" << ll << "\n";
|
||||
myString.append(tmpStr[ll-2]);
|
||||
myString.append(tmpStr[ll-1]);
|
||||
|
||||
} else
|
||||
{
|
||||
myString.append(tmpStr);
|
||||
}
|
||||
myString.append(" ");
|
||||
}
|
||||
|
||||
#ifdef PRINTALLDEBUGS
|
||||
myString.append("\n");
|
||||
qDebug() << myString; // display all output data in out-window
|
||||
#endif
|
||||
|
||||
gpi_setTxt4RsDiagWin(myString);
|
||||
|
||||
emit sendingFinished(); // for whom it may interest
|
||||
}
|
||||
|
||||
|
||||
bool T_com::isPortOpen(void)
|
||||
{
|
||||
if (CatSerial->isOpen())
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
|
||||
/*
|
||||
uint8_t T_com::getAllPortPins(void)
|
||||
{
|
||||
uint8_t rs232pins=0;
|
||||
rs232pins= uint8_t(CatSerial->pinoutSignals());
|
||||
// rs232pins: all signals bitwise coded in one byte:
|
||||
// readback output: bit 0=TxD(=output) bit2=DTR (=output) bit 6=RTS (=output)
|
||||
// unused inputs: bit1=RxD bit 3=DCD bit 5 = RING
|
||||
// handshake inputs: bit 4=DSR (0x10) bit 7=CTS (0x80)
|
||||
//qDebug()<<"serial port pins: " << rs232pins;
|
||||
return rs232pins;
|
||||
}
|
||||
|
||||
bool T_com::getHSin_CTS(void)
|
||||
{
|
||||
// return the used Handshake IN (CTS, alt. DSR): true= high level (+8V)
|
||||
|
||||
uint8_t rs232pins=0;
|
||||
|
||||
rs232pins= uint8_t(CatSerial->pinoutSignals());
|
||||
// rs232pins: all signals bitwise coded in one byte:
|
||||
// readback output: bit 0=TxD(=output) bit2=DTR (=output) bit 6=RTS (=output)
|
||||
// unused inputs: bit1=RxD bit 3=DCD bit 5 = RING
|
||||
// handshake inputs: bit 4=DSR (0x10) bit 7=CTS (0x80)
|
||||
|
||||
if (rs232pins & 0x80) // CTS
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool T_com::getHSin_DSR(void)
|
||||
{
|
||||
uint8_t rs232pins=0;
|
||||
rs232pins= uint8_t(CatSerial->pinoutSignals());
|
||||
if (rs232pins & 0x10) // DSR
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
void T_com::incomingWake(void) //(bool LevelOfTheBit)
|
||||
{
|
||||
emit wasWokenBySerialHandshake();
|
||||
}
|
||||
|
||||
bool T_com::setHSout_RTS(bool hsout)
|
||||
{
|
||||
// hsout true=positiv voltage +12V false= -12V
|
||||
// retval: true=setting OK
|
||||
|
||||
bool cc;
|
||||
// 10.5.19, am Windows-PC nachgemessen, funktioniert gut
|
||||
// false ergibt -12V true ergibt +12V
|
||||
|
||||
cc=CatSerial->setRequestToSend(hsout); // RTS out
|
||||
// retval true means "setting was successful"
|
||||
|
||||
// alternative: use DTR as Handshake:
|
||||
//cc=CatSerial->setDataTerminalReady(false); // DTR out
|
||||
// retval true means "setting was successful"
|
||||
//qDebug()<<"RTS " <<cc;
|
||||
return cc;
|
||||
}
|
||||
|
||||
bool T_com::setHSout_DTR(bool hsout)
|
||||
{
|
||||
// hsout true=positiv voltage +12V false= -12V
|
||||
// retval: true=setting OK
|
||||
|
||||
bool cc;
|
||||
// 10.5.19, am Windows-PC nachgemessen, funktioniert gut
|
||||
// false ergibt -12V true ergibt +12V
|
||||
|
||||
cc=CatSerial->setDataTerminalReady(hsout); // DTR out
|
||||
// retval true means "setting was successful"
|
||||
//qDebug()<<"DTR " <<cc;
|
||||
return cc;
|
||||
}
|
||||
*/
|
||||
415
src/controlBus.cpp
Normal file
415
src/controlBus.cpp
Normal file
|
|
@ -0,0 +1,415 @@
|
|||
#include <stdint.h>
|
||||
#include <QString>
|
||||
#include <QDebug>
|
||||
#include "tslib.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)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
static bool rs_portIsOpen;
|
||||
|
||||
void gpi_serialIsOpen(bool offen)
|
||||
{
|
||||
rs_portIsOpen=offen;
|
||||
}
|
||||
|
||||
bool epi_isSerialPortOpen()
|
||||
{
|
||||
// true: port is open false: port is closed
|
||||
return rs_portIsOpen;
|
||||
}
|
||||
|
||||
// ///////////////////////////////////////////////////////////////////////////////////
|
||||
// Control transfer gui <--> serial
|
||||
// ///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
static char AutoEmissionOn; // 1: zyklisch Anfragen zum Slave senden
|
||||
|
||||
void epi_startEmmision(char start)
|
||||
{
|
||||
AutoEmissionOn=start;
|
||||
}
|
||||
|
||||
bool gpi_isEmmisionOn(void)
|
||||
{
|
||||
return AutoEmissionOn;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------
|
||||
|
||||
static uint16_t datif_sendingPeriod;
|
||||
static bool datif_sendingPer_changed;
|
||||
|
||||
uint16_t gpi_getPeriodicSendTimeVal()
|
||||
{
|
||||
datif_sendingPer_changed=0;
|
||||
if (datif_sendingPeriod<3 || datif_sendingPeriod>10000)
|
||||
return 130; // ms, default
|
||||
else
|
||||
return datif_sendingPeriod;
|
||||
}
|
||||
|
||||
void epi_setPeriodicSendTimeVal(uint16_t val)
|
||||
{
|
||||
if (val>=3 && val<10000)
|
||||
{
|
||||
datif_sendingPer_changed=1;
|
||||
datif_sendingPeriod=val;
|
||||
}
|
||||
}
|
||||
|
||||
bool gpi_PeriodicSendTimeHasChanged()
|
||||
{
|
||||
return 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;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
1292
src/datIf.cpp
Normal file
1292
src/datIf.cpp
Normal file
File diff suppressed because it is too large
Load Diff
1269
src/dcBL.cpp
Normal file
1269
src/dcBL.cpp
Normal file
File diff suppressed because it is too large
Load Diff
2501
src/hwapi.cpp
Normal file
2501
src/hwapi.cpp
Normal file
File diff suppressed because it is too large
Load Diff
525
src/prot.cpp
Normal file
525
src/prot.cpp
Normal file
|
|
@ -0,0 +1,525 @@
|
|||
#include "prot.h"
|
||||
#include <QDebug>
|
||||
#include "controlBus.h"
|
||||
#include "dcBL.h"
|
||||
|
||||
|
||||
T_prot::T_prot()
|
||||
{
|
||||
|
||||
mySerialPort = new T_com();
|
||||
connect(mySerialPort, SIGNAL(receivingFinished()), this, SLOT( analyseRecData() ));
|
||||
//connect(mySerialPort, SIGNAL(receivingFinished()), this, SLOT( receivFin() ));
|
||||
//connect(mySerialPort, SIGNAL(sendingFinished()), this, SLOT(sendeFin()));
|
||||
kindOfData=0; // 0: binaries, 1:text
|
||||
|
||||
}
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------------------------------------------
|
||||
// sending.....
|
||||
// ---------------------------------------------------------------------------------------------------------
|
||||
|
||||
bool T_prot::isPortOpen(void)
|
||||
{
|
||||
return mySerialPort->isPortOpen();
|
||||
}
|
||||
|
||||
bool T_prot::isSerialFree(void)
|
||||
{
|
||||
return true; // ohne HS's kann er nicht blockiert sein
|
||||
}
|
||||
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
void T_prot::setUserReadData( uint16_t ReadCmd, uint16_t RdAddr, uint16_t reserv)
|
||||
{
|
||||
ReadCommand=ReadCmd;
|
||||
ReadAddr=RdAddr;
|
||||
reserve=reserv;
|
||||
SendDataValid |=2;
|
||||
}
|
||||
|
||||
void T_prot::setUserReadData( uint16_t ReadCmd, uint16_t RdAddr)
|
||||
{
|
||||
ReadCommand=ReadCmd;
|
||||
ReadAddr=RdAddr;
|
||||
reserve=0;
|
||||
SendDataValid |=2;
|
||||
}
|
||||
|
||||
void T_prot::setUserReadData( uint16_t ReadCmd)
|
||||
{
|
||||
ReadCommand=ReadCmd;
|
||||
ReadAddr=0;
|
||||
reserve=0;
|
||||
SendDataValid |=2;
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
qDebug()<<"prot: got BL data " << len << "bytes, ";
|
||||
/*
|
||||
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::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]);
|
||||
mySerialPort->writeToSerial(packBuf_2, BLsendDataLength);
|
||||
|
||||
|
||||
} else
|
||||
startPacking();
|
||||
}
|
||||
|
||||
void T_prot::startPacking(void)
|
||||
{
|
||||
uint16_t mycrc;
|
||||
uint16_t uitmp, sendLen;
|
||||
uint8_t uctmp, nn, pp, CrcLp;
|
||||
char sendBuffer[FRAME_MAXLEN], ctmp;
|
||||
|
||||
//qDebug() << "prot start packing "<<slaveAddr;
|
||||
|
||||
for (int nn=0; nn<FRAME_MAXLEN; nn++)
|
||||
sendBuffer[nn]=0;
|
||||
|
||||
sendBuffer[0]='>';
|
||||
uitmp=slaveAddr;
|
||||
sendBuffer[1]= char(uitmp);
|
||||
uitmp>>=8;
|
||||
sendBuffer[2]= char(uitmp);
|
||||
|
||||
uitmp=WriteCommand;
|
||||
sendBuffer[3]= char(uitmp);
|
||||
uitmp>>=8;
|
||||
sendBuffer[4]= char(uitmp);
|
||||
|
||||
uitmp=WriteAddr;
|
||||
sendBuffer[5]= char(uitmp);
|
||||
uitmp>>=8;
|
||||
sendBuffer[6]= char(uitmp);
|
||||
|
||||
uitmp=ReadCommand;
|
||||
sendBuffer[7]= char(uitmp);
|
||||
uitmp>>=8;
|
||||
sendBuffer[8]= char(uitmp);
|
||||
|
||||
uitmp=ReadAddr;
|
||||
sendBuffer[9]= char(uitmp);
|
||||
uitmp>>=8;
|
||||
sendBuffer[10]= char(uitmp);
|
||||
|
||||
uitmp=reserve;
|
||||
sendBuffer[11]= '-'; //char(uitmp);
|
||||
uitmp>>=8;
|
||||
sendBuffer[12]= '-'; //char(uitmp);
|
||||
|
||||
sendBuffer[13]= char(WrDataLength);
|
||||
CrcLp= 14 + WrDataLength;
|
||||
|
||||
if (kindOfData) // 0: binaries, 1:text
|
||||
{
|
||||
for (nn=0; nn<WrDataLength; nn++)
|
||||
{
|
||||
pp=14+nn;
|
||||
ctmp=(chOut_Data[nn]);
|
||||
sendBuffer[pp]= ctmp;
|
||||
}
|
||||
|
||||
} else
|
||||
{
|
||||
for (nn=0; nn<WrDataLength; nn++)
|
||||
{
|
||||
pp=14+nn;
|
||||
uctmp=(ui8OutputData[nn]);
|
||||
sendBuffer[pp]= char(uctmp);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
sendBuffer[CrcLp+2]=13;
|
||||
sendBuffer[CrcLp+3]=10;
|
||||
sendLen+=2;
|
||||
|
||||
// send to VCP:
|
||||
QByteArray packBuff;
|
||||
packBuff.clear();
|
||||
packBuff.append(sendBuffer, sendLen); // ohne sendLen wird beim ersten \0 abgeschnitten!!!
|
||||
mySerialPort->writeToSerial(packBuff, sendLen);
|
||||
// void T_com::writeToSerial(const QByteArray &data, uint16_t sendLength)
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------------------------------------------
|
||||
// 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);
|
||||
|
||||
if (recLength>FRAME_MAXLEN)
|
||||
recLength=FRAME_MAXLEN;
|
||||
for (int nn=0; nn<recLength; nn++)
|
||||
recBuffer[nn]=uint8_t(Indata[nn]);
|
||||
|
||||
myString.clear();
|
||||
tempStr.clear();
|
||||
uint8_t result=FramecheckInData(recBuffer, recLength); // check input data (response from slave)
|
||||
if (result>0)
|
||||
{
|
||||
// dann anzeigen und ende
|
||||
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;
|
||||
|
||||
}
|
||||
myString.setNum(result);
|
||||
|
||||
gpi_storeRawReceivedData(uint8_t(recLength), recBuffer);
|
||||
emit rawDataRecieved();
|
||||
|
||||
} else
|
||||
{
|
||||
//& result ==0
|
||||
gpi_setTxt4masterStateLine("slave response OK");
|
||||
// Daten OK, also prüfe Inhalt.
|
||||
// Konnte der Slave das Master-Command verwenden oder hatte es Fehler?
|
||||
// konnte der Slave die geforderten Daten ausgeben (DOs, AOs)?
|
||||
// konnte der Slave die geforderten Daten einlesen (AIs, DIs)?
|
||||
|
||||
CheckInResult(recBuffer); // Ergebnisse des Slaves anzeigen
|
||||
|
||||
CheckInData(recBuffer); // Eingangs-Daten des Slaves anzeigen
|
||||
}
|
||||
emit framerecieved();
|
||||
//qDebug() << "framereceived emitted";
|
||||
}
|
||||
|
||||
|
||||
|
||||
uint8_t T_prot::FramecheckInData(uint8_t *Inbuf, uint16_t LL)
|
||||
{
|
||||
|
||||
uint16_t rawInLen=LL, crcL_Addr, recCrc, myCrc, nn, datalen, nxt;
|
||||
|
||||
if (rawInLen<12)
|
||||
{
|
||||
qDebug("prot: got %d bytes only", rawInLen);
|
||||
return 1; // wrong length
|
||||
}
|
||||
|
||||
if ( Inbuf[0] != '<')
|
||||
return 2; // wrong start sign
|
||||
|
||||
datalen=uint16_t(Inbuf[9]);
|
||||
if ( datalen > FRAME_DATALEN) //[9]=reported data lenght
|
||||
return 3; // reported datalen too big
|
||||
|
||||
if ((datalen !=(rawInLen-12)) && (datalen !=(rawInLen-13)) && (datalen !=(rawInLen-14)) )
|
||||
{
|
||||
// angehängtes CR und/oder LF tolerieren
|
||||
qDebug() << "wrong data length, " << datalen << " " << rawInLen;
|
||||
return 4; // data len does not match to complete length
|
||||
|
||||
}
|
||||
crcL_Addr=datalen+10; // weil im definierten protocol 10 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
|
||||
}
|
||||
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::CheckInData(uint8_t *recBuffer)
|
||||
{
|
||||
QString myString=nullptr, tempStr=nullptr;
|
||||
|
||||
RecSlaveAddr=recBuffer[1];
|
||||
if (recBuffer[2]==0 && recBuffer[4]==0) // comand result=OK und read result =OK,
|
||||
// dann sind die Eingangsdaten gültig
|
||||
{
|
||||
myString.append("valid INdata: ");
|
||||
INdataValid=true;
|
||||
readSource=uchar2uint(recBuffer[6],recBuffer[5]);
|
||||
readAddress=uchar2uint(recBuffer[8],recBuffer[7]);
|
||||
//lastWakeSrc=uint8_t(recBuffer[4]);
|
||||
RdDataLength=uint8_t(recBuffer[9]);
|
||||
if (RdDataLength>FRAME_DATALEN)
|
||||
RdDataLength=FRAME_DATALEN;
|
||||
for (int ii=0; ii<RdDataLength; ii++)
|
||||
InputData[ii]=uint8_t(recBuffer[ii+10]);
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
bool T_prot::ifDataReceived()
|
||||
{
|
||||
return INdataValid;
|
||||
}
|
||||
|
||||
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
|
||||
//*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];
|
||||
return INdataValid; // nur true wenn CommandState OK und readState OK
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
435
src/sendWRcmd.cpp
Normal file
435
src/sendWRcmd.cpp
Normal file
|
|
@ -0,0 +1,435 @@
|
|||
#include <stdint.h>
|
||||
#include <QString>
|
||||
#include <QDebug>
|
||||
#include "tslib.h"
|
||||
#include "sendWRcmd.h"
|
||||
|
||||
|
||||
void indat_PrnPwr(void);
|
||||
|
||||
|
||||
void sendWRcmd_INI(void)
|
||||
{
|
||||
|
||||
sendWRcmd_clrCmdStack();
|
||||
sendWRcmd_clrCmd4Stack();
|
||||
|
||||
}
|
||||
|
||||
// Command Stack for commands without parameters
|
||||
|
||||
|
||||
static uint16_t nextAsynchsendCmd0[CMDSTACKDEPTH];
|
||||
static uint8_t nrOfCmdsInQueue;
|
||||
/* convention: use simple (not rotating) FIFO Stack:
|
||||
Example: nrOfCmdsInQueue=4 then
|
||||
nextAsynchsendCmd0[0]=cmd1 // was stored as first
|
||||
nextAsynchsendCmd0[1]=cmd2
|
||||
nextAsynchsendCmd0[2]=cmd3
|
||||
nextAsynchsendCmd0[3]=cmd4 // came in as last
|
||||
|
||||
Send: [0] first, then move buffer 1 down:
|
||||
nextAsynchsendCmd0[0]=cmd2
|
||||
nextAsynchsendCmd0[1]=cmd3
|
||||
nextAsynchsendCmd0[2]=cmd4
|
||||
nextAsynchsendCmd0[3]=0;
|
||||
nrOfCmdsInQueue=3 now
|
||||
*/
|
||||
|
||||
void sendWRcmd_clrCmdStack(void)
|
||||
{
|
||||
uint8_t nn;
|
||||
for (nn=0; nn<CMDSTACKDEPTH; nn++)
|
||||
nextAsynchsendCmd0[nn]=0;
|
||||
nrOfCmdsInQueue=0;
|
||||
}
|
||||
|
||||
bool sendWRcmd_setSendCommand0(uint16_t nextCmd)
|
||||
{
|
||||
// write Command to memory, wait for transport
|
||||
if (nrOfCmdsInQueue>=CMDSTACKDEPTH)
|
||||
{
|
||||
qDebug() << "cannot save cmd because stack is full";
|
||||
return false; // not possible
|
||||
}
|
||||
nextAsynchsendCmd0[nrOfCmdsInQueue++]=nextCmd;
|
||||
qDebug() << "PI cmd queued:"<< nextCmd << ", saved, pp=" << nrOfCmdsInQueue;
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
uint16_t sendWRcmd_getSendCommand0(void)
|
||||
{
|
||||
uint16_t nxtAsynchCmd;
|
||||
uint8_t nn;
|
||||
if (nrOfCmdsInQueue==0 || nrOfCmdsInQueue>CMDSTACKDEPTH)
|
||||
return 0; // error
|
||||
nxtAsynchCmd=nextAsynchsendCmd0[0];
|
||||
// move Puffer down by one element
|
||||
for (nn=0; nn<CMDSTACKDEPTH; nn++)
|
||||
nextAsynchsendCmd0[nn]=nextAsynchsendCmd0[nn+1];
|
||||
if (nrOfCmdsInQueue>0)
|
||||
nrOfCmdsInQueue--;
|
||||
qDebug() << "PI cmd queued:"<< nxtAsynchCmd << ", restored, pp now =" << nrOfCmdsInQueue;
|
||||
return nxtAsynchCmd;
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------------------------------------------------
|
||||
// Command Stack for commands with 4 parameters
|
||||
|
||||
|
||||
|
||||
static uint16_t nextAsynchsendCmd4[CMD4STACKDEPTH];
|
||||
static uint8_t nextCmd4para1[CMD4STACKDEPTH];
|
||||
static uint8_t nextCmd4para2[CMD4STACKDEPTH];
|
||||
static uint8_t nextCmd4para3[CMD4STACKDEPTH];
|
||||
static uint8_t nextCmd4para4[CMD4STACKDEPTH];
|
||||
static uint8_t nrOfCmds4InQueue;
|
||||
/* convention: use simple (not rotating) FIFO Stack:
|
||||
Example: nrOfCmdsInQueue=4 then
|
||||
nextAsynchsendCmd0[0]=cmd1 // was stored as first
|
||||
nextAsynchsendCmd0[1]=cmd2
|
||||
nextAsynchsendCmd0[2]=cmd3
|
||||
nextAsynchsendCmd0[3]=cmd4 // came in as last
|
||||
|
||||
Send: [0] first, then move buffer 1 down:
|
||||
nextAsynchsendCmd0[0]=cmd2
|
||||
nextAsynchsendCmd0[1]=cmd3
|
||||
nextAsynchsendCmd0[2]=cmd4
|
||||
nextAsynchsendCmd0[3]=0;
|
||||
nrOfCmdsInQueue=3 now
|
||||
*/
|
||||
|
||||
|
||||
void sendWRcmd_clrCmd4Stack(void)
|
||||
{
|
||||
uint8_t nn;
|
||||
for (nn=0; nn<CMD4STACKDEPTH; nn++)
|
||||
{
|
||||
nextAsynchsendCmd4[nn]=0;
|
||||
nextCmd4para1[nn]=0;
|
||||
nextCmd4para2[nn]=0;
|
||||
nextCmd4para3[nn]=0;
|
||||
nextCmd4para4[nn]=0;
|
||||
}
|
||||
nrOfCmds4InQueue=0;
|
||||
}
|
||||
|
||||
bool sendWRcmd_setSendCommand4(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4)
|
||||
{
|
||||
// write Command to memory, wait for transport
|
||||
if (nrOfCmds4InQueue>=CMD4STACKDEPTH)
|
||||
{
|
||||
qDebug() << "cannot save cmd because stack is full";
|
||||
return false; // not possible
|
||||
}
|
||||
nextAsynchsendCmd4[nrOfCmds4InQueue]=nextCmd;
|
||||
nextCmd4para1[nrOfCmds4InQueue]=dat1;
|
||||
nextCmd4para2[nrOfCmds4InQueue]=dat2;
|
||||
nextCmd4para3[nrOfCmds4InQueue]=dat3;
|
||||
nextCmd4para4[nrOfCmds4InQueue]=dat4;
|
||||
//qDebug() << "data with 4 data byte saved, pp=" << nrOfCmds4InQueue;
|
||||
//qDebug() << " dat1=" << nextCmd4para1[nrOfCmds4InQueue] << " dat2=" << nextCmd4para2[nrOfCmds4InQueue]
|
||||
// << " dat3=" << nextCmd4para3[nrOfCmds4InQueue] << " dat4=" << nextCmd4para4[nrOfCmds4InQueue];
|
||||
nrOfCmds4InQueue++;
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
uint16_t sendWRcmd_getSendCommand4(uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4)
|
||||
{
|
||||
uint16_t nxtAsynchCmd;
|
||||
uint8_t nn;
|
||||
|
||||
if (nrOfCmds4InQueue==0 || nrOfCmds4InQueue>CMD4STACKDEPTH)
|
||||
return 0; // error
|
||||
nxtAsynchCmd=nextAsynchsendCmd4[0];
|
||||
*dat1=nextCmd4para1[0];
|
||||
*dat2=nextCmd4para2[0];
|
||||
*dat3=nextCmd4para3[0];
|
||||
*dat4=nextCmd4para4[0];
|
||||
//qDebug() << "cmd4 restored to send from [0]; pp=" << nrOfCmds4InQueue;
|
||||
//qDebug() << " data1: " << nextCmd4para1[0] << " data2: " << nextCmd4para2[0] <<
|
||||
// " data3: " << nextCmd4para3[0] << " data4: " << nextCmd4para4[0];
|
||||
|
||||
// move Puffer down by one element
|
||||
for (nn=0; nn<CMD4STACKDEPTH; nn++)
|
||||
{
|
||||
nextAsynchsendCmd4[nn]=nextAsynchsendCmd4[nn+1];
|
||||
nextCmd4para1[nn]=nextCmd4para1[nn+1];
|
||||
nextCmd4para2[nn]=nextCmd4para2[nn+1];
|
||||
nextCmd4para3[nn]=nextCmd4para3[nn+1];
|
||||
nextCmd4para4[nn]=nextCmd4para4[nn+1];
|
||||
}
|
||||
if (nrOfCmds4InQueue>0)
|
||||
nrOfCmds4InQueue--;
|
||||
//qDebug() << "cmd4 after push down: pp=" << nrOfCmds4InQueue;
|
||||
return nxtAsynchCmd;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
static uint16_t nextAsynchsendCmd8[CMD8STACKDEPTH];
|
||||
static uint8_t nextCmd8para1[CMD8STACKDEPTH];
|
||||
static uint8_t nextCmd8para2[CMD8STACKDEPTH];
|
||||
static uint16_t nextCmd8para3[CMD8STACKDEPTH];
|
||||
static uint32_t nextCmd8para4[CMD8STACKDEPTH];
|
||||
static uint8_t nrOfCmds8InQueue;
|
||||
|
||||
void sendWRcmd_clrCmd8Stack(void)
|
||||
{
|
||||
uint8_t nn;
|
||||
for (nn=0; nn<CMD8STACKDEPTH; nn++)
|
||||
{
|
||||
nextAsynchsendCmd8[nn]=0;
|
||||
nextCmd8para1[nn]=0;
|
||||
nextCmd8para2[nn]=0;
|
||||
nextCmd8para3[nn]=0;
|
||||
nextCmd8para4[nn]=0;
|
||||
}
|
||||
nrOfCmds8InQueue=0;
|
||||
}
|
||||
|
||||
bool sendWRcmd_setSendCommand8(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uint16_t dat3, uint32_t dat4)
|
||||
{
|
||||
// write Command to memory, wait for transport
|
||||
if (nrOfCmds8InQueue>=CMD8STACKDEPTH)
|
||||
{
|
||||
qDebug() << "cannot save cmd because stack is full";
|
||||
return false; // not possible
|
||||
}
|
||||
nextAsynchsendCmd8[nrOfCmds8InQueue]=nextCmd;
|
||||
nextCmd8para1[nrOfCmds8InQueue]=dat1;
|
||||
nextCmd8para2[nrOfCmds8InQueue]=dat2;
|
||||
nextCmd8para3[nrOfCmds8InQueue]=dat3;
|
||||
nextCmd8para4[nrOfCmds8InQueue]=dat4;
|
||||
nrOfCmds8InQueue++;
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
uint16_t sendWRcmd_getSendCommand8(uint8_t *dat1, uint8_t *dat2, uint16_t *dat3, uint32_t *dat4)
|
||||
{
|
||||
uint16_t nxtAsynchCmd;
|
||||
uint8_t nn;
|
||||
|
||||
if (nrOfCmds8InQueue==0 || nrOfCmds8InQueue>CMD4STACKDEPTH)
|
||||
return 0; // error
|
||||
nxtAsynchCmd=nextAsynchsendCmd8[0];
|
||||
*dat1=nextCmd8para1[0];
|
||||
*dat2=nextCmd8para2[0];
|
||||
*dat3=nextCmd8para3[0];
|
||||
*dat4=nextCmd8para4[0];
|
||||
|
||||
// move buffer down by one element
|
||||
for (nn=0; nn<CMD8STACKDEPTH; nn++)
|
||||
{
|
||||
nextAsynchsendCmd8[nn]=nextAsynchsendCmd8[nn+1];
|
||||
nextCmd8para1[nn]=nextCmd8para1[nn+1];
|
||||
nextCmd8para2[nn]=nextCmd8para2[nn+1];
|
||||
nextCmd8para3[nn]=nextCmd8para3[nn+1];
|
||||
nextCmd8para4[nn]=nextCmd8para4[nn+1];
|
||||
}
|
||||
if (nrOfCmds8InQueue>0)
|
||||
nrOfCmds8InQueue--;
|
||||
return nxtAsynchCmd;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
static uint8_t sendAsynchDataBuf[160]; // no stack, only ONE buffer
|
||||
static uint8_t sendAsyDatLen;
|
||||
|
||||
bool sendWRcmd_setSendBlock160(uint8_t leng, uint8_t *buf)
|
||||
{
|
||||
//qDebug() << "pi epi: storing send data";
|
||||
if (leng>160) leng=160;
|
||||
sendAsyDatLen=leng;
|
||||
tslib_strclr(sendAsynchDataBuf, 0, 160);
|
||||
for (uint8_t nn=0; nn<leng; nn++)
|
||||
sendAsynchDataBuf[nn]=buf[nn];
|
||||
return true; // ok, will be sent
|
||||
}
|
||||
|
||||
uint8_t sendWRcmd_getSendBlock160(uint8_t *leng, uint8_t *buf)
|
||||
{
|
||||
//qDebug() << "pi gpi: restoring send data";
|
||||
*leng=sendAsyDatLen;
|
||||
for (uint8_t nn=0; nn<sendAsyDatLen; nn++)
|
||||
buf[nn]=sendAsynchDataBuf[nn];
|
||||
sendAsyDatLen=0;
|
||||
//tslib_strclr(sendAsynchDataBuf, 0, 64);
|
||||
return *leng;
|
||||
}
|
||||
|
||||
|
||||
// ------------------------------------------------------------------------------------
|
||||
// MDB Sendind Data are store here for next transport to DC (Device Controller)
|
||||
// Transport to Slave runs every 100ms, answer from mdb-slave (e.g. coin changer) comes rigth
|
||||
// with next slave answer
|
||||
|
||||
// start with: SENDDIRCMD_EXCHGMDB,
|
||||
// send crude data from here to DC, DC to mdb slaves, mdb answer, return here within 50ms
|
||||
|
||||
|
||||
static uint8_t Sdata_mdbSendBuffer[64];
|
||||
static uint8_t Sdata_mdbSendLen;
|
||||
|
||||
uint8_t epi_store64ByteSendData(uint8_t length, uint8_t *buf)
|
||||
{
|
||||
// HWapi writes data to be forwarded to DC and further to mdb-device
|
||||
for (uint8_t nn=0; nn<length; nn++)
|
||||
Sdata_mdbSendBuffer[nn]=buf[nn];
|
||||
Sdata_mdbSendLen=length;
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint8_t gpi_restore64ByteSendData(uint8_t *length, uint8_t *buf)
|
||||
{
|
||||
// datif reads data to forward to dc
|
||||
for (uint8_t nn=0; nn<Sdata_mdbSendLen; nn++)
|
||||
buf[nn]=Sdata_mdbSendBuffer[nn];
|
||||
*length=Sdata_mdbSendLen;
|
||||
Sdata_mdbSendLen=0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
//------------------------------------------------------------------------------------
|
||||
//---------------------------------------- Printer Text Fifo -------------------------
|
||||
static uint8_t prnDataParameters[4];
|
||||
static uint8_t prnDataBufferUser;
|
||||
|
||||
void epi_storeUserOfSendingTextBuffer(uint8_t user, uint8_t para1, uint8_t para2, uint8_t para3, uint8_t para4 )
|
||||
{
|
||||
// user=1: Text-Print is using this buffer
|
||||
// 2: QR-code-Printer is using this buffer
|
||||
prnDataBufferUser=user;
|
||||
prnDataParameters[0]=para1;
|
||||
prnDataParameters[1]=para2;
|
||||
prnDataParameters[2]=para3;
|
||||
prnDataParameters[3]=para4;
|
||||
|
||||
// qDebug() << "new user stored: " << user;
|
||||
|
||||
}
|
||||
|
||||
uint8_t gpi_getUserOfSendingTextBuffer(uint8_t *para1, uint8_t *para2, uint8_t *para3, uint8_t *para4)
|
||||
{
|
||||
// user=1: Text-Print is using this buffer
|
||||
// 2: QR-code-Printer is using this buffer
|
||||
//qDebug() << "returning user "<< prnDataBufferUser;
|
||||
|
||||
*para1=prnDataParameters[0];
|
||||
*para2=prnDataParameters[1];
|
||||
*para3=prnDataParameters[2];
|
||||
*para4=prnDataParameters[3];
|
||||
return prnDataBufferUser;
|
||||
|
||||
}
|
||||
|
||||
|
||||
// Sending Text Fifo
|
||||
// ONE printer doc consists of 20 x 64 byte
|
||||
// #define MAXNROF_PRNBYTES 64
|
||||
// #define MAXNROF_PRNBLOCKS 20
|
||||
static char Sdata_PRN_TEXT[MAXNROF_PRNBLOCKS][MAXNROF_PRNBYTES];
|
||||
static uint8_t pPrnDataBuff; // points to next PRINTER_BLOCK
|
||||
|
||||
|
||||
//static uint8_t pPrnDataBuff; // points to next waiting printer text
|
||||
// defined above, needed if more then one text is stored (before sent)
|
||||
// every block will be sent after 100ms, if 8 blocks are stored within this 100ms
|
||||
// then pointer goes up to 8. Important: FIFO!!!!!!!!
|
||||
|
||||
void epi_resetPrinterStack(void)
|
||||
{
|
||||
pPrnDataBuff=0;
|
||||
}
|
||||
|
||||
uint8_t epi_storePrnText(char *buf, uint8_t leng)
|
||||
{
|
||||
// store text from Gui in next higher free memory 0....9
|
||||
|
||||
uint16_t len;
|
||||
uint8_t pp, nn;
|
||||
|
||||
pp=pPrnDataBuff; // next free memory block with 64byte each
|
||||
if (pp>=MAXNROF_PRNBLOCKS)
|
||||
return 1; // not possible, no free mem
|
||||
|
||||
//len=tslib_strlen(buf); // kennt keine Binärzeichen!!!!!!
|
||||
len=leng;
|
||||
if (len>MAXNROF_PRNBYTES)
|
||||
len=MAXNROF_PRNBYTES;
|
||||
|
||||
tslib_strclr(Sdata_PRN_TEXT[pp], 0, MAXNROF_PRNBYTES);
|
||||
|
||||
for (nn=0; nn<len; nn++)
|
||||
Sdata_PRN_TEXT[pp][nn]=buf[nn]; // copy new text into buffer
|
||||
|
||||
if (pPrnDataBuff<MAXNROF_PRNBLOCKS)
|
||||
pPrnDataBuff++; // inc pointer if end not yet reached
|
||||
return 0; // OK
|
||||
}
|
||||
|
||||
|
||||
|
||||
uint8_t gpi_restorePrnText(uint8_t *retbuf)
|
||||
{
|
||||
// read printer text and send to slave, size of retbuf == 64
|
||||
|
||||
// always read from [0] because this is the oldest (Fifo)
|
||||
// then move all text lines down by one and dec pointer
|
||||
|
||||
uint8_t nn, pp=pPrnDataBuff;
|
||||
|
||||
if (pp==0) // next free memory block with 64byte each
|
||||
return 1; // no text in buffer
|
||||
|
||||
// example: pp=5: then buffers [0...4] are occupied
|
||||
|
||||
for (nn=0; nn<MAXNROF_PRNBYTES; nn++)
|
||||
retbuf[nn] = uint8_t (Sdata_PRN_TEXT[0][nn]); // restore oldest text
|
||||
|
||||
// now copy textline [1] to [0], then
|
||||
// copy textline [2] to [1], then
|
||||
// copy textline [3] to [2] .... upto [pp-1] to [pp-2]
|
||||
// hint: copying from 9....0 would delete all strings!!!!!!
|
||||
|
||||
for (nn=0; nn<(pp-1); nn++)
|
||||
tslib_strcpy(Sdata_PRN_TEXT[nn+1], Sdata_PRN_TEXT[nn], MAXNROF_PRNBYTES);
|
||||
if (pPrnDataBuff>0)
|
||||
pPrnDataBuff--;
|
||||
pp=pPrnDataBuff;
|
||||
// example: pp=4: then buffers [0...3] are still occupied, pp=0: all buffers empty
|
||||
|
||||
// now clear highest copyed line (which got free now)
|
||||
tslib_strclr(Sdata_PRN_TEXT[pp], 0, MAXNROF_PRNBYTES);
|
||||
|
||||
// optionally: clear all remaining higher lines:
|
||||
for (nn=(pp+1); nn<MAXNROF_PRNBLOCKS; nn++)
|
||||
tslib_strclr(Sdata_PRN_TEXT[nn], 0, MAXNROF_PRNBYTES);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint8_t gpi_chk4remainingText(void)
|
||||
{
|
||||
// retval: 0: no more textline left (to send) >0: nr of 64byte-blocks
|
||||
return (pPrnDataBuff);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
1516
src/storeINdata.cpp
Normal file
1516
src/storeINdata.cpp
Normal file
File diff suppressed because it is too large
Load Diff
557
src/tslib.cpp
Normal file
557
src/tslib.cpp
Normal file
|
|
@ -0,0 +1,557 @@
|
|||
#include "tslib.h"
|
||||
#include <QThread>
|
||||
|
||||
//tslib::tslib()
|
||||
//{
|
||||
|
||||
|
||||
//}
|
||||
|
||||
|
||||
/*
|
||||
uint16_t tslib::uchar2uint(uint8_t Highbyte, uint8_t Lowbyte)
|
||||
{
|
||||
uint16_t uitmp;
|
||||
uitmp=0;
|
||||
uitmp |= uint8_t(Highbyte);
|
||||
uitmp<<=8;
|
||||
uitmp |= uint8_t(Lowbyte);
|
||||
return uitmp;
|
||||
}
|
||||
|
||||
uint8_t tslib::uint2uchar(uint16_t uival, bool getHighB)
|
||||
{
|
||||
// getHighB: low=GetLowByte
|
||||
uint16_t uitmp=uival;
|
||||
if (getHighB==0)
|
||||
return uint8_t(uitmp);
|
||||
uitmp>>=8;
|
||||
return uint8_t(uitmp);
|
||||
|
||||
}*/
|
||||
|
||||
uint16_t uchar2uint(char Highbyte, char Lowbyte)
|
||||
{
|
||||
uint16_t uitmp;
|
||||
uitmp=0;
|
||||
uitmp |= uint8_t(Highbyte);
|
||||
uitmp<<=8;
|
||||
uitmp |= uint8_t(Lowbyte);
|
||||
return uitmp;
|
||||
}
|
||||
|
||||
uint16_t uchar2uint(uint8_t Highbyte, uint8_t Lowbyte)
|
||||
{
|
||||
uint16_t uitmp;
|
||||
uitmp=0;
|
||||
uitmp |= uint8_t(Highbyte);
|
||||
uitmp<<=8;
|
||||
uitmp |= uint8_t(Lowbyte);
|
||||
return uitmp;
|
||||
}
|
||||
|
||||
uint32_t uchar2ulong(uint8_t Highbyte, uint8_t MHbyte, uint8_t MLbyte, uint8_t Lowbyte)
|
||||
{
|
||||
uint32_t ultmp=0;
|
||||
|
||||
ultmp |= uint8_t(Highbyte);
|
||||
ultmp<<=8;
|
||||
ultmp |= uint8_t(MHbyte);
|
||||
ultmp<<=8;
|
||||
ultmp |= uint8_t(MLbyte);
|
||||
ultmp<<=8;
|
||||
ultmp |= uint8_t(Lowbyte);
|
||||
return ultmp;
|
||||
}
|
||||
|
||||
uint8_t uint2uchar(uint16_t uival, bool getHighB)
|
||||
{
|
||||
// getHighB: low=GetLowByte
|
||||
uint16_t uitmp=uival;
|
||||
if (getHighB==0)
|
||||
return uint8_t(uitmp);
|
||||
uitmp>>=8;
|
||||
return uint8_t(uitmp);
|
||||
|
||||
}
|
||||
|
||||
|
||||
void delay(uint16_t MilliSec)
|
||||
{
|
||||
QThread::msleep(uint32_t(MilliSec));
|
||||
}
|
||||
|
||||
|
||||
void GetTimeString(uint8_t hours, uint8_t minutes, uint8_t seconds, uint8_t System12h, uint8_t ShowSec, uint8_t *buf)
|
||||
{
|
||||
// Zahlenwerte in String wandeln, 12/24h-Format // 12byte für buf!
|
||||
uint8_t usa;
|
||||
uint16_t jj;
|
||||
uint8_t hh, mm, ss, with_sec;
|
||||
|
||||
// buf[0]= ganz linkes Zeichen
|
||||
hh=hours;
|
||||
mm=minutes;
|
||||
ss=seconds;
|
||||
|
||||
// 15.10.12, Plausibilitätsprüfung --------------------------------------------------
|
||||
if (hh>23) hh=0;
|
||||
if (mm>59) mm=0;
|
||||
if (ss>59) ss=0;
|
||||
|
||||
with_sec=ShowSec;
|
||||
for (jj=0; jj<12; jj++) buf[jj]=0;
|
||||
usa = System12h; // 1:12h 0:24h
|
||||
|
||||
// Stunden:
|
||||
if (usa)
|
||||
{
|
||||
// 12h System
|
||||
if (hh==0 || hh==12)
|
||||
{
|
||||
// 12AM (Mitternacht) oder 12PM (Mittag)
|
||||
buf[0]=0x31;
|
||||
buf[1]=0x32;
|
||||
} else
|
||||
if (hh<12)
|
||||
{
|
||||
// 1..11AM
|
||||
buf[0]=hh/10+0x30;
|
||||
buf[1]=hh%10+0x30;
|
||||
} else
|
||||
{
|
||||
//13:00 bis 23Uhr
|
||||
buf[0]=(hh-12)/10+0x30;
|
||||
buf[1]=(hh-12)%10+0x30;
|
||||
}
|
||||
} else
|
||||
{
|
||||
// 24h System
|
||||
buf[0]=hh/10+0x30;
|
||||
buf[1]=hh%10+0x30;
|
||||
}
|
||||
|
||||
// Minuten:
|
||||
buf[2]=':';
|
||||
buf[3]=mm/10+0x30;
|
||||
buf[4]=mm%10+0x30;
|
||||
|
||||
jj=5;
|
||||
if (with_sec)
|
||||
{
|
||||
buf[jj++]=':';
|
||||
buf[jj++]=ss/10+0x30;
|
||||
buf[jj++]=ss%10+0x30;
|
||||
}
|
||||
if (usa)
|
||||
{
|
||||
buf[jj++]=' ';
|
||||
if (hh<12)
|
||||
buf[jj++]='A';
|
||||
else
|
||||
buf[jj++]='P';
|
||||
buf[jj++]='M';
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// ------------------- ********************************************************************************
|
||||
|
||||
void GetDateString(uint8_t day, uint8_t month, uint8_t yearhigh, uint8_t yearlow, uint8_t format, uint8_t sep, uint8_t *buf)
|
||||
{
|
||||
// generate date as ascii string from integers day/month/year
|
||||
// yearhigh: 10..29, in europe always 20 (not in arabia!) comes as hex number, e.g. 0x20
|
||||
// format= 0: dd.mm.yyyy (deutsch)
|
||||
// 1: mm.dd.yyyy (amerika)
|
||||
// 2: yyyy.mm.dd (Iran, Dubai)
|
||||
// 3: dd.yyyy.mm
|
||||
// 4: mm.yyyy.dd
|
||||
// 5: yyyy.dd.mm
|
||||
// sep: 0: use . as seperator 1: use / as seperator
|
||||
// return String in *buf // 11byte für buf!
|
||||
|
||||
|
||||
uint8_t tag, mon, jahr, d10, d1, m10, m1, y1000, y100, y10, y1;
|
||||
uint8_t slash;
|
||||
|
||||
|
||||
y100= (yearhigh & 0x0F)+0x30;
|
||||
y1000=((yearhigh & 0xF0)>>4)+0x30;
|
||||
// if (yearhigh>=20)
|
||||
// {
|
||||
// y1000='2';
|
||||
// y100=28+yearhigh; // '0' + (yearhigh-20)
|
||||
// } else
|
||||
// if (yearhigh<20)
|
||||
// {
|
||||
// y1000='1';
|
||||
// y100=38-yearhigh; // '9' - (19-yearhigh)
|
||||
// }
|
||||
|
||||
tag=day;
|
||||
mon=month;
|
||||
jahr=yearlow;
|
||||
|
||||
if (mon>12 || mon==0) mon=1; // 23.10.12
|
||||
if (tag>31 || tag==0) tag=1;
|
||||
if (jahr>50 || jahr<11) jahr=1;
|
||||
|
||||
if (sep==0)
|
||||
slash='.'; // slash==0
|
||||
else if (sep==1)
|
||||
slash='/';
|
||||
else
|
||||
if (sep>=0x20)
|
||||
slash=sep;
|
||||
else
|
||||
slash='.';
|
||||
|
||||
d10 =tag/10;
|
||||
d1 =tag%10;
|
||||
m10 =mon/10;
|
||||
m1 =mon%10;
|
||||
y10 =jahr/10;
|
||||
y1 =jahr%10;
|
||||
|
||||
d10 +=0x30; // in Asccii wandeln
|
||||
d1 +=0x30;
|
||||
m10 +=0x30;
|
||||
m1 +=0x30;
|
||||
y10 +=0x30;
|
||||
y1 +=0x30;
|
||||
|
||||
switch (format)
|
||||
{
|
||||
// 0: dd.mm.yyyy
|
||||
case 0: buf[0]=d10; buf[1]=d1; buf[2]=slash; buf[3]=m10; buf[4]=m1; buf[5]=slash;
|
||||
buf[6]=y1000; buf[7]=y100; buf[8]=y10; buf[9]=y1; break;
|
||||
|
||||
// 1: mm.dd.yyyy
|
||||
case 1: buf[0]=m10; buf[1]=m1; buf[2]=slash; buf[3]=d10; buf[4]=d1; buf[5]=slash;
|
||||
buf[6]=y1000; buf[7]=y100; buf[8]=y10; buf[9]=y1; break;
|
||||
|
||||
// 2: yyyy.mm.dd
|
||||
case 2: buf[0]=y1000; buf[1]=y100; buf[2]=y10; buf[3]=y1; buf[4]=slash; buf[5]=m10;
|
||||
buf[6]=m1; buf[7]=slash; buf[8]=d10; buf[9]=d1; break;
|
||||
|
||||
// 3: dd.yyyy.mm
|
||||
case 3: buf[0]=d10; buf[1]=d1; buf[2]=slash; buf[3]=y1000; buf[4]=y100;
|
||||
buf[5]=y10; buf[6]=y1; buf[7]=slash; buf[8]=m10; buf[9]=m1; break;
|
||||
|
||||
// 4: mm.yyyy.dd
|
||||
case 4: buf[0]=m10; buf[1]=m1; buf[2]=slash; buf[3]=y1000; buf[4]=y100;
|
||||
buf[5]=y10; buf[6]=y1; buf[7]=slash; buf[8]=d10; buf[9]=d1; break;
|
||||
|
||||
// 5: yyyy.dd.mm
|
||||
case 5: buf[0]=y1000; buf[1]=y100; buf[2]=y10; buf[3]=y1; buf[4]=slash; buf[5]=d10;
|
||||
buf[6]=d1; buf[7]=slash; buf[8]=m10; buf[9]=m1; break;
|
||||
|
||||
}
|
||||
buf[10]=0;
|
||||
|
||||
|
||||
}
|
||||
|
||||
// ------------------- ********************************************************************************
|
||||
|
||||
void GetShortDateString(uint8_t day, uint8_t month, uint8_t yearlow, uint8_t format, uint8_t sep, uint8_t *buf)
|
||||
{
|
||||
// generate date as ascii string from integers day/month/year
|
||||
// format= 0: dd.mm.yy (deutsch)
|
||||
// 1: mm.dd.yy (amerika)
|
||||
// 2: yy.mm.dd (Iran, Dubai)
|
||||
// 3: dd.yy.mm
|
||||
// 4: mm.yy.dd
|
||||
// 5: yy.dd.mm
|
||||
// sep: 0: use . as seperator 1: use / as seperator
|
||||
// return String in *buf // 11byte für buf!
|
||||
|
||||
|
||||
uint8_t tag, mon, jahr, d10, d1, m10, m1, y10, y1;
|
||||
uint8_t slash;
|
||||
|
||||
|
||||
tag=day;
|
||||
mon=month;
|
||||
jahr=yearlow;
|
||||
|
||||
if (mon>12 || mon==0) mon=1; // 23.10.12
|
||||
if (tag>31 || tag==0) tag=1;
|
||||
if (jahr>50 || jahr<11) jahr=1;
|
||||
|
||||
if (sep==0)
|
||||
slash='.'; // slash==0
|
||||
else if (sep==1)
|
||||
slash='/';
|
||||
else if (sep>=0x20)
|
||||
slash=sep;
|
||||
else
|
||||
slash='.';
|
||||
|
||||
d10 =tag/10;
|
||||
d1 =tag%10;
|
||||
m10 =mon/10;
|
||||
m1 =mon%10;
|
||||
y10 =jahr/10;
|
||||
y1 =jahr%10;
|
||||
|
||||
d10 +=0x30; // in Asccii wandeln
|
||||
d1 +=0x30;
|
||||
m10 +=0x30;
|
||||
m1 +=0x30;
|
||||
y10 +=0x30;
|
||||
y1 +=0x30;
|
||||
|
||||
switch (format)
|
||||
{
|
||||
// 0: dd.mm.yyyy
|
||||
case 0: buf[0]=d10; buf[1]=d1; buf[2]=slash; buf[3]=m10; buf[4]=m1; buf[5]=slash;
|
||||
buf[6]=y10; buf[7]=y1; break;
|
||||
|
||||
// 1: mm.dd.yyyy
|
||||
case 1: buf[0]=m10; buf[1]=m1; buf[2]=slash; buf[3]=d10; buf[4]=d1; buf[5]=slash;
|
||||
buf[6]=y10; buf[7]=y1; break;
|
||||
|
||||
// 2: yyyy.mm.dd
|
||||
case 2: buf[0]=y10; buf[1]=y1; buf[2]=slash; buf[3]=m10;
|
||||
buf[4]=m1; buf[5]=slash; buf[6]=d10; buf[7]=d1; break;
|
||||
|
||||
// 3: dd.yyyy.mm
|
||||
case 3: buf[0]=d10; buf[1]=d1; buf[2]=slash;
|
||||
buf[3]=y10; buf[4]=y1; buf[5]=slash; buf[6]=m10; buf[7]=m1; break;
|
||||
|
||||
// 4: mm.yyyy.dd
|
||||
case 4: buf[0]=m10; buf[1]=m1; buf[2]=slash;
|
||||
buf[3]=y10; buf[4]=y1; buf[5]=slash; buf[6]=d10; buf[7]=d1; break;
|
||||
|
||||
// 5: yyyy.dd.mm
|
||||
case 5: buf[0]=y10; buf[1]=y1; buf[2]=slash; buf[3]=d10;
|
||||
buf[4]=d1; buf[5]=slash; buf[6]=m10; buf[7]=m1; break;
|
||||
|
||||
}
|
||||
buf[8]=0;
|
||||
|
||||
|
||||
}
|
||||
|
||||
uint16_t tslib_strlen(char *buf)
|
||||
{
|
||||
uint16_t nn;
|
||||
|
||||
for (nn=0; nn<0xFFF0; nn++)
|
||||
if (buf[nn]==0)
|
||||
return nn;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void tslib_strclr(char *buf, char clrsign, uint16_t len)
|
||||
{
|
||||
uint16_t nn;
|
||||
|
||||
for (nn=0; nn<len; nn++)
|
||||
buf[nn]=clrsign;
|
||||
|
||||
}
|
||||
|
||||
void tslib_strclr(uint8_t *buf, char clrsign, uint16_t len)
|
||||
{
|
||||
uint16_t nn;
|
||||
|
||||
for (nn=0; nn<len; nn++)
|
||||
buf[nn]=uint8_t (clrsign);
|
||||
|
||||
}
|
||||
|
||||
|
||||
void tslib_strcpy(char *srcbuf, char *destbuf, uint16_t len)
|
||||
{
|
||||
uint16_t nn;
|
||||
|
||||
for (nn=0; nn<len; nn++)
|
||||
destbuf[nn]=srcbuf[nn];
|
||||
|
||||
}
|
||||
|
||||
void tslib_strcpy(char *srcbuf, uint8_t *destbuf, uint16_t len)
|
||||
{
|
||||
uint16_t nn;
|
||||
|
||||
for (nn=0; nn<len; nn++)
|
||||
destbuf[nn]=uint8_t(srcbuf[nn]);
|
||||
|
||||
}
|
||||
|
||||
void tslib_strcpy(uint8_t *srcbuf, uint8_t *destbuf, uint16_t len)
|
||||
{
|
||||
uint16_t nn;
|
||||
|
||||
for (nn=0; nn<len; nn++)
|
||||
destbuf[nn]=srcbuf[nn];
|
||||
|
||||
}
|
||||
|
||||
bool tslib_isDecAsciiNumber(char sign)
|
||||
{
|
||||
if (sign>=0x30 && sign<=0x39)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool tslib_isHexAsciiNumber(char sign)
|
||||
{
|
||||
if (sign>=0x30 && sign<=0x39)
|
||||
return true;
|
||||
if (sign>=0x61 && sign<=0x66) // a...f
|
||||
return true;
|
||||
if (sign>=0x41 && sign<=0x46) // A...F
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
int tslib_getMinimum(int val1, int val2)
|
||||
{
|
||||
if (val1<val2)
|
||||
return val1;
|
||||
return val2;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void tslib_text2array(QByteArray text, char *aray, uint16_t maxArayLen)
|
||||
{
|
||||
QByteArray sloc;
|
||||
int ii, LL=text.length();
|
||||
|
||||
if (LL>maxArayLen) LL=maxArayLen;
|
||||
for (ii=0; ii<LL; ii++)
|
||||
{
|
||||
aray[ii]=text.at(ii);
|
||||
}
|
||||
if (LL==maxArayLen)
|
||||
aray[LL-1]=0;
|
||||
else
|
||||
aray[LL]=0;
|
||||
}
|
||||
|
||||
|
||||
// -----------------------------------------------------------------------------------------------
|
||||
// functions for DeviceController's Bootloader ---------------------------------------------------
|
||||
// -----------------------------------------------------------------------------------------------
|
||||
/*
|
||||
uint16_t tslib_calcCrcCcitt(uint16_t BufLength, uint8_t *buf)
|
||||
{
|
||||
uint8_t nn, B15H, element;
|
||||
uint16_t crc = 0x84cf;
|
||||
|
||||
while (BufLength--)
|
||||
{
|
||||
element = *buf++;
|
||||
for (nn = 0; nn < 8; nn++)
|
||||
{
|
||||
B15H = 0;
|
||||
if(crc & 0x8000)
|
||||
B15H = 1;
|
||||
crc = (crc << 1) | ((element >> (7 - nn)) & 0x01);
|
||||
if (B15H)
|
||||
{
|
||||
crc ^= 0x1021;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (nn = 0; nn < 16; nn++)
|
||||
{
|
||||
B15H = 0;
|
||||
if(crc & 0x8000)
|
||||
B15H = 1;
|
||||
crc = (crc << 1) | 0x00;
|
||||
if (B15H)
|
||||
{
|
||||
crc ^= 0x1021;
|
||||
}
|
||||
}
|
||||
return crc;
|
||||
|
||||
}
|
||||
|
||||
static uint8_t LastBLcmd; // stored the last sent cmd in order to analys response
|
||||
// cmd echo'ed: error cmd or'ed with 0x80: OK
|
||||
|
||||
uint8_t tslib_prepareDC_BLcmd(uint8_t Cmd, uint8_t SendDataLength, uint8_t *sendData, uint8_t *outBuf)
|
||||
{
|
||||
// make BL protocol, retval = outbuf length (5...133)
|
||||
// bring data in correct form: start always with 0x02 finish with 0x03 and append checksum
|
||||
// 0x02 Cmd < ...sendData ..> CRC CRC 0x03
|
||||
// Data length = 0...64
|
||||
// special conversion: if data contain 2 or 3 (STX, ETX) then write two bytes: 0x1B (=ESC) and data|0x80
|
||||
// so maxlength = 5 + 2 x 64 (if all data are 2 or 3) without 2,3: maxlength = 5 + 64
|
||||
|
||||
uint8_t myBuf[140], pp=0, nn, uctmp, currLen=0;
|
||||
uint16_t calcCrc;
|
||||
|
||||
tslib_strclr(myBuf, 0, 140);
|
||||
|
||||
myBuf[pp++]=2; // STX
|
||||
myBuf[pp++]=Cmd;
|
||||
LastBLcmd=Cmd;
|
||||
|
||||
// append data:
|
||||
for (nn=0; nn<SendDataLength; nn++)
|
||||
{
|
||||
uctmp=sendData[nn];
|
||||
if (uctmp==2 || uctmp==3) // STX or ETX in normal data!
|
||||
{
|
||||
myBuf[pp++]=0x1B; // ESC
|
||||
myBuf[pp++]=uctmp | 0x80;
|
||||
} else
|
||||
myBuf[pp++]=uctmp;
|
||||
}
|
||||
currLen=pp;
|
||||
|
||||
// calc crc: (over cmd and data, without STX)
|
||||
calcCrc=tslib_calcCrcCcitt(uint16_t(currLen), myBuf);
|
||||
myBuf[pp++]=uint8_t(calcCrc & 0x00FF);
|
||||
myBuf[pp++]=uint8_t((calcCrc>>8) & 0x00FF);
|
||||
myBuf[pp++]=3;
|
||||
currLen=pp;
|
||||
|
||||
return currLen;
|
||||
}
|
||||
|
||||
// some special commands (right out of bootloader manual)
|
||||
uint8_t tslib_readBLversion(uint8_t *sendData)
|
||||
{
|
||||
// minimum size of sendData-buffer: 5byte retval: length
|
||||
uint8_t myBuf[2];
|
||||
tslib_strclr(myBuf, 0, 2);
|
||||
return tslib_prepareDC_BLcmd(0x11, 0, myBuf, sendData);
|
||||
}
|
||||
|
||||
uint8_t tslib_readFWversion(uint8_t *sendData)
|
||||
{
|
||||
// minimum size of sendData-buffer: 5byte retval: length
|
||||
uint8_t myBuf[2];
|
||||
tslib_strclr(myBuf, 0, 2);
|
||||
return tslib_prepareDC_BLcmd(0x12, 0, myBuf, sendData);
|
||||
}
|
||||
|
||||
uint8_t tslib_exitBL(uint8_t *sendData)
|
||||
{
|
||||
// minimum size of sendData-buffer: 5byte retval: length
|
||||
uint8_t myBuf[2];
|
||||
tslib_strclr(myBuf, 0, 2);
|
||||
return tslib_prepareDC_BLcmd(0x18, 0, myBuf, sendData);
|
||||
}
|
||||
|
||||
uint8_t tslib_sendFlashStartAddr2BL(uint32_t startAddr, uint8_t *sendData)
|
||||
{
|
||||
// minimum size of sendData-buffer: 13byte retval: length (9...13)
|
||||
uint8_t myBuf[2];
|
||||
tslib_strclr(myBuf, 0, 2);
|
||||
return tslib_prepareDC_BLcmd(0x11, 0, myBuf, sendData);
|
||||
}
|
||||
*/
|
||||
|
||||
// -----------------------------------------------------------------------------------------------
|
||||
|
||||
Loading…
Reference in New Issue
Block a user