Ministerul Educaţiei si Tineretului al R.

Moldova
Universitatea Tehnica a Moldovei
Catedra Materiale şi Dispozitive Semiconductoare

PROIECT de curs
Sisteme Electronice Programabile

TEMA: Proiectarea unui procesor în

limbajul Verilog

A efectuat: st. Gr. ME-071

Banaru Alexandru

A verificat: Lector superior

Bragarenco Andrei
 *Chişinău 2010*

Cuprins:
Introducere..............................................................................3
2 . Date teoretice.....................................................................3
2.1. Procesorul Elementar......................................................3
2.2. Modulul CROM..............................................................4
2.3.Modulul RALU.................................................................5
3. Proiectare şi implementare................................................6
3.1. Parametrii..................................................................6
3.2. RALU..........................................................................7
3.3. CROM........................................................................8
3.4. Procesorul..................................................................10
3.5. Modulul de testare....................................................10
3.6. Prorgamul de test a procesorului............................11
4. Rezultatele experimentale.................................................12
Concluzii.................................................................................12

2
 Introducere
În prezent dezvoltarea tehnico-ştiinţifică se bazează pe progresele
electronicii digitale de calcul şi procesare a datelor şi mai mult decît atît, e
necesară din ce în ce mai multă performanţă în acest . Elaborarea unui nou
procesor fără unelte performante ar fi foarte anevoioasă, din acest motiv, în anul
1985, a fost elaborat limbajul descriptiv Verilog, ce permite descrierea
comportamentului şi/sau arhitecturii unui sistem numeric.
În acest program urmează să proiectăm un procesor şi să-l simulăm.

2 . Date teoretice
2.1. Procesorul Elementar
Definiţii de bază :
Un procesor este un SO-3 la care unul din automate este de tip RALU iar
celălalt îndeplineşte funcţia de automat de control.
Un procesor elementar, PE, este un procesor al cărui automat de control este
strict iniţial
Vom numi microinstrucţiuni elementele produsului Y x Q ale unui automat
de control
Un procesor elementar va fi format, conform definiţiilor anterioare, dintr-un
circuit de tip RALU şi un automat de control strict iniţial CROM. Acest procesor se va
iniţializa prin resetare şi va executa o singură funcţie, cea definită de secvenţa de
comandă pentru care a fost proiectat automatul de control. Altfel spus, PE este
procesorul cu o singură instrucţiune pe care o interpretează continuu.

Figura 1 .Procesor Elementar

Fie PE din figura 1, format din CR0M, în calitate de automat de control, definit de
următorul format al microinstrucţiunii pe care o generează:
<microinstructiune>::= <com. ralu> <com. i/o> <mod>
<test> <jump>
<com. i/o>::= READ | WRITE | -
<Mod>::= JMP | CJMP | -
<Test>::= CR | WAITJR. | WAIT.W | -
<Jump>::= <o eticheta formata dintr-un sir, nefolosit ca mnemonica, de cel mult 6
caractere>
şi RALU1 definit prin următoarea structură a comenzii:
3
<com.ralu>::= <Left> <Right> <Dest> <Sel> <Func> <Write>
<Left::= L0 | L1 | L2 | - ,
<Right>::= R0 | Rl | R2 | - ,
<Dest>::= DO | Dl | D2 | - ,
<Sel>::= DIN |- ,
<Func>::= XOR | NOT | ADD | LEFT | SHR,
<Write>::= W | -
CROM comandă în exteriorul PE1, citirea unor configuraţii binare prin ieşirea
READ, scrierea prin WRITE. Va recepţiona, în consecinţă indicatorii WAIT_R şi
WAIT.W prin care este sincronizată recepţia pe intrarea DIN şi emiterea pe ieşirea
DOUT. Indicatorul CR este recepţionat pe buclă de la ieşirea ALU din RALUl.
CROM posedă şi o intrare sincronă de reset, RST, prin acţiunea căreia se
iniţializează pentru generarea primei microinstructiuni din secvenţa pentru care a
fost proiectat. Comanda implicită în câmpul <Mod> este INC.
Procesorul elementar PE1 definit prin interconectarea celor două automate (RALU
ŞI CROM) va putea folosi următorul limbaj de microprogramare:
<microinstructiune>::= <com. ralu> <com. i/o> <mod>
<test> <jump>
<com.ralu>::= <Left> <Right> <Dest> <Sel> <Func> <Write>
<Left>::= L0 | L1 | L2 | - ,
<Right>::= R0 | Rl | R2 | - ,
<Dest>::= DO | Dl | D2 | - ,
<Sel>::= DIN | - ,
<Func>::= XOR | NOT | ADD | LEFT | SHR,
<Write>::= W | - .
<com. i/o>::= READ | WRITE | -
<Mod>::= INC | JMP | CJMP
<Test>::= CR | WAIT„R | WAIT_W | -
<Jump>::= <o eticheta formata dintr-un sir, nefolosit ca
mnemonica, de cel mult 6 caractere>.

