# Sayısal Mantık Tasarımı

> Boole cebiri, Karnaugh haritaları, kombinasyonel devreler, flip-floplar, sayaçlar, yazmaçlar, bellek elemanları ve durum makineleri üzerine ayrıntılı sayısal mantık notları.

- Author: Muhammet Ali Köker
- Language: tr
- Canonical: https://alikoker.com.tr/sayisal-mantik-tasarimi
- Translation: https://alikoker.com.tr/en/digital-logic-design
- Published: 2014-06-14T14:10:00+03:00
- Modified: 2025-11-18T19:40:00+03:00
- Verified: 2026-08-08T15:00:00+03:00
- Type: article

Sayısal mantık notlarım Boole ifadesinden gerçek devreye, oradan ardışıl davranış ve durum makinelerine geçişi izliyordu. Bu sürümde Karnaugh sadeleştirmeleri, kombinasyonel bloklar, flip-floplar, sayaçlar ve yazmaçlar arasındaki bağı korudum. Daha sonraki HDL terminolojisini yalnız tarihsel çekirdeği açıklamaya yardımcı olduğu ölçüde ekledim.

## Ünite 1: Sayı Sistemleri ve İkili Kodlar

### Konumsal sayı sistemleri

Sayısal sistemlerde sayıların değeri yalnız kullanılan sembollere değil, bu sembollerin bulunduğu basamaklara da bağlıdır. Tabanı `b` olan konumsal bir sayı sistemi:

```text
(dn ... d2 d1 d0 . d-1 d-2 ...)b
```

biçiminde gösterilebilir.

Sayının değeri:

```text
N = sum(di x b^i)
```

ile bulunur.

Burada:

- `b`: sayı sisteminin tabanı,
- `di`: ilgili basamaktaki rakam,
- `i`: basamak konumudur.

Bir tabanda kullanılabilecek rakamlar:

```text
0 ... b-1
```

aralığındadır.

Örneğin onluk sistemde taban 10, ikili sistemde 2, sekizli sistemde 8, onaltılı sistemde 16'dır.

### Basamak ağırlığı

Bir sayının her basamağı:

```text
di x b^i
```

ağırlığına sahiptir.

Örneğin:

```text
65872_10
```

sayısında:

```text
6 x 10^4
5 x 10^3
8 x 10^2
7 x 10^1
2 x 10^0
```

terimleri bulunur.

En sağdaki basamak en az anlamlı basamak, en soldaki basamak en çok anlamlı basamaktır.

İkili sayılarda bunlar sırasıyla:

```text
LSB - Least Significant Bit
MSB - Most Significant Bit
```

olarak adlandırılır.

### Kombinasyon sayısı

Tabanı `b` olan sistemde `n` basamak:

```text
b^n
```

farklı kombinasyon oluşturabilir.

İkili sistemde `n` bit:

```text
2^n
```

farklı değer temsil eder.

Örneğin 8 bit:

```text
2^8 = 256
```

farklı bit deseni oluşturur.

İşaretsiz gösterimde bu desenler:

```text
0 ... 255
```

aralığını temsil edebilir.

### Onluk sayı sistemi

Onluk sistemin tabanı:

```text
10
```

ve rakamları:

```text
0 1 2 3 4 5 6 7 8 9
```

şeklindedir.

Günlük yaşamda kullanılan sayı sistemidir.

### İkili sayı sistemi

İkili sistemin tabanı:

```text
2
```

ve rakamları:

```text
0
1
```

olarak tanımlanır.

Sayısal elektronik için doğal gösterimdir çünkü iki kararlı mantık durumu doğrudan iki sembolle temsil edilebilir.

Örnek:

```text
101101_2
```

onluk sistemde:

```text
1 x 2^5 +
0 x 2^4 +
1 x 2^3 +
1 x 2^2 +
0 x 2^1 +
1 x 2^0
=
45_10
```

değerine eşittir.

### Sekizli sayı sistemi

Sekizli sistemin tabanı:

```text
8
```

ve rakamları:

```text
0 1 2 3 4 5 6 7
```

şeklindedir.

Bir sekizli rakam tam olarak üç bit ile gösterilebilir:

```text
0_8 = 000_2
1_8 = 001_2
...
7_8 = 111_2
```

Bu nedenle ikili-sekizli dönüşüm üçlü bit grupları üzerinden kolaylıkla yapılabilir.

### Onaltılı sayı sistemi

Onaltılı sistemin tabanı:

```text
16
```

ve rakamları:

```text
0 1 2 3 4 5 6 7 8 9 A B C D E F
```

şeklindedir.

```text
A = 10
B = 11
C = 12
D = 13
E = 14
F = 15
```

Bir onaltılı rakam dört bite karşılık gelir:

```text
0_16 = 0000_2
...
F_16 = 1111_2
```

Bu nedenle işlemci yazmaçları, adresler ve bit maskeleri çoğu zaman onaltılı gösterimle yazılır.

### Onluktan ikiliye dönüşüm

Tamsayı bölümünde sayı art arda 2'ye bölünür. Kalanlar ters sırada okunur.

Örnek:

```text
13 / 2 = 6 kalan 1
 6 / 2 = 3 kalan 0
 3 / 2 = 1 kalan 1
 1 / 2 = 0 kalan 1
```

Sonuç:

```text
13_10 = 1101_2
```

### İkiliden onluya dönüşüm

Her bit basamak ağırlığıyla çarpılır:

```text
110101_2
=
1 x 2^5 +
1 x 2^4 +
0 x 2^3 +
1 x 2^2 +
0 x 2^1 +
1 x 2^0
=
53_10
```

### İkili-onaltılı dönüşüm

İkili sayı sağdan başlayarak dörderli gruplara ayrılır:

```text
1011 1100 0110
   B    C    6
```

Dolayısıyla:

```text
101111000110_2 = BC6_16
```

Ters dönüşümde her onaltılı rakam dört bit ile değiştirilir.

### İkili-sekizli dönüşüm

