DCF77: टाइम सिग्नल प्रणाली कैसे काम करती है?

हैलो हैबर।

संभवतः घड़ी या मौसम स्टेशन खरीदने वाले कई लोगों ने पैकेजिंग पर रेडियो नियंत्रित घड़ी या यहां तक ​​कि परमाणु घड़ी का लोगो देखा होगा। यह बहुत सुविधाजनक है, क्योंकि आपको बस घड़ी को मेज पर रखना होगा, और थोड़ी देर बाद यह स्वचालित रूप से सटीक समय पर समायोजित हो जाएगी।


आइए जानें कि यह कैसे काम करता है और पायथन में एक डिकोडर लिखें।

अलग-अलग समय तुल्यकालन प्रणालियाँ हैं। यूरोप में सबसे लोकप्रिय जर्मन प्रणाली है डीसीएफ-77, जापान का अपना सिस्टम है जे जे वाई, संयुक्त राज्य अमेरिका में एक प्रणाली है डब्ल्यूडब्ल्यूवीबी, और इसी तरह। आगे, कहानी DCF77 के बारे में होगी, जो रूस और पड़ोसी देशों के यूरोपीय भाग में कुछ स्थानों पर स्वागत के लिए सबसे अधिक प्रासंगिक और सुलभ है (सुदूर पूर्व के निवासियों की राय विपरीत हो सकती है, हालांकि, वे, बदले में, प्राप्त कर सकते हैं) और जापानी सिग्नल का विश्लेषण करें;)।

नीचे लिखी हर बात DCF77 के बारे में होगी.

सिग्नल रिसेप्शन

DCF77 एक लंबी तरंग स्टेशन है जो 77.5 kHz की आवृत्ति पर संचालित होता है और आयाम मॉड्यूलेशन में सिग्नल प्रसारित करता है। 50KW स्टेशन फ्रैंकफर्ट से 25 किमी दूर स्थित है, इसका संचालन 1959 में शुरू हुआ था, और 1973 में तारीख की जानकारी सटीक समय में जोड़ दी गई थी। 77 KHz की आवृत्ति पर तरंग दैर्ध्य बहुत लंबा है, इसलिए एंटीना क्षेत्र के आयाम भी काफी अच्छे हैं (विकिपीडिया से फोटो):


ऐसे एंटीना और पावर इनपुट के साथ, रिसेप्शन क्षेत्र लगभग पूरे यूरोप, बेलारूस, यूक्रेन और रूस के हिस्से को कवर करता है।

कोई भी सिग्नल रिकॉर्ड कर सकता है. ऐसा करने के लिए, बस ऑनलाइन रिसीवर के पास जाएं 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" जोड़ें। प्रत्येक मिनट के अंत को 2s लंबी "लंबी" पल्स द्वारा इंगित किया जाता है, बिट अनुक्रम शून्य पर रीसेट हो जाता है, और भरना फिर से शुरू होता है।

उपरोक्त को 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 इंगित करता है कि घड़ी अगले घंटे में डेलाइट सेविंग टाइम में बदल जाएगी। बिट 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 बिट्स जमा करते हैं, और प्रत्येक मिनट के अंत में हमें सटीक समय मिलता है। समय सिंक्रनाइज़ेशन के अन्य तरीकों (उदाहरण के लिए जीपीएस, या भगवान न करे, इंटरनेट:) की तुलना में, ऐसे रेडियो सिंक्रनाइज़ेशन के लिए वस्तुतः कोई बिजली की आवश्यकता नहीं होती है - उदाहरण के लिए, एक नियमित घरेलू मौसम स्टेशन 2 एए बैटरी पर लगभग एक वर्ष तक चलता है। इसलिए, यहां तक ​​कि कलाई घड़ियाँ भी रेडियो सिंक्रोनाइज़ेशन के साथ बनाई जाती हैं, दीवार घड़ियाँ या स्ट्रीट स्टेशन घड़ियाँ तो छोड़ ही दें।

DCF की सुविधा और सरलता भी DIY उत्साही लोगों को आकर्षित करती है। मात्र 10-20 डॉलर में आप रेडीमेड रिसीवर और टीटीएल आउटपुट के साथ रेडीमेड एंटीना मॉड्यूल खरीद सकते हैं, जिसे Arduino या अन्य कंट्रोलर से जोड़ा जा सकता है।


Arduino के लिए पहले ही लिखा जा चुका है तैयार पुस्तकालय. हालाँकि, यह पहले से ही ज्ञात है कि चाहे आप माइक्रोकंट्रोलर पर कुछ भी करें, अंत में आपके पास एक घड़ी या एक मौसम स्टेशन ही होगा। ऐसे उपकरण के साथ, सटीक समय प्राप्त करना वास्तव में आसान है, बशर्ते, कि आप रिसेप्शन क्षेत्र में हों। खैर, आप अपनी घड़ी पर शिलालेख "परमाणु घड़ी" लटका सकते हैं, और साथ ही सभी को समझा सकते हैं कि डिवाइस वास्तव में परमाणु घड़ी का उपयोग करके सिंक्रनाइज़ किया गया है।

जो लोग चाहें वे रेडियो सिंक्रोनाइज़ेशन के साथ एक नया तंत्र स्थापित करके अपनी पुरानी दादी की घड़ी को भी अपग्रेड कर सकते हैं:

आप इसे eBay पर "रेडियो नियंत्रित मूवमेंट" कीवर्ड का उपयोग करके पा सकते हैं।

और अंत में, उन लोगों के लिए एक जीवन हैक जिन्होंने इसे अब तक पढ़ा है। भले ही अगले कुछ हज़ार किमी में एक भी रेडियो सिग्नल ट्रांसमीटर न हो, ऐसे सिग्नल को स्वयं उत्पन्न करना मुश्किल नहीं है। Google Play पर "DCF77 एमुलेटर" नामक एक प्रोग्राम है जो हेडफ़ोन को सिग्नल आउटपुट करता है। लेखक के अनुसार, यदि आप हेडफ़ोन के तार को घड़ी के चारों ओर लपेटते हैं, तो वे सिग्नल पकड़ लेंगे (यह दिलचस्प है कि कैसे, क्योंकि साधारण हेडफ़ोन 77KHz सिग्नल उत्पन्न नहीं करेंगे, लेकिन रिसेप्शन संभवतः हार्मोनिक्स के कारण होता है)। एंड्रॉइड 9 पर, प्रोग्राम ने मेरे लिए बिल्कुल भी काम नहीं किया - बस कोई आवाज नहीं थी (या शायद मैंने इसे नहीं सुना - यह 77KHz है, आखिरकार :), लेकिन शायद किसी की किस्मत बेहतर होगी। हालाँकि, कुछ लोग स्वयं एक पूर्ण विकसित DCF सिग्नल जनरेटर बनाते हैं, जिसे समान Arduino या ESP32 पर बनाना आसान है:

(स्रोत sgfantasytoys.wordpress.com/2015/05/13/synchronize-radio-controlled-watch-without-access)

निष्कर्ष

डीसीएफ प्रणाली वास्तव में काफी सरल और सुविधाजनक साबित हुई। एक सरल और सस्ते रिसीवर की मदद से, आप हमेशा और हर जगह, निश्चित रूप से रिसेप्शन क्षेत्र में, सटीक समय जान सकते हैं। ऐसा लगता है कि व्यापक डिजिटलीकरण और इंटरनेट ऑफ थिंग्स के बावजूद भी, ऐसे सरल समाधान लंबे समय तक मांग में रहेंगे।

स्रोत: www.habr.com