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)
