##// END OF EJS Templates
schain
RSS
test zmq for rawdata
José Chávez -
r975:a07abe3cf821
parent child
Show More
Show file before | Show file after | Hide comments
@@ -101,4 +101,8 ENV/
101 101 .project
102 102 .pydevproject
103 103
104 # vscode
105
106 .vscode
107
104 108 schainpy/scripts/ No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,3 +1,4
1 1 {
2 "python.linting.pylintEnabled": true
2 "python.linting.pylintEnabled": true,
3 "git.ignoreLimitWarning": true
3 4 } No newline at end of file
Show file before | Show file after | Hide comments
@@ -132,18 +132,17 class BasicHeader(Header):
132 132
133 133 def read(self, fp):
134 134
135 self.length = 0
135 136 try:
136 137 if hasattr(fp, 'read'):
137 print 'fromfile'
138 138 header = numpy.fromfile(fp, BASIC_STRUCTURE,1)
139 139 else:
140 print 'fromstring'
141 140 header = numpy.fromstring(fp, BASIC_STRUCTURE,1)
142 141 except Exception, e:
143 142 print "BasicHeader: "
144 143 print e
145 144 return 0
146
145
147 146 self.size = int(header['nSize'][0])
148 147 self.version = int(header['nVersion'][0])
149 148 self.dataBlock = int(header['nDataBlockId'][0])
@@ -155,7 +154,8 class BasicHeader(Header):
155 154
156 155 if self.size < 24:
157 156 return 0
158
157
158 self.length = header.nbytes
159 159 return 1
160 160
161 161 def write(self, fp):
@@ -200,13 +200,20 class SystemHeader(Header):
200 200 self.pciDioBusWidth = pciDioBusWith
201 201
202 202 def read(self, fp):
203
204 startFp = fp.tell()
205
203 self.length = 0
206 204 try:
207 header = numpy.fromfile(fp,SYSTEM_STRUCTURE,1)
205 startFp = fp.tell()
208 206 except Exception, e:
209 print "System Header: " + e
207 startFp = None
208 pass
209
210 try:
211 if hasattr(fp, 'read'):
212 header = numpy.fromfile(fp, SYSTEM_STRUCTURE,1)
213 else:
214 header = numpy.fromstring(fp, SYSTEM_STRUCTURE,1)
215 except Exception, e:
216 print "System Header: " + str(e)
210 217 return 0
211 218
212 219 self.size = header['nSize'][0]
@@ -216,16 +223,19 class SystemHeader(Header):
216 223 self.adcResolution = header['nADCResolution'][0]
217 224 self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
218 225
219 endFp = self.size + startFp
220 226
221 if fp.tell() > endFp:
222 sys.stderr.write("Warning %s: Size value read from System Header is lower than it has to be\n" %fp.name)
223 return 0
227 if startFp is not None:
228 endFp = self.size + startFp
224 229
225 if fp.tell() < endFp:
226 sys.stderr.write("Warning %s: Size value read from System Header size is greater than it has to be\n" %fp.name)
227 return 0
230 if fp.tell() > endFp:
231 sys.stderr.write("Warning %s: Size value read from System Header is lower than it has to be\n" %fp.name)
232 return 0
233
234 if fp.tell() < endFp:
235 sys.stderr.write("Warning %s: Size value read from System Header size is greater than it has to be\n" %fp.name)
236 return 0
228 237
238 self.length = header.nbytes
229 239 return 1
230 240
231 241 def write(self, fp):
@@ -302,13 +312,21 class RadarControllerHeader(Header):
302 312 self.fClock = 0.15/(deltaHeight*1e-6) #0.15Km / (height * 1u)
303 313
304 314 def read(self, fp):
305
306
307 startFp = fp.tell()
315 self.length = 0
308 316 try:
309 header = numpy.fromfile(fp,RADAR_STRUCTURE,1)
317 startFp = fp.tell()
310 318 except Exception, e:
311 print "RadarControllerHeader: " + e
319 startFp = None
320 pass
321
322 try:
323 if hasattr(fp, 'read'):
324 header = numpy.fromfile(fp, RADAR_STRUCTURE,1)
325 else:
326 header = numpy.fromstring(fp, RADAR_STRUCTURE,1)
327 self.length += header.nbytes
328 except Exception, e:
329 print "RadarControllerHeader: " + str(e)
312 330 return 0
313 331
314 332 size = int(header['nSize'][0])
@@ -329,23 +347,64 class RadarControllerHeader(Header):
329 347 self.rangeTxA = header['sRangeTxA'][0]
330 348 self.rangeTxB = header['sRangeTxB'][0]
331 349
332 samplingWindow = numpy.fromfile(fp,SAMPLING_STRUCTURE,self.nWindows)
333
350 try:
351 if hasattr(fp, 'read'):
352 samplingWindow = numpy.fromfile(fp, SAMPLING_STRUCTURE, self.nWindows)
353 else:
354 samplingWindow = numpy.fromstring(fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
355 self.length += samplingWindow.nbytes
356 except Exception, e:
357 print "RadarControllerHeader: " + str(e)
358 return 0
334 359 self.nHeights = int(numpy.sum(samplingWindow['nsa']))
335 360 self.firstHeight = samplingWindow['h0']
336 361 self.deltaHeight = samplingWindow['dh']
337 362 self.samplesWin = samplingWindow['nsa']
363
364
365
366 try:
367 if hasattr(fp, 'read'):
368 self.Taus = numpy.fromfile(fp, '<f4', self.numTaus)
369 else:
370 self.Taus = numpy.fromstring(fp[self.length:], '<f4', self.numTaus)
371 self.length += self.Taus.nbytes
372 except Exception, e:
373 print "RadarControllerHeader: " + str(e)
374 return 0
375
338 376
339 self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
340 377
341 378 self.code_size = 0
342 379 if self.codeType != 0:
343 self.nCode = int(numpy.fromfile(fp,'<u4',1))
344 self.nBaud = int(numpy.fromfile(fp,'<u4',1))
345 380
381 try:
382 if hasattr(fp, 'read'):
383 self.nCode = numpy.fromfile(fp, '<u4', 1)
384 self.length += self.nCode.nbytes
385 self.nBaud = numpy.fromfile(fp, '<u4', 1)
386 self.length += self.nBaud.nbytes
387 else:
388 self.nCode = numpy.fromstring(fp[self.length:], '<u4', 1)[0]
389 self.length += self.nCode.nbytes
390 self.nBaud = numpy.fromstring(fp[self.length:], '<u4', 1)[0]
391 self.length += self.nBaud.nbytes
392 except Exception, e:
393 print "RadarControllerHeader: " + str(e)
394 return 0
346 395 code = numpy.empty([self.nCode,self.nBaud],dtype='i1')
396
347 397 for ic in range(self.nCode):
348 temp = numpy.fromfile(fp,'u4',int(numpy.ceil(self.nBaud/32.)))
398 try:
399 if hasattr(fp, 'read'):
400 temp = numpy.fromfile(fp,'u4', int(numpy.ceil(self.nBaud/32.)))
401 else:
402 temp = numpy.fromstring(fp,'u4', int(numpy.ceil(self.nBaud/32.)))
403 self.length += temp.nbytes
404 except Exception, e:
405 print "RadarControllerHeader: " + str(e)
406 return 0
407
349 408 for ib in range(self.nBaud-1,-1,-1):
350 409 code[ic,ib] = temp[ib/32]%2
351 410 temp[ib/32] = temp[ib/32]/2
@@ -358,22 +417,22 class RadarControllerHeader(Header):
358 417 #
359 418 # if self.line6Function == RCfunction.FLIP:
360 419 # self.flip2 = numpy.fromfile(fp,'<u4',1)
361
362 endFp = size + startFp
363
364 if fp.tell() != endFp:
365 # fp.seek(endFp)
366 print "%s: Radar Controller Header size is not consistent: from data [%d] != from header field [%d]" %(fp.name, fp.tell()-startFp, size)
367 # return 0
368
369 if fp.tell() > endFp:
370 sys.stderr.write("Warning %s: Size value read from Radar Controller header is lower than it has to be\n" %fp.name)
371 # return 0
372
373 if fp.tell() < endFp:
374 sys.stderr.write("Warning %s: Size value read from Radar Controller header is greater than it has to be\n" %fp.name)
420 if startFp is not None:
421 endFp = size + startFp
375 422
423 if fp.tell() != endFp:
424 # fp.seek(endFp)
425 print "%s: Radar Controller Header size is not consistent: from data [%d] != from header field [%d]" %(fp.name, fp.tell()-startFp, size)
426 # return 0
427
428 if fp.tell() > endFp:
429 sys.stderr.write("Warning %s: Size value read from Radar Controller header is lower than it has to be\n" %fp.name)
430 # return 0
431
432 if fp.tell() < endFp:
433 sys.stderr.write("Warning %s: Size value read from Radar Controller header is greater than it has to be\n" %fp.name)
376 434
435
377 436 return 1
378 437
379 438 def write(self, fp):
@@ -512,15 +571,23 class ProcessingHeader(Header):
512 571 self.flag_cspc = False
513 572 self.flag_decode = False
514 573 self.flag_deflip = False
515
574 self.length = 0
516 575 def read(self, fp):
517
518 startFp = fp.tell()
576 self.length = 0
577 try:
578 startFp = fp.tell()
579 except Exception, e:
580 startFp = None
581 pass
519 582
520 583 try:
521 header = numpy.fromfile(fp,PROCESSING_STRUCTURE,1)
584 if hasattr(fp, 'read'):
585 header = numpy.fromfile(fp, PROCESSING_STRUCTURE, 1)
586 else:
587 header = numpy.fromstring(fp, PROCESSING_STRUCTURE, 1)
588 self.length += header.nbytes
522 589 except Exception, e:
523 print "ProcessingHeader: " + e
590 print "ProcessingHeader: " + str(e)
524 591 return 0
525 592
526 593 size = int(header['nSize'][0])
@@ -534,14 +601,31 class ProcessingHeader(Header):
534 601 self.nIncohInt = int(header['nIncoherentIntegrations'][0])
535 602 self.totalSpectra = int(header['nTotalSpectra'][0])
536 603
537 samplingWindow = numpy.fromfile(fp,SAMPLING_STRUCTURE,self.nWindows)
604 try:
605 if hasattr(fp, 'read'):
606 samplingWindow = numpy.fromfile(fp, SAMPLING_STRUCTURE, self.nWindows)
607 else:
608 samplingWindow = numpy.fromstring(fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
609 self.length += samplingWindow.nbytes
610 except Exception, e:
611 print "ProcessingHeader: " + str(e)
612 return 0
538 613
539 614 self.nHeights = int(numpy.sum(samplingWindow['nsa']))
540 615 self.firstHeight = float(samplingWindow['h0'][0])
541 616 self.deltaHeight = float(samplingWindow['dh'][0])
542 617 self.samplesWin = samplingWindow['nsa'][0]
543 618
544 self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
619
620 try:
621 if hasattr(fp, 'read'):
622 self.spectraComb = numpy.fromfile(fp, 'u1', 2*self.totalSpectra)
623 else:
624 self.spectraComb = numpy.fromstring(fp[self.length:], 'u1', 2*self.totalSpectra)
625 self.length += self.spectraComb.nbytes
626 except Exception, e:
627 print "ProcessingHeader: " + str(e)
628 return 0
545 629
546 630 if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
547 631 self.nCode = int(numpy.fromfile(fp,'<u4',1))
@@ -587,14 +671,16 class ProcessingHeader(Header):
587 671 if nPairs > 0:
588 672 self.flag_cspc = True
589 673
590 endFp = size + startFp
591 674
592 if fp.tell() > endFp:
593 sys.stderr.write("Warning: Processing header size is lower than it has to be")
594 return 0
595
596 if fp.tell() < endFp:
597 sys.stderr.write("Warning: Processing header size is greater than it is considered")
675
676 if startFp is not None:
677 endFp = size + startFp
678 if fp.tell() > endFp:
679 sys.stderr.write("Warning: Processing header size is lower than it has to be")
680 return 0
681
682 if fp.tell() < endFp:
683 sys.stderr.write("Warning: Processing header size is greater than it is considered")
598 684
599 685 return 1
600 686
Show file before | Show file after | Hide comments
@@ -13,8 +13,8 class Scope(Figure):
13 13
14 14 isConfig = None
15 15
16 def __init__(self):
17
16 def __init__(self, **kwargs):
17 Figure.__init__(self, **kwargs)
18 18 self.isConfig = False
19 19 self.WIDTH = 300
20 20 self.HEIGHT = 200
Show file before | Show file after | Hide comments
@@ -994,9 +994,9 class JRODataReader(JRODataIO):
994 994 self.__isFirstTimeOnline = 0
995 995
996 996 def __setNewBlock(self):
997 if self.server is None:
998 if self.fp == None:
999 return 0
997 #if self.server is None:
998 if self.fp == None:
999 return 0
1000 1000
1001 1001 # if self.online:
1002 1002 # self.__jumpToLastBlock()
@@ -1013,23 +1013,23 class JRODataReader(JRODataIO):
1013 1013 else:
1014 1014 return 1
1015 1015 print 'xxxx'
1016 if self.server is None:
1017 currentSize = self.fileSize - self.fp.tell()
1018 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
1019 if (currentSize >= neededSize):
1020 self.basicHeaderObj.read(self.fp)
1021 self.lastUTTime = self.basicHeaderObj.utc
1022 return 1
1023 else:
1024 self.basicHeaderObj.read(self.zHeader)
1016 #if self.server is None:
1017 currentSize = self.fileSize - self.fp.tell()
1018 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
1019 if (currentSize >= neededSize):
1020 self.basicHeaderObj.read(self.fp)
1025 1021 self.lastUTTime = self.basicHeaderObj.utc
1026 1022 return 1
1023 # else:
1024 # self.basicHeaderObj.read(self.zHeader)
1025 # self.lastUTTime = self.basicHeaderObj.utc
1026 # return 1
1027 1027 if self.__waitNewBlock():
1028 1028 self.lastUTTime = self.basicHeaderObj.utc
1029 1029 return 1
1030 if self.server is None:
1031 if not(self.setNextFile()):
1032 return 0
1030 #if self.server is None:
1031 if not(self.setNextFile()):
1032 return 0
1033 1033
1034 1034 deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
1035 1035 self.lastUTTime = self.basicHeaderObj.utc
@@ -1290,7 +1290,7 class JRODataReader(JRODataIO):
1290 1290 self.server = address
1291 1291 self.context = zmq.Context()
1292 1292 self.receiver = self.context.socket(zmq.PULL)
1293 self.receiver.bind(self.server)
1293 self.receiver.connect(self.server)
1294 1294 time.sleep(0.5)
1295 1295 print '[Starting] ReceiverData from {}'.format(self.server)
1296 1296 else:
@@ -1503,8 +1503,10 class JRODataReader(JRODataIO):
1503 1503 server=server,
1504 1504 verbose=verbose)
1505 1505 self.isConfig = True
1506 print 'hola'
1507 self.getData()
1506 if server is None:
1507 self.getData()
1508 else:
1509 self.getFromServer()
1508 1510
1509 1511 class JRODataWriter(JRODataIO):
1510 1512
Show file before | Show file after | Hide comments
@@ -11,6 +11,8 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
11 11 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
12 12 from schainpy.model.data.jrodata import Voltage
13 13 import zmq
14 import tempfile
15 from StringIO import StringIO
14 16 # from _sha import blocksize
15 17
16 18 class VoltageReader(JRODataReader, ProcessingUnit):
@@ -216,17 +218,17 class VoltageReader(JRODataReader, ProcessingUnit):
216 218 """
217 219
218 220 print 'READ BLOCK'
219 if self.server is not None:
220 self.zBlock = self.receiver.recv()
221 self.zHeader = self.zBlock[:24]
222 self.zDataBlock = self.zBlock[24:]
223 junk = numpy.fromstring(self.zDataBlock, numpy.dtype([('real','<i4'),('imag','<i4')]))
224 self.processingHeaderObj.profilesPerBlock = 240
225 self.processingHeaderObj.nHeights = 248
226 self.systemHeaderObj.nChannels
227 else:
228 current_pointer_location = self.fp.tell()
229 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
221 # if self.server is not None:
222 # self.zBlock = self.receiver.recv()
223 # self.zHeader = self.zBlock[:24]
224 # self.zDataBlock = self.zBlock[24:]
225 # junk = numpy.fromstring(self.zDataBlock, numpy.dtype([('real','<i4'),('imag','<i4')]))
226 # self.processingHeaderObj.profilesPerBlock = 240
227 # self.processingHeaderObj.nHeights = 248
228 # self.systemHeaderObj.nChannels
229 # else:
230 current_pointer_location = self.fp.tell()
231 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
230 232
231 233 try:
232 234 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
@@ -315,6 +317,97 class VoltageReader(JRODataReader, ProcessingUnit):
315 317
316 318 return
317 319
320 def readFirstHeaderFromServer(self):
321
322 self.getFirstHeader()
323
324 self.firstHeaderSize = self.basicHeaderObj.size
325
326 datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
327 if datatype == 0:
328 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
329 elif datatype == 1:
330 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
331 elif datatype == 2:
332 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
333 elif datatype == 3:
334 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
335 elif datatype == 4:
336 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
337 elif datatype == 5:
338 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
339 else:
340 raise ValueError, 'Data type was not defined'
341
342 self.dtype = datatype_str
343 #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
344 self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
345 # self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
346 # self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
347 self.getBlockDimension()
348
349
350 def getFromServer(self):
351 self.flagDiscontinuousBlock = 0
352 self.profileIndex = 0
353 self.flagIsNewBlock = 1
354 self.dataOut.flagNoData = False
355 self.nTotalBlocks += 1
356 self.nReadBlocks += 1
357 self.blockPointer = 0
358
359 block = self.receiver.recv()
360
361 self.basicHeaderObj.read(block[self.blockPointer:])
362 self.blockPointer += self.basicHeaderObj.length
363 self.systemHeaderObj.read(block[self.blockPointer:])
364 self.blockPointer += self.systemHeaderObj.length
365 self.radarControllerHeaderObj.read(block[self.blockPointer:])
366 self.blockPointer += self.radarControllerHeaderObj.length
367 self.processingHeaderObj.read(block[self.blockPointer:])
368 self.blockPointer += self.processingHeaderObj.length
369 self.readFirstHeaderFromServer()
370
371 timestamp = self.basicHeaderObj.get_datatime()
372 print '[Reading] - Block {} - {}'.format(self.nTotalBlocks, timestamp)
373 current_pointer_location = self.blockPointer
374 junk = numpy.fromstring( block[self.blockPointer:], self.dtype, self.blocksize )
375
376 try:
377 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
378 except:
379 #print "The read block (%3d) has not enough data" %self.nReadBlocks
380 if self.waitDataBlock(pointer_location=current_pointer_location):
381 junk = numpy.fromstring( block[self.blockPointer:], self.dtype, self.blocksize )
382 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
383 # return 0
384
385 #Dimensions : nChannels, nProfiles, nSamples
386
387 junk = numpy.transpose(junk, (2,0,1))
388 self.datablock = junk['real'] + junk['imag'] * 1j
389 self.profileIndex = 0
390 if self.selBlocksize == None: self.selBlocksize = self.dataOut.nProfiles
391 if self.selBlocktime != None:
392 if self.dataOut.nCohInt is not None:
393 nCohInt = self.dataOut.nCohInt
394 else:
395 nCohInt = 1
396 self.selBlocksize = int(self.dataOut.nProfiles*round(self.selBlocktime/(nCohInt*self.dataOut.ippSeconds*self.dataOut.nProfiles)))
397 self.dataOut.data = self.datablock[:,self.profileIndex:self.profileIndex+self.selBlocksize,:]
398 datasize = self.dataOut.data.shape[1]
399 if datasize < self.selBlocksize:
400 buffer = numpy.zeros((self.dataOut.data.shape[0], self.selBlocksize, self.dataOut.data.shape[2]), dtype = 'complex')
401 buffer[:,:datasize,:] = self.dataOut.data
402 self.dataOut.data = buffer
403 self.profileIndex = blockIndex
404
405 self.dataOut.flagDataAsBlock = True
406 self.flagIsNewBlock = 1
407 self.dataOut.realtime = self.online
408
409 return self.dataOut.data
410
318 411 def getData(self):
319 412 """
320 413 getData obtiene una unidad de datos del buffer de lectura, un perfil, y la copia al objeto self.dataOut
@@ -351,24 +444,19 class VoltageReader(JRODataReader, ProcessingUnit):
351 444 self.flagDiscontinuousBlock
352 445 self.flagIsNewBlock
353 446 """
354 print 1
355 447 if self.flagNoMoreFiles:
356 448 self.dataOut.flagNoData = True
357 449 print 'Process finished'
358 450 return 0
359 print 2
360 451 self.flagDiscontinuousBlock = 0
361 452 self.flagIsNewBlock = 0
362 print 3
363 453 if self.__hasNotDataInBuffer():
364
365 454 if not( self.readNextBlock() ):
366 455 return 0
367 456
368 457 self.getFirstHeader()
369 458
370 459 self.reshapeData()
371 print 4
372 460 if self.datablock is None:
373 461 self.dataOut.flagNoData = True
374 462 return 0
Show file before | Show file after | Hide comments
@@ -513,10 +513,10 class CohInt(Operation):
513 513 self.__dataReady = True
514 514 return avgdata, avgdatatime
515 515
516 def run(self, dataOut, **kwargs):
517
516
517 def run(self, dataOut, n=None, timeInterval=None, overlapping=False, byblock=False, **kwargs):
518 518 if not self.isConfig:
519 self.setup(**kwargs)
519 self.setup(n=n, timeInterval=timeInterval, overlapping=overlapping, byblock=byblock, **kwargs)
520 520 self.isConfig = True
521 521
522 522 if dataOut.flagDataAsBlock:
Show file before | Show file after | Hide comments
@@ -1,1 +1,1
1 <Project description="test" id="191" name="john"><ReadUnit datatype="VoltageReader" id="1911" inputId="0" name="VoltageReader"><Operation id="19111" name="run" priority="1" type="self"><Parameter format="str" id="191111" name="server" value="john" /></Operation></ReadUnit><ProcUnit datatype="SpectraProc" id="1912" inputId="1911" name="SpectraProc"><Operation id="19121" name="run" priority="1" type="self"><Parameter format="int" id="191211" name="nFFTPoints" value="64" /></Operation><Operation id="19122" name="SpectraPlot" priority="2" type="other"><Parameter format="int" id="191221" name="id" value="500" /><Parameter format="str" id="191222" name="wintitle" value="Jicamarca Radio Observatory" /><Parameter format="int" id="191223" name="showprofile" value="0" /></Operation></ProcUnit></Project> No newline at end of file
1 <Project description="test" id="191" name="john"><ReadUnit datatype="VoltageReader" id="1911" inputId="0" name="VoltageReader"><Operation id="19111" name="run" priority="1" type="self"><Parameter format="str" id="191111" name="server" value="tcp://10.10.10.121:5555" /></Operation></ReadUnit><ProcUnit datatype="VoltageProc" id="1912" inputId="1911" name="VoltageProc"><Operation id="19121" name="run" priority="1" type="self" /></ProcUnit></Project> No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now