DCF77. Ինչպե՞ս է աշխատում ժամանակի ազդանշանային համակարգը:

Բարև Հաբր։

Հավանաբար շատերը, ովքեր ձեռք են բերում ժամացույց կամ եղանակային կայան, տեսել են «Radio Controlled Clock» կամ նույնիսկ «Atomic Clock» պատկերանշանը փաթեթավորման վրա: Սա շատ հարմար է, քանի որ պարզապես պետք է ժամացույցը դնել սեղանին, և որոշ ժամանակ անց այն ավտոմատ կերպով կհարմարվի ճշգրիտ ժամանակին։


Եկեք պարզենք, թե ինչպես է այն աշխատում և գրենք ապակոդավորիչ Python-ում:

Կան ժամանակի համաժամացման տարբեր համակարգեր: Եվրոպայում ամենահայտնին գերմանական համակարգն է DCF-77, Ճապոնիան ունի իր սեփական համակարգը ՋՋԻ, ԱՄՆ-ում գործում է համակարգ WWVB, և այլն։ Հաջորդը, պատմությունը կլինի DCF77-ի մասին, որպես Ռուսաստանի եվրոպական մասի և հարևան երկրների որոշ վայրերում ընդունելության համար առավել համապատասխան և մատչելի (հեռավոր Արևելքի բնակիչները կարող են հակառակ կարծիք ունենալ, սակայն նրանք, իրենց հերթին, կարող են ստանալ. և վերլուծել ճապոնական ազդանշանը;).

Ստորև գրված ամեն ինչ վերաբերվելու է DCF77-ին:

Ազդանշանի ընդունում

DCF77-ը երկար ալիքային կայան է, որն աշխատում է 77.5 կՀց հաճախականությամբ և ազդանշաններ է հաղորդում ամպլիտուդային մոդուլյացիայի մեջ։ 50 ԿՎտ հզորությամբ կայանը գտնվում է Ֆրանկֆուրտից 25 կմ հեռավորության վրա, այն սկսել է գործել 1959 թվականին, իսկ 1973 թվականին ճշգրիտ ժամանակին ավելացվել է ամսաթիվը։ 77 ԿՀց հաճախականությամբ ալիքի երկարությունը շատ երկար է, ուստի ալեհավաքի դաշտի չափերը նույնպես բավականին պատշաճ են (լուսանկարը Վիքիպեդիայից).


Նման ալեհավաքով և էներգիայի մուտքագրմամբ ընդունման տարածքը ընդգրկում է գրեթե ողջ Եվրոպան, Բելառուսը, Ուկրաինան և Ռուսաստանի մի մասը:

Յուրաքանչյուրը կարող է ազդանշան ձայնագրել: Դա անելու համար պարզապես գնացեք առցանց ընդունիչ http://websdr.ewi.utwente.nl:8901/, այնտեղ ընտրեք 76.5ԿՀց հաճախականությունը և USB մոդուլյացիան։ Պետք է բացվի մի պատկեր, որն ունի հետևյալ տեսքը.

Այնտեղ մենք սեղմում ենք ներբեռնման կոճակը և մի քանի րոպե տևողությամբ հատված ձայնագրում: Իհարկե, եթե ունեք «իսկական» ընդունիչ, որը կարող է ձայնագրել 77.5 ԿՀց հաճախականությունը, կարող եք օգտվել դրանից:

Իհարկե, ռադիոժամային ազդանշաններ ստանալով ինտերնետի միջոցով, մենք իսկապես ճշգրիտ ժամանակ չենք ստանա՝ ազդանշանը փոխանցվում է ուշացումով: Բայց մեր նպատակն է միայն հասկանալ ազդանշանի կառուցվածքը, դրա համար ինտերնետի ձայնագրությունն ավելի քան բավարար է։ Իրական կյանքում, իհարկե, ընդունման և վերծանման համար օգտագործվում են մասնագիտացված սարքեր, դրանք կքննարկվեն ստորև:

Այսպիսով, մենք ստացել ենք ձայնագրությունը, եկեք սկսենք դրա մշակումը։

Ազդանշանի վերծանում

Եկեք բեռնենք ֆայլը Python-ի միջոցով և տեսնենք դրա կառուցվածքը.

from scipy.io import wavfile
from scipy import signal
import matplotlib.pyplot as plt
import numpy as np

sample_rate, data = wavfile.read("dcf_websdr_2019-03-26T20_25_34Z_76.6kHz.wav")
plt.plot(data[:100000])
plt.show()

Մենք տեսնում ենք տիպիկ ամպլիտուդային մոդուլյացիան.


Ապակոդավորումը պարզեցնելու համար եկեք վերցնենք ազդանշանի ծրարը՝ օգտագործելով Հիլբերտի փոխակերպումը.

analytic_signal = signal.hilbert(data)
A = np.abs(analytic_signal)
plt.plot(A[:100000])

Ընդլայնված արդյունք.


Եկեք հարթենք աղմուկի արտանետումները՝ օգտագործելով ցածր անցումային ֆիլտր, և միևնույն ժամանակ հաշվարկենք միջին արժեքը, որը հետագայում օգտակար կլինի վերլուծության համար:

