POCSAG पेजिंग प्रोटोकॉल को समझना

बहुत समय पहले, जब एक मोबाइल फोन की कीमत लगभग 2000 डॉलर थी और एक मिनट की वॉयस कॉल 50 सेंट थी, पेजर्स वास्तव में लोकप्रिय थे। बाद में सेलुलर फोन सस्ते हो गए, कॉल और एसएमएस की कीमतें कम हो गईं, और अंत में पेजर्स ज्यादातर गायब हो गए।


उन लोगों के लिए, जिनके पास पहले एक पेजर था, और जानना चाहते थे कि यह कैसे काम करता है, यह लेख उपयोगी होगा।

मुख्य जानकारी

उन लोगों के लिए जो सिद्धांतों को भूल गए थे या 2000x के बाद पैदा हुए थे, मैं जल्द ही मुख्य विचारों को याद दिलाऊंगा।

पेजिंग संचार नेटवर्क के कुछ फायदे हैं, जो कभी-कभी अब भी महत्वपूर्ण हैं:

- इसका एक तरह से संचार, बिना किसी प्रकार की पुष्टि के, इसलिए नेटवर्क को ओवरलोड नहीं किया जा सकता है - यह सिर्फ कई उपयोगकर्ताओं से निर्भर नहीं करता है। संदेश लगातार "जैसा है" प्रसारित कर रहे हैं, एक के बाद एक, और पेजर को संदेश मिल रहा है यदि इसकी संख्या (जिसे कैपकोड कहा जाता है) डिवाइस आंतरिक संख्या के बराबर है।

- रिसीवर बहुत हल्का है (शाब्दिक और इलेक्ट्रॉनिक दोनों), और 2 एए बैटरी से एक महीने तक काम कर सकता है।

संदेश भेजने के दो बुनियादी मानक हैं - POCSAG (पोस्ट ऑफिस कोड मानकीकरण सलाहकार समूह) और फ्लेक्स । दोनों मानक बहुत पुराने हैं, POCSAG 1982 में बनाया गया था, यह 512, 1200 और 2400 बिट / एस की गति का समर्थन कर सकता है। FSK संचारित करने के लिए (फ़्रीक्वेंसी शिफ्ट कीइंग) विधि का उपयोग 4.5KHz फ़्रीक्वेंसी सेपरेशन के साथ किया जाता है। फ्लेक्स थोड़ा नया है (90 वें में मोटोरोला द्वारा बनाया गया था), यह 6400 बिट / एस की गति के साथ काम कर सकता है और एफएसके 2 और एफएसके 4 दोनों का उपयोग कर सकता है।

दोनों प्रोटोकॉल सामान्य रूप से बहुत आसान हैं, और लगभग 20 साल पहले पीसी-डिकोडर्स बनाए गए थे, जो कि साउंड कार्ड के एक सीरियल पोर्ट से संदेशों को डिकोड कर सकते हैं (कोई एन्क्रिप्शन समर्थित नहीं हैं, इसलिए सभी संदेशों को किसी के द्वारा पढ़ा जा सकता है)।

आओ यह देखो, यह कैसे काम करता है।

संकेत प्राप्त करना

सबसे पहले, हमें डिकोडिंग के लिए एक संकेत की आवश्यकता है। चलो एक लैपटॉप, rtl-sdr रिसीवर लें, और इसे प्राप्त करें।



फ़्रीक्वेंसी शिफ़्ट कीइंग का उपयोग किया जाता है, इसलिए हम FM सेट करेंगे। HDSDR के साथ हम WAV प्रारूप में एक संकेत को बचाएंगे।

आइए देखें, क्या मिलता है। एक अजगर डेटा सरणी के रूप में लोड wav-file:

from scipy.io import wavfile import matplotlib.pyplot as plt fs, data = wavfile.read("pocsag.wav") plt.plot(data) plt.show() 

आउटपुट (बिट्स मैन्युअल रूप से जोड़े गए):



जैसा कि हम देख सकते हैं, इसका आसान और यहां तक ​​कि "नग्न आंखों के साथ" हम बिट्स को पेंट में आकर्षित कर सकते हैं, यह भेद करना आसान है कि "0" कहां है और "1" कहां है। लेकिन इसे मैन्युअल रूप से करना बहुत लंबा होगा, प्रक्रिया को स्वचालित करने के लिए इसका समय।

