Revisión de packet-finder.py

Lucas Teske revisó este gist 9 years ago. Ir a la revisión

1 file changed, 77 insertions, 60 deletions

packet-finder.py

			@@ -3,30 +3,33 @@
3	3		import os, math
4	4		import collections
5	5
	6	+	ifile = "sample.s" #"sample.s"
	7	+	ofile = "sample.s.out"#"sample.s.out"
	8	+	skipi = 0 #4800
	9	+
6	10		'''
7	11		Sync Words Phased
8	12
9	13		0 = 00011010 11001111 11111100 00011101 = 0x1ACFFC1D
10		-	1 = 10001111 01010101 01010110 10000100 = 0x8F555684
	14	+	1 = 10001111 01100101 01010110 10000100 = 0x8F655684
11	15		2 = 11100101 00110000 00000011 11100010 = 0xE53003E2
12		-	3 = 01110000 10101010 10101001 01111011 = 0x70AAA97B
13		-	'''
	16	+	3 = 01110000 10011010 10101001 01111011 = 0x709AA97B
	17	+
	18	+
	19	+
	20	+	10001111 01100101 01010110 10000100
	21	+	01110000 10011010 10101001 01111011
14	22
15	23		'''
16		-	Sync Words 1/2 Symbols
17		-	0 = 00000011 11001100 11110000 11111111 11111111 11110000 00000011 11110011 = 0x03CCF0FFFFF030F3
18		-	1 = 11000000 11111111 00110011 00110011 00110011 00111100 11000000 00110000 = 0xC0FF3333333CC030
19		-	2 = 11111100 00110011 00001111 00000000 00000000 00001111 11111100 00001100 = 0xFC33F00000F0FCC0
20		-	3 = 00111111 00000000 11001100 11001100 11001100 11000011 00111111 11001111 = 0x3F00CCCCCCC33FCF
21		-
22		-	00000011 11001100 11110000 11111111 11111111 11110000 00000011 11110011
23		-	S = 00000011 10010010 11100011 01010100 11100111 10100111 11010100 00010101
24		-
25		-	11111100 00110011 00001111 00000000 00000000 00001111 11111100 00001100
26		-	F = 11111100 01101101 00011100 10101011 00011000 01011000 00101011 11101010
27		-	00000011 10010010 11100011 01010100 11100111 10100111 11010100 00010101
	24	+
28	25		'''
	26	+	Sync Word in 1/2 k=7 FEC:
29	27
	28	+	1111 1100 1010 0010 1011 0110 0011 1101 1011 0000 0000 1101 1001 0111 1001 0100 0xfca2b63db00d9794
	29	+	0101 0110 1111 1011 1101 0011 1001 0100 1101 1010 1010 0100 1100 0001 1100 0010 0x56fbd394daa4c1c2
	30	+	0000 0011 0101 1101 0100 1001 1100 0010 0100 1111 1111 0010 0110 1000 0110 1011 0x035d49c24ff2686b
	31	+	1010 1001 0000 0100 0010 1100 0110 1011 0010 0101 0101 1011 0011 1110 0011 1101 0xa9042c6b255b3e3d
	32	+	'''
30	33
31	34		'''
32	35		Frame Size = 1024 bytes (1020 + 4)
			@@ -41,12 +44,12 @@ frameSymbolSize = 1024 * 8
41	44		frameInputSize = frameSymbolSize * 2
42	45		frameBitSize = frameSymbolSize * 2
43	46		syncWordSize = 32
44		-	syncWordDoubleSize = syncWordSize * 2
	47	+	syncWordDoubleSize = 64
45	48
46		-	UW0 = 0x03CCF0FFFFF030F3
47		-	UW1 = 0xC0FF3333333CC030
48		-	UW2 = 0xFC33F00000F0FCC0
49		-	UW3 = 0x3F00CCCCCCC33FCF
	49	+	UW0 = 0xfca2b63db00d9794
	50	+	UW1 = 0x56fbd394daa4c1c2
	51	+	UW2 = 0x035d49c24ff2686b
	52	+	UW3 = 0xa9042c6b255b3e3d
