DCF77: როგორ მუშაობს დროის სიგნალის სისტემა?

გამარჯობა ჰაბრ.

ალბათ ბევრს, ვინც ყიდულობს საათს ან ამინდის სადგურს, უნახავს რადიო კონტროლირებადი საათი ან თუნდაც ატომური საათის ლოგო შეფუთვაზე. ეს ძალიან მოსახერხებელია, რადგან თქვენ უბრალოდ უნდა დადოთ საათი მაგიდაზე და გარკვეული პერიოდის შემდეგ ის ავტომატურად მოერგება ზუსტ დროს.


მოდით გავარკვიოთ როგორ მუშაობს და დავწეროთ დეკოდერი პითონში.

არსებობს დროის სინქრონიზაციის სხვადასხვა სისტემა. ევროპაში ყველაზე პოპულარული გერმანული სისტემაა DCF-77იაპონიას აქვს საკუთარი სისტემა JJY, აშშ-ში არის სისტემა WWVB, და ასე შემდეგ. შემდეგი, სიუჟეტი იქნება DCF77-ის შესახებ, როგორც ყველაზე აქტუალური და ხელმისაწვდომი რუსეთის ევროპულ ნაწილში და მეზობელ ქვეყნებში ზოგიერთ ადგილას (შორეული აღმოსავლეთის მაცხოვრებლებს შეიძლება ჰქონდეთ საპირისპირო აზრი, თუმცა, მათ, თავის მხრივ, შეუძლიათ მიიღონ და გააანალიზეთ იაპონური სიგნალი;).

ყველაფერი დაწერილი ქვემოთ იქნება DCF77-ის შესახებ.

სიგნალის მიღება

DCF77 არის გრძელი ტალღის სადგური, რომელიც მუშაობს 77.5 kHz სიხშირეზე და გადასცემს სიგნალებს ამპლიტუდის მოდულაციაში. 50 კვტ სიმძლავრის სადგური მდებარეობს ფრანკფურტიდან 25 კმ-ში, მან მუშაობა დაიწყო 1959 წელს, ხოლო 1973 წელს თარიღის შესახებ ინფორმაცია დაემატა ზუსტ დროს. ტალღის სიგრძე 77 კჰც სიხშირეზე ძალიან გრძელია, ამიტომ ანტენის ველის ზომები ასევე საკმაოდ ღირსეულია (ფოტო ვიკიპედიიდან):


ასეთი ანტენით და დენის შეყვანით, მიმღების ზონა მოიცავს თითქმის მთელ ევროპას, ბელორუსიას, უკრაინას და რუსეთის ნაწილს.

ნებისმიერს შეუძლია სიგნალის ჩაწერა. ამისათვის უბრალოდ გადადით ონლაინ მიმღებზე http://websdr.ewi.utwente.nl:8901/აირჩიეთ სიხშირე 76.5KHz და USB მოდულაცია. ამის მსგავსი სურათი უნდა გაიხსნას:

იქ ჩვენ ვაჭერთ ჩამოტვირთვის ღილაკს და ჩავწერთ ფრაგმენტს რამდენიმე წუთის განმავლობაში. რა თქმა უნდა, თუ თქვენ გაქვთ "ნამდვილი" მიმღები, რომელსაც შეუძლია ჩაწეროს 77.5KHz სიხშირე, შეგიძლიათ გამოიყენოთ იგი.

რა თქმა უნდა, ინტერნეტის საშუალებით რადიო დროის სიგნალების მიღებით, ჩვენ ნამდვილად არ მივიღებთ ზუსტ დროს - სიგნალი გადადის დაგვიანებით. მაგრამ ჩვენი მიზანი მხოლოდ სიგნალის სტრუქტურის გაგებაა; ამისათვის ინტერნეტის ჩაწერა საკმარისზე მეტია. რეალურ ცხოვრებაში, რა თქმა უნდა, სპეციალიზებული მოწყობილობები გამოიყენება მიღებისა და დეკოდირებისთვის; ისინი ქვემოთ იქნება განხილული.

ასე რომ, ჩვენ მივიღეთ ჩანაწერი, დავიწყოთ მისი დამუშავება.

