ಹಲೋ ಹಬ್ರ್. ಬಹುಶಃ ವಿಮಾನದಲ್ಲಿ ಸಂಬಂಧಿಕರು ಅಥವಾ ಸ್ನೇಹಿತರನ್ನು ಭೇಟಿಯಾದ ಅಥವಾ ನೋಡಿದ ಪ್ರತಿಯೊಬ್ಬರೂ ಉಚಿತ Flightradar24 ಸೇವೆಯನ್ನು ಬಳಸಿದ್ದಾರೆ. ನೈಜ ಸಮಯದಲ್ಲಿ ವಿಮಾನದ ಸ್ಥಾನವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಇದು ತುಂಬಾ ಅನುಕೂಲಕರ ಮಾರ್ಗವಾಗಿದೆ.
В ಅಂತಹ ಆನ್ಲೈನ್ ಸೇವೆಯ ಕಾರ್ಯಾಚರಣೆಯ ತತ್ವವನ್ನು ವಿವರಿಸಲಾಗಿದೆ. ನಾವು ಈಗ ಮುಂದುವರಿಯುತ್ತೇವೆ ಮತ್ತು ವಿಮಾನದಿಂದ ಸ್ವೀಕರಿಸುವ ನಿಲ್ದಾಣಕ್ಕೆ ಯಾವ ಡೇಟಾವನ್ನು ಕಳುಹಿಸಲಾಗುತ್ತಿದೆ ಮತ್ತು ಸ್ವೀಕರಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಪೈಥಾನ್ ಬಳಸಿ ಅದನ್ನು ನಾವೇ ಡಿಕೋಡ್ ಮಾಡುತ್ತೇವೆ.
История
ನಿಸ್ಸಂಶಯವಾಗಿ, ಬಳಕೆದಾರರು ತಮ್ಮ ಸ್ಮಾರ್ಟ್‌ಫೋನ್‌ಗಳಲ್ಲಿ ನೋಡಲು ವಿಮಾನ ಡೇಟಾವನ್ನು ರವಾನಿಸುವುದಿಲ್ಲ. ವ್ಯವಸ್ಥೆಯನ್ನು ADS-B (ಸ್ವಯಂಚಾಲಿತ ಅವಲಂಬಿತ ಕಣ್ಗಾವಲು-ಪ್ರಸಾರ) ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ವಿಮಾನದ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ನಿಯಂತ್ರಣ ಕೇಂದ್ರಕ್ಕೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರವಾನಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ - ಅದರ ಗುರುತಿಸುವಿಕೆ, ನಿರ್ದೇಶಾಂಕಗಳು, ನಿರ್ದೇಶನ, ವೇಗ, ಎತ್ತರ ಮತ್ತು ಇತರ ಡೇಟಾವನ್ನು ರವಾನಿಸಲಾಗುತ್ತದೆ. ಹಿಂದೆ, ಅಂತಹ ವ್ಯವಸ್ಥೆಗಳ ಆಗಮನದ ಮೊದಲು, ರವಾನೆದಾರನು ರಾಡಾರ್ನಲ್ಲಿ ಒಂದು ಬಿಂದುವನ್ನು ಮಾತ್ರ ನೋಡಬಹುದು. ಹೆಚ್ಚು ವಿಮಾನಗಳು ಇದ್ದಾಗ ಇದು ಸಾಕಾಗಲಿಲ್ಲ.
ತಾಂತ್ರಿಕವಾಗಿ, ADS-B ವಿಮಾನದಲ್ಲಿ ಟ್ರಾನ್ಸ್ಮಿಟರ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಅದು ನಿಯತಕಾಲಿಕವಾಗಿ 1090 MHz ನ ಹೆಚ್ಚಿನ ಆವರ್ತನದಲ್ಲಿ ಮಾಹಿತಿಯ ಪ್ಯಾಕೆಟ್‌ಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ (ಇತರ ವಿಧಾನಗಳಿವೆ, ಆದರೆ ನಾವು ಅವುಗಳಲ್ಲಿ ಹೆಚ್ಚು ಆಸಕ್ತಿ ಹೊಂದಿಲ್ಲ, ಏಕೆಂದರೆ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಇಲ್ಲಿ ಮಾತ್ರ ರವಾನಿಸಲಾಗುತ್ತದೆ). ಸಹಜವಾಗಿ, ಟ್ರಾನ್ಸ್ಮಿಟರ್ ಜೊತೆಗೆ, ವಿಮಾನ ನಿಲ್ದಾಣದಲ್ಲಿ ಎಲ್ಲೋ ರಿಸೀವರ್ ಕೂಡ ಇದೆ, ಆದರೆ ನಮಗೆ, ಬಳಕೆದಾರರಾಗಿ, ನಮ್ಮ ಸ್ವಂತ ರಿಸೀವರ್ ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ.
ಅಂದಹಾಗೆ, ಹೋಲಿಕೆಗಾಗಿ, ಸಾಮಾನ್ಯ ಬಳಕೆದಾರರಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಏರ್‌ನಾವ್ ರಾಡಾರ್‌ಬಾಕ್ಸ್ ಅಂತಹ ಮೊದಲ ವ್ಯವಸ್ಥೆಯು 2007 ರಲ್ಲಿ ಕಾಣಿಸಿಕೊಂಡಿತು ಮತ್ತು ಸುಮಾರು $900 ವೆಚ್ಚವಾಗುತ್ತದೆ; ನೆಟ್‌ವರ್ಕ್ ಸೇವೆಗಳಿಗೆ ಚಂದಾದಾರಿಕೆಯು ವರ್ಷಕ್ಕೆ ಮತ್ತೊಂದು $250 ವೆಚ್ಚವಾಗುತ್ತದೆ.
ಆ ಮೊದಲ ರಷ್ಯಾದ ಮಾಲೀಕರ ವಿಮರ್ಶೆಗಳನ್ನು ವೇದಿಕೆಯಲ್ಲಿ ಓದಬಹುದು . ಈಗ RTL-SDR ರಿಸೀವರ್‌ಗಳು ವ್ಯಾಪಕವಾಗಿ ಲಭ್ಯವಿವೆ, ಇದೇ ರೀತಿಯ ಸಾಧನವನ್ನು $30 ಗೆ ಜೋಡಿಸಬಹುದು; ಇದರ ಬಗ್ಗೆ ಹೆಚ್ಚಿನವು . ಪ್ರೋಟೋಕಾಲ್ಗೆ ಹೋಗೋಣ - ಅದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ನೋಡೋಣ.
ಸಂಕೇತಗಳನ್ನು ಸ್ವೀಕರಿಸಲಾಗುತ್ತಿದೆ
ಮೊದಲಿಗೆ, ಸಿಗ್ನಲ್ ಅನ್ನು ರೆಕಾರ್ಡ್ ಮಾಡಬೇಕಾಗಿದೆ. ಸಂಪೂರ್ಣ ಸಿಗ್ನಲ್ ಕೇವಲ 120 ಮೈಕ್ರೋಸೆಕೆಂಡ್‌ಗಳ ಅವಧಿಯನ್ನು ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ ಅದರ ಘಟಕಗಳನ್ನು ಆರಾಮವಾಗಿ ಡಿಸ್ಅಸೆಂಬಲ್ ಮಾಡಲು, ಕನಿಷ್ಠ 5 MHz ನ ಮಾದರಿ ಆವರ್ತನದೊಂದಿಗೆ SDR ರಿಸೀವರ್ ಅಪೇಕ್ಷಣೀಯವಾಗಿದೆ.
ರೆಕಾರ್ಡಿಂಗ್ ಮಾಡಿದ ನಂತರ, ನಾವು 5000000 ಮಾದರಿಗಳು/ಸೆಕೆಂಡಿನ ಮಾದರಿ ದರದೊಂದಿಗೆ WAV ಫೈಲ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ; ಅಂತಹ ರೆಕಾರ್ಡಿಂಗ್‌ನ 30 ಸೆಕೆಂಡುಗಳು ಸುಮಾರು 500MB "ತೂಕ". ಮೀಡಿಯಾ ಪ್ಲೇಯರ್‌ನೊಂದಿಗೆ ಅದನ್ನು ಕೇಳುವುದು ನಿಷ್ಪ್ರಯೋಜಕವಾಗಿದೆ - ಫೈಲ್ ಧ್ವನಿಯನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ, ಆದರೆ ನೇರವಾಗಿ ಡಿಜಿಟೈಸ್ ಮಾಡಿದ ರೇಡಿಯೋ ಸಿಗ್ನಲ್ - ಇದು ಸಾಫ್ಟ್‌ವೇರ್ ಡಿಫೈನ್ಡ್ ರೇಡಿಯೋ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
ನಾವು ಪೈಥಾನ್ ಬಳಸಿ ಫೈಲ್ ಅನ್ನು ತೆರೆಯುತ್ತೇವೆ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತೇವೆ. ಸ್ವಂತ ಪ್ರಯೋಗ ಮಾಡಲು ಬಯಸುವವರು ಉದಾಹರಣೆ ರೆಕಾರ್ಡಿಂಗ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು .
ಫೈಲ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ಒಳಗೆ ಏನಿದೆ ಎಂದು ನೋಡೋಣ.
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 ಪ್ರಕಾರದಲ್ಲಿ ಮಾತ್ರ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೇವೆ, ಏಕೆಂದರೆ... ಇದು ವಿಮಾನದ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
ICAO (24 ಬಿಟ್‌ಗಳು) - ವಿಮಾನದ ಅಂತರಾಷ್ಟ್ರೀಯ ಅನನ್ಯ ಕೋಡ್. ನೀವು ಅದರ ಕೋಡ್ ಮೂಲಕ ವಿಮಾನವನ್ನು ಪರಿಶೀಲಿಸಬಹುದು (ದುರದೃಷ್ಟವಶಾತ್, ಲೇಖಕರು ಡೇಟಾಬೇಸ್ ಅನ್ನು ನವೀಕರಿಸುವುದನ್ನು ನಿಲ್ಲಿಸಿದ್ದಾರೆ, ಆದರೆ ಇದು ಇನ್ನೂ ಪ್ರಸ್ತುತವಾಗಿದೆ). ಉದಾಹರಣೆಗೆ, ಕೋಡ್ 3c5ee2 ಗಾಗಿ ನಾವು ಈ ಕೆಳಗಿನ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿದ್ದೇವೆ:
ಸಂಪಾದಿಸಿ: ರಲ್ಲಿ ICAO ಕೋಡ್‌ನ ವಿವರಣೆಯನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ನೀಡಲಾಗಿದೆ; ಆಸಕ್ತರು ಅದನ್ನು ಓದಬೇಕೆಂದು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ.
ಡೇಟಾ (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 ನೊಂದಿಗೆ ಪ್ಯಾಕೇಜ್. ಇಲ್ಲಿ ಆಸಕ್ತಿದಾಯಕ ವಿಷಯವೆಂದರೆ ವೇಗವು ನಿಖರವಾಗಿ, ನೆಲಕ್ಕೆ (ಗ್ರೌಂಡ್ ಸ್ಪೀಡ್) ಅಥವಾ ವಾಯುಗಾಮಿ, ವಿಮಾನ ಸಂವೇದಕದಿಂದ (ಏರ್‌ಸ್ಪೀಡ್) ಅಳೆಯಬಹುದು. ಹಲವಾರು ವಿಭಿನ್ನ ಕ್ಷೇತ್ರಗಳು ಸಹ ಹರಡುತ್ತವೆ:
()
ತೀರ್ಮಾನಕ್ಕೆ
ನೀವು ನೋಡುವಂತೆ, ಎಡಿಎಸ್-ಬಿ ತಂತ್ರಜ್ಞಾನವು ಆಸಕ್ತಿದಾಯಕ ಸಹಜೀವನವಾಗಿ ಮಾರ್ಪಟ್ಟಿದೆ, ಒಂದು ಮಾನದಂಡವು ವೃತ್ತಿಪರರಿಗೆ ಮಾತ್ರವಲ್ಲದೆ ಸಾಮಾನ್ಯ ಬಳಕೆದಾರರಿಗೂ ಉಪಯುಕ್ತವಾಗಿದೆ. ಆದರೆ ಸಹಜವಾಗಿ, ಡಿಜಿಟಲ್ ಎಸ್‌ಡಿಆರ್ ರಿಸೀವರ್‌ಗಳ ಅಗ್ಗದ ತಂತ್ರಜ್ಞಾನವು ಇದರಲ್ಲಿ ಪ್ರಮುಖ ಪಾತ್ರವನ್ನು ವಹಿಸಿದೆ, ಇದು ಗಿಗಾಹರ್ಟ್ಜ್‌ಗಿಂತ ಹೆಚ್ಚಿನ ಆವರ್ತನಗಳೊಂದಿಗೆ "ನಾಣ್ಯಗಳಿಗೆ" ಅಕ್ಷರಶಃ ಸಂಕೇತಗಳನ್ನು ಸ್ವೀಕರಿಸಲು ಸಾಧನವನ್ನು ಅನುಮತಿಸುತ್ತದೆ.
ಮಾನದಂಡದಲ್ಲಿಯೇ, ಸಹಜವಾಗಿ, ಇನ್ನೂ ಹೆಚ್ಚಿನವುಗಳಿವೆ. ಆಸಕ್ತರು ಪುಟದಲ್ಲಿ ಪಿಡಿಎಫ್ ವೀಕ್ಷಿಸಬಹುದು ಅಥವಾ ಈಗಾಗಲೇ ಮೇಲೆ ತಿಳಿಸಿದ ಒಂದನ್ನು ಭೇಟಿ ಮಾಡಿ .
ಮೇಲಿನ ಎಲ್ಲಾವು ಅನೇಕರಿಗೆ ಉಪಯುಕ್ತವಾಗುವುದು ಅಸಂಭವವಾಗಿದೆ, ಆದರೆ ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬ ಸಾಮಾನ್ಯ ಕಲ್ಪನೆಯು ಉಳಿದಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.
ಮೂಲಕ, ಪೈಥಾನ್‌ನಲ್ಲಿ ಸಿದ್ಧವಾದ ಡಿಕೋಡರ್ ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ, ನೀವು ಅದನ್ನು ಅಧ್ಯಯನ ಮಾಡಬಹುದು . ಮತ್ತು SDR ರಿಸೀವರ್‌ಗಳ ಮಾಲೀಕರು ಸಿದ್ಧಪಡಿಸಿದ ADS-B ಡಿಕೋಡರ್ ಅನ್ನು ಜೋಡಿಸಬಹುದು ಮತ್ತು ಪ್ರಾರಂಭಿಸಬಹುದು , ಇದನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ಚರ್ಚಿಸಲಾಗಿದೆ .
ಲೇಖನದಲ್ಲಿ ವಿವರಿಸಿದ ಪಾರ್ಸರ್‌ನ ಮೂಲ ಕೋಡ್ ಅನ್ನು ಕಟ್‌ನ ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ. ಇದು ಒಂದು ಪರೀಕ್ಷಾ ಉದಾಹರಣೆಯಾಗಿದ್ದು ಅದು ಉತ್ಪಾದನೆಯಂತೆ ನಟಿಸುವುದಿಲ್ಲ, ಆದರೆ ಕೆಲವು ವಿಷಯಗಳು ಅದರಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಮತ್ತು ಮೇಲೆ ದಾಖಲಿಸಲಾದ ಫೈಲ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡಲು ಇದನ್ನು ಬಳಸಬಹುದು.
ಮೂಲ ಕೋಡ್ (ಪೈಥಾನ್)
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