|
|
#include "mainwindow.h"
|
|
|
#include <iostream>
|
|
|
#include <QNetworkInterface>
|
|
|
|
|
|
MainWindow::MainWindow(QWidget *parent)
|
|
|
: QWidget(parent)
|
|
|
{
|
|
|
parsingContinue = false;
|
|
|
totalOfBytes = 0;
|
|
|
totalOfPackets = 0;
|
|
|
|
|
|
analyserSGSEServerTC = new QTcpServer();
|
|
|
analyserSGSEServerTM = new QTcpServer();
|
|
|
|
|
|
socketTC = NULL;
|
|
|
socketTM = NULL;
|
|
|
socketEchoServer = new QTcpSocket();
|
|
|
|
|
|
//****
|
|
|
// XML
|
|
|
// xml handlers
|
|
|
xmlHandler = new LFRXmlHandler();
|
|
|
// xml sources
|
|
|
sourceTC = new QXmlInputSource();
|
|
|
// xml writer
|
|
|
lfrXmlWriter = new LFRXmlWriter();
|
|
|
// setup xml parser for the echo bridge
|
|
|
lfrXmlParser = new LFRXmlParser();
|
|
|
|
|
|
UI = new MainWindowUI();
|
|
|
readSettings();
|
|
|
this->UI->serverTMEchoDialogBox->setIP(echoBridgeIP0, echoBridgeIP1, echoBridgeIP2, echoBridgeIP3);
|
|
|
|
|
|
lfrXmlParser->generalCCSDSPacketStore = &this->generalCCSDSPacketStore;
|
|
|
|
|
|
initSocketStatesList();
|
|
|
|
|
|
this->setLayout(UI->layout());
|
|
|
|
|
|
connect(this->UI->button_openServerTCTM, SIGNAL(clicked()), this, SLOT(listenOnTCTMPorts()));
|
|
|
connect(this->UI->button_testServerTCTM, SIGNAL(clicked()), this, SLOT(testTCTMPorts()));
|
|
|
connect(this->UI->button_openSocketEchoServer, SIGNAL(clicked()), this, SLOT(openEchoServer()));
|
|
|
//
|
|
|
connect(this->analyserSGSEServerTC, SIGNAL(newConnection()), this, SLOT(newConnectionOnTCServer()));
|
|
|
connect(this->analyserSGSEServerTM, SIGNAL(newConnection()), this, SLOT(newConnectionOnTMServer()));
|
|
|
//
|
|
|
connect(this, SIGNAL(socketTMHasChanged(QTcpSocket*)), this->lfrXmlWriter, SLOT(setSocketTM(QTcpSocket*)));
|
|
|
connect(this->UI->button_TCAcknowledgement, SIGNAL(clicked()), this->lfrXmlWriter, SLOT(sendXML_TC_Acknowledgment()));
|
|
|
connect(this->UI->button_TCRejection, SIGNAL(clicked()), this->lfrXmlWriter, SLOT(sendXML_TC_rejection()));
|
|
|
connect(this->UI->button_GSEHK, SIGNAL(clicked()), this->lfrXmlWriter, SLOT(sendXML_GSE_HK()));
|
|
|
|
|
|
// socket echo server
|
|
|
connect(this->socketEchoServer, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
|
|
|
this, SLOT(socket_TMEcho_ServerHasChanged()));
|
|
|
connect(this->socketEchoServer, SIGNAL(readyRead()),
|
|
|
this, SLOT(readDataOnSocketEchoServer()));
|
|
|
|
|
|
// display on console
|
|
|
connect(this->xmlHandler, SIGNAL(displayMessage(QString)),
|
|
|
this, SLOT(displayOnConsole(QString)));
|
|
|
connect(this->UI->hkDisplay, SIGNAL(displayMessage(QString)),
|
|
|
this, SLOT(displayOnConsole(QString)));
|
|
|
connect(this->lfrXmlParser, SIGNAL(sendMessage(QString)),
|
|
|
this, SLOT(displayOnConsole(QString)));
|
|
|
//
|
|
|
connect(this->lfrXmlParser, SIGNAL(processPacketStore()),
|
|
|
this, SLOT(processPacketStore()));
|
|
|
//
|
|
|
connect(this->UI->button_resetStatistics, SIGNAL(clicked()),
|
|
|
this, SLOT(resetStatistics()));
|
|
|
|
|
|
displayNetworkInterfaces();
|
|
|
|
|
|
this->xmlHandler->packetStoreHasChanged(&generalCCSDSPacketStore);
|
|
|
};
|
|
|
|
|
|
MainWindow::~MainWindow()
|
|
|
{
|
|
|
|
|
|
}
|
|
|
|
|
|
void MainWindow::displayNetworkInterfaces()
|
|
|
{
|
|
|
QList<QHostAddress> list = QNetworkInterface::allAddresses();
|
|
|
this->displayOnConsole("Network interfaces:");
|
|
|
for(int nIter=0; nIter<list.count(); nIter++)
|
|
|
{
|
|
|
this->UI->displayOnConsole(list[nIter].toString());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void MainWindow::listenOnTCTMPorts()
|
|
|
{
|
|
|
QString str;
|
|
|
|
|
|
//***
|
|
|
// TC
|
|
|
analyserSGSEServerTC->listen(QHostAddress::Any, this->UI->getTCPort());
|
|
|
str = analyserSGSEServerTC->errorString();
|
|
|
if (!str.isEmpty())
|
|
|
{
|
|
|
this->displayOnConsole(str);
|
|
|
}
|
|
|
this->displayOnConsole("Listening TC on port "
|
|
|
+ QString::number(this->UI->getTCPort())
|
|
|
);
|
|
|
|
|
|
//***
|
|
|
// TM
|
|
|
analyserSGSEServerTM->listen(QHostAddress::Any, this->UI->getTMPort());
|
|
|
str = analyserSGSEServerTM->errorString();
|
|
|
if (!str.isEmpty())
|
|
|
{
|
|
|
this->displayOnConsole(str);
|
|
|
}
|
|
|
this->displayOnConsole("Listening TM on port "
|
|
|
+ QString::number(this->UI->getTMPort())
|
|
|
);
|
|
|
}
|
|
|
|
|
|
void MainWindow::testTCTMPorts()
|
|
|
{
|
|
|
if (socketTC != NULL)
|
|
|
{
|
|
|
this->displayOnConsole("TC socket *** " + socketStates.at(socketTC->state()) );
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
this->displayOnConsole("TC socket *** not tested, (socketTC) is NULL" );
|
|
|
}
|
|
|
if (socketTM != NULL)
|
|
|
{
|
|
|
this->displayOnConsole("TM socket *** " + socketStates.at(socketTM->state()) );
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
this->displayOnConsole("TM socket *** not tested, (socketTM) is NULL" );
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void MainWindow::newConnectionOnTCServer()
|
|
|
{
|
|
|
this->displayOnConsole("got new connection on TC port");
|
|
|
socketTC = analyserSGSEServerTC->nextPendingConnection();
|
|
|
this->displayOnConsole("TC socket *** " + socketStates.at(socketTC->state()) );
|
|
|
connect(this->socketTC, SIGNAL(readyRead()), this, SLOT(readDataOnTCPort()));
|
|
|
}
|
|
|
|
|
|
void MainWindow::newConnectionOnTMServer()
|
|
|
{
|
|
|
this->displayOnConsole("got new connection on TM port");
|
|
|
socketTM = analyserSGSEServerTM->nextPendingConnection();
|
|
|
this->displayOnConsole("TM socket *** " + socketStates.at(socketTM->state()) );
|
|
|
connect(this->socketTM, SIGNAL(readyRead()), this, SLOT(readDataOnTMPort()));
|
|
|
|
|
|
emit socketTMHasChanged(this->socketTM);
|
|
|
}
|
|
|
|
|
|
void MainWindow::readDataOnTCPort()
|
|
|
{
|
|
|
bool ok;
|
|
|
int nbBytesAvailable = 0;
|
|
|
|
|
|
nbBytesAvailable = socketTC->bytesAvailable();
|
|
|
buffer = (char *) malloc(nbBytesAvailable);
|
|
|
socketTC->read(buffer, nbBytesAvailable);
|
|
|
|
|
|
this->displayOnConsole("readDataOnTCPort *** "
|
|
|
+ QString::number(nbBytesAvailable)
|
|
|
+ " read");
|
|
|
|
|
|
QByteArray xmlData( buffer, nbBytesAvailable);
|
|
|
|
|
|
free(buffer);
|
|
|
|
|
|
sourceTC->setData( xmlData );
|
|
|
|
|
|
xmlReader.setContentHandler(xmlHandler);
|
|
|
xmlReader.setErrorHandler(xmlHandler);
|
|
|
|
|
|
ok = xmlReader.parse(sourceTC);
|
|
|
if (!ok) {
|
|
|
std::cout << "Parsing failed." << std::endl;
|
|
|
}
|
|
|
else {
|
|
|
QStringList names = xmlHandler->names();
|
|
|
QList<int> indentations = xmlHandler->indentations();
|
|
|
|
|
|
int items = names.count();
|
|
|
|
|
|
for (int i = 0; i < items; ++i) {
|
|
|
displayOnConsole(
|
|
|
names[i]
|
|
|
+ " --- identations: "
|
|
|
+ QString::number(indentations[i]));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void MainWindow::readDataOnTMPort()
|
|
|
{
|
|
|
this->displayOnConsole("TM data received, begin parsing");
|
|
|
}
|
|
|
|
|
|
void MainWindow::readDataOnSocketEchoServer()
|
|
|
{
|
|
|
QString dataString;
|
|
|
|
|
|
dataArray.append(socketEchoServer->readAll());
|
|
|
dataString = QString::fromAscii(dataArray);
|
|
|
this->lfrXmlParser->processIncomingStr(dataString);
|
|
|
dataArray.clear();
|
|
|
}
|
|
|
|
|
|
void MainWindow::displayOnConsole(QString message)
|
|
|
{
|
|
|
this->UI->displayOnConsole( message );
|
|
|
}
|
|
|
|
|
|
void MainWindow::initSocketStatesList()
|
|
|
{
|
|
|
socketStates.append("The socket is not connected");
|
|
|
socketStates.append("The socket is performing a host name lookup");
|
|
|
socketStates.append("The socket has started establishing a connection");
|
|
|
socketStates.append("A connection is established");
|
|
|
socketStates.append("The socket is bound to an address and port (for servers)");
|
|
|
socketStates.append("The socket is about to close (data may still be waiting to be written)");
|
|
|
socketStates.append("For internal use only");
|
|
|
}
|
|
|
|
|
|
void MainWindow::openEchoServer()
|
|
|
{
|
|
|
socketEchoServer->connectToHost(this->UI->serverTMEchoDialogBox->getIP(),
|
|
|
this->UI->spinbox_serverTMEchoPort->value());
|
|
|
//socketEchoServer->open();
|
|
|
}
|
|
|
|
|
|
void MainWindow::socket_TMEcho_ServerHasChanged()
|
|
|
{
|
|
|
this->displayOnConsole("TM Echo Socket socket *** " + socketStates.at(socketEchoServer->state()) );
|
|
|
}
|
|
|
|
|
|
void MainWindow::preProcessPacket(TMPacketToRead *packet)
|
|
|
{
|
|
|
unsigned char pid = 0;
|
|
|
unsigned char cat = 0;
|
|
|
unsigned char typ = 0;
|
|
|
unsigned char sub = 0;
|
|
|
unsigned int sid = 0;
|
|
|
unsigned int length = 0;
|
|
|
unsigned int coarse_t = 0;
|
|
|
unsigned int fine_t = 0;
|
|
|
|
|
|
//*********************************
|
|
|
// get the parameters of the packet
|
|
|
pid = ((packet->Value[4] & 0x07) << 4) + ((packet->Value[5] & 0xf0) >> 4);
|
|
|
cat = packet->Value[5] & 0x0f;
|
|
|
typ = packet->Value[11]; // TYPE
|
|
|
sub = packet->Value[12]; // SUBTYPE
|
|
|
sid = 0;
|
|
|
length = packet->Value[8] * 256 + packet->Value[9];
|
|
|
// compare length in the packet with the size of the packet
|
|
|
if ( (length + 1 + 10) != (packet->size))
|
|
|
{
|
|
|
displayOnConsole("reception of " + QString::number(packet->size)
|
|
|
+ " bytes instead of " + QString::number(length + 1 + 10));
|
|
|
}
|
|
|
coarse_t = packet->Value[14] * pow(2, 24) + packet->Value[15] * pow(2, 16)
|
|
|
+ packet->Value[16] * pow(2, 8) + packet->Value[17];
|
|
|
fine_t = packet->Value[18] * pow(2, 8) + packet->Value[19];
|
|
|
|
|
|
if ((pid == 76) & (cat == 1) & (typ == 1) & (sub == 8))
|
|
|
sid = packet->Value[20] * 256 + packet->Value[21];
|
|
|
else if ((pid == 76) & (cat == 4) & (typ == 3) & (sub == 25))
|
|
|
sid = 1;
|
|
|
else if ((pid == 76) & (cat == 12) & (typ == 21) & (sub == 3))
|
|
|
sid = packet->Value[20];
|
|
|
else if ((pid == 79) & (cat == 12) & (typ == 21) & (sub == 3))
|
|
|
sid = packet->Value[20];
|
|
|
|
|
|
this->UI->tmStatistics->updateStatistics(pid, cat, typ, sub, sid, length, coarse_t, fine_t);
|
|
|
|
|
|
//***************************************************
|
|
|
// if the packet is an HK packet, display its content
|
|
|
if ( (typ == TYPE_HK) & (sub == SUBTYPE_HK) )
|
|
|
{
|
|
|
this->UI->hkDisplay->displayPacket(packet);
|
|
|
}
|
|
|
|
|
|
//****************************************
|
|
|
// if the packet is a waveform, display it
|
|
|
if ( (typ == 21) & (sub == 3) )
|
|
|
{
|
|
|
sid = packet->Value[20]; // SID
|
|
|
switch (sid){
|
|
|
case SID_NORMAL_SWF_F0:
|
|
|
buildWFAndDisplay(packet, &wfPacketNormal[0], 0);
|
|
|
break;
|
|
|
case SID_NORMAL_SWF_F1:
|
|
|
buildWFAndDisplay(packet, &wfPacketNormal[1], 1);
|
|
|
break;
|
|
|
case SID_NORMAL_SWF_F2:
|
|
|
buildWFAndDisplay(packet, &wfPacketNormal[2], 2);
|
|
|
break;
|
|
|
case SID_NORMAL_CWF_F3:
|
|
|
buildWFAndDisplay(packet, &wfPacketNormal[3], 3);
|
|
|
break;
|
|
|
case SID_BURST_CWF_F2:
|
|
|
buildWFAndDisplayBurst(packet, &wfPacketBurst);
|
|
|
break;
|
|
|
case SID_SBM1_CWF_F1:
|
|
|
buildWFAndDisplaySBM1(packet, &wfPacketSBM1);
|
|
|
break;
|
|
|
case SID_SBM2_CWF_F2:
|
|
|
buildWFAndDisplaySBM2(packet, &wfPacketSBM2);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void MainWindow::buildWFAndDisplay(TMPacketToRead *packet, WFPacket *wfPacket, unsigned char num_page)
|
|
|
{
|
|
|
unsigned int i = 0;
|
|
|
unsigned int j = 0;
|
|
|
unsigned char *data;
|
|
|
unsigned char pkt_nr = 0;
|
|
|
unsigned int blk_nr = 0;
|
|
|
|
|
|
pkt_nr = packet->Value[23]; // PKT_NR
|
|
|
blk_nr = packet->Value[30] * 256 + packet->Value[31];
|
|
|
data = &packet->Value[32]; // start of the first data block;
|
|
|
j = (pkt_nr-1) * 340;
|
|
|
for ( i=0; i<blk_nr; i++ ){
|
|
|
wfPacket->wf_e1[j + i] = (short) ( (data[ (i * BLK_SIZE) ] << 8) + (data[ (i*BLK_SIZE) + 1]) );
|
|
|
wfPacket->wf_v[j + i] = (short) ( (data[ (i * BLK_SIZE) + 2] << 8) + (data[ (i*BLK_SIZE) + 3]) );
|
|
|
wfPacket->wf_b1[j + i] = (short) ( (data[ (i * BLK_SIZE) + 4] << 8) + (data[ (i*BLK_SIZE) + 5]) );
|
|
|
wfPacket->wf_e2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 6] << 8) + (data[ (i*BLK_SIZE) + 7]) );
|
|
|
wfPacket->wf_b3[j + i] = (short) ( (data[ (i * BLK_SIZE) + 8] << 8) + (data[ (i*BLK_SIZE) + 9]) );
|
|
|
wfPacket->wf_b2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 10] << 8) + (data[ (i*BLK_SIZE) + 11]) );
|
|
|
}
|
|
|
if (pkt_nr == 7)
|
|
|
{
|
|
|
this->UI->wfDisplay->displayOnPlot(wfPacket->wf_v, num_page, 0);
|
|
|
this->UI->wfDisplay->displayOnPlot(wfPacket->wf_e1, num_page, 1);
|
|
|
this->UI->wfDisplay->displayOnPlot(wfPacket->wf_e2, num_page, 2);
|
|
|
this->UI->wfDisplay->displayOnPlot(wfPacket->wf_b1, num_page, 3);
|
|
|
this->UI->wfDisplay->displayOnPlot(wfPacket->wf_b2, num_page, 4);
|
|
|
this->UI->wfDisplay->displayOnPlot(wfPacket->wf_b3, num_page, 5);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void MainWindow::buildWFAndDisplayBurst(TMPacketToRead *packet, WFPacket *wfPacket)
|
|
|
{
|
|
|
unsigned int i = 0;
|
|
|
unsigned int j = 0;
|
|
|
unsigned char *data;
|
|
|
static unsigned char pkt_nr = 1;
|
|
|
unsigned int blk_nr = 0;
|
|
|
|
|
|
blk_nr = packet->Value[28] * 256 + packet->Value[29];
|
|
|
data = &packet->Value[30]; // start of the first data block;
|
|
|
j = (pkt_nr-1) * 340;
|
|
|
for ( i=0; i<blk_nr; i++ ){
|
|
|
wfPacket->wf_e1[j + i] = (short) ( (data[ (i * BLK_SIZE) ] << 8) + (data[ (i*BLK_SIZE) + 1]) );
|
|
|
wfPacket->wf_v[j + i] = (short) ( (data[ (i * BLK_SIZE) + 2] << 8) + (data[ (i*BLK_SIZE) + 3]) );
|
|
|
wfPacket->wf_b1[j + i] = (short) ( (data[ (i * BLK_SIZE) + 4] << 8) + (data[ (i*BLK_SIZE) + 5]) );
|
|
|
wfPacket->wf_e2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 6] << 8) + (data[ (i*BLK_SIZE) + 7]) );
|
|
|
wfPacket->wf_b3[j + i] = (short) ( (data[ (i * BLK_SIZE) + 8] << 8) + (data[ (i*BLK_SIZE) + 9]) );
|
|
|
wfPacket->wf_b2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 10] << 8) + (data[ (i*BLK_SIZE) + 11]) );
|
|
|
}
|
|
|
pkt_nr = pkt_nr + 1;
|
|
|
if (blk_nr == 8)
|
|
|
{
|
|
|
this->UI->wfPageBurst->displayOnPlot(wfPacket->wf_v, 0);
|
|
|
this->UI->wfPageBurst->displayOnPlot(wfPacket->wf_e1, 1);
|
|
|
this->UI->wfPageBurst->displayOnPlot(wfPacket->wf_e2, 2);
|
|
|
this->UI->wfPageBurst->displayOnPlot(wfPacket->wf_b1, 3);
|
|
|
this->UI->wfPageBurst->displayOnPlot(wfPacket->wf_b2, 4);
|
|
|
this->UI->wfPageBurst->displayOnPlot(wfPacket->wf_b3, 5);
|
|
|
pkt_nr = 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void MainWindow::buildWFAndDisplaySBM1(TMPacketToRead *packet, WFPacket *wfPacket)
|
|
|
{
|
|
|
unsigned int i = 0;
|
|
|
unsigned int j = 0;
|
|
|
unsigned char *data;
|
|
|
static unsigned char pkt_nr = 1;
|
|
|
unsigned int blk_nr = 0;
|
|
|
|
|
|
blk_nr = packet->Value[28] * 256 + packet->Value[29];
|
|
|
data = &packet->Value[30]; // start of the first data block;
|
|
|
j = (pkt_nr-1) * 340;
|
|
|
for ( i=0; i<blk_nr; i++ ){
|
|
|
wfPacket->wf_e1[j + i] = (short) ( (data[ (i * BLK_SIZE) ] << 8) + (data[ (i*BLK_SIZE) + 1]) );
|
|
|
wfPacket->wf_v[j + i] = (short) ( (data[ (i * BLK_SIZE) + 2] << 8) + (data[ (i*BLK_SIZE) + 3]) );
|
|
|
wfPacket->wf_b1[j + i] = (short) ( (data[ (i * BLK_SIZE) + 4] << 8) + (data[ (i*BLK_SIZE) + 5]) );
|
|
|
wfPacket->wf_e2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 6] << 8) + (data[ (i*BLK_SIZE) + 7]) );
|
|
|
wfPacket->wf_b3[j + i] = (short) ( (data[ (i * BLK_SIZE) + 8] << 8) + (data[ (i*BLK_SIZE) + 9]) );
|
|
|
wfPacket->wf_b2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 10] << 8) + (data[ (i*BLK_SIZE) + 11]) );
|
|
|
}
|
|
|
pkt_nr = pkt_nr + 1;
|
|
|
if (blk_nr == 8)
|
|
|
{
|
|
|
this->UI->wfPageSBM1->displayOnPlot(wfPacket->wf_v, 0);
|
|
|
this->UI->wfPageSBM1->displayOnPlot(wfPacket->wf_e1, 1);
|
|
|
this->UI->wfPageSBM1->displayOnPlot(wfPacket->wf_e2, 2);
|
|
|
this->UI->wfPageSBM1->displayOnPlot(wfPacket->wf_b1, 3);
|
|
|
this->UI->wfPageSBM1->displayOnPlot(wfPacket->wf_b2, 4);
|
|
|
this->UI->wfPageSBM1->displayOnPlot(wfPacket->wf_b3, 5);
|
|
|
pkt_nr = 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void MainWindow::buildWFAndDisplaySBM2(TMPacketToRead *packet, WFPacket *wfPacket)
|
|
|
{
|
|
|
unsigned int i = 0;
|
|
|
unsigned int j = 0;
|
|
|
unsigned char *data;
|
|
|
static unsigned char pkt_nr = 1;
|
|
|
unsigned int blk_nr = 0;
|
|
|
|
|
|
blk_nr = packet->Value[28] * 256 + packet->Value[29];
|
|
|
data = &packet->Value[30]; // start of the first data block;
|
|
|
j = (pkt_nr-1) * 340;
|
|
|
for ( i=0; i<blk_nr; i++ ){
|
|
|
wfPacket->wf_e1[j + i] = (short) ( (data[ (i * BLK_SIZE) ] << 8) + (data[ (i*BLK_SIZE) + 1]) );
|
|
|
wfPacket->wf_v[j + i] = (short) ( (data[ (i * BLK_SIZE) + 2] << 8) + (data[ (i*BLK_SIZE) + 3]) );
|
|
|
wfPacket->wf_b1[j + i] = (short) ( (data[ (i * BLK_SIZE) + 4] << 8) + (data[ (i*BLK_SIZE) + 5]) );
|
|
|
wfPacket->wf_e2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 6] << 8) + (data[ (i*BLK_SIZE) + 7]) );
|
|
|
wfPacket->wf_b3[j + i] = (short) ( (data[ (i * BLK_SIZE) + 8] << 8) + (data[ (i*BLK_SIZE) + 9]) );
|
|
|
wfPacket->wf_b2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 10] << 8) + (data[ (i*BLK_SIZE) + 11]) );
|
|
|
}
|
|
|
pkt_nr = pkt_nr + 1;
|
|
|
if (blk_nr == 8)
|
|
|
{
|
|
|
this->UI->wfPageSBM2->displayOnPlot(wfPacket->wf_v, 0);
|
|
|
this->UI->wfPageSBM2->displayOnPlot(wfPacket->wf_e1, 1);
|
|
|
this->UI->wfPageSBM2->displayOnPlot(wfPacket->wf_e2, 2);
|
|
|
this->UI->wfPageSBM2->displayOnPlot(wfPacket->wf_b1, 3);
|
|
|
this->UI->wfPageSBM2->displayOnPlot(wfPacket->wf_b2, 4);
|
|
|
this->UI->wfPageSBM2->displayOnPlot(wfPacket->wf_b3, 5);
|
|
|
pkt_nr = 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void MainWindow::processIncomingPacket(TMPacketToRead *packet)
|
|
|
{
|
|
|
totalOfBytes = totalOfBytes + packet->size;
|
|
|
totalOfPackets = totalOfPackets + 1;
|
|
|
this->UI->totalOfBytesHasChanged(totalOfBytes);
|
|
|
this->UI->totalOfPacketsHasChanged(totalOfPackets);
|
|
|
preProcessPacket(packet);
|
|
|
}
|
|
|
|
|
|
void MainWindow::resetStatistics()
|
|
|
{
|
|
|
totalOfBytes = 0;
|
|
|
totalOfPackets = 0;
|
|
|
this->UI->totalOfBytesHasChanged(totalOfBytes);
|
|
|
this->UI->totalOfPacketsHasChanged(totalOfPackets);
|
|
|
}
|
|
|
|
|
|
void MainWindow::processPacketStore()
|
|
|
{
|
|
|
TMPacketToRead *packet;
|
|
|
while(!generalCCSDSPacketStore.isEmpty())
|
|
|
{
|
|
|
packet = generalCCSDSPacketStore.takeFirst();
|
|
|
processIncomingPacket(packet);
|
|
|
delete(packet);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void MainWindow::readSettings()
|
|
|
{
|
|
|
QSettings settings("lpp", "lfrsge");
|
|
|
echoBridgeIP0 = (unsigned char) settings.value("echoBridgeIP0", 127).toInt();
|
|
|
echoBridgeIP1 = (unsigned char) settings.value("echoBridgeIP1", 0).toInt();
|
|
|
echoBridgeIP2 = (unsigned char) settings.value("echoBridgeIP2", 0).toInt();
|
|
|
echoBridgeIP3 = (unsigned char) settings.value("echoBridgeIP3", 1).toInt();
|
|
|
}
|
|
|
|
|
|
void MainWindow::writeSettings()
|
|
|
{
|
|
|
QSettings settings("lpp", "lfrsge");
|
|
|
settings.setValue("echoBridgeIP0", this->UI->serverTMEchoDialogBox->getAddressPart1());
|
|
|
settings.setValue("echoBridgeIP1", this->UI->serverTMEchoDialogBox->getAddressPart2());
|
|
|
settings.setValue("echoBridgeIP2", this->UI->serverTMEchoDialogBox->getAddressPart3());
|
|
|
settings.setValue("echoBridgeIP3", this->UI->serverTMEchoDialogBox->getAddressPart4());
|
|
|
}
|
|
|
|
|
|
void MainWindow::closeEvent(QCloseEvent *)
|
|
|
{
|
|
|
writeSettings();
|
|
|
}
|
|
|
|