Bitler üçlü gruplara ayrılır:

```text
101 110 011
 5   6   3
```

Dolayısıyla:

```text
101110011_2 = 563_8
```

### İkili toplama

Temel kurallar:

```text
0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 10
1 + 1 + 1 = 11
```

`1 + 1` işleminde:

```text
toplam = 0
elde = 1
```

oluşur.

Bu davranış tam toplayıcı devresinin temelidir.

### İki'nin tümleyeni

Modern sayısal sistemlerde signed tamsayıların temel gösterimi iki'nin tümleyenidir.

`n` bit signed aralık:

```text
-2^(n-1) ... 2^(n-1)-1
```

olur.

8 bit için:

```text
-128 ... 127
```

Bir bit deseninin iki'nin tümleyeni:

1. bütün bitleri tersle,
2. sonuca 1 ekle

adımlarıyla elde edilir.

Örnek:

```text
00001101     13
11110010     1'in tümleyeni
11110011     2'nin tümleyeni
```

Bu desen 8 bit signed gösterimde `-13` değeridir.

### İkili çıkarma

Çıkarma toplama donanımı kullanılarak yapılabilir:

```text
A - B
=
A + two_complement(B)
```

Örneğin:

```text
7 - 3
=
7 + (-3)
```

biçiminde hesaplanabilir.

Bu özellik sayısal devre tasarımında ayrı bir büyük çıkarma donanımı yerine toplama ve tümleme yapılarının birlikte kullanılmasını sağlar.

### İkili çarpma

Temel bit çarpımları:

```text
0 x 0 = 0
0 x 1 = 0
1 x 0 = 0
1 x 1 = 1
```

Çok basamaklı çarpım:

- kısmi çarpım üretme,
- kaydırma,
- toplama

işlemleriyle gerçekleştirilebilir.

Örnek:

```text
   1011
x   101
-------
   1011
  0000
 1011
-------
110111
```

### İkili bölme

İkili bölme:

- karşılaştırma,
- çıkarma,
- kaydırma

işlemleri kullanılarak yapılabilir.

Tekrarlı çıkarma öğretici bir modeldir, ancak donanım bölücüler daha gelişmiş ardışıl veya paralel algoritmalar kullanabilir.

### İkili sayı ve ikili kod farkı

İkili sayı:

```text
1010_2
```

gibi bir sayısal değerin taban-2 gösterimidir.

İkili kod ise bir sembol veya bilgiyi belirli kurala göre bit dizisiyle temsil eder.

Örneğin onluk `12` sayısı:

```text
1100_2
```

ikili değerine sahiptir.

8421 BCD kodu ise:

```text
0001 0010
```

şeklindedir.

Bu iki gösterim birbirine karıştırılmamalıdır.

### BCD

BCD, her onluk rakamı ayrı dört bitlik kodla gösterir.

Örnek:

```text
59_10
```

için:

```text
5 -> 0101
9 -> 1001
```

dolayısıyla:

```text
59_BCD = 0101 1001
```

olur.

Dört bit 16 kombinasyon oluşturmasına rağmen BCD yalnız:

```text
0000 ... 1001
```

aralığındaki 10 deseni kullanır.

### Alfanümerik kodlar

Karakterler de bit dizileriyle kodlanır.

ASCII:

```text
7 bit
128 kod noktası
```

tanımlar.

ASCII'nin kendisi 7 bitlik bir koddur. Tarihsel seri iletişim sistemlerinde ayrıca sekizinci bit eşlik biti olarak kullanılabilmiştir, ancak bu ASCII standardının zorunlu bir parçası değildir.

EBCDIC özellikle IBM ana bilgisayarlarında tarihsel ve güncel kullanım alanına sahip 8 bitlik karakter kodlama ailesidir.

Modern metin sistemlerinde temel standart Unicode'dur. Unicode kod noktaları UTF-8, UTF-16 ve UTF-32 gibi kodlama biçimleriyle saklanabilir.

## Ünite 2: İkili Mantık ve Mantık Kapıları

### İkili mantık

İkili mantıkta değişkenler iki değer alır:

```text
0
1
```

Bunlar fiziksel devrede:

- düşük/yüksek gerilim,
- pasif/aktif,
- yanlış/doğru

gibi anlamlara karşılık gelebilir.

Mantıksal `0` ve `1` doğrudan tek bir gerilim değeri değil, kullanılan lojik aile tarafından tanımlanan gerilim aralıklarıdır.

### AND işlemi

AND:

```text
Z = A B
```

veya:

```text
Z = A AND B
```

şeklinde gösterilir.

| A | B | Z |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |

Çıkış yalnız bütün girişler `1` ise `1` olur.

### OR işlemi

OR:

```text
Z = A + B
```

şeklinde yazılır.

| A | B | Z |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |

En az bir giriş `1` ise çıkış `1` olur.

### NOT işlemi

NOT tek girişlidir:

```text
Z = A'
```

| A | Z |
| --- | --- |
| 0 | 1 |
| 1 | 0 |

Girişi tersler.

### Anahtarlama modeli

Mantık işlemleri anahtarlarla modellenebilir.

Seri anahtarlar:

```text
A AND B
```

davranışına benzetilebilir. Akım yolunun oluşması için iki anahtarın da kapalı olması gerekir.

Paralel anahtarlar:

```text
A OR B
```

davranışına benzetilebilir. Kollardan birinin kapanması akım yolunu oluşturabilir.

Bu model mantığı öğretmek için yararlıdır. Gerçek sayısal tümdevreler MOSFET veya başka aktif elektronik yapıların transistor düzeyindeki birleşimleriyle gerçekleştirilir.

### Buffer

Tampon kapısı:

```text
Y = A
```

işlevini gerçekleştirir.

Mantıksal değeri değiştirmez ancak fiziksel devrede:

- sürme kapasitesi,
- izolasyon,
- fan-out,
- sinyal bütünlüğü

için önemlidir.

### Inverter