ग्राफ़ को बड़ा करने के बाद, हम देख सकते हैं कि प्रत्येक बिट में 20 नमूनों की चौड़ाई है। हमारे पास प्रति सेकंड बिटरेट wav फ़ाइल में 24000 नमूने हैं, इसलिए कुंजीयन गति 1200bit / s है। एक शून्य पार करने की स्थिति की खोज करें - बिट अनुक्रम की शुरुआत। यह सत्यापित करने के लिए मार्कर भी जोड़ें कि सभी बिट्स उचित स्थानों पर हैं।

 speed = 1200 fs = 24000 cnt = int(fs/speed) start = 0 for p in range(2*cnt): if data[p] < - 50 and data[p+1] > 50: start = p break # Bits frame bits = np.zeros(data.size) for p in range(0, data.size - cnt, cnt): bits[start + p] = 500 plt.plot(bits) 

जैसा कि हम देख सकते हैं, इसका पूरी तरह से मेल नहीं खाता (ट्रांसमीटर और रिसीवर में थोड़ी भिन्न आवृत्तियाँ हैं), लेकिन यह निश्चित रूप से डिकोडिंग के लिए पर्याप्त है।



लंबे संकेतों के लिए हमें संभवतः स्वचालित आवृत्ति सुधार एल्गोरिथ्म की आवश्यकता होगी, लेकिन इस तरह के संकेतों के लिए यह महत्वपूर्ण नहीं है।

अंतिम चरण - हमें बिट अनुक्रम में wav फ़ाइल का अनुवाद करने की आवश्यकता है। यह भी आसान है, हम प्रत्येक बिट की लंबाई जानते हैं, यदि डेटा योग सकारात्मक है, तो हम "1" जोड़ देंगे, अन्यथा "0" (अंत में पाया गया कि सिग्नल को वापस करने की आवश्यकता है, इसलिए 0 और 1 को बदल दिया गया था) ।

 bits_str = "" for p in range(0, data.size - cnt, cnt): s = 0 for p1 in range(p, p+cnt): s += data[p] bits_str += "1" if s < 0 else "0" print("Bits") print(bits_str) 

आउटपुट - उचित बिट अनुक्रम (एक स्ट्रिंग प्रारूप में), जिसमें हमारा संदेश होता है।

101010101010101010101010101010101010101010101010101010101010101010101010101
010101010101010101010101010101010101010101010100111110011010010000101001101
100001111010100010011100000110010111011110101000100111000001100101110111101
010001001110000011001011101111010100010011100000110010111011110101000100111
000001100101110111101010001001110000011001011101111010100010011100000110010
011011110101000100111000001100101110111101010001001110000011001011101111010
100010011100000110010111011110101000100111000001100101110111101010001001110
...
111101111

केवल संख्यात्मक संदेश डिकोड करना

एक वेव-फाइल की तुलना में थोड़ा अनुक्रम बहुत अधिक सुविधाजनक है, हम इससे डेटा निकाल सकते हैं। सबसे पहले, डेटा को 4 बाइट ब्लॉक में विभाजित करने देता है।

10101010101010101010101010101010
10101010101010101010101010101010
10101010101010101010101010101010
10101010101010101010101010101010

01111100110100100001010011011000
01111010100010011100000110010111
01111010100010011100000110010111
01111010100010011100000110010111
01111010100010011100000110010111
00001000011011110100010001101000
10000011010000010101010011010100

01111100110100100001010111011000
11110101010001000001000000111000
01111010100010011100000110010111
01111010100010011100000110010111
01111010100010011100000110010111
00100101101001011010010100101111

हम निश्चित रूप से एक पैटर्न देख सकते हैं। अब हमें यह खोजने की जरूरत है कि प्रत्येक भाग का क्या मतलब है। POCSAG मैनुअल पीडीएफ प्रारूप में उपलब्ध है , जो डेटा संरचनाओं के विवरण की जांच करता है।



यह अब बहुत स्पष्ट है। हेडर में एक लंबा ब्लॉक "10101010101" होता है, इसका उपयोग स्लीप मोड से पेजर को "जाग्रत" करने के लिए किया जाता है। संदेश में ही ब्लॉक बैच -1 शामिल है ... बैच-एन, प्रत्येक ब्लॉक अद्वितीय अनुक्रम एफएससी से शुरू हो रहा है। फिर, जैसा कि हम मैनुअल में देख सकते हैं, यदि स्ट्रिंग "0" से शुरू होती है, तो इसमें प्राप्तकर्ता का पता होता है। पता स्वयं (कैपकोड) संग्रहीत है पेजर है, और यदि यह मेल नहीं खाता है, पेजर संदेश को अनदेखा कर देगा। यदि एक स्ट्रिंग "1" से शुरू होती है, तो इसमें संदेश का मुख्य भाग होता है। हमारे उदाहरण में हमारे पास इस प्रकार के 2 तार हैं।

प्रत्येक ब्लॉक की जांच न करें। हम निष्क्रिय कोड भी देख सकते हैं - खाली ब्लॉक 01111 ... 0111, उनके पास कोई उपयोगी जानकारी नहीं है। उन्हें हटाने के बाद, हमें केवल यही मिलता है:

01111100110100100001010011011000 - Frame Sync
00001000011011110100010001101000 - Address
10000011010000010101010011010100 - Message

01111100110100100001010111011000 - Frame Sync
11110101010001000001000000111000 - Message
00100101101001011010010100101111 - Address

हमें खोजने की जरूरत है, अंदर क्या है।

मैनुअल की जाँच के बाद यह स्पष्ट होता है कि दो प्रकार के संदेश हैं - न्यूमेरिक-केवल और अल्फा-न्यूमेरिक । न्यूमेरिक-केवल संदेशों को 4 बिट बीसीडी-कोड के रूप में सहेजा जाता है, इसलिए 20 बिट्स में 5 प्रतीक हो सकते हैं (सीआरसी बिट्स भी हैं, हम उन्हें अभी उपयोग नहीं कर रहे हैं)। यदि संदेश अल्फा-न्यूमेरिक है, तो 7-बिट एएससीआईआई एन्कोडिंग का उपयोग किया जाता है। यह संदेश बहुत छोटा है, इसलिए यह केवल संख्यात्मक-केवल संदेश हो सकता है।

तार से 10000011010000010101010011010100 और 11110101010001000001000000111000 से हम इस 4-बिट क्रम प्राप्त कर सकते हैं:
1 0000 0110 1000 0010 10101 0011010100 - 0h 6h 8h 2h आह
1 1110 1010 1000 1000 00100 0000111000 - एह अह 8 ह 8 ह 2 ह

अगला कदम, मैनुअल से डिकोडिंग तालिका प्राप्त करना है:



यह स्पष्ट है कि एक संख्यात्मक-केवल संदेश में अंक 0-9, अक्षर U ("कुरूप"), स्थान और दो कोष्ठक हो सकते हैं। इसे डिकोड करने के लिए एक छोटी विधि लिखते हैं:

 def parse_msg(block): # 16 lines in a batch, each block has a length 32 bits for cw in range(16): cws = block[32 * cw:32 * (cw + 1)] if cws[0] == "0": addr = cws[1:19] print(" Addr:" + addr) else: msg = cws[1:21] print(" Msg: " + msg) size = 4 s = "" for ind in range(0, len(msg), size): bcd_s = msg[ind:ind + size] value = int(bcd_s, 2) symbols = "0123456789*U -)(" s += symbols[value] print(" ", s) print() 

अंत में, हमें एक संदेश "0682 *) * 882" मिलता है।

इसका यह बताना कठिन है कि इसका क्या अर्थ है, लेकिन यदि केवल संख्यात्मक संदेशों का उपयोग किया जाता है, तो किसी को इसकी आवश्यकता है।

डिकोडिंग अल्फा-न्यूमेरिक मैसेजेस

अगला, और अधिक दिलचस्प कदम, अल्फा-न्यूमेरिक संदेशों को डिकोड करना है। यह अधिक दिलचस्प है, क्योंकि आउटपुट के रूप में, हमें मानव पठनीय पाठ प्राप्त करना चाहिए।

सबसे पहले, हमें एक संदेश फिर से रिकॉर्ड करने की आवश्यकता है, हम एचडीएसडीआर का उपयोग करेंगे। हम डिकोडिंग से पहले एक संदेश प्रकार नहीं जानते हैं, इसलिए हम सिर्फ एक लंबा संदेश रिकॉर्ड करेंगे, हम प्राप्त कर सकते हैं, और उम्मीद करेंगे कि इसमें कुछ पाठ शामिल हैं।



Wav से बिट अनुक्रम में परिवर्तित करने के बाद (ऊपर एक पायथन कोड देखें), हम इसे प्राप्त कर रहे हैं:



कुछ दिलचस्प चीजें हम तुरंत देख सकते हैं, एक नग्न आंखों के साथ - उदाहरण के लिए, प्रारंभ अनुक्रम 01010101010101 दो बार दोहरा रहा है। इस प्रकार, यह संदेश केवल लंबा नहीं है, इसमें शाब्दिक रूप से दो संदेश शामिल हैं, एक साथ विलय (एक मानक इस बात से इनकार नहीं कर रहा है, btw)।

