DCF77: kuidas töötab täpse aja edastamise süsteem?

Tere, Habr.

Tõenäoliselt on paljud, kes ostavad kella või ilmateadet, näinud pakendil logo Radio Controlled Clock või isegi Atomic Clock. See on väga mugav, sest piisab, kui panna kell lauale ja see seadistab end automaatselt täpselt õigeks ajaks mõne aja pärast.


Selgitage välja, kuidas see töötab ja kirjutame dekooderi Python'i keeles.

On olemas erinevaid ajasünkroonimise süsteeme. Kõige populaarsem Euroopas on saksa süsteem DCF-77, Jaapanis on oma süsteem JJY, ning Ameerika Ühendriikides on süsteem WWVB, ja nii edasi. Edasi räägime DCF77-st, kui kõige asjakohasemast ja mõnes Euroopa Venemaa osas ja naaberriikides vastuvõetavast signaalist (Kaukaasia elanikud võivad olla teistsugusel arvamusel, kuigi nad võivad omakorda vastu võtta ja analüüsida Jaapani signaali;).

Kõik, mis edaspidi tuleb, on seotud DCF77-ga.

Signaali vastuvõtt

DCF77 on pikkade laineide jaam, mis töötab sagedusel 77,5 kHz ja edastab signaale amplituudimodulatsiooniga. Jaama võimsus on 50 kW, see asub Frankfurdist 25 km kaugusel ja alustas tööd juba 1959. aastal; 1973. aastal lisati täpsetele aegadele kuupäeva teave. 77 kHz sagedusel on lainepikkus üsna suur, seega on ka antennide väljakud üsna suured (pilt Wikipedia-st):


Selle antenni ja sisendi võimsuse korral katab vastuvõtuala praktiliselt kogu Euroopa, Valgevene, Ukraina ja osa Venemaast.

Signaali saab salvestada igaüks. Selleks piisab, kui minna veebivastuvõtjale http://websdr.ewi.utwente.nl:8901/, valida seal sagedus 76,5 kHz ja USB-modulatsioon. Peaks avanema pilt umbes selline:

Seal vajutame nuppu allalaadimiseks ja salvestame mitme minuti pikkuse fragmendi. Loomulikult, kui on olemas "päris" vastuvõtja, mis suudab salvestada sagedust 77,5 kHz, saab kasutada ka seda.

Muidugi, kui võetakse täpsete aegade raadi signaale üle Interneti, ei saa me tõeliselt täpset aega — signaal edastatakse viivitusega. Aga meie eesmärk on lihtsalt mõista signaali struktuuri, selleks on internetisalvestused rohkem kui piisavad. Reaalses elus kasutatakse muidugi spetsialiseeritud seadmeid vastuvõtmiseks ja dekodeerimiseks, millest allpool räägitakse.

Nii saime salvestuse, nüüd alustame selle töötlemist.

Signaali dekodeerimine

Laadime faili Python’i abil ja vaatame selle struktuuri:

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()

Me näeme tüüpilist amplituudimodulatsiooni:


Decoding'i lihtsustamiseks saame signaali katte Hilberti transformatsiooni abil:

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

Tulemus suurendatud vaates:


Silume müras olevad äärmuslikud väärtused madalpääsufiltri abil ning arvutame keskmise väärtuse, mida tarvitame hiljem parseerimisel.

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

Tulemus (kollane joon): peaaegu ristkülikukujuline signaal, mida on üsna lihtne analüüsida.

Parseerimine

Esiteks tuleb saada bitijada. Signaali struktuur on väga lihtne.


Impulssid on jagatud sekundilisteks intervallideks. Kui impulsside vahe on 0,1 s (st impulsi pikkus 0,9 s), lisame bitijadasse „0“, kui vahe on 0,2 s (st pikkus 0,8 s), lisame „1“. Iga minuti lõpp tähistatakse „pika“ impulssiga, pikkus 2 s, samal ajal nullitakse bitijada ja täitmine algab uuesti.

Üles kirjutatust ei ole keeruline kirjutada Pythonis.

sig_start, sig_stop = 0, 0
pos = 0
bits_str = ""
while pos < cnt - 4:
    if A[pos]  avg:
        # Signaali algus
        sig_start = pos
    if A[pos] > avg and A[pos+1] < avg:
        # Signaali lõpp
        sig_stop = pos

        diff = sig_stop - sig_start
    
        if diff  0.85*sample_rate and diff  1.5*sample_rate:
            print(bits_str)
            bits_str = ""

    pos += 1

Tulemusena saame bitijada, meie näites kahe sekundi jooksul näeb see välja järgmiselt:

0011110110111000001011000001010000100110010101100010011000
0001111100110110001010100001010000100110010101100010011000

