diff --git a/.gitignore b/.gitignore
index f287ae7..d63b165 100644
--- a/.gitignore
+++ b/.gitignore
@@ -101,4 +101,8 @@ ENV/
 .project
 .pydevproject
 
+# vscode
+
+.vscode
+
 schainpy/scripts/
\ No newline at end of file
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 500bc70..9b1c9b9 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,3 +1,4 @@
 {
-    "python.linting.pylintEnabled": true
+    "python.linting.pylintEnabled": true,
+    "git.ignoreLimitWarning": true
 }
\ No newline at end of file
diff --git a/schainpy/model/data/jroheaderIO.py b/schainpy/model/data/jroheaderIO.py
index 4e88ab1..a869f36 100644
--- a/schainpy/model/data/jroheaderIO.py
+++ b/schainpy/model/data/jroheaderIO.py
@@ -132,18 +132,17 @@ class BasicHeader(Header):
     
     def read(self, fp):
         
+        self.length = 0
         try:
             if hasattr(fp, 'read'):
-                print 'fromfile'
                 header = numpy.fromfile(fp, BASIC_STRUCTURE,1)
             else:
-                print 'fromstring'
                 header = numpy.fromstring(fp, BASIC_STRUCTURE,1)
         except Exception, e:
             print "BasicHeader: "
             print e
             return 0
-        
+
         self.size = int(header['nSize'][0])
         self.version = int(header['nVersion'][0])
         self.dataBlock = int(header['nDataBlockId'][0])
@@ -155,7 +154,8 @@ class BasicHeader(Header):
         
         if self.size < 24:
             return 0
-            
+
+        self.length = header.nbytes
         return 1
     
     def write(self, fp):
@@ -200,13 +200,20 @@ class SystemHeader(Header):
         self.pciDioBusWidth = pciDioBusWith
         
     def read(self, fp):
-        
-        startFp = fp.tell()
-        
+        self.length = 0
         try:
-            header = numpy.fromfile(fp,SYSTEM_STRUCTURE,1)
+            startFp = fp.tell()
         except Exception, e:
-            print "System Header: " + e
+            startFp = None
+            pass
+
+        try:
+            if hasattr(fp, 'read'):
+                header = numpy.fromfile(fp, SYSTEM_STRUCTURE,1)
+            else:
+                header = numpy.fromstring(fp, SYSTEM_STRUCTURE,1)
+        except Exception, e:
+            print "System Header: " + str(e)
             return 0
         
         self.size = header['nSize'][0]
@@ -216,16 +223,19 @@ class SystemHeader(Header):
         self.adcResolution = header['nADCResolution'][0]
         self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
         
-        endFp = self.size + startFp
         
-        if fp.tell() > endFp:
-            sys.stderr.write("Warning %s: Size value read from System Header is lower than it has to be\n" %fp.name)
-            return 0
+        if startFp is not None:
+            endFp = self.size + startFp
             
-        if fp.tell() < endFp:
-            sys.stderr.write("Warning %s: Size value read from System Header size is greater than it has to be\n" %fp.name)
-            return 0
+            if fp.tell() > endFp:
+                sys.stderr.write("Warning %s: Size value read from System Header is lower than it has to be\n" %fp.name)
+                return 0
+                
+            if fp.tell() < endFp:
+                sys.stderr.write("Warning %s: Size value read from System Header size is greater than it has to be\n" %fp.name)
+                return 0
         
+        self.length = header.nbytes
         return 1
     
     def write(self, fp):
@@ -302,13 +312,21 @@ class RadarControllerHeader(Header):
             self.fClock = 0.15/(deltaHeight*1e-6)   #0.15Km / (height * 1u)
 
     def read(self, fp):
-        
-       
-        startFp = fp.tell()
+        self.length = 0
         try:
-            header = numpy.fromfile(fp,RADAR_STRUCTURE,1)
+            startFp = fp.tell()
         except Exception, e:
-            print "RadarControllerHeader: " + e
+            startFp = None
+            pass
+
+        try:
+            if hasattr(fp, 'read'):
+                header = numpy.fromfile(fp, RADAR_STRUCTURE,1)
+            else:
+                header = numpy.fromstring(fp, RADAR_STRUCTURE,1)
+            self.length += header.nbytes
+        except Exception, e:
+            print "RadarControllerHeader: " + str(e)
             return 0
         
         size = int(header['nSize'][0])
@@ -329,23 +347,64 @@ class RadarControllerHeader(Header):
         self.rangeTxA = header['sRangeTxA'][0]
         self.rangeTxB = header['sRangeTxB'][0]
         
