有代码基于libero的数字逻辑设计仿真及验证实验48Word文件下载.docx

有代码基于libero的数字逻辑设计仿真及验证实验48Word文件下载.docx

《有代码基于libero的数字逻辑设计仿真及验证实验48Word文件下载.docx》由会员分享，可在线阅读，更多相关《有代码基于libero的数字逻辑设计仿真及验证实验48Word文件下载.docx（64页珍藏版）》请在冰豆网上搜索。

reg[4:

1]a,b;

wire[4:

1]y;

HC00u1（a,b,y）;

initial

begin

a=4'

b0000;

b=4'

b0001;

#10b=b<

<

1;

b1111;

end

//74HC02代码-或非

//HC02.v

moduleHC02（A,B,Y）;

assignY=~（A|B）;

//74HC02测试平台代码

moduletest2（）;

HC02u2（a,b,y）;

//74HC04代码-非

//HC04.v

moduleHC04（A,Y）;

input[6:

1]A;

output[6:

assignY=~A;

//74HC04测试平台代码

moduletest3（）;

reg[6:

1]a;

wire[6:

HC04u3（a,y）;

b000001;

#10a=a<

//74HC08代码-与

//HC08.v

moduleHC08（A,B,Y）;

assignY=A&

B;

//74HC08测试平台代码

moduletest4（）;

HC08u4（a,b,y）;

//74HC32代码-或

//HC32.v

moduleHC32（A,B,Y）;

assignY=A|B;

//74HC32测试平台代码

moduletest5（）;

HC32u5（a,b,y）;

//74HC86代码-异或

//HC86.v

moduleHC86（A,B,Y）;

assignY=A^B;

//74HC86测试平台代码

moduletest6（）;

HC86u6（a,b,y）;

2、第一次仿真结果（任选一个门，请注明，插入截图，下同）。

（将波形窗口背景设为白色，调整窗口至合适大小，使波形能完整显示，对窗口截图。

后面实验中的仿真使用相同方法处理）

异或门：

3、综合结果。

（将相关窗口调至合适大小，使RTL图能完整显示，对窗口截图，后面实验中的综合使用相同方法处理）

4、第二次仿真结果（综合后）。

回答输出信号是否有延迟，延迟时间约为多少？

输出信号有延迟，延迟时间为300ps。

5、第三次仿真结果（布局布线后）。

分析是否有出现竞争冒险。

输出信号有延迟，延迟时间是4200ps。

没有出现竞争冒险。

2、组合逻辑电路

1、了解基于Verilog的组合逻辑电路的设计及其验证。

3、学习针对实际组合逻辑电路芯片74HC148、74HC138、74HC153、74HC85、74HC283、74HC4511进行VerilogHDL设计的方法。

2、进行针对74系列基本组合逻辑电路的设计，并完成相应的仿真实验。

3、参考教材中相应章节的设计代码、测试平台代码（可自行编程），完成74HC148、74HC138、74HC153、74HC85、74HC283、74HC4511相应的设计、综合及仿真。

4、74HC85测试平台的测试数据要求：

进行比较的A、B两数，分别为本人学号的末两位，如“89”，则A数为“1000”，B数为“1001”。

若两数相等，需考虑级联输入（级联输入的各种取值情况均需包括）；

若两数不等，则需增加一对取值情况，验证A、B相等时的比较结果。

5、74HC4511设计成扩展型的，即能显示数字0~9、字母a~f。

6、提交针对74HC148、74HC138、74HC153、74HC85、74HC283、74HC4511（任选一个）的综合结果，以及相应的仿真结果。

//74HC148代码

//HC148.v

moduleHC148（DataIn,EO,Dataout）;

input[7:

0]DataIn;

outputEO;

output[2:

0]Dataout;

reg[2:

regEO;

integerI;

always@（DataIn）

Dataout=0;

EO=1;

for（I=0;

I<

8;

I=I+1）

if（DataIn[I]）

Dataout=I;

EO=0;

//74HC148测试平台代码

//test148.v

moduletest148;

reg[7:

0]in;

wire[2:

0]out;

wireEO;

in=00000001;

repeat（9）

#20in=in<

HC148u148（in,EO,out）;

//74HC138代码

//HC138.v

moduleHC138（A,B,C,G1,G2AN,G2BN,Y7,Y6,Y5,Y4,Y3,Y2,Y1,Y0）;

inputA,B,C;

inputG1,G2AN,G2BN;

outputY7,Y6,Y5,Y4,Y3,Y2,Y1,Y0;

wireY7,Y6,Y5,Y4,Y3,Y2,Y1,Y0;

0]Eq;

wire[7:

0]EqN;

0]DataIn;

assignEqN=~Eq;

assignDataIn[0]=A;

assignDataIn[1]=B;

assignDataIn[2]=C;

always@（DataInorG1orG2ANorG2BN）

if（!

G1）

Eq=8'

b11111111;

elseif（!

（G2AN&

G2BN））

elseEq=1'

b1<

DataIn;

assignY0=EqN[0];

assignY1=EqN[1];

assignY2=EqN[2];

assignY3=EqN[3];

assignY4=EqN[4];

assignY5=EqN[5];

assignY6=EqN[6];

assignY7=EqN[7];

//74HC138测试平台代码

//test138.v

`timescale1ns/10ps

moduletest138;

regA,B,C;

regG1,G2AN,G2BN;

wireY0,Y1,Y2,Y3,Y4,Y5,Y6,Y7;

A=0;

repeat（20）

#20A=$random;

B=0;

C=0;

G1=0;

#40G1=1;

G2AN=0;

#25G2AN=1;

G2BN=0;

#45G2BN=1;

HC138u138

（

.A（A）,

.B（B）,

.C（C）,

.G1（G1）,

.G2AN（G2AN）,

.G2BN（G2BN）,

.Y0（Y0）,

.Y1（Y1）,

.Y2（Y2）,

.Y3（Y3）,

.Y4（Y4）,

.Y5（Y5）,

.Y6（Y6）,

.Y7（Y7）

）;

//74HC153代码

//HC153.v

moduleHC153（C0,C1,C2,C3,A,B,Y,G）;

inputC0,C1,C2,C3,A,B,G;

outputY;

regY;

always@（C0orC1orC2orC3orAorB）

if（G）Y=0;

else

case（{A,B}）

0:

Y=C0;

1:

Y=C1;

2:

Y=C2;

3:

Y=C3;

default:

Y=1'

bx;

endcase

//74HC153测试平台代码

//test153.v

moduletest153;

regC0,C1,C2,C3;

regA,B,G;

wireY;

G=1;

#20G=0;

#20B=$random;

C0=0;

#20C0=$random;

C1=0;

#20C1=$random;

C2=0;

#20C2=$random;

C3=0;

#20C3=$random;

HC153u153

.C0（C0）,

.C1（C1）,

.C2（C2）,

.C3（C3）,

.G（G）,

.Y（Y）

//74HC85代码

//HC85.v

moduleHC85（A3,A2,A1,A0,B3,B2,B1,B0,QAGB,QASB,QAEB,IAGB,IASB,IAEB）;

inputA3,A2,A1,A0,B3,B2,B1,B0,IAGB,IASB,IAEB;

outputQAGB,QASB,QAEB;

regQAGB,QASB,QAEB;

wire[3:

0]DataA,DataB;

assignDataA[0]=A0;

assignDataA[1]=A1;

assignDataA[2]=A2;

assignDataA[3]=A3;

assignDataB[0]=B0;

assignDataB[1]=B1;

assignDataB[2]=B2;

assignDataB[3]=B3;

always@（DataAorDataB）

if（DataA>

DataB）

QAGB=1;

QASB=0;

QAEB=0;

elseif（DataA<

QASB=1;

QAGB=0;

elseif（IAGB&

!

IASB&

IAEB）

IAGB&

elseif（IAEB）

QAEB=1;

if（DataA==DataB）

if（IAGB&

beginQAGB=0;

beginQAGB=1;

//74HC85测试平台代码

//test85.v

moduletest85;

regA3,A2,A1,A0,B3,B2,B1,B0;

regIAGB,IASB,IAEB;

wireQAGB,QASB,QAEB;

A3=0;

#20A3=$random;

A2=0;

#20A2=$random;

A1=0;

#20A1=$random;

A0=0;

#20A0=$random;

B3=0;

#20B3=$random;

B2=0;

#20B2=$random;

B1=0;

#20B1=$random;

B0=0;

#20B0=$random;

IAGB=0;

repeat（10）

#40IAGB=$random;

IASB=0;

#40IASB=$random;

IAEB=0;

#40IAEB=$random;

HC85u85

.A3（A3）,

.A2（A2）,

.A1（A1）,

.A0（A0）,

.B3（B3）,

.B2（B2）,

.B1（B1）,

.B0（B0）,

.IAGB（IAGB）,

.IASB（IASB）,

.IAEB（IAEB）,

.QAGB（QAGB）,

.QASB（QASB）,

.QAEB（QAEB）

Endmodule

//74HC283代码

//HC283.v

moduleHC283（A3,A2,A1,A0,B3,B2,B1,B0,Sigma3,Sigma2,Sigma1,Sigma0,C0,C4）;

inputA3,A2,A1,A0,B3,B2,B1,B0;

inputC0;

outputSigma3,Sigma2,Sigma1,Sigma0;

outputC4;

regC4;

reg[3:

0]Sigma;

wire[3:

always@（DataAorDataBorC0）

{C4,Sigma}=DataA+DataB+C0;

assignSigma0=Sigma[0];

assignSigma1=Sigma[1];

assignSigma2=Sigma[2];

assignSigma3=Sigma[3];

//74HC283测试平台代码

//test283.v

moduletest283;

regC0;

wireSigma3,Sigma2,Sigma1,Sigma0;

wireC4;

HC283u283

.Sigma3（Sigma3）,

.Sigma2（Sigma2）,

.Sigma1（Sigma1）,

.Sigma0（Sigma0）,

.C4（C4）

//74HC4511代码

//HC4511.v

moduleHC4511（A,Seg,LT_N,BI_N,LE）;

inputLT_N,BI_N,LE;

input[3:

0]A;

output[7:

0]Seg;

reg[7:

0]SM_8S;

assignSeg=SM_8S;

always@（AorLT_NorBI_NorLE）

LT_N）SM_8S=8'

BI_N）SM_8S=8'

b00000000;

elseif（LE）SM_8S=SM_8S;

case（A）

4'

d0:

SM_8S=8'

b00111111;

d1:

b00000110;

d2:

SM_8S