Tersleyici:

```text
Y = A'
```

işlevini gerçekleştirir.

CMOS inverter sayısal elektronik için en temel transistor düzeyindeki devrelerden biridir.

### NAND

NAND:

```text
Y = (AB)'
```

işlevini verir.

NAND evrensel kapıdır. Her Boolean işlev yalnız NAND kullanılarak gerçekleştirilebilir.

### NOR

NOR:

```text
Y = (A + B)'
```

işlevini verir.

NOR da evrensel kapıdır.

### XOR

Exclusive OR:

```text
Y = A XOR B
```

girişler farklı olduğunda `1` üretir.

| A | B | XOR |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |

Boolean gösterim:

```text
A XOR B = A'B + AB'
```

XOR:

- toplama,
- parity,
- bit değiştirme

devrelerinde önemlidir.

### XNOR

XNOR girişler aynı olduğunda `1` üretir:

```text
A XNOR B = AB + A'B'
```

Bir bitlik eşitlik karşılaştırıcısının temelidir.

## Ünite 3: Mantık Devrelerinin Analizi ve Sentezi

### Genel mantık devresi

Bir kombinasyonel devrenin çıkışları yalnız mevcut girişlerin fonksiyonudur:

```text
Y = F(X)
```

Geçmiş durumun etkisi yoktur.

Bir devre:

- lojik şema,
- Boolean denklem,
- doğruluk tablosu

ile eşdeğer biçimde ifade edilebilir.

### Analiz

Analizde devre verilidir ve davranışı bulunur.

Temel sıra:

1. giriş değişkenlerini belirle,
2. ara düğümleri adlandır,
3. her kapının denklemini yaz,
4. çıkış denklemini çıkar,
5. gerekiyorsa sadeleştir,
6. doğruluk tablosunu oluştur.

Örneğin:

```text
X = AB
Y = C'
Z = X + Y
```

ise:

```text
Z = AB + C'
```

olur.

### Sentez

Sentezde istenen davranış verilir ve devre oluşturulur.

Temel sıra:

1. giriş ve çıkışları belirle,
2. doğruluk tablosunu oluştur,
3. Boolean fonksiyonunu çıkar,
4. sadeleştir,
5. kapılarla gerçekleştir.

### Minterm

`n` değişkenli minterm her değişkeni bir kez içerir ve yalnız bir giriş kombinasyonunda `1` olur.

İki değişken için:

```text
m0 = A'B'
m1 = A'B
m2 = AB'
m3 = AB
```

Bir doğruluk tablosunda çıkışın `1` olduğu satırların mintermleri OR işlemine alınarak kanonik SOP elde edilir.

Örnek:

```text
F(A,B) = sum m(1,3)
```

eşdeğeri:

```text
F = A'B + AB
```

olur.

### Sum of Products

SOP, çarpım terimlerinin toplamıdır:

```text
F = A'BC + AB'C + ABC
```

AND kapılarıyla terimler oluşturulur, ardından OR ile birleştirilir.

### Maxterm

Maxterm her değişkeni bir kez içeren toplam terimidir ve yalnız bir giriş kombinasyonunda `0` olur.

İki değişken için örnek maxtermler:

```text
M0 = A + B
M1 = A + B'
M2 = A' + B
M3 = A' + B'
```

### Product of Sums

POS toplam terimlerinin çarpımıdır:

```text
F = (A + B')(A' + C)
```

Doğruluk tablosunda çıkışın `0` olduğu satırlardan kanonik POS oluşturulabilir.

### Kanonik ve sadeleştirilmiş ifade

Kanonik ifade doğruluk tablosunun davranışını doğrudan temsil eder ancak minimum kapı sayısını garanti etmez.

Sadeleştirme amacı:

- literal sayısını,
- kapı sayısını,
- kapı giriş sayısını,
- gecikmeyi

azaltmaktır.

Gerçek donanım sentezinde yalnız cebirsel küçüklük değil:

- zamanlama,
- güç,
- alan,
- fan-out,
- teknoloji kütüphanesi

de değerlendirilir.

## Ünite 4: Boole Cebri

### Temel yapı

Boole cebri iki değerli mantığın cebirsel temelidir.

Değerler:

```text
0
1
```

Temel işlemler:

```text
AND
OR
NOT
```

### Kimlik kuralları

```text
A + 0 = A
A . 1 = A
```

### Baskınlık

```text
A + 1 = 1
A . 0 = 0
```

### Idempotent kuralları

```text
A + A = A
A . A = A
```

### Tamamlayıcı

```text
A + A' = 1
A . A' = 0
```

### Çift tümleme

```text
(A')' = A
```

### Değişme

```text
A + B = B + A
AB = BA
```

### Birleşme

```text
A + (B + C) = (A + B) + C
A(BC) = (AB)C
```

### Dağılma

```text
A(B + C) = AB + AC
```

Boolean cebrinde ayrıca:

```text
A + BC = (A + B)(A + C)
```

eşitliği geçerlidir.

### Yutma

```text
A + AB = A
```

```text
A(A + B) = A
```

### De Morgan

```text
(AB)' = A' + B'
```

```text
(A + B)' = A'B'
```

De Morgan kuralları NAND/NOR dönüşümlerinin temelidir.

### NAND ile gerçekleştirme

Örneğin:

```text
F = AB + CD
```

De Morgan ile:

```text
F = ((AB)'(CD)')'
```

biçimine dönüştürülerek iki seviyeli NAND-NAND ağıyla gerçekleştirilebilir.

### NOR ile gerçekleştirme

POS biçimi:

```text
F = (A + B)(C + D)
```

uygun tersleme ile NOR-NOR ağına dönüştürülebilir.

## Ünite 5: Karnaugh Haritaları

### K-haritasının amacı

Karnaugh haritası az sayıda değişkenli Boolean fonksiyonlarını görsel komşuluk kullanarak sadeleştirir.

K-haritası doğruluk tablosunun yeniden düzenlenmiş biçimidir.

