|
1
|
#!/usr/bin/python
|
|
2
|
from __future__ import division
|
|
3
|
import struct
|
|
4
|
import sys
|
|
5
|
print sys.argv
|
|
6
|
import fileinput
|
|
7
|
import binascii
|
|
8
|
from optparse import OptionParser
|
|
9
|
from StringIO import StringIO
|
|
10
|
import struct
|
|
11
|
|
|
12
|
parser = OptionParser()
|
|
13
|
parser.add_option("-f", "--file", dest="filename",
|
|
14
|
help="write report to FILE", metavar="FILE" )
|
|
15
|
|
|
16
|
parser.add_option("-t", "--tuning", action="store_true", dest="SHOW_TUNE", default="False", help="show tuning block")
|
|
17
|
|
|
18
|
parser.add_option("-F", "--feature", action="store_true", dest="SHOW_FEATURE", default="False", help="show feature block")
|
|
19
|
|
|
20
|
parser.add_option("-p", "--programing", action="store_true", dest="SHOW_PROGRAMING", default="False", help="show programing block")
|
|
21
|
|
|
22
|
(options, args) = parser.parse_args()
|
|
23
|
|
|
24
|
#print options
|
|
25
|
|
|
26
|
#def chunks(f):
|
|
27
|
# skip = 0
|
|
28
|
# while True:
|
|
29
|
# byte = f.read(1)
|
|
30
|
# if byte == "":
|
|
31
|
# break
|
|
32
|
# if ord(byte) == 0x80:
|
|
33
|
# print "80 field found"
|
|
34
|
# print "skipped:", skip
|
|
35
|
# skip = 0
|
|
36
|
#
|
|
37
|
# size = ord(f.read(1))
|
|
38
|
# repeat = ord(f.read(1)) or 1
|
|
39
|
# chunk = f.read(size * repeat)
|
|
40
|
# checksum = ord(f.read(1))
|
|
41
|
# yield size, repeat, chunk, checksum
|
|
42
|
# else:
|
|
43
|
# skip += 1
|
|
44
|
|
|
45
|
|
|
46
|
def chunks(f):
|
|
47
|
skip = 0
|
|
48
|
while True:
|
|
49
|
byte = f.read(1)
|
|
50
|
if byte == "":
|
|
51
|
break
|
|
52
|
if ord(byte) == 0x80:
|
|
53
|
print ""
|
|
54
|
print "80 field found"
|
|
55
|
print "skipped:", skip
|
|
56
|
skip = 0
|
|
57
|
size = ord(f.read(1))
|
|
58
|
repeat = ord(f.read(1)) or 1
|
|
59
|
chunk = f.read(size * repeat)
|
|
60
|
checksum = ord(f.read(1))
|
|
61
|
yield size, repeat, chunk, checksum
|
|
62
|
elif ord(byte) == 0x84: #llrrnnnn if ll == 0, each element is nnnnn long and there are rr of them if ll != 0: ll is the length of each item and and there are rr of them
|
|
63
|
print ""
|
|
64
|
print "84 field found"
|
|
65
|
print "skipped:", skip
|
|
66
|
if skip != 0:
|
|
67
|
break
|
|
68
|
skip = 0
|
|
69
|
SIZE_TUPLE = (struct.unpack('>bbH',(f.read(4))))
|
|
70
|
print "SIZE TUPLE = %s" % (SIZE_TUPLE,)
|
|
71
|
print "SIZE TUPLE ll = %s" % SIZE_TUPLE[0]
|
|
72
|
print "SIZE TUPLE rr = %s" % SIZE_TUPLE[1]
|
|
73
|
print "SIZE TUPLE nnnn = %s" % SIZE_TUPLE[2]
|
|
74
|
if SIZE_TUPLE[0] == 0:
|
|
75
|
size = int(SIZE_TUPLE[2] * SIZE_TUPLE[1])
|
|
76
|
elif SIZE_TUPLE[0] != 0:
|
|
77
|
size = int(SIZE_TUPLE[0] * (SIZE_TUPLE[1] + 1))
|
|
78
|
size = int(SIZE_TUPLE[0] + SIZE_TUPLE[1])
|
|
79
|
print "size" "0x%x" % size
|
|
80
|
repeat = 1
|
|
81
|
chunk = f.read(size)
|
|
82
|
print "SIZZZZZZZZZE " "0x%x" % size
|
|
83
|
checksum = ord(f.read(1))
|
|
84
|
yield size, repeat, chunk, checksum
|
|
85
|
else:
|
|
86
|
skip += 1
|
|
87
|
|
|
88
|
|
|
89
|
|
|
90
|
def chonks(pointer):
|
|
91
|
|
|
92
|
while True:
|
|
93
|
byte = data[pointer:(pointer+1)]
|
|
94
|
if byte == "":
|
|
95
|
break
|
|
96
|
if ord(byte) == 0x80:
|
|
97
|
print ""
|
|
98
|
print "80 field found"
|
|
99
|
size = ord(data[(pointer+1):(pointer+2)])
|
|
100
|
repeat = ord(data[(pointer+2):(pointer+3)]) or 1
|
|
101
|
chonk = data[(pointer+3):((pointer+3)+(size * repeat))]
|
|
102
|
checksum = ord(data[(((pointer+3)+(size * repeat))):(((pointer+3)+(size * repeat))+1)])
|
|
103
|
yield size, repeat, chonk, checksum
|
|
104
|
break
|
|
105
|
elif ord(byte) == 0x84: #llrrnnnn if ll == 0, each element is nnnnn long and there are rr of them if ll != 0: ll is the length of each item and and there are rr+1 of them
|
|
106
|
print ""
|
|
107
|
print "84 field found"
|
|
108
|
SIZE_TUPLE = (struct.unpack('>BBH',data[(pointer+1):(pointer+5)]))
|
|
109
|
print "SIZE TUPLE = %s" % (SIZE_TUPLE,)
|
|
110
|
print "SIZE TUPLE ll = %x" % SIZE_TUPLE[0]
|
|
111
|
print "SIZE TUPLE rr = %x" % SIZE_TUPLE[1]
|
|
112
|
print "SIZE TUPLE nnnn = ", "0x%x" % SIZE_TUPLE[2]
|
|
113
|
if SIZE_TUPLE[0] == 0:
|
|
114
|
size = int(SIZE_TUPLE[2] * SIZE_TUPLE[1])
|
|
115
|
elif SIZE_TUPLE[0] != 0:
|
|
116
|
size = int(SIZE_TUPLE[0] * (SIZE_TUPLE[1]))
|
|
117
|
#size = int(SIZE_TUPLE[0] + SIZE_TUPLE[1])
|
|
118
|
print "size " "0x%x" % size
|
|
119
|
repeat = 1
|
|
120
|
chonk = data[(pointer+5):(pointer+5+size)]
|
|
121
|
print "SIZZZZZZZZZE " "0x%x" % size
|
|
122
|
checksum = ord(data[(pointer+6+size)])
|
|
123
|
yield size, repeat, chonk, checksum
|
|
124
|
break
|
|
125
|
if ord(byte) == 0xc4:
|
|
126
|
print ""
|
|
127
|
print "c4 field found"
|
|
128
|
# c4 ll rp 00 bk nn 00 <size> ck
|
|
129
|
# ll -------------------------- is length of block
|
|
130
|
# rp ----------------------- rp repeated blocks
|
|
131
|
# 00 ----- 00 ----------- Always 00 (spacer)
|
|
132
|
# bk ----------------- block length
|
|
133
|
# nn -------------- number of blocks
|
|
134
|
# size ----- Size is ll * rp, total chonk size is size + 8
|
|
135
|
# ck - Checksum 8
|
|
136
|
|
|
137
|
size = ord(data[(pointer+1):(pointer+2)])
|
|
138
|
repeat = ord(data[(pointer+2):(pointer+3)]) or 1
|
|
139
|
block_length = ord(data[(pointer+4):(pointer+5)])
|
|
140
|
block_number = ord(data[(pointer+5):(pointer+6)])
|
|
141
|
chonk = data[(pointer+7):((pointer+7)+(size * repeat))]
|
|
142
|
checksum = ord(data[(((pointer+7)+(size * repeat))):(((pointer+7)+(size * repeat))+1)])
|
|
143
|
yield size, repeat, chonk, checksum
|
|
144
|
break
|
|
145
|
if ord(byte) == 0xc0: # c0 chonks are lists, where each wad has it's own checksum in addition to the chonk checksum
|
|
146
|
print ""
|
|
147
|
print "c0 field found" # c0 ll nn <wad> <wc> ck == ll is length of wad, nn number of wads in the chonk, <wad> is the wad and <wc> is the wad checksum, ck is a checksum.
|
|
148
|
# ll * rp is size, total size is 5 + ll * rp
|
|
149
|
size = ord(data[(pointer+1):(pointer+2)])
|
|
150
|
repeat = ord(data[(pointer+2):(pointer+3)]) or 1
|
|
151
|
#type = ord(data[(pointer+3):(pointer+4)])
|
|
152
|
chonk = data[(pointer+3):((pointer+4)+(size * repeat))]
|
|
153
|
#need code to break into wads
|
|
154
|
checksum = ord(data[(((pointer+4)+(size * repeat))):(((pointer+4)+(size * repeat))+1)])
|
|
155
|
yield size, repeat, chonk, checksum
|
|
156
|
break
|
|
157
|
if ord(byte) == 0x04:
|
|
158
|
print ""
|
|
159
|
print "04 field found" # No idea about this, it's always block 0x15 and only in the 50 and 65 radios.
|
|
160
|
# The checksum doesn't match 5A either, it's 0d. The only value I've seen of it is 04 0100 0204 0200
|
|
161
|
size = 7
|
|
162
|
repeat = 1
|
|
163
|
chonk = data[(pointer+1):((pointer)+(size * repeat))]
|
|
164
|
checksum = 0 #ord(data[(((pointer+4)+(size * repeat))):(((pointer+4)+(size * repeat))+1)])
|
|
165
|
yield size, repeat, chonk, checksum
|
|
166
|
break
|
|
167
|
|
|
168
|
|
|
169
|
else:
|
|
170
|
print "byte is not a 80, 84, c0, or c4"
|
|
171
|
size = 0
|
|
172
|
repeat = 0
|
|
173
|
type = 0
|
|
174
|
chonk = "0x00"
|
|
175
|
checksum = 0
|
|
176
|
yield size, repeat, chonk, checksum
|
|
177
|
break
|
|
178
|
|
|
179
|
|
|
180
|
|
|
181
|
|
|
182
|
def hexprint(data, addrfmt=None):
|
|
183
|
"""Return a hexdump-like encoding of @data"""
|
|
184
|
if addrfmt is None:
|
|
185
|
addrfmt = '%(addr)03i'
|
|
186
|
|
|
187
|
block_size = 8
|
|
188
|
|
|
189
|
lines = len(data) / block_size
|
|
190
|
|
|
191
|
if (len(data) % block_size) != 0:
|
|
192
|
lines += 1
|
|
193
|
data += "\x00" * ((lines * block_size) - len(data))
|
|
194
|
|
|
195
|
out = ""
|
|
196
|
|
|
197
|
for block in range(0, (len(data)/block_size)):
|
|
198
|
addr = block * block_size
|
|
199
|
try:
|
|
200
|
out += addrfmt % locals()
|
|
201
|
except (OverflowError, ValueError, TypeError, KeyError):
|
|
202
|
out += "%03i" % addr
|
|
203
|
out += ': '
|
|
204
|
|
|
205
|
left = len(data) - (block * block_size)
|
|
206
|
if left < block_size:
|
|
207
|
limit = left
|
|
208
|
else:
|
|
209
|
limit = block_size
|
|
210
|
|
|
211
|
for j in range(0, limit):
|
|
212
|
out += "%02x " % ord(data[(block * block_size) + j])
|
|
213
|
|
|
214
|
out += " "
|
|
215
|
|
|
216
|
for j in range(0, limit):
|
|
217
|
char = data[(block * block_size) + j]
|
|
218
|
|
|
219
|
if ord(char) > 0x20 and ord(char) < 0x7E:
|
|
220
|
out += "%s" % char
|
|
221
|
else:
|
|
222
|
out += "."
|
|
223
|
|
|
224
|
out += "\n"
|
|
225
|
|
|
226
|
return out
|
|
227
|
|
|
228
|
|
|
229
|
def chksm8 (s):
|
|
230
|
sum = 0
|
|
231
|
for c in s:
|
|
232
|
sum += ord(c)
|
|
233
|
sum = sum % 0x100
|
|
234
|
# return '0x%2x' % (sum)
|
|
235
|
return sum # this returns it as an int.
|
|
236
|
|
|
237
|
|
|
238
|
def parse_toc(string, size=0x2, start=2):
|
|
239
|
length = (int(ord(string[0:1]) + ord(string[1:2])) + 0x1)
|
|
240
|
print "number of pointers in TOC =", (length - 1)
|
|
241
|
returnarray = []
|
|
242
|
for i in range(start, length * size, size):
|
|
243
|
returnarray.append(string[i:i+size])
|
|
244
|
return returnarray
|
|
245
|
|
|
246
|
|
|
247
|
#example of
|
|
248
|
#print "0x%x" % ((sum(map(ord, (binascii.a2b_hex('000a03ffdf03ff7f3faf'))))) % 0x100 )
|
|
249
|
|
|
250
|
|
|
251
|
class BinaryReaderEOFException(Exception):
|
|
252
|
def __init__(self):
|
|
253
|
pass
|
|
254
|
def __str__(self):
|
|
255
|
return 'Not enough bytes in file to satisfy read request'
|
|
256
|
|
|
257
|
|
|
258
|
|
|
259
|
#import fileinput
|
|
260
|
#for line in fileinput.input():
|
|
261
|
# process(line)
|
|
262
|
|
|
263
|
#print options.filename
|
|
264
|
#read data from file
|
|
265
|
|
|
266
|
with open(options.filename, 'rb') as f:
|
|
267
|
data = f.read()
|
|
268
|
|
|
269
|
# load the tuning cp and print the length and checksum is valid
|
|
270
|
#open file, look at first 2 bytes, this is the legth of the tuning CP including checksum
|
|
271
|
#print length and checksum is valid
|
|
272
|
#store the tuning data including checksum as TUNING_BLOCK
|
|
273
|
|
|
274
|
#def get_bytes_from_file(filename):
|
|
275
|
# return open(filename, "rb").read()
|
|
276
|
|
|
277
|
#with open(options.filename, 'rb') as f:
|
|
278
|
# data = f.read()
|
|
279
|
|
|
280
|
#for line in data:
|
|
281
|
# print line'
|
|
282
|
|
|
283
|
reader = StringIO(data)
|
|
284
|
integer, short = struct.unpack('>ih', reader.read(6))
|
|
285
|
STRING_MAGIC = 0x80
|
|
286
|
|
|
287
|
# load the Tuning data and find the length
|
|
288
|
|
|
289
|
TUNING_LENGTH = (ord(data[0]) << 8) + ord(data[1])
|
|
290
|
TUNING_BLOCK = data[:TUNING_LENGTH]
|
|
291
|
|
|
292
|
#load the FDB and print length and is the checksum valid
|
|
293
|
|
|
294
|
FEATURE_BLOCK_START = TUNING_LENGTH
|
|
295
|
FEATURE_BLOCK_LENGTH = (ord(data[FEATURE_BLOCK_START]) << 8) + ord(data[FEATURE_BLOCK_START+1])
|
|
296
|
FEATURE_BLOCK_END = FEATURE_BLOCK_START + FEATURE_BLOCK_LENGTH
|
|
297
|
FEATURE_BLOCK = data[FEATURE_BLOCK_START+2:FEATURE_BLOCK_END]
|
|
298
|
|
|
299
|
|
|
300
|
|
|
301
|
|
|
302
|
|
|
303
|
#load the rest of the CP and print length and checksum valid the CP starts with 0x0400 on a byte boundry. I should check for this
|
|
304
|
|
|
305
|
PROGRAMING_BLOCK_START = TUNING_LENGTH + FEATURE_BLOCK_LENGTH
|
|
306
|
PROGRAMING_BLOCK_LENGTH = (ord(data[PROGRAMING_BLOCK_START+2]) << 8) + ord(data[PROGRAMING_BLOCK_START+3])
|
|
307
|
PROGRAMING_BLOCK_END = PROGRAMING_BLOCK_START + PROGRAMING_BLOCK_LENGTH
|
|
308
|
PROGRAMING_BLOCK = data[PROGRAMING_BLOCK_START:PROGRAMING_BLOCK_END]
|
|
309
|
|
|
310
|
|
|
311
|
|
|
312
|
|
|
313
|
TOC_HEADER_START = (ord(data[PROGRAMING_BLOCK_START+4]) << 8) + ord(data[PROGRAMING_BLOCK_START+5])
|
|
314
|
TOC_START = (ord(data[PROGRAMING_BLOCK_START+6]) << 8) + ord(data[PROGRAMING_BLOCK_START+7])
|
|
315
|
|
|
316
|
print "toc start 1 (hex) = ", "0x%x" % TOC_START
|
|
317
|
|
|
318
|
PROGRAMING_BLOCK = data[PROGRAMING_BLOCK_START:PROGRAMING_BLOCK_END]
|
|
319
|
|
|
320
|
|
|
321
|
|
|
322
|
#TOC_HEADER_LENGTH = struct.unpack(">h", (data[TOC_HEADER_START:(TOC_HEADER_START+2)]))
|
|
323
|
TOC_HEADER_LENGTH = (ord(data[TOC_HEADER_START]) << 8) + ord(data[TOC_HEADER_START+1])
|
|
324
|
|
|
325
|
print "toc Header length 1 (hex) = ", "0x%x" % TOC_HEADER_LENGTH
|
|
326
|
|
|
327
|
TOC_HEADER_DATA = data[TOC_HEADER_START:(TOC_HEADER_START+TOC_HEADER_LENGTH)]
|
|
328
|
|
|
329
|
# TOC has the first 2 bytes as the number of 2 byte pointers + 1 byte for checksum + the 2 byte header
|
|
330
|
TOC_LENGTH = ((ord(data[TOC_START]) << 8) + ord(data[TOC_START+1]) <<1) + 3
|
|
331
|
|
|
332
|
print "toc start 1 (hex) = ", "0x%x" % TOC_START
|
|
333
|
|
|
334
|
print "toc Length 1 (hex) = ", "0x%x" % TOC_LENGTH
|
|
335
|
|
|
336
|
|
|
337
|
TOC_DATA = data[TOC_START:(TOC_START+TOC_LENGTH)]
|
|
338
|
#print "toc data (hex) = ", "0x%x" % TOC_DATA
|
|
339
|
|
|
340
|
|
|
341
|
#tuning block unpack
|
|
342
|
|
|
343
|
RX_PIERS = TUNING_BLOCK[0x139:0x147]
|
|
344
|
TX_PIERS = TUNING_BLOCK[0x147:0x155]
|
|
345
|
#find the offest based on the magicnumber preceding the RF TEST PIERS location the tuning block, then read 14 sets of 2 bytes
|
|
346
|
#RF_TEST_PIERS_OFFSET = (TUNING_BLOCK.index('\xFF\xFF\xFF\xFF\x07'))+5
|
|
347
|
#RF_TEST_PIERS = TUNING_BLOCK[RF_TEST_PIERS_OFFSET:RF_TEST_PIERS_OFFSET+28]
|
|
348
|
|
|
349
|
#RX_PIERS_TUPLE = struct.unpack('>HHHHHHH',RX_PIERS)
|
|
350
|
#TX_PIERS_TUPLE = struct.unpack('>HHHHHHH',TX_PIERS)
|
|
351
|
#RF_TEST_PIERS_TUPLE = struct.unpack('>HHHHHHHHHHHHHH',RF_TEST_PIERS)
|
|
352
|
|
|
353
|
|
|
354
|
|
|
355
|
# feature block decoding
|
|
356
|
reader = StringIO(FEATURE_BLOCK)
|
|
357
|
FEATURElist = list()
|
|
358
|
|
|
359
|
|
|
360
|
#for size, repeat, chunk, checksum in chunks(reader):
|
|
361
|
# print "\nsize:", "0x%x" % size
|
|
362
|
#print "repeat:", "0x%x" % repeat
|
|
363
|
#print "total:", "0x%x" % size * repeat
|
|
364
|
#print "data:"
|
|
365
|
#print hexprint(chunk)
|
|
366
|
# FEATURElist.append(chunk)
|
|
367
|
#print "checksum:", "0x%x" % checksum
|
|
368
|
|
|
369
|
#print "freature list number of items = " , len(FEATURElist)
|
|
370
|
#for item in FEATURElist:
|
|
371
|
#print item.encode('hex')
|
|
372
|
|
|
373
|
#Feature_List_1 = FEATURElist[0]
|
|
374
|
#Feature_List_2 = FEATURElist[1]
|
|
375
|
#FDB_TUPLE_1 = struct.unpack('>10sH16sHBBBBBBBBBBHHH16sBB10sBBBBBBBB',Feature_List_1) # This is the unpack for the first FDB with serial number an frequency limits
|
|
376
|
#SERIAL_NUMBER = FDB_TUPLE_1[0]
|
|
377
|
#SPACE_1_FDB_1 = FDB_TUPLE_1[1]
|
|
378
|
#MODEL_NUMBER = FDB_TUPLE_1[2]
|
|
379
|
#SPACE_2_FDB_1 = FDB_TUPLE_1[3] #null 0x2A1:2A2
|
|
380
|
#CP_VER_MAJOR = FDB_TUPLE_1[4] #cp ver major 0x2A3
|
|
381
|
#CP_VER_MINOR = FDB_TUPLE_1[5] #cp ver Minor 0x2A4
|
|
382
|
#CP_SOURCE = FDB_TUPLE_1[6] #CP source 0x2A5
|
|
383
|
#CP_DATE_YEAR_UPPER = FDB_TUPLE_1[7] #cp date Year upper 0x2A6
|
|
384
|
#CP_DATE_YEAR_LOWER = FDB_TUPLE_1[8] #cp date Year lower 0x2A7
|
|
385
|
#CP_DATE_MONTH = FDB_TUPLE_1[9] #cp date Month 0x2A8
|
|
386
|
#CP_DATE_DAY = FDB_TUPLE_1[10] #cp date Day 0x2A9
|
|
387
|
#CP_DATE_HOUR = FDB_TUPLE_1[11] #cp Date Hour 0x2AA
|
|
388
|
#CP_DATE_MINUTE = FDB_TUPLE_1[11] #cp Date Minute 0x2AB
|
|
389
|
#CHANNEL_STEP = FDB_TUPLE_1[13] #
|
|
390
|
#BASEBAND_RAW = int(FDB_TUPLE_1[14])
|
|
391
|
#LOWER_LIMIT_RAW = FDB_TUPLE_1[15]
|
|
392
|
#UPPER_LIMIT_RAW = FDB_TUPLE_1[16]
|
|
393
|
#FIRMWARE_PN = FDB_TUPLE_1[17] # 0x2b3:2c2
|
|
394
|
#FDB_UNK_BLK_B_INT_1 = FDB_TUPLE_1[18] #0x2C3
|
|
395
|
#FDB_UNK_BLK_B_INT_2 = FDB_TUPLE_1[19] #0x2C4 Nullpad
|
|
396
|
#TANAPA = FDB_TUPLE_1[20] #0x2c5:2ce
|
|
397
|
#FDB_UNK_BLK_C_INT_1 = FDB_TUPLE_1[22] # 0x2cf
|
|
398
|
#FDB_UNK_BLK_C_INT_2 = FDB_TUPLE_1[23] # 0x2D0
|
|
399
|
#FDB_UNK_BLK_C_INT_3 = FDB_TUPLE_1[23] # 0x2D1
|
|
400
|
#FDB_UNK_BLK_C_INT_4 = FDB_TUPLE_1[24] # 0x2d2
|
|
401
|
#FDB_UNK_BLK_C_INT_5 = FDB_TUPLE_1[25] # 0x2d3
|
|
402
|
#FDB_UNK_BLK_C_INT_6 = FDB_TUPLE_1[26] # 0x2d4
|
|
403
|
#FDB_UNK_BLK_C_INT_7 = FDB_TUPLE_1[27] # 0x2d5
|
|
404
|
#REGION_CODE = FDB_TUPLE_1[28] # region code 0x2d6
|
|
405
|
#
|
|
406
|
#
|
|
407
|
#
|
|
408
|
#
|
|
409
|
#MODEL_NUMBER_TUPLE = struct.unpack('>c2scccc2sccccccc',MODEL_NUMBER)
|
|
410
|
#MODEL_NUMBER_TEST_BYTE = MODEL_NUMBER_TUPLE[1]
|
|
411
|
#
|
|
412
|
#if (MODEL_NUMBER_TUPLE[1]).isdigit() == True:
|
|
413
|
# if (MODEL_NUMBER_TUPLE[0]).isalpha() == True: # tests the unit type is alpha only
|
|
414
|
# print "DEBUG: Model is 1 clause"
|
|
415
|
# MODEL_NUMBER_BYTE_0 = MODEL_NUMBER_TUPLE[0]
|
|
416
|
# MODEL_NUMBER_BYTE_1 = MODEL_NUMBER_TUPLE[1]
|
|
417
|
# MODEL_NUMBER_BYTE_2 = MODEL_NUMBER_TUPLE[2]
|
|
418
|
# MODEL_NUMBER_BYTE_3 = MODEL_NUMBER_TUPLE[3]
|
|
419
|
# MODEL_NUMBER_BYTE_4 = MODEL_NUMBER_TUPLE[4]
|
|
420
|
# MODEL_NUMBER_BYTE_5 = MODEL_NUMBER_TUPLE[5]
|
|
421
|
# MODEL_NUMBER_BYTE_6 = MODEL_NUMBER_TUPLE[6]
|
|
422
|
# MODEL_NUMBER_BYTE_7 = MODEL_NUMBER_TUPLE[7]
|
|
423
|
# MODEL_NUMBER_BYTE_8 = MODEL_NUMBER_TUPLE[8]
|
|
424
|
# MODEL_NUMBER_BYTE_9 = MODEL_NUMBER_TUPLE[9]
|
|
425
|
# MODEL_NUMBER_BYTE_10 = MODEL_NUMBER_TUPLE[10]
|
|
426
|
# MODEL_NUMBER_BYTE_11 = MODEL_NUMBER_TUPLE[11]
|
|
427
|
# MODEL_NUMBER_BYTE_12 = MODEL_NUMBER_TUPLE[12]
|
|
428
|
# MODEL_NUMBER_BYTE_13 = MODEL_NUMBER_TUPLE[13]
|
|
429
|
#else:
|
|
430
|
# MODEL_NUMBER_TUPLE = struct.unpack('>2s2scccc2scccccc',MODEL_NUMBER)
|
|
431
|
# print "ERROR: model number series is not 2 digits"
|
|
432
|
#
|
|
433
|
#
|
|
434
|
##handle model numbers begining with 2 alphas
|
|
435
|
#
|
|
436
|
#
|
|
437
|
#if(MODEL_NUMBER_TUPLE[1]).isdigit() == True:
|
|
438
|
# if (MODEL_NUMBER_TUPLE[0]).isalpha() == True: # tests the unit type is alpha only
|
|
439
|
# print "DEBUG: Model is 2 clause"
|
|
440
|
# MODEL_NUMBER_BYTE_0 = MODEL_NUMBER_TUPLE[0]
|
|
441
|
# MODEL_NUMBER_BYTE_1 = MODEL_NUMBER_TUPLE[1]
|
|
442
|
# MODEL_NUMBER_BYTE_2 = MODEL_NUMBER_TUPLE[2]
|
|
443
|
# MODEL_NUMBER_BYTE_3 = MODEL_NUMBER_TUPLE[3]
|
|
444
|
# MODEL_NUMBER_BYTE_4 = MODEL_NUMBER_TUPLE[4]
|
|
445
|
# MODEL_NUMBER_BYTE_5 = MODEL_NUMBER_TUPLE[5]
|
|
446
|
# MODEL_NUMBER_BYTE_6 = MODEL_NUMBER_TUPLE[6]
|
|
447
|
# MODEL_NUMBER_BYTE_7 = MODEL_NUMBER_TUPLE[7]
|
|
448
|
# MODEL_NUMBER_BYTE_8 = MODEL_NUMBER_TUPLE[8]
|
|
449
|
# MODEL_NUMBER_BYTE_9 = MODEL_NUMBER_TUPLE[9]
|
|
450
|
# MODEL_NUMBER_BYTE_10 = MODEL_NUMBER_TUPLE[10]
|
|
451
|
# MODEL_NUMBER_BYTE_11 = MODEL_NUMBER_TUPLE[11]
|
|
452
|
# MODEL_NUMBER_BYTE_12 = MODEL_NUMBER_TUPLE[12]
|
|
453
|
# MODEL_NUMBER_BYTE_13 = ""
|
|
454
|
#else:
|
|
455
|
# print "ERROR: model number series is not 2 digits"
|
|
456
|
# MODEL_NUMBER_TUPLE = struct.unpack('>3s2scccc2sccccc',MODEL_NUMBER)
|
|
457
|
#
|
|
458
|
# #handle model numbers begining with 3 alphas
|
|
459
|
#
|
|
460
|
#if (MODEL_NUMBER_TUPLE[1]).isdigit() == True:
|
|
461
|
# if (MODEL_NUMBER_TUPLE[0]).isalpha() == True: # tests the unit type is alpha only
|
|
462
|
# print "DEBUG: Model is 3 clause"
|
|
463
|
# MODEL_NUMBER_BYTE_0 = MODEL_NUMBER_TUPLE[0]
|
|
464
|
# MODEL_NUMBER_BYTE_1 = MODEL_NUMBER_TUPLE[1]
|
|
465
|
# MODEL_NUMBER_BYTE_2 = MODEL_NUMBER_TUPLE[2]
|
|
466
|
# MODEL_NUMBER_BYTE_3 = MODEL_NUMBER_TUPLE[3]
|
|
467
|
# MODEL_NUMBER_BYTE_4 = MODEL_NUMBER_TUPLE[4]
|
|
468
|
# MODEL_NUMBER_BYTE_5 = MODEL_NUMBER_TUPLE[5]
|
|
469
|
# MODEL_NUMBER_BYTE_6 = MODEL_NUMBER_TUPLE[6]
|
|
470
|
# MODEL_NUMBER_BYTE_7 = MODEL_NUMBER_TUPLE[7]
|
|
471
|
# MODEL_NUMBER_BYTE_8 = MODEL_NUMBER_TUPLE[8]
|
|
472
|
# MODEL_NUMBER_BYTE_9 = MODEL_NUMBER_TUPLE[9]
|
|
473
|
# MODEL_NUMBER_BYTE_10 = MODEL_NUMBER_TUPLE[10]
|
|
474
|
# MODEL_NUMBER_BYTE_11 = MODEL_NUMBER_TUPLE[11]
|
|
475
|
# MODEL_NUMBER_BYTE_12 = ""
|
|
476
|
# MODEL_NUMBER_BYTE_13 = ""
|
|
477
|
# else:
|
|
478
|
# print "ERROR: model number series is not 2 digits"
|
|
479
|
# exit()
|
|
480
|
#
|
|
481
|
#
|
|
482
|
#else:
|
|
483
|
# print "ERROR: model number is not single alpha"
|
|
484
|
# print "model number tuple %r" % MODEL_NUMBER_TUPLE[0]
|
|
485
|
# print "model number tuple state %s" % ((MODEL_NUMBER_TUPLE[1]).isdigit())
|
|
486
|
# exit()
|
|
487
|
#
|
|
488
|
#
|
|
489
|
#BASEBAND_MHz = (BASEBAND_RAW * .025)
|
|
490
|
#LOWER_LIMIT_MHz = (LOWER_LIMIT_RAW*5/1000 + BASEBAND_MHz )
|
|
491
|
#UPPER_LIMIT_MHz = (UPPER_LIMIT_RAW*5/1000 + BASEBAND_MHz )
|
|
492
|
#
|
|
493
|
##calc the tuning piers
|
|
494
|
#RX_PIERS_1 = (RX_PIERS_TUPLE[0]/200)+BASEBAND_MHz
|
|
495
|
#RX_PIERS_2 = (RX_PIERS_TUPLE[1]/200)+BASEBAND_MHz
|
|
496
|
#RX_PIERS_3 = (RX_PIERS_TUPLE[2]/200)+BASEBAND_MHz
|
|
497
|
#RX_PIERS_4 = (RX_PIERS_TUPLE[3]/200)+BASEBAND_MHz
|
|
498
|
#RX_PIERS_5 = (RX_PIERS_TUPLE[4]/200)+BASEBAND_MHz
|
|
499
|
#RX_PIERS_6 = (RX_PIERS_TUPLE[5]/200)+BASEBAND_MHz
|
|
500
|
#RX_PIERS_7 = (RX_PIERS_TUPLE[6]/200)+BASEBAND_MHz
|
|
501
|
#
|
|
502
|
#TX_PIERS_1 = (TX_PIERS_TUPLE[0]/200)+BASEBAND_MHz
|
|
503
|
#TX_PIERS_2 = (TX_PIERS_TUPLE[1]/200)+BASEBAND_MHz
|
|
504
|
#TX_PIERS_3 = (TX_PIERS_TUPLE[2]/200)+BASEBAND_MHz
|
|
505
|
#TX_PIERS_4 = (TX_PIERS_TUPLE[3]/200)+BASEBAND_MHz
|
|
506
|
#TX_PIERS_5 = (TX_PIERS_TUPLE[4]/200)+BASEBAND_MHz
|
|
507
|
#TX_PIERS_6 = (TX_PIERS_TUPLE[5]/200)+BASEBAND_MHz
|
|
508
|
#TX_PIERS_7 = (TX_PIERS_TUPLE[6]/200)+BASEBAND_MHz
|
|
509
|
#
|
|
510
|
#RF_TEST_PIERS_TX_1 = (RF_TEST_PIERS_TUPLE[0]/200)+BASEBAND_MHz
|
|
511
|
#RF_TEST_PIERS_RX_1 = (RF_TEST_PIERS_TUPLE[1]/200)+BASEBAND_MHz
|
|
512
|
#RF_TEST_PIERS_TX_2 = (RF_TEST_PIERS_TUPLE[2]/200)+BASEBAND_MHz
|
|
513
|
#RF_TEST_PIERS_RX_2 = (RF_TEST_PIERS_TUPLE[3]/200)+BASEBAND_MHz
|
|
514
|
#RF_TEST_PIERS_TX_3 = (RF_TEST_PIERS_TUPLE[4]/200)+BASEBAND_MHz
|
|
515
|
#RF_TEST_PIERS_RX_3 = (RF_TEST_PIERS_TUPLE[5]/200)+BASEBAND_MHz
|
|
516
|
#RF_TEST_PIERS_TX_4 = (RF_TEST_PIERS_TUPLE[6]/200)+BASEBAND_MHz
|
|
517
|
#RF_TEST_PIERS_RX_4 = (RF_TEST_PIERS_TUPLE[7]/200)+BASEBAND_MHz
|
|
518
|
#RF_TEST_PIERS_TX_5 = (RF_TEST_PIERS_TUPLE[8]/200)+BASEBAND_MHz
|
|
519
|
#RF_TEST_PIERS_RX_5 = (RF_TEST_PIERS_TUPLE[9]/200)+BASEBAND_MHz
|
|
520
|
#RF_TEST_PIERS_TX_6 = (RF_TEST_PIERS_TUPLE[10]/200)+BASEBAND_MHz
|
|
521
|
#RF_TEST_PIERS_RX_6 = (RF_TEST_PIERS_TUPLE[11]/200)+BASEBAND_MHz
|
|
522
|
#RF_TEST_PIERS_TX_7 = (RF_TEST_PIERS_TUPLE[12]/200)+BASEBAND_MHz
|
|
523
|
#RF_TEST_PIERS_RX_7 = (RF_TEST_PIERS_TUPLE[13]/200)+BASEBAND_MHz
|
|
524
|
|
|
525
|
|
|
526
|
|
|
527
|
if options.SHOW_TUNE == True:
|
|
528
|
|
|
529
|
|
|
530
|
|
|
531
|
print "tuning block length (hex) = ", "0x%x" % TUNING_LENGTH
|
|
532
|
|
|
533
|
|
|
534
|
|
|
535
|
print TUNING_BLOCK.encode('hex')
|
|
536
|
print "rx piers = ", RX_PIERS.encode('hex')
|
|
537
|
print "tx piers = ", TX_PIERS.encode('hex')
|
|
538
|
print "RF_TEST_PIERS = ", RF_TEST_PIERS.encode('hex')
|
|
539
|
print "Baseband MHz = ", BASEBAND_MHz
|
|
540
|
print "RX_PIERS_1 = %.3f MHz" % RX_PIERS_1
|
|
541
|
print "RX_PIERS_2 = %.3f MHz" % RX_PIERS_2
|
|
542
|
print "RX_PIERS_3 = %.3f MHz" % RX_PIERS_3
|
|
543
|
print "RX_PIERS_4 = %.3f MHz" % RX_PIERS_4
|
|
544
|
print "RX_PIERS_5 = %.3f MHz" % RX_PIERS_5
|
|
545
|
print "RX_PIERS_6 = %.3f MHz" % RX_PIERS_6
|
|
546
|
print "RX_PIERS_7 = %.3f MHz" % RX_PIERS_7
|
|
547
|
print " "
|
|
548
|
print "TX_PIERS_1 = %.3f MHz" % TX_PIERS_1
|
|
549
|
print "TX_PIERS_2 = %.3f MHz" % TX_PIERS_2
|
|
550
|
print "TX_PIERS_3 = %.3f MHz" % TX_PIERS_3
|
|
551
|
print "TX_PIERS_4 = %.3f MHz" % TX_PIERS_4
|
|
552
|
print "TX_PIERS_5 = %.3f MHz" % TX_PIERS_5
|
|
553
|
print "TX_PIERS_6 = %.3f MHz" % TX_PIERS_6
|
|
554
|
print "TX_PIERS_7 = %.3f MHz" % TX_PIERS_7
|
|
555
|
print " "
|
|
556
|
print "RF_TEST_PIERS 1, TX = %.3f MHz , RX = %.3f MHz " % (RF_TEST_PIERS_TX_1, RF_TEST_PIERS_RX_1)
|
|
557
|
print "RF_TEST_PIERS 2, TX = %.3f MHz , RX = %.3f MHz " % (RF_TEST_PIERS_TX_2, RF_TEST_PIERS_RX_2)
|
|
558
|
print "RF_TEST_PIERS 3, TX = %.3f MHz , RX = %.3f MHz " % (RF_TEST_PIERS_TX_3, RF_TEST_PIERS_RX_3)
|
|
559
|
print "RF_TEST_PIERS 4, TX = %.3f MHz , RX = %.3f MHz " % (RF_TEST_PIERS_TX_4, RF_TEST_PIERS_RX_4)
|
|
560
|
print "RF_TEST_PIERS 5, TX = %.3f MHz , RX = %.3f MHz " % (RF_TEST_PIERS_TX_5, RF_TEST_PIERS_RX_5)
|
|
561
|
print "RF_TEST_PIERS 6, TX = %.3f MHz , RX = %.3f MHz " % (RF_TEST_PIERS_TX_6, RF_TEST_PIERS_RX_6)
|
|
562
|
print "RF_TEST_PIERS 7, TX = %.3f MHz , RX = %.3f MHz " % (RF_TEST_PIERS_TX_7, RF_TEST_PIERS_RX_7)
|
|
563
|
|
|
564
|
|
|
565
|
print "TUNING PIERS header, FILE NAME, MODEL NUMBER, TANAPA, BASEBAND_MHz, LOWER_LIMIT_MHz, UPPER_LIMIT_MHz, RX_PIERS_1, RX_PIERS_2, RX_PIERS_3, RX_PIERS_4, RX_PIERS_5, RX_PIERS_6, RX_PIERS_7, TX_PIERS_1, TX_PIERS_2, TX_PIERS_3, TX_PIERS_4, TX_PIERS_5, TX_PIERS_6, TX_PIERS_7, RF_TEST_PIERS_TX_1, RF_TEST_PIERS_RX_1, RF_TEST_PIERS_TX_2, RF_TEST_PIERS_RX_2, RF_TEST_PIERS_TX_3, RF_TEST_PIERS_RX_3, RF_TEST_PIERS_TX_4, RF_TEST_PIERS_RX_4, RF_TEST_PIERS_TX_5, RF_TEST_PIERS_RX_6, RF_TEST_PIERS_TX_7, RF_TEST_PIERS_RX_7"
|
|
566
|
print "TUNING PIERS, %30s, %16s, %10s, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f" % (options.filename, MODEL_NUMBER, TANAPA, BASEBAND_MHz, LOWER_LIMIT_MHz, UPPER_LIMIT_MHz, RX_PIERS_1, RX_PIERS_2, RX_PIERS_3, RX_PIERS_4, RX_PIERS_5, RX_PIERS_6, RX_PIERS_7, TX_PIERS_1, TX_PIERS_2, TX_PIERS_3, TX_PIERS_4, TX_PIERS_5, TX_PIERS_6, TX_PIERS_7, RF_TEST_PIERS_TX_1, RF_TEST_PIERS_RX_1, RF_TEST_PIERS_TX_2, RF_TEST_PIERS_RX_2, RF_TEST_PIERS_TX_3, RF_TEST_PIERS_RX_3, RF_TEST_PIERS_TX_4, RF_TEST_PIERS_RX_4, RF_TEST_PIERS_TX_5, RF_TEST_PIERS_RX_6, RF_TEST_PIERS_TX_7, RF_TEST_PIERS_RX_7)
|
|
567
|
|
|
568
|
|
|
569
|
if options.SHOW_FEATURE == True:
|
|
570
|
print "feature block length (hex) = ", "0x%x" % FEATURE_BLOCK_LENGTH
|
|
571
|
print "feature block start (hex) = ", "0x%x" % FEATURE_BLOCK_START
|
|
572
|
print "feature block end (hex) = ", "0x%x" % FEATURE_BLOCK_END
|
|
573
|
# print FEATURE_BLOCK.find(STRING_MAGIC)
|
|
574
|
print FEATURE_BLOCK.encode('hex')
|
|
575
|
|
|
576
|
|
|
577
|
|
|
578
|
|
|
579
|
# unpack tuple 2 now, but it size varies
|
|
580
|
if len(Feature_List_2) == 0x9:
|
|
581
|
FDB_TUPLE_2 = struct.unpack('>BBBBBBBBB',Feature_List_2) # This is the unpack for the Second FDB with channel sizes and such
|
|
582
|
FDB2_LEN_9_INT_1 = FDB_TUPLE_2[0] # Trunking personalities 0x2db
|
|
583
|
FDB2_LEN_9_INT_2 = FDB_TUPLE_2[1] # Signaling 0x2dc trunking high and conventional low, FF is everything
|
|
584
|
FDB2_LEN_9_INT_3 = FDB_TUPLE_2[2] # control head (nibble based) 0x2dd
|
|
585
|
FDB2_LEN_9_INT_4 = FDB_TUPLE_2[3] # 0x2de UNK (nibbles)
|
|
586
|
FDB2_LEN_9_INT_5 = FDB_TUPLE_2[4] # 0x2df UNK (nibbles)
|
|
587
|
FDB2_LEN_9_INT_6 = FDB_TUPLE_2[5] # 0x2e0 UNK (nibbles)
|
|
588
|
FDB2_LEN_9_INT_7 = FDB_TUPLE_2[6] # 0x2e1 UNK (nibbles)
|
|
589
|
FDB2_LEN_9_INT_8 = FDB_TUPLE_2[7] # 0x2e2 Conventional Pers number
|
|
590
|
FDB2_LEN_9_INT_9 = FDB_TUPLE_2[8] # 0x2e3 UNK (nibbles)
|
|
591
|
print "FDB2, %60s, MODEL -, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, Size = %2d, %x, %x, %x, %x, %x, %x, %x, %x, %x" % (options.filename, MODEL_NUMBER_BYTE_0, MODEL_NUMBER_BYTE_1, MODEL_NUMBER_BYTE_2, MODEL_NUMBER_BYTE_3, MODEL_NUMBER_BYTE_4, MODEL_NUMBER_BYTE_5, MODEL_NUMBER_BYTE_6, MODEL_NUMBER_BYTE_7, MODEL_NUMBER_BYTE_8, MODEL_NUMBER_BYTE_9, MODEL_NUMBER_BYTE_10, MODEL_NUMBER_BYTE_11, MODEL_NUMBER_BYTE_12, MODEL_NUMBER_BYTE_13, (len(Feature_List_2)), FDB2_LEN_9_INT_1, FDB2_LEN_9_INT_2, FDB2_LEN_9_INT_3, FDB2_LEN_9_INT_4, FDB2_LEN_9_INT_5, FDB2_LEN_9_INT_6, FDB2_LEN_9_INT_7, FDB2_LEN_9_INT_8, FDB2_LEN_9_INT_9)
|
|
592
|
|
|
593
|
elif len(Feature_List_2) == 0xA:
|
|
594
|
FDB_TUPLE_2 = struct.unpack('>BBBBBBBBBB',Feature_List_2)
|
|
595
|
FDB2_LEN_A_INT_1 = FDB_TUPLE_2[0]
|
|
596
|
FDB2_LEN_A_INT_2 = FDB_TUPLE_2[1]
|
|
597
|
FDB2_LEN_A_INT_3 = FDB_TUPLE_2[2]
|
|
598
|
FDB2_LEN_A_INT_4 = FDB_TUPLE_2[3]
|
|
599
|
FDB2_LEN_A_INT_5 = FDB_TUPLE_2[4]
|
|
600
|
FDB2_LEN_A_INT_6 = FDB_TUPLE_2[5]
|
|
601
|
FDB2_LEN_A_INT_7 = FDB_TUPLE_2[6]
|
|
602
|
FDB2_LEN_A_INT_8 = FDB_TUPLE_2[7]
|
|
603
|
FDB2_LEN_A_INT_9 = FDB_TUPLE_2[8]
|
|
604
|
FDB2_LEN_A_INT_10 = FDB_TUPLE_2[9] # 0x2e4 UNK (nibbles)
|
|
605
|
print "FDB2, %60s, MODEL -, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, Size = %2d, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x" % (options.filename, MODEL_NUMBER_BYTE_0, MODEL_NUMBER_BYTE_1, MODEL_NUMBER_BYTE_2, MODEL_NUMBER_BYTE_3, MODEL_NUMBER_BYTE_4, MODEL_NUMBER_BYTE_5, MODEL_NUMBER_BYTE_6, MODEL_NUMBER_BYTE_7, MODEL_NUMBER_BYTE_8, MODEL_NUMBER_BYTE_9, MODEL_NUMBER_BYTE_10, MODEL_NUMBER_BYTE_11, MODEL_NUMBER_BYTE_12, MODEL_NUMBER_BYTE_13, (len(Feature_List_2)), FDB2_LEN_A_INT_1, FDB2_LEN_A_INT_2, FDB2_LEN_A_INT_3, FDB2_LEN_A_INT_4, FDB2_LEN_A_INT_5, FDB2_LEN_A_INT_6, FDB2_LEN_A_INT_7, FDB2_LEN_A_INT_8, FDB2_LEN_A_INT_9, FDB2_LEN_A_INT_10)
|
|
606
|
|
|
607
|
elif len(Feature_List_2) == 0xE:
|
|
608
|
FDB_TUPLE_2 = struct.unpack('>BBBBBBBBBBBBBB',Feature_List_2)
|
|
609
|
FDB2_LEN_E_INT_1 = FDB_TUPLE_2[0]
|
|
610
|
FDB2_LEN_E_INT_2 = FDB_TUPLE_2[1]
|
|
611
|
FDB2_LEN_E_INT_3 = FDB_TUPLE_2[2]
|
|
612
|
FDB2_LEN_E_INT_4 = FDB_TUPLE_2[3]
|
|
613
|
FDB2_LEN_E_INT_5 = FDB_TUPLE_2[4]
|
|
614
|
FDB2_LEN_E_INT_6 = FDB_TUPLE_2[5]
|
|
615
|
FDB2_LEN_E_INT_7 = FDB_TUPLE_2[6]
|
|
616
|
FDB2_LEN_E_INT_8 = FDB_TUPLE_2[7]
|
|
617
|
FDB2_LEN_E_INT_9 = FDB_TUPLE_2[8]
|
|
618
|
FDB2_LEN_E_INT_10 = FDB_TUPLE_2[9] # 0x2e4 UNK (nibbles)
|
|
619
|
FDB2_LEN_E_INT_11 = FDB_TUPLE_2[10] # 0x2e5 UNK (nibbles)
|
|
620
|
FDB2_LEN_E_INT_12 = FDB_TUPLE_2[11] # 0x2e6 UNK (nibbles)
|
|
621
|
FDB2_LEN_E_INT_13 = FDB_TUPLE_2[12] # 0x2e7 UNK (nibbles)
|
|
622
|
FDB2_LEN_E_INT_14 = FDB_TUPLE_2[13] # 0x2e8 UNK (nibbles)
|
|
623
|
print "FDB2, %60s, MODEL -, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, Size = %2d, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x" % (options.filename, MODEL_NUMBER_BYTE_0, MODEL_NUMBER_BYTE_1, MODEL_NUMBER_BYTE_2, MODEL_NUMBER_BYTE_3, MODEL_NUMBER_BYTE_4, MODEL_NUMBER_BYTE_5, MODEL_NUMBER_BYTE_6, MODEL_NUMBER_BYTE_7, MODEL_NUMBER_BYTE_8, MODEL_NUMBER_BYTE_9, MODEL_NUMBER_BYTE_10, MODEL_NUMBER_BYTE_11, MODEL_NUMBER_BYTE_12, MODEL_NUMBER_BYTE_13, (len(Feature_List_2)), FDB2_LEN_E_INT_1, FDB2_LEN_E_INT_2, FDB2_LEN_E_INT_3, FDB2_LEN_E_INT_4, FDB2_LEN_E_INT_5, FDB2_LEN_E_INT_6, FDB2_LEN_E_INT_7, FDB2_LEN_E_INT_8, FDB2_LEN_E_INT_9, FDB2_LEN_E_INT_10, FDB2_LEN_E_INT_11, FDB2_LEN_E_INT_12, FDB2_LEN_E_INT_13, FDB2_LEN_E_INT_14)
|
|
624
|
|
|
625
|
elif len(Feature_List_2) == 0x10:
|
|
626
|
FDB_TUPLE_2 = struct.unpack('>BBBBBBBBBBBBBBBB',Feature_List_2)
|
|
627
|
FDB2_LEN_10_INT_1 = FDB_TUPLE_2[0]
|
|
628
|
FDB2_LEN_10_INT_2 = FDB_TUPLE_2[1]
|
|
629
|
FDB2_LEN_10_INT_3 = FDB_TUPLE_2[2]
|
|
630
|
FDB2_LEN_10_INT_4 = FDB_TUPLE_2[3]
|
|
631
|
FDB2_LEN_10_INT_5 = FDB_TUPLE_2[4]
|
|
632
|
FDB2_LEN_10_INT_6 = FDB_TUPLE_2[5]
|
|
633
|
FDB2_LEN_10_INT_7 = FDB_TUPLE_2[6]
|
|
634
|
FDB2_LEN_10_INT_8 = FDB_TUPLE_2[7]
|
|
635
|
FDB2_LEN_10_INT_9 = FDB_TUPLE_2[8]
|
|
636
|
FDB2_LEN_10_INT_10 = FDB_TUPLE_2[9] # 0x2e4 UNK (nibbles)
|
|
637
|
FDB2_LEN_10_INT_11 = FDB_TUPLE_2[10] # 0x2e5 UNK (nibbles)
|
|
638
|
FDB2_LEN_10_INT_12 = FDB_TUPLE_2[11] # 0x2e6 UNK (nibbles) 0 or 1?
|
|
639
|
FDB2_LEN_10_INT_13 = FDB_TUPLE_2[12] # 0x2e7 UNK (nibbles) Unused?
|
|
640
|
FDB2_LEN_10_INT_14 = FDB_TUPLE_2[13] # 0x2e8 UNK (nibbles) Unused
|
|
641
|
FDB2_LEN_10_INT_15 = FDB_TUPLE_2[14] # 0x2e9 UNK (nibbles) Unused
|
|
642
|
FDB2_LEN_10_INT_16 = FDB_TUPLE_2[15] # 0x2ea UNK (nibbles) Unused
|
|
643
|
print "FDB2, %60s, MODEL -, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, Size = %2d, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x" % (options.filename, MODEL_NUMBER_BYTE_0, MODEL_NUMBER_BYTE_1, MODEL_NUMBER_BYTE_2, MODEL_NUMBER_BYTE_3, MODEL_NUMBER_BYTE_4, MODEL_NUMBER_BYTE_5, MODEL_NUMBER_BYTE_6, MODEL_NUMBER_BYTE_7, MODEL_NUMBER_BYTE_8, MODEL_NUMBER_BYTE_9, MODEL_NUMBER_BYTE_10, MODEL_NUMBER_BYTE_11, MODEL_NUMBER_BYTE_12, MODEL_NUMBER_BYTE_13, (len(Feature_List_2)), FDB2_LEN_10_INT_1, FDB2_LEN_10_INT_2, FDB2_LEN_10_INT_3, FDB2_LEN_10_INT_4, FDB2_LEN_10_INT_5, FDB2_LEN_10_INT_6, FDB2_LEN_10_INT_7, FDB2_LEN_10_INT_8, FDB2_LEN_10_INT_9, FDB2_LEN_10_INT_10, FDB2_LEN_10_INT_11, FDB2_LEN_10_INT_12, FDB2_LEN_10_INT_13, FDB2_LEN_10_INT_14, FDB2_LEN_10_INT_15, FDB2_LEN_10_INT_16)
|
|
644
|
|
|
645
|
|
|
646
|
# print "FDB2, %60s, Size = %2d, %s" % (options.filename, (len(Feature_List_2)), )
|
|
647
|
|
|
648
|
#SERIAL_NUMBER = struct.unpack('>10s',Feature_List_1[0:10])
|
|
649
|
# print options.filename, " FDBTUPLE1", FDB_TUPLE_1
|
|
650
|
#unpak = int(struct.unpack('>2s',Feature_List_1[10:12])[0])
|
|
651
|
if int(SPACE_1_FDB_1) != 0x0000:
|
|
652
|
print "Serial number space NOT found"
|
|
653
|
#print "%30s, %10s, 0x%x, %16s, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, %d, %d, %d, %16s, 0x%x, 0x%x, %10s, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x" % (options.filename, SERIAL_NUMBER, SPACE_1_FDB_1, MODEL_NUMBER, SPACE_2_FDB_1, CP_VER_MAJOR, CP_VER_MINOR, CP_SOURCE, CP_DATE_YEAR_UPPER, CP_DATE_YEAR_LOWER, CP_DATE_MONTH, CP_DATE_DAY, SPACE_3_FDB_1, CHANNEL_STEP, BASEBAND_RAW, LOWER_LIMIT_RAW, UPPER_LIMIT_RAW, FIRMWARE_PN, FDB_UNK_BLK_B_INT_1, FDB_UNK_BLK_B_INT_2, TANAPA, FDB_UNK_BLK_C_INT_1, FDB_UNK_BLK_C_INT_2, FDB_UNK_BLK_C_INT_3, FDB_UNK_BLK_C_INT_4, FDB_UNK_BLK_C_INT_5, FDB_UNK_BLK_C_INT_6, FDB_UNK_BLK_C_INT_7, REGION_CODE)
|
|
654
|
print "FDB1, %30s, %10s, %x, %16s, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %.1f MHz, %.1f MHz, %.1f MHz, %16s, %x, %x, %10s, %x, %x, %x, %x, %x, %x, %x, %x" % (options.filename, SERIAL_NUMBER, SPACE_1_FDB_1, MODEL_NUMBER, SPACE_2_FDB_1, CP_VER_MAJOR, CP_VER_MINOR, CP_SOURCE, CP_DATE_YEAR_UPPER, CP_DATE_YEAR_LOWER, CP_DATE_MONTH, CP_DATE_DAY, CP_DATE_HOUR, CP_DATE_MINUTE, CHANNEL_STEP, BASEBAND_MHz, LOWER_LIMIT_MHz, UPPER_LIMIT_MHz, FIRMWARE_PN, FDB_UNK_BLK_B_INT_1, FDB_UNK_BLK_B_INT_2, TANAPA, FDB_UNK_BLK_C_INT_1, FDB_UNK_BLK_C_INT_2, FDB_UNK_BLK_C_INT_3, FDB_UNK_BLK_C_INT_4, FDB_UNK_BLK_C_INT_5, FDB_UNK_BLK_C_INT_6, FDB_UNK_BLK_C_INT_7, REGION_CODE)
|
|
655
|
|
|
656
|
|
|
657
|
|
|
658
|
# print "buffer", unpak.encode('hex')
|
|
659
|
print "Serial Number = ","%r" % SERIAL_NUMBER
|
|
660
|
print "Model Number = ","%r" % MODEL_NUMBER
|
|
661
|
print "Channel Step = ","0x%x" % CHANNEL_STEP
|
|
662
|
print "TANAPA = ","%r" % TANAPA
|
|
663
|
print "Firmware P/N = ","%r" % FIRMWARE_PN
|
|
664
|
print "Base band = ","%r MHz" % BASEBAND_MHz
|
|
665
|
print "Lower limit = ","%r MHz" % LOWER_LIMIT_MHz
|
|
666
|
print "Upper limit = ","%r MHz" % UPPER_LIMIT_MHz
|
|
667
|
|
|
668
|
# print the model and unk blocks
|
|
669
|
if len(Feature_List_2) == 0x9:
|
|
670
|
print "UNKNOWN BYTES, %s, %s, %s, %s, %s, %s, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x" % (MODEL_NUMBER_BYTE_0, MODEL_NUMBER_BYTE_1, MODEL_NUMBER_BYTE_4, MODEL_NUMBER_BYTE_6, MODEL_NUMBER_BYTE_7, TANAPA, FDB_UNK_BLK_B_INT_1, FDB_UNK_BLK_C_INT_1, FDB_UNK_BLK_C_INT_2, FDB_UNK_BLK_C_INT_3, FDB_UNK_BLK_C_INT_4, FDB_UNK_BLK_C_INT_5, FDB_UNK_BLK_C_INT_6, FDB_UNK_BLK_C_INT_7, FDB2_LEN_9_INT_3, FDB2_LEN_9_INT_4, FDB2_LEN_9_INT_5, FDB2_LEN_9_INT_6, FDB2_LEN_9_INT_7, FDB2_LEN_9_INT_9)
|
|
671
|
|
|
672
|
elif len(Feature_List_2) == 0xA:
|
|
673
|
print "UNKNOWN BYTES, %s, %s, %s, %s, %s, %s, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x" % (MODEL_NUMBER_BYTE_0, MODEL_NUMBER_BYTE_1, MODEL_NUMBER_BYTE_4, MODEL_NUMBER_BYTE_6, MODEL_NUMBER_BYTE_7, TANAPA, FDB_UNK_BLK_B_INT_1, FDB_UNK_BLK_C_INT_1, FDB_UNK_BLK_C_INT_2, FDB_UNK_BLK_C_INT_3, FDB_UNK_BLK_C_INT_4, FDB_UNK_BLK_C_INT_5, FDB_UNK_BLK_C_INT_6, FDB_UNK_BLK_C_INT_7, FDB2_LEN_A_INT_3, FDB2_LEN_A_INT_4, FDB2_LEN_A_INT_5, FDB2_LEN_A_INT_6, FDB2_LEN_A_INT_7, FDB2_LEN_A_INT_9, FDB2_LEN_A_INT_10)
|
|
674
|
|
|
675
|
elif len(Feature_List_2) == 0xE:
|
|
676
|
print "UNKNOWN BYTES, %s, %s, %s, %s, %s, %s, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x" % (MODEL_NUMBER_BYTE_0, MODEL_NUMBER_BYTE_1, MODEL_NUMBER_BYTE_4, MODEL_NUMBER_BYTE_6, MODEL_NUMBER_BYTE_7, TANAPA, FDB_UNK_BLK_B_INT_1, FDB_UNK_BLK_C_INT_1, FDB_UNK_BLK_C_INT_2, FDB_UNK_BLK_C_INT_3, FDB_UNK_BLK_C_INT_4, FDB_UNK_BLK_C_INT_5, FDB_UNK_BLK_C_INT_6, FDB_UNK_BLK_C_INT_7, FDB2_LEN_E_INT_3, FDB2_LEN_E_INT_4, FDB2_LEN_E_INT_5, FDB2_LEN_E_INT_6, FDB2_LEN_E_INT_7, FDB2_LEN_E_INT_9, FDB2_LEN_E_INT_10, FDB2_LEN_E_INT_11, FDB2_LEN_E_INT_12, FDB2_LEN_E_INT_13, FDB2_LEN_E_INT_14)
|
|
677
|
|
|
678
|
|
|
679
|
elif len(Feature_List_2) == 0x10:
|
|
680
|
print "UNKNOWN BYTES, %s, %s, %s, %s, %s, %s, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x" % (MODEL_NUMBER_BYTE_0, MODEL_NUMBER_BYTE_1, MODEL_NUMBER_BYTE_4, MODEL_NUMBER_BYTE_6, MODEL_NUMBER_BYTE_7, TANAPA, FDB_UNK_BLK_B_INT_1, FDB_UNK_BLK_C_INT_1, FDB_UNK_BLK_C_INT_2, FDB_UNK_BLK_C_INT_3, FDB_UNK_BLK_C_INT_4, FDB_UNK_BLK_C_INT_5, FDB_UNK_BLK_C_INT_6, FDB_UNK_BLK_C_INT_7, FDB2_LEN_10_INT_3, FDB2_LEN_10_INT_4, FDB2_LEN_10_INT_5, FDB2_LEN_10_INT_6, FDB2_LEN_10_INT_7, FDB2_LEN_10_INT_9, FDB2_LEN_10_INT_10, FDB2_LEN_10_INT_11, FDB2_LEN_10_INT_12, FDB2_LEN_10_INT_13, FDB2_LEN_10_INT_14, FDB2_LEN_10_INT_15, FDB2_LEN_10_INT_16)
|
|
681
|
|
|
682
|
|
|
683
|
|
|
684
|
|
|
685
|
|
|
686
|
# print "Serial number = " , "%r" % SERIAL_NUMBER[0]
|
|
687
|
|
|
688
|
#print "Model number = " , "%r" % MODEL_NUMBER[0]
|
|
689
|
|
|
690
|
def str2int(s, chars):
|
|
691
|
i = 0
|
|
692
|
for c in reversed(s):
|
|
693
|
i *= len(chars)
|
|
694
|
i += chars.index(c)
|
|
695
|
return i
|
|
696
|
|
|
697
|
def int2str(i, chars):
|
|
698
|
s = ""
|
|
699
|
while i:
|
|
700
|
s += chars[i % len(chars)]
|
|
701
|
i //= len(chars)
|
|
702
|
return s
|
|
703
|
|
|
704
|
|
|
705
|
|
|
706
|
|
|
707
|
if options.SHOW_PROGRAMING == True:
|
|
708
|
|
|
709
|
|
|
710
|
|
|
711
|
print "programing block length (hex) = ", "0x%x" % PROGRAMING_BLOCK_LENGTH
|
|
712
|
print "programing block start (hex) = ", "0x%x" % PROGRAMING_BLOCK_START
|
|
713
|
print "programing block end (hex) = ", "0x%x" % PROGRAMING_BLOCK_END
|
|
714
|
#print PROGRAMING_BLOCK.encode('hex')
|
|
715
|
print "toc header start (hex) = ", "0x%x" % TOC_HEADER_START
|
|
716
|
print "toc header length (hex) = ", "0x%x" % TOC_HEADER_LENGTH
|
|
717
|
print "toc header data (hex) = ", TOC_HEADER_DATA.encode('hex')
|
|
718
|
print "toc header checksum = ", "0x%x" % chksm8(TOC_HEADER_DATA)
|
|
719
|
|
|
720
|
print "toc start (hex) = ", "0x%x" % TOC_START
|
|
721
|
print "toc length (hex) = ", "0x%x" % TOC_LENGTH
|
|
722
|
print "toc data (hex) = ", TOC_DATA.encode('hex')
|
|
723
|
print "toc header checksum = ", "0x%x" % chksm8(TOC_DATA)
|
|
724
|
TOC_POINTERS= parse_toc(TOC_DATA)
|
|
725
|
print "tocpointers length", len(TOC_POINTERS)
|
|
726
|
for i in range(len(TOC_POINTERS)):
|
|
727
|
print "Block ", "0x%02X" % i ," =>" ,TOC_POINTERS[i].encode('hex')
|
|
728
|
|
|
729
|
|
|
730
|
|
|
731
|
chonknum=0x00
|
|
732
|
for i in range(len(TOC_POINTERS)):
|
|
733
|
|
|
734
|
|
|
735
|
if int(TOC_POINTERS[chonknum].encode('hex'), 16 ) == 0x0000 : # if it's zero, skip it
|
|
736
|
print "skipping chonk number ", "0x%02X" % chonknum, "is 0x0000"
|
|
737
|
print "%s,CHONK DATA,0x%02X,0x%02X,0x0000" % (options.filename, (int(TOC_POINTERS[chonknum].encode('hex'), 16 )), chonknum)
|
|
738
|
chonknum += 0x1
|
|
739
|
else:
|
|
740
|
for size, repeat, chonk, checksum in chonks(int(TOC_POINTERS[chonknum].encode('hex'), 16 ) ):
|
|
741
|
print "chonk number ", "0x%02X" % chonknum ," =>" ,TOC_POINTERS[chonknum].encode('hex')
|
|
742
|
print "size:", "0x%x" % size
|
|
743
|
print "repeat:", "0x%x" % repeat
|
|
744
|
print "total size:", "0x%x" % size * repeat
|
|
745
|
print "chonk data ", "0x%02X" % chonknum ," =>" ,chonk.encode('hex')
|
|
746
|
print "checksum ", "0x%02X" % chonknum ," =>", "0x%02X" % checksum
|
|
747
|
print "%s,CHONK DATA,0x%02X,0x%02X,0x%s" % (options.filename, (int(TOC_POINTERS[chonknum].encode('hex'), 16 )), chonknum, chonk.encode('hex'))
|
|
748
|
chonknum += 0x1
|
|
749
|
|
|
750
|
|
|
751
|
|
|
752
|
|
|
753
|
#setup the Progaming list tuple
|
|
754
|
# PROGRAMMING_LIST = list()
|
|
755
|
#
|
|
756
|
# reader = StringIO(PROGRAMING_BLOCK)
|
|
757
|
# for size, repeat, chunk, checksum in chunks(reader):
|
|
758
|
# print "\nsize:", "0x%x" % size
|
|
759
|
# print "repeat:", "0x%x" % repeat
|
|
760
|
# print "total:", "0x%x" % (size * repeat)
|
|
761
|
# print "data:"
|
|
762
|
# #print hexprint(chunk)
|
|
763
|
# PROGRAMMING_LIST.append(chunk)
|
|
764
|
# print "checksum:", "0x%x" % checksum
|
|
765
|
#
|
|
766
|
#
|
|
767
|
#
|
|
768
|
# print "number of programing block = ", "0x%x" % len(PROGRAMMING_LIST)
|
|
769
|
# print "PRG-BLK-0 = ", PROGRAMMING_LIST[0].encode('hex')
|
|
770
|
# PRG_BLK_1 = PROGRAMMING_LIST[1].encode('hex')
|
|
771
|
#
|
|
772
|
# #ProgramingBlock1struct.unpack('>10sH16sHBBBBBBBHBHHH16sBB10sBBBBBBBB',)
|
|
773
|
# print "PROG-BLK-1, %30s, %16s, %10s, 0x%s" % (options.filename, MODEL_NUMBER, TANAPA, PRG_BLK_1)
|
|
774
|
#
|
|
775
|
# print "PRG-BLK-2 = ", PROGRAMMING_LIST[2].encode('hex')
|
|
776
|
# print "PRG-BLK-3 = ", PROGRAMMING_LIST[3].encode('hex')
|
|
777
|
# print "PRG-BLK-4 = ", PROGRAMMING_LIST[4].encode('hex')
|
|
778
|
# print "PRG-BLK-5 = ", PROGRAMMING_LIST[5].encode('hex')
|
|
779
|
# print "PRG-BLK-6 = ", PROGRAMMING_LIST[6].encode('hex')
|
|
780
|
# print "PRG-BLK-7 = ", PROGRAMMING_LIST[7].encode('hex')
|
|
781
|
# print "PRG-BLK-8 = ", PROGRAMMING_LIST[8].encode('hex')
|
|
782
|
if options.SHOW_PROGRAMING == "False" and options.SHOW_FEATURE == "False" and options.SHOW_TUNE == "False":
|
|
783
|
print "no data shown"
|
|
784
|
|
|
785
|
|
|
786
|
|