diff --git a/schainpy/IO/Data.py b/schainpy/IO/Data.py
index bc2ffab..3e3d522 100644
--- a/schainpy/IO/Data.py
+++ b/schainpy/IO/Data.py
@@ -7,13 +7,13 @@ Created on 23/01/2012
 
 
 class DataReader:
-    __buffer = 0
-    __buffer_count = 0
+       
     def __init__(self):
-        pass
+        __buffer = 0
+        __buffer_count = 0
     
 class DataWriter:
-    __buffer = 0
-    __buffer_count = 0
+    
     def __init__(self):
-        pass
\ No newline at end of file
+        __buffer = 0
+        __buffer_count = 0
\ No newline at end of file
diff --git a/schainpy/IO/Header.py b/schainpy/IO/Header.py
index 23a23a6..664f9f8 100644
--- a/schainpy/IO/Header.py
+++ b/schainpy/IO/Header.py
@@ -46,26 +46,25 @@ class PROCFLAG:
 
 class BasicHeader:
     
-    size = 0
-    version = 0
-    dataBlock = 0
-    utc = 0
-    miliSecond = 0
-    timeZone = 0
-    dstFlag = 0
-    errorCount = 0
-    struct = numpy.dtype([
-                          ('nSize','<u4'),
-                          ('nVersion','<u2'),
-                          ('nDataBlockId','<u4'),
-                          ('nUtime','<u4'),
-                          ('nMilsec','<u2'),     
-                          ('nTimezone','<i2'),
-                          ('nDstflag','<i2'),
-                          ('nErrorCount','<u4')
-                          ])   
-        
     def __init__(self):
+        self.size = 0
+        self.version = 0
+        self.dataBlock = 0
+        self.utc = 0
+        self.miliSecond = 0
+        self.timeZone = 0
+        self.dstFlag = 0
+        self.errorCount = 0
+        self.struct = numpy.dtype([
+                              ('nSize','<u4'),
+                              ('nVersion','<u2'),
+                              ('nDataBlockId','<u4'),
+                              ('nUtime','<u4'),
+                              ('nMilsec','<u2'),     
+                              ('nTimezone','<i2'),
+                              ('nDstflag','<i2'),
+                              ('nErrorCount','<u4')
+                              ])   
         pass
     
     def read(self, fp):
@@ -97,23 +96,23 @@ class BasicHeader:
         return obj
 
 class SystemHeader:
-    size = 0 
-    numSamples = 0
-    numProfiles = 0
-    numChannels = 0
-    adcResolution = 0
-    pciDioBusWidth = 0
-    struct = numpy.dtype([
-                        ('nSize','<u4'),
-                        ('nNumSamples','<u4'),
-                        ('nNumProfiles','<u4'),
-                        ('nNumChannels','<u4'),
-                        ('nADCResolution','<u4'),
-                        ('nPCDIOBusWidth','<u4'),
-                        ])
     
     def __init__(self):
-        pass
+        self.size = 0 
+        self.numSamples = 0
+        self.numProfiles = 0
+        self.numChannels = 0
+        self.adcResolution = 0
+        self.pciDioBusWidth = 0
+        self.struct = numpy.dtype([
+                            ('nSize','<u4'),
+                            ('nNumSamples','<u4'),
+                            ('nNumProfiles','<u4'),
+                            ('nNumChannels','<u4'),
+                            ('nADCResolution','<u4'),
+                            ('nPCDIOBusWidth','<u4'),
+                            ])
+    
 
     def read(self, fp):
         header = numpy.fromfile(fp,self.struct,1)
@@ -141,46 +140,46 @@ class SystemHeader:
         return obj
     
 class RadarControllerHeader:
-    size = 0
-    expType = 0
-    nTx = 0
-    ipp = 0
-    txA = 0
-    txB = 0
-    numWindows = 0
-    numTaus = 0
-    codeType = 0
-    line6Function = 0
-    line5Fuction = 0
-    fClock = 0
-    prePulseBefore = 0
-    prePulserAfter = 0
-    rangeIpp = 0
-    rangeTxA = 0
-    rangeTxB = 0
-    struct = numpy.dtype([
-                         ('nSize','<u4'),
-                         ('nExpType','<u4'),
-                         ('nNTx','<u4'),
-                         ('fIpp','<f4'),
-                         ('fTxA','<f4'),
-                         ('fTxB','<f4'),
-                         ('nNumWindows','<u4'),
-                         ('nNumTaus','<u4'),
-                         ('nCodeType','<u4'),
-                         ('nLine6Function','<u4'),
-                         ('nLine5Function','<u4'),
-                         ('fClock','<f4'),
-                         ('nPrePulseBefore','<u4'),
-                         ('nPrePulseAfter','<u4'),
-                         ('sRangeIPP','<a20'),
-                         ('sRangeTxA','<a20'),
-                         ('sRangeTxB','<a20'),
-                         ])
     
     
     def __init__(self):
