8-bitowe alu verilog kod (brama poziomu) wymagane!

[icaniwill]

Muszę 8-bitowy kod alu verilog (brama poziomu) może ktoś mi pomoże?

 

[news]

Z eksperymentu, który F-Secure przeprowadził wspólnie z Europolem, wynika, że konsumenci beztrosko narażają swoje dane osobiste i lekkomyślnie akceptują absurdalne warunki korzystania z sieci.

Read more...

 

[pratibha md]

Oto kod
DONT FORGET TO PREZ HEPLED ME THE BUTTONModuł alu (CLK, RESET, A, B, T, OP, C, N, V, Z);

//************************************************ ****
/ / 8 bitowa jednostka arytmetyczno-logiczna
/ /
/ / Parametr:
/ / CLK ....... zegarem systemowym
/ / RESET ..... System Resetuj
/ / A. ........ A wejście
/ / B. ........ wejście B
/ / OP ........ do wykonywania operacji
/ / Y. ........ 8 bitów wyniku wyjścia
/ / C. ........ carry
/ / V. ........ przepełnienia statusu
/ / N. ........ podpisania statusu
/ / Z. ........ zero status
/ /
//************************************************ ****
wejście CLK, RESET;
wejscie [7:0] A;
wejscie [7:0] B;
wejscie [15:0] OP;
wyjście [7:0] Y;
wyjście C;
wyjście V;
wyjście N;
Z wyjścia;
//------------------------------------------------ ------
/ / Wewnętrzne węzły
//------------------------------------------------ ------
reg [7:0] Y, LogicUnit, AluNoShift;
wire [7:0] ArithUnit;
reg shiftout;
Drut C, V, N, Z;

Drut carryout;
Drut OVF;
reg Neg; / / negatywny status ALU
reg Zero / / zero status ALU

//------------------------------------------------ -----------
/ / Arithmetic jednostki
/ /
/ / Gona wykorzystania myAddSub dla tej części ... wydaje się, prawo do pracy ...
/ / Zamiast próbuje wyprowadzić rzeczy.
/ /
/ / Działanie w adder subtractor jest następująca
/ /
/ / PO [0] OP [1] przeprowadzać | operacji
/ / 0 0 0 | Y = A - 1;
/ / 0 0 1 | Y = A;
/ / 0 1 0 | Y = A - B - 1;
/ / 0 1 1 | Y = A - B;
/ / 1 0 0 | Y = A;
/ / 1 0 1 | Y = A 1;
/ / 1 1 0 | Y = A B;
/ / 1 1 1 | Y = A B 1;
/ /
//------------------------------------------------ ------------

myAddSub ADD1 (. A (A). B (B). CI (C). ADD (PO [0]). BOP (PO) [1],. Y (ArithUnit). CO (carryout) . OVF (OVF));

//---------------------------------------------
/ / Logic Unit
/ / OP [1] PO [0] | operacji
/ / 0 0 | Y = A i B
/ / 0 1 | Y = A lub B
/ / 1 0 | Y = A xor B
/ / 1 1 | Y = Not A
//---------------------------------------------

