Shift registers-yOGOMn7CW0I

बेसिक इलेक्ट्रॉनिक्स में फिर सेआपका स्वागत है।
 इस कक्षा में हम शिफ्ट रजिस्टर (shift Register) के साथ जारी रखेंगे, हम एक बाई-डायरेक्शनल (Bi-Directional) शिफ्ट रजिस्टर (shift Register) को देखेंगे, हम यह भी देखेंगे कि 2 शिफ्ट रजिस्टर(shift Register) के बीच एक समानांतर हस्तांतरण कैसे लागू किया जा सकता है, हम देखेंगे कि सीरियल आउट (serial out) में समानांतर डेटा (Data) ट्रांसफर कैसे प्राप्त किया जा सकता है ।
 आगे हम देखेंगे कि कैसे एक जोड़ के साथ शिफ्ट रजिस्टर 2 बाइनरी संख्या को गुणा करने के लिए उपयोग किया जा सकता है।
 अंत में, हम एक नए विषय के साथ शुरू करेंगे जिसका नाम काउंटर होगा।
 तो, हम शुरू करते हैं।
 मान लें कि अब हमारे पास 2 शिफ्ट रजिस्टर (shift Register) हैं यह A 3, A 2, A 1, A 0 हैं जो पहली शिफ्ट रजिस्टर और B 3, B 2, B 1 के बिट्स हैं, B 0 दूसरी शिफ्ट रजिस्टर (shift Register) के बिट हैं।
 हम जो करना चाहते हैं वह डेटा (Data) को स्थानांतरित करना है जो इस पहली पाली में दूसरे नंबर पर है।
 इसलिए यह हासिल करना आसान है, हमें इस B 3 फ्लिप फ्लॉप के D इनपुट के रूप में इस A 3 को जोड़ने की आवश्यकता है; वहाँ पर A 2 और इसी तरह से।
 और अब सक्रिय क्लॉक एज़(edge) के बाद A रजिस्टर ( Register) की मटेरियल (material) को B रजिस्टर ( Register) में कॉपी किया जाएगा, क्योंकि यह A 3 यहां Q के रूप में दिखाई देगा जो कि B 3 A 2 है जो B 2 के रूप में दिखाई देगा और इसी तरह।
 इसलिए, यह एक बहुत आसान ऑपरेशन(operation) है और इसे यहां पर योजनाबद्ध तरीके से दर्शाया गया है।
 जो शिफ्ट रजिस्टर (shift Register) हमने पहले देखा था वह बाएं से दाएं डेटा ( Data) स्थानांतरित कर रहा था, लेकिन हम यहां दिखाया गया एक बाई -डायरेक्शनल (Bi-Directional) शिफ्ट रजिस्टर(shift Register) भी बना सकते हैं जो डेटा(Data) को बाएं से दाएं या दाएं से बाएं स्थानांतरित कर सकते हैं M या मोड(mode) नामक इस इनपुट के वैल्यू (value) के आधार पर।
 जब मोड इनपुट 1 होता है तो डेटा (Data) दाईं ओर शिफ्ट(shift )हो जाता है और अगर यह 0 है तो यह उस दिशा में बाईं ओर शिफ्ट(shift )हो जाता है।
 तो, आइए देखें कि यह कैसे काम करता है।
 आइए हम पहले M को 1 के बराबर लेते हैं: उस स्थिति में क्या होता है यह M बार(bar) 0 है और इस ऐण्ड गेट(AND gate) का आउटपुट 0 है और अनिवार्य रूप से D तब इस इनपुट के समान है।
 और इसी तरह यह D इस इनपुट वगैरह के समान है।
 और फिर आप देखेंगे कि हमारे पास ठीक वही कनेक्शन है जो हमने पहले के उदाहरण में देखा था, और वह शिफ्ट राइट ऑपरेशन(Shift Right Operation) है।
 प्रत्येक क्लॉक एज़(edge) के साथ डेटा(Data) इसके फ्लिप फ्लॉप से इस 1 पर शिफ्ट (shift )हो जाएगा और इसी तरह से।
 M के बराबर 0, के बारे में क्या है? यदि M 0 है, तो इस ऐण्ड गेट(AND gate) का आउटपुट 0 है और फिर उस स्थिति में यह D के समान Q 1 है, और इसी तरह हम पाएंगे कि यह D 1 के समान Q 2है; D 2 के समान Q 3 है और D 3 के समान D L है।
 तो, यह वह संबंध है जिसके बारे में हम अभी बात कर रहे हैं।
 और एक सक्रिय क्लॉक की एज़(edge) के साथ यह D L इस फ्लिप फ्लॉप में लोड (load) हो जाता है जो कुछ भी था Q 3 अब यहाँ आ जाएगा Q 2 जो कुछ भी था अब यहाँ आ जाएगा और इसी तरह से।
 तो, M के बराबर 1 के साथ सारांश में हमारे पास शिफ्ट राइट ऑपरेशन (Shift Right Operation) है और M के बराबर 0 के साथ हमारे पास शिफ्ट लेफ्ट ऑपरेशन(Shift Left Operation) है।
 आइए एक बाइनरी नंबर 1 1 0 1 पर विचार करें और देखें कि जब हम शिफ्ट लेफ्ट ऑपरेशन(Shift Left Operation) करते हैं, तो क्या होता है।
 यह संख्या 1 प्लस 4 प्लस 8 है जो डेसीमल (Decimal) 13 है।
 इस 1 का वेट (weight) 20 है, इस 1 का वेट (weight) 22 है और इसी तरह से।
 और अब देखते हैं कि जब हम इसे छोड़ देते हैं तो क्या होता है।
 और यहाँ शिफ्ट लेफ्ट ऑपरेशन(Shift Left Operation) का परिणाम है, इस पूरे नंबर को लेफ्ट शिफ्ट(shift) करके 1 स्थान मिला है, और यह 0 यहाँ पर पैडेड(Padded) हो गया है।
 नया नंबर अब 2 प्लस 8 प्लस 16 है जो डेसीमल (Decimal) 26 है और यह निश्चित रूप से पुरानी संख्या 13 से दोगुना है।
 और यह आश्चर्यजनक नहीं है, क्योंकि अगर हम इस बिट को उदाहरण के लिए मानते हैं तो यह पुराना वेट (weight) 20 है और इसका नया वेट (weight) अब 21 है; वह पोल वेट (pole weight) से दोगुना है।
 इस 1 का वेट (weight) 22 है और अब इसे दोबारा फिर से वेट (weight) 23 इत्यादि मिला है।
 इसलिए, यह पूरी बाइनरी संख्या शिफ्ट लेफ्ट (Shift Left) से दोगुनी हो गई है।
 तो, निष्कर्ष में शिफ्ट लेफ्ट ऑपरेशन(Shift Left Operation) बाइनरी(binary) संख्या को 2 से गुणा करने के बराबर है।
 और इसी तरह राइट शिफ्ट(Right shift ) करना बाइनरी(binary) संख्या को 2 से विभाजित करने के बराबर है।
 उदाहरण के लिए, यदि यह हमारा मूल नंबर था और हम इस नंबर को प्राप्त करने के लिए इसे राइट शिफ्ट(Right shift ) करते हैं।
 फिर नया नंबर मूल संख्या का आधा है।
 अब सवाल यह है कि हम इन ऑपरेशनों(operations) को कैसे लागू करेंगे? ये शिफ्ट रजिस्टर(shift Register) व्यावसायिक रूप से I C S के रूप में उपलब्ध हैं और हमने पहले ही देखा है कि किसी दिए गए नंबर को इस तरह से कैसे शिफ्ट रजिस्टर(shift Register) पर एक शिफ्ट लेफ्ट (Shift Left)या शिफ्ट राइट (Shift Right) ऑपरेशन(operation) कैसे किया जाता है।
 इसलिए, हमने उन सभी प्रासंगिक तंत्रों पर चर्चा की है, जिन्हें हमें बस इसे एक साथ रखने और इन कार्यों को प्राप्त करने की आवश्यकता है आइए अब हम बदलाव का उपयोग करते हुए गुणन को देखें और प्रक्रिया जोड़ें।
 और यहाँ एक उदाहरण है; 1 0 1 1 जो कि डेसीमल (Decimal) 11 है, जो कि हमारा नंबर एक A 3 A 2 A 1 A 0. A 3यह है , और A 0 यह 1 है; इसलिए A 0 LSB है, A 3 MSB है।
 यहाँ हमारी संख्या B है और वह डेसीमल (Decimal) 13 है और हम इन दोनों को गुणा करना चाहते हैं।
 तो, यह हमारा गुण्य(Multiplicand) है और यह हमारा गुणक(multiplier) है।
 हम कहां से शुरू करें? हम उस L S B को देखते हैं जो 1. है।
 इसलिए, हम गुण्य(Multiplicand) को LSB से गुणा करते हैं, और इस मामले में इसका मतलब है कि हम इस संख्या को पुन: उत्पन्न करते हैं क्योंकि यह 1 0 1 1 है।
 अगला, हम अगले उच्च बिट को देखते हैं और वह है 0 और जब हम गुण्य(Multiplicand) को A 0 से गुणा करते हैं तो हमें 0 0 0 0 मिलता है और यही हम यहां लिखते हैं।
 और हमें इसे छोड़ देना होगा क्योंकि इससे वेट (weight) अधिक होता है।
 इसलिए, A 0 है, जो यहीं से आता है।
 अब इसके अंकन के बारे में एक टिप्पणी वास्तव में Z के समान 0है, लेकिन हम 0 को निरूपित करने के लिए एक अलग प्रतीक Z का उपयोग करते हैं जो संख्याओं के स्वतंत्र होने से गुणा किया जाता है।
 तो, यह Z हमेशा 0 होने जा रहा है, कोई फर्क नहीं पड़ता कि ये संख्याएं क्या हैं।
 उसके बाद हम इन 2 नंबरों को जोड़ते हैं और यह परिणाम है।
 अगला हम अगले उच्च बिट को देखते हैं जो 1 है, इसलिए हम मल्टीप्लीकेन्ड(multiplicand) को पुन: पेश करते हैं।
 और अब हम इसे 2 बार छोड़ देते हैं और इसलिए हमें ये दोनों 0 मिलते हैं।
 हम फिर से जोड़ते हैं हम आखिरी बिट M S B को देखते हैं जो कि 1 है, इसलिए हम इस मल्टीप्लीकेन्ड(multiplicand) को फिर से उसी तरह से दोहराते हैं और 3 बार स्थानांतरित करते हैं।
 तो, हम इन तीन 0 यहाँ मिलता है।
 और फिर अंत में, हम अपने अंतिम परिणाम को प्राप्त करने के लिए इन 2 संख्याओं को जोड़ते हैं और यह डेसीमल (Decimal) 143 है।
 आइए देखते हैं कि इस पद्धति को कैसे लागू किया जा सकता है।
 हम 2 रजिस्टरों के साथ शुरू करते हैं 4 बिटरजिस्टर( Register) 2रजिस्टर( Register) करते हैं और 1रजिस्टर( Register) करते हैं।
 यह हमारा L S B होने जा रहा है, जो कि हमारा M S B है; और हम इन सभी रजिस्टरों को सभी 0 के साथ आरंभ करते हैं।
 अब स्टेप(step) संख्या 1 को 1 0 1 1 लोड(load) करना है इस 1 को इस अन्य रजिस्टर में मल्टीप्लीकेन्ड(multiplicand) करें।
 चूंकि B 0 है 1, और अब हम इस परिणाम को प्राप्त करने के लिए इन दो 4 बिट बाइनरी संख्याओं को जोड़ने जा रहे हैं।
 और यह बाइनरी नंबर बस इस हिस्से में कॉपी(copy) होने वाला है।
 तो, हमें 1 0 1 1 मिला है, निश्चित रूप से ये सभी 0 हैं, इसलिए हमारे पास यहां पर समान संख्या है जो कि जोड़ का परिणाम है।
 अगला हम इस परिणाम को 1 स्थिति से दाएं स्थानांतरित करते हैं, इसलिए यह संख्या 1 0 1 1 यहाँ दिखाई दी है अब 1 0 1 1 और 1 0 बाईं ओर से पैडेड(padded) है।
 अब, अगला बिट, चूंकि B 1 है 0 हम0 0 0 0 लोड(load) करते हैं अब हम इस स्टेप(step) के बारे में बात कर रहे हैं।
 और अब हम इन दो नंबरों को जोड़ने जा रहे हैं और अब आप देखते हैं कि यह इन दो नंबरों को जोड़ने से मेल खाता है।
 और यह 1 इस 0 में जोड़ा जा रहा है जो कि वैसे भी हो रहा है क्योंकि यह 1 बस वहाँ पर कॉपी(copy) होने वाला है।
 तो, यह इस जोड़ का परिणाम है।
 और हम इस प्रक्रिया को तब तक दोहराते रहते हैं जब तक हम B 3 तक नहीं पहुँच जाते,तो अगली स्टेप(step) शिफ्ट(shift )राइट 1 बिट, इसलिए यह 0 1 0 1 1 यहाँ आ गया है 0 1 0 1 1, 1 0 को बाईं ओर से जोड़ा गया है।
 अब हम 1 0 1 1 को लोड(load) करते हैं, क्योंकि B 2 1 है जो इस स्टेप(step) से मेल खाता है यहां शिफ्ट(shift )राइट जोड़ें।
 और अंत में, हम 1 0 1 1 को लोड(load) करते हैं क्योंकि B 3 के बराबर1 है; यह यहाँ स्टेप है और फिर जोड़ने और शिफ्ट(shift ) है।
 तो, यह हमारा अंतिम परिणाम है और यह वास्तव में इस संख्या के समान है।
 आइए हम इस सर्किट को देखें और यह पता लगाने की कोशिश करें कि यह क्या कर रहा है।
 हमारे पास 4 jk फ्लिप फ्लॉप हैं और वे सभी सकारात्मक एज़(edge) के कारण हैं।
 यहाँ डायरेक्ट सेट इनपुट S d है यह डायरेक्ट रिसेट इनपुट R d है।
 और हम जो नोटिस करते हैं वह यह है कि यद्यपि हम यहां jk फ्लिप फ्लॉप का उपयोग कर रहे हैं, हम वास्तव में उन्हें D फ्लिप फ्लॉप के रूप में उपयोग कर रहे हैं, क्योंकि आप देखते हैं कि इनमें से प्रत्येक मामले में j और k एक दूसरे के व्युत्क्रम हैं; हमारे यहाँ 0 यहाँ 1 है, आपके पास Q 3 यहाँ Q 3 बार यहाँ, Q 2 हैयहाँ Q 2 बार यहाँ।
 Q 1 यहाँ और Q 1 बार यहाँ।
 इसलिए हालांकि ये फ्लिप फ्लॉप jk फ्लिप फ्लॉप हैं, कार्यक्षमता D फ्लिप फ्लॉप जैसी है।
 इसलिए, अनिवार्य रूप से यह एक शिफ्ट रजिस्टर(shift Register ) है जिसके बारे में हम बात कर रहे हैं।
 अब, हम कनेक्शनों को देखते हैं: क्लॉक उन सभी के लिए सामान्य है, और क्लियर(clear) इनपुट भी सामान्य है जो प्रत्येक फ्लिप फ्लॉप के प्रत्यक्ष रीसेट इनपुट पर जा रहा है।
 अब S d के लिए हम इस वेरिएबल को लोडेड एंडेड(load anded) के साथ जोड़ रहे हैं जिसे कुछ अन्य वैरिएबल(variable) के साथ यहाँ वैरिएबल(variable) A 3 यहाँ A 2 यहाँ A 1 यहाँ एक 0 यहाँ 0 है।
 और A 3, A 2, A 1, A 0 एक बाइनरी नंबर का प्रतिनिधित्व करता है।
 और हम जो करने जा रहे हैं वह इस बाइनरी नंबर को इन फ्लिप फ्लॉप में लोड(load) करने के साथ शुरू करना है।
 ये सिग्नल(signal) लगाए जा रहे हैं; क्लियर(clear) सिग्नल(signal) के लिए यहां एक पल्स(pulse), लोड(load) सिग्नल(signal) के लिए एक पल्स(pulse)।
 और यह क्लॉक(clock) सिग्नल(signal) एक मुक्त चलने वाली क्लॉक और कुछ तर्क से लिया गया है।
 तो, पहलीपल्स(pulse)यहाँ से शुरू होती है और कुल 4 क्लॉक पल्सेस (clock pulses) हैं।
 अब देखते हैं कि यह कैसे काम करता है।
 इस समय हमारे पास लोड(load) के बराबर 0 है, इसलिए इस ऐण्ड गेट(AND gate) का आउटपुट 0 है और अन्य हैं; इसलिए S d 0. है।
 क्लियर(clear) इनपुट अधिक है, इसलिए R d है 1, इसलिए हमारे पास S d के बराबर 0 है और R d के बराबर 1है और जो फ्लिप फ्लॉप को क्लियर(clear) करेगा; इसका मतलब है कि Q 3 को 0 के बराबर बनाया जाएगा।
 Q 1 Q2 Q 0 को भी 0. के बराबर बनाया जाएगा।
 क्लियर(clear) पल्स(pulse) के बाद लोड(load) पल्स(pulse) साथ आता है और आइए हम यहां कहीं स्थिति को देखते हैं।
 तो, लोड(load) सिग्नल(signal) 1 क्लियर(clear) 0 है, इसलिए सभी R d इनपुट अब 0 हैं।
 यह 1 है, इसलिए इस फ्लिप फ्लॉप के लिए S d के इस गेट का आउटपुट A 3 के बराबर है।
 अब हम 2 स्थितियों को A 3 के बराबर 0 पहले ले लेते हैं; इसका मतलब है, हमारे पास S d के बराबर0 है और R d के बराबर0 है।
 इसलिए, वास्तव में कुछ भी नहीं होने जा रहा है, फ्लिप फ्लॉप सामान्य रूप से काम करेगा; यदि आप याद करते हैं तो इसका आउटपुट पहले से ही 0. है और चूंकि क्लॉक की एज़(edge) नहीं है, इसलिए आउटपुट 0. होना जारी रहेगा।
 इसलिए, यदि A 3 0 था, अब, A 3 को 1 मानें उस स्थिति में S d होगा1 और R d 0 है।
 इसलिए, फ्लिप फ्लॉप आउटपुट Q 3 सेट हो जाएगा 1 पर।
 दूसरे शब्दों में यदि A 3 है 0, तो Q 3 इस समय 0 होगा और यदि A 3 था 1तो Q 3 होगा 1. तो, यहाँ यह बिट बस इस फ्लिप फ्लॉप में लोड(load) हो रहा है और इसी तरह A 2 यहाँ लोड(load) हो जाएगा आदि।
 तो, यह पूरी बाइनरी संख्या अब इस शिफ्ट रजिस्टर(shift Register ) में लोड(load) हो गई है।
 अब, क्लॉक पल्स(pulse)के साथ आया है।
 पहला सक्रिय किनारा आने पर क्या होता है? यह 0 Q 3 में स्थानांतरित हो जाएगा, Q 3 जो भी गया था वह Q 2 और इसी तरह जाएगा।
 तो, यह 1 स्थिति से एक शिफ्ट राइट ऑपरेशन(Shift Right Operation) है।
 और प्रत्येक अतिरिक्त सक्रिय एज़(edge)के साथ ये डेटा(Data) बस एक बार और राइट शिफ्ट(right shift ) होगा।
 तो, यह है कि यह सर्किट कैसे काम करता है।
 संक्षेप में सभी फ्लिप फ्लॉप्स के साथ शुरुआत में R 1 के बराबर क्लियर(clear) करने के लिए मंजूरी दे दी है, यह हिस्सा और S d के बराबर 0.है।
 जब लोड(load) 1 के बराबर है तो यह हिस्सा S d के बराबर A iहै; इसका मतलब है, A 3 या A 2 या A 1 या A 0 और R d, 0 है; इसका मतलब है कि, बाइनरी नंबर शिफ्ट रजिस्टर(shift Register) में लोड(load) हो जाता है।
 और बाद में, हर क्लॉक पल्स(pulse) के साथ, डेटा(data) राइट शिफ्ट(right shift ) है और आउटपुट Q 0 पर क्रमिक रूप से वहॉ पर प्रकट होता है और आउटपुट Q 0 पर क्रमानुसार दिखाई देता है।
 तो, पहले यह A 0 Q 0 पर दिखाई देगा और इसके बाद यह A 1 जो इस फ्लिप फ्लॉप में लोड(load) हो गया है, शुरू में Q 0 और इसी तरह दिखाई देगा।
 और यह डेटा आउट मूवमेंट(out data movement) के क्रम में समानांतर से मेल खाती है आइए अब हम इन योजनाबद्ध चित्रों को सीरियल आउट डेटा(Data) पल में समानांतर दिखाते हुए देखें।
 इसमें जो समानांतर है वह हमारा डेटा(Data) A 3, A 2, A 1, A 0 है; और जो इन फ्लिप फ्लॉप में समान रूप से लोड(load) हो रहा है, जैसे।
 तो, इस स्टेप(step) में ऐसा होता है, और अब क्लॉक पल्स(pulse)पहले क्लॉक पल्स(pulse)के साथ आती है, हम उसी के कारण शिफ्ट राइट ऑपरेशन(Shift Right Operation) करने जा रहे हैं।
 पहले फ्लिप फ्लॉप में एक 0 दिखाई देता है क्योंकि हमारे यहां J के बराबर 0 है, और जो कुछ भी यहां था वह अगले फ्लिप फ्लॉप और इतने पर स्थानांतरित हो जाता है।
 1 और क्लॉक पल्स(pulse) के साथ हमारे पास 1 और शिफ्ट(shift )राइट है।
 चलिए अब काउंटरों से शुरू करते हैं।
 काउंटर कई स्टेट्स (states) के साथ सर्किट हैं; और इस तस्वीर या स्टेट(state) ट्रांजीशन (transition) आरेख में प्रत्येक स्टेट को 1 सर्कल(circle) द्वारा दर्शाया गया है, यह स्टेट(state) 1 है, यह स्टेट(state) 2 है, यह स्टेट 3 है, 4 आदि K तक ।
 और इस स्थिति के बाद काउंटर वापस स्टेट(state)1 में चला जाता है और k स्टेट्स(states) के साथ इस तरह के काउंटर को एक मॉडुलो (Modulo) k या मॉड(mod) k काउंटर कहा जाता है।
 और एक काउंटर के अंदर क्या है? हम देखते हैं: एक काउंटर फ्लिप फ्लॉप के साथ बनाया जा सकता है प्रत्येक फ्लिप फ्लॉप 2 स्टेट्स(states) 0 या 1 के साथ 1 मेमोरी(memory) तत्व के रूप में सेवारत है।
 फ्लिप फ्लॉप Q का आउटपुट 0 या 1. हो सकता है और अगर काउंटर में N फ्लिप फ्लॉप हैं हमारे पास 2N संभावित स्टेट्स(states) के लिए है, क्योंकि प्रत्येक फ्लिप फ्लॉप में Q के बराबर 0 या Q के बराबर1 हो सकता है।
 और इसलिए, मान लें कि हमारे पास 3 फ्लिप फ्लॉप हैं तो हमारे पास अधिकतम 8 संभावित स्टेट(state) हो सकते हैं; तो हमारा k 8. हो सकता है।
 लेकिन हम कुछ स्टेट्स(states) को भी बाहर कर सकते हैं, और इसलिए N फ्लिप फ्लॉप का उपयोग 2N के बराबर या उससे कम के साथ एक मॉड(mod) k काउंटर बनाने के लिए किया जा सकता है।
 इसलिए, ये चित्र दिखाता है, इस काउंटर के अंदर फ्लिप फ्लॉप हैं और यह Q 0, Q 1, Q 2 वगैरह उन फ्लिप फ्लॉप के आउटपुट हैं।
 और काउंटर 1 से 2 या 2 से 3 उदाहरण के लिए अगले स्टेट(state) में कैसे जाता है, जो क्लॉक की पल्सेस(pulses) द्वारा किया जाता है।
 इसलिए, हर बार क्लॉक की पल्स के लिए काउंटर 1 से 2, 2 से 3, 3 से 4 और इसी तरह से 1 स्टेट(state) द्वारा आगे बढ़ेगा।
 इसके अलावा एक शोध सुविधा भी यहां दी गई है, जिसका उपयोग काउंटर को शुरू करने के लिए एक निश्चित स्थिति को बाध्य करने के लिए किया जा सकता है।
 उदाहरण के लिए, मान लें कि हमारे पास इस काउंटर के अंदर 3 फ्लिप फ्लॉप हैं, इसलिए आउटपुट Q 0, Q 1, Q 2 हैं और हम चाहते हैं कि काउंटर स्टेट(state) 0 0 0 में शुरू हो।
 इसलिए, रीसेट सुविधा का उपयोग करके प्राप्त किया जा सकता है ।
 अब इसके अलावा यहाँ पर डिकोडिंग(Decoding) लॉजिक के लिए इस बॉक्स को भी दिखाया गया है, हम उस पर थोड़ी देर बाद नज़र डालेंगे।
 यहां एक काउंटर का उदाहरण दिया गया है: यह सामान्य स्टेट(state) ट्रांजीशन (transition) आरेख है और यह हमारा विशिष्ट काउंटर है।
 और वास्तव में यह एक सर्किट है जिसे हम पहले ही देख चुके हैं।
 तो, इस काउंटर के लिए अनुक्रम यहाँ पर दिखाया गया है; यदि आप Q 0, Q 1, Q 2 के बराबर 0 0 0 से प्रारंभ करते हैं, तो यह है कि यह कैसे आगे बढ़ता है।
 और यहाँ एक तालिका है जो Q 0, Q 1, Q 2 दिखाता है, इसलिए हमारे पास 0 0 0 है जो कि हमारे स्टेट(state) 1 के साथ शुरू होता है।
 फिर हमारे पास 1 1 0: 1 1 0 है जो कि हमारा स्टेट(state) 2 है, फिर 1 1 1: 1 1 1 स्टेट(state) 3, फिर 0 1 1: 0 1 1 स्टेट(state) 4, फिर 1 0 1 स्टेट(state) 5 और उसके बाद हम वापस स्टेट(state) 1के लिए 0 0 0 पर वापस आते हैं।
 इसका मतलब है कि, हमारी अंतिम स्टेट यह 1 1 0 1 है।
 इसलिए, k यहां 5 है।
 तो, यह एक मॉडुलो (Modulo)5 या मॉड(mod) 5 काउंटर है।
 आइए अब हम इस डिकोडिंग(Decoding) लॉजिक को देखें।
 यह तर्क कुछ नहीं है, लेकिन कुछ संयोजी(combinatorial)सर्किट उपयुक्त रूप से डिज़ाइन किए गए हैं ताकि कुछ वांछित आउटपुट प्राप्त करने के लिए यहां 1 या अधिक आउटपुट हो सकें।
 अब चूंकि काउंटर k स्टेट्स(states) के माध्यम से साइकिल(cycle) कर रहा है, इसलिए ये आउटपुट आवधिक भी होंगे जो k क्लॉक के चक्र के बाद आउटपुट को इनमें से किसी भी पिन पर दोहराने जा रहे हैं।
 अब विशेष रूप से इस उदाहरण को लेते हैं।
 हम कहते हैं कि हमारे पास एक मॉड(mod) 8 काउंटर है; इसका मतलब है कि k 8 है; इसका मतलब है, हमारे पास 8 स्टेट(state) हैं 1, 2, 3, 4, 5, 6, 7, 8 और फिर 1 पर वापस, यह हमारी क्लॉक(clock) सिग्नल(signal) है।
 अब हमारे लिए यह संभव होना चाहिए कि हम अपने डिकोडिंग(Decoding) लॉजिक को डिजाइन करें, ताकि इस प्रकार के आउटपुट पिनों में से 1 पर इस तरह की वेवफॉर्म(waveform) प्राप्त हो सके; उदाहरण के लिए पहले वाला।
 अब यह संकेत X 1 है जब काउंटर स्टेट(state) 3 में है, अन्यथा यह 0. है और चूंकि स्टेट(state) 3 प्रत्येक 8 क्लॉक अवधियों में एक बार आता है, अगर क्लॉक की अवधि T है तो यह अंतराल 8 गुना T होने वाला है।
 या दूसरे शब्दों में, इस सिग्नल(signal) X की आवृत्ति क्लॉक की आवृत्ति 8 से विभाजित होने वाली है; तो हम उस टिप्पणी करते हैं।
 यह कहना संभव है कि एक डिकोडर आउटपुट(decoder output ) का कहना है X जो इस स्थिति में केवल 1 है I इस मामले में तीसरा स्टेट(state) और 0 अन्यथा।
 तो, k क्लॉक पल्स(pulse) के लिए हमें X पर एक सिंगल(single) पल्स(pulse) मिलता है; वह क्लॉक की आवृत्ति k द्वारा विभाजित की गई है।
 इस कारण से एक मॉड(mod) k काउंटर को k काउंटर द्वारा विभाजित भी कहा जाता है।
 इसलिए, उदाहरण के लिए, इस काउंटर को 8 काउंटर द्वारा विभाजित कहा जाएगा।
 हमें संक्षेप में बताएं: हमने शिफ्ट रजिस्टर(shift Register) से संबंधित कुछ कार्यों पर ध्यान दिया और एक आवेदन भी; दो बाइनरी संख्याओं का गुणन।
 हमने एक काउंटर की कार्यक्षमता देखी है।
 अगली कक्षा में हम काउंटरों के कुछ उदाहरणों को देखेंगे।
 तो अगली बार मिलते हैं।