Temel amaç:

- komşu mintermleri birleştirmek,
- değişen değişkenleri elemek,
- daha az literal içeren ifade elde etmektir.

### Gray düzeni

Hücreler normal binary sayma sırasıyla değil Gray kod sırasıyla yerleştirilir:

```text
00
01
11
10
```

Bu sayede komşu hücreler yalnız bir değişkende farklı olur.

### İki değişkenli K-haritası

Dört hücre içerir:

```text
2^2 = 4
```

İki komşu `1` birleştirildiğinde bir değişken elenir.

Örneğin:

```text
A'B + AB = B
```

### Üç değişkenli K-haritası

Sekiz hücre içerir:

```text
2^3 = 8
```

Kenarlar da birbirine komşudur.

Bu nedenle ilk ve son sütun fiziksel olarak uzakta çizilmiş olsa da mantıksal komşudur.

### Dört değişkenli K-haritası

On altı hücre içerir:

```text
2^4 = 16
```

Satır ve sütunların her ikisi de Gray kod düzenindedir.

### Gruplama kuralları

Gruplar:

```text
1, 2, 4, 8, 16, ...
```

hücre içermelidir.

Tercih:

- mümkün olan en büyük grup,
- bütün `1` hücrelerini kapsama,
- gereksiz grup sayısını azaltma.

Gruplar gerektiğinde örtüşebilir.

### SOP sadeleştirmesi

SOP elde etmek için `1` hücreleri gruplanır.

Grup içinde değişmeyen değişkenler sonuç teriminde kalır.

Örneğin dört hücreli bir grupta iki değişken değişiyorsa bu iki değişken elenir.

### POS sadeleştirmesi

POS için `0` hücreleri gruplanır.

Sonuç maxterm biçiminde yazılır.

### Don't-care durumları

Bazı giriş birleşimleri sistemde hiç oluşmuyorsa veya çıkışı önemsizse:

```text
X
```

ile gösterilebilir.

Don't-care hücresi sadeleştirmeyi iyileştiriyorsa `0` veya `1` gibi kullanılabilir, gerekmiyorsa kullanılmayabilir.

### K-haritasının sınırı

İki, üç ve dört değişkenli fonksiyonlarda çok kullanışlıdır.

Değişken sayısı büyüdükçe görsel yöntem zorlaşır. Büyük devrelerde mantık minimizasyonu ve teknoloji eşleme işlemleri EDA sentez araçlarıyla otomatik yapılır.

K-haritası buna rağmen mantık sadeleştirmenin temelini anlamak için önemini korur.

## Ünite 6: Birleşimsel Devre Tasarımı

### Tasarım adımları

Bir birleşimsel devre için:

1. problemi tanımla,
2. giriş ve çıkışları belirle,
3. doğruluk tablosunu oluştur,
4. çıkış fonksiyonlarını yaz,
5. sadeleştir,
6. devreyi çiz,
7. doğrula.

Bu sıra:

- toplayıcı,
- çıkarıcı,
- karşılaştırıcı,
- kodlayıcı,
- kod çözücü,
- çoklayıcı

gibi yapıların tamamına uygulanabilir.

### Yarım toplayıcı

İki bit toplar:

```text
A
B
```

Çıkışlar:

```text
S
C
```

Doğruluk tablosu:

| A | B | S | C |
| --- | --- | --- | --- |
| 0 | 0 | 0 | 0 |
| 0 | 1 | 1 | 0 |
| 1 | 0 | 1 | 0 |
| 1 | 1 | 0 | 1 |

Denklemler:

```text
S = A XOR B
C = AB
```

### Tam toplayıcı

Tam toplayıcı:

```text
A
B
Cin
```

girişlerini toplar.

Çıkışlar:

```text
S
Cout
```

Toplam:

```text
S = A XOR B XOR Cin
```

Elde:

```text
Cout = AB + Cin(A XOR B)
```

şeklinde yazılabilir.

### Tam toplayıcının yarım toplayıcılardan kurulması

Birinci yarım toplayıcı:

```text
S1 = A XOR B
C1 = AB
```

İkinci yarım toplayıcı:

```text
S = S1 XOR Cin
C2 = S1 Cin
```

Son elde:

```text
Cout = C1 + C2
```

olur.

### Paralel toplayıcı

`n` bitlik sayılar için `n` tam toplayıcı zincirlenebilir.

Basit ripple-carry yapısında:

```text
Cout(i) -> Cin(i+1)
```

bağlantısı bulunur.

Sorun, elde gecikmesinin bitler boyunca yayılmasıdır.

Bit genişliği arttıkça hız için:

- carry-lookahead,
- carry-select,
- prefix adder

gibi daha gelişmiş yapılar kullanılabilir.

### İki'nin tümleyeniyle çıkarma

Çıkarma:

```text
A - B
=
A + B' + 1
```

olduğundan toplayıcı devresi hem toplama hem çıkarma için kullanılabilir.

Kontrol biti `SUB`:

```text
B_i XOR SUB
Cin = SUB
```

şeklinde uygulanırsa:

```text
SUB = 0 -> A + B
SUB = 1 -> A + B' + 1
```

elde edilir.

### Karşılaştırıcı

İki ikili sayının:

```text
A > B
A = B
A < B
```

ilişkilerini üretir.

Bir bit için:

```text
EQ = A XNOR B
GT = AB'
LT = A'B
```

Çok bitli karşılaştırmada en anlamlı bitten başlanır.

İlk farklı yüksek basamak sonucu belirler.

### Kaskat karşılaştırıcı

Daha geniş sayıları karşılaştırmak için küçük karşılaştırıcı bloklar zincirlenebilir.

Alt blok:

- eşit,
- büyük,
- küçük

bilgisini üst basamaklara taşır.

Güncel HDL sentezinde karşılaştırma çoğunlukla doğrudan:

```text
A > B
A == B
```

ifadeleriyle yazılır ve sentez aracı uygun devreyi oluşturur.