50	53
51	54		def processFrame(frameData, n):
52	55		'''
			@@ -66,8 +69,8 @@ def processFrame(frameData, n):
66	69		if n == 1 or n == 3: # 90 / 270 phase
67	70		# We can just shift to 90 and if its 270 we invert the bits later
68	71		for i in range(0, len(frameData), 2):
69		-	a = 1 if frameData[i+1] == 0 else 1
70		-	b = 1 if frameData[i] == 0 else 1
	72	+	a = 1 if frameData[i+1] == 0 else 0
	73	+	b = 0 if frameData[i] == 0 else 1
71	74		frameData[i] = a
72	75		frameData[i+1] = b
73	76
			@@ -104,8 +107,8 @@ def processFrameBitMap(frameData, n):
104	107		if n == 1 or n == 3: # 90 / 270 phase
105	108		# We can just shift to 90 and if its 270 we invert the bits later
106	109		for i in range(0, len(frameData), 2):
107		-	a = 1 if frameData[i+1] == 0 else 1
108		-	b = 1 if frameData[i] == 0 else 1
	110	+	a = 0 if frameData[i+1] == 0 else 1
	111	+	b = 1 if frameData[i] == 0 else 0
109	112		frameData[i] = a
110	113		frameData[i+1] = b
111	114
			@@ -116,6 +119,8 @@ def processFrameBitMap(frameData, n):
116	119		bdata = ""
117	120		for i in range(0, len(frameData)):
118	121		bdata += chr(0xFF) if frameData[i] == 1 else chr(0x00)
	122	+	#bdata += chr(0xFF) if frameData[i] == 1 else chr(0x00)
	123	+	#bdata += chr(0xFF) if frameData[i] == 1 else chr(0x00)
119	124		return bdata
120	125
121	126		def invertBits(frame):
			@@ -135,10 +140,17 @@ def binStringToIntArr(b):
135	140		a.append(int(i))
136	141		return a
137	142
	143	+	invertIQ = False
	144	+
138	145		def symbolToBit(symbol):
139	146		bdata = []
140		-	I = ord(symbol[0]) - 127
141		-	Q = ord(symbol[1]) - 127
	147	+	if not invertIQ:
	148	+	I = ord(symbol[0]) - 127
	149	+	Q = ord(symbol[1]) - 127
	150	+	else:
	151	+	I = ord(symbol[1]) - 127
	152	+	Q = ord(symbol[0]) - 127
	153	+
142	154		if I > 0:
143	155		bdata.append(1)
144	156		else:
			@@ -166,12 +178,12 @@ def checkCorrelationInBuffer():
166	178		uw1c = 0
167	179		uw2c = 0
168	180		uw3c = 0
169		-	# To get the highest correlation, we xor with the inverse of the word. So 180 phase
	181	+	# To get the highest correlation, we xor with the word. So 180 phase
170	182		for k in range(0, syncWordDoubleSize):
171		-	uw0c += sbits[i+k] ^ UW2[k]
172		-	uw1c += sbits[i+k] ^ UW3[k]
173		-	uw2c += sbits[i+k] ^ UW0[k]
174		-	uw3c += sbits[i+k] ^ UW1[k]
	183	+	uw0c += sbits[i+k] ^ UW0[k]
	184	+	uw1c += sbits[i+k] ^ UW1[k]
	185	+	uw2c += sbits[i+k] ^ UW2[k]
	186	+	uw3c += sbits[i+k] ^ UW3[k]
175	187
176	188		uw0p = i if uw0c > uw0mc else uw0p
177	189		uw1p = i if uw1c > uw1mc else uw1p
			@@ -191,16 +203,20 @@ UW1 = binStringToIntArr(binary(UW1, syncWordDoubleSize))
191	203		UW2 = binStringToIntArr(binary(UW2, syncWordDoubleSize))
192	204		UW3 = binStringToIntArr(binary(UW3, syncWordDoubleSize))
193	205
194		-	f = open("test.s", "r")
195		-	fsize = os.path.getsize("test.s")
196		-	o = open("test.s.out", "w")
197		-	ob = open("test.s.outbit", "w")
	206	+	#f = open("test.s", "r")
	207	+	f = open(ifile, "r")
	208	+	fsize = os.path.getsize(ifile)
	209	+	o = open(ofile, "w")
	210	+	ob = open(ofile + "bit", "w")
198	211
199	212		sbits = collections.deque(maxlen=frameBitSize)
200	213
201	214		count = 0
202	215		fcount = 0
203	216
	217	+	f.seek(skipi)
	218	+	count += skipi
	219	+
204	220		print "Frame Input Size: %s" %frameInputSize
205	221
206	222		while count < fsize:
			@@ -237,31 +253,32 @@ while count < fsize:
237	253		print "Max Correlation with 270 degrees Word at %s" % uw3p
238	254		n = 3
239	255		p = uw3p
240		-
241		-	'''
242		-	Read p bits for syncing the Circle Buffer
243		-	Each pair of bits come from 2 bytes of the input
244		-	So we will read 1 byte per bit
245		-	'''
246		-	#t = p if p % 2 == 0 else p + 1
247		-	#data = f.read(t)
248		-	#for i in range(0, t, 2):
249		-	# b = symbolToBit(data[i:i+2])
250		-	# sbits.append(b[0])
251		-	# sbits.append(b[1])
252		-
253		-	print "B: " + str(list(sbits)[p:p+64])
254		-	print "W: " + str(UW0)
255		-
256		-	'''
257		-	Now we should have everything in sync
258		-	'''
259		-	#frame = processFrame(list(sbits), n)
260		-	#o.write(frame)
261		-	#frameb = processFrameBitMap(list(sbits), n)
262		-	#ob.write(frameb)
263		-	fcount += 1
264		-	count += frameInputSize #+ t
	256	+	if mp < 47:
	257	+	print "Frame Lock Error"
	258	+	count += frameInputSize
	259	+	else:
	260	+	'''
	261	+	Read p bits for syncing the Circle Buffer
	262	+	Each pair of bits come from 2 bytes of the input
	263	+	So we will read 1 byte per bit
	264	+	'''
	265	+	#p -= 12
	266	+	t = p if p % 2 == 0 else p + 1
	267	+	data = f.read(t)
	268	+	for i in range(0, t, 2):
	269	+	b = symbolToBit(data[i:i+2])
	270	+	sbits.append(b[0])
	271	+	sbits.append(b[1])
	272	+
	273	+	'''
	274	+	Now we should have everything in sync
	275	+	'''
	276	+	frame = processFrame(list(sbits), n)
	277	+	o.write(frame)
	278	+	frameb = processFrameBitMap(list(sbits), n)
	279	+	ob.write(frameb)
	280	+	fcount += 1
	281	+	count += frameInputSize + t
265	282
266	283		'''
267	284		Clean everything