जैसा कि हमने पहले पाया है, प्रत्येक डेटा ब्लॉक एक अनुक्रम से शुरू हो रहा है, जिसे फ़्रेम सिंक कोड (01111100 ...) कहा जाता है, इसके बाद 32-बिट ब्लॉक भेज रहे हैं। प्रत्येक ब्लॉक पते या संदेश निकाय को संग्रहीत कर सकता है।

पहले हमें संख्यात्मक-केवल संदेश मिलते थे, अब हम ASCII- संदेश पढ़ना चाहते हैं। सबसे पहले, हमें उन्हें अलग करने की जरूरत है। यह डेटा एक "फ़ंक्शन बिट्स" फ़ील्ड (बिट्स 20-21) में सहेजा गया है - यदि दोनों बिट्स 00 हैं, तो इसका न्यूमेरिक-मैसेज, यदि बिट्स 11 हैं, तो इसका टेक्स्ट मैसेज है।

उल्लेख करने के लिए दिलचस्प है, वह संदेश क्षेत्र 20-बिट लंबा है, इसलिए संख्यात्मक-केवल संदेश के मामले में पांच 4-बिट ब्लॉकों को वहां रखने के लिए इसका आदर्श है। लेकिन अगर हमारे पास 7bit ASCII- संदेश है, तो हम 20 से 7 को विभाजित नहीं कर सकते हैं। यह अनुमान लगाना संभव है कि पहला प्रोटोकॉल संस्करण केवल संख्यात्मक-केवल संदेशों का समर्थन कर रहा था (यह मत भूलो कि यह 1982 में बनाया गया था और शायद पहले निक्सी-ट्यूब पेजर्स अधिक प्रदर्शित करने में सक्षम नहीं थे ), और केवल बाद में ASCII- संदेश समर्थन जोड़ा गया था। विरासत के कारणों के कारण फ्रेमिंग मानक को नहीं बदला गया था, और डेवलपर्स ने आसान दृष्टिकोण का उपयोग किया - वे बस "बिट्स" के रूप में संयुक्त हैं, एक के बाद एक। प्रत्येक संदेश से हमें 20 बिट लेने और अगले में विलय करने की आवश्यकता है, अंत में हम संदेश बॉडी को डीकोड कर सकते हैं।

हमारे संदेश के एक ब्लॉक को देखें (रिक्त स्थान आसान पढ़ने के लिए जोड़ रहे थे):

0 0001010011100010111111110010010
1 00010100000110110011 11100111001
1 01011010011001110100 01111011100
1 11010001110110100100 11011000100
1 11000001101000110100 10011110111
1 11100000010100011011 11101110000
1 00110010111011001101 10011011010
1 00011001011100010110 10011000010
1 10101100000010010101 10110000101
1 00010110111011001101 00000011011
1 10100101000000101000 11001010100
1 00111101010101101100 11011111010

"0" बिट पहले स्ट्रिंग में हमें दिखाता है कि यह पता फ़ील्ड है, और 20-21 बिट्स में "11" हमें दिखाता है कि संदेश वास्तव में अल्फा-न्यूमेरिक है। फिर हम बस हर स्ट्रिंग से 20 बिट लेते हैं और इसे एक साथ मर्ज करते हैं।

यह हमारा बिट क्रम है:

00010100000110110011010110100110011101001101000111011010010011000001101000
11010011100000010100011011001100101110110011010001100101110001011010101100
000010010101000101101110110011011010010100000010100000111101010101101

POCSAG में 7-बिट ASCII कोड का उपयोग किया जाता है, इसलिए हम एक स्ट्रिंग को 7 char ब्लॉक्स में विभाजित करेंगे:

0001010 0000110 1100110 1011010 0110011 1010011 ...

इसे डिकोड करने की कोशिश करने के बाद (ASCII टेबल को इंटरनेट में आसानी से पाया जा सकता है), हमें मिल रहा है ... बस कुछ नहीं। मैनुअल को फिर से जाँचना, और यहाँ छोटा वाक्यांश है "ASCII वर्णों को बाएं से दाएं (MSB से LSB) रखा गया है। एलएसबी पहले संचारण कर रहा है। ” तो, कम बिट पहले संचारण कर रहा है - सही डिकोडिंग के लिए हमें सभी तारों को उलटने की आवश्यकता है।

