Multiplexers, Decoders and Encodersمەڵتیپلێکسەرەکان، کۆدهەڵوەشێنەرەکان و کۆدکەرەکان

So far you have built every circuit gate by gate: an adder is a few XOR, AND and OR gates wired together. Real designers rarely start from single gates. They reuse ready-made building blocks — small circuits with one clear job, such as choosing one signal out of four or turning a binary number into one lit lamp. A chip with such a block holds roughly 10 to 100 gates: an MSI chip, one step up from the SSI gate chips in Power, delay and fan-out.

تا ئێستا هەموو سووڕێکت (Electric circuit) گەیت (Logic gate) بە گەیت دروست کرد: کۆکەرەوەیەک (Adder) بریتییە لە چەند گەیتێکی XOR، AND و OR کە پێکەوە بەستراون. دیزاینەرە ڕاستەقینەکان کەم لە تاکە گەیتێکەوە دەست پێ دەکەن. ئەوان بلۆکی بنیاتنەری ئامادە دووبارە بەکار دەهێننەوە — سووڕی بچووک کە هەر یەکەیان کارێکی ڕوونی هەیە، وەک هەڵبژاردنی یەک سیگناڵ (Signal) لە چوار، یان گۆڕینی ژمارەیەکی دووانی بۆ ڕووناککردنەوەی تەنها یەک چرا. چیپێک (Microchip) کە بلۆکێکی وەهای تێدا بێت نزیکەی ⁦10⁩ تا ⁦100⁩ گەیت لەخۆ دەگرێت: چیپێکی MSI، یەک پلە سەرووی چیپەکانی SSIـی گەیتەکان لە وزە، دواکەوتن و ⁦fan-out⁩.

The course's list of topics ends with sequential circuits, digital registers, digital counters and memory devices. This last chapter teaches them in three lessons:

لیستی بابەتەکانی کۆرسەکە بە سووڕە زنجیرەییەکان (Sequential circuit)، تۆمارگەکانی (Register) دیجیتاڵ (Digital)، ژمێرەرە دیجیتاڵەکان (Digital counter) و ئامێرەکانی بیرگە (Memory) کۆتایی دێت. ئەم کۆتا بەشە لە سێ وانەدا فێریان دەکات:

A multiplexer (MUX), also called a data selector, has several data inputs, one output and a few select lines. The number on the select lines says which data input is copied to the output; all the other data inputs are ignored.

مەڵتیپلێکسەر ⁦(MUX)⁩، کە پێی دەوترێت هەڵبژێری دراوە (Data)ش، چەند نێوخستەی دراوەی، یەک دەرخستە و چەند هێڵێکی هەڵبژاردنی هەیە. ئەو ژمارەیەی لەسەر هێڵەکانی هەڵبژاردنە دیاری دەکات کام نێوخستەی دراوە کۆپی دەکرێت بۆ دەرخستە؛ هەموو نێوخستەکانی دراوەی تر پشتگوێ دەخرێن.

The smallest one, the 2-to-1 multiplexer, has data inputs $D_0$ and $D_1$ and one select line S. When $S = 0$ the output is $D_0$; when $S = 1$ it is $D_1$. As a Boolean expression:

بچووکترینیان، مەڵتیپلێکسەری دوو بۆ یەک، نێوخستەکانی دراوە $D_0$ و $D_1$ و یەک هێڵی هەڵبژاردنی S هەیە. کاتێک $S = 0$ بێت دەرخستە $D_0$ـە؛ کاتێک $S = 1$ بێت $D_1$ـە. وەک دەربڕینێکی بوولی (Boolean expression):

With n select lines you can number $2^n$ inputs. That is why multiplexers come with 2, 4, 8 or 16 data inputs and 1, 2, 3 or 4 select lines. A 4-to-1 multiplexer reads its select lines $S_1S_0$ as a 2-bit number from 0 to 3 and passes that input to Y.

