##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » SOLO_LFR » LPPMON_PLUGINS_PAUL
RSS

Clone from http://pc-instru.lpp.polytechnique.fr:5000/LPPMON_GROUP/LPPMON_PLUGINS_PAUL

ASM_F1 and ASM_F2 displays added to lfrsgse
leroy -
r75:be11db85f112 default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,723 +1,731
1 1 #include "mainwindow.h"
2 2 #include <iostream>
3 3 #include <QNetworkInterface>
4 4
5 5 MainWindow::MainWindow(QWidget *parent)
6 6 : QMainWindow(parent)
7 7 {
8 8 parsingContinue = false;
9 9 totalOfBytes = 0;
10 10 totalOfPackets = 0;
11 11
12 12 spectraPacketNormalSpectrumF0 = new SpectraPacket(0, 128);
13 spectraPacketNormalSpectrumF1 = new SpectraPacket(0, 128);
14 spectraPacketNormalSpectrumF2 = new SpectraPacket(0, 128);
13 15
14 16 //*********
15 17 // wfPacket
16 18 wfPacketNormal[0] = new WFPacket(0, 2048);
17 19 wfPacketNormal[1] = new WFPacket(0, 2048);
18 20 wfPacketNormal[2] = new WFPacket(0, 2048);
19 21 wfPacketNormal[3] = new WFPacket(0, 2688);
20 22 wfPacketBurst = new WFPacket(0, 2688);
21 23 wfPacketSBM1 = new WFPacket(0, 2688);
22 24 wfPacketSBM2 = new WFPacket(0, 2688);
23 25 wfPacketCWF_F3 = new WFPacket(0, 2688);
24 26
25 27 //****
26 28 // XML
27 29 // xml handlers
28 30 xmlHandler = new LFRXmlHandler();
29 31 // xml sources
30 32 sourceTC = new QXmlInputSource();
31 33 // xml writer
32 34 lfrXmlWriter = new LFRXmlWriter();
33 35 // setup xml parser for the echo bridge
34 36 lfrXmlParser = new LFRXmlParser();
35 37
36 38 UI = new MainWindowUI();
37 39 readSettings();
38 40 this->UI->serverTMEchoDialogBox->setIP(echoBridgeIP0, echoBridgeIP1, echoBridgeIP2, echoBridgeIP3);
39 41
40 42 lfrXmlParser->generalCCSDSPacketStore = &this->generalCCSDSPacketStore;
41 43
42 44 initSocketStatesList();
43 45
44 46 this->setCentralWidget(this->UI);
45 47 //this->setLayout(UI->layout());
46 48
47 49 analyserSGSEServerTC = new QTcpServer();
48 50 analyserSGSEServerTM = new QTcpServer();
49 51
50 52 socketTC = NULL;
51 53 socketTM = NULL;
52 54 socketEchoServer = new QTcpSocket();
53 55
54 56 connect(this->UI->button_openServerTCTM, SIGNAL(clicked()), this, SLOT(listenOnTCTMPorts()));
55 57 connect(this->UI->button_testServerTCTM, SIGNAL(clicked()), this, SLOT(testTCTMPorts()));
56 58 connect(this->UI->button_openSocketEchoServer, SIGNAL(clicked()), this, SLOT(openEchoServer()));
57 59 //
58 60 connect(this->analyserSGSEServerTC, SIGNAL(newConnection()), this, SLOT(newConnectionOnTCServer()));
59 61 connect(this->analyserSGSEServerTM, SIGNAL(newConnection()), this, SLOT(newConnectionOnTMServer()));
60 62 //
61 63 connect(this, SIGNAL(socketTMHasChanged(QTcpSocket*)), this->lfrXmlWriter, SLOT(setSocketTM(QTcpSocket*)));
62 64 connect(this->UI->button_TCAcknowledgement, SIGNAL(clicked()), this->lfrXmlWriter, SLOT(sendXML_TC_Acknowledgment()));
63 65 connect(this->UI->button_TCRejection, SIGNAL(clicked()), this->lfrXmlWriter, SLOT(sendXML_TC_rejection()));
64 66 connect(this->UI->button_GSEHK, SIGNAL(clicked()), this->lfrXmlWriter, SLOT(sendXML_GSE_HK()));
65 67
66 68 // socket echo server
67 69 connect(this->socketEchoServer, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
68 70 this, SLOT(socket_TMEcho_ServerHasChanged()));
69 71 connect(this->socketEchoServer, SIGNAL(readyRead()),
70 72 this, SLOT(readDataOnSocketEchoServer()));
71 73
72 74 // display on console
73 75 connect(this->xmlHandler, SIGNAL(displayMessage(QString)),
74 76 this, SLOT(displayOnConsole(QString)));
75 77 connect(this->UI->hkDisplay, SIGNAL(displayMessage(QString)),
76 78 this, SLOT(displayOnConsole(QString)));
77 79 connect(this->lfrXmlParser, SIGNAL(sendMessage(QString)),
78 80 this, SLOT(displayOnConsole(QString)));
79 81 //
80 82 connect(this->lfrXmlParser, SIGNAL(processPacketStore()),
81 83 this, SLOT(processPacketStore()));
82 84 //
83 85 connect(this->UI->button_resetStatistics, SIGNAL(clicked()),
84 86 this, SLOT(resetStatistics()));
85 87
86 88 displayNetworkInterfaces();
87 89
88 90 this->xmlHandler->packetStoreHasChanged(&generalCCSDSPacketStore);
89 91 };
90 92
91 93 MainWindow::~MainWindow()
92 94 {
93 95 delete wfPacketNormal[0];
94 96 delete wfPacketNormal[1];
95 97 delete wfPacketNormal[2];
96 98 delete wfPacketNormal[3];
97 99 delete wfPacketBurst;
98 100 delete wfPacketSBM1;
99 101 delete wfPacketSBM2;
100 102 delete wfPacketCWF_F3;
101 103 }
102 104
103 105 void MainWindow::displayNetworkInterfaces()
104 106 {
105 107 QList<QHostAddress> list = QNetworkInterface::allAddresses();
106 108 this->displayOnConsole("Network interfaces:");
107 109 for(int nIter=0; nIter<list.count(); nIter++)
108 110 {
109 111 this->UI->displayOnConsole(list[nIter].toString());
110 112 }
111 113 }
112 114
113 115 void MainWindow::listenOnTCTMPorts()
114 116 {
115 117 QString str;
116 118
117 119 //***
118 120 // TC
119 121 analyserSGSEServerTC->listen(QHostAddress::Any, this->UI->getTCPort());
120 122 str = analyserSGSEServerTC->errorString();
121 123 if (!str.isEmpty())
122 124 {
123 125 this->displayOnConsole(str);
124 126 }
125 127 this->displayOnConsole("Listening TC on port "
126 128 + QString::number(this->UI->getTCPort())
127 129 );
128 130
129 131 //***
130 132 // TM
131 133 analyserSGSEServerTM->listen(QHostAddress::Any, this->UI->getTMPort());
132 134 str = analyserSGSEServerTM->errorString();
133 135 if (!str.isEmpty())
134 136 {
135 137 this->displayOnConsole(str);
136 138 }
137 139 this->displayOnConsole("Listening TM on port "
138 140 + QString::number(this->UI->getTMPort())
139 141 );
140 142 }
141 143
142 144 void MainWindow::testTCTMPorts()
143 145 {
144 146 if (socketTC != NULL)
145 147 {
146 148 this->displayOnConsole("TC socket *** " + socketStates.at(socketTC->state()) );
147 149 }
148 150 else
149 151 {
150 152 this->displayOnConsole("TC socket *** not tested, (socketTC) is NULL" );
151 153 }
152 154 if (socketTM != NULL)
153 155 {
154 156 this->displayOnConsole("TM socket *** " + socketStates.at(socketTM->state()) );
155 157 }
156 158 else
157 159 {
158 160 this->displayOnConsole("TM socket *** not tested, (socketTM) is NULL" );
159 161 }
160 162 }
161 163
162 164 void MainWindow::newConnectionOnTCServer()
163 165 {
164 166 this->displayOnConsole("got new connection on TC port");
165 167 socketTC = analyserSGSEServerTC->nextPendingConnection();
166 168 this->displayOnConsole("TC socket *** " + socketStates.at(socketTC->state()) );
167 169 connect(this->socketTC, SIGNAL(readyRead()), this, SLOT(readDataOnTCPort()));
168 170 }
169 171
170 172 void MainWindow::newConnectionOnTMServer()
171 173 {
172 174 this->displayOnConsole("got new connection on TM port");
173 175 socketTM = analyserSGSEServerTM->nextPendingConnection();
174 176 this->displayOnConsole("TM socket *** " + socketStates.at(socketTM->state()) );
175 177 connect(this->socketTM, SIGNAL(readyRead()), this, SLOT(readDataOnTMPort()));
176 178
177 179 emit socketTMHasChanged(this->socketTM);
178 180 }
179 181
180 182 void MainWindow::readDataOnTCPort()
181 183 {
182 184 bool ok;
183 185 int nbBytesAvailable = 0;
184 186
185 187 nbBytesAvailable = socketTC->bytesAvailable();
186 188 buffer = (char *) malloc(nbBytesAvailable);
187 189 socketTC->read(buffer, nbBytesAvailable);
188 190
189 191 this->displayOnConsole("readDataOnTCPort *** "
190 192 + QString::number(nbBytesAvailable)
191 193 + " read");
192 194
193 195 QByteArray xmlData( buffer, nbBytesAvailable);
194 196
195 197 free(buffer);
196 198
197 199 sourceTC->setData( xmlData );
198 200
199 201 xmlReader.setContentHandler(xmlHandler);
200 202 xmlReader.setErrorHandler(xmlHandler);
201 203
202 204 ok = xmlReader.parse(sourceTC);
203 205 if (!ok) {
204 206 std::cout << "Parsing failed." << std::endl;
205 207 }
206 208 else {
207 209 QStringList names = xmlHandler->names();
208 210 QList<int> indentations = xmlHandler->indentations();
209 211
210 212 int items = names.count();
211 213
212 214 for (int i = 0; i < items; ++i) {
213 215 displayOnConsole(
214 216 names[i]
215 217 + " --- identations: "
216 218 + QString::number(indentations[i]));
217 219 }
218 220 }
219 221 }
220 222
221 223 void MainWindow::readDataOnTMPort()
222 224 {
223 225 this->displayOnConsole("TM data received, begin parsing");
224 226 }
225 227
226 228 void MainWindow::readDataOnSocketEchoServer()
227 229 {
228 230 QString dataString;
229 231
230 232 dataArray.append(socketEchoServer->readAll());
231 233 // dataString = QString::fromAscii(dataArray);
232 234 dataString = QString::fromLatin1(dataArray);
233 235 this->lfrXmlParser->processIncomingStr(dataString);
234 236 dataArray.clear();
235 237 }
236 238
237 239 void MainWindow::displayOnConsole(QString message)
238 240 {
239 241 this->UI->displayOnConsole( message );
240 242 }
241 243
242 244 void MainWindow::initSocketStatesList()
243 245 {
244 246 socketStates.append("The socket is not connected");
245 247 socketStates.append("The socket is performing a host name lookup");
246 248 socketStates.append("The socket has started establishing a connection");
247 249 socketStates.append("A connection is established");
248 250 socketStates.append("The socket is bound to an address and port (for servers)");
249 251 socketStates.append("The socket is about to close (data may still be waiting to be written)");
250 252 socketStates.append("For internal use only");
251 253 }
252 254
253 255 void MainWindow::openEchoServer()
254 256 {
255 257 socketEchoServer->connectToHost(this->UI->serverTMEchoDialogBox->getIP(),
256 258 this->UI->spinbox_serverTMEchoPort->value());
257 259 //socketEchoServer->open();
258 260 }
259 261
260 262 void MainWindow::socket_TMEcho_ServerHasChanged()
261 263 {
262 264 this->displayOnConsole("TM Echo Socket socket *** " + socketStates.at(socketEchoServer->state()) );
263 265 }
264 266
265 267 void MainWindow::buildWFAndDisplay_SWF(TMPacketToRead *packet, WFPacket *wfPacket, unsigned char num_page)
266 268 {
267 269 unsigned int i = 0;
268 270 static unsigned int nbSamples = 0;
269 271 unsigned char *data;
270 272 unsigned char pa_lfr_pkt_cnt;
271 273 unsigned char pa_lfr_pkt_nr;
272 274 unsigned int pa_lfr_swf_blk_nr = 0;
273 275 double deltaT;
274 276
275 277 switch(num_page)
276 278 {
277 279 case 0: // F0
278 280 deltaT = 1. / 24576;
279 281 break;
280 282 case 1: // F1
281 283 deltaT = 1. / 4096;
282 284 break;
283 285 case 2: // F2
284 286 deltaT = 1. / 256;
285 287 break;
286 288 default:
287 289 deltaT = 0;
288 290 break;
289 291 }
290 292 pa_lfr_pkt_cnt = packet->Value[22];
291 293 pa_lfr_pkt_nr = packet->Value[23]; // PA_LFR_PKT_NR
292 294 pa_lfr_swf_blk_nr = packet->Value[30] * 256 + packet->Value[31]; // PA_LFR_SWF_BLK_NR
293 295 data = &packet->Value[32]; // start of the first data block;
294 296
295 297 if (pa_lfr_pkt_nr == 1) // the acquisition time of the first packet of the snapshot is taken as starting time
296 298 {
297 299 nbSamples = 0;
298 300 wfPacket->coarseTime = ((packet->Value[24] & 0x7f) << 24)
299 301 + (packet->Value[25] << 16)
300 302 + (packet->Value[26] << 8)
301 303 + packet->Value[27];
302 304 wfPacket->fineTime = (packet->Value[28] << 8) + packet->Value[29];
303 305 }
304 306
305 307 for ( i=0; i<pa_lfr_swf_blk_nr; i++ ){
306 308 wfPacket->wf_v[nbSamples + i] = (short) ( (data[ (i * BLK_SIZE) ] << 8) + (data[ (i*BLK_SIZE) + 1]) );
307 309 wfPacket->wf_e1[nbSamples + i] = (short) ( (data[ (i * BLK_SIZE) + 2] << 8) + (data[ (i*BLK_SIZE) + 3]) );
308 310 wfPacket->wf_e2[nbSamples + i] = (short) ( (data[ (i * BLK_SIZE) + 4] << 8) + (data[ (i*BLK_SIZE) + 5]) );
309 311 wfPacket->wf_b1[nbSamples + i] = (short) ( (data[ (i * BLK_SIZE) + 6] << 8) + (data[ (i*BLK_SIZE) + 7]) );
310 312 wfPacket->wf_b2[nbSamples + i] = (short) ( (data[ (i * BLK_SIZE) + 8] << 8) + (data[ (i*BLK_SIZE) + 9]) );
311 313 wfPacket->wf_b3[nbSamples + i] = (short) ( (data[ (i * BLK_SIZE) + 10] << 8) + (data[ (i*BLK_SIZE) + 11]) );
312 314 }
313 315
314 316 nbSamples = nbSamples + pa_lfr_swf_blk_nr;
315 317
316 318 if (pa_lfr_pkt_nr == pa_lfr_pkt_cnt)
317 319 {
318 320 this->UI->wfDisplay->displayOnPlot(wfPacket->wf_v, num_page, 0, wfPacket->coarseTime, wfPacket->fineTime, deltaT, nbSamples);
319 321 this->UI->wfDisplay->displayOnPlot(wfPacket->wf_e1, num_page, 1, wfPacket->coarseTime, wfPacket->fineTime, deltaT, nbSamples);
320 322 this->UI->wfDisplay->displayOnPlot(wfPacket->wf_e2, num_page, 2, wfPacket->coarseTime, wfPacket->fineTime, deltaT, nbSamples);
321 323 this->UI->wfDisplay->displayOnPlot(wfPacket->wf_b1, num_page, 3, wfPacket->coarseTime, wfPacket->fineTime, deltaT, nbSamples);
322 324 this->UI->wfDisplay->displayOnPlot(wfPacket->wf_b2, num_page, 4, wfPacket->coarseTime, wfPacket->fineTime, deltaT, nbSamples);
323 325 this->UI->wfDisplay->displayOnPlot(wfPacket->wf_b3, num_page, 5, wfPacket->coarseTime, wfPacket->fineTime, deltaT, nbSamples);
324 326 }
325 327 }
326 328
327 329 void MainWindow::buildWFAndDisplay_CWF_LONG_F3(TMPacketToRead *packet, WFPacket *wfPacket)
328 330 {
329 331 unsigned int i = 0;
330 332 unsigned int j = 0;
331 333 unsigned char *data;
332 334 static unsigned char pkt_nr = 1;
333 335 unsigned int blk_nr = 0;
334 336 static unsigned int coarseTime;
335 337 static unsigned int fineTime;
336 338 unsigned int tmpCoarseTime;
337 339 unsigned int tmpFineTime;
338 340 double deltaT;
339 341 double DELTA;
340 342 unsigned int nbData;
341 343
342 344 deltaT = 1 / 16.;
343 345
344 346 if (pkt_nr == 1) // the acquisition time of the first packet of the snapshot is taken as starting time
345 347 {
346 348 tmpCoarseTime = coarseTime;
347 349 tmpFineTime = fineTime;
348 350 coarseTime = ((packet->Value[22] & 0x7f) << 24)
349 351 + (packet->Value[23] << 16)
350 352 + (packet->Value[24] << 8)
351 353 + packet->Value[25];
352 354 fineTime = (packet->Value[26] << 8) + packet->Value[27];
353 355 DELTA = (coarseTime + fineTime * 1. / 65536.)
354 356 - (tmpCoarseTime + tmpFineTime * 1. / 65536);
355 357 displayOnConsole( "DELTA = " + QString::number(DELTA, 'f', 10) );
356 358 }
357 359 blk_nr = packet->Value[28] * 256 + packet->Value[29]; // PA_LFR_CWFL3_BLK_NR
358 360 data = &packet->Value[30]; // start of the first data block;
359 361
360 362 j = (pkt_nr-1) * blk_nr;
361 363 for ( i=0; i<blk_nr; i++ ){
362 364 wfPacket->wf_v[j + i] = (short) ( (data[ (i * BLK_SIZE) ] << 8) + (data[ (i*BLK_SIZE) + 1]) );
363 365 wfPacket->wf_e1[j + i] = (short) ( (data[ (i * BLK_SIZE) + 2] << 8) + (data[ (i*BLK_SIZE) + 3]) );
364 366 wfPacket->wf_e2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 4] << 8) + (data[ (i*BLK_SIZE) + 5]) );
365 367 wfPacket->wf_b1[j + i] = (short) ( (data[ (i * BLK_SIZE) + 6] << 8) + (data[ (i*BLK_SIZE) + 7]) );
366 368 wfPacket->wf_b2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 8] << 8) + (data[ (i*BLK_SIZE) + 9]) );
367 369 wfPacket->wf_b3[j + i] = (short) ( (data[ (i * BLK_SIZE) + 10] << 8) + (data[ (i*BLK_SIZE) + 11]) );
368 370 }
369 371 pkt_nr = pkt_nr + 1;
370 372 if (pkt_nr == (NB_PACKETS_PER_GROUP_OF_CWF+1))
371 373 {
372 374 nbData = j + blk_nr;
373 375 this->UI->wfPage_CWF_F3->displayOnPlot(wfPacket->wf_v, 0, coarseTime, fineTime, deltaT, nbData);
374 376 this->UI->wfPage_CWF_F3->displayOnPlot(wfPacket->wf_e1, 1, coarseTime, fineTime, deltaT, nbData);
375 377 this->UI->wfPage_CWF_F3->displayOnPlot(wfPacket->wf_e2, 2, coarseTime, fineTime, deltaT, nbData);
376 378 this->UI->wfPage_CWF_F3->displayOnPlot(wfPacket->wf_b1, 3, coarseTime, fineTime, deltaT, nbData);
377 379 this->UI->wfPage_CWF_F3->displayOnPlot(wfPacket->wf_b2, 4, coarseTime, fineTime, deltaT, nbData);
378 380 this->UI->wfPage_CWF_F3->displayOnPlot(wfPacket->wf_b3, 5, coarseTime, fineTime, deltaT, nbData);
379 381 pkt_nr = 1;
380 382 }
381 383 }
382 384
383 385 void MainWindow::buildWFAndDisplay_CWF_F3_light(TMPacketToRead *packet, WFPacket *wfPacket)
384 386 {
385 387 unsigned int i = 0;
386 388 unsigned int j = 0;
387 389 unsigned char *data;
388 390 static unsigned char pkt_nr = 1;
389 391 unsigned int blk_nr = 0;
390 392 static unsigned int coarseTime;
391 393 static unsigned int fineTime;
392 394 unsigned int tmpCoarseTime;
393 395 unsigned int tmpFineTime;
394 396 double deltaT;
395 397 double DELTA;
396 398 unsigned int nbData;
397 399
398 400 deltaT = 1 / 16.;
399 401
400 402 if (pkt_nr == 1) // the acquisition time of the first packet of the snapshot is taken as starting time
401 403 {
402 404 tmpCoarseTime = coarseTime;
403 405 tmpFineTime = fineTime;
404 406 coarseTime = ((packet->Value[22] & 0x7f) << 24)
405 407 + (packet->Value[23] << 16)
406 408 + (packet->Value[24] << 8)
407 409 + packet->Value[25];
408 410 fineTime = (packet->Value[26] << 8) + packet->Value[27];
409 411 DELTA = (coarseTime + fineTime * 1. / 65536.)
410 412 - (tmpCoarseTime + tmpFineTime * 1. / 65536);
411 413 displayOnConsole( "DELTA = " + QString::number(DELTA, 'f', 10) );
412 414 }
413 415 blk_nr = packet->Value[28] * 256 + packet->Value[29]; // PA_LFR_CWF3_BLK_NR
414 416 data = &packet->Value[30]; // start of the first data block;
415 417
416 418 j = (pkt_nr-1) * blk_nr;
417 419 for ( i=0; i<blk_nr; i++ ){
418 420 wfPacket->wf_v[j + i] = (short) ( (data[ (i * BLK_SIZE_CWF3_LIGHT) ] << 8) + (data[ (i*BLK_SIZE_CWF3_LIGHT) + 1]) );
419 421 wfPacket->wf_e1[j + i] = (short) ( (data[ (i * BLK_SIZE_CWF3_LIGHT) + 2] << 8) + (data[ (i*BLK_SIZE_CWF3_LIGHT) + 3]) );
420 422 wfPacket->wf_e2[j + i] = (short) ( (data[ (i * BLK_SIZE_CWF3_LIGHT) + 4] << 8) + (data[ (i*BLK_SIZE_CWF3_LIGHT) + 5]) );
421 423 wfPacket->wf_b1[j + i] = 0;
422 424 wfPacket->wf_b2[j + i] = 0;
423 425 wfPacket->wf_b3[j + i] = 0;
424 426 }
425 427 pkt_nr = pkt_nr + 1;
426 428 if (pkt_nr == (NB_PACKETS_PER_GROUP_OF_CWF_LIGHT+1))
427 429 {
428 430 nbData = j + blk_nr;
429 431 this->UI->wfPage_CWF_F3->displayOnPlot(wfPacket->wf_v, 0, coarseTime, fineTime, deltaT, nbData);
430 432 this->UI->wfPage_CWF_F3->displayOnPlot(wfPacket->wf_e1, 1, coarseTime, fineTime, deltaT, nbData);
431 433 this->UI->wfPage_CWF_F3->displayOnPlot(wfPacket->wf_e2, 2, coarseTime, fineTime, deltaT, nbData);
432 434 this->UI->wfPage_CWF_F3->displayOnPlot(wfPacket->wf_b1, 3, coarseTime, fineTime, deltaT, nbData);
433 435 this->UI->wfPage_CWF_F3->displayOnPlot(wfPacket->wf_b2, 4, coarseTime, fineTime, deltaT, nbData);
434 436 this->UI->wfPage_CWF_F3->displayOnPlot(wfPacket->wf_b3, 5, coarseTime, fineTime, deltaT, nbData);
435 437 pkt_nr = 1;
436 438 }
437 439 }
438 440
439 441 void MainWindow::buildWFAndDisplay_CWF_F1(TMPacketToRead *packet, WFPacket *wfPacket)
440 442 {
441 443 unsigned int i = 0;
442 444 unsigned int j = 0;
443 445 unsigned char *data;
444 446 static unsigned char pkt_nr = 1;
445 447 unsigned int blk_nr = 0;
446 448 static unsigned int coarseTime;
447 449 static unsigned int fineTime;
448 450 double deltaT;
449 451 unsigned int nbData;
450 452
451 453 deltaT = 1. / 4096.;
452 454
453 455 if (pkt_nr == 1) // the acquisition time of the first packet of the snapshot is taken as starting time
454 456 {
455 457 coarseTime = ((packet->Value[22] & 0x7f) << 24)
456 458 + (packet->Value[23] << 16)
457 459 + (packet->Value[24] << 8)
458 460 + packet->Value[25];
459 461 fineTime = (packet->Value[26] << 8) + packet->Value[27];
460 462 }
461 463 blk_nr = packet->Value[28] * 256 + packet->Value[29]; // PA_LFR_CWF_BLK_NR
462 464 data = &packet->Value[30]; // start of the first data block;
463 465
464 466 j = (pkt_nr-1) * blk_nr;
465 467 for ( i=0; i<blk_nr; i++ ){
466 468 wfPacket->wf_v[j + i] = (short) ( (data[ (i * BLK_SIZE) ] << 8) + (data[ (i*BLK_SIZE) + 1]) );
467 469 wfPacket->wf_e1[j + i] = (short) ( (data[ (i * BLK_SIZE) + 2] << 8) + (data[ (i*BLK_SIZE) + 3]) );
468 470 wfPacket->wf_e2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 4] << 8) + (data[ (i*BLK_SIZE) + 5]) );
469 471 wfPacket->wf_b1[j + i] = (short) ( (data[ (i * BLK_SIZE) + 6] << 8) + (data[ (i*BLK_SIZE) + 7]) );
470 472 wfPacket->wf_b2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 8] << 8) + (data[ (i*BLK_SIZE) + 9]) );
471 473 wfPacket->wf_b3[j + i] = (short) ( (data[ (i * BLK_SIZE) + 10] << 8) + (data[ (i*BLK_SIZE) + 11]) );
472 474 }
473 475 pkt_nr = pkt_nr + 1;
474 476 if (pkt_nr == (NB_PACKETS_PER_GROUP_OF_CWF+1))
475 477 {
476 478 nbData = j + blk_nr;
477 479 this->UI->wfPage_CWF_F1->displayOnPlot(wfPacket->wf_v, 0, coarseTime, fineTime, deltaT, nbData);
478 480 this->UI->wfPage_CWF_F1->displayOnPlot(wfPacket->wf_e1, 1, coarseTime, fineTime, deltaT, nbData);
479 481 this->UI->wfPage_CWF_F1->displayOnPlot(wfPacket->wf_e2, 2, coarseTime, fineTime, deltaT, nbData);
480 482 this->UI->wfPage_CWF_F1->displayOnPlot(wfPacket->wf_b1, 3, coarseTime, fineTime, deltaT, nbData);
481 483 this->UI->wfPage_CWF_F1->displayOnPlot(wfPacket->wf_b2, 4, coarseTime, fineTime, deltaT, nbData);
482 484 this->UI->wfPage_CWF_F1->displayOnPlot(wfPacket->wf_b3, 5, coarseTime, fineTime, deltaT, nbData);
483 485 pkt_nr = 1;
484 486 }
485 487 }
486 488
487 489 void MainWindow::buildWFAndDisplay_CWF_F2(TMPacketToRead *packet, WFPacket *wfPacket)
488 490 {
489 491 unsigned int i = 0;
490 492 unsigned int j = 0;
491 493 unsigned char *data;
492 494 static unsigned char pkt_nr = 1;
493 495 unsigned int blk_nr = 0;
494 496 static unsigned int coarseTime;
495 497 static unsigned int fineTime;
496 498 double deltaT;
497 499 unsigned int nbData;
498 500
499 501 deltaT = 1. / 256.;
500 502
501 503 if (pkt_nr == 1) // the acquisition time of the first packet of the snapshot is taken as starting time
502 504 {
503 505 coarseTime = ((packet->Value[22] & 0x7f) << 24)
504 506 + (packet->Value[23] << 16)
505 507 + (packet->Value[24] << 8)
506 508 + packet->Value[25];
507 509 fineTime = (packet->Value[26] << 8) + packet->Value[27];
508 510 }
509 511 blk_nr = packet->Value[28] * 256 + packet->Value[29]; // PA_LFR_CWF3_BLK_NR
510 512 data = &packet->Value[30]; // start of the first data block;
511 513
512 514 j = (pkt_nr-1) * blk_nr;
513 515 for ( i=0; i<blk_nr; i++ ){
514 516 wfPacket->wf_v[j + i] = (short) ( (data[ (i * BLK_SIZE) ] << 8) + (data[ (i*BLK_SIZE) + 1]) );
515 517 wfPacket->wf_e1[j + i] = (short) ( (data[ (i * BLK_SIZE) + 2] << 8) + (data[ (i*BLK_SIZE) + 3]) );
516 518 wfPacket->wf_e2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 4] << 8) + (data[ (i*BLK_SIZE) + 5]) );
517 519 wfPacket->wf_b1[j + i] = (short) ( (data[ (i * BLK_SIZE) + 6] << 8) + (data[ (i*BLK_SIZE) + 7]) );
518 520 wfPacket->wf_b2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 8] << 8) + (data[ (i*BLK_SIZE) + 9]) );
519 521 wfPacket->wf_b3[j + i] = (short) ( (data[ (i * BLK_SIZE) + 10] << 8) + (data[ (i*BLK_SIZE) + 11]) );
520 522 }
521 523 pkt_nr = pkt_nr + 1;
522 524 if (pkt_nr == (NB_PACKETS_PER_GROUP_OF_CWF+1))
523 525 {
524 526 nbData = j + blk_nr;
525 527 this->UI->wfPage_CWF_F2->displayOnPlot(wfPacket->wf_v, 0, coarseTime, fineTime, deltaT, nbData);
526 528 this->UI->wfPage_CWF_F2->displayOnPlot(wfPacket->wf_e1, 1, coarseTime, fineTime, deltaT, nbData);
527 529 this->UI->wfPage_CWF_F2->displayOnPlot(wfPacket->wf_e2, 2, coarseTime, fineTime, deltaT, nbData);
528 530 this->UI->wfPage_CWF_F2->displayOnPlot(wfPacket->wf_b1, 3, coarseTime, fineTime, deltaT, nbData);
529 531 this->UI->wfPage_CWF_F2->displayOnPlot(wfPacket->wf_b2, 4, coarseTime, fineTime, deltaT, nbData);
530 532 this->UI->wfPage_CWF_F2->displayOnPlot(wfPacket->wf_b3, 5, coarseTime, fineTime, deltaT, nbData);
531 533 pkt_nr = 1;
532 534 }
533 535 }
534 536
535 void MainWindow::build_ASM_AndDisplay_NORM_F0(TMPacketToRead *packet, SpectraPacket *spectraPacket)
537 void MainWindow::build_ASM_AndDisplay_NORM(TMPacketToRead *packet, SpectraPacket *spectraPacket,
538 double deltaF, unsigned char indiceStart,
539 ASMPage* asmPage )
536 540 {
537 541 unsigned int i;
538 542 unsigned int j;
539 543 unsigned char *data;
540 544 unsigned char *aux;
541 545 unsigned char cntASM;
542 546 unsigned char nrASM;
543 547 unsigned int blkNR;
544 double deltaF;
545 548 unsigned int nbData;
546 549
547 550 cntASM = packet->Value[22];
548 551 nrASM = packet->Value[23];
549 552 blkNR = packet->Value[30] * 256 + packet->Value[31];
550 553
551 554 data = &packet->Value[32]; // start of the first data block;
552 555
553 556 j = (nrASM-1) * blkNR;
554 557 for ( i=0; i<blkNR; i++ ){
555 558 aux = (unsigned char*) &spectraPacket->s11[ j + i ]; // s11 is a table of float
556 559 aux[3] = data[ (i * 50 + 2*0 ) ];
557 560 aux[2] = data[ (i * 50 + 2*0 ) + 1];
558 561 aux = (unsigned char*) &spectraPacket->s22[ j + i ]; // s22 is a table of float
559 562 aux[3] = data[ (i * 50 + 2*9 ) ];
560 563 aux[2] = data[ (i * 50 + 2*9 ) + 1];
561 564 aux = (unsigned char*) &spectraPacket->s33[ j + i ]; // s33 is a table of float
562 565 aux[3] = data[ (i * 50 + 2*16) ];
563 566 aux[2] = data[ (i * 50 + 2*16) + 1];
564 567 aux = (unsigned char*) &spectraPacket->s44[ j + i ]; // s44 is a table of float
565 568 aux[3] = data[ (i * 50 + 2*21) ];
566 569 aux[2] = data[ (i * 50 + 2*21) + 1];
567 570 aux = (unsigned char*) &spectraPacket->s55[ j + i ]; // s55 is a table of float
568 571 aux[3] = data[ (i * 50 + 2*24) ];
569 572 aux[2] = data[ (i * 50 + 2*24) + 1];
570 573 }
571 574
572 deltaF = 24576. / 256. ;
573 575 nbData = j + blkNR;
574 576 if (nrASM == cntASM)
575 577 {
576 this->UI->asmPage_F0->displayOnPlot(spectraPacket->s11, 0, ASM_F0_INDICE_START, deltaF, nbData);
577 this->UI->asmPage_F0->displayOnPlot(spectraPacket->s22, 1, ASM_F0_INDICE_START, deltaF, nbData);
578 this->UI->asmPage_F0->displayOnPlot(spectraPacket->s33, 2, ASM_F0_INDICE_START, deltaF, nbData);
579 this->UI->asmPage_F0->displayOnPlot(spectraPacket->s44, 3, ASM_F0_INDICE_START, deltaF, nbData);
580 this->UI->asmPage_F0->displayOnPlot(spectraPacket->s55, 4, ASM_F0_INDICE_START, deltaF, nbData);
578 asmPage->displayOnPlot(spectraPacket->s11, 0, indiceStart, deltaF, nbData);
579 asmPage->displayOnPlot(spectraPacket->s22, 1, indiceStart, deltaF, nbData);
580 asmPage->displayOnPlot(spectraPacket->s33, 2, indiceStart, deltaF, nbData);
581 asmPage->displayOnPlot(spectraPacket->s44, 3, indiceStart, deltaF, nbData);
582 asmPage->displayOnPlot(spectraPacket->s55, 4, indiceStart, deltaF, nbData);
581 583 }
582 584 }
583 585
584 586 void MainWindow::resetStatistics()
585 587 {
586 588 totalOfBytes = 0;
587 589 totalOfPackets = 0;
588 590 this->UI->totalOfBytesHasChanged(totalOfBytes);
589 591 this->UI->totalOfPacketsHasChanged(totalOfPackets);
590 592 }
591 593
592 594 //******************
593 595 // packet processing
594 596
595 597 void MainWindow::processPacketStore()
596 598 {
597 599 TMPacketToRead *packet;
598 600 while(!generalCCSDSPacketStore.isEmpty())
599 601 {
600 602 packet = generalCCSDSPacketStore.takeFirst();
601 603 processIncomingPacket(packet);
602 604 delete(packet);
603 605 }
604 606 }
605 607
606 608 void MainWindow::processIncomingPacket(TMPacketToRead *packet)
607 609 {
608 610 totalOfBytes = totalOfBytes + packet->size;
609 611 totalOfPackets = totalOfPackets + 1;
610 612 this->UI->totalOfBytesHasChanged(totalOfBytes);
611 613 this->UI->totalOfPacketsHasChanged(totalOfPackets);
612 614 preProcessPacket(packet);
613 615 }
614 616
615 617 void MainWindow::preProcessPacket(TMPacketToRead *packet)
616 618 {
617 619 unsigned char pid = 0;
618 620 unsigned char cat = 0;
619 621 unsigned char typ = 0;
620 622 unsigned char sub = 0;
621 623 unsigned int sid = 0;
622 624 unsigned int length = 0;
623 625 unsigned int coarse_t = 0;
624 626 unsigned int fine_t = 0;
625 627
626 628 //*********************************
627 629 // get the parameters of the packet
628 630 pid = this->UI->tmStatistics->getPID( packet );
629 631 cat = this->UI->tmStatistics->getCAT( packet );
630 632 typ = this->UI->tmStatistics->getTYPE( packet );
631 633 sub = this->UI->tmStatistics->getSUBTYPE( packet );
632 634 length = this->UI->tmStatistics->getLENGTH( packet );
633 635 coarse_t = this->UI->tmStatistics->getCoarseTime( packet );
634 636 fine_t = this->UI->tmStatistics->getFineTime( packet );
635 637 sid = this->UI->tmStatistics->getSID( packet, pid, cat, typ, sub );
636 638
637 639 this->UI->tmStatistics->updateStatistics(pid, cat, typ, sub, sid, length, coarse_t, fine_t);
638 640
639 641 // compare length in the packet with the size of the packet
640 642 if ( (length + 1 + 10) != (packet->size))
641 643 {
642 644 displayOnConsole("reception of " + QString::number(packet->size)
643 645 + " bytes instead of " + QString::number(length + 1 + 10));
644 646 }
645 647
646 648 //***************************************************
647 649 // if the packet is an HK packet, display its content
648 650 if ( (pid == TM_PACKET_PID_DEFAULT) & (cat == TM_PACKET_CAT_HK)
649 651 & (typ == TM_TYPE_HK) & (sub == TM_SUBTYPE_HK) )
650 652 {
651 653 this->UI->hkDisplay->displayPacket(packet);
652 654 }
653 655
654 656 //**************************************************************
655 657 // if the packet is a parameter dump packet, display its content
656 658 if ( (pid == TM_PACKET_PID_DEFAULT) & (cat == TM_PACKET_CAT_PARAMETER_DUMP)
657 659 & (typ == TM_TYPE_PARAMETER_DUMP) & (sub == TM_SUBTYPE_PARAMETER_DUMP) )
658 660 {
659 661 this->UI->parameterDump->updateParameterDump(packet);
660 662 }
661 663
662 664 //****************************************
663 665 // if the packet is a waveform, display it
664 666 if ( (typ == TM_TYPE_LFR_SCIENCE) & (sub == TM_SUBTYPE_LFR_SCIENCE) )
665 667 {
666 668 //sid = packet->Value[20]; // SID
667 669 switch (sid){
668 670 case SID_NORMAL_SWF_F0:
669 671 buildWFAndDisplay_SWF(packet, wfPacketNormal[0], 0);
670 672 break;
671 673 case SID_NORMAL_SWF_F1:
672 674 buildWFAndDisplay_SWF(packet, wfPacketNormal[1], 1);
673 675 break;
674 676 case SID_NORMAL_SWF_F2:
675 677 buildWFAndDisplay_SWF(packet, wfPacketNormal[2], 2);
676 678 break;
677 679 case SID_NORMAL_CWF_F3:
678 680 buildWFAndDisplay_CWF_F3_light(packet, wfPacketCWF_F3);
679 681 break;
680 682 case SID_NORMAL_CWF_LONG_F3:
681 683 buildWFAndDisplay_CWF_LONG_F3(packet, wfPacketCWF_F3);
682 684 break;
683 685 case SID_BURST_CWF_F2:
684 686 buildWFAndDisplay_CWF_F2(packet, wfPacketBurst);
685 687 break;
686 688 case SID_SBM1_CWF_F1:
687 689 buildWFAndDisplay_CWF_F1(packet, wfPacketSBM1);
688 690 break;
689 691 case SID_SBM2_CWF_F2:
690 692 buildWFAndDisplay_CWF_F2(packet, wfPacketSBM2);
691 693 break;
692 694 case SID_NORMAL_ASM_F0:
693 build_ASM_AndDisplay_NORM_F0(packet, spectraPacketNormalSpectrumF0);
695 build_ASM_AndDisplay_NORM(packet, spectraPacketNormalSpectrumF0, 4096./256., ASM_F1_INDICE_START, this->UI->asmPage_F0 );
696 break;
697 case SID_NORMAL_ASM_F1:
698 build_ASM_AndDisplay_NORM(packet, spectraPacketNormalSpectrumF1, 4096./256., ASM_F1_INDICE_START, this->UI->asmPage_F1 );
699 break;
700 case SID_NORMAL_ASM_F2:
701 build_ASM_AndDisplay_NORM(packet, spectraPacketNormalSpectrumF2, 256./256., ASM_F2_INDICE_START, this->UI->asmPage_F2 );
694 702 break;
695 703 }
696 704 }
697 705 }
698 706
699 707 //******************
700 708 // general functions
701 709
702 710 void MainWindow::readSettings()
703 711 {
704 712 QSettings settings("lpp", "lfrsgse");
705 713 echoBridgeIP0 = (unsigned char) settings.value("echoBridgeIP0", 127).toInt();
706 714 echoBridgeIP1 = (unsigned char) settings.value("echoBridgeIP1", 0).toInt();
707 715 echoBridgeIP2 = (unsigned char) settings.value("echoBridgeIP2", 0).toInt();
708 716 echoBridgeIP3 = (unsigned char) settings.value("echoBridgeIP3", 1).toInt();
709 717 }
710 718
711 719 void MainWindow::writeSettings()
712 720 {
713 721 QSettings settings("lpp", "lfrsgse");
714 722 settings.setValue("echoBridgeIP0", this->UI->serverTMEchoDialogBox->get_addressPart1());
715 723 settings.setValue("echoBridgeIP1", this->UI->serverTMEchoDialogBox->get_addressPart2());
716 724 settings.setValue("echoBridgeIP2", this->UI->serverTMEchoDialogBox->get_addressPart3());
717 725 settings.setValue("echoBridgeIP3", this->UI->serverTMEchoDialogBox->get_addressPart4());
718 726 }
719 727
720 728 void MainWindow::closeEvent(QCloseEvent *)
721 729 {
722 730 writeSettings();
723 731 }
Show file before | Show file after | Hide comments
@@ -1,113 +1,116
1 1 #ifndef MAINWINDOW_H
2 2 #define MAINWINDOW_H
3 3
4 4 #include <QTcpServer>
5 5 #include <QTcpSocket>
6 6 #include <QXmlSimpleReader>
7 7 #include <QSettings>
8 8 #include <QMainWindow>
9 9
10 10 #include <lfrxmlhandler.h>
11 11 #include <lfrxmlwriter.h>
12 12 #include <mainwindowui.h>
13 13 #include <spectrapacket.h>
14 14
15 15 #include "tmpackettoread.h"
16 16 #include "wfpacket.h"
17 17 #include "lfrxmlparser.h"
18 18
19 19 class MainWindow : public QMainWindow
20 20 {
21 21 Q_OBJECT
22 22
23 23 public:
24 24 MainWindow(QWidget *parent = 0);
25 25 ~MainWindow();
26 26
27 27 void displayNetworkInterfaces();
28 28 void initSocketStatesList();
29 29 //
30 30 void preProcessPacket(TMPacketToRead *packet);
31 31 unsigned char getPID(TMPacketToRead *packet);
32 32 unsigned char getCAT(TMPacketToRead *packet);
33 33 unsigned char getTYPE(TMPacketToRead *packet);
34 34 unsigned char getSUBTYPE(TMPacketToRead *packet);
35 35 unsigned int getLENGTH(TMPacketToRead *packet);
36 36 unsigned int getCoarseTime(TMPacketToRead *packet);
37 37 unsigned int getFineTime(TMPacketToRead *packet);
38 38 unsigned int getSID(TMPacketToRead *packet, unsigned char pid, unsigned char cat, unsigned char typ, unsigned char sub);
39 39 //
40 40 void buildWFAndDisplay_SWF(TMPacketToRead *packet, WFPacket *wfPacket, unsigned char num_page);
41 41 void buildWFAndDisplay_CWF_LONG_F3(TMPacketToRead *packet, WFPacket *wfPacket);
42 42 void buildWFAndDisplay_CWF_F3_light(TMPacketToRead *packet, WFPacket *wfPacket);
43 43 void buildWFAndDisplayBurst(TMPacketToRead *packet, WFPacket *wfPacket);
44 44 void buildWFAndDisplay_CWF_F1(TMPacketToRead *packet, WFPacket *wfPacket);
45 45 void buildWFAndDisplay_CWF_F2(TMPacketToRead *packet, WFPacket *wfPacket);
46 46 void build_ASM_AndDisplay_NORM_F0(TMPacketToRead *packet, SpectraPacket *spectraPacket);
47 void build_ASM_AndDisplay_NORM(TMPacketToRead *packet, SpectraPacket *spectraPacket, double deltaF, unsigned char indiceStart, ASMPage *asmPage);
47 48
48 49 protected:
49 50 void closeEvent(QCloseEvent *);
50 51
51 52 private:
52 53 void readSettings();
53 54 void writeSettings();
54 55 unsigned char echoBridgeIP0;
55 56 unsigned char echoBridgeIP1;
56 57 unsigned char echoBridgeIP2;
57 58 unsigned char echoBridgeIP3;
58 59
59 60 QByteArray dataArray;
60 61
61 62 QList<TMPacketToRead*> generalCCSDSPacketStore;
62 63
63 64 QTcpServer *analyserSGSEServerTC;
64 65 QTcpServer *analyserSGSEServerTM;
65 66 QTcpSocket *socketTC;
66 67 QTcpSocket *socketTM;
67 68 QTcpSocket *socketEchoServer;
68 69
69 70 unsigned int totalOfBytes;
70 71 unsigned int totalOfPackets;
71 72
72 73 QXmlSimpleReader xmlReader;
73 74 QXmlInputSource *sourceTC;
74 75 LFRXmlHandler *xmlHandler;
75 76 LFRXmlParser *lfrXmlParser;
76 77
77 78 QList<QString> socketStates;
78 79
79 80 char *buffer;
80 81
81 82 MainWindowUI *UI;
82 83
83 84 LFRXmlWriter *lfrXmlWriter;
84 85
85 86 WFPacket *wfPacketNormal[4];
86 87 WFPacket *wfPacketBurst;
87 88 WFPacket *wfPacketSBM1;
88 89 WFPacket *wfPacketSBM2;
89 90 WFPacket *wfPacketCWF_F3;
90 91 SpectraPacket *spectraPacketNormalSpectrumF0;
92 SpectraPacket *spectraPacketNormalSpectrumF1;
93 SpectraPacket *spectraPacketNormalSpectrumF2;
91 94
92 95 bool parsingContinue;
93 96
94 97 signals:
95 98 void socketTMHasChanged(QTcpSocket *socket);
96 99
97 100 public slots:
98 101 void displayOnConsole(QString message);
99 102 void listenOnTCTMPorts();
100 103 void testTCTMPorts();
101 104 void newConnectionOnTCServer();
102 105 void newConnectionOnTMServer();
103 106 void readDataOnTCPort();
104 107 void readDataOnTMPort();
105 108 void readDataOnSocketEchoServer();
106 109 void openEchoServer();
107 110 void socket_TMEcho_ServerHasChanged();
108 111 void processIncomingPacket(TMPacketToRead *packet);
109 112 void resetStatistics();
110 113 void processPacketStore();
111 114 };
112 115
113 116 #endif // MAINWINDOW_H
Show file before | Show file after | Hide comments
@@ -1,203 +1,219
1 1 #include "mainwindowui.h"
2 2
3 3 MainWindowUI::MainWindowUI(QWidget *parent) :
4 4 QWidget(parent)
5 5 {
6 6 label_serverTMEcho = new QLabel(tr("TM Echo Server address"));
7 7 label_serverTMEchoPort = new QLabel(tr("TM Echo Server Port"));
8 8 label_TMServerPort = new QLabel(tr("TM Server Port:"));
9 9 label_TCServerPort = new QLabel(tr("TC Server Port:"));
10 10 label_currentTCTMServer = new QLabel(tr("Current IP address:"));
11 11 label_currentTCTMServerIP = new QLabel(tr("-"));
12 12 label_totalOfBytes = new QLabel(tr("Received Bytes: -"));
13 13 label_totalOfPackets = new QLabel(tr("Received Packets: -"));
14 14
15 15 console = new QTextEdit();
16 16
17 17 spwTabWidget = new QTabWidget();
18 18 spwTabWidgetPage0 = new QWidget();
19 19 spwTabWidgetPage1 = new QWidget();
20 20 spwTabWidgetPage2 = new QWidget();
21 21 spwTabWidgetPage3 = new QWidget();
22 22
23 23 tmStatistics = new TMStatistics;
24 24
25 25 wfDisplay = new WFDisplay(0, 2048, 2048, 15000);
26 26 wfPage_CWF_F1 = new WFPage(0, 8 * BLK_NR_CWF, 8 * BLK_NR_CWF, 15000);
27 27 wfPage_CWF_F2 = new WFPage(0, 8 * BLK_NR_CWF, 8 * BLK_NR_CWF, 15000);
28 28 wfPage_CWF_F3 = new WFPage(0, 8 * BLK_NR_CWF, 8 * BLK_NR_CWF, 15000);
29 29 asmPage_F0 = new ASMPage(0, NB_BINS_PER_ASM_F0, NB_BINS_PER_ASM_F0, 15000);
30 asmPage_F1 = new ASMPage(0, NB_BINS_PER_ASM_F1, NB_BINS_PER_ASM_F1, 15000);
31 asmPage_F2 = new ASMPage(0, NB_BINS_PER_ASM_F2, NB_BINS_PER_ASM_F2, 15000);
30 32
31 33 wfPage_CWF_F1->pageTitle = "SBM1_CWF_F1";
32 34 wfPage_CWF_F2->pageTitle = "SBM2_CWF_F2";
33 35 wfPage_CWF_F3->pageTitle = "NORM_CWF_F3";
34 36 asmPage_F0->pageTitle = "ASM_F0";
37 asmPage_F1->pageTitle = "ASM_F1";
38 asmPage_F2->pageTitle = "ASM_F2";
35 39 hkDisplay = new HKDisplay();
36 40 recordPage = new RecordPage;
37 41
38 42 spinbox_TMServerPort = new QSpinBox();
39 43 spinbox_TCServerPort = new QSpinBox();
40 44 spinbox_serverTMEchoPort = new QSpinBox();
41 45 spinbox_TMServerPort->setRange(59000, 65535);
42 46 spinbox_TCServerPort->setRange(59001, 65535);
43 47 spinbox_serverTMEchoPort->setRange(59002, 65535);
44 48
45 49 button_openServerTCTM = new QPushButton(tr("Open TC / TM Ports"));
46 50 button_testServerTCTM = new QPushButton(tr("Test TC / TM Ports"));
47 51 button_openSocketEchoServer = new QPushButton(tr("Open Echo Server"));
48 52 button_TCAcknowledgement = new QPushButton(tr("send TC Acknowledgement"));
49 53 button_TCRejection = new QPushButton(tr("send TC rejection"));
50 54 button_GSEHK = new QPushButton(tr("send GSE HK"));
51 55 button_clearConsole = new QPushButton(tr("Clear console"));
52 56 button_resetStatistics = new QPushButton(tr("Reset statistics"));
53 57
54 58 serverTMEchoDialogBox = new QIPDialogBox();
55 59 serverTMEchoDialogBox->setIP(127, 0, 0, 1);
56 60
57 61 groupbox_TMEcho = new QGroupBox(tr("TM Echo Server"));
58 62 groupbox_ports = new QGroupBox(tr("Ports for the TM and TC Servers"));
59 63 groupbox_TMToForeignGSETester = new QGroupBox(tr("Send TM to the foreign GSE tester"));
60 64
61 65 layout_TMEcho = new QVBoxLayout();
62 66 layout_overallLayout = new QVBoxLayout();
63 67 layout_ports = new QGridLayout();
64 68 layout_TMToForeignGSETester = new QVBoxLayout();
65 69 mainLayout = new QGridLayout();
66 70
67 71 parameterDump = new ParameterDump();
68 72
69 73 layout_TMEcho->addWidget(label_serverTMEcho);
70 74 layout_TMEcho->addWidget(serverTMEchoDialogBox);
71 75 layout_TMEcho->addWidget(label_serverTMEchoPort);
72 76 layout_TMEcho->addWidget(spinbox_serverTMEchoPort);
73 77 layout_TMEcho->addWidget(button_openSocketEchoServer);
74 78 layout_TMEcho->addWidget(label_totalOfPackets);
75 79 layout_TMEcho->addWidget(label_totalOfBytes);
76 80 layout_TMEcho->addWidget(button_resetStatistics);
77 81 groupbox_TMEcho->setLayout(layout_TMEcho);
78 82
79 83 layout_ports->addWidget(label_TMServerPort, 0, 0, 1, 1);
80 84 layout_ports->addWidget(spinbox_TMServerPort, 0, 1, 1, 1);
81 85 layout_ports->addWidget(label_TCServerPort, 1, 0, 1, 1);
82 86 layout_ports->addWidget(spinbox_TCServerPort, 1, 1, 1, 1);
83 87 layout_ports->addWidget(button_openServerTCTM, 2, 0, 1, 2);
84 88 layout_ports->addWidget(button_testServerTCTM, 3, 0, 1, 2);
85 89 groupbox_ports->setLayout(layout_ports);
86 90
87 91 layout_TMToForeignGSETester->addWidget(button_TCAcknowledgement);
88 92 layout_TMToForeignGSETester->addWidget(button_TCRejection);
89 93 layout_TMToForeignGSETester->addWidget(button_GSEHK);
90 94 groupbox_TMToForeignGSETester->setLayout(layout_TMToForeignGSETester);
91 95
92 96 mainLayout->addWidget(groupbox_TMEcho, 0, 0, 1, 1);
93 97 mainLayout->addWidget(button_clearConsole, 1, 0, 1, 1);
94 98 mainLayout->addWidget(console, 0, 1, 2, 1);
95 99 mainLayout->addWidget(groupbox_ports, 2, 0, 1, 1);
96 100 mainLayout->addWidget(groupbox_TMToForeignGSETester, 2, 1, 1, 1);
97 101 mainLayout->setColumnStretch(2, 1);
98 102 mainLayout->setRowStretch(3, 1);
99 103
100 104 spwTabWidget->addTab(spwTabWidgetPage0, tr("Connection"));
101 105 spwTabWidget->addTab(spwTabWidgetPage1, tr("TM Statistics"));
102 106 spwTabWidget->addTab(spwTabWidgetPage3, tr("HK"));
103 107 spwTabWidget->addTab(parameterDump, tr("DUMP"));
104 108 spwTabWidget->addTab(recordPage, tr("REC"));
105 109 spwTabWidget->addTab(spwTabWidgetPage2, tr("WFRM NORM"));
106 110 spwTabWidget->addTab( wfPage_CWF_F1, tr("CWF_F1"));
107 111 spwTabWidget->addTab( wfPage_CWF_F2, tr("CWF_F2"));
108 112 spwTabWidget->addTab( wfPage_CWF_F3, tr("CWF_F3"));
109 113 spwTabWidget->addTab( asmPage_F0, tr("ASM_F0"));
114 spwTabWidget->addTab( asmPage_F1, tr("ASM_F1"));
115 spwTabWidget->addTab( asmPage_F2, tr("ASM_F2"));
110 116
111 117 spwTabWidgetPage0->setLayout(mainLayout);
112 118 spwTabWidgetPage1->setLayout(tmStatistics->layout());
113 119 spwTabWidgetPage2->setLayout(wfDisplay->layout());
114 120 spwTabWidgetPage3->setLayout(hkDisplay->layout());
115 121
116 122 layout_overallLayout->addWidget(spwTabWidget);
117 123
118 124 this->setLayout(layout_overallLayout);
119 125
120 126 connect(this->button_clearConsole, SIGNAL(clicked()), this, SLOT(clearConsole()));
121 127
122 128 // SWF_F0
123 129 connect(this->recordPage, SIGNAL(signal_store_swf_f0()),
124 130 this->wfDisplay->page_f0, SLOT(storeWfrm()));
125 131 connect(this->recordPage, SIGNAL(signal_defaultStorageDirectoryUpdated(QString)),
126 132 this->wfDisplay->page_f0, SLOT(setDefaultStorageDirectory(QString)));
127 133 // SWF_F1
128 134 connect(this->recordPage, SIGNAL(signal_store_swf_f1()),
129 135 this->wfDisplay->page_f1, SLOT(storeWfrm()));
130 136 connect(this->recordPage, SIGNAL(signal_defaultStorageDirectoryUpdated(QString)),
131 137 this->wfDisplay->page_f1, SLOT(setDefaultStorageDirectory(QString)));
132 138 // SWF_F2
133 139 connect(this->recordPage, SIGNAL(signal_store_swf_f2()),
134 140 this->wfDisplay->page_f2, SLOT(storeWfrm()));
135 141 connect(this->recordPage, SIGNAL(signal_defaultStorageDirectoryUpdated(QString)),
136 142 this->wfDisplay->page_f2, SLOT(setDefaultStorageDirectory(QString)));
137 143 // CWF_F1
138 144 connect(this->recordPage, SIGNAL(signal_store_cwf_f1()),
139 145 this->wfPage_CWF_F1, SLOT(storeWfrm()));
140 146 connect(this->recordPage, SIGNAL(signal_defaultStorageDirectoryUpdated(QString)),
141 147 this->wfPage_CWF_F1, SLOT(setDefaultStorageDirectory(QString)));
142 148 // CWF_F2
143 149 connect(this->recordPage, SIGNAL(signal_store_cwf_f2()),
144 150 this->wfPage_CWF_F2, SLOT(storeWfrm()));
145 151 connect(this->recordPage, SIGNAL(signal_defaultStorageDirectoryUpdated(QString)),
146 152 this->wfPage_CWF_F2, SLOT(setDefaultStorageDirectory(QString)));
147 153 // CWF_F3
148 154 connect(this->recordPage, SIGNAL(signal_store_cwf_f3()),
149 155 this->wfPage_CWF_F3, SLOT(storeWfrm()));
150 156 connect(this->recordPage, SIGNAL(signal_defaultStorageDirectoryUpdated(QString)),
151 157 this->wfPage_CWF_F3, SLOT(setDefaultStorageDirectory(QString)));
152 158 // ASM_F0
153 159 connect(this->recordPage, SIGNAL(signal_store_asm_f0()),
154 160 this->asmPage_F0, SLOT(storeWfrm()));
155 161 connect(this->recordPage, SIGNAL(signal_defaultStorageDirectoryUpdated(QString)),
156 162 this->asmPage_F0, SLOT(setDefaultStorageDirectory(QString)));
163 // ASM_F1
164 connect(this->recordPage, SIGNAL(signal_store_asm_f1()),
165 this->asmPage_F1, SLOT(storeWfrm()));
166 connect(this->recordPage, SIGNAL(signal_defaultStorageDirectoryUpdated(QString)),
167 this->asmPage_F1, SLOT(setDefaultStorageDirectory(QString)));
168 // ASM_F2
169 connect(this->recordPage, SIGNAL(signal_store_asm_f2()),
170 this->asmPage_F2, SLOT(storeWfrm()));
171 connect(this->recordPage, SIGNAL(signal_defaultStorageDirectoryUpdated(QString)),
172 this->asmPage_F2, SLOT(setDefaultStorageDirectory(QString)));
157 173
158 174 emit this->recordPage->signal_defaultStorageDirectoryUpdated(this->recordPage->defaultStorageDirectory);
159 175 }
160 176
161 177 QString MainWindowUI::getTMEchoServerAddress()
162 178 {
163 179 return(serverTMEchoDialogBox->getIP());
164 180 }
165 181
166 182 void MainWindowUI::setTCTMServerAddressIP(QString address)
167 183 {
168 184 label_currentTCTMServerIP->setText(address);
169 185 }
170 186
171 187 int MainWindowUI::getTMPort()
172 188 {
173 189 return spinbox_TMServerPort->value();
174 190 }
175 191
176 192 int MainWindowUI::getTCPort()
177 193 {
178 194 return spinbox_TCServerPort->value();
179 195 }
180 196
181 197 void MainWindowUI::displayOnConsole(QString message)
182 198 {
183 199 console->append(message);
184 200 }
185 201
186 202 void MainWindowUI::clearConsole()
187 203 {
188 204 console->clear();
189 205 }
190 206
191 207 void MainWindowUI::totalOfBytesHasChanged(unsigned int nbBytes)
192 208 {
193 209 label_totalOfBytes->setText(
194 210 "Received Bytes: "
195 211 + QString::number(nbBytes));
196 212 }
197 213
198 214 void MainWindowUI::totalOfPacketsHasChanged(unsigned int nbPackets)
199 215 {
200 216 label_totalOfPackets->setText(
201 217 "Received Packets: "
202 218 + QString::number(nbPackets));
203 219 }
Show file before | Show file after | Hide comments
@@ -1,104 +1,106
1 1 #ifndef MAINWINDOWUI_H
2 2 #define MAINWINDOWUI_H
3 3
4 4 #include <QWidget>
5 5 #include <qipdialogbox.h>
6 6 #include <QLabel>
7 7 #include <QPushButton>
8 8 #include <QGridLayout>
9 9 #include <QVBoxLayout>
10 10 #include <QGroupBox>
11 11 #include <QSpinBox>
12 12 #include <QTextEdit>
13 13 #include <QTabWidget>
14 14
15 15 #include <wfdisplay.h>
16 16 #include <pagespectra.h>
17 17 #include <asmpage.h>
18 18 #include <parameterdump.h>
19 19
20 20 #include "tmstatistics.h"
21 21 #include "hkdisplay.h"
22 22 #include "recordpage.h"
23 23
24 24 class MainWindowUI : public QWidget
25 25 {
26 26 Q_OBJECT
27 27 public:
28 28 explicit MainWindowUI(QWidget *parent = 0);
29 29
30 30 void setTCTMServerAddressIP(QString address);
31 31 QString getTMEchoServerAddress();
32 32 int getTMPort();
33 33 int getTCPort();
34 34 void displayOnConsole(QString message);
35 35
36 36 QTabWidget *spwTabWidget;
37 37 QWidget* spwTabWidgetPage0;
38 38 QWidget* spwTabWidgetPage1;
39 39 QWidget* spwTabWidgetPage2;
40 40 QWidget* spwTabWidgetPage3;
41 41
42 42 TMStatistics* tmStatistics;
43 43
44 44 WFDisplay* wfDisplay;
45 45 WFPage* wfPage_CWF_F1;
46 46 WFPage* wfPage_CWF_F2;
47 47 WFPage* wfPage_CWF_F3;
48 48 ASMPage* asmPage_F0;
49 ASMPage* asmPage_F1;
50 ASMPage* asmPage_F2;
49 51 HKDisplay* hkDisplay;
50 52 RecordPage* recordPage;
51 53
52 54 QWidget* widget_spectrogram;
53 55
54 56 ParameterDump* parameterDump;
55 57
56 58 QPushButton *button_openServerTCTM;
57 59 QPushButton *button_testServerTCTM;
58 60 QPushButton *button_openSocketEchoServer;
59 61 QPushButton *button_TCAcknowledgement;
60 62 QPushButton *button_TCRejection;
61 63 QPushButton *button_GSEHK;
62 64 QPushButton *button_clearConsole;
63 65 QPushButton *button_resetStatistics;
64 66
65 67 QIPDialogBox *serverTMEchoDialogBox;
66 68
67 69 QSpinBox *spinbox_serverTMEchoPort;
68 70
69 71 signals:
70 72
71 73 public slots:
72 74 void clearConsole();
73 75 void totalOfBytesHasChanged(unsigned int nbBytes);
74 76 void totalOfPacketsHasChanged(unsigned int nbPackets);
75 77
76 78 private:
77 79 QLabel *label_serverTMEcho;
78 80 QLabel *label_serverTMEchoPort;
79 81 QLabel *label_TMServerPort;
80 82 QLabel *label_TCServerPort;
81 83 QLabel *label_currentTCTMServer;
82 84 QLabel *label_currentTCTMServerIP;
83 85 QLabel *label_totalOfBytes;
84 86 QLabel *label_totalOfPackets;
85 87
86 88 QTextEdit *console;
87 89
88 90 QSpinBox *spinbox_TMServerPort;
89 91 QSpinBox *spinbox_TCServerPort;
90 92
91 93 QGroupBox *groupbox_TMEcho;
92 94 QGroupBox *groupbox_ports;
93 95 QGroupBox *groupbox_TMToForeignGSETester;
94 96
95 97 QVBoxLayout *layout_TMEcho;
96 98 QVBoxLayout *layout_TMToForeignGSETester;
97 99 QVBoxLayout *layout_overallLayout;
98 100
99 101 QGridLayout *mainLayout;
100 102 QGridLayout *layout_ports;
101 103
102 104 };
103 105
104 106 #endif // MAINWINDOWUI_H
Show file before | Show file after | Hide comments
@@ -1,157 +1,171
1 1 #include "recordpage.h"
2 2
3 3 RecordPage::RecordPage(QWidget *parent) :
4 4 QWidget(parent)
5 5 {
6 6 logFileEn = false;
7 7
8 8 radiobutton_swf_f0 = new QRadioButton("swf_f0");
9 9 radiobutton_swf_f1 = new QRadioButton("swf_f1");
10 10 radiobutton_swf_f2 = new QRadioButton("swf_f2");
11 11 radiobutton_cwf_f1 = new QRadioButton("cwf_f1");
12 12 radiobutton_cwf_f2 = new QRadioButton("cwf_f2");
13 13 radiobutton_cwf_f3 = new QRadioButton("cwf_f3");
14 14 radiobutton_asm_f0 = new QRadioButton("asm_f0");
15 radiobutton_asm_f1 = new QRadioButton("asm_f1");
16 radiobutton_asm_f2 = new QRadioButton("asm_f2");
15 17
16 18 radiobutton_swf_f0->setAutoExclusive(false);
17 19 radiobutton_swf_f1->setAutoExclusive(false);
18 20 radiobutton_swf_f2->setAutoExclusive(false);
19 21 radiobutton_cwf_f1->setAutoExclusive(false);
20 22 radiobutton_cwf_f2->setAutoExclusive(false);
21 23 radiobutton_cwf_f3->setAutoExclusive(false);
22 24 radiobutton_asm_f0->setAutoExclusive(false);
25 radiobutton_asm_f1->setAutoExclusive(false);
26 radiobutton_asm_f2->setAutoExclusive(false);
23 27
24 28 label_currentDir = new QLabel("Current Dir: -");
25 29
26 30 button_chooseDir = new QPushButton("choose dir");
27 31 button_storeWfrm = new QPushButton(tr("REC"));
28 32
29 33 groupbox_waveforms = new QGroupBox("waveforms");
30 34 groupbox_matrices = new QGroupBox("spectral matrices");
31 35 groupbox_directory = new QGroupBox("directory");
32 36
33 37 vboxlayout_waveforms = new QVBoxLayout();
34 38 vboxlayout_matrices = new QVBoxLayout();
35 39 vboxlayout_directory = new QVBoxLayout();
36 40
37 41 mainLayout = new QGridLayout();
38 42
39 43 this->readSettings();
40 44
41 45 vboxlayout_waveforms->addWidget(radiobutton_swf_f0);
42 46 vboxlayout_waveforms->addWidget(radiobutton_swf_f1);
43 47 vboxlayout_waveforms->addWidget(radiobutton_swf_f2);
44 48 vboxlayout_waveforms->addWidget(radiobutton_cwf_f1);
45 49 vboxlayout_waveforms->addWidget(radiobutton_cwf_f2);
46 50 vboxlayout_waveforms->addWidget(radiobutton_cwf_f3);
47 51 vboxlayout_waveforms->addStretch();
48 52
49 53
50 54 vboxlayout_matrices->addWidget(radiobutton_asm_f0);
55 vboxlayout_matrices->addWidget(radiobutton_asm_f1);
56 vboxlayout_matrices->addWidget(radiobutton_asm_f2);
51 57 vboxlayout_matrices->addStretch();
52 58
53 59 vboxlayout_directory->addWidget(button_storeWfrm);
54 60 vboxlayout_directory->addWidget(button_chooseDir);
55 61 vboxlayout_directory->addWidget(label_currentDir);
56 62 vboxlayout_directory->addStretch();
57 63
58 64 groupbox_waveforms->setLayout(vboxlayout_waveforms);
59 65 groupbox_matrices->setLayout(vboxlayout_matrices);
60 66 groupbox_directory->setLayout(vboxlayout_directory);
61 67
62 68 mainLayout->addWidget(groupbox_directory, 0, 0, 1, 1);
63 69 mainLayout->addWidget(groupbox_waveforms, 0, 1, 1, 1);
64 70 mainLayout->addWidget(groupbox_matrices, 0, 2, 1, 1);
65 71 mainLayout->setRowStretch(1, 1);
66 72 mainLayout->setColumnStretch(3, 1);
67 73
68 74 this->setLayout(mainLayout);
69 75
70 76 connect(this->button_chooseDir, SIGNAL(clicked()), this, SLOT(chooseDir()));
71 77 connect(this->button_storeWfrm, SIGNAL(clicked()), this, SLOT(storeWfrm()));
72 78 }
73 79
74 80 RecordPage::~RecordPage()
75 81 {
76 82 this->writeSettings();
77 83 }
78 84
79 85 void RecordPage::chooseDir()
80 86 {
81 87 QString tmpDefaultStorageDirectory;
82 88 tmpDefaultStorageDirectory = QFileDialog::getExistingDirectory(this,
83 89 "choose the directory",
84 90 QDir::homePath(),
85 91 QFileDialog::ShowDirsOnly);
86 92
87 93 if( !tmpDefaultStorageDirectory.isEmpty() )
88 94 {
89 95 defaultStorageDirectory = tmpDefaultStorageDirectory;
90 96 }
91 97
92 98 label_currentDir->setText(defaultStorageDirectory);
93 99 emit signal_defaultStorageDirectoryUpdated( defaultStorageDirectory );
94 100 }
95 101
96 102 void RecordPage::storeWfrm()
97 103 {
98 104 if (logFileEn == false)
99 105 {
100 106 // enable storage
101 107 button_storeWfrm->setText(tr("STOP"));
102 108 logFileEn = true;
103 109 if (radiobutton_swf_f0->isChecked()) emit signal_store_swf_f0();
104 110 if (radiobutton_swf_f1->isChecked()) emit signal_store_swf_f1();
105 111 if (radiobutton_swf_f2->isChecked()) emit signal_store_swf_f2();
106 112 if (radiobutton_cwf_f1->isChecked()) emit signal_store_cwf_f1();
107 113 if (radiobutton_cwf_f2->isChecked()) emit signal_store_cwf_f2();
108 114 if (radiobutton_cwf_f3->isChecked()) emit signal_store_cwf_f3();
109 115 if (radiobutton_asm_f0->isChecked()) emit signal_store_asm_f0();
116 if (radiobutton_asm_f1->isChecked()) emit signal_store_asm_f0();
117 if (radiobutton_asm_f2->isChecked()) emit signal_store_asm_f0();
110 118 radiobutton_swf_f0->setEnabled(false);
111 119 radiobutton_swf_f1->setEnabled(false);
112 120 radiobutton_swf_f2->setEnabled(false);
113 121 radiobutton_cwf_f1->setEnabled(false);
114 122 radiobutton_cwf_f2->setEnabled(false);
115 123 radiobutton_cwf_f3->setEnabled(false);
116 124 radiobutton_asm_f0->setEnabled(false);
125 radiobutton_asm_f1->setEnabled(false);
126 radiobutton_asm_f2->setEnabled(false);
117 127 }
118 128 else
119 129 {
120 130 // disable storage
121 131 button_storeWfrm->setText(tr("REC"));
122 132 logFileEn = false;
123 133 if (radiobutton_swf_f0->isChecked()) emit signal_store_swf_f0();
124 134 if (radiobutton_swf_f1->isChecked()) emit signal_store_swf_f1();
125 135 if (radiobutton_swf_f2->isChecked()) emit signal_store_swf_f2();
126 136 if (radiobutton_cwf_f1->isChecked()) emit signal_store_cwf_f1();
127 137 if (radiobutton_cwf_f2->isChecked()) emit signal_store_cwf_f2();
128 138 if (radiobutton_cwf_f3->isChecked()) emit signal_store_cwf_f3();
129 139 if (radiobutton_asm_f0->isChecked()) emit signal_store_asm_f0();
140 if (radiobutton_asm_f1->isChecked()) emit signal_store_asm_f1();
141 if (radiobutton_asm_f2->isChecked()) emit signal_store_asm_f2();
130 142 radiobutton_swf_f0->setEnabled(true);
131 143 radiobutton_swf_f1->setEnabled(true);
132 144 radiobutton_swf_f2->setEnabled(true);
133 145 radiobutton_cwf_f1->setEnabled(true);
134 146 radiobutton_cwf_f2->setEnabled(true);
135 147 radiobutton_cwf_f3->setEnabled(true);
136 148 radiobutton_asm_f0->setEnabled(true);
149 radiobutton_asm_f1->setEnabled(true);
150 radiobutton_asm_f2->setEnabled(true);
137 151 }
138 152 }
139 153
140 154 void RecordPage::readSettings()
141 155 {
142 156 QSettings settings("lpp", "lfrsgse");
143 157 defaultStorageDirectory = settings.value( "storageDirectory", QDir::homePath() ).toString();
144 158 label_currentDir->setText( defaultStorageDirectory );
145 159 emit signal_defaultStorageDirectoryUpdated( defaultStorageDirectory );
146 160 }
147 161
148 162 void RecordPage::writeSettings()
149 163 {
150 164 QSettings settings("lpp", "lfrsgse");
151 165 settings.setValue("storageDirectory", defaultStorageDirectory);
152 166 }
153 167
154 168 void RecordPage::closeEvent(QCloseEvent *event)
155 169 {
156 170 event->accept();
157 171 }
Show file before | Show file after | Hide comments
@@ -1,70 +1,74
1 1 #ifndef RECORDPAGE_H
2 2 #define RECORDPAGE_H
3 3
4 4 #include <QWidget>
5 5 #include <QRadioButton>
6 6 #include <QGroupBox>
7 7 #include <QVBoxLayout>
8 8 #include <QGridLayout>
9 9 #include <QLabel>
10 10 #include <QPushButton>
11 11 #include <QSettings>
12 12 #include <QFileDialog>
13 13 #include <QCloseEvent>
14 14
15 15 class RecordPage : public QWidget
16 16 {
17 17 Q_OBJECT
18 18 public:
19 19 explicit RecordPage(QWidget *parent = 0);
20 20 ~RecordPage();
21 21
22 22 QLabel *label_currentDir;
23 23
24 24 bool logFileEn;
25 25
26 26 QPushButton *button_chooseDir;
27 27 QPushButton *button_storeWfrm;
28 28
29 29 QRadioButton *radiobutton_swf_f0;
30 30 QRadioButton *radiobutton_swf_f1;
31 31 QRadioButton *radiobutton_swf_f2;
32 32 QRadioButton *radiobutton_cwf_f1;
33 33 QRadioButton *radiobutton_cwf_f2;
34 34 QRadioButton *radiobutton_cwf_f3;
35 35 QRadioButton *radiobutton_asm_f0;
36 QRadioButton *radiobutton_asm_f1;
37 QRadioButton *radiobutton_asm_f2;
36 38
37 39 QGroupBox *groupbox_waveforms;
38 40 QGroupBox *groupbox_matrices;
39 41 QGroupBox *groupbox_directory;
40 42
41 43 QVBoxLayout *vboxlayout_waveforms;
42 44 QVBoxLayout *vboxlayout_matrices;
43 45 QVBoxLayout *vboxlayout_directory;
44 46
45 47 QString defaultStorageDirectory;
46 48
47 49 QGridLayout *mainLayout;
48 50
49 51 protected:
50 52 void closeEvent(QCloseEvent *event);
51 53
52 54 signals:
53 55 void signal_store_swf_f0();
54 56 void signal_store_swf_f1();
55 57 void signal_store_swf_f2();
56 58 void signal_store_cwf_f1();
57 59 void signal_store_cwf_f2();
58 60 void signal_store_cwf_f3();
59 61 void signal_store_asm_f0();
62 void signal_store_asm_f1();
63 void signal_store_asm_f2();
60 64 void signal_defaultStorageDirectoryUpdated( QString nameOfTheDirectory );
61 65
62 66 public slots:
63 67 void chooseDir();
64 68 void storeWfrm();
65 69 void readSettings();
66 70 void writeSettings();
67 71
68 72 };
69 73
70 74 #endif // RECORDPAGE_H
General Comments 0
You need to be logged in to leave comments. Login now