यह मैन्युअल रूप से करने के लिए बहुत उबाऊ है, तो आइए पायथन कोड लिखें:

 def parse_msg(block): msgs = "" for cw in range(16): cws = block[32 * cw:32 * (cw + 1)] # Skip the idle word if cws.startswith("0111101010"): continue if cws[0] == "0": addr, type = cws[1:19], cws[19:21] print(" Addr:" + addr, type) else: msg = cws[1:21] print(" Msg: " + msg) msgs += msg # Split long string to 7 chars blocks bits = [msgs[i:i+7] for i in range(0, len(msgs), 7)] # Get the message msg = "" for b in bits: b1 = b[::-1] # Revert string value = int(b1, 2) msg += chr(value) print("Msg:", msg) print() 

अंत में, हम इस अनुक्रम (बिट्स, प्रतीक कोड और ASCII प्रतीक) प्राप्त कर रहे हैं:

 0101000 40 ( 0110000 48 0 0110011 51 3 0101101 45 - 1100110 102 f 1100101 101 e 1100010 98 b 0101101 45 - 0110010 50 2 0110000 48 0 0110001 49 1 0111001 57 9 0100000 32 0110001 49 1 0110011 51 3 0111010 58 : 0110011 51 3 0110001 49 1 0111010 58 : 0110100 52 4 0110101 53 5 0100000 32 0101010 42 * 0110100 52 4 0110111 55 7 0110110 54 6 0101001 41 ) 0100000 32 1000001 65 A 1010111 87 W 1011010 90 Z 

विलय के बाद हम स्ट्रिंग प्राप्त कर रहे हैं: "(03-feb-2019 13:31:45 * 476) AWZ"। जैसा कि वादा किया गया था, इसका सुंदर मानव पठनीय है।

वैसे, इसका उल्लेख दिलचस्प है, कि 7-बिट एएससीआईआई कोड का उपयोग किया जाता है। कुछ अक्षरों (जर्मन, सिरिलिक, आदि) के प्रतीकों को 7 बिट्स में ठीक से एन्कोड नहीं किया जा सकता है। 7 बिट्स क्यों? संभवतः इंजीनियरों ने तय किया था कि "7 बिट्स सभी के लिए पर्याप्त होंगे", कौन जानता है ...

निष्कर्ष

POCSAG कैसे काम करता है, यह जांच करना वास्तव में दिलचस्प था। यह दुर्लभ प्रोटोकॉल में से एक है, जो अब तक उपयोग में हैं, जो कि शाब्दिक रूप से कागज की शीट पर डिकोड किया जा सकता है (और मैं निश्चित रूप से टीईटीआरए या जीएसएम के साथ यह कोशिश नहीं करूंगा)।

निश्चित रूप से, POCSAG प्रोटोकॉल यहां पूरी तरह से वर्णित नहीं है। सबसे महत्वपूर्ण और दिलचस्प हिस्सा किया जाता है, अन्य सामान इतना रोमांचक नहीं है। कम से कम, कोई कैकोडोड डिकोडिंग नहीं है, और कोई त्रुटि सुधार कोड (बीसीएच चेक बिट्स) नहीं है - यह संदेश में 2 गलत बिट्स को ठीक करने की अनुमति दे सकता है। लेकिन यहां एक और POCSAG डिकोडर लिखने का कोई लक्ष्य नहीं था, उनमें से पहले से ही पर्याप्त हैं।

जो लोग rtl-sdr के साथ वास्तविक डिकोडिंग का परीक्षण करना चाहते हैं, उनके लिए फ्रीवेयर PDW एप्लिकेशन का उपयोग किया जा सकता है। यह वर्चुअल ऑडियो केबल एप्लिकेशन के माध्यम से HDSDR से PDW तक ध्वनि को अग्रेषित करने के लिए केवल इसकी पर्याप्त स्थापना की आवश्यकता नहीं है।

परिणाम इस तरह दिखते हैं:



(कृपया ध्यान रखें कि सार्वजनिक सेवा संदेश डिकोडिंग कुछ देशों में अवैध हो सकता है, और वैसे भी प्राप्तकर्ता की गोपनीयता का सम्मान कर सकते हैं)

यदि कोई इस विषय के बारे में अधिक जानकारी प्राप्त करना चाहता है, तो मल्टीमोन-एनजी डिकोडर के स्रोत उपलब्ध हैं, यह कई प्रोटोकॉल को डिकोड कर सकता है, POCSAG और फ्लेक्स भी।

पढ़ने के लिए धन्यवाद।