بە n هێڵی هەڵبژاردن دەتوانیت $2^n$ نێوخستە ژمارە بکەیت. بۆیە مەڵتیپلێکسەرەکان بە 2، 4، 8 یان ⁦16⁩ نێوخستەی دراوە و 1، 2، 3 یان 4 هێڵی هەڵبژاردن دێن. مەڵتیپلێکسەرێکی چوار بۆ یەک هێڵەکانی هەڵبژاردنی $S_1S_0$ وەک ژمارەیەکی دوو بیتی لە 0ـەوە تا 3 دەخوێنێتەوە و ئەو نێوخستەیە دەنێرێت بۆ Y.

Built from gates, each data input gets its own 3-input AND gate. Two of its inputs come from the select lines — through an inversion bubble wherever that gate's code has a 0 — so the gate opens only for its own code. The four AND outputs meet in one OR gate. Watch the select lines count from 00 to 11:

ئەگەر بە گەیتەکان دروستی بکەیت، هەر نێوخستەیەکی دراوە گەیتێکی ANDـی (AND gate) خۆی هەیە کە سێ نێوخستەی هەیە. دوو لە نێوخستەکانی لە هێڵەکانی هەڵبژاردنەوە دێن — لە هەر شوێنێک کۆدی ئەو گەیتە 0ـی تێدا بێت بە بازنەیەکی پێچەوانەکردندا (Bubble) — بۆیە گەیتەکە تەنها بۆ کۆدی خۆی دەکرێتەوە. دەرخستەکانی چوار ANDـەکە لە یەک گەیتی ORـدا بە یەک دەگەن. سەیر بکە هێڵەکانی هەڵبژاردن چۆن لە ⁦00⁩ـەوە تا ⁦11⁩ دەژمێرن:

The AND gates with their bubbles turn the select code into "exactly one gate open". That part of the circuit is a decoder — you will meet it on its own further down.

گەیتەکانی AND لەگەڵ بازنەکانی پێچەوانەکردنیان کۆدی هەڵبژاردن دەکەن بە «تەنها یەک گەیت کراوەیە». ئەو بەشەی سووڕەکە کۆدهەڵوەشێنەرێکە — لە خوارەوە بە تەنها دەیبینیت.

A full truth table lists every combination of all inputs. An 8-to-1 multiplexer has 3 select lines and 8 data inputs — 11 inputs — so its full table would have $2^{11} = 2048$ rows, almost all saying the same thing. In general a multiplexer with n select lines has $n + 2^n$ inputs, so its full table has $2^{\,n + 2^n}$ rows.

خشتەیەکی ڕاستی (Truth table) تەواو هەموو تێکەڵەیەکی هەموو نێوخستەکان دەنووسێت. مەڵتیپلێکسەرێکی هەشت بۆ یەک 3 هێڵی هەڵبژاردن و 8 نێوخستەی دراوەی هەیە — ⁦11⁩ نێوخستە — بۆیە خشتە تەواوەکەی $2^{11} = 2048$ ڕیزی دەبوو کە نزیکەی هەموویان هەمان شت دەڵێن. بە گشتی مەڵتیپلێکسەرێک بە n هێڵی هەڵبژاردن $n + 2^n$ نێوخستەی هەیە، بۆیە خشتە تەواوەکەی $2^{\,n + 2^n}$ ڕیزی هەیە.

So datasheets print an abbreviated table. Each row gives only the select code, and the output column names the input that is copied, instead of listing every 0 and 1 of the other inputs. Eight rows replace 2048:

بۆیە پەڕەی زانیاریی چیپەکان ⁦(datasheet)⁩ خشتەیەکی کورتکراوە چاپ دەکەن. هەر ڕیزێک تەنها کۆدی هەڵبژاردن دەدات و ستوونی دەرخستە ناوی ئەو نێوخستەیە دەنووسێت کە کۆپی دەکرێت، لە جیاتی نووسینی هەموو 0 و 1ـەکانی نێوخستەکانی تر. هەشت ڕیز جێگەی ⁦2048⁩ دەگرنەوە:

