เชนเซเชฒเซ เชนเซเชฌเซเชฐ. เชธเชเชญเชตเชคเช เชฆเชฐเซเช เชตเซเชฏเชเซเชคเชฟ เชเซ เชเซเชฃเซ เชเซเชฏเชพเชฐเซเชฏ เชธเชเชพเชเช เชเซ เชฎเชฟเชคเซเชฐเซเชจเซ เชชเซเชฒเซเชจเชฎเชพเช เชฎเชณเซเชฏเชพ เชนเซเชฏ เช เชฅเชตเชพ เชเซเชฏเชพ เชนเซเชฏ เชคเซเชฎเชฃเซ เชซเซเชฐเซ Flightradar24 เชธเซเชตเชพเชจเซ เชเชชเชฏเซเช เชเชฐเซเชฏเซ เชนเซเชฏ. เชตเชพเชธเซเชคเชตเชฟเช เชธเชฎเชฏเชฎเชพเช เชเชฐเชเซเชฐเชพเชซเซเชเชจเซ เชธเซเชฅเชฟเชคเชฟเชจเซ เชเซเชฐเซ เช เชเชฐเชตเชพเชจเซ เช เชเซเชฌ เช เช เชจเซเชเซเชณ เชฐเซเชค เชเซ.
ะ
ะััะพัะธั
เชฆเซเชเซเชคเซ เชฐเซเชคเซ, เชฏเซเชเชฐเซเชธเชจเซ เชคเซเชฎเชจเชพ เชธเซเชฎเชพเชฐเซเชเชซเซเชจ เชชเชฐ เชเซเชตเชพ เชฎเชพเชเซ เชเชฐเชเซเชฐเชพเชซเซเช เชกเซเชเชพ เชเซเชฐเชพเชจเซเชธเชฎเชฟเช เชฅเชคเซ เชจเชฅเซ. เชธเชฟเชธเซเชเชฎเชจเซ ADS-B (เชเชเซเชฎเซเชเชฟเช เชกเชฟเชชเซเชจเซเชกเชจเซเช เชธเชฐเซเชตเซเชฒเชจเซเชธ-เชฌเซเชฐเซเชกเชเชพเชธเซเช) เชเชนเซเชตเชพเชฎเชพเช เชเชตเซ เชเซ, เช เชจเซ เชคเซเชจเซ เชเชชเชฏเซเช เชเชฐเชเซเชฐเชพเชซเซเช เชตเชฟเชถเซเชจเซ เชฎเชพเชนเชฟเชคเซเชจเซ เชจเชฟเชฏเชเชคเซเชฐเชฃ เชเซเชจเซเชฆเซเชฐเชฎเชพเช เชเชชเชฎเซเชณเซ เชเซเชฐเชพเชจเซเชธเชฎเชฟเช เชเชฐเชตเชพ เชฎเชพเชเซ เชฅเชพเชฏ เชเซ - เชคเซเชจเชพ เชเชณเชเชเชฐเซเชคเชพ, เชเซเชเชฐเซเชกเชฟเชจเซเชเซเชธ, เชฆเชฟเชถเชพ, เชเชกเชช, เชเชเชเชพเช เช เชจเซ เช เชจเซเชฏ เชกเซเชเชพ เชเซเชฐเชพเชจเซเชธเชฎเชฟเช เชฅเชพเชฏ เชเซ. เช เชเชพเช, เชเชตเซ เชธเชฟเชธเซเชเชฎเซเชจเชพ เชเชเชฎเชจ เชชเชนเซเชฒเชพเช, เชฐเชตเชพเชจเชเซ เชฐเชกเชพเชฐ เชชเชฐ เชฎเชพเชคเซเชฐ เชเช เชฌเชฟเชเชฆเซ เชเซเช เชถเชเชคเซ เชนเชคเซ. เชเซเชฏเชพเชฐเซ เชเชฃเชพ เชฌเชงเชพ เชตเชฟเชฎเชพเชจเซ เชนเชคเชพ เชคเซเชฏเชพเชฐเซ เช เชชเซเชฐเชคเซเช เชจ เชนเชคเซเช.
เชคเชเชจเซเชเซ เชฐเซเชคเซ, ADS-B เชฎเชพเช เชเชฐเชเซเชฐเชพเชซเซเช เชชเชฐ เชเซเชฐเชพเชจเซเชธเชฎเซเชเชฐเชจเซ เชธเชฎเชพเชตเซเชถ เชฅเชพเชฏ เชเซ เชเซ เชธเชฎเชฏเชพเชเชคเชฐเซ 1090 MHz เชจเซ เชเชเชฆเชฎ เชเชเชเซ เชเชตเชฐเซเชคเชจ เชชเชฐ เชฎเชพเชนเชฟเชคเซเชจเชพ เชชเซเชเซเชเซ เชฎเซเชเชฒเซ เชเซ (เชคเซเชฏเชพเช เช เชจเซเชฏ เชฎเซเชกเซเชธ เชเซ, เชชเชฐเชเชคเซ เช เชฎเชจเซ เชคเซเชฎเชพเช เชเชเชฒเซ เชฐเซเชเชฟ เชจเชฅเซ, เชเชพเชฐเชฃ เชเซ เชเซเชเชฐเซเชกเชฟเชจเซเชเซเชธ เชซเชเซเชค เช เชนเซเช เช เชชเซเชฐเชธเชพเชฐเชฟเชค เชฅเชพเชฏ เชเซ). เช เชฒเชฌเชคเซเชค, เชเซเชฐเชพเชจเซเชธเชฎเซเชเชฐ เชเชชเชฐเชพเชเชค, เชเชฐเชชเซเชฐเซเช เชชเชฐ เชเซเชฏเชพเชเช เชฐเซเชธเซเชตเชฐ เชชเชฃ เชเซ, เชชเชฐเชเชคเซ เช เชฎเชพเชฐเชพ เชฎเชพเชเซ, เชตเชชเชฐเชพเชถเชเชฐเซเชคเชพเช เชคเชฐเซเชเซ, เชเชชเชฃเซเช เชชเซเชคเชพเชจเซเช เชฐเซเชธเซเชตเชฐ เชฐเชธเชชเซเชฐเชฆ เชเซ.
เชเซ เชเซ, เชธเชฐเชเชพเชฎเชฃเซ เชฎเชพเชเซ, เชเชตเซ เชชเซเชฐเชฅเชฎ เชธเชฟเชธเซเชเชฎ, เชเชฐเชจเชต เชฐเชกเชพเชฐเชฌเซเชเซเชธ, เชธเชพเชฎเชพเชจเซเชฏ เชตเชชเชฐเชพเชถเชเชฐเซเชคเชพเช เชฎเชพเชเซ เชกเชฟเชเชพเชเชจ เชเชฐเชตเชพเชฎเชพเช เชเชตเซ เชนเชคเซ, เชคเซ 2007 เชฎเชพเช เชฆเซเชเชพเช เชนเชคเซ, เช เชจเซ เชคเซเชจเซ เชเชฟเชเชฎเชค เชฒเชเชญเช $900 เชนเชคเซ; เชจเซเชเชตเชฐเซเช เชธเซเชตเชพเชเชจเชพ เชธเชฌเซเชธเซเชเซเชฐเชฟเชชเซเชถเชจ เชฎเชพเชเซ เชตเชฐเซเชทเซ เชฌเซเชเชพ $250เชจเซ เชเชฐเซเช เชฅเชพเชฏ เชเซ.
เชคเซ เชชเซเชฐเชฅเชฎ เชฐเชถเชฟเชฏเชจ เชฎเชพเชฒเชฟเชเซเชจเซ เชธเชฎเซเชเซเชทเชพเช เชซเซเชฐเชฎ เชชเชฐ เชตเชพเชเชเซ เชถเชเชพเชฏ เชเซ
เชธเชเชเซเชคเซ เชชเซเชฐเชพเชชเซเชค เชเชฐเซ เชฐเชนเซเชฏเชพ เชเซเช
เชชเซเชฐเชฅเชฎ, เชธเชฟเชเซเชจเชฒ เชฐเซเชเซเชฐเซเชก เชเชฐเชตเชพเชจเซ เชเชฐเซเชฐ เชเซ. เชธเชฎเชเซเชฐ เชธเชฟเชเซเชจเชฒเชจเซ เชธเชฎเชฏเชเชพเชณเซ เชฎเชพเชคเซเชฐ 120 เชฎเชพเชเชเซเชฐเซเชธเซเชเชจเซเชกเชจเซ เชเซ, เชคเซเชฅเซ เชคเซเชจเชพ เชเชเชเซเชจเซ เชเชฐเชพเชฎเชฅเซ เชกเชฟเชธเชเชธเซเชฎเซเชฌเชฒ เชเชฐเชตเชพ เชฎเชพเชเซ, เชเชเชพเชฎเชพเช เชเชเชพ 5 เชฎเซเชเชพเชนเชฐเซเชเชเชจเซ เชธเซเชฎเซเชชเชฒเชฟเชเช เชเชตเชฐเซเชคเชจ เชธเชพเชฅเซ เชเชธเชกเซเชเชฐ เชฐเซเชธเซเชตเชฐ เชเชเซเชเชจเซเชฏ เชเซ.
เชฐเซเชเซเชฐเซเชกเชฟเชเช เชเชฐเซเชฏเชพ เชชเชเซ, เช
เชฎเซ 5000000 เชจเชฎเซเชจเชพ/เชธเซเชเชเชกเชจเชพ เชจเชฎเซเชจเชพ เชฆเชฐ เชธเชพเชฅเซ WAV เชซเชพเชเชฒ เชชเซเชฐเชพเชชเซเชค เชเชฐเซเช เชเซเช; เชเชตเชพ เชฐเซเชเซเชฐเซเชกเชฟเชเชเชจเซ 30 เชธเซเชเชจเซเชกเชจเซเช "เชตเชเชจ" เชฒเชเชญเช 500MB เชเซ. เชฎเซเชกเชฟเชฏเชพ เชชเซเชฒเซเชฏเชฐ เชธเชพเชฅเซ เชคเซเชจเซ เชธเชพเชเชญเชณเชตเซเช, เช
เชฒเชฌเชคเซเชค, เชจเชเชพเชฎเซเช เชเซ - เชซเชพเชเชฒเชฎเชพเช เชงเซเชตเชจเชฟ เชจเชฅเซ, เชชเชฐเชเชคเซ เชธเซเชงเซ เชกเชฟเชเชฟเชเชพเชเชเซเชก เชฐเซเชกเชฟเชฏเซ เชธเชฟเชเซเชจเชฒ - เช เชฐเซเชคเซ เชธเซเชซเซเชเชตเซเชฐ เชจเชฟเชฐเซเชงเชพเชฐเชฟเชค เชฐเซเชกเชฟเชฏเซ เชเชพเชฐเซเชฏ เชเชฐเซ เชเซ.
เช
เชฎเซ Python เชจเซ เชเชชเชฏเซเช เชเชฐเซเชจเซ เชซเชพเชเชฒ เชเซเชฒเซเชถเซเช เช
เชจเซ เชชเซเชฐเชเซเชฐเชฟเชฏเชพ เชเชฐเซเชถเซเช. เชเซเช เชเชพเชคเซ เชชเซเชฐเชฏเซเช เชเชฐเชตเชพ เชฎเชพเชเซ เชเซ เชคเซเช เชเชฆเชพเชนเชฐเชฃ เชฐเซเชเซเชฐเซเชกเชฟเชเช เชกเชพเชเชจเชฒเซเชก เชเชฐเซ เชถเชเซ เชเซ
เชเชพเชฒเซ เชซเชพเชเชฒ เชกเชพเชเชจเชฒเซเชก เชเชฐเซเช เช เชจเซ เชเซเชเช เชเซ เช เชเชฆเชฐ เชถเซเช เชเซ.
from scipy.io import wavfile
import matplotlib.pyplot as plt
import numpy as np
fs, data = wavfile.read("adsb_20190311_191728Z_1090000kHz_RF.wav")
data = data.astype(float)
I, Q = data[:, 0], data[:, 1]
A = np.sqrt(I*I + Q*Q)
plt.plot(A)
plt.show()
เชชเชฐเชฟเชฃเชพเชฎ: เช เชฎเซ เชชเซเชทเซเช เชญเซเชฎเชฟ เช เชตเชพเช เชธเชพเชฎเซ เชธเซเชชเชทเซเช "เชชเชฒเซเชธ" เชเซเชเช เชเซเช.
เชฆเชฐเซเช "เชชเชฒเซเชธ" เช เชเช เชธเชฟเชเซเชจเชฒ เชเซ, เชเซ เชคเชฎเซ เชเซเชฐเชพเชซ เชชเชฐ เชฐเชฟเชเซเชฒเซเชฏเซเชถเชจ เชตเชงเชพเชฐเชถเซ เชคเซ เชคเซเชจเซเช เชฎเชพเชณเชเซเช เชธเซเชชเชทเซเชเชชเชฃเซ เชฆเซเชถเซเชฏเชฎเชพเชจ เชเซ.
เชเซเชฎ เชคเชฎเซ เชเซเช เชถเชเซ เชเซ, เชเชฟเชคเซเชฐ เชเชชเชฐเชจเชพ เชตเชฐเซเชฃเชจเชฎเชพเช เชเซ เชเชชเชตเชพเชฎเชพเช เชเชตเซเชฏเซเช เชเซ เชคเซเชจเซ เชธเชพเชฅเซ เชคเชฆเซเชฆเชจ เชธเซเชธเชเชเชค เชเซ. เชคเชฎเซ เชกเซเชเชพ เชชเชฐ เชชเซเชฐเชเซเชฐเชฟเชฏเชพ เชเชฐเชตเชพเชจเซเช เชถเชฐเซ เชเชฐเซ เชถเชเซ เชเซ.
เชกเซเชเซเชกเชฟเชเช
เชชเซเชฐเชฅเชฎ, เชคเชฎเชพเชฐเซ เชฅเซเชกเซ เชธเซเชเซเชฐเซเชฎ เชฎเซเชณเชตเชตเชพเชจเซ เชเชฐเซเชฐ เชเซ. เชธเชฟเชเซเชจเชฒ เชชเซเชคเซ เชฎเชพเชจเซเชเซเชธเซเชเชฐ เชเชจเซเชเซเชกเชฟเชเชเชจเซ เชเชชเชฏเซเช เชเชฐเซเชจเซ เชเชจเซเชเซเชก เชฅเชฏเซเชฒ เชเซ:
เชจเชฟเชฌเชฒเซเชธเชฎเชพเช เชธเซเชคเชฐเชจเชพ เชคเชซเชพเชตเชคเชฅเซ เชตเชพเชธเซเชคเชตเชฟเช โ0โ เช
เชจเซ โ1โ เชฎเซเชณเชตเชตเซเช เชธเชฐเชณ เชเซ.
bits_str = ""
for p in range(8):
pos = start_data + bit_len*p
p1, p2 = A[pos: pos + bit_len/2], A[pos + bit_len/2: pos + bit_len]
avg1, avg2 = np.average(p1), np.average(p2)
if avg1 < avg2:
bits_str += "0"
elif avg1 > avg2:
bits_str += "1"
เชธเชฟเชเซเชจเชฒเชจเซ เชฐเชเชจเชพ เชชเซเชคเซ เชจเซเชเซ เชฎเซเชเชฌ เชเซ:
เชเชพเชฒเซ เชเซเชทเซเชคเซเชฐเซเชจเซ เชตเชงเซ เชตเชฟเชเชคเชฎเชพเช เชเซเชเช.
DF (เชกเชพเชเชจเชฒเชฟเชเช เชซเซเชฐเซเชฎเซเช, 5 เชฌเชฟเชเซเชธ) - เชธเชเชฆเซเชถเชจเซ เชชเซเชฐเชเชพเชฐ เชจเชเซเชเซ เชเชฐเซ เชเซ. เชคเซเชฏเชพเช เชเชฃเชพ เชชเซเชฐเชเชพเชฐเซ เชเซ:
(
เช เชฎเชจเซ เชซเชเซเชค DF17 เชชเซเชฐเชเชพเชฐเชฎเชพเช เช เชฐเชธ เชเซ, เชเชพเชฐเชฃ เชเซ... เช เชคเซ เชเซ เชเซ เชตเชฟเชฎเชพเชจเชจเชพ เชเซเชเชฐเซเชกเชฟเชจเซเชเซเชธ เชงเชฐเชพเชตเซ เชเซ.
เชเชเชธเซเชเช (24 เชฌเชฟเชเซเชธ) - เชเชฐเชเซเชฐเชพเชซเซเชเชจเซ เชเชเชคเชฐเชฐเชพเชทเซเชเซเชฐเซเชฏ เช
เชจเชจเซเชฏ เชเซเชก. เชคเชฎเซ เชชเซเชฒเซเชจเชจเซ เชคเซเชจเชพ เชเซเชก เชฆเซเชตเชพเชฐเชพ เชเซเช เชเชฐเซ เชถเชเซ เชเซ
เชธเชเชชเชพเชฆเชฟเชค เชเชฐเซ: เชฎเชพเช
เชฎเชพเชนเชฟเชคเซ (56 เช เชฅเชตเชพ 112 เชฌเชฟเชเซเชธ) - เชตเชพเชธเซเชคเชตเชฟเช เชกเซเชเชพ เชเซ เชเซเชจเซ เชเชชเชฃเซ เชกเซเชเซเชก เชเชฐเซเชถเซเช. เชกเซเชเชพเชจเชพ เชชเซเชฐเชฅเชฎ 5 เชฌเชฟเชเซเชธ เชซเซเชฒเซเชก เชเซ เชชเซเชฐเชเชพเชฐ เชเซเชก, เชธเชเชเซเชฐเชนเชฟเชค เชเชฐเชตเชพเชฎเชพเช เชเชตเซ เชฐเชนเซเชฒเชพ เชกเซเชเชพเชจเชพ เชชเซเชเชพเชชเซเชฐเชเชพเชฐเชจเซ เชธเชฎเชพเชตเซ เชเซ (DF เชธเชพเชฅเซ เชฎเซเชเชเชตเชฃเชฎเชพเช เชจ เชเชตเซ). เชเชฎเชพเชเชจเชพ เชเชฃเชพ เชชเซเชฐเชเชพเชฐเซ เชเซ:
(
เชเชพเชฒเซ เชชเซเชเซเชเซเชจเชพ เชฅเซเชกเชพ เชเชฆเชพเชนเชฐเชฃเซ เชเซเชเช.
เชตเชฟเชฎเชพเชจเชจเซ เชเชณเช
เชฆเซเชตเชฟเชธเชเชเซ เชธเซเชตเชฐเซเชชเชฎเชพเช เชเชฆเชพเชนเชฐเชฃ:
00100 011 000101 010111 000111 110111 110001 111000
เชกเซเชเชพ เชซเซเชฒเซเชกเซเชธ:
+------+------+------+------+------+------+------+------+------+------+
| TC,5 | EC,3 | C1,6 | C2,6 | C3,6 | C4,6 | C5,6 | C6,6 | C7,6 | C8,6 |
+------+------+------+------+------+------+------+------+------+------+
TC = 00100b = 4, เชฆเชฐเซเช เช
เชเซเชทเชฐ C1-C8 เชฒเชพเชเชจเชฎเชพเช เชธเซเชเชเชพเชเชเซเชจเซ เช
เชจเซเชฐเซเชช เชเซเชก เชงเชฐเชพเชตเซ เชเซ:
#ABCDEFGHIJKLMNOPQRSTUVWXYZ####_###############0123456789#####
เชถเชฌเซเชฆเชฎเชพเชณเชพเชจเซ เชกเซเชเซเชก เชเชฐเซเชจเซ, เชเชฐเชเซเชฐเชพเชซเซเช เชเซเชก เชฎเซเชณเชตเชตเซ เชธเชฐเชณ เชเซ: EWG7184
symbols = "#ABCDEFGHIJKLMNOPQRSTUVWXYZ#####_###############0123456789######"
code_str = ""
for p in range(8):
c = int(bits_str[8 + 6*p:8 + 6*(p + 1)], 2)
code_str += symbols[c]
print("Aircraft Identification:", code_str.replace('#', ''))
เชเชฐเชฌเซเชฐเซเชจ เชธเซเชฅเชฟเชคเชฟ
เชเซ เชจเชพเชฎ เชธเชฐเชณ เชเซ, เชคเซ เชเซเชเชฐเซเชกเชฟเชจเซเชเซเชธ เชตเชงเซ เชเชเชฟเชฒ เชเซ. เชคเซเช 2, เชธเชฎเชพเชจ เช เชจเซ เชตเชฟเชเชฟเชคเซเชฐ เชซเซเชฐเซเชฎเชจเชพ เชธเซเชตเชฐเซเชชเชฎเชพเช เชชเซเชฐเชธเชพเชฐเชฟเชค เชฅเชพเชฏ เชเซ. เชซเซเชฒเซเชก เชเซเชก TC = 01011b = 11.
เชธเชฎ เช
เชจเซ เชตเชฟเชทเชฎ เชชเซเชเซเชเซเชจเซเช เชเชฆเชพเชนเชฐเชฃ:
01011 000 000101110110 00 10111000111001000 10000110101111001
01011 000 000110010000 01 10010011110000110 10000011110001000
เชเซเชเชฐเซเชกเชฟเชจเซเชเซเชธเชจเซ เชเชฃเชคเชฐเซ เชคเซเชจเชพ เชฌเชฆเชฒเซ เชฎเซเชถเซเชเซเชฒ เชธเซเชคเซเชฐ เช เชจเซเชธเชพเชฐ เชฅเชพเชฏ เชเซ:
เชนเซเช GIS โโเชจเชฟเชทเซเชฃเชพเชค เชจเชฅเซ, เชคเซเชฅเซ เชฎเชจเซ เชเชฌเชฐ เชจเชฅเซ เชเซ เชคเซ เชเซเชฏเชพเชเชฅเซ เชเชตเซ เชเซ. เชเซเชฃ เชเชพเชฃเซ เชเซ, เชเชฟเชชเซเชชเชฃเซเชเชฎเชพเช เชฒเชเซ.
เชเชเชเชพเชเชจเซ เชธเชฐเชณ เชเชฃเชตเชพเชฎเชพเช เชเชตเซ เชเซ - เชเซเชเซเชเชธ เชฌเซเชเชจเชพ เชเชงเชพเชฐเซ, เชคเซเชจเซ 25 เช เชฅเชตเชพ 100 เชซเซเชเชจเชพ เชเซเชฃเชพเชเช เชคเชฐเซเชเซ เชฐเชเซ เชเชฐเซ เชถเชเชพเชฏ เชเซ.
เชเชฐเชฌเซเชฐเซเชจ เชตเซเชฒเซเชธเซเชเซ
TC=19 เชธเชพเชฅเซเชจเซเช เชชเซเชเซเช. เช เชนเซเช เชฐเชธเชชเซเชฐเชฆ เชฌเชพเชฌเชค เช เชเซ เชเซ เชเชกเชช เชเชพเช เชคเซ เชธเชเซเช เชนเซเช เชถเชเซ เชเซ, เชเชฎเซเชจเชจเซ เชธเชพเชชเซเชเซเชท (เชเซเชฐเชพเชเชจเซเชก เชธเซเชชเซเชก), เช เชฅเชตเชพ เชเชฐเชฌเซเชฐเซเชจ, เชเชฐเชเซเชฐเชพเชซเซเช เชธเซเชจเซเชธเชฐ (เชเชฐเชธเซเชชเซเชก) เชฆเซเชตเชพเชฐเชพ เชฎเชพเชชเชตเชพเชฎเชพเช เชเชตเซ เชเซ. เชเชฃเชพเช เชตเชฟเชตเชฟเชง เชเซเชทเซเชคเซเชฐเซ เชชเชฃ เชชเซเชฐเชธเชพเชฐเชฟเชค เชฅเชพเชฏ เชเซ:
เชจเชฟเชทเซเชเชฐเซเชท
เชเซเชฎ เชคเชฎเซ เชเซเช เชถเชเซ เชเซ, ADS-B เชเซเชเซเชจเซเชฒเซเชเซ เช เชเช เชฐเชธเชชเซเชฐเชฆ เชธเชนเชเซเชตเชจ เชฌเชจเซ เชเชฏเซเช เชเซ, เชเซเชฏเชพเชฐเซ เชงเซเชฐเชฃ เชฎเชพเชคเซเชฐ เชตเซเชฏเชพเชตเชธเชพเชฏเชฟเชเซ เชฎเชพเชเซ เช เชจเชนเซเช, เชชเชฃ เชธเชพเชฎเชพเชจเซเชฏ เชตเชชเชฐเชพเชถเชเชฐเซเชคเชพเช เชฎเชพเชเซ เชชเชฃ เชเชชเชฏเซเชเซ เชเซ. เชชเชฐเชเชคเซ เช เชฒเชฌเชคเซเชค, เชเชฎเชพเช เชฎเซเชเซเชฏ เชญเซเชฎเชฟเชเชพ เชกเชฟเชเชฟเชเชฒ SDR เชฐเซเชธเซเชตเชฐเซเชจเซ เชธเชธเซเชคเซ เชคเชเชจเซเช เชฆเซเชตเชพเชฐเชพ เชญเชเชตเชตเชพเชฎเชพเช เชเชตเซ เชนเชคเซ, เชเซ เชเชชเชเชฐเชฃเชจเซ "เชชเซเชจเชฟเชธ เชฎเชพเชเซ" เชเซเชเชพเชนเชฐเซเชเซเชเชฅเซ เชเชชเชฐเชจเซ เชซเซเชฐเซเชเซเชตเชจเซเชธเซเช เชธเชพเชฅเซ เชถเชพเชฌเซเชฆเชฟเช เชฐเซเชคเซ เชธเชฟเชเซเชจเชฒ เชชเซเชฐเชพเชชเซเชค เชเชฐเชตเชพเชจเซ เชฎเชเชเซเชฐเซ เชเชชเซ เชเซ.
เชงเซเชฐเชฃเชฎเชพเช เช, เช
เชฒเชฌเชคเซเชค, เชคเซเชฏเชพเช เชเชฃเซเช เชฌเชงเซเช เชเซ. เชฐเชธ เชงเชฐเชพเชตเชคเชพ เชฒเซเชเซ เชชเซเชทเซเช เชชเชฐ เชชเซเชกเซเชเชซ เชเซเช เชถเชเซ เชเซ
เชคเซ เช เชธเชเชญเชตเชฟเชค เชเซ เชเซ เชเชชเชฐเซเชเซเชค เชคเชฎเชพเชฎ เชเชฃเชพ เชฒเซเชเซ เชฎเชพเชเซ เชเชชเชฏเซเชเซ เชฅเชถเซ, เชชเชฐเชเชคเซ เชคเซ เชเซเชตเซ เชฐเซเชคเซ เชเชพเชฐเซเชฏ เชเชฐเซ เชเซ เชคเซเชจเซ เชเชเชพเชฎเชพเช เชเชเซ เชธเชพเชฎเชพเชจเซเชฏ เชตเชฟเชเชพเชฐ, เชฎเชจเซ เชเชถเชพ เชเซ, เชฐเชนเซ เชเซ.
เชฎเชพเชฐเซเช เชฆเซเชตเชพเชฐเชพ, เชชเชพเชฏเชฅเซเชจเชฎเชพเช เชคเซเชฏเชพเชฐ เชกเซเชเซเชกเชฐ เชชเชนเซเชฒเซเชฅเซ เช เช
เชธเซเชคเชฟเชคเซเชตเชฎเชพเช เชเซ, เชคเชฎเซ เชคเซเชจเซ เช
เชญเซเชฏเชพเชธ เชเชฐเซ เชถเชเซ เชเซ
เชฒเซเชเชฎเชพเช เชตเชฐเซเชฃเชตเซเชฒ เชชเชพเชฐเซเชธเชฐเชจเซ เชธเซเชฐเซเชค เชเซเชก เชเชเชจเซ เชจเซเชเซ เชเชชเซเชฒ เชเซ. เช เชเช เชชเชฐเซเชเซเชทเชฃ เชเชฆเชพเชนเชฐเชฃ เชเซ เชเซ เชเชคเซเชชเชพเชฆเชจ เชนเซเชตเชพเชจเซ เชกเซเชณ เชเชฐเชคเซเช เชจเชฅเซ, เชชเชฐเชเชคเซ เชคเซเชฎเชพเช เชเซเชเชฒเซเช เชตเชธเซเชคเซเช เชเชพเชฎ เชเชฐเซ เชเซ, เช
เชจเซ เชคเซเชจเซ เชเชชเชฏเซเช เชเชชเชฐ เชฐเซเชเซเชฐเซเชก เชเชฐเซเชฒเซ เชซเชพเชเชฒเชจเซ เชชเชพเชฐเซเชธ เชเชฐเชตเชพ เชฎเชพเชเซ เชฅเช เชถเชเซ เชเซ.
เชธเซเชฐเซเชธ เชเซเชก (เชชเชพเชฏเชฅเซเชจ)
from __future__ import print_function
from scipy.io import wavfile
from scipy import signal
import matplotlib.pyplot as plt
import numpy as np
import math
import sys
def parse_message(data, start, bit_len):
max_len = bit_len*128
A = data[start:start + max_len]
A = signal.resample(A, 10*max_len)
bits = np.zeros(10*max_len)
bit_len *= 10
start_data = bit_len*8
# Parse first 8 bits
bits_str = ""
for p in range(8):
pos = start_data + bit_len*p
p1, p2 = A[pos: pos + bit_len/2], A[pos + bit_len/2: pos + bit_len]
avg1, avg2 = np.average(p1), np.average(p2)
if avg1 < avg2:
bits_str += "0"
elif avg1 > avg2:
bits_str += "1"
df = int(bits_str[0:5], 2)
# Aircraft address (db - https://junzis.com/adb/?q=3b1c5c )
bits_str = ""
for p in range(8, 32):
pos = start_data + bit_len * p
p1, p2 = A[pos: pos + bit_len / 2], A[pos + bit_len / 2: pos + bit_len]
avg1, avg2 = np.average(p1), np.average(p2)
if avg1 < avg2:
bits_str += "0"
elif avg1 > avg2:
bits_str += "1"
# print "Aircraft address:", bits_str, hex(int(bits_str, 2))
address = hex(int(bits_str, 2))
# Filter specific aircraft (optional)
# if address != "0x3c5ee2":
# return
if df == 16 or df == 17 or df == 18 or df == 19 or df == 20 or df == 21:
# print "Pos:", start, "DF:", msg_type
# Data (56bit)
bits_str = ""
for p in range(32, 88):
pos = start_data + bit_len*p
p1, p2 = A[pos: pos + bit_len/2], A[pos + bit_len/2: pos + bit_len]
avg1, avg2 = np.average(p1), np.average(p2)
if avg1 < avg2:
bits_str += "0"
# bits[pos + bit_len / 2] = 50
elif avg1 > avg2:
bits_str += "1"
# http://www.lll.lu/~edward/edward/adsb/DecodingADSBposition.html
# print "Data:"
# print bits_str[:8], bits_str[8:20], bits_str[20:22], bits_str[22:22+17], bits_str[39:39+17]
# Type Code:
tc, ec = int(bits_str[:5], 2), int(bits_str[5:8], 2)
# print("DF:", df, "TC:", tc)
# 1 - 4 Aircraft identification
# 5 - 8 Surface position
# 9 - 18 Airborne position (w/ Baro Altitude)
# 19 Airborne velocities
if tc >= 1 and tc <= 4: # and (df == 17 or df == 18):
print("Aircraft address:", address)
print("Data:")
print(bits_str[:8], bits_str[8:14], bits_str[14:20], bits_str[20:26], bits_str[26:32], bits_str[32:38], bits_str[38:44])
symbols = "#ABCDEFGHIJKLMNOPQRSTUVWXYZ#####_###############0123456789######"
code_str = ""
for p in range(8):
c = int(bits_str[8 + 6*p:8 + 6*(p + 1)], 2)
code_str += symbols[c]
print("Aircraft Identification:", code_str.replace('#', ''))
print()
if tc == 11:
print("Aircraft address:", address)
print("Data: (11)")
print(bits_str[:8], bits_str[8:20], bits_str[20:22], bits_str[22:22+17], bits_str[39:39+17])
# Bit 22 contains the F flag which indicates which CPR format is used (odd or even)
# First frame has F flag = 0 so is even and the second frame has F flag = 1 so odd
# f = bits_str[21:22]
# print("F:", int(f, 2))
# Altitude
alt1b = bits_str[8:20]
if alt1b[-5] == '1':
bits = alt1b[:-5] + alt1b[-4:]
n = int(bits, 2)
alt_ft = n*25 - 1000
print("Alt (ft)", alt_ft)
# lat_dec = int(bits_str[22:22+17], 2)
# lon_dec = int(bits_str[39:39+17], 2)
# print("Lat/Lon:", lat_dec, lon_dec)
# http://airmetar.main.jp/radio/ADS-B%20Decoding%20Guide.pdf
print()
if tc == 19:
print("Aircraft address:", address)
print("Data:")
# print(bits_str)
print(bits_str[:5], bits_str[5:8], bits_str[8:10], bits_str[10:13], bits_str[13] ,bits_str[14:24], bits_str[24], bits_str[25:35], bits_str[35:36], bits_str[36:65])
subtype = int(bits_str[5:8], 2)
# https://mode-s.org/decode/adsb/airborne-velocity.html
spd, hdg, rocd = -1, -1, -1
if subtype == 1 or subtype == 2:
print("Velocity Subtype 1: Ground speed")
v_ew_sign = int(bits_str[13], 2)
v_ew = int(bits_str[14:24], 2) - 1 # east-west velocity
v_ns_sign = int(bits_str[24], 2)
v_ns = int(bits_str[25:35], 2) - 1 # north-south velocity
v_we = -1*v_ew if v_ew_sign else v_ew
v_sn = -1*v_ns if v_ns_sign else v_ns
spd = math.sqrt(v_sn*v_sn + v_we*v_we) # unit in kts
hdg = math.atan2(v_we, v_sn)
hdg = math.degrees(hdg) # convert to degrees
hdg = hdg if hdg >= 0 else hdg + 360 # no negative val
if subtype == 3:
print("Subtype Subtype 3: Airspeed")
hdg = int(bits_str[14:24], 2)/1024.0*360.0
spd = int(bits_str[25:35], 2)
vr_sign = int(bits_str[36], 2)
vr = int(bits_str[36:45], 2)
rocd = -1*vr if vr_sign else vr # rate of climb/descend
print("Speed (kts):", spd, "Rate:", rocd, "Heading:", hdg)
print()
# print()
def calc_coordinates():
def _cprN(lat, is_odd):
nl = _cprNL(lat) - is_odd
return nl if nl > 1 else 1
def _cprNL(lat):
try:
nz = 15
a = 1 - math.cos(math.pi / (2 * nz))
b = math.cos(math.pi / 180.0 * abs(lat)) ** 2
nl = 2 * math.pi / (math.acos(1 - a/b))
return int(math.floor(nl))
except:
# happens when latitude is +/-90 degree
return 1
def floor_(x):
return int(math.floor(x))
lat1b, lon1b, alt1b = "10111000111010011", "10000110111111000", "000101111001"
lat2b, lon2b, alt2b = "10010011101011100", "10000011000011011", "000101110111"
lat1, lon1, alt1 = int(lat1b, 2), int(lon1b, 2), int(alt1b, 2)
lat2, lon2, alt2 = int(lat2b, 2), int(lon2b, 2), int(alt2b, 2)
# 131072 is 2^17, since CPR lat and lon are 17 bits each
cprlat_even, cprlon_even = lat1/131072.0, lon1/131072.0
cprlat_odd, cprlon_odd = lat2/131072.0, lon2/131072.0
print(cprlat_even, cprlon_even)
j = floor_(59*cprlat_even - 60*cprlat_odd)
print(j)
air_d_lat_even = 360.0 / 60
air_d_lat_odd = 360.0 / 59
# Lat
lat_even = float(air_d_lat_even * (j % 60 + cprlat_even))
lat_odd = float(air_d_lat_odd * (j % 59 + cprlat_odd))
if lat_even >= 270:
lat_even = lat_even - 360
if lat_odd >= 270:
lat_odd = lat_odd - 360
# Lon
ni = _cprN(lat_even, 0)
m = floor_(cprlon_even * (_cprNL(lat_even)-1) - cprlon_odd * _cprNL(lat_even) + 0.5)
lon = (360.0 / ni) * (m % ni + cprlon_even)
print("Lat", lat_even, "Lon", lon)
# Altitude
# Q-bit (bit 48) indicates whether the altitude is encoded in multiples of 25 or 100 ft (0: 100 ft, 1: 25 ft)
# The value can represent altitudes from -1000 to +50175 ft.
if alt1b[-5] == '1':
bits = alt1b[:-5] + alt1b[-4:]
n = int(bits, 2)
alt_ft = n*25 - 1000
print("Alt (ft)", alt_ft)
fs, data = wavfile.read("adsb_20190311_191728Z_1090000kHz_RF.wav")
T = 1/fs
print("Sample rate %f MS/s" % (fs / 1e6))
print("Cnt samples %d" % len(data))
print("Duration: %f s" % (T * len(data)))
data = data.astype(float)
cnt = data.shape[0]
# Processing only part on file (faster):
# cnt = 10000000
# data = data[:cnt]
print("Processing I/Q...")
I, Q = data[:, 0], data[:, 1]
A = np.sqrt(I*I + Q*Q)
bits = np.zeros(cnt)
# To see scope without any processing, uncomment
# plt.plot(A)
# plt.show()
# sys.exit(0)
print("Extracting signals...")
pos = 0
avg = 200
msg_start = 0
# Find beginning of each signal
while pos < cnt - 16*1024:
# P1 - message start
while pos < cnt - 16*1024:
if A[pos] < avg and A[pos+1] > avg and pos - msg_start > 1000:
msg_start = pos
bits[pos] = 100
pos += 4
break
pos += 1
start1, start2, start3, start4 = msg_start, 0, 0, 0
# P2
while pos < cnt - 16*1024:
if A[pos] < avg and A[pos+1] > avg:
start2 = pos
bits[pos] = 90
pos += 1
break
pos += 1
# P3
while pos < cnt - 16*1024:
if A[pos] < avg and A[pos+1] > avg:
start3 = pos
bits[pos] = 80
pos += 1
break
pos += 1
# P4
while pos < cnt - 16*1024:
if A[pos] < avg and A[pos+1] > avg:
start4 = pos
bits[pos] = 70
pos += 1
break
pos += 1
sig_diff = start4 - start1
if 20 < sig_diff < 25:
bits[msg_start] = 500
bit_len = int((start4 - start1) / 4.5)
# print(pos, start1, start4, ' - ', bit_len)
# start = start1 + 8*bit_len
parse_message(A, msg_start, bit_len)
pos += 450
# For debugging: check signal start
# plt.plot(A)
# plt.plot(bits)
# plt.show()
เชฎเชจเซ เชเชถเชพ เชเซ เชเซ เชเซเชเชจเซ เชฐเชธ เชนเชคเซ, เชคเชฎเชพเชฐเชพ เชงเซเชฏเชพเชจ เชฌเชฆเชฒ เชเชญเชพเชฐ.
เชธเซเชฐเซเชธ: www.habr.com