Flightradar24 - તે કેવી રીતે કામ કરે છે? ભાગ 2, ADS-B પ્રોટોકોલ

હેલો હેબ્ર. સંભવતઃ દરેક વ્યક્તિ કે જેણે ક્યારેય સગાંઓ કે મિત્રોને પ્લેનમાં મળ્યા હોય અથવા જોયા હોય તેમણે ફ્રી Flightradar24 સેવાનો ઉપયોગ કર્યો હોય. વાસ્તવિક સમયમાં એરક્રાફ્ટની સ્થિતિને ટ્રૅક કરવાની આ ખૂબ જ અનુકૂળ રીત છે.

В પ્રથમ ભાગ આવી ઓનલાઈન સેવાના સંચાલન સિદ્ધાંતનું વર્ણન કરવામાં આવ્યું હતું. અમે હવે આગળ વધીશું અને જાણીશું કે એરક્રાફ્ટમાંથી રીસીવિંગ સ્ટેશન પર કયો ડેટા મોકલવામાં આવી રહ્યો છે અને પ્રાપ્ત થઈ રહ્યો છે અને પાયથોનનો ઉપયોગ કરીને તેને જાતે ડીકોડ કરીશું.

История

દેખીતી રીતે, યુઝર્સને તેમના સ્માર્ટફોન પર જોવા માટે એરક્રાફ્ટ ડેટા ટ્રાન્સમિટ થતો નથી. સિસ્ટમને ADS-B (ઓટોમેટિક ડિપેન્ડન્ટ સર્વેલન્સ-બ્રોડકાસ્ટ) કહેવામાં આવે છે, અને તેનો ઉપયોગ એરક્રાફ્ટ વિશેની માહિતીને નિયંત્રણ કેન્દ્રમાં આપમેળે ટ્રાન્સમિટ કરવા માટે થાય છે - તેના ઓળખકર્તા, કોઓર્ડિનેટ્સ, દિશા, ઝડપ, ઊંચાઈ અને અન્ય ડેટા ટ્રાન્સમિટ થાય છે. અગાઉ, આવી સિસ્ટમોના આગમન પહેલાં, રવાનગી રડાર પર માત્ર એક બિંદુ જોઈ શકતી હતી. જ્યારે ઘણા બધા વિમાનો હતા ત્યારે આ પૂરતું ન હતું.

તકનીકી રીતે, ADS-B માં એરક્રાફ્ટ પર ટ્રાન્સમીટરનો સમાવેશ થાય છે જે સમયાંતરે 1090 MHz ની એકદમ ઊંચી આવર્તન પર માહિતીના પેકેટો મોકલે છે (ત્યાં અન્ય મોડ્સ છે, પરંતુ અમને તેમાં એટલી રુચિ નથી, કારણ કે કોઓર્ડિનેટ્સ ફક્ત અહીં જ પ્રસારિત થાય છે). અલબત્ત, ટ્રાન્સમીટર ઉપરાંત, એરપોર્ટ પર ક્યાંક રીસીવર પણ છે, પરંતુ અમારા માટે, વપરાશકર્તાઓ તરીકે, આપણું પોતાનું રીસીવર રસપ્રદ છે.

માર્ગ દ્વારા, સરખામણી માટે, આવી પહેલી સિસ્ટમ, એરનેવ રડારબોક્સ, જે સામાન્ય વપરાશકર્તાઓ માટે રચાયેલ છે, 2007 માં દેખાઈ હતી અને તેની કિંમત લગભગ $900 હતી, અને લગભગ 250$ નેટવર્ક સેવાઓના સબ્સ્ક્રિપ્શનનો દર વર્ષે ખર્ચ થાય છે.

તે પ્રથમ રશિયન માલિકોની સમીક્ષાઓ ફોરમ પર વાંચી શકાય છે રેડિયોસ્કેનર. હવે જ્યારે RTL-SDR રીસીવરો વ્યાપકપણે ઉપલબ્ધ થયા છે, સમાન ઉપકરણ $30 માં એસેમ્બલ કરી શકાય છે; આ વિશે વધુ પ્રથમ ભાગ. ચાલો પ્રોટોકોલ પર જ આગળ વધીએ - ચાલો જોઈએ કે તે કેવી રીતે કાર્ય કરે છે.

સંકેતો પ્રાપ્ત કરી રહ્યા છીએ

પ્રથમ, સિગ્નલ રેકોર્ડ કરવાની જરૂર છે. સમગ્ર સિગ્નલનો સમયગાળો માત્ર 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 બિટ્સ) - એરક્રાફ્ટનો આંતરરાષ્ટ્રીય અનન્ય કોડ. તમે પ્લેનને તેના કોડ દ્વારા ચેક કરી શકો છો ઓનલાઇન (કમનસીબે, લેખકે ડેટાબેઝ અપડેટ કરવાનું બંધ કરી દીધું છે, પરંતુ તે હજુ પણ સંબંધિત છે). ઉદાહરણ તરીકે, કોડ 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 સાથેનું પેકેજ. અહીં રસપ્રદ બાબત એ છે કે ઝડપ કાં તો સચોટ હોઈ શકે છે, જમીનની સાપેક્ષ (ગ્રાઉન્ડ સ્પીડ), અથવા એરબોર્ન, એરક્રાફ્ટ સેન્સર (એરસ્પીડ) દ્વારા માપવામાં આવે છે. ઘણાં વિવિધ ક્ષેત્રો પણ પ્રસારિત થાય છે:

(સ્રોત)

નિષ્કર્ષ

જેમ તમે જોઈ શકો છો, ADS-B ટેક્નોલોજી એ એક રસપ્રદ સહજીવન બની ગયું છે, જ્યારે ધોરણ માત્ર વ્યાવસાયિકો માટે જ નહીં, પણ સામાન્ય વપરાશકર્તાઓ માટે પણ ઉપયોગી છે. પરંતુ અલબત્ત, આમાં મુખ્ય ભૂમિકા ડિજિટલ SDR રીસીવરોની સસ્તી તકનીક દ્વારા ભજવવામાં આવી હતી, જે ઉપકરણને "પેનિસ માટે" ગીગાહર્ટ્ઝથી ઉપરની ફ્રીક્વન્સીઝ સાથે શાબ્દિક રીતે સિગ્નલ પ્રાપ્ત કરવાની મંજૂરી આપે છે.

ધોરણમાં જ, અલબત્ત, ત્યાં ઘણું બધું છે. રસ ધરાવતા લોકો પૃષ્ઠ પર પીડીએફ જોઈ શકે છે આઈસીએઓ અથવા પહેલાથી જ ઉપર જણાવેલ એકની મુલાકાત લો વેબસાઇટ.

તે અસંભવિત છે કે ઉપરોક્ત તમામ ઘણા લોકો માટે ઉપયોગી થશે, પરંતુ તે કેવી રીતે કાર્ય કરે છે તેનો ઓછામાં ઓછો સામાન્ય વિચાર, મને આશા છે, રહે છે.

માર્ગ દ્વારા, પાયથોનમાં તૈયાર ડીકોડર પહેલેથી જ અસ્તિત્વમાં છે, તમે તેનો અભ્યાસ કરી શકો છો અહીં. અને 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