b, a = signal.butter(2, 20.0/sample_rate)
zi = signal.lfilter_zi(b, a)
A, _ = signal.lfilter(b, a, A, zi=zi*A[0])
avg = (np.amax(A) + np.amin(A))/2

Արդյունք (դեղին գիծ). գրեթե քառակուսի ալիքի ազդանշան, որը բավականին հեշտ է վերլուծել:

Վերլուծություն

Նախ անհրաժեշտ է ստանալ բիթերի հաջորդականությունը: Ազդանշանի կառուցվածքն ինքնին շատ պարզ է.


Իմպուլսները բաժանված են երկրորդ ընդմիջումներով. Եթե ​​իմպուլսների միջև հեռավորությունը 0.1 վ է (այսինքն՝ իմպուլսի երկարությունը 0.9 վրկ է), բիթերի հաջորդականությանը ավելացրեք «0», եթե հեռավորությունը 0.2 վ է (այսինքն՝ երկարությունը 0.8 վրկ), ավելացրեք «1»: Յուրաքանչյուր րոպեի ավարտը նշվում է «երկար» զարկերակով, 2 վրկ, բիթերի հաջորդականությունը զրոյացվում է, և լիցքավորումը նորից սկսվում է:

Վերոնշյալը հեշտ է գրել Python-ում:

sig_start, sig_stop = 0, 0
pos = 0
bits_str = ""
while pos < cnt - 4:
    if A[pos] < avg and A[pos+1] > avg:
        # Signal begin
        sig_start = pos
    if A[pos] > avg and A[pos+1] < avg:
        # Signal end
        sig_stop = pos

        diff = sig_stop - sig_start
    
        if diff < 0.85*sample_rate:
            bits_str += "1"
        if diff > 0.85*sample_rate and diff < 1.25*sample_rate:
            bits_str += "0"
        if diff > 1.5*sample_rate:
            print(bits_str)
            bits_str = ""

    pos += 1

Արդյունքում մենք ստանում ենք բիթերի հաջորդականություն, մեր օրինակում երկու վայրկյանում այսպիսի տեսք ունի.

0011110110111000001011000001010000100110010101100010011000
0001111100110110001010100001010000100110010101100010011000

Ի դեպ, հետաքրքիր է, որ ազդանշանն ունի նաև տվյալների «երկրորդ շերտ»: Բիթերի հաջորդականությունը նույնպես կոդավորված է օգտագործելով փուլային մոդուլյացիա. Տեսականորեն սա պետք է ապահովի ավելի ամուր վերծանում նույնիսկ թուլացած ազդանշանի դեպքում:

Մեր վերջին քայլը՝ փաստացի տվյալների ստացում: Բիթերը փոխանցվում են վայրկյանում մեկ անգամ, ուստի մենք ունենք ընդհանուր առմամբ 59 բիթ, որոնցում կոդավորված է բավականին շատ տեղեկատվություն.


Բիթերը նկարագրված են Վիքիպեդիա, և նրանք բավականին հետաքրքրասեր են։ Առաջին 15 բիթերը չեն օգտագործվում, թեև պլաններ կային դրանք օգտագործել նախազգուշացման համակարգերի և քաղաքացիական պաշտպանության համար: A1 բիթը ցույց է տալիս, որ հաջորդ ժամին ժամացույցը կփոխվի ամառային ժամանակի: Bit A2 ցույց է տալիս, որ լրացուցիչ թռիչք երկրորդ, որը երբեմն օգտագործվում է Երկրի պտույտի համաձայն ժամանակը հարմարեցնելու համար։ Մնացած բիթերը կոդավորում են ժամերը, րոպեները, վայրկյանները և ամսաթիվը:

Նրանց համար, ովքեր ցանկանում են ինքնուրույն փորձարկել, ապակոդավորման կոդը տրված է սփոյլերի տակ։
Աղբյուրի կոդը

def decode(bits):
    if bits[0] != '0' or bits[20] != '1':
        return
    
    minutes, hours, day_of_month, weekday, month, year = map(convert_block,
                                                             (bits[21:28], bits[29:35], bits[36:42], bits[42:45],
                                                              bits[45:50], bits[50:58]))
    days = ('Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday')
    print('{dow}, {dom:02}.{mon:02}.{y}, {h:02}:{m:02}'.format(h=hours, m=minutes, dow=days[weekday],
                                                               dom=day_of_month, mon=month, y=year))


def convert_ones(bits):
    return sum(2**i for i, bit in enumerate(bits) if bit == '1')


def convert_tens(bits):
    return 10*convert_ones(bits)


def right_parity(bits, parity_bit):
    num_of_ones = sum(int(bit) for bit in bits)
    return num_of_ones % 2 == int(parity_bit)


def convert_block(bits, parity=False):
    if parity and not right_parity(bits[:-1], bits[-1]):
        return -1
    
    ones = bits[:4]
    tens = bits[4:]
    return convert_tens(tens) + convert_ones(ones)