## Ünite 7: Kodlayıcılar ve Kod Çözücüler

### Kodlayıcı

Encoder, aktif giriş hattını daha kısa ikili kodla temsil eder.

Örneğin 4-to-2 encoder:

```text
D0 -> 00
D1 -> 01
D2 -> 10
D3 -> 11
```

Basit encoder aynı anda yalnız bir girişin aktif olduğunu varsayar.

### Öncelikli kodlayıcı

Birden fazla giriş aynı anda aktif olabiliyorsa priority encoder kullanılır.

Örneğin:

```text
D3 > D2 > D1 > D0
```

önceliği tanımlanmış olabilir.

Birden fazla giriş `1` olduğunda en yüksek öncelikli giriş kodlanır.

Genellikle ayrıca:

```text
valid
```

çıkışı bulunur.

### BCD kodlayıcı

On giriş hattının birini 4 bit BCD koduna dönüştürebilir:

```text
0 ... 9
↓
0000 ... 1001
```

### Kod çözücü

Decoder, `n` bitlik giriş koduna göre en fazla:

```text
2^n
```

çıkıştan birini etkinleştirir.

### 2-to-4 decoder

Girişler:

```text
A1 A0
```

çıkışlar:

```text
Y0 Y1 Y2 Y3
```

Aktif-high durumda:

```text
Y0 = A1'A0'
Y1 = A1'A0
Y2 = A1A0'
Y3 = A1A0
```

### 3-to-8 decoder

Üç giriş:

```text
A2 A1 A0
```

sekiz minterm üretir.

Bu nedenle decoder aynı zamanda minterm üreteci olarak düşünülebilir.

### Enable girişi

Birçok decoder:

```text
EN
```

girişine sahiptir.

Enable aktif değilse decoder çıkışları pasif kalır.

Bu özellik:

- daha büyük decoder kurmak,
- bellek seçmek,
- çevre birimi adreslemek

için kullanılır.

### Entegre devre örnekleri

74xx ailesindeki:

```text
74138
74147
74148
74154
```

gibi devreler tarihsel eğitim ve laboratuvar örnekleridir.

Bu entegreleri tanımak mantık işlevini anlamak için yararlıdır, ancak güncel tasarımda aynı işlev:

- FPGA,
- CPLD,
- ASIC,
- programlanabilir lojik

içinde doğrudan sentezlenebilir.

Ezberlenmesi gereken temel konu parça numarası değil, işlevsel mantıktır.

## Ünite 8: Çoklayıcılar, Demultiplexer ve Üç Durumlu Mantık

### Multiplexer

Multiplexer, birçok veri girişinden birini seçim girişlerine göre tek çıkışa aktarır.

`2^n` veri girişli MUX için:

```text
n
```

seçim biti gerekir.

### 2-to-1 multiplexer

Girişler:

```text
D0
D1
S
```

Çıkış:

```text
Y = S'D0 + SD1
```

olur.

### 4-to-1 multiplexer

İki seçim biti:

```text
S1 S0
```

dört girişten birini seçer.

| S1 | S0 | Y |
| --- | --- | --- |
| 0 | 0 | D0 |
| 0 | 1 | D1 |
| 1 | 0 | D2 |
| 1 | 1 | D3 |

### Çok bitli multiplexer

İki adet 4 bit veri yolu:

```text
A[3:0]
B[3:0]
```

tek 4 bit çıkışa seçilebilir.

Aynı seçim biti her bit konumundaki MUX'u kontrol eder.

Bu yapı işlemci veri yollarında çok yaygındır.

### Multiplexer ile Boolean işlev

MUX veri seçicisi olmasının yanında genel Boolean fonksiyon gerçekleştirmek için de kullanılabilir.

Seçim girişleri değişkenlerden bazılarına bağlanır, veri girişleri:

```text
0
1
X
X'
```

gibi değerlerle doldurulur.

Bu yöntem fonksiyonu doğrudan MUX üzerinden gerçekler.

### Demultiplexer

Demultiplexer tek veri girişini seçim hatlarına göre çok sayıda çıkıştan birine yönlendirir.

2 çıkışlı örnek:

```text
Y0 = S'D
Y1 = SD
```

"Tekilleyici" tarihsel Türkçe kaynaklarda görülebilir. Güncel mühendislik kullanımında `demultiplexer`, `demux` veya çoktan dağıtıcı ifadeleri daha yaygındır.

### Üç durumlu çıkış

Üç durumlu çıkış:

```text
0
1
Z
```

durumlarını alabilir.

`Z` yüksek empedans durumudur.

Bu durumda eleman ortak hattı etkin biçimde sürmez.

### Üç durumlu buffer

Enable aktifken:

```text
Y = A
```

Enable pasifken:

```text
Y = Z
```

olur.

Ortak veri yolunda birden fazla kaynak bulunuyorsa aynı anda yalnız bir sürücünün etkin olması gerekir.

İki kaynağın aynı anda zıt değer sürmesi elektriksel çatışmaya ve yüksek akıma yol açabilir.

### Güncel kullanım

Üç durumlu sürücüler:

- PCB veri yolları,
- harici bellek arabirimleri,
- iki yönlü I/O

için önemlidir.

FPGA ve ASIC iç mantığında büyük üç durumlu ağlar çoğunlukla MUX ağlarına dönüştürülür.

## Ünite 9: Eşlik Devreleri ve Aritmetik Mantık Birimi

### Eşlik

Parity basit hata sezme yöntemidir.

**Çift eşlik:** Veri ve parity biti birlikte değerlendirildiğinde `1` sayısı çift olur.

**Tek eşlik:** Toplam `1` sayısı tek olur.

### Eşlik üretimi

XOR işleminin önemli özelliği:

```text
A XOR B XOR C ...
```

sonucunun bitler içindeki tek/çift `1` sayısına bağlı olmasıdır.

Dört bit için çift eşlik biti:

```text
P = A XOR B XOR C XOR D
```

gibi üretilebilir.