zawsze @ (A lub B lub OP [1:0])
zacząć
przypadku (PO [1:0])
2'b00: LogicUnit = A & B;
2'b01: LogicUnit = A | B;
2'b10: LogicUnit = A ^ B;
2'b11: LogicUnit =! A;
domyślnie: LogicUnit = 8'bx;
endcase
koniec
//----------------------------------------------
/ / Wybierz między logiką i arithmatic
/ / PO [2] | operacji
/ / 0 | operację arytmetyczną
/ / 1 | Logiczne operacji
//----------------------------------------------
zawsze @ (PO [2] lub LogicUnit lub ArithUnit)
zacząć
jeśli (PO) [2]
AluNoShift = LogicUnit;
w przeciwnym razie
AluNoShift = ArithUnit [7:0];
koniec
//-----------------------------------------------
/ / Shift operacji
/ /
/ / OP [3] OP [4] OP [5] | operacji
/ / 0 0 0 | NOP
/ / 1 0 0 | Shift Left (ASL)
/ / 0 1 0 | Arithmentic Shift Right (ASR.. Nowych)
/ / 1 1 0 | Logical Shift Right (LSR)
/ / 0 0 1 | Obróć w lewo (ROL)
/ / 1 0 1 | Obróć w prawo (ROR)
/ / 0 1 1 | NOP
/ / 1 1 1 | NOP
//-----------------------------------------------
zawsze @ (PO [5:3] lub AluNoShift lub C)
zacząć
przypadku (PO [5:3])
3'b000: zacząć
Y = AluNoShift; / / nie zmiana wyjścia
shiftout = 0;
koniec
3'b001: zacząć
Y = (AluNoShift [6:0], 1'b0); / / ASL
shiftout = AluNoShift [7];
koniec
3'b010: zacząć
Y = (AluNoShift [7], AluNoShift [7:1]); / / ASR
shiftout = AluNoShift [0];
koniec
3'b011: zacząć
Y = (1'b0, AluNoShift [7:1]); / / LSR
shiftout = AluNoShift [0];
koniec
3'b100: zacząć
Y = (AluNoShift [6:0], C);
shiftout = AluNoShift [7];
koniec
3'b101: zacząć
Y = (C, AluNoShift [7:1]); / / LSR
shiftout = AluNoShift [0];
koniec
3'b110: zacząć
Y = AluNoShift; / / nie zmiana wyjścia
shiftout = 0;
koniec
3'b111: zacząć
Y = AluNoShift; / / nie zmiana wyjścia
shiftout = 0;
koniec
domyślnie: zacząć
Y = 8'bx;
shiftout = 0;
koniec
endcase
koniec
//------------------------------------------------ -----------
/ / Wygeneruj stan bitów na stan rejestrów
/ /
//------------------------------------------------ -----------

zawsze @ (Y)
zacząć
if (! Y [0] &! Y [1] &! T [2] &! Y [3] &! T [4] &! Y [5] &! T [6] &! Y [7])
Zero = 1;
w przeciwnym razie
Zero = 0;
koniec

zawsze @ (Y [7])
Neg = Y [7];

//------------------------------------------------ -----------
/ / Carry Zarejestruj
/ / OP [6] OP [7] op [8] | operacji
/ / 0 0 0 | NOP
/ / 0 0 1 | Carry <- Adder / Sub Carry / Wypożycz
/ / 1 0 1 | Carry <- Shifter Out
/ / 0 1 1 | Carry <- 0
/ / 1 1 1 | Carry <- 1
//------------------------------------------------ -----------

Status CARRY1 (. CLK (CLK). zresetować (RESET). obciążenia (PO [8]). a (carryout). b (shiftout). c (1'b0). d (1'b1 ). sel (PO [7:6]). s (C));

//------------------------------------------------ -----------
/ / Overflow stan rejestru
/ / OP [9] op [10] op [11] | operacji
/ / 0 0 0 | NOP
/ / 0 0 1 | Overflow <- Adder / Sub Overflow
/ / 1 0 1 | Overflow <- zewnętrzne
/ / 0 1 1 | Overflow <- 0
/ / 1 1 1 | Overflow <- 1
//------------------------------------------------ -----------

Status OVF1 (. CLK (CLK). zresetować (RESET). obciążenia (PO [11]). a (OVF). b (T) [6]. c (1'b0). d ( 1'b1). sel (PO [10:9]). s (V));

//------------------------------------------------ -----------
/ / Zero Stan Zarejestruj
/ / Op [12] op [13] | operacji
/ / 0 0 | NOP
/ / 1 0 | zero <- Zero Input1
/ / 0 1 | Zero <- Zero Input2
/ / 1 1 | Zero <- 0
//------------------------------------------------ -----------

Status ZERO1 (. CLK (CLK). zresetować (RESET). ładunku (1'b1). A (z). b (zero). c (1'b1). d (1'b0) . sel (PO [13:12]). S (Z));

//------------------------------------------------ -----------
/ / Wykluczające Stan Zarejestruj
/ / Op [14] op [15] | operacji
/ / 0 0 | NOP
/ / 1 0 | Neg <- Neg Input1
/ / 0 1 | Neg <- Neg Input2
/ / 1 1 | Neg <- 0
//------------------------------------------------ -----------

Status NEG1 (. CLK (CLK). zresetować (RESET). ładunku (1'b1). a (N). b (Neg). c (1'b1). d (1'b0) . sel (PO [15:14]). s (N));

endmodule