-        pass
+        self.size = 0
+        self.expType = 0
+        self.nTx = 0
+        self.ipp = 0
+        self.txA = 0
+        self.txB = 0
+        self.numWindows = 0
+        self.numTaus = 0
+        self.codeType = 0
+        self.line6Function = 0
+        self.line5Fuction = 0
+        self.fClock = 0
+        self.prePulseBefore = 0
+        self.prePulserAfter = 0
+        self.rangeIpp = 0
+        self.rangeTxA = 0
+        self.rangeTxB = 0
+        self.struct = numpy.dtype([
+                             ('nSize','<u4'),
+                             ('nExpType','<u4'),
+                             ('nNTx','<u4'),
+                             ('fIpp','<f4'),
+                             ('fTxA','<f4'),
+                             ('fTxB','<f4'),
+                             ('nNumWindows','<u4'),
+                             ('nNumTaus','<u4'),
+                             ('nCodeType','<u4'),
+                             ('nLine6Function','<u4'),
+                             ('nLine5Function','<u4'),
+                             ('fClock','<f4'),
+                             ('nPrePulseBefore','<u4'),
+                             ('nPrePulseAfter','<u4'),
+                             ('sRangeIPP','<a20'),
+                             ('sRangeTxA','<a20'),
+                             ('sRangeTxB','<a20'),
+                             ])
+        
 
     def read(self, fp):
         header = numpy.fromfile(fp,self.struct,1)
@@ -231,41 +230,40 @@ class RadarControllerHeader:
         return obj
     
 class ProcessingHeader:
-    size = 0
-    dataType = 0
-    blockSize = 0
-    profilesPerBlock = 0
-    dataBlocksPerFile = 0
-    numWindows = 0
-    processFlags = 0
-    coherentInt = 0
-    incoherentInt = 0
-    totalSpectra = 0
-    struct = numpy.dtype([
-                           ('nSize','<u4'),
-                           ('nDataType','<u4'),
-                           ('nSizeOfDataBlock','<u4'),
-                           ('nProfilesperBlock','<u4'),
-                           ('nDataBlocksperFile','<u4'),
-                           ('nNumWindows','<u4'),
-                           ('nProcessFlags','<u4'),
-                           ('nCoherentIntegrations','<u4'),
-                           ('nIncoherentIntegrations','<u4'),
-                           ('nTotalSpectra','<u4')
-                           ])
-    samplingWindow = 0
-    structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
-    numHeights = 0
-    firstHeight = 0
-    deltaHeight = 0
-    samplesWin = 0
-    spectraComb = 0
-    numCode = 0
-    codes = 0
-    numBaud = 0
     
     def __init__(self):
-        pass
+        self.size = 0
+        self.dataType = 0
+        self.blockSize = 0
+        self.profilesPerBlock = 0
+        self.dataBlocksPerFile = 0
+        self.numWindows = 0
+        self.processFlags = 0
+        self.coherentInt = 0
+        self.incoherentInt = 0
+        self.totalSpectra = 0
+        self.struct = numpy.dtype([
+                               ('nSize','<u4'),
+                               ('nDataType','<u4'),
+                               ('nSizeOfDataBlock','<u4'),
+                               ('nProfilesperBlock','<u4'),
+                               ('nDataBlocksperFile','<u4'),
+                               ('nNumWindows','<u4'),
+                               ('nProcessFlags','<u4'),
+                               ('nCoherentIntegrations','<u4'),
+                               ('nIncoherentIntegrations','<u4'),
+                               ('nTotalSpectra','<u4')
+                               ])
+        self.samplingWindow = 0
+        self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
+        self.numHeights = 0
+        self.firstHeight = 0
+        self.deltaHeight = 0
+        self.samplesWin = 0
+        self.spectraComb = 0
+        self.numCode = 0
+        self.codes = 0
+        self.numBaud = 0
     
     def read(self, fp):
         header = numpy.fromfile(fp,self.struct,1)
diff --git a/schainpy/IO/Voltage.py b/schainpy/IO/Voltage.py
index 0126bac..bf5b891 100644
--- a/schainpy/IO/Voltage.py
+++ b/schainpy/IO/Voltage.py
@@ -23,68 +23,66 @@ from Model.Voltage import Voltage
 
 class VoltageReader(DataReader):
     