2.2. Modulul CROM

CROM-ul este un automat de control tip Moore imediat în componenţa
căruia este şi un ROM pentru stocarea comenzilor CROM-ului.
Structura CROM-ului este următoarea:
Circuitul INC este un circuit de incrementare combinaţional care ne pune în
fiecare ciclu de ceas la dispoziţie valoarea incrementată a stării curente. Dacă pe
intrările de selecţie ale MUX se aplică S1 S0 = 00, atunci starea următoare a
autoamtului de control va fi obţinută prin incrementarea celei curente.Registrul
împreună cu circuitul de incrementare formează un numărător sincron.
Circuitul TC este un foarte modest circuit combinaţional folosit pentru
transcodificarea câmpului MOD în funcţie de valoarea bitului testat, T, selectat de
mul-tiplexorul de test, MUXT. Tabelul de mai jos descrie funcţia realizată de acest
circuit.Câmpul MOD este codificat prin biţii Ml, MO, iar ieşirea TC generează cei
doi biţii de selecţie pentru MUX. Câmpul MOD va specifica cele patru moduri de
tranziţie ale CROM-ului:

4
INC : starea următoare a CROM se obţine prin incrementare

Figura 4. Structura CROM-ului

JMP : starea următoare a CROM este dată de câmpul JUMP prin selectarea intrării 1
a MUX de către ieşire TC

Figura 5. Tabelul de adevăr al circuitului transcodor .

CJMP : starea următoare depinde de valoarea intrării selectate, prin codul TEST
sub denumirea de T, la intrarea TC:
 dacă testul nu este îndeplinit, T = 0, atunci tranziţia are loc prin incre-
mentare pentru că ieşirile TC iau valoarea 00
 dacă testul este îndeplinit, T = 1, atunci tranziţia are loc prin saltui la adresa
dată de câmpul JUMP, selectat prin valoarea 01 de la ieşirea TC
INIT : starea următoare este dată de codul de iniţializare prezent pe intrarea X1,
conec-tată la intrările 2 şi 3 ale MUX.
2.3.Modulul RALU
Una din aplicaţiile cele mai spectaculoase ale conceptului de AS3 este legată
de realizarea unui automat funcţional utilizat ca o componentă centrală a structurii
uzuale de procesor. Arhitectura oricărui procesor este centrată pe o serie de funcţii
Iogico-aritmetice, aplicabile unui set de registre ce formează starea internă a
procesorului în cauză. Pentru a realiza o astfel de arhitectură este necesară o unitate
de tip ALU prin care să poată fi prelucrat conţinutul registrelor. Este vorba de
unitatea RALU (Registers with Arithmetic and Logic Unii).

5
 Figura 6.O variantă simplă de RALU