სიგნალის დეკოდირება

მოდით ჩატვირთოთ ფაილი პითონის გამოყენებით და ვნახოთ მისი სტრუქტურა:

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 წამის სიგრძით, ბიტების თანმიმდევრობა აღდგება ნულამდე და შევსება იწყება თავიდან.

ზემოაღნიშნულის დაწერა მარტივია პითონში.

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 მიუთითებს, რომ საათი შეიცვლება დღის განათების დროზე მომდევნო საათში. ბიტი 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-ის მოხერხებულობა და სიმარტივე ასევე იზიდავს წვრილმანი ენთუზიასტებს. სულ რაღაც 10-20 დოლარად შეგიძლიათ შეიძინოთ მზა ანტენის მოდული მზა მიმღებით და TTL გამომავალით, რომელიც შეიძლება დაუკავშირდეს Arduino-ს ან სხვა კონტროლერს.


უკვე დაწერილია Arduino-სთვის მზა ბიბლიოთეკები. თუმცა, უკვე ცნობილია, რომ რაც არ უნდა გააკეთოთ მიკროკონტროლერზე, ან საათით ან მეტეოროლოგიური სადგურით. ასეთი მოწყობილობით ზუსტი დროის დადგენა ნამდვილად მარტივია, რა თქმა უნდა, იმ პირობით, რომ მიმღებ ზონაში იმყოფებით. კარგად, შეგიძლიათ დაკიდოთ წარწერა "ატომური საათი" თქვენს საათზე და ამავე დროს აუხსნათ ყველას, რომ მოწყობილობა ნამდვილად სინქრონიზებულია ატომური საათის გამოყენებით.

მსურველებს შეუძლიათ ძველი ბებიის საათის განახლებაც კი, ახალი მექანიზმის დაყენებით რადიო სინქრონიზაციასთან ერთად:

შეგიძლიათ იპოვოთ ebay-ზე საკვანძო სიტყვების „რადიო კონტროლირებადი მოძრაობა“.

და ბოლოს, ლაიფ ჰაკი მათთვის, ვინც აქამდე წაიკითხა. მაშინაც კი, თუ მომდევნო რამდენიმე ათასი კილომეტრის მანძილზე არც ერთი რადიოსიგნალის გადამცემი არ არის, ძნელი არ არის ასეთი სიგნალის შექმნა. Google Play-ზე არის პროგრამა სახელწოდებით "DCF77 Emulator", რომელიც აწვდის სიგნალს ყურსასმენებზე. ავტორის თქმით, თუ ყურსასმენის მავთულს შემოახვევთ საათს, ისინი აიღებენ სიგნალს (საინტერესოა როგორ, რადგან ჩვეულებრივი ყურსასმენები არ გამოიმუშავებენ 77KHz სიგნალს, მაგრამ მიღება ალბათ ჰარმონიის გამო ხდება). Android 9-ზე პროგრამა საერთოდ არ მუშაობდა ჩემთვის - უბრალოდ არ იყო ხმა (ან შეიძლება მე არ გამიგია - ბოლოს და ბოლოს ეს არის 77KHz :), მაგრამ იქნებ ვინმეს უკეთესი იღბალი ჰქონდეს. თუმცა, ზოგიერთი თავად ქმნის სრულფასოვან DCF სიგნალის გენერატორს, რომლის დამზადება მარტივია იმავე Arduino-ზე ან ESP32-ზე:

(წყარო sgfantasytoys.wordpress.com/2015/05/13/synchronize-radio-controlled-watch-without-access)

დასკვნა

DCF სისტემა მართლაც საკმაოდ მარტივი და მოსახერხებელი აღმოჩნდა. მარტივი და იაფფასიანი მიმღების დახმარებით შეგიძლიათ ყოველთვის და ყველგან გქონდეთ ზუსტი დრო, რა თქმა უნდა მისაღებში. როგორც ჩანს, მიუხედავად ფართო დიგიტალიზაციისა და ნივთების ინტერნეტის მიუხედავად, ასეთი მარტივი გადაწყვეტილებები დიდი ხნის განმავლობაში იქნება მოთხოვნადი.

წყარო: www.habr.com