-    __idFile = None
-    
-    __fp = None
-    
-    __startDateTime = None
-    
-    __endDateTime = None
-    
-    __dataType = None
-    
-    __fileSizeByHeader = 0
-    
-    __pathList = []
-    
-    filenameList = []
-    
-    __lastUTTime = 0
-    
-    __maxTimeStep = 5 
-    
-    __flagIsNewFile = 0
-    
-    __ippSeconds = 0
-    
-    flagResetProcessing = 0    
-    
-    flagIsNewBlock = 0
-    
-    noMoreFiles = 0
-    
-    nReadBlocks = 0
-    
-    online = 0
-    
-    filename = None
-    
-    fileSize = None
-    
-    firstHeaderSize = 0
-    
-    basicHeaderSize = 24
-    
-    m_BasicHeader = BasicHeader()
-    
-    m_SystemHeader = SystemHeader()
-    
-    m_RadarControllerHeader = RadarControllerHeader()
-    
-    m_ProcessingHeader = ProcessingHeader()
-    
-    m_Voltage = None
-    
-    __buffer = 0
-    
-    __buffer_id = 9999
-     
     def __init__(self, m_Voltage = None):
         
         if m_Voltage == None:
             m_Voltage = Voltage()
             
         self.m_Voltage = m_Voltage
+        
+        self.__idFile = None
+    
+        self.__fp = None
+        
+        self.__startDateTime = None
+        
+        self.__endDateTime = None
+        
+        self.__dataType = None
+        
+        self.__fileSizeByHeader = 0
+        
+        self.__pathList = []
+        
+        self.filenameList = []
+        
+        self.__lastUTTime = 0
+        
+        self.__maxTimeStep = 5 
+        
+        self.__flagIsNewFile = 0
+        
+        self.__ippSeconds = 0
+        
+        self.flagResetProcessing = 0    
+        
+        self.flagIsNewBlock = 0
+        
+        self.noMoreFiles = 0
+        
+        self.nReadBlocks = 0
+        
+        self.online = 0
+        
+        self.filename = None
+        
+        self.fileSize = None
+        
+        self.firstHeaderSize = 0
+        
+        self.basicHeaderSize = 24
+        
+        self.m_BasicHeader = BasicHeader()
+        
+        self.m_SystemHeader = SystemHeader()
+        
+        self.m_RadarControllerHeader = RadarControllerHeader()
+        
+        self.m_ProcessingHeader = ProcessingHeader()
+        
+        self.__buffer = 0
+        
+        self.__buffer_id = 9999
     
     def __rdSystemHeader(self,fp=None):
         if fp == None:
@@ -393,6 +391,7 @@ class VoltageReader(DataReader):
         self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
         self.m_Voltage.m_BasicHeader.utc = time
         self.m_Voltage.data = data
+        self.m_Voltage.dataType = self.__dataType
         
         self.__buffer_id += 1
         
@@ -438,23 +437,190 @@ class VoltageReader(DataReader):
         self.online = online
 
 class VoltageWriter(DataWriter):
-    
-    m_BasicHeader= BasicHeader()
-
-
-    m_SystemHeader = SystemHeader()
-
-
-    m_RadarControllerHeader = RadarControllerHeader()
-
-
-    m_ProcessingHeader = ProcessingHeader()
 
-    m_Voltage = None
     
-    def __init__(self, m_Voltage):
+    def __init__(self, m_Voltage = None):
+        
+        if m_Voltage == None:
+            m_Voltage = Voltage()    
         
         self.m_Voltage = m_Voltage
+        
+        self.__fp = None
+    
+        self.__blocksCounter = 0
+        
+        self.__setFile = None
+        
+        self.__flagIsNewFile = 0
+        
+        self.__buffer = 0
+        
+        self.__buffer_id = 0
+        
+        self.__dataType = None
+        
+        self.__ext = None
+        
+        self.nWriteBlocks = 0 
+        
+        self.flagIsNewBlock = 0
+        
+        self.noMoreFiles = 0
+        
+        self.filename = None
+        
+        self.m_BasicHeader= BasicHeader()
+    
+        self.m_SystemHeader = SystemHeader()
+    
+        self.m_RadarControllerHeader = RadarControllerHeader()
+    
+        self.m_ProcessingHeader = ProcessingHeader()
+    
+    def __setNextFile(self):
+        setFile = self.__setFile
+        ext = self.__ext
+        path = self.__path
+        
+        setFile += 1
+         
+        if not(self.__blocksCounter >= self.m_ProcessingHeader.dataBlocksPerFile):
+            self.__fp.close()
+            return 0
+        
+        timeTuple = time.localtime(self.m_Voltage.m_BasicHeader.utc) # utc from m_Voltage
+        file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_doy,setFile,ext)
+        subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_doy) 
+        tmp = os.path.join(path,subfolder)
+        if not(os.path.exists(tmp)):
+            os.mkdir(tmp)
+   
+        filename = os.path.join(path,subfolder,file)
+        fp = open(filename,'wb')
+        
+        
+        
+        #guardando atributos 
+        self.filename = filename
+        self.__subfolder = subfolder
+        self.__fp = fp
+        self.__setFile = setFile
+        self.__flagIsNewFile = 1
+        
+        print 'Writing the file: %s'%self.filename
+        
+        return 1
+            
 
