🧗 🧑‍🤝‍🧑 👩🏼 8-बिट मोर्स कोड 👍🏽 👆 🏊

इलेक्ट्रॉनिक शिल्प में request-कोड का उपयोग करने के प्रेमियों में से एक के अनुरोध पर, एक फ़ंक्शन (सबप्रोग्राम, प्रक्रिया) लिखना आवश्यक हो गया जो डॉट्स और डैश के अनुक्रम से एक ट्रिल जारी करेगा। मोर्स कोड में, एक वर्ण की लंबाई 1 वर्ण (अक्षर E और T) से 9 वर्ण (SOS ट्रिग्राफ) हो सकती है। एक पैरामीटर के रूप में उपरोक्त फ़ंक्शन को क्या पास करना है? यदि आपको लाइसेंस की शर्तों का बोझ नहीं है , तो मैं आपको मोर्स कोड को 1 बाइट में भरने की प्रक्रिया से परिचित होने के लिए आमंत्रित करता हूं ।

मोर्स कोड में, 1-6 वर्ण लंबे वर्ण अक्सर उपयोग किए जाते हैं।

; . Ee   ; - Tt  ; .. Ii  ; .- Aa  ; -. Nn  ; -- Mm  ; ... Ss  ; ..- Uu  ; .-. Rr  ; .-- Ww  ; -.. Dd  ; -.- Kk  ; --. Gg  ; --- Oo  ; .... Hh  ; ...- Vv  ; ..-. Ff  ; ..--  ; .-.. Ll  ; .-.-  [AA] digraph UNKNOWN STATION ; .--. Pp  ; .--- Jj  ; -... Bb  ; -..- Xx   ; -.-. Cc  ; -.-- Yy  ; --.. Zz  ; --.- Qq  ; ---.  ; ----  ; .---- 1 ; ..--- 2 ; ...-- 3 ; ....- 4 ; ..... 5 ; -.... 6 ; --... 7 ; ---.. 8 ; ----. 9 ; ----- 0 ; ..-..  ; ..-.- [INT] trigraph - military network question marker ; -..-. Slash/Fraction Bar [/] ; -.--. Parenthesis (Open) ; .-... [AS] digraph - Ampersand (or "Wait") [&] ; -...- [BT] digraph - Double Dash = or -- ; .-.-. Plus sign [+] ; .-.-. [AR] digraph - New Page Signal ; -.-.- Starting Signal ; ...-. Understood ; .--.-.  ; .-.-.- Period [.] ; --..-- Comma [,] ; ..--.. [UD] digraph Question Mark [?] ; .----. Apostrophe ['] ; -.-.-- [KW] digraph - Exclamation Point [!] ; -.--.- Parenthesis (Close) ; ---... Colon [:] ; -.-.-. Semicolon [;] ; -....- Hyphen, Minus Sign [-] ; ..--.- Underscore [_] ; .-..-. Quotation mark ["] ; .--.-. [AC] digraph - At Sign [@] ; ...-.- End of work ; ...-..- [SX] digraph - Dollar sign [$] ; ........ [HH] digraph - Error/correction ; ...---... [SOS] trigraph

इन पात्रों को 8-बिट तर्क में रखा जाएगा। एक बाइट में वर्णों का क्रम होना चाहिए (1 से 6 तक) और उनकी संख्या (1 से 6 तक) भी। अक्षरों के अनुक्रम को शिफ्ट कमांड द्वारा कैरी फ्लैग (कैरी) में धकेलने में आसानी के लिए कम से कम महत्वपूर्ण या उच्चतम बिट पर संरेखित किया जाना चाहिए। हमें काउंटर के स्थान के लिए दो विकल्प मिलते हैं (सी) और वर्णों के अनुक्रम (एस):

; arg [s, x, x, x, x, c, c, c] - 1 वर्ण
; arg [s, s, x, x, x, c, c, c] - 2 अक्षर
; arg [s, s, s, x, x, c, c, c] - 3 वर्ण
; arg [s, s, s, s, x, c, c, c] - 4 वर्ण
; arg [s, s, s, s, s, c, c, c] - 5 अक्षर
; arg [s, s, s, s, s, s / c, c, c] - 6 अक्षर

; arg [c, c, c, x, x, x, x, s] - 1 वर्ण
; arg [c, c, c, x, x, x, s, s] - 2 अक्षर
; arg [c, c, c, x, x, s, s, s] - 3 वर्ण
; arg [c, c, c, x, s, s, s, s] - 4 वर्ण
; arg [c, c, c, s, s, s, s, s] - 5 वर्ण
; arg [c, c, c / s, s, s, s, s, s] - 6 वर्ण

पहले अवतार में, अधिकतम अनुक्रम लंबाई के साथ, 6 वां चरित्र काउंटर के सबसे महत्वपूर्ण बिट पर आरोपित है।

दूसरे अवतार में, अधिकतम अनुक्रम लंबाई के साथ, 1 वर्ण काउंटर के कम से कम महत्वपूर्ण बिट पर आरोपित होता है। इस मामले में, काउंटर के कम से कम महत्वपूर्ण बिट को महत्वहीन माना जा सकता है, क्योंकि दोनों संयोजन 110 और 111 को काउंटर के अधिकतम मूल्य (6) के रूप में लिया जा सकता है। यदि काउंटर का मूल्य 5 या उससे कम है, तो काउंटर के बिट्स पर महत्वपूर्ण संकेत सुपरिम्पोज नहीं किए जाते हैं।

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

; arg [c2, c1, c0 / s6, s5, s4, s3, s2, s1]

मोर्स कोड में, एक बिंदु की अवधि को इकाई समय अंतराल के रूप में लिया जाता है। डैश की अवधि 3 अंतराल है। चरित्र के अंदर के पात्रों के बीच का ठहराव 1 अंतराल है। पात्रों के बीच ठहराव - 4 अंतराल। शब्दों के बीच ठहराव - 7 अंतराल। फ़ंक्शन को सूचित करने के लिए कि संकेतों पर काम करना आवश्यक नहीं है, बस ठहराव संयोजन दर्ज करें:

; arg [0, 0, 0, 0, 0, 0, 0, 0]

तर्क को स्वीकार करने के बाद arg [c2, c1, c0 / s6, s5, s4, s3, s2, s1], फ़ंक्शन को काउंटर और अनुक्रम को इसमें से निकालना चाहिए, वर्ण को "बंद" देखा और इसे 3 अंतरालों के ठहराव के साथ समाप्त करना चाहिए।

शब्दों के बीच एक विराम बनाने के लिए, हम तर्क arg [0, 0, 0, 0, 0, 0, 0, 0] फ़ंक्शन को पास करते हैं। फ़ंक्शन को पिछले चरित्र से 3 अंतराल के बाद के ठहराव के अलावा, 4 अंतराल (कुल 7 अंतराल) के एक ठहराव का काम करना चाहिए।

काउंटर निकालने के लिए, फ़ंक्शन को 5 बिट्स द्वारा arg सामग्री की प्रतिलिपि को दाईं ओर स्थानांतरित करना होगा, AND मास्क (00000111) लागू करें, काउंटर को 6 के बराबर करें यदि 7. बराबर, अगला, दाईं ओर चरण दर चरण, मूल arg से वर्ण निकालें। यदि "0" एक बिंदु है: 1 बीप अंतराल, 1 पॉज़ अंतराल। यदि "1" एक डैश है: 3 बीप अंतराल, 1 पॉज़ अंतराल। अंतिम चरित्र का अभ्यास करने के बाद - 2 ठहराव अंतराल। यदि arg = 0: केवल 4 अंतराल का ठहराव।

यह 8-बिट एन्कोडिंग सभी मोर्स वर्णों को शामिल करती है और 1 से 6 वर्णों तक के डिग्राफ को लंबा करती है। निम्नलिखित उदाहरणों पर विचार करें:

 ; . Ee   arg[0, 0, 1, x, x, x, x, 0] ; - Tt  arg[0, 0, 1, x, x, x, x, 1] ; .. Ii  arg[0, 1, 0, x, x, x, 0, 0] ; .- Aa  arg[0, 1, 0, x, x, x, 1, 0] ; -. Nn  arg[0, 1, 0, x, x, x, 0, 1] ; -- Mm  arg[0, 1, 0, x, x, x, 1, 1] ; ... Ss  arg[0, 1, 1, x, x, 0, 0, 0] ; ..- Uu  arg[0, 1, 1, x, x, 1, 0, 0] ; .-. Rr  arg[0, 1, 1, x, x, 0, 1, 0] ; .-- Ww  arg[0, 1, 1, x, x, 1, 1, 0] ; -.. Dd  arg[0, 1, 1, x, x, 0, 0, 1] ; -.- Kk  arg[0, 1, 1, x, x, 1, 0, 1] ; --. Gg  arg[0, 1, 1, x, x, 0, 1, 1] ; --- Oo  arg[0, 1, 1, x, x, 1, 1, 1] ; .... Hh  arg[1, 0, 0, x, 0, 0, 0, 0] ; ...- Vv  arg[1, 0, 0, x, 1, 0, 0, 0] ; ..-. Ff  arg[1, 0, 0, x, 0, 1, 0, 0] ; ..--  arg[1, 0, 0, x, 1, 1, 0, 0] ; .-.. Ll  arg[1, 0, 0, x, 0, 0, 1, 0] ; .-.-  arg[1, 0, 0, x, 1, 0, 1, 0] ; .--. Pp  arg[1, 0, 0, x, 0, 1, 1, 1] ; .--- Jj  arg[1, 0, 0, x, 1, 1, 1, 0] ; -... Bb  arg[1, 0, 0, x, 0, 0, 0, 1] ; -..- Xx   arg[1, 0, 0, x, 1, 0, 0, 1] ; -.-. Cc  arg[1, 0, 0, x, 0, 1, 0, 1] ; -.-- Yy  arg[1, 0, 0, x, 1, 1, 0, 1] ; --.. Zz  arg[1, 0, 0, x, 0, 0, 1, 1] ; --.- Qq  arg[1, 0, 0, x, 1, 0, 1, 1] ; ---.  arg[1, 0, 0, x, 0, 1, 1, 1] ; ----  arg[1, 0, 0, x, 1, 1, 1, 1] ; .---- 1 arg[1, 0, 1, 1, 1, 1, 1, 0] ; ..--- 2 arg[1, 0, 1, 1, 1, 1, 0, 0] ; ...-- 3 arg[1, 0, 1, 1, 1, 0, 0, 0] ; ....- 4 arg[1, 0, 1, 1, 0, 0, 0, 0] ; ..... 5 arg[1, 0, 1, 0, 0, 0, 0, 0] ; -.... 6 arg[1, 0, 1, 0, 0, 0, 0, 1] ; --... 7 arg[1, 0, 1, 0, 0, 0, 1, 1] ; ---.. 8 arg[1, 0, 1, 0, 0, 1, 1, 1] ; ----. 9 arg[1, 0, 1, 0, 1, 1, 1, 1] ; ----- 0 arg[1, 0, 1, 1, 1, 1, 1, 1] ; ..-..  arg[1, 0, 1, 0, 0, 1, 0, 0] ; ..-.- [INT] arg[1, 0, 1, 1, 0, 1, 0, 0] ; -..-. [/] arg[1, 0, 1, 0, 1, 0, 0, 1] ; -.--. Parenthesis arg[1, 0, 1, 1, 0, 1, 1, 0] ; .-... [&] arg[1, 0, 1, 0, 0, 0, 1, 0] ; -...- [=] arg[1, 0, 1, 1, 0, 0, 0, 1] ; .-.-. [+] arg[1, 0, 1, 0, 1, 0, 1, 0] ; -.-.- Starting Signal arg[1, 0, 1, 1, 0, 1, 0, 1] ; ...-. Understood arg[1, 0, 1, 0, 1, 0, 0, 0] ; .--.-.  arg[1, 1, 0, 1, 0, 1, 1, 0] ; .-.-.- [.] arg[1, 1, 1, 0, 1, 0, 1, 0] ; --..-- [,] arg[1, 1, 1, 1, 0, 0, 1, 1] ; ..--.. [?] arg[1, 1, 0, 0, 1, 1, 0, 0] ; .----. ['] arg[1, 1, 0, 1, 1, 1, 1, 0] ; -.-.-- [!] arg[1, 1, 1, 1, 0, 1, 0, 1] ; -.--.- Parenthesis arg[1, 1, 1, 0, 1, 1, 0, 1] ; ---... [:] arg[1, 1, 0, 0, 0, 1, 1, 1] ; -.-.-. [;] arg[1, 1, 0, 1, 0, 1, 0, 1] ; -....- [-] arg[1, 1, 1, 0, 0, 0, 0, 1] ; ..--.- [_] arg[1, 1, 1, 0, 1, 1, 0, 0] ; .-..-. ["] arg[1, 1, 0, 1, 0, 0, 1, 0] ; .--.-. [@] arg[1, 1, 0, 1, 0, 1, 1, 0] ; ...-.- End of work arg[1, 1, 1, 0, 1, 0, 0, 0]

यदि आप सूखे अवशेषों में बारीकी से देखते हैं:

 ; ...-..- Dollar sign [$] [SX] digraph ; ........ Error/correction [HH] digraph or [EEEEEEEE] ; ...---... [SOS]

यह एक अतिरिक्त फ़ंक्शन void dot3woPostPause () को शुरू करने के लिए तर्कसंगत होगा जिसके बाद [X] (-..-), [5] (.....) या [:] (---...)।

पूर्णता के लिए, "मुश्किल" पथ पर विचार करें। 6 से अधिक वर्णों की लंबाई के साथ मोर्स डिग्राफ और ट्रिग्राफ को वर्कआउट करने के लिए, "अतिरिक्त" वर्णों के बाद "2" अंतराल के बिना "अतिरिक्त" वर्णों के बिना "अतिरिक्त" वर्णों को काम करने के लिए एन्कोडिंग को जोड़ना आवश्यक है।

"अतिरिक्त" वर्णों की संख्या 1 से 3 तक है। काउंटर की अंक क्षमता 2. हम arg बिट्स [4,3] में मीटर लगाते हैं, और arg बिट्स में अनुक्रम [2,1,0]:

; arg [0, 0, 0, c1, c0, s3, s2, s1]

काउंटर निकालने के लिए arg [7,6,5] = 000 के साथ, फ़ंक्शन को arg सामग्री की प्रतिलिपि को 3 बिट्स द्वारा दाईं ओर स्थानांतरित करना होगा, AND मास्क (00000011) लागू करें। अगला, मूल arg से वर्णों को निकालने के दाईं ओर कदम बढ़ाएँ। यदि "0" एक बिंदु है: 1 बीप अंतराल, 1 पॉज़ अंतराल। यदि "1" एक डैश है: 3 बीप अंतराल, 1 पॉज़ अंतराल। अंतिम पात्र को काम करने के बाद, कोई अतिरिक्त रोक नहीं लगाई जाती है।

अब, "लंबे" प्रतीक को काम करने के लिए, आपको पहले वर्णों को बिना पोस्ट-पॉज़ के संसाधित करना होगा, फिर पोस्ट-पॉज़ वाले वर्णों को। इसके लिए दो 8-बिट तर्क आवश्यक हैं। तर्कों में वर्णों की कुल संख्या वर्ण की लंबाई के अनुरूप होनी चाहिए:

 ; ...-..- Dollar sign [$] [SX] digraph ; arg1[0, 0, 0, 0, 1, x, x, 0] arg2[1, 1, 1, 0, 0, 1, 0, 0] ; arg1[0, 0, 0, 1, 0, x, 0, 0] arg2[1, 0, 1, 1, 0, 0, 1, 0] ; arg1[0, 0, 0, 1, 1, 0, 0, 0] arg2[1, 0, 0, x, 1, 0, 0, 1] ; ; ........ Error/correction [HH] digraph or [EEEEEEEE] ; arg1[0, 0, 0, 1, 0, x, 0, 0] arg2[1, 1, 0, 0, 0, 0, 0, 0] ; arg1[0, 0, 0, 1, 1, 0, 0, 0] arg2[1, 0, 1, 0, 0, 0, 0, 0] ; ; ...---... [SOS] ; arg1[0, 0, 0, 1, 1, 0, 0, 0] arg2[1, 1, 0, 0, 0, 1, 1, 1]

8-बिट कोड में मोर्स कोड वर्णों को अलग-अलग प्रोग्रामिंग भाषाओं में और विभिन्न प्लेटफार्मों पर लागू किया जा सकता है। मैक्स (- कोड के प्रेमी) के लिए मैंने STM8 एसएसएम पर "मछली" का स्रोत कोड तैयार किया।

उपयोगकर्ता "एकॉन 32" से वैकल्पिक 8-बिट एन्कोडिंग, जिससे आप दूसरे तर्क से छुटकारा पा सकते हैं:

 ; arg[0, 0, 0, 0, 0, 0, 0, 0] — [HH] +   2  ; arg[0, 0, 0, 0, 1, 0, 0, 1] — [$] +   2  ; arg[1, 0, s1, s2, s3, s4, s5, s6] — [6 ] +   2  ; arg[1, 1, 0, s1, s2, s3, s4, s5] — [5 ] +   2  ; arg[1, 1, 1, 0, s1, s2, s3, s4] — [4 ] +   2  ; arg[1, 1, 1, 1, 0, s1, s2, s3] — [3 ] +   2  ; arg[1, 1, 1, 1, 1, 0, s1, s2] — [2 ] +   2  ; arg[1, 1, 1, 1, 1, 1, 0, s1] — [1 ] +   2  ; arg[1, 1, 1, 1, 1, 1, 1, 0] —    4  ; arg[1, 1, 1, 1, 1, 1, 1, 1] — [SOS] +   2  ;     8 ;      Carry  ;   ('1')  ;   ('0')    (Carry) -      ;  0b00000000, 0b11111111, 0b11111110

अक्षरों के अनुक्रम के विपरीत (जैसे [एस], [ओ], [एस]) डिग्राफ और ट्रिग्राफ (जैसे [एसओएस]) को अंतर-पत्र विराम के बिना संसाधित किया जाता है।

8-बिट मोर्स कोड

More articles: