def testByteAligned(self):
bitstring.bytealigned = True
a = BitArray("0x00 ff 0f f")
l = list(a.findall("0xff"))
self.assertEqual(l, [8])
p = a.find("0x0f")[0]
self.assertEqual(p, 16)
p = a.rfind("0xff")[0]
self.assertEqual(p, 8)
s = list(a.split("0xff"))
self.assertEqual(s, ["0x00", "0xff0ff"])
a.replace("0xff", "")
self.assertEqual(a, "0x000ff")
def testNotByteAligned(self):
bitstring.bytealigned = False
a = BitArray('0x00 ff 0f f')
l = list(a.findall('0xff'))
self.assertEqual(l, [8, 20])
p = a.find('0x0f')[0]
self.assertEqual(p, 4)
p = a.rfind('0xff')[0]
self.assertEqual(p, 20)
s = list(a.split('0xff'))
self.assertEqual(s, ['0x00', '0xff0', '0xff'])
a.replace('0xff', '')
self.assertEqual(a, '0x000')
def testByteAligned(self):
bitstring.settings.bytealigned = True
a = BitArray('0x00 ff 0f f')
l = list(a.findall('0xff'))
self.assertEqual(l, [8])
p = a.find('0x0f')[0]
self.assertEqual(p, 16)
p = a.rfind('0xff')[0]
self.assertEqual(p, 8)
s = list(a.split('0xff'))
self.assertEqual(s, ['0x00', '0xff0ff'])
a.replace('0xff', '')
self.assertEqual(a, '0x000ff')
def testNotByteAligned(self):
bitstring.bytealigned = False
a = BitArray('0x00 ff 0f f')
l = list(a.findall('0xff'))
self.assertEqual(l, [8, 20])
p = a.find('0x0f')[0]
self.assertEqual(p, 4)
p = a.rfind('0xff')[0]
self.assertEqual(p, 20)
s = list(a.split('0xff'))
self.assertEqual(s, ['0x00', '0xff0', '0xff'])
a.replace('0xff', '')
self.assertEqual(a, '0x000')
def testByteAligned(self):
bitstring.settings.bytealigned = True
a = BitArray('0x00 ff 0f f')
l = list(a.findall('0xff'))
self.assertEqual(l, [8])
p = a.find('0x0f')[0]
self.assertEqual(p, 16)
p = a.rfind('0xff')[0]
self.assertEqual(p, 8)
s = list(a.split('0xff'))
self.assertEqual(s, ['0x00', '0xff0ff'])
a.replace('0xff', '')
self.assertEqual(a, '0x000ff')
def enumeration_solver(T, K=None, S=None):
"""
Tries all the possible combinations of flipping:
At each round are available len(S) - K + 1
possible flip positions ranging from
0 to len(S) - K
"""
from bitstring import BitArray
S = BitArray(bin=S.replace('+', '1').replace('-', '0'))
solution = '1' * len(S)
if S.bin == solution:
return 'Case #{}: {}\n'.format(T, 0)
#print('Case {}'.format(S.bin))
cand = [S]
flip_pos = range(len(S) - K + 1)
flips = 1
explored = {S.bin}
while flips > 0:
#print('Round {} Candidates {}'.format(flips,len(cand)))
new_cand = []
for c in cand:
for f in flip_pos:
flipped = BitArray(c)
flipped.invert(range(f, f + K))
if flipped.bin == solution:
return 'Case #{}: {}\n'.format(T, flips)
if flipped.bin not in explored:
new_cand.append(flipped)
explored.add(flipped.bin)
if len(new_cand) == 0:
return 'Case #{}: IMPOSSIBLE\n'.format(T)
cand = new_cand
flips += 1
def write_shadow_regis(data_dir: str, writes: List[Tuple[int, int]]) -> None:
"""Write shadow registers:
- prepares and burns into FLASH a binary application for initialization of shadow registers
- the application is launched using "execute" command
- after registers are written, the application do software reset to return back to boot-loader
:param data_dir: absolute path of directory with data files
:param writes: list of show register initialization tuples, that contain:
- the first parameter is an address of the shadow register
- second parameter represents 32-bit value (unsigned integer)
The list may contain maximum 12 tuples
"""
if TEST_IMG_CONTENT:
return
if NO_SHADOWS:
return
assert len(writes) <= 12
write_shadows_app = load_binary(data_dir, "write_shadows",
"write_shadows.bin")
stack_ptr = int.from_bytes(write_shadows_app[:4], byteorder="little")
initial_pc = int.from_bytes(write_shadows_app[4:8], byteorder="little")
# write_shadow is an application, that contains table of 12 writes, for each write 32 bit address and 32-bit value
write_shadows_arr = BitArray(write_shadows_app)
# now we construct an existing table content to be replaced
datatable_old = "0x"
for index in range(12):
char = hex(index)[2:]
datatable_old += "d" + char + "debabe"
datatable_old += "2" + char + "436587"
assert len(datatable_old) == 12 * 8 * 2 + 2
# this is new table content
datatable_new = bytes()
for (addr, value) in writes:
datatable_new += pack("<I", value)
datatable_new += pack("<I", addr)
# the table must contain 12 entries, so first entry is repeated, until table is full needed
for _ in range(12 - len(writes)):
datatable_new += pack("<I", writes[0][1]) # value
datatable_new += pack("<I", writes[0][0]) # addr
assert len(datatable_new) == 12 * 8
# replace the table in the image
res = write_shadows_arr.replace(datatable_old,
datatable_new,
bytealigned=True)
assert res == 1
# burn image into FLASH
mboot = burn_img_via_usb_into_flexspi_flash(data_dir,
write_shadows_arr.bytes)
assert mboot is not None
assert mboot.execute(initial_pc, 0x8001000, stack_ptr)
mboot.close()
sleep(2) # wait until boot-loader is restarted
def testReplace(self):
s = BitArray("0b01")
s.replace("0b1", "0b11")
self.assertEqual(s, "0b011")
def testReplace(self):
s = BitArray('0b01')
s.replace('0b1', '0b11')
self.assertEqual(s, '0b011')
def testReplace(self):
s = BitArray('0b01')
s.replace('0b1', '0b11')
self.assertEqual(s, '0b011')
def getgps(old_dt):
# k = sub.find('0x851200',bytealigned = True)
# if len(k) == 0:
# gps = 'N/A'
# return gps
try:
sub.find('0x85000004', bytealigned=True)
sub.pos += 32
#read 0x850000 - GPS Ver
gpsver = sub.read(4 * 8)
sub.pos += 32
#read 0x8501 - Latitude Ref (N or S)
latref = BitArray(sub.read(8))
latref = latref.tobytes().decode('utf-8')
sub.pos += 32
# read 0x8502 - latiture (6 chunks)
l1 = sub.read(4 * 8).uint
l2 = sub.read(4 * 8).uint
l3 = sub.read(4 * 8).uint
l4 = sub.read(4 * 8).uint
l5 = sub.read(4 * 8).uint
l6 = sub.read(4 * 8).uint
if (l2 == 0 or l4 == 0 or l6 == 0):
gps = 'N/A'
return gps
#write latitute string for text output
lat = str(l1 / l2) + '°' + str(l3 / l4) + "'" + str(
float(l5) / float(l6)) + '"'
latdd = round((float(l1) / float(l2) + (float(l3) / float(l4)) / 60 +
(float(l5) / float(l6) /
(60 * 60)) * (-1 if latref in ['W', 'S'] else 1)), 7)
sub.pos += 32
#read 0x8503 - longtitude ref (E or W)
lonref = BitArray(sub.read(8))
lonref = lonref.tobytes().decode('utf-8')
# read 0x8504 - lontgiture (6 chunks)
sub.pos += 32
l1 = sub.read(4 * 8).uint
l2 = sub.read(4 * 8).uint
l3 = sub.read(4 * 8).uint
l4 = sub.read(4 * 8).uint
l5 = sub.read(4 * 8).uint
l6 = sub.read(4 * 8).uint
if (l2 == 0 or l4 == 0 or l6 == 0):
gps = 'N/A'
return gps
#write latitute string for text output
lon = str(float(l1) / float(l2)) + '°' + str(
float(l3) / float(l4)) + "'" + str(float(l5) / float(l6)) + '"'
londd = round((float(l1) / float(l2) + float(l3) / float(l4) / 60 +
(float(l5) / float(l6) /
(60 * 60)) * (-1 if lonref in ['W', 'S'] else 1)), 7)
k = sub.find('0x85050001', bytealigned=True)
if len(k) != 0:
sub.pos += 32
#read 0x8505 - 1 bytes = AltitudeRef (0 = above sea level, 1 = below sea level)
x8505 = sub.read(8).uint
sub.pos += 32
#read 0x8506 - 8 bytes ([4]/[4]) - Altitude
x8506_1 = sub.read(4 * 8).uint
x8506_2 = sub.read(4 * 8).uint
x8506 = str(float(x8506_1) / float(x8506_2))
else:
x8505 = None
sub.pos += 32
# read 0x8507 - timestamp (6 chunks)
l1 = sub.read(4 * 8).uint
l2 = sub.read(4 * 8).uint
l3 = sub.read(4 * 8).uint
l4 = sub.read(4 * 8).uint
l5 = sub.read(4 * 8).uint
l6 = sub.read(4 * 8).uint
if (l2 == 0 or l4 == 0 or l6 == 0):
gps = 'N/A'
return gps
#write timestamp for text output (hh:mm:ss.xxx)
gpsts = str(int(float(l1) / float(l2))).zfill(2) + ':' + str(
int(float(l3) / float(l4))).zfill(2) + ":" + str(
int(float(l5) / float(l6))).zfill(2)
#print (gpsts)
sub.pos += 32
#read 0x8509 - GPS fix STATUS (not used yet)
gpsfix = BitArray(sub.read(8))
gpsfix = gpsfix.tobytes().decode('utf-8')
sub.pos += 32
# read 0x850a - GPS Measure mode (2 = 2D, 3 = 3D) - not used yet
gpsmeasure = BitArray(sub.read(8))
gpsmeasure = gpsmeasure.tobytes().decode('utf-8')
sub.pos += 32
#read 0x850b - 8 bytes ([4]/[4]) -- DOP -not used yet
x850b_1 = sub.read(4 * 8).uint
x850b_2 = sub.read(4 * 8).uint
x850b = str(float(x850b_1) / float(x850b_2))
if sub.read(4 * 8) == '0x850c0001':
#read 0x850c - 1 byte - SpeedRef (K = km/h, M = mph, N = knots)
x850c = BitArray(sub.read(8))
x850c = x850c.tobytes().decode('utf-8')
sub.pos += 32
#read 0x850d - 8 bytes ([4]/[4]???) - SPEED
x850d_1 = sub.read(4 * 8).uint
x850d_2 = sub.read(4 * 8).uint
x850d = round(float(x850d_1) / float(x850d_2), 2)
else:
x850d = 'N/A'
if sub.read(4 * 8) == '0x850e0001':
#read 0x850e - 1 byte - TrackRef (Direction Reference, T = True direction, M = Magnetic direction)
x850e = BitArray(sub.read(8))
x850e = x850e.tobytes().decode('utf-8')
sub.pos += 32
#read 0x850f - Course 8 bytes ([4]/[4]) (degrees from 0.0 to 359.99)
x850f_1 = sub.read(4 * 8).uint
x850f_2 = sub.read(4 * 8).uint
x850f = round(float(x850f_1) / float(x850f_2), 2)
else:
x850f = 'N/A'
#write full lat + lon + timestamp for text output
if latref == None or lonref == None: gps = 'N/A'
else:
gps = lat + str(latref) + ' ' + lon + str(lonref) + ' ' + gpsts
# debug
#gps = gps + '\n' +str(x8505) + ' ' + str(x8506) + ' ' + str(gpsfix) + ' ' + str(gpsmeasure) + ' ' + str(x850b) + ' ' + str(x850c) + ' ' + str(x850d) + ' ' + str(x850e) + ' ' + str(x850f)
if x850d != 'N/A' or x850f != 'N/A':
gps = gps + '\n' 'Speed: ' + str(x850d) + 'km/h Course: ' + str(
x850f)
k = sub.find('0x851d000a', bytealigned=True)
sub.pos += 32
gpxdate = BitArray(sub.read(8 * 10))
gpxdate = gpxdate.tobytes().decode('utf-8')
gpxdate = gpxdate.replace(':', '-')
gpxdate = gpxdate + 'T' + gpsts + 'Z'
dt = datetime.strptime(gpxdate, '%Y-%m-%dT%H:%M:%SZ')
#print (lat,lon, x850d, x850f)
#write GPX.
if (args.gpx
and 'ExifGPS'.encode() in exifchk) and old_dt < dt.timestamp():
if x8505 != None:
gpx_point = gpxpy.gpx.GPXTrackPoint(
latdd,
londd,
position_dilution=x850b,
type_of_gpx_fix=(gpsmeasure + 'd'),
elevation=(float(x8506) * (-1 if x8505 == 1 else 1)),
time=datetime(dt.year, dt.month, dt.day, dt.hour,
dt.minute, dt.second))
else:
gpx_point = gpxpy.gpx.GPXTrackPoint(
latdd,
londd,
position_dilution=x850b,
type_of_gpx_fix=(gpsmeasure + 'd'),
time=datetime(dt.year, dt.month, dt.day, dt.hour,
dt.minute, dt.second))
gpx_segment.points.append(gpx_point)
#GPX EXT TEST AREA
namespace = '{gpxtx}'
nsmap = {'gpxtpx': namespace[1:-1]} #
root = mod_etree.Element(namespace + 'TrackPointExtension')
subnode1 = mod_etree.SubElement(root, namespace + 'speed')
subnode2 = mod_etree.SubElement(root, namespace + 'course')
if x850d != 'N/A' and x850c == 'K':
subnode1.text = str(round(x850d_1 / x850d_2 / 3.6, 2))
elif x850d != 'N/A' and x850c == 'M':
subnode1.text = str(round(x850d_1 / x850d_2 / 2.23694, 2))
elif x850d != 'N/A' and x850c == 'N':
subnode1.text = str(round(x850d_1 / x850d_2 / 1.94384, 2))
if x850f != 'N/A':
subnode2.text = str(x850f)
gpx.nsmap = nsmap
if x850d != 'N/A' or x850f != 'N/A':
gpx_point.extensions.append(root)
old_dt = dt.timestamp()
except (bitstring.ReadError, UnicodeDecodeError):
return 'N/A'
return gps, old_dt
