Hej Habr.
Mange, der køber ure eller vejrstationer, har sikkert set logoet Radio Controlled Clock eller endda Atomic Clock på emballagen. Det er virkelig praktisk, for man skal blot sætte uret på bordet, så indstiller det sig automatisk til det præcise tidspunkt efter noget tid.
Lad os finde ud af, hvordan det fungerer, og skrive en dekoder i Python.
Der findes forskellige tidssynkroniseringssystemer. Det mest populære i Europa er det tyske system , i Japan har de deres eget system , i USA er der systemet , og så videre. Næste del vil handle om DCF77, da det er det mest relevante og tilgængelige for modtagelse i nogle dele af den europæiske del af Rusland og nabolandene (folk i Fjernøsten kan have en anden mening; de kan imidlertid modtage og analysere det japanske signal).
Alt, hvad der skrives her, handler om DCF77.
Modtagelse af signalet
DCF77 er en langbølge station, der arbejder på en frekvens på 77,5 kHz og sender signaler i amplitudemodulation. Stationen, som har en effekt på 50 kW, ligger 25 km fra Frankfurt og begyndte driften allerede i 1959. I 1973 blev der til det præcise tidspunkt tilføjet oplysninger om datoen. Bølgelængden ved 77 kHz er ret stor, derfor er størrelsen på antennefeltet også ret betydelig (billede fra Wikipedia):
Med en sådan antenne og den påførte effekt dækker modtageområdet praktisk talt hele Europa, Hviderusland, Ukraine og dele af Rusland.
Alle kan optage signalet. For dette er det nok at gå ind på en online modtager , vælge en frekvens på 76,5 kHz og USB-modulation. Der skulle åbne et billede, som dette:
Der trykker vi også på knappen download og optager et uddrag på et par minutter. Selvfølgelig, med en "ægte" modtager, der kan optage frekvensen 77,5 kHz, kan man også bruge den.
Selvfølgelig, når vi modtager radiosignaler for præcise tider via internettet, får vi ikke virkelig præcise tider — signalet overføres med forsinkelse. Men vores mål er blot at forstå signalets struktur; til dette formål er internettoptagelser mere end tilstrækkelige. I virkeligheden bruges der selvfølgelig specialiserede enheder til at modtage og dekode, som vil blive omtalt nedenfor.
Så, vi har fået en optagelse, lad os gå videre til behandling af den.
Dekodning af signalet
Lad os indlæse filen ved hjælp af Python og se dens struktur:
fra scipy.io import wavfile
fra 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()
Vi ser en typisk amplitudemodulation:
For at forenkle dekodningen, lad os tage signalets omslag ved hjælp af Hilbert-transformasjonen:
analytic_signal = signal.hilbert(data)
A = np.abs(analytic_signal)
plt.plot(A[:100000]) Resultatet i forstørret visning:
Vi vil udglatte udsving fra forstyrrelser ved hjælp af et lavpasfilter og samtidig beregne gennemsnittet, som senere vil være nyttigt til parsing.
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 Resultatet (den gule linje): næsten rektangulært signal, som er ret nemt at analysere.
Parsing
Først skal vi få sekvensen af bits. Selve signalstrukturen er meget simpel.
Impulserne er delt op i sekundintervaller. Hvis afstanden mellem impulserne er 0.1s (dvs. længden af selve impulsen er 0.9s), tilføjer vi "0" til bitsekvensen. Hvis afstanden er 0.2s (dvs. længden er 0.8s), tilføjer vi "1". Enden af hver minut markeres med en "lang" impuls, der varer 2s, og bitsekvensen nulstilles og begynder forfra.
Det ovenstående kan nemt skrives på Python.
sig_start, sig_stop = 0, 0
pos = 0
bits_str = ""
while pos < cnt - 4:
if A[pos] avg:
# Signalets begyndelse
sig_start = pos
if A[pos] > avg and A[pos+1] < avg:
# Signalets slut
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
Som et resultat får vi en sekvens af bits, i vores eksempel for to sekunder ser den således ud:
0011110110111000001011000001010000100110010101100010011000
0001111100110110001010100001010000100110010101100010011000
For resten er det interessant, at signalet også har et "andet lag" af data. Bitsekvensen er også kodet ved hjælp af . Teoretisk set skulle dette sikre en mere robust dekodning, selv ved svag signal.
Vores sidste skridt: at få selve dataene. Bits sendes én gang i sekundet, så vi har i alt 59 bits, hvor der er kodet en del information:
Bits er beskrevet i , og de er ret interessante. De første 15 bits bruges ikke, selvom der var planer om at anvende dem til alarmsystemer og civilbeskyttelse. Bit A1 angiver, at klokken vil blive springet frem til sommertid næste time. Bit A2 angiver, at der vil blive tilføjet , som nogle gange bruges til at korrigere tiden i overensstemmelse med jordens rotation. De øvrige bits koder timer, minutter, sekunder og dato.
For dem, der ønsker at eksperimentere selv, er koden til dekodning angivet under spoileren.
Kildekode
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 = ('Søndag', 'Mandag', 'Tirsdag', 'Onsdag', 'Torsdag', 'Fredag', 'Lørdag', 'Søndag')
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)
Ved at køre programmet vil vi se et output, der ser omtrent sådan ud:
0011110110111000001011000001010000100110010101100010011000
Tirsdag, 26.03.19, 21:41
0001111100110110001010100001010000100110010101100010011000
Tirsdag, 26.03.19, 21:42
Det er faktisk hele magien. Fordelen ved et sådant system er, at dekodningen er ekstremt simpel og kan udføres på enhver, også den mest enkle mikrokontroller. Man skal blot tælle længden af impulserne, opsamle 60 bits, og i slutningen af hvert minut får man præcist tid. Sammenlignet med andre metoder til tidssynkronisering (som GPS eksempelvis, eller Gud forbyde, internettet:), kræver denne radiosynkronisering praktisk talt ingen energi — for eksempel fungerer en almindelig hjemmevejrstation i omtrent et år på 2 AA-batterier. Derfor laver man endda armbåndsure med radiosynkronisering, for ikke at nævne vægure eller udendørs stationer.
Bekvemmeligheden og enkelheden ved DCF tiltrækker også gør-det-selv entusiaster. Man kan købe en færdig modul med antenne og en færdig modtager med TTL-udgang for kun 10-20$, som kan tilsluttes Arduino eller en anden controller.
For Arduino er der allerede skrevet og Men det er jo allerede kendt - hvad man end laver med en mikrokontroller, får man enten et ur eller en vejrstation. Med en sådan enhed er det faktisk ikke svært at få præcis tid, så længe man befinder sig inden for modtagelsesområdet. Og man kan også hænge en inskription "Atomic Clock" på uret og forklare alle interesserede, at enheden faktisk synkroniseres med atomure.
De interesserede kan endda opgradere deres oldeforældres ur ved at installere en ny mekanisme med radiokontrol:
Sådan en kan findes på ebay med søgeordene "Radio Controlled Movement".
Og endelig, et livshack til dem, der har læst så langt. Selvom der ikke er nogen radiosignaltransmitter inden for et par tusinde km, kan man selv generere et sådant signal. Der er et program på Google Play med navnet "DCF77 Emulator", som sender signalet til hovedtelefonerne. Ifølge forfatteren, hvis man vikler ledningen fra hovedtelefonerne omkring uret, vil de opfange signalet (interessant hvordan, da almindelige hovedtelefoner ikke kan sende et signal på 77 kHz, men muligvis modtageren fungerer via harmonik). Jeg fik ikke programmet til at fungere på Android 9 - der var simpelthen ingen lyd (eller måske hørte jeg det ikke - 77 kHz jo :), men måske er der nogle, der er mere heldige. Nogle bygger desuden en fuld signalgenerator DCF, som ikke er vanskelig at lave på den samme Arduino eller ESP32:
(kilde )
Konklusion
DCF-systemet viste sig at være ret simpelt og praktisk. Med en billig og enkel modtager kan man altid have præcis tid, selvfølgelig inden for modtagelsesområdet. Man kunne forestille sig, at på trods af den udbredte digitalisering og "Internet of Things", vil sådanne enkle løsninger være efterspurgt i lang tid fremover.
Kilde: habr.com