RAM : reprezintă memoria de registre cu trei porturi:
e portul de citire adresat prin câmpul Left, ce furnizează operandul stâng, LO, al
ALU
portul de citire adresat prin câmpul Right, ce furnizează operandul drept,
RO, al ALU (şi AOUT, adresa de ieşire pentru memoria externă)
portul de scriere adresat prin câmpul Deşt, activat de valoarea W a câmpului
Write
MUX : reprezintă n MUXE folosite pentru selectarea operandului L la intrarea
ALU; permite accesul unor valori din exterior, recepţionate pe intrarea DIN
ALU : este unitatea logico-aritmetică comandată de câmpui Func; generează pe
lângă rezultatul operaţiei, ce se stochează temporar în LM, şi o serie de indicatori ce
car-acterizează rezultatul operaţiei curente (Ind= {CR, OVFL, SGN, ODD, ZERO})
ML : este latch-ul master, transparent pe primul palier al ceasului, cel ce urmează
fron-tului activ.
Pe primul palier al ceasului RALU recepţionează toate câmpurile care-i deter-mină
funcţionarea, fapt ce-i permite să ofere la intrarea ALU doi operanzi. Rezultatul de
la ieşirea ALU se înscrie în LM.
Pe cel de al doilea palier al impulsului de ceas, ML se închide memorând rezul-tatul
operaţiei din ciclul de ceas curent, iar dacă Write ia valoarea W conţinutul latch-ului
LM se va înscrie în memoria de registre la locaţia selectată prin Deşt.
Comanda primită de o astfel de unitate de prelucrare poate fi descrisă prin linii de
comandă definite în funcţie de structura internă a memoriei şi de operaţiile executabile
în ALU. Vom da o definiţie a liniei de comandă în cazul particular pe care-l vom
folosi în exemplele ce urmează

3. Proiectare şi implementare
3.1. Parametrii
Pentru a face proiectul mai clar şi mai simplu de înţeles, am decis să-l proeictez
pe module aparte, astfel voi avea un modul RALU şi un modul CROM, pe care le
voi uni într-un singur modul PROCESOR. Pentru o flexibilitate mai mare, am
parametrizat majoritatea valorilor utilizate, astfel la efectuarea modificărilor
ulterioare, şansele de a efectua o greşeală e mult mai mică. Toţi parametrii se conţin
într-un fişier aparte, şi se includ în modulele RALU şi CROM prin comanda
`include "parameter.vh"
Conţinutul fişierului este:
//biti rezervati pentru adresele parameter sub = 4'd2;
registrilor parameter inc = 4'd3;
parameter ralu_reg_adr = 4; parameter dec = 4'd4;
//numarul de stari posibile ale RALU parameter shl = 4'd5;
parameter state_nr = 5; parameter shr = 4'd6;
parameter rol = 4'd7;
//operatiile pe care le poate efectua parameter ror = 4'd8;
RALU-ul parameter AND = 4'd9;
parameter nop = 4'd0; parameter OR = 4'd10;
parameter add = 4'd1; parameter XOR = 4'd11;

6
 parameter NOT = 4'd12; parameter R13 = 4'd13;
parameter com = 4'd13; parameter R14 = 4'd14;
parameter LEFT = 4'd14; parameter R15 = 4'd15;
parameter RIGHT = 4'd15;
//Definirea elementelor
//modul de incrementare a PC microinstructiunii
parameter mode_inc = 2'b00; parameter select = 1'd1;
parameter mode_jmp = 2'b01; parameter no_sel = 1'd0;
parameter mode_cjmp = 2'b10;
parameter mode_init = 2'b1x; parameter wr = 1'd1;
parameter no_wr = 1'd0;
//Definirea registrilor de uz general
parameter R0 = 4'd0; //Definiea bitilor de control
parameter R1 = 4'd1; parameter no_test = 3'dx;
parameter R2 = 4'd2; parameter carry = 3'd0;
parameter R3 = 4'd3; parameter zero = 3'd1;
parameter R4 = 4'd4; parameter equal = 3'd2;
parameter R5 = 4'd5; parameter sign = 3'd3;
parameter R6 = 4'd6; parameter pare = 3'd4;
parameter R7 = 4'd7;
parameter R8 = 4'd8; //Etichete
parameter R9 = 4'd9; parameter no_label = 8'bx;
parameter R10 = 4'd10; parameter label_0 = 8'b0;
parameter R11 = 4'd11; parameter label_1 = 8'd5;
parameter R12 = 4'd12; parameter label_2 = 8'd2;

3.2. RALU
Pentru descrierea RALU am utilizat toate metode de descrirere studiate la acest curs, și, pe
care le oferă Verilog, şi anume:
 Discriptivă
 Flux de date
 Comportamentală.
module RALU (LA, RA, DA, Func, sel, w, Din, Dout,state, ck, rst);

`include "parameter.vh"
//############### Dfinirea intrarilor si iesirilor ###############
input [ralu_reg_adr-1:0] LA, RA, DA;
input [3:0] Func;
input [7:0] Din;
input sel, w, ck, rst;
output [7:0] Dout ;
output [7:0] state;
//############### Definirea registrilor ###############
reg [7:0] RAM[7:0];
reg C;
wire [7:0]Ro = (sel)?Din:RAM[RA];
wire [7:0]Lo = RAM[LA];
reg [7:0] Dout;
initial Dout = 0;
//############### Initailizarea registrilor ###############
initial
begin
RAM[0] = 8'd0;
RAM[1] = 8'd0;

