##// END OF EJS Templates
schain-jc
RSS
En esta version se corrigieron los bugs de lectura, la lectura se ha implementado para modo offline, el script TestReader.py es un ejemplo que muestra como debe hacerse la lectura de rawdata usando estas librerias.
Daniel Valdez -
r8:cd80c0608691
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,3 +1,5
1 import numpy
2
1 3 class PROCFLAG:
2 4 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
3 5 DECODE_DATA = numpy.uint32(0x00000002)
Show file before | Show file after | Hide comments
@@ -16,8 +16,6 from Data import DataReader
16 16 from Data import DataWriter
17 17
18 18 class VoltageReader(DataReader):
19 # Este flag indica que la data leida no es continua
20 __jumpDataFlag = False
21 19
22 20 __idFile = 0
23 21
@@ -39,7 +37,7 class VoltageReader(DataReader):
39 37
40 38 __maxTimeStep = 5
41 39
42 __flagResetProcessing = 0
40 flagResetProcessing = 0
43 41
44 42 __flagIsNewFile = 0
45 43
@@ -55,18 +53,18 class VoltageReader(DataReader):
55 53
56 54 basicHeaderSize = 24
57 55
58 objBasicHeader = BasicHeader()
56 basicHeaderObj = BasicHeader()
59 57
60 objSystemHeader = SystemHeader()
58 systemHeaderObj = SystemHeader()
61 59
62 objRadarControllerHeader = RadarControllerHeader()
60 radarControllerHeaderObj = RadarControllerHeader()
63 61
64 objProcessingHeader = ProcessingHeader()
62 processingHeaderObj = ProcessingHeader()
65 63
66 64 __buffer = 0
67 65
68 66 __buffer_id = 9999
69 m_Voltage= Voltage()
67 #m_Voltage= Voltage()
70 68
71 69
72 70 def __init__(self):
@@ -76,19 +74,19 class VoltageReader(DataReader):
76 74 if fp == None:
77 75 fp = self.__fp
78 76
79 self.objSystemHeader.read(fp)
77 self.systemHeaderObj.read(fp)
80 78
81 79 def __rdRadarControllerHeader(self,fp=None):
82 80 if fp == None:
83 81 fp = self.__fp
84 82
85 self.objRadarControllerHeader.read(fp)
83 self.radarControllerHeaderObj.read(fp)
86 84
87 85 def __rdProcessingHeader(self,fp=None):
88 86 if fp == None:
89 87 fp = self.__fp
90 88
91 self.objProcessingHeader.read(fp)
89 self.processingHeaderObj.read(fp)
92 90
93 91 def __searchFiles(self,path, startDateTime, endDateTime, set=None, expLabel = "", ext = "*.r"):
94 92
@@ -168,14 +166,14 class VoltageReader(DataReader):
168 166 if endUTSeconds==None:
169 167 endUTSeconds = self.endUTCSeconds
170 168
171 objBasicHeader = BasicHeader()
169 basicHeaderObj = BasicHeader()
172 170
173 if not(objBasicHeader.read(fp)):
171 if not(basicHeaderObj.read(fp)):
174 172 return 0
175 173
176 174 fp.close()
177 175
178 if not ((startUTSeconds <= objBasicHeader.utc) and (endUTSeconds >= objBasicHeader.utc)):
176 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds >= basicHeaderObj.utc)):
179 177 return 0
180 178
181 179 return 1
@@ -185,7 +183,7 class VoltageReader(DataReader):
185 183 if fp == None:
186 184 fp = self.__fp
187 185
188 self.objBasicHeader.read(fp)
186 self.basicHeaderObj.read(fp)
189 187
190 188 def __readFirstHeader(self):
191 189
@@ -193,9 +191,9 class VoltageReader(DataReader):
193 191 self.__rdSystemHeader()
194 192 self.__rdRadarControllerHeader()
195 193 self.__rdProcessingHeader()
196 self.firstHeaderSize = self.objBasicHeader.size
194 self.firstHeaderSize = self.basicHeaderObj.size
197 195
198 data_type=int(numpy.log2((self.objProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
196 data_type=int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
199 197 if data_type == 0:
200 198 tmp=numpy.dtype([('real','<i1'),('imag','<i1')])
201 199 elif data_type == 1:
@@ -212,9 +210,8 class VoltageReader(DataReader):
212 210 print 'no define data type'
213 211 tmp = 0
214 212
215 self.__flagIsNewFile = 0
216 213 self.__dataType = tmp
217 self.__sizeOfFileByHeader = self.objProcessingHeader.dataBlocksPerFile * self.objProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.objProcessingHeader.dataBlocksPerFile - 1)
214 self.__sizeOfFileByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
218 215
219 216 def __setNextFileOnline(self):
220 217 return 0
@@ -235,7 +232,7 class VoltageReader(DataReader):
235 232 fp = open(filename,'rb')
236 233
237 234 currentSize = fileSize - fp.tell()
238 neededSize = self.objProcessingHeader.blockSize + self.firstHeaderSize
235 neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
239 236
240 237 if (currentSize < neededSize):
241 238 continue
@@ -261,20 +258,27 class VoltageReader(DataReader):
261 258
262 259 def __setNewBlock(self):
263 260
261 if self.__flagIsNewFile:
262 return 1
263
264 264 currentSize = self.fileSize - self.__fp.tell()
265 neededSize = self.objProcessingHeader.blockSize + self.basicHeaderSize
265 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
266 266
267 267 # Bloque Completo
268 268 if (currentSize >= neededSize):
269 269 self.__readBasicHeader()
270 270 return 1
271 271
272 self.__setNextFile()
272 if not(self.__setNextFile()):
273 return 0
274
273 275 self.__readFirstHeader()
274 276
275 deltaTime = self.objBasicHeader.utc - self.__lastUTTime # check this
277 deltaTime = self.basicHeaderObj.utc - self.__lastUTTime # check this
278
279 self.flagResetProcessing = 0
276 280 if deltaTime > self.__maxTimeStep:
277 self.__flagResetProcessing = 1
281 self.flagResetProcessing = 1
278 282
279 283 return 1
280 284
@@ -285,11 +289,13 class VoltageReader(DataReader):
285 289 seteado a 0
286 290 """
287 291
288 pts2read = self.objProcessingHeader.profilesPerBlock*self.objProcessingHeader.numHeights*self.objSystemHeader.numChannels
292 pts2read = self.processingHeaderObj.profilesPerBlock*self.processingHeaderObj.numHeights*self.systemHeaderObj.numChannels
289 293
290 294 data = numpy.fromfile(self.__fp,self.__dataType,pts2read)
291 295
292 data = data.reshape((self.objProcessingHeader.profilesPerBlock, self.objProcessingHeader.numHeights, self.objSystemHeader.numChannels))
296 data = data.reshape((self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.numHeights, self.systemHeaderObj.numChannels))
297
298 self.__flagIsNewFile = 0
293 299
294 300 self.__buffer = data
295 301
@@ -297,14 +303,17 class VoltageReader(DataReader):
297 303
298 304 def readNextBlock(self):
299 305
300 self.__setNewBlock()
306 if not(self.__setNewBlock()):
307 return 0
301 308
302 309 self.__readBlock()
303 310
304 self.__lastUTTime = self.objBasicHeader.utc
311 self.__lastUTTime = self.basicHeaderObj.utc
312
313 return 1
305 314
306 315 def __hasNotDataInBuffer(self):
307 if self.__buffer_id >= self.objProcessingHeader.profilesPerBlock:
316 if self.__buffer_id >= self.processingHeaderObj.profilesPerBlock:
308 317 return 1
309 318
310 319 return 0
@@ -315,6 +324,7 class VoltageReader(DataReader):
315 324 lectura es necesario hacer una nueva lectura de los bloques de datos
316 325 "__readBlock"
317 326 """
327 self.flagResetProcessing = 0
318 328
319 329 if self.__hasNotDataInBuffer():
320 330 self.readNextBlock()
@@ -324,7 +334,7 class VoltageReader(DataReader):
324 334 return None
325 335
326 336 data = self.__buffer[self.__buffer_id,:,:]
327
337 #time = timeblock + n*ipp
328 338 #print self.__buffer_id
329 339
330 340 self.__buffer_id += 1
General Comments 0
You need to be logged in to leave comments. Login now