A demultiplexer (DEMUX) does the opposite job. It has one data input D, n select lines (also called address inputs) and $2^n$ outputs. The select number decides which output receives D; every other output stays 0. For a 1-to-4 demultiplexer:

دیمەڵتیپلێکسەر ⁦(DEMUX)⁩ کارە پێچەوانەکە دەکات. یەک نێوخستەی دراوە D، n هێڵی هەڵبژاردن (کە پێیان دەوترێت هێڵەکانی ناونیشانیش) و $2^n$ دەرخستەی هەیە. ژمارەی هەڵبژاردن بڕیار دەدات کام دەرخستە D وەربگرێت؛ هەموو دەرخستەکانی تر 0 دەمێننەوە. بۆ دیمەڵتیپلێکسەرێکی یەک بۆ چوار:

Why have both? Together they let several signals share one wire. The multiplexer at the sending end and the demultiplexer at the receiving end get the same select number, which counts 00, 01, 10, 11 again and again, so each signal uses the wire in turn. This is time-division multiplexing, used in telephone networks and digital links.

بۆچی هەردووکیان؟ پێکەوە ڕێگە دەدەن چەند سیگناڵێک یەک وایەر بەکار بهێنن. مەڵتیپلێکسەر لە لای نێرەر و دیمەڵتیپلێکسەر لە لای وەرگر هەمان ژمارەی هەڵبژاردن وەردەگرن کە بەردەوام ⁦00⁩، ⁦01⁩، ⁦10⁩، ⁦11⁩ دەژمێرێت، بۆیە هەر سیگناڵێک بە نۆرە وایەرەکە بەکار دەهێنێت. ئەمە فرەکردنی بە دابەشکردنی کاتە (time-division multiplexing) کە لە ڕایەڵەکانی تەلەفۆن و پەیوەندیی دیجیتاڵدا بەکار دێت.

Look again at the AND gates inside the multiplexer: for each select code exactly one of them opens. On its own, that circuit is a decoder. It has n inputs and $2^n$ outputs, and for every input number exactly one output is 1 — the output with that number. All the others are 0. A 2-to-4 decoder:

دووبارە سەیری گەیتەکانی ANDـی ناو مەڵتیپلێکسەر بکە: بۆ هەر کۆدێکی هەڵبژاردن ڕێک یەکێکیان دەکرێتەوە. ئەو سووڕە بە تەنها کۆدهەڵوەشێنەرێکە. n نێوخستە و $2^n$ دەرخستەی هەیە و بۆ هەر ژمارەیەکی نێوخستە ڕێک یەک دەرخستە 1ـە — ئەو دەرخستەیەی هەمان ژمارەی هەیە. هەموو ئەوانی تر 0ـن. کۆدهەڵوەشێنەرێکی دوو بۆ چوار:

Each output is one AND term of all the inputs, so each output is a minterm: $Y_0 = \overline{A}\,\overline{B}$, $Y_1 = \overline{A}B$, $Y_2 = A\overline{B}$, $Y_3 = AB$ (see Minterms and maxterms).

هەر دەرخستەیەک یەک بڕی ANDـی هەموو نێوخستەکانە، بۆیە هەر دەرخستەیەک مینتێرمێکە (Minterm): $Y_0 = \overline{A}\,\overline{B}$، $Y_1 = \overline{A}B$، $Y_2 = A\overline{B}$، $Y_3 = AB$ (بڕوانە مینتێرمەکان و ماکستێرمەکان).

A 3-to-8 decoder works the same way with three inputs A, B and C (A is the most significant bit). Its eight outputs are the eight minterms of three variables, so for every input code exactly one of them is 1:

کۆدهەڵوەشێنەرێکی سێ بۆ هەشت بە هەمان شێوە بە سێ نێوخستە، A، B و C، کار دەکات (A گرنگترین بیتە (Most significant bit)). هەشت دەرخستەکەی بریتین لە هەشت مینتێرمەکەی سێ گۆڕاوی بوولی (Boolean variable)، بۆیە بۆ هەر کۆدێکی نێوخستە ڕێک یەکێکیان 1ـە:

Most decoder chips have an enable input E. When $E = 0$ every output stays 0, whatever the other inputs say; when $E = 1$ the decoder works normally. In the table an X means "any value":

زۆربەی چیپەکانی کۆدهەڵوەشێنەر نێوخستەی چالاککردن Eـیان هەیە. کاتێک $E = 0$ بێت هەموو دەرخستەکان 0 دەمێننەوە، نێوخستەکانی تر هەرچییەک بڵێن؛ کاتێک $E = 1$ بێت کۆدهەڵوەشێنەرەکە بە ئاسایی کار دەکات. لە خشتەکەدا X واتە «هەر بەهایەک»:

Now feed a data bit into E. When the bit is 1, the selected output is 1; when it is 0, all outputs are 0. The selected output simply copies the data bit — that is exactly a demultiplexer, with A and B as its select lines. This is why the 74HC138 chip is sold as a 3-to-8 decoder/demultiplexer.

ئێستا بیتێکی دراوە بدە بە E. کاتێک بیتەکە 1 بێت، دەرخستە هەڵبژێردراوەکە 1ـە؛ کاتێک 0 بێت، هەموو دەرخستەکان 0ـن. دەرخستە هەڵبژێردراوەکە تەنها بیتی دراوەکە کۆپی دەکات — ئەمە ڕێک دیمەڵتیپلێکسەرێکە کە A و B هێڵەکانی هەڵبژاردنین. بۆیە چیپی ⁦74HC138⁩ وەک کۆدهەڵوەشێنەر/دیمەڵتیپلێکسەری سێ بۆ هەشت دەفرۆشرێت.

Many decoder chips, the 74HC138 among them, have active-low outputs: the selected output goes LOW (0) and all the others stay HIGH (1). The symbol shows an inversion bubble on each output. Enable inputs let a designer switch on one decoder among several — the same idea as the enable inputs of chips on a shared bus.

زۆرێک لە چیپەکانی کۆدهەڵوەشێنەر، ⁦74HC138⁩یش لەناویاندا، دەرخستەکانی چالاک بە LOWیان هەیە: دەرخستە هەڵبژێردراوەکە دەبێتە ⁦LOW (0)⁩ و هەموو ئەوانی تر ⁦HIGH (1)⁩ دەمێننەوە. هێماکە (Symbol) بازنەیەکی پێچەوانەکردن لەسەر هەر دەرخستەیەک پیشان دەدات. نێوخستەکانی چالاککردن ڕێگە دەدەن دیزاینەر لە نێوان چەند کۆدهەڵوەشێنەرێکدا تەنها یەکێکیان هەڵبکات — هەمان بیرۆکەی نێوخستەی چالاککردن لە چیپەکانی سەر تێپەڕگەیەکی هاوبەش.

The digits on a microwave oven, a petrol pump or an old calculator are seven-segment displays: seven light bars named a to g. To show a digit, a BCD-to-7-segment decoder turns the digit's BCD code into the right pattern of segments. Unlike the decoders above, several of its outputs are 1 at the same time: it is a code converter.

تاکژمارەکانی سەر مایکرۆوەیڤ، پەمپی بەنزین یان حاسیبەیەکی (Calculator) کۆن پیشاندەرە حەوت بەشییەکانن: حەوت هێڵی ڕووناک کە ناویان a تا gـیە. بۆ پیشاندانی تاکژمارەیەک، کۆدهەڵوەشێنەرێکی BCD بۆ حەوت بەش کۆدی دەیی دووانیی ئەو تاکژمارەیە دەگۆڕێت بۆ نەخشەی دروستی بەشەکان. بە پێچەوانەی کۆدهەڵوەشێنەرەکانی سەرەوە، چەند دەرخستەیەکی لە هەمان کاتدا 1ـن: ئەم کۆدهەڵوەشێنەرە گۆڕەری کۆدـە.

The six codes 1010 to 1111 are not BCD digits. A designer may treat them as don't-cares when simplifying the circuit of each segment. Ready-made chips such as the CMOS 4511 do the whole job.