### Eşlik denetimi

Alıcı aynı XOR işlemini veri ve parity biti üzerinde uygular.

Beklenen parity koşulu bozulmuşsa hata sezilir.

Parity:

- tek sayıda bit hatasını sezer,
- çift sayıda bazı hataları kaçırır,
- hata konumunu belirlemez,
- tek başına hata düzeltmez.

Bu nedenle basit hata sezme mekanizmasıdır.

### Aritmetik Mantık Birimi

ALU, işlemcinin aritmetik ve bit düzeyi mantık işlemlerini yapan temel veri yolu bileşenidir.

Girişler:

```text
A
B
operation
carry-in
```

Çıkışlar:

```text
F
flags
```

### Aritmetik işlemler

Basit ALU:

```text
A + B
A - B
A + 1
A - 1
```

gibi işlemleri yapabilir.

### Mantık işlemleri

```text
A AND B
A OR B
A XOR B
NOT A
```

gibi işlemler bulunabilir.

### İşlem seçimi

Aritmetik ve mantık bloklarının sonuçları ayrı üretilebilir ve MUX ile seçilebilir:

```text
A, B
 ├─ Aritmetik birim ─┐
 ├─ Mantık birimi ───┼─ MUX -> F
 └─ Karşılaştırıcı ──┘
```

Kontrol girişleri yapılacak işlevi belirler.

### Durum bayrakları

Bir ALU işlemi sonucunda tipik bayraklar:

- zero,
- carry,
- negative/sign,
- overflow,
- parity

olabilir.

Her ISA aynı bayrakları aynı anlamla kullanmaz.

### Sıfır bayrağı

Sonuç:

```text
F = 0
```

ise etkin olur.

Bit düzeyinde bütün sonuç bitlerinin NOR işlemiyle üretilebilir.

### İşaret bayrağı

İki'nin tümleyeni signed sonuç için en anlamlı bit negatiflik göstergesi olarak kullanılabilir:

```text
N = F[n-1]
```

### Carry

Unsigned toplamada en üst basamaktan çıkan eldeyi ifade eder.

Çıkarma sırasında carry/borrow yorumunun kesin anlamı kullanılan mimariye göre değişebilir.

### Overflow

Signed aritmetik taşmasıdır.

Carry ile aynı şey değildir.

İki'nin tümleyeninde iki aynı işaretli operand toplanıp sonuç ters işaretliyse overflow oluşur.

### Parity bayrağı

Bazı mimariler sonuç bitlerinin parity bilgisini bayrakta tutar.

Bu özellik evrensel değildir ve modern ISA'ların hepsinde bulunmaz.

## Ünite 10: Sıralı Mantık Devreleri

### Sıralı mantık

Birleşimsel devrede:

```text
Y = F(X)
```

Sıralı devrede:

```text
Q(next) = F(Q, X)
Y = G(Q, X)
```

olur.

Çıkış veya sonraki durum geçmiş durumdan etkilenir.

Bellek özelliği geri besleme ve saklama elemanlarıyla oluşturulur.

### Durum

Bir sıralı devrenin gelecekteki davranışını etkileyen saklanmış bilgiye durum denir.

Durum bitleri:

- latch,
- flip-flop,
- register

ile tutulabilir.

### Latch

Latch seviye duyarlı saklama elemanıdır.

Enable aktif olduğu sürece giriş değişimlerini izleyebilir.

### SR NOR latch

Aktif-high SR NOR latch:

| S | R | Q(next) |
| --- | --- | --- |
| 0 | 0 | Önceki durum |
| 1 | 0 | 1 |
| 0 | 1 | 0 |
| 1 | 1 | Geçersiz/yasak |

`S=R=1` durumu klasik NOR latch için geçersizdir.

### SR NAND latch

NAND tabanlı SR latch genellikle aktif-low girişlidir.

Bu nedenle giriş isimleri:

```text
S'
R'
```

biçiminde gösterilebilir.

Aktif seviyenin ne olduğu sembolden ve devreden okunmalıdır.

### Gated latch

Enable sinyali eklenerek latch'in ne zaman girişe tepki vereceği kontrol edilir.

Bu yapı senkron sistemlere geçişi anlamak için önemlidir.

### Flip-flop

Flip-flop tipik olarak saat kenarında durum değiştirir.

Temel türler:

- SR,
- D,
- T,
- JK.

### SR flip-flop

Saat olayında S ve R girişlerine göre durum değiştirir.

Klasik tasarımda `S=R=1` yasak durumdur.

### D flip-flop

D flip-flop:

```text
Q(next) = D
```

denklemine sahiptir.

Tek veri girişi olduğundan yasak giriş kombinasyonu yoktur.

Modern senkron tasarımın en yaygın saklama elemanlarından biridir.

### T flip-flop

T:

```text
T = 0 -> durumu koru
T = 1 -> durumu değiştir
```

Davranış:

```text
Q(next) = T XOR Q
```

olarak yazılabilir.

Sayaçlarda doğal kullanım alanına sahiptir.

### JK flip-flop

JK:

| J | K | Q(next) |
| --- | --- | --- |
| 0 | 0 | Q |
| 0 | 1 | 0 |
| 1 | 0 | 1 |
| 1 | 1 | Q' |

SR'nin yasak durumunu:

```text
J = K = 1
```

için toggle davranışıyla ortadan kaldırır.

### Saat kenarı

Pozitif kenar:

```text
0 -> 1
```

Negatif kenar:

```text
1 -> 0
```

geçişidir.

Flip-flop tasarımına göre yalnız belirlenen kenarda yeni giriş örneklenir.

### Setup ve hold

Bir flip-flopun doğru çalışması için giriş:

- aktif saat kenarından belirli süre önce kararlı olmalı,
- kenardan belirli süre sonra da kararlı kalmalıdır.

Bu süreler:

```text
setup time
hold time
```

olarak adlandırılır.

İhlal edilirse metastability riski oluşur.

### Master-slave flip-flop