7
 RAM[2] = 8'd0;
RAM[3] = 8'd0;
RAM[4] = 8'd0;
RAM[5] = 8'd0;
RAM[6] = 8'd0;
RAM[7] = 8'd0;
end
//############### Definirea starilor ALU ###############
assign state[pare] = Dout[0];
assign state[sign] = Dout[7];
assign state[equal] = (Lo==Ro);
assign state[zero] = (Dout==0);
assign state[carry] = C;
//############### Definirea isntructiunii de scriere in registri###############
always @(posedge ck)
if (w) RAM[DA] = Dout;
//###############Definirea operatiilor ALU###############
always @(Lo or Ro or Din or Func)
begin
C=1'b0;
case (Func)
sub: {C,Dout} = Lo-Ro;
inc: {C,Dout} = Lo+1;
dec: {C,Dout} = Lo-1;
shl: {C,Dout} = {Lo,1'b0};
shr: {Dout,C} = {1'b0,Lo};
rol: Dout = {Lo[size-2:0],Lo[7]};
ror: Dout = {Lo[0],Lo[7:1]};
AND: Dout = Lo & Ro;
OR: Dout = Lo | Ro;
XOR: Dout = Lo ^ Ro;
NOT: Dout = ~Lo;
com: Dout = 1'd0-Lo;
LEFT: Dout = Lo;
RIGHT: Dout = Ro;
add: {C,Dout} = Lo+Ro;
default Dout = 0;
endcase
end
endmodule
3.3. CROM
module CROM(init_ADDR, STATE_in, cmdout, CK, RST);// antetul programului
`include "parameter.vh"
//############### Initializarea porturilor ###############
input [7:0] init_ADDR;
input [state_nr-1:0] STATE_in;
output [17:0] cmdout;
input CK, RST;
// declararea parametrilor
//############### Descriem ROM ###############
reg [30:0] ROM[0:255];
initial // blocul de initializare si definire a programului

8
 begin
// adrress <LeftAdress> <RightAdress> <Data> <Functia> <select> <Write enable> ||
<test> <mod> <next>
// În R1 introducem datele de la Din
ROM[0] = {R0, R1, R1, RIGHT, select, wr, no_test, mode_inc, no_label};
// In R2 introducem R1
ROM[1] = {R0, R1, R2, RIGHT, no_sel, wr, no_test, mode_inc, no_label};
// R2--; if (R1 ==0 ) jump to adress 0x05
ROM[2] = {R1, R1, R1, dec, no_sel, wr, zero, mode_cjmp, 8'd5};
// R4 <- R3 + Din, if (Carry == 1) jump to adress 0x02
ROM[3] = {R4, R3, R4, add, select, wr, carry, mode_cjmp, 8'd2};
// R5++, jump, salt la adresa 0x02
ROM[4] = {R5, R5, R5, inc, no_sel, wr, no_test, mode_jmp, 8'd2};
// NOP, ramii la pozitia data, permanent
ROM[5] = {R4, R4, R4, nop, no_sel, no_wr, no_test, mode_jmp, 8'd6};
end
//############### Definirea firelor si registrului contorului de program ###############
reg [7:0] PC;
wire [2:0] test;
wire [1:0] mod;
wire [7:0] next;
//############### Impartirea comezii pe parti componente ###############
assign {cmdout, test, mod, next} = ROM[PC];
//############### Definirea bitului de test ###############
reg T;
//############### blocul comportamental ###############
always @(STATE_in or test)
case (test)
3'b000 : T = STATE_in[0];
3'b001 : T = STATE_in[1];
3'b010 : T = STATE_in[2];
3'b011 : T = STATE_in[3];
3'b100 : T = STATE_in[4];
endcase
//############### Definirea modulului de incrementare ###############
reg S;
always @(T or mod)
if(mod==2'b10) S={1'b0,T};
else S=mod;
//############### Definirea comportamenutului program counterului ###############
always @(negedge(CK) or negedge (RST))
if(RST) PC=init_ADDR;
else case (S)
2'b00: PC=PC+2'b01;
2'b01: PC=next;
default: PC=init_ADDR;
endcase
endmodule

3.4. Procesorul
9
 Avînd la dispoziţie modulele CROM şi RALU, definrea proceosrului ocupă
nu mai mult de cîteva rînduri
module procesor(Din, Dout, ck, rst);
input [7:0] Din;
output [7:0] Dout;
input ck, rst;
wire [17:0] cmd;
wire [state_nr-1:0] state;
wire [3:0] LA;
wire [3:0] RA ;
wire [3:0] DA;
wire [3:0] func;
wire sel;
wire w;
assign {LA, RA, DA, func, sel, w} = cmd;
CROM crom(8'd0, state, cmd,ck, rst);
RALU ralu(LA, RA, DA, func, sel, w, Din, Dout, state, ck, rst);
endmodule
3.5. Modulul de testare
module test_procesor;
reg rst, ck;
reg [7:0] Din;
wire [7:0] Dout;
initial
begin
rst=1;
#10 rst=0;
end
initial
ck = 1;
always
#10 ck = ck;
initial
begin
Din = 8'd5;
end
procesor DUT(Din, Dout, ck, rst);
always
begin
$display("din= %b dout=%b ck=%b rst=%d ", Din, Dout, ck, rst);
#20 ;
end
always @(negedge ck)
Din = $random;
endmodule

3.6. Prorgamul de test a procesorului

10
 Pentru a testa procesorul, l-am programat iniţial cu 6 instrucţiuni, care fiind
executate, permit de a calcula suma datelor de intrare.
Schema bloc a programului este:

4. Rezultatele experimentale

11
 5. Concluzii
În urma efectuării acestei lucrări de laborator, m-am familiarizat cu metodele
de proiectare și modelare a unui procesor elementar care execută şi interpreteză
comenzile scrise în ROM-ul CROM-ului. Deci schimbarea funcţiilor procesorului
înseamnă schimbarea microprogramului din ROM.Configuraţia random de biţi din
ROM-ul CROM-ului este cea care defineşte funcţioal sistemul. Structura fizică
simplă a maşinii este folosită pentru a executa structura simbolocă complexă
"stocată" în ROM.

12