-        samplingWindow = numpy.fromfile(fp,SAMPLING_STRUCTURE,self.nWindows)
-        
+        try:
+            if hasattr(fp, 'read'):
+                samplingWindow = numpy.fromfile(fp, SAMPLING_STRUCTURE, self.nWindows)
+            else:
+                samplingWindow = numpy.fromstring(fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
+            self.length += samplingWindow.nbytes
+        except Exception, e:
+            print "RadarControllerHeader: " + str(e)
+            return 0
         self.nHeights = int(numpy.sum(samplingWindow['nsa']))
         self.firstHeight = samplingWindow['h0']
         self.deltaHeight = samplingWindow['dh']
         self.samplesWin = samplingWindow['nsa']
+    
+        
+
+        try:
+            if hasattr(fp, 'read'):
+                self.Taus = numpy.fromfile(fp, '<f4', self.numTaus)
+            else:
+                self.Taus = numpy.fromstring(fp[self.length:], '<f4', self.numTaus)
+            self.length += self.Taus.nbytes
+        except Exception, e:
+            print "RadarControllerHeader: " + str(e)
+            return 0
+        
         
-        self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
         
         self.code_size = 0
         if self.codeType != 0:
-            self.nCode = int(numpy.fromfile(fp,'<u4',1))
-            self.nBaud = int(numpy.fromfile(fp,'<u4',1))
             
+            try:
+                if hasattr(fp, 'read'):
+                    self.nCode = numpy.fromfile(fp, '<u4', 1)
+                    self.length += self.nCode.nbytes
+                    self.nBaud = numpy.fromfile(fp, '<u4', 1)
+                    self.length += self.nBaud.nbytes
+                else:
+                    self.nCode = numpy.fromstring(fp[self.length:], '<u4', 1)[0]
+                    self.length += self.nCode.nbytes
+                    self.nBaud = numpy.fromstring(fp[self.length:], '<u4', 1)[0]
+                    self.length += self.nBaud.nbytes
+            except Exception, e:
+                print "RadarControllerHeader: " + str(e)
+                return 0
             code = numpy.empty([self.nCode,self.nBaud],dtype='i1')
+           
             for ic in range(self.nCode):
-                temp = numpy.fromfile(fp,'u4',int(numpy.ceil(self.nBaud/32.)))
+                try:
+                    if hasattr(fp, 'read'):
+                        temp = numpy.fromfile(fp,'u4', int(numpy.ceil(self.nBaud/32.)))
+                    else:
+                        temp = numpy.fromstring(fp,'u4', int(numpy.ceil(self.nBaud/32.)))
+                    self.length += temp.nbytes
+                except Exception, e:
+                    print "RadarControllerHeader: " + str(e)
+                    return 0
+
                 for ib in range(self.nBaud-1,-1,-1):
                     code[ic,ib] = temp[ib/32]%2
                     temp[ib/32] = temp[ib/32]/2
@@ -358,22 +417,22 @@ class RadarControllerHeader(Header):
 #  
 #             if self.line6Function == RCfunction.FLIP:
 #                 self.flip2 = numpy.fromfile(fp,'<u4',1)
-        
-        endFp = size + startFp
-        
-        if fp.tell() != endFp:
-#             fp.seek(endFp)
-            print "%s: Radar Controller Header size is not consistent: from data [%d] != from header field [%d]" %(fp.name, fp.tell()-startFp, size)
-#             return 0
-
-        if fp.tell() > endFp:
-            sys.stderr.write("Warning %s: Size value read from Radar Controller header is lower than it has to be\n" %fp.name)
-#             return 0
-            
-        if fp.tell() < endFp:
-            sys.stderr.write("Warning %s: Size value read from Radar Controller header is greater than it has to be\n" %fp.name)
+        if startFp is not None:
+            endFp = size + startFp
             
+            if fp.tell() != endFp:
+    #             fp.seek(endFp)
+                print "%s: Radar Controller Header size is not consistent: from data [%d] != from header field [%d]" %(fp.name, fp.tell()-startFp, size)
+    #             return 0
+
+            if fp.tell() > endFp:
+                sys.stderr.write("Warning %s: Size value read from Radar Controller header is lower than it has to be\n" %fp.name)
+    #             return 0
+                
+            if fp.tell() < endFp:
+                sys.stderr.write("Warning %s: Size value read from Radar Controller header is greater than it has to be\n" %fp.name)
             
+        
         return 1
     
     def write(self, fp):
@@ -512,15 +571,23 @@ class ProcessingHeader(Header):
         self.flag_cspc = False
         self.flag_decode = False
         self.flag_deflip = False
-    
+        self.length = 0
     def read(self, fp):
-        
-        startFp = fp.tell()
+        self.length = 0
+        try:
+            startFp = fp.tell()
+        except Exception, e:
+            startFp = None
+            pass
         
         try:
-            header = numpy.fromfile(fp,PROCESSING_STRUCTURE,1)
+            if hasattr(fp, 'read'):
+                header = numpy.fromfile(fp, PROCESSING_STRUCTURE, 1)
+            else:
+                header = numpy.fromstring(fp, PROCESSING_STRUCTURE, 1)
+            self.length += header.nbytes
         except Exception, e:
-            print "ProcessingHeader: " + e
+            print "ProcessingHeader: " + str(e)
             return 0
         
         size = int(header['nSize'][0])
@@ -534,14 +601,31 @@ class ProcessingHeader(Header):
         self.nIncohInt = int(header['nIncoherentIntegrations'][0])
         self.totalSpectra = int(header['nTotalSpectra'][0])
         
-        samplingWindow = numpy.fromfile(fp,SAMPLING_STRUCTURE,self.nWindows)
+        try:
+            if hasattr(fp, 'read'):
+                samplingWindow = numpy.fromfile(fp, SAMPLING_STRUCTURE, self.nWindows)
+            else:
+                samplingWindow = numpy.fromstring(fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
+            self.length += samplingWindow.nbytes
+        except Exception, e:
+            print "ProcessingHeader: " + str(e)
+            return 0
         
         self.nHeights = int(numpy.sum(samplingWindow['nsa']))
         self.firstHeight = float(samplingWindow['h0'][0])
         self.deltaHeight = float(samplingWindow['dh'][0])
         self.samplesWin = samplingWindow['nsa'][0]
         
-        self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
+
+        try:
+            if hasattr(fp, 'read'):
+                self.spectraComb = numpy.fromfile(fp, 'u1', 2*self.totalSpectra)
+            else:
+                self.spectraComb = numpy.fromstring(fp[self.length:], 'u1', 2*self.totalSpectra)
+            self.length += self.spectraComb.nbytes
+        except Exception, e:
+            print "ProcessingHeader: " + str(e)
+            return 0
         
         if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
             self.nCode = int(numpy.fromfile(fp,'<u4',1))
@@ -587,14 +671,16 @@ class ProcessingHeader(Header):
         if nPairs > 0:
             self.flag_cspc = True
         
-        endFp = size + startFp
         
-        if fp.tell() > endFp:
-            sys.stderr.write("Warning: Processing header size is lower than it has to be")
-            return 0
-            
-        if fp.tell() < endFp:
-            sys.stderr.write("Warning: Processing header size is greater than it is considered")
+        
+        if startFp is not None:
+            endFp = size + startFp
+            if fp.tell() > endFp:
+                sys.stderr.write("Warning: Processing header size is lower than it has to be")
+                return 0
+                
+            if fp.tell() < endFp:
+                sys.stderr.write("Warning: Processing header size is greater than it is considered")
         
         return 1
     
diff --git a/schainpy/model/graphics/jroplot_voltage.py b/schainpy/model/graphics/jroplot_voltage.py
index a9f3993..927b819 100644
--- a/schainpy/model/graphics/jroplot_voltage.py
+++ b/schainpy/model/graphics/jroplot_voltage.py
@@ -13,8 +13,8 @@ class Scope(Figure):
     
     isConfig = None
     
-    def __init__(self):
-        
+    def __init__(self, **kwargs):
+        Figure.__init__(self, **kwargs)
         self.isConfig = False
         self.WIDTH = 300
         self.HEIGHT = 200
diff --git a/schainpy/model/io/jroIO_base.py b/schainpy/model/io/jroIO_base.py
index 47f0b08..1ebc6b2 100644
--- a/schainpy/model/io/jroIO_base.py
+++ b/schainpy/model/io/jroIO_base.py
@@ -994,9 +994,9 @@ class JRODataReader(JRODataIO):
         self.__isFirstTimeOnline = 0
 
     def __setNewBlock(self):
-        if self.server is None:
-            if self.fp == None:
-                return 0
+        #if self.server is None:
+        if self.fp == None:
+            return 0
 
 #         if self.online:
 #             self.__jumpToLastBlock()
@@ -1013,23 +1013,23 @@ class JRODataReader(JRODataIO):
             else:
                 return 1
         print 'xxxx'
-        if self.server is None:
-            currentSize = self.fileSize - self.fp.tell()
-            neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
-            if (currentSize >= neededSize):
-                self.basicHeaderObj.read(self.fp)
-                self.lastUTTime = self.basicHeaderObj.utc
-                return 1
-        else:
-            self.basicHeaderObj.read(self.zHeader)
+        #if self.server is None:
+        currentSize = self.fileSize - self.fp.tell()
+        neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
+        if (currentSize >= neededSize):
+            self.basicHeaderObj.read(self.fp)
             self.lastUTTime = self.basicHeaderObj.utc
             return 1
+        # else:
+        #     self.basicHeaderObj.read(self.zHeader)
+        #     self.lastUTTime = self.basicHeaderObj.utc
+        #     return 1
         if self.__waitNewBlock():
             self.lastUTTime = self.basicHeaderObj.utc
             return 1
-        if self.server is None:
-            if not(self.setNextFile()):
-                return 0
+        #if self.server is None:
+        if not(self.setNextFile()):
+            return 0
 
         deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
         self.lastUTTime = self.basicHeaderObj.utc
@@ -1290,7 +1290,7 @@ class JRODataReader(JRODataIO):
             self.server = address
             self.context = zmq.Context()
             self.receiver = self.context.socket(zmq.PULL)
-            self.receiver.bind(self.server)
+            self.receiver.connect(self.server)
             time.sleep(0.5)
             print '[Starting] ReceiverData from {}'.format(self.server)
         else: 
@@ -1503,8 +1503,10 @@ class JRODataReader(JRODataIO):
                         server=server,
                         verbose=verbose)
             self.isConfig = True
-        print 'hola'
-        self.getData()
+        if server is None:
+            self.getData()
+        else: 
+            self.getFromServer()
 
 class JRODataWriter(JRODataIO):
 
diff --git a/schainpy/model/io/jroIO_voltage.py b/schainpy/model/io/jroIO_voltage.py
index 8362cb7..9d1dec2 100644
--- a/schainpy/model/io/jroIO_voltage.py
+++ b/schainpy/model/io/jroIO_voltage.py
@@ -11,6 +11,8 @@ from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
 from schainpy.model.data.jrodata import Voltage
 import zmq
+import tempfile
+from StringIO import StringIO
 # from _sha import blocksize
 
 class VoltageReader(JRODataReader, ProcessingUnit):
@@ -216,17 +218,17 @@ class VoltageReader(JRODataReader, ProcessingUnit):
         """
         
         print 'READ BLOCK'
-        if self.server is not None:
-            self.zBlock = self.receiver.recv()
-            self.zHeader = self.zBlock[:24]
-            self.zDataBlock = self.zBlock[24:]
-            junk = numpy.fromstring(self.zDataBlock, numpy.dtype([('real','<i4'),('imag','<i4')]))
-            self.processingHeaderObj.profilesPerBlock = 240
-            self.processingHeaderObj.nHeights = 248
-            self.systemHeaderObj.nChannels
-        else:
-            current_pointer_location = self.fp.tell()
-            junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
+        # if self.server is not None:
+        #     self.zBlock = self.receiver.recv()
+        #     self.zHeader = self.zBlock[:24]
+        #     self.zDataBlock = self.zBlock[24:]
+        #     junk = numpy.fromstring(self.zDataBlock, numpy.dtype([('real','<i4'),('imag','<i4')]))
+        #     self.processingHeaderObj.profilesPerBlock = 240
+        #     self.processingHeaderObj.nHeights = 248
+        #     self.systemHeaderObj.nChannels
+        # else:
+        current_pointer_location = self.fp.tell()
+        junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
 
         try:
             junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
@@ -315,6 +317,97 @@ class VoltageReader(JRODataReader, ProcessingUnit):
 
         return
 
+    def readFirstHeaderFromServer(self):
+        
+        self.getFirstHeader()
+
+        self.firstHeaderSize = self.basicHeaderObj.size
+
+        datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
+        if datatype == 0:
+            datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
+        elif datatype == 1:
+            datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
+        elif datatype == 2:
+            datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
+        elif datatype == 3:
+            datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
+        elif datatype == 4:
+            datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
+        elif datatype == 5:
+            datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
+        else:
+            raise ValueError, 'Data type was not defined'
+
+        self.dtype = datatype_str
+        #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
+        self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
+#        self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
+#        self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
+        self.getBlockDimension()
+
+
+    def getFromServer(self):       
+        self.flagDiscontinuousBlock = 0
+        self.profileIndex = 0
+        self.flagIsNewBlock = 1
+        self.dataOut.flagNoData = False
+        self.nTotalBlocks += 1
+        self.nReadBlocks += 1
+        self.blockPointer = 0
+
+        block = self.receiver.recv()
+        
+        self.basicHeaderObj.read(block[self.blockPointer:])
+        self.blockPointer += self.basicHeaderObj.length
+        self.systemHeaderObj.read(block[self.blockPointer:])
+        self.blockPointer += self.systemHeaderObj.length
+        self.radarControllerHeaderObj.read(block[self.blockPointer:])
+        self.blockPointer += self.radarControllerHeaderObj.length
+        self.processingHeaderObj.read(block[self.blockPointer:])
+        self.blockPointer += self.processingHeaderObj.length
+        self.readFirstHeaderFromServer()
+        
+        timestamp = self.basicHeaderObj.get_datatime()
+        print '[Reading] - Block {} - {}'.format(self.nTotalBlocks, timestamp)
+        current_pointer_location = self.blockPointer
+        junk = numpy.fromstring( block[self.blockPointer:], self.dtype, self.blocksize )
+
+        try:
+            junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
+        except:
+            #print "The read block (%3d) has not enough data" %self.nReadBlocks
+            if self.waitDataBlock(pointer_location=current_pointer_location):
+                junk = numpy.fromstring( block[self.blockPointer:], self.dtype, self.blocksize )
+                junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
+#             return 0
+
+        #Dimensions : nChannels, nProfiles, nSamples
+
+        junk = numpy.transpose(junk, (2,0,1))
+        self.datablock = junk['real'] + junk['imag'] * 1j        
+        self.profileIndex = 0
+        if self.selBlocksize == None: self.selBlocksize = self.dataOut.nProfiles
+        if self.selBlocktime != None:
+            if self.dataOut.nCohInt is not None:
+                nCohInt = self.dataOut.nCohInt
+            else:
+                nCohInt = 1
+            self.selBlocksize = int(self.dataOut.nProfiles*round(self.selBlocktime/(nCohInt*self.dataOut.ippSeconds*self.dataOut.nProfiles)))
+        self.dataOut.data = self.datablock[:,self.profileIndex:self.profileIndex+self.selBlocksize,:]
+        datasize = self.dataOut.data.shape[1]
+        if datasize < self.selBlocksize:
+            buffer = numpy.zeros((self.dataOut.data.shape[0], self.selBlocksize, self.dataOut.data.shape[2]), dtype = 'complex')
+            buffer[:,:datasize,:] = self.dataOut.data
+            self.dataOut.data = buffer
+            self.profileIndex = blockIndex
+
+        self.dataOut.flagDataAsBlock = True
+        self.flagIsNewBlock = 1
+        self.dataOut.realtime = self.online
+
+        return self.dataOut.data
+
     def getData(self):
         """
         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):
             self.flagDiscontinuousBlock
             self.flagIsNewBlock
         """
-        print 1
         if self.flagNoMoreFiles:
             self.dataOut.flagNoData = True
             print 'Process finished'
             return 0
-        print 2
         self.flagDiscontinuousBlock = 0
         self.flagIsNewBlock = 0
-        print 3
         if self.__hasNotDataInBuffer():
-
             if not( self.readNextBlock() ):
                 return 0
 
             self.getFirstHeader()
 
             self.reshapeData()
-        print 4
         if self.datablock is None:
             self.dataOut.flagNoData = True
             return 0
diff --git a/schainpy/model/proc/jroproc_voltage.py b/schainpy/model/proc/jroproc_voltage.py
index 745195d..9f84851 100644
--- a/schainpy/model/proc/jroproc_voltage.py
+++ b/schainpy/model/proc/jroproc_voltage.py
@@ -513,10 +513,10 @@ class CohInt(Operation):
         self.__dataReady = True
         return avgdata, avgdatatime
 
-    def run(self, dataOut, **kwargs):
-
+    
+    def run(self, dataOut, n=None, timeInterval=None, overlapping=False, byblock=False, **kwargs):
         if not self.isConfig:
-            self.setup(**kwargs)
+            self.setup(n=n, timeInterval=timeInterval, overlapping=overlapping, byblock=byblock, **kwargs)
             self.isConfig = True
 
         if dataOut.flagDataAsBlock:
diff --git a/schainpy/scripts/schain.xml b/schainpy/scripts/schain.xml
index 23e42dd..f486119 100644
--- a/schainpy/scripts/schain.xml
+++ b/schainpy/scripts/schain.xml
@@ -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
+<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