Tarihsel master-slave yapı iki seviye duyarlı latch'i ardışık kullanarak girişin bir saat fazında alınmasını, diğer fazda çıkışa aktarılmasını sağlar.

Kenar tetiklemeyi anlamak için öğretici bir yapıdır.

Modern standart hücre kütüphanelerinde gerçek flip-flop iç yapısı teknolojiye bağlıdır.

## Ünite 11: Senkron Sayıcı Tasarımı

### Sayaç

Sayaç her saat olayında önceden belirlenmiş durum dizisini izleyen sıralı devredir.

Üç bit binary sayaç:

```text
000
001
010
011
100
101
110
111
000
...
```

dizisini izler.

### Mod

Bir sayacın tekrar etmeden önce geçtiği farklı durum sayısı:

```text
modulus
```

olarak adlandırılır.

`n` bitlik tam binary sayaç:

```text
mod 2^n
```

yapısındadır.

### Asenkron sayaç

Ripple counter'da bir flip-flopun çıkışı sonrakinin saat girişini sürer.

Avantaj:

- basit devre.

Dezavantaj:

- propagation delay basamaklar boyunca birikir,
- ara geçici durumlar oluşabilir.

### Senkron sayaç

Bütün flip-floplar aynı saat işaretini kullanır.

Sonraki durum giriş mantığıyla hesaplanır.

Bu nedenle yüksek hızlı sayım için daha uygundur.

### Sayaç tasarım adımları

Senkron sayaç tasarımı:

1. durumları belirle,
2. durum diyagramını çiz,
3. durum tablosunu oluştur,
4. kullanılacak flip-flop türünü seç,
5. uyarma gereksinimlerini belirle,
6. K-haritalarıyla sadeleştir,
7. devreyi oluştur.

### Durum diyagramı

İki bit ileri sayaç:

```text
00 -> 01 -> 10 -> 11 -> 00
```

durum geçişlerine sahiptir.

### Durum tablosu

| Q1 | Q0 | Q1(next) | Q0(next) |
| --- | --- | --- | --- |
| 0 | 0 | 0 | 1 |
| 0 | 1 | 1 | 0 |
| 1 | 0 | 1 | 1 |
| 1 | 1 | 0 | 0 |

### T flip-flop uyarımı

T flip-flop için:

| Q | Q(next) | T |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |

Dolayısıyla:

```text
T = Q XOR Q(next)
```

olarak düşünülebilir.

### D flip-flop uyarımı

D flip-flop en basit uyarma ilişkisine sahiptir:

```text
D = Q(next)
```

Bu nedenle modern senkron durum makinesi sentezinde D flip-flop modeli çok doğaldır.

### JK uyarım tablosu

| Q | Q(next) | J | K |
| --- | --- | --- | --- |
| 0 | 0 | 0 | X |
| 0 | 1 | 1 | X |
| 1 | 0 | X | 1 |
| 1 | 1 | X | 0 |

`X` don't-care değeridir.

### Geri sayıcı

İki bit geri sayaç:

```text
11 -> 10 -> 01 -> 00 -> 11
```

gibi davranabilir.

Tasarım adımları ileri sayıcıyla aynıdır. Yalnız hedef durum dizisi değişir.

### İleri-geri sayaç

Kontrol girişi:

```text
UP_DOWN
```

ile bir devre:

```text
ileri
geri
```

sayım arasında seçilebilir.

### Entegre sayaçlar

74xx ailesindeki sayaç entegreleri klasik laboratuvar örnekleridir.

Güncel sistemlerde sayaçlar çoğu zaman:

- FPGA HDL kodu,
- mikrodenetleyici timer/counter çevre birimi,
- ASIC mantığı

içinde gerçekleştirilir.

## Ünite 12: Yazmaçlar

### Yazmaç

Register, ortak kontrol edilen flip-flop grubudur.

`n` bitlik register:

```text
n bit
```

saklar.

Örneğin 8 bit register:

```text
Q7 Q6 Q5 Q4 Q3 Q2 Q1 Q0
```

çıkışlarına sahiptir.

### Paralel yazmaç

Bütün bitler aynı saat olayında yüklenir:

```text
D7...D0
↓
Q7...Q0
```

Bu işleme paralel yükleme denir.

### Load enable

Register yalnız `LOAD=1` olduğunda yeni veri alabilir:

```text
LOAD = 0 -> Q(next) = Q
LOAD = 1 -> Q(next) = D
```

Her bit için MUX yaklaşımı:

```text
Dff_input = LOAD ? D : Q
```

şeklinde düşünülebilir.

### Üç durumlu çıkışlı yazmaç

Bir yazmaç ortak veri yolunu:

```text
OE = 1
```

olduğunda sürer.

Pasif durumda:

```text
Z
```

çıktısı verir.

Aynı veri yolunda yalnız bir kaynak etkin tutulmalıdır.

### Kaydırma yazmacı

Shift register saatle birlikte bitleri bir konum kaydırır.

Temel türler:

- SISO,
- SIPO,
- PISO,
- PIPO.

### Seri giriş paralel çıkış

SIPO:

```text
serial in
   ↓
[FF] -> [FF] -> [FF] -> [FF]
                   ↓
             paralel çıkışlar
```

seri veriyi zaman içinde toplar ve paralel biçimde okunabilir hale getirir.

### Paralel giriş seri çıkış

PISO paralel veriyi tek seri hat üzerinden bit bit göndermek için kullanılır.

Bu yapı:

- pin sayısını azaltma,
- seri iletişim,
- I/O genişletme

uygulamalarında kullanılabilir.

### Seri giriş seri çıkış

SISO bir dijital gecikme hattı gibi düşünülebilir.

Bir bit her saat olayında bir kademe ilerler.

### İki yönlü kaydırma

Kontrol girişine göre:

```text
sağa kaydır
sola kaydır
```

işlemleri yapılabilir.

Universal shift register ayrıca:

- paralel yükleme,
- durumu koruma

