74181
IC 74181 to 4-bitowy ALU.
| Kierunek | Szerokość | Nazwa | Opis | |
| Wejście | [3: 0] | a | Wejście a | |
| Wejście | [3: 0] | B | Wejście b | |
| Wejście | [3: 0] | s | Wybrana funkcja | |
| Wejście | M | Tryb: 0 = logika | 1 = arytmetyka | |
| Wejście | Cn | Przeniesienie | ||
| Wyjście | [3: 0] | F | Wynik | |
| Wyjście | X | Nosić generowanie | ||
| Wyjście | Y | Nosić propagację | ||
| Wyjście | Aeqb | A == B. | ||
| Wyjście | . CNP4 przeniesienie (CN+4) |
| S3 | S2 | S1 | S0 | Funkcja logiczna | Logika Opis | Arith Funkcja | Arith Opis |
| - | - | - | - | -------------------- | -------------------- | ------------------ | --------------------- |
| 0 | 0 | 0 | 0 | ! (A | b) | ani | a | przenieś a |
| 0 | 0 | 0 | 1 | ! (A & b) | nand | a +! B | a - b - 1 |
| 0 | 0 | 1 | 0 | ! A & b | not a i b | a +! B + cn | a - b |
| 0 | 0 | 1 | 1 | ! A | nie a | a - 1 + cn | a - 1 |
| 0 | 1 | 0 | 0 | ! B | nie b | a + a | double a |
| 0 | 1 | 0 | 1 | a ^ b | xor | a + a +! B | a + a - b - 1 |
| 0 | 1 | 1 | 0 | ! A | B | nie a lub b | a + a +! B + cn | a + a - b |
| 0 | 1 | 1 | 1 | ! (A ^ B) | XNOR | 2A - 1 + cn | podwójnie minus 1 |
| 1 | 0 | 0 | 0 | a & b | i | a + b | Dodaj |
| 1 | 0 | 0 | 1 | ! (A |! B) | lub z nie b | a + b + 1 | Dodaj z noszeniem |
| 1 | 0 | 1 | 0 | a | przenieś a | a + 1 | Przyrost a |
| 1 | 0 | 1 | 1 | a | ! B | a lub nie b | a +! B + 1 | a - b + 1 |
| 1 | 1 | 0 | 0 | B | Przenieś B | 1 | Zawsze 1 (ustaw) |
| 1 | 1 | 0 | 1 | a | B | lub | 0 | zawsze 0 (jasne) |
| 1 | 1 | 1 | 0 | a &! B | a, a nie b | ! B | nie b |
| 1 | 1 | 1 | 1 | ! (A ^ B) | XNOR | ! B + CN | NOT B + NAROR |
Werilog równoważny, bez noszenia i inne ważne sygnały:
moduł ALU74181 (
wejście [3: 0] s,
wejście ci, m,
wejście [3: 0] a, b,
Reg wyjściowy [3: 0] y
);
Reg [3: 0] P, g;
Zawsze @(*) Zacznij
p [0] <= ~ (a [0] | (s [0] i b [0]) | (s [1] i ~ b [0]));
P [1] <= ~ (a [1] | (s [0] i b [1]) | (s [1] i ~ b [1]));
P [2] <= ~ (A [2] | (S [0] i B [2]) | (S [1] i ~ B [2]));
P [3] <= ~ (A [3] | (S [0] i B [3]) | (S [1] i ~ B [3]));
g [0] <= ~ ((a [0] i ~ b [0] & s [2]) | (a [0] i b [0] i s [3]));
g [1] <= ~ ((a [1] i ~ b [1] i s [2]) | (a [1] i b [1] i s [3]));
g [2] <= ~ ((a [2] i ~ b [2] i s [2]) | (a [2] i b [2] i s [3]));
g [3] <= ~ (A [3] i ~ B [3] i s [2]) | (A [3] i B [3] i S [3]));
y [0] = (p [0] ^ g [0]) ^ ~ (~ ci & ~ m);
y [1] = (p [1] ^ g [1]) ^ ~ ((~ ci & ~ m & g [0]) | (~ m & p [0]));
y [2] = (p [2] ^ g [2]) ^ ~ ((~ ci & ~ m & g [0] i g [1]) | (~ m & p [1]) | (~ m & p [0] i g [1]));
y [3] = (p [3] ^ g [3]) ^ ~ ((~ ci & ~ m & g [0] & g [1] i g [2]) | (~ m & p [2]) | (~ m & p [1] i g [2]) | (~ m & p [0] i g [1] i g [2]));
koniec
Endmodule // ALU74181
Ukończ Verilog, jeszcze nie sprawdzony:
moduł ALU74181 (
przewód wejściowy [3: 0] a,
przewód wejściowy [3: 0] b,
przewód wejściowy [3: 0] s,
Drut wejściowy M, // Tryb: 0 = logika, 1 = arytmetyka
przewód wejściowy CN, // przeniesienie
drut wyjściowy [3: 0] f, // wynik
Wygeneruj przewód wyjściowy x, //
drut wyjściowy y, // przenoś propagację
Drut wyjściowy aeqb, // a == b
Drut wyjściowy CNP4 // Przenoszenie (CN+4)
);
drut [3: 0] tu;
Wire [3: 0] TV;
drut [3: 0] TX;
// tu [n] = ~ (a [n] | (b [n] i s [0]) | (~ b [n] i s [1])))
Przypisz Tu [0] = ~ (A [0] | (B [0] & S [0]) | (~ B [0] & s [1]));
Przypisz Tu [1] = ~ (A [1] | (B [1] i S [0]) | (~ B [1] i S [1]));
Przypisz Tu [2] = ~ (A [2] | (B [2] i S [0]) | (~ B [2] i S [1]));
Przypisz Tu [3] = ~ (A [3] | (B [3] i S [0]) | (~ B [3] i S [1]));
// tv [n] = ~ ((a [n] i ~ b [n] i s [2]) | (a [n] i b [n] i s [3])))
Przypisz TV [0] = ~ ((A [0] i ~ B [0] & s [2]) | (A [0] i B [0] i S [3]));
Przypisz TV [1] = ~ ((A [1] i ~ B [1] i s [2]) | (A [1] i B [1] i S [3]));
Przypisz TV [2] = ~ ((A [2] i ~ B [2] i S [2]) | (A [2] i B [2] i S [3]));
Przypisz TV [3] = ~ (A [3] i ~ B [3] i S [2]) | (A [3] i B [3] i S [3]));
// tx [n] = tu [n] ^ tv [n]
przypisz tx = tu ^ tv;
// Ty = TU0 & TV1 & TV2 i TV3 | TU1 i TV2 i TV3 | TU2 i TV3 | Tu3
Wire ty = (tu [0] i telewizja [1] i telewizja [2] i telewizja [3]) |
(TU [1] i TV [2] i TV [3]) |
(TU [2] i TV [3]) |
TU [3];
// f [n] = tx [n] ^ noś logikę
Przypisz f [0] = tx [0] ^ ~ (m & cn);
Przypisz f [1] = tx [1] ^ ~ ((tu [0] i m) | (TV [0] i m & cn));
Przypisz f [2] = tx [2] ^ ~ ((tu [1] i m) |
(TU [0] i TV [1] i m) |
(TV [0] i TV [1] i M & CN));
Przypisz f [3] = tx [3] ^ ~ ((tu [2] i m) |
(TU [1] i TV [2] i m) |
(TU [0] i TV [1] i TV [2] i m) |
(TV [0] i TV [1] i TV [2] i M & CN));
// Wyjścia stanu
Przypisz x = ~ (telewizję [0] i telewizja [1] i telewizja [2] i telewizja [3]); // noszenie wygenerowania (g)
przypisać y = ~ ty; // noś propagację (p)
przypisz aeqb = f [0] i f [1] i f [2] i f [3]; // a == b
Przypisz CNP4 = Ty | (TV [0] i TV [1] i TV [2] i TV [3] i CN); // przeniesienie (CN+4)
Endmodule