شەش کۆدی ⁦1010⁩ تا ⁦1111⁩ تاکژمارەی کۆدی دەیی دووانی نین. دیزاینەر دەتوانێت لە کاتی کورتکردنەوەی سووڕی هەر بەشێکدا وەک دۆخە بێبایەخەکان سەیریان بکات. چیپی ئامادەی وەک ⁦CMOS 4511⁩ هەموو کارەکە دەکات.

An encoder does the reverse of a decoder. It has $2^n$ input lines and n outputs, and it outputs the number of the one input that is active. A 4-to-2 encoder:

کۆدکەر پێچەوانەی کۆدهەڵوەشێنەر کار دەکات. $2^n$ هێڵی نێوخستە و n دەرخستەی هەیە و ژمارەی ئەو تاکە نێوخستەیە دەدات کە چالاکە. کۆدکەرێکی چوار بۆ دوو:

Read the table column by column: $Y_1$ is 1 for inputs 2 and 3, and $Y_0$ is 1 for inputs 1 and 3. So an encoder needs only OR gates — and $D_0$ is not even connected, because input 0 gives the code 00 anyway:

خشتەکە ستوون بە ستوون بخوێنەوە: $Y_1$ بۆ نێوخستەکانی 2 و ⁦3 1⁩ـە و $Y_0$ بۆ نێوخستەکانی 1 و ⁦3 1⁩ـە. کەواتە کۆدکەر تەنها پێویستی بە گەیتەکانی OR هەیە — و $D_0$ تەنانەت نابەسترێتەوە، چونکە نێوخستەی 0 لە هەر حاڵدا کۆدی ⁦00⁩ دەدات:

The simple encoder trusts that only one input is active. Activate two at once — $D_1$ and $D_2$ — and the OR gates give $Y_1Y_0 = 11$, the code of input 3, which nobody activated.

کۆدکەر سادەکە متمانە دەکات کە تەنها یەک نێوخستە چالاکە. ئەگەر دووان پێکەوە چالاک بکەیت — $D_1$ و $D_2$ — گەیتەکانی OR $Y_1Y_0 = 11$ دەدەن، کە کۆدی نێوخستەی 3ـە و کەس چالاکی نەکردووە.

A priority encoder fixes this. Each input has a priority — here $D_3$ is the highest — and when several inputs are active, the output is the number of the highest one. An extra output V (valid) is 1 when at least one input is active, so the circuit can tell "input 0 is active" apart from "nothing is active".

کۆدکەری پێشینەیی ئەم کێشەیە چارەسەر دەکات. هەر نێوخستەیەک پێشینەییەکی هەیە — لێرەدا $D_3$ بەرزترینە — و کاتێک چەند نێوخستەیەک چالاک بن، دەرخستە ژمارەی بەرزترینیانە. دەرخستەیەکی زیادە، V (valid، واتە دروست)، کاتێک لانیکەم یەک نێوخستە چالاک بێت 1ـە، بۆیە سووڕەکە دەتوانێت «نێوخستەی 0 چالاکە» لە «هیچ شتێک چالاک نییە» جیا بکاتەوە.

Each X is a don't-care: once a higher input is active, the lower ones cannot change the answer. One row with Xs stands for several rows of the full 16-row table — the row 1XXX alone covers eight. From the table:

هەر X دۆخێکی بێبایەخە: هەر کە نێوخستەیەکی بەرزتر چالاک بێت، نێوخستە نزمترەکان ناتوانن وەڵامەکە بگۆڕن. یەک ڕیز بە Xـەکانەوە جێگەی چەند ڕیزێکی خشتە ⁦16⁩ ڕیزییە تەواوەکە دەگرێتەوە — تەنها ڕیزی ⁦1XXX⁩ هەشت ڕیز دەگرێتەوە. لە خشتەکەوە:

Priority matters wherever several requests can arrive together: an interrupt controller decides which device the CPU serves first, and a keypad must give one answer when two keys are pressed together. Real chips: the 74HC148 (8 inputs to 3 outputs) and the 74HC147 (10 inputs to a 4-bit BCD code, for a decimal keypad).