Երբ մենք գործարկում ենք ծրագիրը, մենք կտեսնենք հետևյալ արդյունքը.

0011110110111000001011000001010000100110010101100010011000
Tuesday, 26.03.19, 21:41
0001111100110110001010100001010000100110010101100010011000
Tuesday, 26.03.19, 21:42

Իրականում, սա է ողջ կախարդանքը: Նման համակարգի առավելությունն այն է, որ վերծանումը չափազանց պարզ է և կարող է իրականացվել ցանկացած, նույնիսկ ամենապարզ միկրոկոնտրոլերի վրա: Մենք պարզապես հաշվում ենք իմպուլսների երկարությունը, կուտակում ենք 60 բիթ, և յուրաքանչյուր րոպեի վերջում ստանում ենք ճշգրիտ ժամանակը։ Համեմատած ժամանակի համաժամացման այլ մեթոդների հետ (օրինակ, GPS, կամ Աստված մի արասցե, ինտերնետ :), նման ռադիոհամաժամացման համար անհրաժեշտ է էլեկտրաէներգիա, օրինակ, սովորական տնային եղանակային կայանը աշխատում է մոտ մեկ տարի 2 AA մարտկոցով: Հետեւաբար, նույնիսկ ձեռքի ժամացույցները պատրաստվում են ռադիոյի համաժամանակացմամբ, էլ չենք խոսում, իհարկե, պատի ժամացույցների կամ փողոցային կայանների ժամացույցների մասին:

DCF-ի հարմարավետությունն ու պարզությունը գրավում են նաև DIY սիրահարներին: Ընդամենը 10-20 դոլարով կարող եք գնել պատրաստի ալեհավաքի մոդուլ՝ պատրաստի ընդունիչով և TTL ելքով, որը կարելի է միացնել Arduino-ին կամ այլ կարգավորիչին։


Արդեն գրված է Arduino-ի համար պատրաստի գրադարաններ. Այնուամենայնիվ, արդեն հայտնի է, որ անկախ նրանից, թե ինչ եք անում միկրոկոնտրոլերի վրա, դուք հայտնվում եք կամ ժամացույցով, կամ եղանակային կայանով: Նման սարքի դեպքում ճշգրիտ ժամանակը ստանալը իսկապես հեշտ է, եթե իհարկե դուք գտնվում եք ընդունարանում։ Դե, դուք կարող եք կախել «Ատոմային ժամացույց» մակագրությունը ձեր ժամացույցի վրա և միևնույն ժամանակ բացատրել բոլորին, որ սարքն իսկապես սինխրոնիզացված է ատոմային ժամացույցի միջոցով:

Ցանկացողները կարող են նույնիսկ թարմացնել իրենց հին տատիկի ժամացույցը՝ տեղադրելով ռադիոհամաժամացման նոր մեխանիզմ.

Դուք կարող եք գտնել մեկը ebay-ում՝ օգտագործելով «Radio Controlled Movement» հիմնաբառերը:

Եվ վերջապես, կյանքի հնարք նրանց համար, ովքեր կարդացել են մինչև այս պահը: Նույնիսկ եթե մի քանի հազար կիլոմետրերի շառավղով չկա ոչ մի ռադիոհաղորդիչ, հեշտ է ինքներդ ստեղծել այն: Google Play-ում կա մի հավելված՝ «DCF77 Emulator» անունով, որը ազդանշան է ուղարկում ականջակալներին: Հեղինակը պնդում է, որ եթե ականջակալների մալուխը փաթաթեք ժամացույցի շուրջ, այն կընդունի ազդանշանը (հետաքրքիր է, թե ինչպես, քանի որ սովորական ականջակալները չեն ստեղծի 77 կՀց ազդանշան, բայց դա, հավանաբար, պայմանավորված է հարմոնիկաներով): Իմ ժամացույցի վրա... Android 9-րդ ծրագիրը ընդհանրապես չաշխատեց՝ պարզապես ձայն չկար (կամ գուցե ես պարզապես չէի լսում այն՝ վերջիվերջո, այն 77 կՀց է :)), բայց գուցե ինչ-որ մեկը ավելի բախտավոր լինի։ Սակայն որոշ մարդիկ կառուցում են իրենց սեփական լիարժեք DCF ազդանշանի գեներատորը, որը հեշտ է պատրաստել Arduino-ի կամ ESP32-ի միջոցով։

(աղբյուր sgfantasytoys.wordpress.com/2015/05/13/synchronize-radio-controlled-watch-without-access)

Ամփոփում

DCF համակարգը պարզվեց, որ իսկապես բավականին պարզ և հարմար է: Պարզ և էժան ընդունիչի օգնությամբ դուք կարող եք ճշգրիտ ժամանակը ունենալ միշտ և ամենուր, իհարկե ընդունարանում։ Թվում է, թե չնայած համատարած թվայնացմանն ու իրերի ինտերնետին, նման պարզ լուծումները դեռ երկար ժամանակ պահանջված կլինեն։

Source: www.habr.com