def parse(self, data): totalbits = len(data) * 8 b = BitString(bytes=data) self.sizelen = b.read("uint:5") if self.sizelen > 0: self.xmin = b.read("uint:%d" % self.sizelen) self.xmax = b.read("uint:%d" % self.sizelen) self.ymin = b.read("uint:%d" % self.sizelen) self.ymax = b.read("uint:%d" % self.sizelen) taillen = (self.sizelen * 4 + 5) % 8 != 0 and 8 - (self.sizelen * 4 + 5) % 8 or 0 else: self.xmin = self.xmax = self.ymin = self.ymax = 0 taillen = 3 b.read("uint:%d" % taillen) self.framerate = b.read("uint:16") self.framecount = b.read("uintle:16") # print self.sizelen,self.xmin,self.xmax,self.ymin,self.ymax # print self.framerate,self.framecount while b.pos < totalbits: tagcl = b.read("uintle:16") tagcode = tagcl >> 6 taglen = tagcl & 0x3F if taglen == 0x3F: taglen = b.read("intle:32") tagdata = b.read("bytes:%d" % taglen) self.tags.append([tagcode, tagdata])
def parse(self,data): totalbits = len(data)*8 b = BitString(bytes=data) self.sizelen = b.read('uint:5') if self.sizelen>0: self.xmin = b.read('uint:%d'%self.sizelen) self.xmax = b.read('uint:%d'%self.sizelen) self.ymin = b.read('uint:%d'%self.sizelen) self.ymax = b.read('uint:%d'%self.sizelen) taillen = (self.sizelen*4+5)%8 != 0 and 8-(self.sizelen*4+5)%8 or 0 else: self.xmin=self.xmax=self.ymin=self.ymax=0 taillen = 3 b.read('uint:%d'%taillen) self.framerate = b.read('uint:16') self.framecount = b.read('uintle:16') #print self.sizelen,self.xmin,self.xmax,self.ymin,self.ymax #print self.framerate,self.framecount while b.pos<totalbits: tagcl = b.read('uintle:16') tagcode = (tagcl>>6) taglen = tagcl&0x3f if taglen == 0x3f: taglen = b.read('intle:32') tagdata = b.read('bytes:%d'%taglen) self.tags.append( [tagcode,tagdata] )
def extract_bufr_from_lrit_file(file_path, prefix, output_dir): """ read lrit file """ file_size = os.path.getsize(file_path) fp = open(file_path, "rb") bs = BitString(fp) cpt = 0 print("==== Looking for Bufrs in %s\n" % (file_path)) # look for BUFR in hex 0x42554652 f_val = bs.find('0x42554652', bytealigned=True) while f_val: begin = bs.pos print("** Found Bufr in pos %s\n" % (begin)) # read size bufr_value = bs.read(32).hex size = bs.read('uint:24') print("size in decimal = %s" % (size)) if size > file_size: print("Size read in bufr %d is bigger than the file size %d\n" % (size, file_size)) return #read all bits (end-begin)+1 bs.pos = begin read_bits = bs.read(size) dest_fp = open("%s/%s_bufr_%s.bufr" % (output_dir, prefix, cpt), "wb") dest_fp.write(read_bits.tobytes()) dest_fp.close() cpt += 1 #look for the next grib f_val = bs.find('0x42554652', start=bs.pos, bytealigned=True)
def extract_bufr_from_lrit_file(file_path, prefix, output_dir): """ read lrit file """ file_size = os.path.getsize(file_path) fp = open(file_path, "rb") bs = BitString(fp) cpt=0 print("==== Looking for Bufrs in %s\n" %(file_path)) # look for BUFR in hex 0x42554652 f_val = bs.find('0x42554652', bytealigned=True) while f_val: begin= bs.pos print("** Found Bufr in pos %s\n" % (begin) ) # read size bufr_value = bs.read(32).hex size = bs.read('uint:24') print("size in decimal = %s" %(size)) if size > file_size: print("Size read in bufr %d is bigger than the file size %d\n" %(size, file_size)) return #read all bits (end-begin)+1 bs.pos = begin read_bits = bs.read(size) dest_fp = open("%s/%s_bufr_%s.bufr" % (output_dir, prefix, cpt), "wb") dest_fp.write(read_bits.tobytes()) dest_fp.close() cpt +=1 #look for the next grib f_val = bs.find('0x42554652', start=bs.pos, bytealigned=True)
def __init__(self, filestr): try: self.data = filestr b = BitString(bytes=filestr[:8]) self.signature = b.read("bytes:3") # FWS/SWS self.version = b.read("uint:8") self.filelength = b.read("uintle:32") self.sizelen = self.xmin = self.xmax = self.ymin = self.ymax = 0 self.framerate = self.framecount = 0 self.tags = [] # print self.signature,self.version,self.filelength if self.signature == "CWS": data = zlib.decompress(filestr[8:]) self.parse(data) else: self.parse(filestr[8:]) self.parsed = True except Exception as what: print what self.parsed = False
def __init__(self,filestr): try: self.data = filestr b = BitString(bytes=filestr[:8]) self.signature = b.read('bytes:3') #FWS/SWS self.version = b.read('uint:8') self.filelength = b.read('uintle:32') self.sizelen = self.xmin = self.xmax = self.ymin = self.ymax = 0 self.framerate = self.framecount = 0 self.tags = [] #print self.signature,self.version,self.filelength if self.signature=='CWS': data = zlib.decompress(filestr[8:]) self.parse(data) else: self.parse(filestr[8:]) self.parsed = True except Exception as what: print what self.parsed = False
def make_test_data(codename, infile, outfile, n=1): '''Takes a "complete" binary source and returns a bitstring suitable for creating a much smaller, parsable binary suitable for testing. Currently supported metrics: 'quality' :param codename: (required) metrics codename (e.g. 'tile', 'quality') :param infile: (required) path to file to be used as source data. :param outfile: (optional) path to file to be written (default: ./QualityMetricsTest.bin) :param n: (optional) integer describing number of complete records to write. ''' record_length = {'quality': 153730} bs = BitString(bytes=open(infile, 'rb').read()) buf = bs.read(record_length[codename] * n) outbin = open(outfile, 'wb') buf.tofile(outbin) outbin.close() return outfile
def make_test_data(codename, infile, outfile, n=1): '''Takes a "complete" binary source and returns a bitstring suitable for creating a much smaller, parsable binary suitable for testing. Currently supported metrics: 'quality' :param codename: (required) metrics codename (e.g. 'tile', 'quality') :param infile: (required) path to file to be used as source data. :param outfile: (optional) path to file to be written (default: ./QualityMetricsTest.bin) :param n: (optional) integer describing number of complete records to write. ''' record_length = { 'quality': 153730 } bs = BitString(bytes=open(infile, 'rb').read()) buf = bs.read(record_length[codename] * n) outbin = open(outfile, 'wb') buf.tofile(outbin) outbin.close() return outfile
def parse_correctedintensitymetrics(path): fn = 'CorrectedIntMetricsOut.bin' fn = os.path.join(path, fn) dict = {} num_called = {} a = BitString(bytes=open(fn, 'rb').read()) file_version = a.read('uintle:8') record_byte_length = a.read('uintle:8') if not (2 <= file_version <= 4): sys.exit('extraction metrics file version %d not supported' % (file_version)) # 16 bits of header, 8 bits to a byte for i in range(0, ((a.len - 16) / (record_byte_length * 8))): tile_number = 0 lane_number = a.read('uintle:16') if (file_version <= 3): tile_number = a.read('uintle:16') else: tile_number = a.read('uintle:32') cycle_number = a.read('uintle:16') if (file_version == 2): avg_int = a.read('uintle:16') avg_corrected_int_A = a.read('uintle:16') avg_corrected_int_C = a.read('uintle:16') avg_corrected_int_G = a.read('uintle:16') avg_corrected_int_T = a.read('uintle:16') if (file_version <= 3): avg_corrected_int_called_A = a.read('uintle:16') avg_corrected_int_called_C = a.read('uintle:16') avg_corrected_int_called_G = a.read('uintle:16') avg_corrected_int_called_T = a.read('uintle:16') num_N = 0 num_A = 0 num_C = 0 num_G = 0 num_T = 0 if (file_version == 2): num_N = a.read('floatle:32') num_A = a.read('floatle:32') num_C = a.read('floatle:32') num_G = a.read('floatle:32') num_T = a.read('floatle:32') if (file_version >= 3): num_N = float(a.read('uintle:32')) num_A = float(a.read('uintle:32')) num_C = float(a.read('uintle:32')) num_G = float(a.read('uintle:32')) num_T = float(a.read('uintle:32')) if (file_version == 2): snr = a.read('floatle:32') if lane_number not in num_called: num_called[lane_number] = {} if cycle_number not in num_called[lane_number]: num_called[lane_number][cycle_number] = {} num_called[lane_number][cycle_number]['N'] = 0 num_called[lane_number][cycle_number]['A'] = 0 num_called[lane_number][cycle_number]['C'] = 0 num_called[lane_number][cycle_number]['G'] = 0 num_called[lane_number][cycle_number]['T'] = 0 num_called[lane_number][cycle_number]['N'] += num_N num_called[lane_number][cycle_number]['A'] += num_A num_called[lane_number][cycle_number]['C'] += num_C num_called[lane_number][cycle_number]['G'] += num_G num_called[lane_number][cycle_number]['T'] += num_T pct_called = {} for l in num_called: if l not in pct_called: pct_called[l] = {} for c in num_called[l]: if c not in pct_called[l]: pct_called[l][c] = {} total_calls = num_called[l][c]['N'] + num_called[l][c][ 'A'] + num_called[l][c]['C'] + num_called[l][c][ 'G'] + num_called[l][c]['T'] try: pct_called[l][c]['A'] = (num_called[l][c]['A'] / total_calls) * 100 pct_called[l][c]['C'] = (num_called[l][c]['C'] / total_calls) * 100 pct_called[l][c]['G'] = (num_called[l][c]['G'] / total_calls) * 100 pct_called[l][c]['T'] = (num_called[l][c]['T'] / total_calls) * 100 except ZeroDivisionError: pct_called[l][c]['A'] = 0.0 pct_called[l][c]['C'] = 0.0 pct_called[l][c]['G'] = 0.0 pct_called[l][c]['T'] = 0.0 dict['percent_called'] = pct_called return dict
def parse_errormetrics(path, read_cycle_lookup): fn = 'ErrorMetricsOut.bin' fn = os.path.join(path, fn) dict = {} if (not os.path.exists(fn)): return dict a = BitString(bytes=open(fn, 'rb').read()) file_version = a.read('uintle:8') record_byte_length = a.read('uintle:8') if not (3 <= file_version <= 4): sys.exit('error metrics file version %d not supported' % (file_version)) error_rates = {} # 16 bits of header, 8 bits to a byte for i in range(0, ((a.len - 16) / (record_byte_length * 8))): lane_number = a.read('uintle:16') tile_number = 0 if (file_version < 4): tile_number = a.read('uintle:16') else: tile_number = a.read('uintle:32') cycle_number = a.read('uintle:16') error_rate = a.read('floatle:32') if (file_version < 4): num_perfect_reads = a.read('uintle:32') reads_one_error = a.read('uintle:32') reads_two_error = a.read('uintle:32') reads_three_error = a.read('uintle:32') reads_four_error = a.read('uintle:32') read_number = read_cycle_lookup[cycle_number - 1] if lane_number not in error_rates: error_rates[lane_number] = {} if read_number not in error_rates[lane_number]: error_rates[lane_number][read_number] = [] error_rates[lane_number][read_number].append(error_rate) dict['error_rate'] = {} dict['error_rate_stddev'] = {} for lane in error_rates: dict['error_rate'][lane] = {} dict['error_rate_stddev'][lane] = {} for read in error_rates[lane]: narray = numpy.array(error_rates[lane][read]) dict['error_rate'][lane][read] = round(numpy.mean(narray), 2) dict['error_rate_stddev'][lane][read] = round(numpy.std(narray), 2) return dict
def parse_qualitymetrics(path, read_cycle_lookup): fn = 'QMetricsOut.bin' fn = os.path.join(path, fn) dict = {} a = BitString(bytes=open(fn, 'rb').read()) file_version = a.read('uintle:8') record_byte_length = a.read('uintle:8') header_len = 16 if not (4 <= file_version <= 7): sys.exit('Q metrics file version %d not supported' % (file_version)) qscore_bin_flag = 0 if (file_version >= 5): qscore_bin_flag = a.read('uintle:8') header_len += 8 num_qscore_bins = None remapped_qscores = None bin_low_qscores = None bin_high_qscores = None if (qscore_bin_flag == 1): num_qscore_bins = a.read('uintle:8') header_len += 8 remapped_qscores = [0] * num_qscore_bins bin_low_qscores = [0] * num_qscore_bins bin_high_qscores = [0] * num_qscore_bins if (file_version >= 7): for i in range(num_qscore_bins): bin_low_qscores[i] = a.read('uintle:8') header_len += 8 bin_high_qscores[i] = a.read('uintle:8') header_len += 8 remapped_qscores[i] = a.read('uintle:8') header_len += 8 else: for i in range(num_qscore_bins): bin_low_qscores[i] = a.read('uintle:8') header_len += 8 for i in range(num_qscore_bins): bin_high_qscores[i] = a.read('uintle:8') header_len += 8 for i in range(num_qscore_bins): remapped_qscores[i] = a.read('uintle:8') header_len += 8 total_clusters = {} q30_clusters = {} percent_q30 = {} for i in range(0, ((a.len - header_len) / (record_byte_length * 8))): lane_number = a.read('uintle:16') tile_number = 0 if (file_version <= 6): tile_number = a.read('uintle:16') else: tile_number = a.read('uintle:32') cycle_number = a.read('uintle:16') read_number = read_cycle_lookup[cycle_number - 1] num_buckets = 50 if (qscore_bin_flag): if (file_version > 5): num_buckets = num_qscore_bins for i in range(num_buckets): count = a.read('uintle:32') if lane_number not in total_clusters: total_clusters[lane_number] = {} if read_number not in total_clusters[lane_number]: total_clusters[lane_number][read_number] = 0 total_clusters[lane_number][read_number] += count bucket_qscore = None if ((qscore_bin_flag == 1) and (file_version > 5)): bucket_qscore = remapped_qscores[i] else: bucket_qscore = i + 1 if (bucket_qscore >= 30): if lane_number not in q30_clusters: q30_clusters[lane_number] = {} if read_number not in q30_clusters[lane_number]: q30_clusters[lane_number][read_number] = 0 q30_clusters[lane_number][read_number] += count dict['percent_q30'] = {} for lane in (total_clusters): dict['percent_q30'][lane] = {} for read in (total_clusters[lane]): percent_q30 = None if (q30_clusters[lane][read] == 0): percent_q30 = 0.00 else: percent_q30 = (q30_clusters[lane][read] / float(total_clusters[lane][read])) * 100 dict['percent_q30'][lane][read] = round(percent_q30, 2) return dict
def parse_tilemetrics(path): fn = 'TileMetricsOut.bin' fn = os.path.join(path, fn) dict = {} a = BitString(bytes=open(fn, 'rb').read()) file_version = a.read('uintle:8') record_byte_length = a.read('uintle:8') if not (2 <= file_version <= 3): sys.exit('tile metrics file version %d not supported' % (file_version)) header_size = 16 tile_area = 0 if (file_version == 3): tile_area = a.read('floatle:32') header_size = 48 cluster_density = {} percent_aligned = {} num_cluster = {} num_cluster_pf = {} # header_size bits of header, 8 bits to a byte for i in range(0, int((a.len - header_size) / (record_byte_length * 8))): lane_number = a.read('uintle:16') tile_number = 0 if (file_version <= 2): tile_number = a.read('uintle:16') else: tile_number = a.read('uintle:32') if (file_version <= 2): metric_code = a.read('uintle:16') metric_value = a.read('floatle:32') # only grab desired metrics if (metric_code == 100): if lane_number not in cluster_density: cluster_density[lane_number] = [] cluster_density[lane_number].append(metric_value) elif (metric_code == 102): if lane_number not in num_cluster: num_cluster[lane_number] = 0 num_cluster[lane_number] += metric_value elif (metric_code == 103): if lane_number not in num_cluster_pf: num_cluster_pf[lane_number] = 0 num_cluster_pf[lane_number] += int(metric_value) elif (metric_code == 300): if lane_number not in percent_aligned: percent_aligned[lane_number] = {} if 1 not in percent_aligned[lane_number]: percent_aligned[lane_number][1] = [] percent_aligned[lane_number][1].append(metric_value) elif (metric_code == 301): if lane_number not in percent_aligned: percent_aligned[lane_number] = {} if 2 not in percent_aligned[lane_number]: percent_aligned[lane_number][2] = [] percent_aligned[lane_number][2].append(metric_value) elif (metric_code == 302): if lane_number not in percent_aligned: percent_aligned[lane_number] = {} if 3 not in percent_aligned[lane_number]: percent_aligned[lane_number][3] = [] percent_aligned[lane_number][3].append(metric_value) else: metric_code = a.read('bytes:1') if (metric_code == 't'): cluster_count = a.read('floatle:32') pf_cluster_count = a.read('floatle:32') calc_cluster_density = cluster_count / tile_area if lane_number not in cluster_density: cluster_density[lane_number] = [] cluster_density[lane_number].append(calc_cluster_density) if lane_number not in num_cluster: num_cluster[lane_number] = 0 num_cluster[lane_number] += cluster_count if lane_number not in num_cluster_pf: num_cluster_pf[lane_number] = 0 num_cluster_pf[lane_number] += int(pf_cluster_count) elif (metric_code == 'r'): read_number = a.read('uintle:32') pct_aligned = a.read('floatle:32') if (not math.isnan(pct_aligned)): if lane_number not in percent_aligned: percent_aligned[lane_number] = {} if read_number not in percent_aligned[lane_number]: percent_aligned[lane_number][read_number] = [] percent_aligned[lane_number][read_number].append( pct_aligned) elif (metric_code == '\00'): empty = a.read('bytes:8') else: sys.exit('illegal metric_code %s encountered' % (metric_code)) dict['cluster_density'] = {} dict['cluster_density_stddev'] = {} for lane in cluster_density: narray = numpy.array(cluster_density[lane]) dict['cluster_density'][lane] = round(numpy.mean(narray) / 1000, 2) dict['cluster_density_stddev'][lane] = round( numpy.std(narray) / 1000, 2) dict['num_cluster'] = {} dict['num_cluster_pf'] = {} dict['pct_cluster_pf'] = {} for lane in num_cluster: dict['num_cluster'][lane] = num_cluster[lane] dict['num_cluster_pf'][lane] = num_cluster_pf[lane] dict['pct_cluster_pf'][lane] = round( (float(num_cluster_pf[lane]) / float(num_cluster[lane])) * 100, 2) dict['percent_aligned'] = {} for lane in percent_aligned: for read in percent_aligned[lane]: narray = numpy.array(percent_aligned[lane][read]) if lane not in dict['percent_aligned']: dict['percent_aligned'][lane] = {} if read not in dict['percent_aligned'][lane]: dict['percent_aligned'][lane][read] = {} dict['percent_aligned'][lane][read] = round(numpy.mean(narray), 2) return dict
class EmulateEfuseControllerBase(object): """ The class for virtual efuse operations. Using for HOST_TEST. """ CHIP_NAME = "" mem = None debug = False Blocks = None Fields = None REGS = None def __init__(self, efuse_file=None, debug=False): self.debug = debug self.efuse_file = efuse_file if self.efuse_file: try: self.mem = BitString(open(self.efuse_file, 'a+b'), length=(self.REGS.EFUSE_MEM_SIZE & self.REGS.EFUSE_ADDR_MASK) * 8) except ValueError: # the file is empty or does not fit the length. self.mem = BitString(length=(self.REGS.EFUSE_MEM_SIZE & self.REGS.EFUSE_ADDR_MASK) * 8) self.mem.set(0) self.mem.tofile(open(self.efuse_file, 'a+b')) else: # efuse_file is not provided it means we do not want to keep the result of efuse operations self.mem = BitString( (self.REGS.EFUSE_MEM_SIZE & self.REGS.EFUSE_ADDR_MASK) * 8) self.mem.set(0) """ esptool method start >> """ def read_efuse(self, n, block=0): """ Read the nth word of the ESP3x EFUSE region. """ blk = self.Blocks.get(self.Blocks.BLOCKS[block]) return self.read_reg(blk.rd_addr + (4 * n)) def read_reg(self, addr): self.mem.pos = self.mem.length - ( (addr & self.REGS.EFUSE_ADDR_MASK) * 8 + 32) return self.mem.read("uint:32") def write_reg(self, addr, value, mask=0xFFFFFFFF, delay_us=0, delay_after_us=0): self.mem.pos = self.mem.length - ( (addr & self.REGS.EFUSE_ADDR_MASK) * 8 + 32) self.mem.overwrite("uint:32={}".format(value & mask)) self.handle_writing_event(addr, value) def update_reg(self, addr, mask, new_val): position = self.mem.length - ( (addr & self.REGS.EFUSE_ADDR_MASK) * 8 + 32) self.mem.pos = position cur_val = self.mem.read("uint:32") self.mem.pos = position self.mem.overwrite("uint:32={}".format(cur_val | (new_val & mask))) def write_efuse(self, n, value, block=0): """ Write the nth word of the ESP3x EFUSE region. """ blk = self.Blocks.get(self.Blocks.BLOCKS[block]) self.write_reg(blk.wr_addr + (4 * n), value) """ << esptool method end """ def handle_writing_event(self, addr, value): self.save_to_file() def save_to_file(self): if self.efuse_file: with open(self.efuse_file, 'wb') as f: self.mem.tofile(f) def handle_coding_scheme(self, blk, data): return data def copy_blocks_wr_regs_to_rd_regs(self, updated_block=None): for b in reversed(self.Blocks.BLOCKS): blk = self.Blocks.get(b) if updated_block is not None: if blk.id != updated_block: continue data = self.read_block(blk.id, wr_regs=True) if self.debug: print(blk.name, data.hex) plain_data = self.handle_coding_scheme(blk, data) plain_data = self.check_wr_protection_area(blk.id, plain_data) self.update_block(blk, plain_data) def clean_blocks_wr_regs(self): for b in self.Blocks.BLOCKS: blk = self.Blocks.get(b) for offset in range(0, blk.len * 4, 4): wr_addr = blk.wr_addr + offset self.write_reg(wr_addr, 0) def read_field(self, name, bitstring=True): for e in self.Fields.EFUSES: field = self.Fields.get(e) if field.name == name: self.read_block(field.block) block = self.read_block(field.block) if field.type.startswith("bool"): field_len = 1 else: field_len = int(re.search(r'\d+', field.type).group()) if field.type.startswith("bytes"): field_len *= 8 block.pos = block.length - (field.word * 32 + field.pos + field_len) if bitstring: return block.read(field_len) else: return block.read(field.type) return None def get_bitlen_of_block(self, blk, wr=False): return 32 * blk.len def read_block(self, idx, wr_regs=False): block = None for b in self.Blocks.BLOCKS: blk = self.Blocks.get(b) if blk.id == idx: blk_len_bits = self.get_bitlen_of_block(blk, wr=wr_regs) addr = blk.wr_addr if wr_regs else blk.rd_addr self.mem.pos = self.mem.length - ( (addr & self.REGS.EFUSE_ADDR_MASK) * 8 + blk_len_bits) block = self.mem.read(blk_len_bits) break return block def update_block(self, blk, wr_data): wr_data = self.read_block(blk.id) | wr_data self.overwrite_mem_from_block(blk, wr_data) def overwrite_mem_from_block(self, blk, wr_data): self.mem.pos = self.mem.length - ( (blk.rd_addr & self.REGS.EFUSE_ADDR_MASK) * 8 + wr_data.len) self.mem.overwrite(wr_data) def check_wr_protection_area(self, num_blk, wr_data): # checks fields which have the write protection bit. # if the write protection bit is set then we need to protect that area from changes. write_disable_bit = self.read_field("WR_DIS", bitstring=False) mask_wr_data = BitString(len(wr_data)) mask_wr_data.set(0) blk = self.Blocks.get(self.Blocks.BLOCKS[num_blk]) if blk.write_disable_bit is not None and write_disable_bit & ( 1 << blk.write_disable_bit): mask_wr_data.set(1) else: for e in self.Fields.EFUSES: field = self.Fields.get(e) if blk.id == field.block and field.block == num_blk: if field.write_disable_bit is not None and write_disable_bit & ( 1 << field.write_disable_bit): data = self.read_field(field.name) data.set(1) mask_wr_data.pos = mask_wr_data.length - ( field.word * 32 + field.pos + data.len) mask_wr_data.overwrite(data) mask_wr_data.invert() return wr_data & mask_wr_data def check_rd_protection_area(self): # checks fields which have the read protection bits. # if the read protection bit is set then we need to reset this field to 0. read_disable_bit = self.read_field("RD_DIS", bitstring=False) for b in self.Blocks.BLOCKS: blk = self.Blocks.get(b) block = self.read_block(blk.id) if blk.read_disable_bit is not None and read_disable_bit & ( 1 << blk.read_disable_bit): block.set(0) else: for e in self.Fields.EFUSES: field = self.Fields.get(e) if blk.id == field.block and field.read_disable_bit is not None and read_disable_bit & ( 1 << field.read_disable_bit): raw_data = self.read_field(field.name) raw_data.set(0) block.pos = block.length - ( field.word * 32 + field.pos + raw_data.length) block.overwrite(BitString(raw_data.length)) self.overwrite_mem_from_block(blk, block) def clean_mem(self): self.mem.set(0) if self.efuse_file: with open(self.efuse_file, 'wb') as f: self.mem.tofile(f)
def extract_grib_from_lrit_file(file_path, prefix, output_dir): """ read lrit file """ fp = open(file_path, "rb") bs = BitString(fp) cpt = 0 print("==== Looking for Gribs in %s\n" % (file_path)) #look for HRAA70 in hex 0x485241413730 #f_val = bs.find('0x485241413730', bytealigned=True) #print("f_val = %s\n" %(f_val)) #bs.pos = f_val # look for GRIB in hex 0x47524942 f_val = bs.find('0x47524942', bytealigned=True) print("f_val = %s\n" % (f_val)) while f_val: begin = bs.pos print("begin = %d\n" % (begin)) #look for bulletin header bs.pos -= 21 * 8 bulletin_header = bs.read(18 * 8).hex print("Bulletin Header = %s\n" % bulletin_header) l = "%s" % bulletin_header header_name = binascii.unhexlify(l[2:]) header_name = header_name.replace(" ", "_") print("Bulletin Header = %s\n" % header_name) # look for GRIB in hex 0x47524942 f_val = bs.find('0x47524942', bytealigned=True) bs.pos = begin print("** Found Grib in pos %s" % (bs.bytepos)) # read size grib_value = bs.read(32).hex size = bs.read('uint:24') * 8 #print("size in decimal = %s" %(size)) #read all bits (end-begin)+1 bs.pos = begin read_bits = bs.read(size) dest_fp = open( "%s/%s_%s_%s.grb" % (output_dir, prefix, bulletin_header, cpt), "wb") dest_fp.write(read_bits.tobytes()) dest_fp.close() cpt += 1 #sys.exit(1) #look for the next grib f_val = bs.find('0x47524942', start=bs.pos, bytealigned=True)
def extract_grib_from_lrit_file(file_path, prefix, output_dir): """ read lrit file """ fp = open(file_path, "rb") bs = BitString(fp) cpt=0 print("==== Looking for Gribs in %s\n" %(file_path)) #look for HRAA70 in hex 0x485241413730 #f_val = bs.find('0x485241413730', bytealigned=True) #print("f_val = %s\n" %(f_val)) #bs.pos = f_val # look for GRIB in hex 0x47524942 f_val = bs.find('0x47524942', bytealigned=True) print("f_val = %s\n" %(f_val)) while f_val: begin = bs.pos print("begin = %d\n" % (begin)) #look for bulletin header bs.pos -= 21*8 bulletin_header = bs.read(18*8).hex print("Bulletin Header = %s\n" % bulletin_header) l = "%s" % bulletin_header header_name = binascii.unhexlify(l[2:]) header_name = header_name.replace(" ","_") print("Bulletin Header = %s\n" % header_name) # look for GRIB in hex 0x47524942 f_val = bs.find('0x47524942', bytealigned=True) bs.pos = begin print("** Found Grib in pos %s" % (bs.bytepos) ) # read size grib_value = bs.read(32).hex size = bs.read('uint:24')*8 #print("size in decimal = %s" %(size)) #read all bits (end-begin)+1 bs.pos = begin read_bits = bs.read(size) dest_fp = open("%s/%s_%s_%s.grb" % (output_dir, prefix, bulletin_header, cpt), "wb") dest_fp.write(read_bits.tobytes()) dest_fp.close() cpt +=1 #sys.exit(1) #look for the next grib f_val = bs.find('0x47524942', start=bs.pos, bytealigned=True)