常见面试笔试题verilog程序库
常见面试笔试题-vｅrilog程序库
————————————————————————————————作者：————————————————————————————————日期:
加减法
ｍｏdｕle addsuｂ
( input [7:0] dataa,
ｉｎｐut [7:0] datab,
inpｕt add_ｓub，/／if tｈiｓiｓ1, add; ｅlｓe subtract
input clk,
oｕｔput reg ［8：0] result );
ａｌｗays @ (posedｇe ｃlk)
bｅｇiｎ
if （add_sub) resulｔ<= ｄaｔaa + ｄａtab；//ｏr "assｉgn {cｏuｔ，suｍ}＝ｄataa＋datab；＂
elsｅresult <＝ｄａｔaａ- dａtab；
end
endmoｄule
四位的全加法器.
ｍoｄｕle add4(cout,ｓum，a,b，cｉn)
input[3:0]ａ,ｂ; inpｕt ciｎ;
ouｔput ［３:0] sｕm; ｏｕtpｕt ｃｏｕt;
ａssiｇｎ?｛ｃouｔ,sｕm}=ａ+b+cin;
endmoｄｕlｅ
补码不仅可以执行正值和负值转换，其实补码存在的意义，就是避免计算机去做减法的操作。
1101 -3 补
+ 1００0 8
01015
假设-3 + 8，只要将-3 转为补码形式，亦即０011 => 1101,然后和8，亦即１００0 相加
就会得到5,亦即01０1。至于溢出的最高位可以无视掉。
乘法器
ｍoｄulｅmulｔ(outcomｅ,a,b);
ｐarameter SIZＥ=8;
ｉnput［SＩZE：1] a,ｂ;
outpuｔreｇ[2*SＩZE:1] outcoｍe；
inteｇer i;
alwaｙｓ＠(ａor b）
ｂeｇｉn outcome＜=0;
for(i=0,i<=SIZE;i=ｉ+1)
if(ｂ［i]) outcome<=ouｔcome+（a<＜(i-1)）；
ｅｎd
endmodule
另一种乘法器。在初始化之际,取乘数和被乘数的正负关系,然后取被乘数和乘数的正值。输出结果根据正负关系取得。
else ｉｆ( Sｔart_Ｓｉｇ)
cａse( ｉ)
0: begｉｎ
isＮeｇ<= Multiplicaｎｄ[7］^ Multiｐlieｒ[7］;
Mcand <＝Muｌｔｉｐｌicand［7] ？( ～Muｌtiｐｌicand + 1'b1 ) : Ｍultｉplicanｄ;
Ｍeｒ<= Mｕltiｐliｅｒ[７] ? （~Ｍultｉpｌｉｅr + １'b1 ) : Mｕltiplier;
Ｔemp ＜= １6'd0;
ｉ<＝i + 1'b１;
ｅｎd
1: // Mulｔｉｐliｎg
iｆ( Mer ＝= ０) i <= ｉ＋1'b1;
elｓe begｉn Tｅmp ＜= Temp + Mcａnd; Mer <= Mｅｒ- 1'ｂ1; end
２：begiｎiｓDone <＝1'b1；i <= i + １'ｂ1; eｎｄ
3：begｉn isDonｅ<= 1＇b０; i <＝2'd0; end
enｄcase
assign Dｏne_Sig ＝isDoｎe;
assｉgn Prｏducｔ= ｉｓNeｇ? ( ~Temp + 1'b1 ) : Temp；
endmoｄule
boｏth乘法器
mｏdule ｂoｏｔh_ｍulｔiｐlieｒ_module
(
input CLK,
? input ＲＳＴn,
?ｉｎput Stａｒt_Sｉg,
? inpｕt ［７：0]A,
inpｕｔ［7:0］Ｂ,
ouｔｐut Doｎe_Sig,
ｏｕtpｕt [15:0]Ｐrｏｄuct,
?oｕｔpuｔ[7:0］SＱ_ａ,
output ［７:0］SQ＿s,
? outｐｕt [16:0]SQ＿p
);
reg [3:0］i;
? reg [７:0]a; ／/ resulｔｏf Ａ
? reg ［7:０]s; /／rｅverse reｓulｔof A
? reg ［１6:０]p；/／ｐ空间，1６＋１位
ｒeg [３:０]X;?/／指示ｎ次循环
? rｅg ｉsDone;
?always @ ( poｓedgｅCLＫor nｅgedｇｅＲSTn )
if( !ＲSTn )
begiｎ
???ｉ<＝4'd0;
???ａ<= 8'd0；
???s <＝8'd0;
??p <＝17'ｄ０;
???Ｘ＜= 4'ｄ０;
???isDone <＝１'ｂ0;
??eｎd
ｅlsｅiｆ（Starｔ_Siｇ)
?ｃaｓe（ｉ）
0:
?ｂegin ａ<= A; s ＜＝( ~A + 1'ｂ1 )；ｐ<= { ８'ｄ０, B , １'ｂ0 }; i <= i + 1'ｂ1；enｄ
1:
???iｆ( X ＝＝8 ) beｇin Ｘ<= 4'd0; ｉ＜= i ＋4'ｄ2; enｄ
??ｅlsｅif（p[1:０] == 2'b01 ) begin ｐ<= ｛p[16:9] + a , p[8:0] ｝；i <= i + 1'ｂ1; ｅnd
?else if( p[1:０] ＝= 2'b10 ）beｇｉn ｐ<= { p[１6:9] + s ，p[8:0］}; i <＝i + １'b1; end
???eｌｓｅi <= i + １'b1; ／/00和11,无操作
??2:
bｅgin p <= { ｐ[1６］, p[16:1] }; X <= X + １'b1; i <= i - 1'b1; eｎd /／右移,最高位补0 ｏr １．
??3：
??beｇin isDone <= 1'b1; ｉ<= ｉ＋1'b１；ｅnd
?４:
??begｉn iｓDoｎe ＜= 1'b0; i ＜= ４'d０；enｄ
endcａｓe
? assigｎDone_Sｉｇ= iｓDone;
ａssign Prodｕｃｔ= p[16：1］；
endmodule
除法器
ｍｏdulｅdｉviｄer_ｍoｄulｅ
(
inpｕt CLK，
input RＳTn,
inｐut Starｔ_Sig，
input [7：0］Dividenｄ,
ｉnput [7:0]Divisｏr,
outpuｔDｏnｅ_Siｇ,
oｕtput ［７:０]Quoｔieｎｔ，
output [7:0］Reｍindeｒ，
)；
ｒeｇ[3:0]ｉ;
rｅg [7:0]Ｄｅnｄ；
reg [7：0]Dsoｒ;
ｒeｇ[７:０]Q;
reｇ[７:0]R；
ｒｅｇisNｅg;
reg ｉsDone；
alwaｙs ＠( pｏsｅdge CＬＫｏr ｎegｅdge RSTn ）
if( ！RSTn )
ｂegin
i <= ４＇d0;
Dend <= ８＇d0;
Dｓor ＜= 8'd０;
Q <= 8'd0;
ｉsNeg <= 1'b0;
isDone <= 1'b0;
end
ｅlse if( Ｓｔart_Ｓig )
case( i )
0:
ｂeｇiｎ
Denｄ<= Diviｄｅｎd[7] ? ～Ｄiｖiｄenｄ+ 1'b1 : Dｉvidｅｎd;
Ｄｓor <＝Divisｏr[7] ? Diｖisor : ( ~Divisor ＋1＇b1 );
??ｉsNeg <＝Dｉviｄenｄ[7] ＾Ｄivisor[7];
i <= i + 1'ｂ1;
end
1: if( Ｄivisor > Ｄeｎｄ)
begiｎQ <= ｉsNeg ? ( ~Q + 1'b１）: Q; i <＝ｉ+ 1＇
b１; end
ｅlse beｇｉn Denｄ<= Dend + Dsoｒ；Q <
＝Q + １'b１；enｄ
2：begiｎisDoｎe ＜= １'b１；ｉ<= i ＋1＇b１; end 3: ｂｅgin ｉｓDｏne <= １＇b0; i ＜= 4'd0；ｅｎd
endｃase
assiｇｎDoｎe_Siｇ= ｉsDonｅ;
assigｎQuｏtient ＝Q;
ａssｉgｎRemｉnｄeｒ= Denｄ;
ｅｎdmoｄule
除法器2
moｄulｅｄiｖ(ａ,b,ｃlk，ｒesult，yu）
input［3:0］ａ,b；
oｕtｐuｔｒeｇ[3:0] ｒeｓult,ｙu;
ｉnput clk；rｅg[1:0］ｓｔａte;reg[3:0] ｍ,ｎ;
parameter S０=2'b00,S1=2'b01,S2=2＇b10；
aｌｗayｓ@(ｐoｓedge ｃlｋ)
beｇin ｃasｅ(stａte)
S0: begin iｆ(ａ>b) begｉｎn<=a－ｂ;m＜=4'ｂ0001; ｓtａte<＝S1；eｎd
ｅlse beｇin m<=4'b0０００;n＜=a; staｔe<=Ｓ2; end
end
S１: ｂegin ｉf(ｎ>=b) begｉn m<=m+１;n<＝n－ｂ;ｓｔate＜=S1;end
ｅlse bｅgｉn sｔate＜＝S２;end
ｅnｄ
Ｓ２：beｇiｎreｓuｌt<=m；yu<=n;sｔaｔe<=Ｓ0；end
dｅfｕle：ｓtate＜=Ｓ0；
endcasｅ
eｎｄ
ｅndmｏdule
1３、一个可预置初值的7进制循环计数器
①veriloｇ
mｏdule coｕnt（clk,ｒeseｔ,loａd，dａte,ｏut);
inpｕt load,clk,reset;
inpｕt[3:0] dａｔe；
output reg[3:0］out；
parameter WIDTH＝４＇d７;
always@（ｃｌｋｏr reset）
bｅgin
if（reseｔ) out<=4＇d0;
ｅlse if（ｌoａｄ）?oｕt<=date;
?elsｅif(out＝=WIＤTH-1) out<=4'd0;
elｓe ?out<＝out+1;
end
endmoｄulｅ
Johnsoｎ计数器
约翰逊(Ｊohnｓon)计数器又称扭环计数器,是一种用n位触发器来表示２ｎ个状态的计数器。它与环形计数器不同,后者用n位触发器仅可表示n个状态。n位二进制计数器(ｎ为触发器的个数)有２^n个状态。若以四位二进制计数器为例,它可表示１６个状态。
“0000-100０-１100-11１0－1１11-0１11-００11-00０1－0000-1０0０……”
module Johｎson(input clk,inｐut clｒ,outｐut ｒeｇ[Ｎ-1:0］q);
aｌwａys＠(ｐosedgｅclk ｏr negedｇe clr)
iｆ(!cｌr)?q＜=｛Ｎ{1’b0}}
eｌse if(!q[0］) q＜=｛1’ｂ1,q［Ｎ-1：１］｝;
else??q<={1’b０,ｑ[N-1]:1｝];
enｄmodule
任意分频,占空比不为50%
alwayｓ(clｋ)
?begin?if(count＝=x-1) count<=０;
??ｅlse?couｎｔ＜=count+1;?end
aｓsign ｃlｋｏut=ｃount[ｙ]?/／y一般用cｏunt的最高位
偶数分频(8分频，占空比50%）(计数至n-1，翻转)
ｍodｕｌe cｏunt５(ｒeset,ｃlｋ,out)
ｉnｐut cｌk,ｒesｅｔ; ｏｕtput out；
rｅg[1：0］cｏunｔ;
always@(clk）
if(reseｔ) begiｎｃount<=0; ouｔ<=0; end
else if(counｔ==3)?beｇｉn coｕnt<＝０;ｏut<=！ｏut: ｅｎd
else ｃoｕｎt＜＝ｃounｔ+1；
endｍodｕle
奇数分频电路(占空比5０%)。
module coｕｎt5（ｒesｅｔ,clk,out)
iｎｐut clk，reｓｅt；?oｕtput ｏｕt;
reg[２:0] ｍ,n；
reg coｕnt1;ｒeｇｃount2;
alwａys＠(ｐoｓedge clk)
begiｎ
?iｆ（rｅset) ?begiｎm<=０;cｏunt1<＝0；ｅnd
?elsｅ?ｂegin iｆ（m==4）m<=０; eｌse m<=ｍ+1; //“４”为分频数ＮUＭ-1，NUM=5
if(m＜2）count1<＝1; elsｅｃｏuｎt1<=０；?eｎｄ
enｄ
ａlways@（ｎｅgedgｅcｌk)
begｉn
if(reset) begiｎ?n<＝０;count2<=0;end
else begin?iｆ(ｎ＝＝4) ｎ＜=0; else n<=n+1;
if(ｎ<２）count2<=1；ｅlse count2<=0;?eｎd
end
ａssign out=couｎｔ1｜ｃount2;
半整数分频
moｄule fdiｖ5_5(clｋin,clr，clkout)
iｎpuｔclkin,clｒ；?ouｔｐuｔreg cｌkoｕt;
ｒeg clk1; ｗire clｋ2; ｉntegｅr counｔ;
xｏｒｘｏｒ１（clk２，clkin,clk1)
always＠(ｐosedgｅclｋout or neｇedgｅclｒ)
bｅgin?if(~clｒ) begin clｋ1＜＝１’b０; eｎd
elsｅclk1<=~clk1;
end
aｌwａys@(posedｇe clk2 or negedgｅclr)
begｉn?ｉf(～ｃlr）
begin count＜=0; clｋｏｕt<=1’b0; ｅnｄ
?ｅlｓｅif（cｏunt==5)
??bｅgin coｕnｔ＜=0; clkｏut<=1’b1; ｅｎd
?eｌsｅbegin count<=coｕnt+1; clkout＜=1’ｂ0; end
ｅnd
eｎｄmodule
小数分频
N＝M/P．N为分配比，Ｍ为分频器输入脉冲数，P为分频器输出脉冲数。
N=(8×9＋９×1)／(9+1）=8.１先做9次8分频再做1次9分频。
module ｆdiｖ８_1（ｃlkin，rst,clkoｕｔ)
iｎput clｋin,rsｔ; ｏutput rｅg ｃlkoｕt;
reg[３:0] ｃnｔ1，cｎt2；
alwａys@（pｏsedgｅclkｉｎoｒposedｇe rsｔ)
ｂegin if(rst) begin cｎt１<=0；cｎt2<=０;clkoｕt＜=０; ｅnd
eｌsｅiｆ(cnt１＜9) //cｎt1, 0~8 begin
if（cnt2＜7) begｉn ｃnt2＜＝cnt2＋1；clｋｏut<＝０; eｎｄ
else ｂegin cnt2<=0；cｎt1＜=ｃnt1＋1；cｌkout<=1；eｎd
ｅnd
elｓｅｂegin //cｎｔ1, 9
if(cnt２<8) begin cnｔ2<=cnt2+1;clｋｏut<＝0; end
eｌｓe ｂegin cnｔ2<=０；cnt1<＝０;clkout<=１;end
eｎd
enｄ
ｅndmoｄule
串并转换
moduｌe p2s(ｃlｋ，ｃｌr,load,pi,so)
inpuｔclk,clr,load;
ｉnｐuｔ［3:0] ｐi;
ｏuｔput sｏ;
ｒeg[3:0］r;
alwaｙs@(posedgｅclk or ｎｅgedgｅclｒ）
if（~ｃlr)?r＜=４'h0;
ｅlse ｉｆ（loａd) r<＝pi;
else ｒ<={r, 1'b0}; // ｏr r<<1;
assigｎso=r[3];
enｄmodｕlｅ
module s2p(clk,ｃlr,ｅn,si,po)
ｉnpuｔclk,ｃlｒ，en，si;
ouｔｐｕt[3：0] po;
alwayｓ@(posｅdge clk or ｎegedge ｃｌr)
iｆ（~ｃｌr)?r<=8’ｈo；
ｅlse r＜=｛r,ｓｉ｝；
ａｓsign po＝(eｎ) ？r ：4’h0;
endｍodｕlｅ
b) 试用VHDL或VERILOG、ABLE描述8位D触发器逻辑。module dｆf(q,qn，d,clｋ,ｓeｔ,ｒｅset)
input[7:0] d,set;
ｉｎput clk，ｒeset；
oｕtput reg[7:0] q，qn;
aｌｗays @(poｓedge clk）
ｂegin
if(reseｔ) begin?ｑ＜=8’h0０; qn＜=８’hＦF; end
ｅｌse if（seｔ) beｇｉn q＜=8’ｈFF; qn＜=8’h０0; enｄelｓe begｉn q＜=d; ｑn<=~d；ｅnd
end
ｅnｄmodｕlｅ
序列检测“101”
moｄuｌe ｘulｉe101(ｃｌk,clr,x,ｚ）;
input clk,clｒ,x;output reg z;
reg[1:0］staｔe,ｎext_stａｔe；
parameter s０=２'b０0,s1=2'ｂ０1,s2＝2'ｂ１1,ｓ３=２'ｂ1０;
alwａｙs @(ｐoseｄge clk or poｓedge clｒ)
beｇin iｆ（clr) sｔate＜＝s0；
ｅlsｅstate<＝next_ｓtate;
end
aｌｗays ＠(state or x）
begin
case（state)
s0:ｂegin iｆ(x)?ｎｅｘt_sｔate＜=s1；
?? else neｘt＿sｔａｔe<=s０;end
s1：beｇin if(x）?ｎｅｘｔ_ｓtate<＝s1；
?eｌse nｅxt_state＜=s２;end
?s2:ｂegin iｆ（x)?nｅxt_ｓtate<＝s3；
??else next_stａtｅ<＝s0;ｅnd
?s3：beｇｉｎｉf（x) next_ｓtate<=s1;
?elｓｅnｅxｔ_statｅ<=s2;ｅnd
?defauｌt: next_sｔａte<=s0;
endcaｓe
ｅnｄ
alwaｙs @(statｅ)
begin cａse(statｅ)
??ｓ3：z＝1;
?defａult：z=0;
?enｄｃaｓe
eｎｄ
endｍｏｄule
?
按键消抖
1.采用一个频率较低的时钟,对输入进行采样,消除抖动。
mｏdｕle swｉtｃh(clk，ｋｅｙiｎ，keyouｔ）
parameteｒCＯUNＴWIＤTH=8；
inpｕt cｌk,keyin; ｏuｔｐut ｒｅg keｙout; ｒeg[ＣOUＮTWIＤTH-1：0]counteｒ; wirｅclk＿usｅ; /／频率较低的时钟
assigｎclk_ｕｓe=coｕｎtｅr[ＣOUNTＷIDTH-1］;
always@(posegde clｋ)
cｏuntｅｒ<=coｕnｔer＋1’b1；
alwaｙｓ@(pｏsedge clk_use)
?keyout<=ｋeyiｎ;
endmoｄule
2.mｏdule switch(cｌk,keｙiｎ,keｙout)
parameter CＯUNTＷＩＤTH=8；
input ｃlk，keyin;?ｏutpuｔrｅgｋeyout；rｅg[COUNTＷIDTH-1：0]cｏunter; iniｔial ?counteｒ<=0，keyouｔ<＝0,keyin＜=0;
aｌwａｙs@(ｐosegｄe clｋ)
if(keyin=1)beｇin key_m<=ｋeyin, ｃounter<＝cｏunｔer+1;end
?else couｎter<＝０;
?if(ｋeyin&&ｃounｔer[m］) keyout<=1; //ｍ定义时延
endmodule
数码管显示
moｄｕlｅｎumber＿mod_module ??//分别取得数字的十位和个位
(ＣLK, RSTｎ, Nｕｍber_Data, Ten_Datａ, Ｏne_Ｄａta);
inｐｕｔCＬＫ;
ｉnput RSTn；
? iｎpuｔ[7:0]Numｂer_Data;
outpuｔ[3:0］Tｅｎ＿Dａta；
oｕtpuｔ[3:0]Ｏne_Ｄata;
?ｒeg [３１:０]rTeｎ;
?ｒeg [3１:0]rOne；
ａlｗays @ （pｏsedge CLＫoｒｎeｇeｄge RSTｎ)
if( ！RSTｎ)
bｅgin
???rＴeｎ<= 32'd0；
???rOne <= 3２'ｄ0;
?enｄ
?else
?begin
??rTｅn <= Ｎumbｅr_Data / 10;
??rＯne <= Numbｅr_Datａ％10;
?eｎｄ
?ａssign Ten＿Ｄaｔa ＝rＴｅn[3:０];
?ａssiｇn Onｅ_Data ＝rOｎe[３:0];
endmｏｄule
ｍodulｅled（ＣLK, Ten_Ｄata, One_Data,led0, leｄ１)；?//数码管显示ｉnpｕt [3:0] Ｔｅn_Data，One_Ｄaｔa；
?iｎpuｔCLＫ;
output ［7：0] lｅd0，leｄ1;
?reg [7:0］lｅｄ0, led1；
alwayｓ＠( posedgｅｃp_50)
ｂegｉn
???caｓez （One_Dａｔa）
??4'd0 : led０= 8'ｂ1100_0000;
???4'd1 : ｌed0 = 8'b111１_１０01;
?４＇ｄ２: led0 ＝8＇b1０10_０100;
??４'d3 : ｌed0 ＝8'ｂ１01１_０００0;
???4'd4 : lｅｄ0 = 8'b1０01_1０01;
???４'ｄ5 : led0 = 8＇b10０1＿00１0;
?????４'d６: led0 = 8'b100０_0010；
???4＇d7 ：ｌｅd0 ＝8'b１11１_1００0;
??4'ｄ8 : led0 = 8'ｂ１0０0_0000;
???4＇ｄ９：led０= ８＇b1001_００0０;?
????ｄｅｆａｕlt: led0 = 8'b１１1１＿1111; ?
?enｄcaｓe
???caｓez (Ten_Ｄatａ)
????4'ｄ0 ：ｌed１＝8'b1１0０_０000;
???4'ｄ1 : lｅd1 = 8'b１1１1＿10０１;
??４'d2 : led１＝８'b10１0_０10０;
???４'d3 ：led1 = ８＇b1０１1_000０;
?4＇ｄ4 : led1 = 8＇b１0０１_1001;
???4'd5 ：ｌeｄ1 = ８＇b1００1＿0０10;
????4'd6 : led１= 8'b1０00_0010;
?４'d7 : led1 ＝8'b１11１＿1000;
?４'d8 : led1 = 8'ｂ１000＿0０0０;
????４'d９: ｌed1 = 8'b1001_0０00;?
????defaulｔ: lｅd０= 8'b1111_１111; ??
?eｎdcase
??enｄ
endmoｄuｌe
５. fifｏ控制器.
FIFＯ存储器ＦＩＦO是英文Ｆirst In Ｆiｒst Ｏut 的缩写,是一种先进先出的数据缓存器,他与普通存储器的区别是没有外部读写地址线，这样使用起来非常简单,但缺点就是只能顺序写入数据,顺序的读出数据，其数据地址由内部读写指针自动加1完成，不能像普通存储器那样可以由地址线决定读取或写入某个指定的地址。在系统设计中,以增加数据传输率、处理大量数据流、匹配具有不同传输率的系统为目的而广泛使用FIＦO存储器,从而提高了系统性能.
FIＦO参数:
FＩＦO的宽度，ｔｈｅwidｔh，指ＦIFO一次读写操作的数据位;
FIＦO深度，TＨE DEEPTH，指ＦIＦO可以存储多少个Ｎ位的数据;
满标志,ＦＩFＯ已满或将要满时送出的一个信号,以阻止FIFＯ的血操作继续向FＩFO中写数据而造成溢出(oｖeｒｆlow);
空标志,阻止FIFIO的读操作;
mｏdｕｌe fｉfo_mｏduｌe
(
inpｕt CLＫ,
inｐｕt RSＴｎ,
input Wriｔe_Rｅq,
inpｕt [7：０]FIFO_Write_Data，
ｉnｐuｔRead_Ｒｅq,
outpｕｔ［７:0]FＩFＯ_Ｒead_Ｄaｔa，
output Full＿Sｉｇ,
oｕtput Empty_Ｓiｇ，
/********＊＊**＊＊＊＊**＊***/
output ［7:0]ＳＱ_rS1,
ｏutpuｔ[７:0］SQ_ｒＳ2,
ｏutput [７:０]SQ_rS3,
ｏutpｕt ［７:0］ＳQ＿rＳ4,
oｕtput ［2:0］SQ＿Count
／********＊＊*＊***＊****＊＊／
);
/****＊***＊***********＊**************＊/
parameｔｅr DEEＰ＝３＇d4;
/***＊*********＊*＊＊＊＊****＊************/
rｅg [７:0]rShift ［DＥEP:０];
ｒeg [2：0］Count;
reg [7:０]Data;
ａlways @ ( poｓedｇe ＣLＫor neｇedge ＲSTｎ)
if( !RＳTn )
ｂegin
ｒShｉft[0] ＜= 8＇ｄ0; rSｈift[1］＜= 8'd0; ｒSｈift［2] ＜＝8'ｄ0；
rSｈｉfｔ[３］<= 8'd０; rSｈifｔ[４] <= 8'd0;
Coｕnt <＝3'd0;
Ｄａｔa <＝8＇d0;
ｅnd
elsｅif( Read_Req && Ｗrite＿Reｑ＆＆Count ＜DEEP && Cｏunt > 0 ) ｂｅgin
rSｈｉft[１] ＜= FＩFO_Wｒite＿Data;
rShift[2] <= ｒＳhifｔ［1];
ｒSｈift[3] <= rＳhiｆt[2];
rShift[４] <＝rShiｆt[3]；
Data <= rＳｈｉft[ Cｏuｎｔ]；
end
else ｉf( Write_Req &＆Couｎt < DEＥP ）
begin
rShｉft[1] <= FIＦO_Write_Data；
rShift[2］<= rSｈiｆt[1];
rShift[３] ＜= rShｉft[２];
rShift[4] <= rSｈｉｆt[3]；
Count <= Cｏｕnｔ＋1'b1;
ｅnｄ
else if( Rｅad＿Req ＆＆Cｏunｔ＞０）
begin
Ｄata <= ｒShifｔ[Count];
Couｎt <= Count - 1'b１;
end
/＊*＊****＊**＊***＊＊****＊＊**＊***＊＊******/
ａｓsｉｇn FＩFO_Read＿Datａ= Data;
aｓsign Fｕlｌ_Sig = （Ｃouｎt == DEEP ) ？1'b1 : 1'b0;
ａssiｇｎEｍpｔy_Siｇ= （Ｃｏｕnｔ== 0 ）? 1＇b1 : 1＇b0;
／***＊**＊＊＊***＊********＊＊＊******＊*****／
assiｇn SＱ_ｒS１= ｒＳhift[1];
ａｓsign SQ_rS2 = ｒShift[2]；
ａssigｎＳQ_ｒS３= rShiｆt[3］;
assign SＱ_rS4 = rShift[４];
ａssｉｇn SQ_Cｏｕnt ＝Counｔ；
/＊**＊*****＊**＊***＊＊******＊*******＊**＊/
Ｅｎdmodule
fifｉ2 (指针控制)
ｍodｕｌe FIＦO（date，q,clr，clk，wｅ,rｅ,ff，ef）;
parameter WIDTH=8,DEEPＴH＝８,ADDR＝３;
ｉnpｕｔcｌk,clr;
iｎｐｕt we，re;
inｐuｔ［WＩＤTＨ－1:0] date;
ouｔpuｔｆf,ef;
output ｒeｇ［WＩDTH-1：0] q；
ｒeｇ[WＩDTH-1:0] mem＿daｔｅ[ＤEEPTH-1:0];
reｇ[ADDＲ－1:0] waddｒ,raddr; ｒeg ff,eｆ;
alwaｙｓ＠(posｅdge ｃlｋor negedgｅclr) ／／写地址
begin ｉｆ（！ｃｌr) wａddr=0;
?else iｆ(we==1&＆ff＝=0) ｗａｄdr=waddr+１;
?ｅlsｅif(we==1&＆ff＝=0&&waｄdr==7) waddr=0；
end
ａlwayｓ＠(posｅdge clk)
bｅｇin iｆ(ｗe&&!fｆ) mｅm_dａｔe[wａddｒ]=daｔｅ; enｄ
alwayｓ@（poｓｅdgｅcｌk or negedge cｌr)?／/读地址
bｅgin if（！cｌr）ｒａddr=0;
?elsｅif(re＝=1&＆ｅf==0) radｄr=ｗaddr+1;
??ｅｌｓｅｉf(re==1&&ｅf＝=0&&raddr==７）rａdｄr=0；
ｅnｄ
alwａys@（posｅｄge clk)
begin iｆ（re&&!ef) q＝ｍem_ｄate[raddr]；?ｅｎd
aｌways＠(ｐｏseｄgｅclk or nｅｇedgｅclr)
bｅgin iｆ（!cｌr) ｆf=１'b0;
??else if((we & !re) && （（waddr==rａddｒ-1) || （(ｗaddr==DEＥＰＴＨ-1) &＆(raｄdr=＝1'b0）)))
??ff=1'ｂ1；
?else ｆf=1'b0;
end
alwａys@(posedｇe clk or ｎegedge cｌｒ)
ｂｅｇiｎif(！clr）ｅf=１'b0；
?ｅlse if(((!ｗｅ＆re）&&(ｗadｄr＝=raddｒ+1)||((rａddr==DEEPTH－1）&＆(wadｄｒ==１'b0))）)
?ef＝１'b1;
?else ef＝1'b0;
ｅnｄ
ｅｎdmｏduｌe
交通信号灯
ｍoｄule ｊiaｏtong(clk，reset,lamp,downtｉme）;
inpｕｔcｌk,resｅt;
oｕtput reg ［５:0]lａmｐ;
oｕtｐut[６:0]doｗntimｅ;
ｒeg [６：０]timedｏwn；
reｇ[1:0]state;
ｒeg ［31:0]count１;
alｗays@(ｃlk）/／产生0~１00ｓ的计时
begin
if(ｒeset) counｔ1<＝0；/／计数器必须赋初值,否者无法进行计数
eｌsｅif(cｏｕnｔ1=＝３２＇d１0０) counｔ１<＝0;
eｌse count1<=counｔ1+1;
enｄ
ａlｗayｓ@(clｋor ｃount1)
beｇin
if(rｅｓｅt) state<=0；
elｓe if(counｔ1>=32'ｄ1＆&coｕnｔ1＜=32'ｄ45）state＝0;
ｅlｓe if(cｏuｎt1>=32'd4６&&counｔ1<=３２'d50) state＝1;
ｅlｓe iｆ(ｃount1>=32'd５1&&count1<=32'd95) ｓtate=2；
elsｅif(count1＞=3２'ｄ９6＆&ｃｏunt1<=32'd１００) sｔate=3;
ｅnd
alwａys@（clk)
bｅgin
caｓe(ｓtate）//state只能在一个过程快内被赋值，所以其复位操作放在前一个aｌwayｓ块中
0：bｅgiｎｌamp＜=６'b１0０001；timedｏwｎ<=＇d４5－coｕnt1;ｅnｄ
1：begin lamp<=6'b０10０01；ｔｉmedown<='d5０-cｏunt1;end
２:bｅgｉn lamp<＝6＇ｂ0０1100; timedown<='ｄ9５－cｏｕnt1;ｅnd
3:begiｎｌaｍp<＝6'ｂ0０1010; timedｏwn<＝＇ｄ1０0-couｎt1;enｄ
endｃase
eｎｄ
assign ｄownｔime=timedown；
endｍodule
仿真激励：
`ｔimescale １ms/1ｍs
｀ｉｎclude "jiａoｔong.v"
moｄule jｉaotong_tｐ;
reg cｌk; ｒeｇｒeｓet;
ｗire [５:０]lamp;
wire [6：0］downtimｅ; //输出需用wｉre型
jｉaotｏng u1(
.clk(clk),
.reｓet(reset),
.lａmｐ(laｍp）,
．downｔiｍe（dｏｗntｉｍｅ)
);
initial
ｂｅgin
cｌk=0; reset=0;
#５０0 ｒeset=1；
#500 reset＝0; ／/需统一放入begin-enｄ块中
ｅnd
ａｌwａｙs #500 clk＝~cｌk；
iｎitｉal ＄mｏｎitor($time,,,"clk＝%ｂcoｕnt1=%ｄ"，clk,couｎt1); //只是在调试过程中监控count1的计数状态
enｄmoduｌe