işlevlerini de birleştirebilir.

### Aritmetik kaydırma

Signed iki'nin tümleyeni sayıda aritmetik sağa kaydırma işaret bitini koruyacak biçimde gerçekleştirilir.

Lojik sağa kaydırmada ise soldan sıfır girer.

Bu fark aritmetik işlemlerde önemlidir.

## Ünite 13: Yazmaç Dizileri ve Belleğe Geçiş

### Yazmaç dizisi

Register array, birden çok yazmacın ortak veri ve seçim mantığıyla bir araya getirilmesidir.

Örneğin:

```text
4 x 4
```

ifadesi:

```text
4 adet yazmaç
her biri 4 bit
```

anlamına gelebilir.

Toplam saklama kapasitesi:

```text
4 x 4 = 16 bit
```

olur.

### Okuma ve yazma

Temel işlemler:

```text
write:
R[address] <- data
```

```text
read:
data <- R[address]
```

şeklindedir.

Her yazmaç için ayrı RD ve WR hattı kullanmak yazmaç sayısı büyüdükçe verimsiz olur.

Bu nedenle:

- ortak okuma/yazma kontrolü,
- adres seçim hatları,
- decoder

kullanılır.

### Adres seçimi

`N` adet yazmaç için gereken adres biti:

```text
ceil(log2 N)
```

kadardır.

Örneğin 16 yazmaç:

```text
4 bit
```

adresle seçilebilir.

### 4 x 4 yazmaç dizisi

Dört adet 4 bit yazmaç:

```text
R0
R1
R2
R3
```

ortak 4 bit veri yoluna bağlanabilir.

İki adres biti:

```text
A1 A0
```

dört yazmaçtan birini seçer.

### Kapasite genişletme

İki adet:

```text
8 x 4
```

yazmaç dizisi uygun seçim mantığıyla:

```text
16 x 4
```

kapasiteye genişletilebilir.

Burada yazmaç sayısı artar, sözcük genişliği değişmez.

### Sözcük genişliği genişletme

İki adet:

```text
4 x 8
```

yapı paralel bağlanarak:

```text
4 x 16
```

oluşturulabilir.

Burada adres sayısı aynı kalır, her yazmacın bit genişliği artar.

### Boyutlandırma ilkesi

Bellek yapılarında iki ayrı büyüklük vardır:

```text
sözcük sayısı
sözcük genişliği
```

Örneğin:

```text
1024 x 8
```

bellek:

```text
1024 sözcük
8 bit/sözcük
```

anlamına gelir.

Toplam kapasite:

```text
8192 bit
=
1024 bayt
```

olur.

### Adres decoder'ı

`n` adres biti:

```text
2^n
```

satırdan birini seçebilir.

Bu nedenle register array ve RAM organizasyonu decoder kavramının doğrudan uygulamasıdır.

### Register file

İşlemci içindeki yazmaç dizileri güncel terminolojide çoğunlukla **register file** olarak adlandırılır.

Modern register file:

- birden çok okuma portu,
- bir veya daha fazla yazma portu

içerebilir.

Örneğin iki kaynak ve bir hedef kullanan ALU komutu için:

```text
2 read ports
1 write port
```

doğal bir düzenlemedir.

### Yazmaç dizisinden belleğe

Küçük register array ile büyük RAM arasındaki temel düşünce aynıdır:

```text
adres
↓
seçim
↓
saklama hücresi
↓
okuma/yazma veri yolu
```

Fark:

- hücre teknolojisi,
- port sayısı,
- kapasite,
- gecikme,
- enerji,
- fiziksel düzen

gibi ayrıntılardadır.

Bu nedenle sayı sistemlerinden başlayan ders zinciri sonunda gerçek işlemci veri yollarına ulaşır:

```text
bit
↓
kapı
↓
Boolean fonksiyonu
↓
birleşimsel devre
↓
flip-flop
↓
register
↓
register file
↓
ALU ve veri yolu
↓
işlemci
```

## Sayısal Tasarımın Bütünsel Çerçevesi

Sayısal mantık tasarımı birbirinden bağımsız kapı sembollerini ezberleme dersi değildir. Temel düşünce soyutlama katmanlarının birbirine dönüşmesidir.

Bir sayı:

```text
13_10
```

ikili sistemde:

```text
1101_2
```

olarak gösterilir.

Bu bitler fiziksel olarak lojik seviyelerle temsil edilir.

Lojik seviyeler:

```text
AND
OR
NOT
XOR
```

kapılarıyla işlenir.

Kapı ağı Boolean fonksiyonuna karşılık gelir.

Boolean fonksiyonları:

- cebir,
- K-haritası

ile sadeleştirilebilir.

Bu işlevler birleşerek:

```text
toplayıcı
karşılaştırıcı
encoder
decoder
MUX
ALU
```

gibi birleşimsel blokları oluşturur.

Durum saklamak için:

```text
latch
flip-flop
```

eklenir.

Bunlardan:

```text
counter
register
register file
```

oluşturulur.

Sonuçta bilgisayar işlemcisinin temel veri yolu bileşenlerine ulaşılır.

Sayısal tasarımın ana zinciri:

```text
Sayı gösterimi
    ↓
Boolean cebri
    ↓
Mantık kapıları
    ↓
Kombinasyonel mantık
    ↓
Sıralı mantık
    ↓
Yazmaçlar ve sayaçlar
    ↓
Veri yolu ve ALU
    ↓
İşlemci organizasyonu
```

şeklindedir.

## Bu Çalışmaya Atıf

Köker, M. A. (2014). Sayısal Mantık Tasarımı. alikoker.com.tr. https://alikoker.com.tr/sayisal-mantik-tasarimi

- BibTeX: https://alikoker.com.tr/sayisal-mantik-tasarimi.bib
- RIS: https://alikoker.com.tr/sayisal-mantik-tasarimi.ris
- CSL-JSON: https://alikoker.com.tr/sayisal-mantik-tasarimi.csl.json