Lucas Teske revisó este gist 9 years ago. Ir a la revisión

1 file changed, 272 insertions

packet-finder.py(archivo creado)

		@@ -0,0 +1,272 @@
1	+	#!/usr/bin/env python
2	+
3	+	import os, math
4	+	import collections
5	+
6	+	'''
7	+	Sync Words Phased
8	+
9	+	0 = 00011010 11001111 11111100 00011101 = 0x1ACFFC1D
10	+	1 = 10001111 01010101 01010110 10000100 = 0x8F555684
11	+	2 = 11100101 00110000 00000011 11100010 = 0xE53003E2
12	+	3 = 01110000 10101010 10101001 01111011 = 0x70AAA97B
13	+	'''
14	+
15	+	'''
16	+	Sync Words 1/2 Symbols
17	+	0 = 00000011 11001100 11110000 11111111 11111111 11110000 00000011 11110011 = 0x03CCF0FFFFF030F3
18	+	1 = 11000000 11111111 00110011 00110011 00110011 00111100 11000000 00110000 = 0xC0FF3333333CC030
19	+	2 = 11111100 00110011 00001111 00000000 00000000 00001111 11111100 00001100 = 0xFC33F00000F0FCC0
20	+	3 = 00111111 00000000 11001100 11001100 11001100 11000011 00111111 11001111 = 0x3F00CCCCCCC33FCF
21	+
22	+	00000011 11001100 11110000 11111111 11111111 11110000 00000011 11110011
23	+	S = 00000011 10010010 11100011 01010100 11100111 10100111 11010100 00010101
24	+
25	+	11111100 00110011 00001111 00000000 00000000 00001111 11111100 00001100
26	+	F = 11111100 01101101 00011100 10101011 00011000 01011000 00101011 11101010
27	+	00000011 10010010 11100011 01010100 11100111 10100111 11010100 00010101
28	+	'''
29	+
30	+
31	+	'''
32	+	Frame Size = 1024 bytes (1020 + 4)
33	+	Rate = 1/2
34	+	Frame Symbol Size = 1024 * 8 * 2
35	+
36	+	Input = IQ Byte. Symbol = 2 Byte
37	+	Frame Input Size = 1024 * 8 * 2 * 2
38	+	'''
39	+
40	+	frameSymbolSize = 1024 * 8
41	+	frameInputSize = frameSymbolSize * 2
42	+	frameBitSize = frameSymbolSize * 2
43	+	syncWordSize = 32
44	+	syncWordDoubleSize = syncWordSize * 2
45	+
46	+	UW0 = 0x03CCF0FFFFF030F3
47	+	UW1 = 0xC0FF3333333CC030
48	+	UW2 = 0xFC33F00000F0FCC0
49	+	UW3 = 0x3F00CCCCCCC33FCF
50	+
51	+	def processFrame(frameData, n):
52	+	'''
53	+	Gets the bit array, corrects the phase ambiguity and returns a byte array
54	+	frameData = bit array
55	+	n = phase number(0 = 0, 1 = 90, 2 = 180, 3 = 270)
56	+	'''
57	+	# Fix Ambiguity
58	+	'''
59	+	p0 p1 p2 p3
60	+	00 10 11 01
61	+	01 00 10 11
62	+	11 01 00 10
63	+	10 11 01 00
64	+	'''
65	+
66	+	if n == 1 or n == 3: # 90 / 270 phase
67	+	# We can just shift to 90 and if its 270 we invert the bits later
68	+	for i in range(0, len(frameData), 2):
69	+	a = 1 if frameData[i+1] == 0 else 1
70	+	b = 1 if frameData[i] == 0 else 1
71	+	frameData[i] = a
72	+	frameData[i+1] = b
73	+
74	+	if n == 2 or n == 3: # 180 / 270 is 0 / 90 inverted
75	+	frameData = invertBits(frameData)
76	+
77	+	# Generate byte array
78	+	bdata = ""
79	+	for i in range(0, len(frameData), 8):
80	+	v = 0
81	+	for k in range(0, 8):
82	+	v = v << 1
83	+	v = v \| frameData[i+k]
84	+	bdata += chr(v)
85	+
86	+	return bdata
87	+
88	+
89	+	def processFrameBitMap(frameData, n):
90	+	'''
91	+	Gets the bit array, corrects the phase ambiguity and returns a byte array
92	+	frameData = bit array
93	+	n = phase number(0 = 0, 1 = 90, 2 = 180, 3 = 270)
94	+	'''
95	+	# Fix Ambiguity
96	+	'''
97	+	p0 p1 p2 p3
98	+	00 10 11 01
99	+	01 00 10 11
100	+	11 01 00 10
101	+	10 11 01 00
102	+	'''
103	+
104	+	if n == 1 or n == 3: # 90 / 270 phase
105	+	# We can just shift to 90 and if its 270 we invert the bits later
106	+	for i in range(0, len(frameData), 2):
107	+	a = 1 if frameData[i+1] == 0 else 1
108	+	b = 1 if frameData[i] == 0 else 1
109	+	frameData[i] = a
110	+	frameData[i+1] = b
111	+
112	+	if n == 2 or n == 3: # 180 / 270 is 0 / 90 inverted
113	+	frameData = invertBits(frameData)
114	+
115	+	# Generate byte array
116	+	bdata = ""
117	+	for i in range(0, len(frameData)):
118	+	bdata += chr(0xFF) if frameData[i] == 1 else chr(0x00)
119	+	return bdata
120	+
121	+	def invertBits(frame):
122	+	for i in range(0, len(frame)):
123	+	frame[i] = 1 if frame[i] == 0 else 0
124	+
125	+	return frame
126	+
127	+	def binary(num, length=8):
128	+	return format(num, '#0{}b'.format(length + 2))
129	+
130	+	def binStringToIntArr(b):
131	+	if b[1] == 'b':
132	+	b = b[2:]
133	+	a = []
134	+	for i in b:
135	+	a.append(int(i))
136	+	return a
137	+
138	+	def symbolToBit(symbol):
139	+	bdata = []
140	+	I = ord(symbol[0]) - 127
141	+	Q = ord(symbol[1]) - 127
142	+	if I > 0:
143	+	bdata.append(1)
144	+	else:
145	+	bdata.append(0)
146	+
147	+	if Q > 0:
148	+	bdata.append(1)
149	+	else:
150	+	bdata.append(0)
151	+
152	+	return bdata
153	+
154	+	def checkCorrelationInBuffer():
155	+	uw0mc = 0 # Highest Correlation Factor for UW0
156	+	uw0p = 0 # Highest Correlation Position for UW0
157	+	uw1mc = 0
158	+	uw1p = 0
159	+	uw2mc = 0
160	+	uw2p = 0
161	+	uw3mc = 0
162	+	uw3p = 0
163	+
164	+	for i in range(0, frameBitSize - syncWordDoubleSize):
165	+	uw0c = 0
166	+	uw1c = 0
167	+	uw2c = 0
168	+	uw3c = 0
169	+	# To get the highest correlation, we xor with the inverse of the word. So 180 phase
170	+	for k in range(0, syncWordDoubleSize):
171	+	uw0c += sbits[i+k] ^ UW2[k]
172	+	uw1c += sbits[i+k] ^ UW3[k]
173	+	uw2c += sbits[i+k] ^ UW0[k]
174	+	uw3c += sbits[i+k] ^ UW1[k]
175	+
176	+	uw0p = i if uw0c > uw0mc else uw0p
177	+	uw1p = i if uw1c > uw1mc else uw1p
178	+	uw2p = i if uw2c > uw2mc else uw2p
179	+	uw3p = i if uw3c > uw3mc else uw3p
180	+
181	+	uw0mc = uw0c if uw0c > uw0mc else uw0mc
182	+	uw1mc = uw1c if uw1c > uw1mc else uw1mc
183	+	uw2mc = uw2c if uw2c > uw2mc else uw2mc
184	+	uw3mc = uw3c if uw3c > uw3mc else uw3mc
185	+
186	+	return uw0p, uw0mc, uw1p, uw1mc, uw2p, uw2mc, uw3p, uw3mc
187	+
188	+
189	+	UW0 = binStringToIntArr(binary(UW0, syncWordDoubleSize))
190	+	UW1 = binStringToIntArr(binary(UW1, syncWordDoubleSize))
191	+	UW2 = binStringToIntArr(binary(UW2, syncWordDoubleSize))
192	+	UW3 = binStringToIntArr(binary(UW3, syncWordDoubleSize))
193	+
194	+	f = open("test.s", "r")
195	+	fsize = os.path.getsize("test.s")
196	+	o = open("test.s.out", "w")
197	+	ob = open("test.s.outbit", "w")
198	+
199	+	sbits = collections.deque(maxlen=frameBitSize)
200	+
201	+	count = 0
202	+	fcount = 0
203	+
204	+	print "Frame Input Size: %s" %frameInputSize
205	+
206	+	while count < fsize:
207	+	'''
208	+	Read the data from input to sbits
209	+	'''
210	+	data = f.read(frameInputSize)
211	+	for i in range(0, frameInputSize, 2):
212	+	b = symbolToBit(data[i:i+2])
213	+	sbits.append(b[0])
214	+	sbits.append(b[1])
215	+
216	+	'''
217	+	Search for the sync word using correlation
218	+	'''
219	+
220	+	uw0p, uw0mc, uw1p, uw1mc, uw2p, uw2mc, uw3p, uw3mc = checkCorrelationInBuffer()
221	+	mp = max(uw0mc, uw1mc, uw2mc, uw3mc)
222	+	print "Frame: #%s" %fcount
223	+	print "Max Correlation: %s" %mp
224	+	if mp == uw0mc:
225	+	print "Max Correlation with 0 degrees Word at %s" % uw0p
226	+	n = 0
227	+	p = uw0p
228	+	elif mp == uw1mc:
229	+	print "Max Correlation with 90 degrees Word at %s" % uw1p
230	+	n = 1
231	+	p = uw1p
232	+	elif mp == uw2mc:
233	+	print "Max Correlation with 180 degrees Word at %s" % uw2p
234	+	n = 2
235	+	p = uw2p
236	+	elif mp == uw3mc:
237	+	print "Max Correlation with 270 degrees Word at %s" % uw3p
238	+	n = 3
239	+	p = uw3p
240	+
241	+	'''
242	+	Read p bits for syncing the Circle Buffer
243	+	Each pair of bits come from 2 bytes of the input
244	+	So we will read 1 byte per bit
245	+	'''
246	+	#t = p if p % 2 == 0 else p + 1
247	+	#data = f.read(t)
248	+	#for i in range(0, t, 2):
249	+	# b = symbolToBit(data[i:i+2])
250	+	# sbits.append(b[0])
251	+	# sbits.append(b[1])
252	+
253	+	print "B: " + str(list(sbits)[p:p+64])
254	+	print "W: " + str(UW0)
255	+
256	+	'''
257	+	Now we should have everything in sync
258	+	'''
259	+	#frame = processFrame(list(sbits), n)
260	+	#o.write(frame)
261	+	#frameb = processFrameBitMap(list(sbits), n)
262	+	#ob.write(frameb)
263	+	fcount += 1
264	+	count += frameInputSize #+ t
265	+
266	+	'''
267	+	Clean everything
268	+	'''
269	+
270	+	f.close()
271	+	o.close()
272	+	ob.close()

Siguiente Anterior