|
|
#include "mainwindow.h"
|
|
|
#include <iostream>
|
|
|
#include <QNetworkInterface>
|
|
|
|
|
|
MainWindow::MainWindow(QWidget *parent)
|
|
|
: QWidget(parent)
|
|
|
{
|
|
|
totalOfBytes = 0;
|
|
|
|
|
|
analyserSGSEServerTC = new QTcpServer();
|
|
|
analyserSGSEServerTM = new QTcpServer();
|
|
|
|
|
|
socketTC = NULL;
|
|
|
socketTM = NULL;
|
|
|
socketEchoServer = new QTcpSocket();
|
|
|
|
|
|
sourceTC = new QXmlInputSource();
|
|
|
sourceTMechoBridge = new QXmlInputSource();
|
|
|
xmlHandler = new LFRXmlHandler();
|
|
|
|
|
|
lfrXmlWriter = new LFRXmlWriter();
|
|
|
|
|
|
UI = new MainWindowUI();
|
|
|
|
|
|
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()));
|
|
|
connect(this->socketEchoServer, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
|
|
|
this, SLOT(socket_TMEcho_ServerHasChanged()));
|
|
|
connect(this->socketEchoServer, SIGNAL(readyRead()),
|
|
|
this, SLOT(readDataOnSocketEchoServer()));
|
|
|
//
|
|
|
connect(this->xmlHandler, SIGNAL(displayMessage(QString)), this, SLOT(displayOnConsole(QString)));
|
|
|
|
|
|
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()
|
|
|
{
|
|
|
int nbBytesAvailable = 0;
|
|
|
|
|
|
nbBytesAvailable = socketEchoServer->bytesAvailable();
|
|
|
buffer = (char *) malloc(nbBytesAvailable);
|
|
|
socketEchoServer->read(buffer, nbBytesAvailable);
|
|
|
|
|
|
totalOfBytes = totalOfBytes + nbBytesAvailable;
|
|
|
this->UI->totalOfBytesHasChanged(totalOfBytes);
|
|
|
|
|
|
processIncomingData(buffer, nbBytesAvailable);
|
|
|
|
|
|
free(buffer);
|
|
|
}
|
|
|
|
|
|
void MainWindow::processIncomingData(char *data, unsigned int size)
|
|
|
{
|
|
|
QByteArray newdat;
|
|
|
int index;
|
|
|
char *values;
|
|
|
unsigned char *ccsdsData;
|
|
|
unsigned int ccsdsSize = 0;
|
|
|
unsigned char sizeByte1 = 0;
|
|
|
unsigned char sizeByte0 = 0;
|
|
|
|
|
|
TMPacketToRead *incomingPacket;
|
|
|
|
|
|
newdat = QByteArray::fromRawData( data, size);
|
|
|
index = newdat.indexOf("<EventBinary>") + 13;
|
|
|
|
|
|
values = (char*) (newdat.data() + index);
|
|
|
sizeByte0 = fromAsciiToChar(values[ 8*2 ])*16 + fromAsciiToChar(values[ 8*2+1 ]);
|
|
|
sizeByte1 = fromAsciiToChar(values[ 9*2 ])*16 + fromAsciiToChar(values[ 9*2+1 ]);
|
|
|
ccsdsSize = sizeByte0*256 + sizeByte1;
|
|
|
ccsdsData = (unsigned char*) malloc(ccsdsSize + 1 + 10);
|
|
|
for (unsigned int i=0; i<ccsdsSize; i++)
|
|
|
{
|
|
|
ccsdsData[i] = fromAsciiToChar(values[ i*2 ])*16 + fromAsciiToChar(values[ i*2+1 ]);
|
|
|
}
|
|
|
incomingPacket = new TMPacketToRead(ccsdsData, ccsdsSize);
|
|
|
generalCCSDSPacketStore.append(incomingPacket);
|
|
|
preProcessPacket(incomingPacket);
|
|
|
free(ccsdsData);
|
|
|
}
|
|
|
|
|
|
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];
|
|
|
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 == 12) & (typ == 21) & (sub == 3))
|
|
|
sid = packet->Value[20];
|
|
|
else if ((pid == 76) & (cat == 4) & (typ == 3) & (sub == 25))
|
|
|
sid = 1;
|
|
|
|
|
|
this->UI->tmStatistics->updateStatistics(pid, cat, typ, sub, sid, length, coarse_t, fine_t);
|
|
|
|
|
|
//****************************************
|
|
|
// 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;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
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[24] * 256 + packet->Value[25];
|
|
|
data = &packet->Value[26]; // 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);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
char MainWindow::fromAsciiToChar(char value)
|
|
|
{
|
|
|
char ret = -1;
|
|
|
if (value > 'a')
|
|
|
{
|
|
|
ret = value - 'a' + 10;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
ret = value - '0';
|
|
|
}
|
|
|
return ret;
|
|
|
}
|
|
|
|