+    
+    def __setNewBlock(self):
+        if self.__fp == None:
+            return 0
+        
+        if self.__flagIsNewFile:
+            return 1
+        
+        #Bloques completados?
+        if self.__blocksCounter < self.m_ProcessingHeader.profilesPerBlock:
+            self.__writeBasicHeader()
+            return 1
+        
+        if not(self.__setNextFile()):
+            return 0
+        
+        self.__writeFirstHeader()
+        
+        return 1
+    
+    def __writeBlock(self):
+        
+        numpy.save(self.__fp,self.__buffer)
+        
+        self.__buffer = numpy.array([],self.__dataType)
+        
+        self.__buffer_id = 0 
+        
+        self.__flagIsNewFile = 0
+        
+        self.flagIsNewBlock = 1
+        
+        self.nWriteBlocks += 1
+        
+        self.__blocksCounter += 1
+    
+    def writeNextBlock(self):
+        if not(self.__setNewBlock()):
+            return 0
+        
+        self.__writeBlock()
+        
+        return 1
+    
+    def __hasAllDataInBuffer(self):
+        if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
+            return 1
+        
+        return 0
+    
+    def putData(self):
+        self.flagIsNewBlock = 0
+        
+        if self.m_Voltage.noData:
+            return None
+        
+        shape = self.m_Voltage.data.shape
+        data = numpy.zeros(shape,self.__dataType)
+        data['real'] = self.m_Voltage.data.real
+        data['imag'] = self.m_Voltage.data.imag
+        data = data.reshape((-1))
+        
+        self.__buffer = numpy.hstack((self.__buffer,data))
+        
+        self.__buffer_id += 1
+        
+        if __hasAllDataInBuffer():
+            self.writeNextBlock()
+        
+        
+        if self.noMoreFiles:
+            print 'Process finished'
+            return None
+        
+        return 1
+    
 
-    
\ No newline at end of file
+    def setup(self,path,set=None,format=None):
+        
+        if set == None:
+            set = -1
+        else:
+            set -= 1
+        
+        if format == 'hdf5':
+            ext = '.hdf5'
+            print 'call hdf5 library'
+            return 0
+        
+        if format == 'rawdata':
+            ext = '.r'
+        
+        #call to config_headers
+        
+        self.__setFile = set
+        
+        if not(self.__setNextFile()):
+            print "zzzzzzzzzzzz"
+            return 0
+        
+        self.__writeFirstHeader() # dentro de esta funcion se debe setear e __dataType
+        
+        self.__buffer = numpy.array([],self.__dataType)
+        
+    
+    
+    def __writeBasicHeader(self):
+        pass
+    
+    def __writeFirstHeader(self):
+        pass
\ No newline at end of file
diff --git a/schainpy/Model/Voltage.py b/schainpy/Model/Voltage.py
index 06cad9a..768e356 100644
--- a/schainpy/Model/Voltage.py
+++ b/schainpy/Model/Voltage.py
@@ -18,25 +18,30 @@ class Voltage(Data):
     '''
 
 
-    m_RadarControllerHeader= RadarControllerHeader()
-
-    m_ProcessingHeader= ProcessingHeader()
-
-    m_SystemHeader= SystemHeader()
-
-    m_BasicHeader= BasicHeader()
-    
-    #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
-    data = None
     
-    noData = True
 
 
     def __init__(self):
         '''
         Constructor
         '''
-        pass
+        
+        self.m_RadarControllerHeader= RadarControllerHeader()
+
+        self.m_ProcessingHeader= ProcessingHeader()
+        
+        self.m_SystemHeader= SystemHeader()
+        
+        self.m_BasicHeader= BasicHeader()
+        
+        #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
+        self.data = None
+        
+        self.dataType = None
+        
+        self.noData = True
+        
+        
 
     def copy(self):
         obj = Voltage()