Muide, on huvitav, et signaalis on ka „teine kiht“ andmeid. Bitijada on samuti kodeeritud faasimodulatsiooniga. Teoreetiliselt peaks see tagama stabiilsema dekodeerimise isegi nõrgenenud signaali korral.

Meie viimane samm: saada andmed. Bitid edastatakse iga sekundi järel, seega on meil kokku 59 bitti, milles on kodeeritud palju teavet:


Bitid on kirjeldatud Vikipeediad, ja nad on üsna huvitavad. Esimesed 15 bitti ei ole kasutuses, kuigi oli plaan neid kasutada häiresüsteemide ja kodaniku kaitse jaoks. A1 bitt näitab, et järgmisel korral kellad suveajale üleminekuks seadistatakse. A2 bitt näitab, et järgmisel tunnil lisatakse täiendav sekundi, mida mõnikord kasutatakse ajakorrektuuriks vastavalt Maa pöörlemisele. Ülejäänud bitid kodeerivad tunde, minuteid, sekundeid ja kuupäeva.

Neile, kes soovivad ise katsetada, on dekodeerimise kood pandud spoilerisse.
Allika kood

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 = ('Pühapäev', 'Esmaspäev', 'Teisipäev', 'Kolmapäev', 'Neljapäev', 'Reede', 'Laupäev', 'Pühapäev')
    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)

Programmi käivitamisel näeme umbes sellist väljundit:

0011110110111000001011000001010000100110010101100010011000
Teisipäev, 26.03.19, 21:41
0001111100110110001010100001010000100110010101100010011000
Teisipäev, 26.03.19, 21:42

Tegelikult on kogu maagia siin. Selle süsteemi eeliseks on see, et dekodeerimine on äärmiselt lihtne ja seda saab teha mis tahes, isegi kõige lihtsama mikrokontrolleriga. Lihtsalt loeme impulsside pikkuse, kogume 60 bitti ja iga minuti lõpus saame täpset aega. Võrreldes teiste ajasünkroonimise viisidega (näiteks GPS-i või jumal hoidku, internetiga :), vajab selline raadiosünkroonimine praktiliselt mitte mingit energiat — näiteks, tavaline kodune ilmajaam töötab umbes aasta kahe AA patareiga. Seetõttu kasutatakse raadiosünkroonimist isegi käekellades, rääkimata muidugi seinakelladest või tänavate jaamade kelladest.

DCF mugavus ja lihtsus köidavad ka DIY entusiastide tähelepanu. Ainult 10-20 dollari eest saab osta valmis mooduli antenniga ja valmis vastuvõtjaga, millel on TTL-väljund, mida saab ühendada Arduino või muu kontrolleriga.


Arduino jaoks on juba kirjutatud ja valmis raamatukogudKuid nagu ikka, on selge, et kui midagi teha mikrokontrolleriga, saadakse kas kell või ilmateade. Sellise seadmega on tõepoolest lihtne täpset aega saada, kui oled loomulikult vastuvõtualas. Ja võid kellale riputada kiire kirjutise „Aatomikell“, selgitades soovijatele, et seade tõesti sünkroniseerib aatomikellade abiga.

Soovijad võivad isegi vanaema kellasid üles uuendada, paigaldades neisse uue raadio sünkroniseerimise mehhanismi:

Seda saab leida eBay's ots fraasidega „Raadio juhtimise mehaanika”.

Ja lõpuks, vihje neile, kes siia välja lugesid. Isegi kui lähima paarikümne tuhande kilomeetri raadiuses ei ole ühtegi raadiovastuvõtjat, on sellise signaali iseseisvalt genereerimine lihtne. Google Play's on rakendus nimega „DCF77 Emulator“, mis edastab signaali kõrvaklappidesse. Toote autori sõnul, kui keerata kõrvaklappide juhe kellade ümber, saavad nad signaali (huvitav, kuidas, sest tavalised kõrvaklappid ei genereeri 77KHz signaali, kuid tõenäoliselt saadakse vastuvõtt harmoonikute kaudu). Minu Android 9 seadmes ei töötanud rakendus üldse — lihtsalt ei olnud heli (võib-olla ei kuulnud ma seda — 77KHz on ju :), kuid võib-olla on kellegil rohkem õnne. Mõned teevad endale ka korraliku DCF signaaligeneraatori, mille tegemine ei ole keeruline ka sama Arduino või ESP32 peal:

(allikas sgfantasytoys.wordpress.com/2015/05/13/synchronize-radio-controlled-watch-without-access)

Kokkuvõte

DCF süsteem osutus tõeliselt lihtsaks ja mugavaks. Odava ja lihtsa vastuvõtja abil on alati ja igal pool võimalik saada täpset aega, muidugi vastuvõtuala piires. Tundub, et isegi vaatamata ulatuslikule digitaliseerimisele ja „asjade internetile” on sellised lihtsad lahendused veel pikaks ajaks nõutud.

Allikas: habr.com