پێشینەیی لە هەر شوێنێکدا گرنگە کە چەند داواکارییەک پێکەوە بگەن: کۆنترۆڵەری پچڕاندن (interrupt controller) بڕیار دەدات CPU سەرەتا خزمەتی کام ئامێر بکات و تەختەیەکی ژمارە دەبێت کاتێک دوو دوگمە (Key) پێکەوە دادەگیرێن یەک وەڵام بدات. چیپی ڕاستەقینە: ⁦74HC148 (8⁩ نێوخستە بۆ 3 دەرخستە) و ⁦74HC147 (10⁩ نێوخستە بۆ کۆدی دەیی دووانی، واتە 4 بیت، بۆ تەختەیەکی ژمارەی دەیی (Decimal)).

Because a decoder's outputs are the minterms, a decoder can build any function of its inputs: write the function as a sum of minterms and OR those outputs together. Example: the odd-parity bit P for three data bits A, B, C must be 1 when the data has an even number of 1s, so that the total number of 1s becomes odd. That happens for 000, 011, 101 and 110:

چونکە دەرخستەکانی کۆدهەڵوەشێنەر مینتێرمەکانن، کۆدهەڵوەشێنەرێک دەتوانێت هەر نەخشەیەکی بوولیی نێوخستەکانی خۆی دروست بکات: نەخشە بوولییەکە وەک کۆی مینتێرمەکان بنووسە و دەرخستەکانی هاوتای ئەو مینتێرمەکان بە OR پێکەوە ببەستە. نموونە: بیتی پاریتیی (Parity bit) تاک P بۆ سێ بیتی دراوە A، B، C دەبێت 1 بێت کاتێک دراوەکە ژمارەیەکی جووتی 1ـی تێدا بێت، تاکو کۆی ژمارەی 1ـەکان ببێتە تاک. ئەمە بۆ ⁦000⁩، ⁦011⁩، ⁦101⁩ و ⁦110⁩ ڕوو دەدات:

The decoder version needs no simplifying at all: the minterm list is the circuit. (Parity bits are explained with the ASCII code.)

وەشانی کۆدهەڵوەشێنەر هیچ کورتکردنەوەیەکی ناوێت: لیستی مینتێرمەکان خودی سووڕەکەیە. (بیتی پاریتی لەگەڵ کۆدی ASCII ڕوون کراوەتەوە.)

A multiplexer can do the same job. Put the function's variables on the select lines and wire each data input to the value the truth table wants in that row. With an 8-to-1 multiplexer and A, B, C on $S_2S_1S_0$, the parity bit needs $D_0 \ldots D_7 = 1, 0, 0, 1, 0, 1, 1, 0$ — the output column of the truth table, copied onto the inputs.

مەڵتیپلێکسەرێکیش دەتوانێت هەمان کار بکات. گۆڕاوە بوولییەکانی نەخشە بوولییەکە بخەرە سەر هێڵەکانی هەڵبژاردن و هەر نێوخستەیەکی دراوە ببەستە بەو بەهایەی خشتەی ڕاستی لەو ڕیزەدا دەیەوێت. بە مەڵتیپلێکسەرێکی هەشت بۆ یەک و A، B، C لەسەر $S_2S_1S_0$، بیتی پاریتییەکە پێویستی بە $D_0 \ldots D_7 = 1, 0, 0, 1, 0, 1, 1, 0$ هەیە — ستوونی دەرخستەی خشتەی ڕاستی، کە کۆپی کراوەتە سەر نێوخستەکان.

A smaller trick uses a 4-to-1 multiplexer with only A and B on the select lines. Each data input then gets 0, 1, C or $\overline{C}$. Look at each pair of rows that share the same A and B:

فێڵێکی بچووکتر مەڵتیپلێکسەرێکی چوار بۆ یەک بەکار دەهێنێت کە تەنها A و B لەسەر هێڵەکانی هەڵبژاردنن. ئەو کاتە هەر نێوخستەیەکی دراوە 0، 1، C یان $\overline{C}$ وەردەگرێت. سەیری هەر جووتە ڕیزێک بکە کە هەمان A و Bـیان هەیە:

That is the right half of the figure above: one 4-to-1 multiplexer and one NOT gate replace the whole parity circuit. When both rows of a pair give 0 (or both give 1), the data input is simply wired to 0 (or 1).

ئەمە نیوەی ڕاستی وێنەکەی سەرەوەیە: یەک مەڵتیپلێکسەری چوار بۆ یەک و یەک گەیتی NOT جێگەی هەموو سووڕی پاریتییەکە دەگرنەوە. کاتێک هەردوو ڕیزی جووتێک 0 بدەن (یان هەردووکیان ⁦1⁩)، نێوخستەی دراوەکە تەنها بە 0 (یان ⁦1⁩) دەبەسترێتەوە.

A comparator compares two binary numbers A and B. Equality you already know: one XNOR per pair of bits and an AND gate. A magnitude comparator also says which number is larger. For one bit, with G for $A > B$, E for $A = B$ and L for $A < B$:

بەراوردکەر دوو ژمارەی دووانی A و B بەراورد دەکات. یەکسانی پێشتر دەیزانیت: بۆ هەر جووتە بیتێک یەک XNOR و گەیتێکی AND. بەراوردکەرێکی قەبارە هەروەها دەڵێت کام ژمارە گەورەترە. بۆ یەک بیت، کە G بۆ $A > B$، E بۆ $A = B$ و L بۆ $A < B$ـە:

For longer numbers, compare from the most significant bit down, the way you compare 47 and 45: the first position where the numbers differ decides. $A = 1011$ (11) and $B = 1001$ (9) agree in bits 3 and 2; in bit 1 A has the 1, so $A > B$. The 7485 / 74HC85 chip does this for 4 bits and has extra inputs so that several chips can be chained for longer numbers.

بۆ ژمارەی درێژتر، لە گرنگترین بیتەوە بەرەو خوار بەراورد بکە، وەک چۆن ⁦47⁩ و ⁦45⁩ بەراورد دەکەیت: یەکەم شوێن کە ژمارەکان تێیدا جیاوازن بڕیار دەدات. $A = 1011$ ⁦(11)⁩ و $B = 1001$ ⁦(9)⁩ لە بیتەکانی 3 و 2دا وەک یەکن؛ لە بیتی 1دا ⁦A 1⁩ـەکەی هەیە، بۆیە $A > B$. چیپی ⁦7485 / 74HC85⁩ ئەمە بۆ 4 بیت دەکات و نێوخستەی زیادەی هەیە تاکو چەند چیپێک بۆ ژمارەی درێژتر بە یەکەوە زنجیر بکرێن.

Every block in this lesson is sold as a small chip of the 7400 family (and its CMOS relatives). Inside a modern processor the same blocks are parts of one huge circuit, but they work exactly as here.

هەموو بلۆکێکی ئەم وانەیە وەک چیپێکی بچووکی خێزانی ⁦7400⁩ (و خزمە CMOSـەکانی) دەفرۆشرێت. لەناو پرۆسێسەرێکی نوێدا هەمان بلۆکەکان بەشێکن لە یەک سووڕی زۆر گەورە، بەڵام ڕێک وەک ئێرە کار دەکەن.

Original exercises in the spirit of the course's exercise set: build functions with a decoder and external gates, simplify with don't-cares, and read MSI blocks. Try each one before you open the answer.

ڕاهێنانی تازە لەسەر شێوەی ڕاهێنانەکانی کۆرسەکە: دروستکردنی نەخشە بوولییەکان بە کۆدهەڵوەشێنەر و گەیتی دەرەکی، کورتکردنەوە بە دۆخە بێبایەخەکان و خوێندنەوەی بلۆکەکانی MSI. پێش کردنەوەی وەڵام هەر یەکێکیان تاقی بکەرەوە.