数字逻辑电路实验报告(七巧板设计)

《数字逻辑电路》实验报告

第十四次实验：七巧板的基本设计

姓名：车开达

学号：101220007

2010级计算机系一班

邮箱：798195236@https://www.360docs.net/doc/5c7825827.html,

时间：12月22日

一、实验目的

这个实验是自己的个人的设计，是从一本关于iphone的游戏设计中得到的灵感，自己感觉这个实验能够将键盘和显示器联系起来并且实现不算太难，主要是联系获得键盘的数据，处理数据并能够在显示器上显示相应的图案，是个个人感觉比较新颖的想法，所以没有太用心实现简易处理器，大部分时间都用来实现这个设计了。

二、实验原理（背景知识）

从第九次实验中的键盘实验可以学到如何接受外界键盘的输入，在后面的VGA实验中可以基本了解如何显示基本图案，但是如何实现移动和旋转，所以为了方便实现以及统一管理，自己使用了有一个点来形成一个图案，并且对移动和旋转都是以这个点为基准的。然后主要是对每个图案的图形计算，其中对图像的旋转是要新的计算，不可能使用固定计算函数可以得到，所以不同的旋转是不同的状态，这样就能实现基本的移动和旋转，另外可以实现相应的游戏功能，即每一个图案的坐标相对位置是不变的，所以实现对应的游戏功能就是计算每个坐标的相对位置是否相同。至于详细想法在下面进行细述。

三、实验器材/环境

硬件：个人电脑，Altera公司的DE2-70开发板等；

软件：Quartus II等。

四、实验设计思路（验收实验）

1、分析所需要的七巧板形状，每个形状的支撑点，对每个形状进行编号以及每种形状可以出现的状态：

（1）5个三角形，我们选取直角顶点为支撑点，共存在8个状态，即每次旋转45度；

（2）1个正方形，我们任意选取一个顶点为支撑点，共存在2个状态，即旋转45度产生的两种状态；

（3）1个平行四边形，我们选取角度小的那个顶点为支撑点，共存在4个状态，每个状态有一对平行边或者平行水平或者平行数值。

2、确定键盘上的功能键，并对其功能进行编号，主要有移动方向键（后来共用了2组方向键，以便操控），控制旋转键，选择不同图形键，后来添加了初始键、两个预置图案的键、一个判断图形是否符合要求的键，并对他们进行了相应的编码（4位，最后证明4位有点少）。

3、确定功能模块：

（1）从键盘接受数据并对其进行基本出来的模块，代码如下：

module io_ps2(clk,clrn,ps2_clk,ps2_data,data,change);

input clk,clrn,ps2_clk,ps2_data;

output reg [3:0]data;

output change;

wire change;

reg ready;

reg overflow;

reg [3:0]count;

reg [7:0]temp_data,temp;

reg key_f0;

reg [9:0] buffer;

reg [7:0]fifo[7:0];

reg [2:0] w_ptr,r_ptr;

reg [2:0] ps2_clk_sync;

always @(posedge clk)begin

ps2_clk_sync<={ps2_clk_sync[1:0],ps2_clk};

end

wire sampling = ps2_clk_sync[2]&~ps2_clk_sync[1];

always @(posedge clk)begin

if(clrn==0)begin

count<=0;

w_ptr<=0;

r_ptr<=0;

overflow<=0;

end

else

if(sampling)begin

if(count==4'd10)begin

if((buffer[0]==0)&&(ps2_data)&&(^buffer[9:1]))begin

fifo[w_ptr]<=buffer[8:1];

w_ptr<=w_ptr+3'b1;

ready<=1'b1;

overflow<=overflow|(r_ptr==(w_ptr+3'b1));

end

count<=0;

end

else begin

buffer[count]<=ps2_data;

count<=count+3'b1;

end

if(ready)begin

temp=fifo[r_ptr-3'd1];

temp_data=fifo[r_ptr];

r_ptr<=r_ptr+3'd1;

ready<=1'b0;

if(temp_data==8'hf0)begin

//temp=fifo[r_ptr-3'd2];

key_f0<=1'b1;

end

else begin

key_f0<=1'b0;

end

always @(posedge key_f0 or negedge clrn)begin

if(!clrn)

data <= 4'd0;

else begin

case(temp)

8'h0D: data <= 4'd1;

8'h29: data <= 4'd2;

8'h1D: data <= 4'd3;

8'h1C: data <= 4'd4;

8'h1B: data <= 4'd5;

8'h23: data <= 4'd6;

8'h43: data <= 4'd7;

8'h3B: data <= 4'd8;

8'h42: data <= 4'd9;

8'h4B: data <= 4'd10;

8'h16: data <= 4'd11;

8'h1E: data <= 4'd12;

8'h45: data <= 4'd13;

8'h5A: data <= 4'd14;

default:

data <= 4'd15;

endcase

end

assign change=~key_f0;

endmodule

（2）接受键盘模块送来的数据，并由此选择对应图形的状态，并在开始时对所有图形位置状态进行初始化，将每个图形坐标、状态送入VGA显示模块，代码如下：module

ps2_vga(din,clk,x0,x1,x2,x3,x4,x5,x6,y0,y1,y2,y3,y4,y5,y6,state0,state1,state2,state3,state4,state5 ,state6,choose);

input [3:0]din;

input clk;

output reg [2:0]choose;

output reg [9:0]x0,y0,x1,y1,x2,y2,x3,y3,x4,y4,x5,y5,x6,y6;

output reg [2:0]state0,state1,state2,state5,state6;

output reg [1:0]state4;

output reg state3;

initial begin

x0 = 10'd320;

y0 = 10'd240;

x1 = 10'd320;

y1 = 10'd240;

x2 = 10'd384;

y2 = 10'd176;

x3 = 10'd320;

y3 = 10'd176;

x4 = 10'd352;

y4 = 10'd208;

x5 = 10'd288;

y5 = 10'd208;

x6 = 10'd320;

y6 = 10'd240;

state3 = 1'b1;

state4 = 2'd1;

end

always @ (posedge clk) begin

case(din)

4'd1:

choose <= choose + 1'b1;

4'd2: begin

case(choose)

3'd0:

state0 <= state0 + 1'b1;

3'd1:

state1 <= state1 + 1'b1;

3'd2:

state2 <= state2 + 1'b1;

3'd3:

state3 <= state3 + 1'b1;

3'd4:

state4 <= state4 + 1'b1;

3'd5:

state5 <= state5 + 1'b1;

3'd6:

state6 <= state6 + 1'b1;

default:;

endcase

end

4'd3: begin

case(choose)

3'd0:

y0 <= y0 - 10'd5;

y1 <= y1 - 10'd5;

3'd2:

y2 <= y2 - 10'd5;

3'd3:

y3 <= y3 - 10'd5;

3'd4:

y4 <= y4 - 10'd5;

3'd5:

y5 <= y5 - 10'd5;

3'd6:

y6 <= y6 - 10'd5;

default:;

endcase

end

4'd4: begin

case(choose)

3'd0:

x0 <= x0 - 10'd5;

3'd1:

x1 <= x1 - 10'd5;

3'd2:

x2 <= x2 - 10'd5;

3'd3:

x3 <= x3 - 10'd5;

3'd4:

x4 <= x4 - 10'd5;

3'd5:

x5 <= x5 - 10'd5;

3'd6:

x6 <= x6 - 10'd5;

default:;

endcase

end

4'd5: begin

case(choose)

3'd0:

y0 <= y0 + 10'd5;

3'd1:

y1 <= y1 + 10'd5;

3'd2:

y2 <= y2 + 10'd5;

3'd3:

y3 <= y3 + 10'd5;

y4 <= y4 + 10'd5;

3'd5:

y5 <= y5 + 10'd5;

3'd6:

y6 <= y6 + 10'd5;

default:;

endcase

end

4'd6: begin

case(choose)

3'd0:

x0 <= x0 + 10'd5;

3'd1:

x1 <= x1 + 10'd5;

3'd2:

x2 <= x2 + 10'd5;

3'd3:

x3 <= x3 + 10'd5;

3'd4:

x4 <= x4 + 10'd5;

3'd5:

x5 <= x5 + 10'd5;

3'd6:

x6 <= x6 + 10'd5;

default:;

endcase

end

4'd7: begin

case(choose)

3'd0:

y0 <= y0 - 10'd1;

3'd1:

y1 <= y1 - 10'd1;

3'd2:

y2 <= y2 - 10'd1;

3'd3:

y3 <= y3 - 10'd1;

3'd4:

y4 <= y4 - 10'd1;

3'd5:

y5 <= y5 - 10'd1;

3'd6:

y6 <= y6 - 10'd1;

endcase

end

4'd8: begin

case(choose)

3'd0:

x0 <= x0 - 10'd1;

3'd1:

x1 <= x1 - 10'd1;

3'd2:

x2 <= x2 - 10'd1;

3'd3:

x3 <= x3 - 10'd1;

3'd4:

x4 <= x4 - 10'd1;

3'd5:

x5 <= x5 - 10'd1;

3'd6:

x6 <= x6 - 10'd1;

default:;

endcase

end

4'd9: begin

case(choose)

3'd0:

y0 <= y0 + 10'd1;

3'd1:

y1 <= y1 + 10'd1;

3'd2:

y2 <= y2 + 10'd1;

3'd3:

y3 <= y3 + 10'd1;

3'd4:

y4 <= y4 + 10'd1;

3'd5:

y5 <= y5 + 10'd1;

3'd6:

y6 <= y6 + 10'd1;

default:;

endcase

end

4'd10: begin

case(choose)

3'd0:

x0 <= x0 + 10'd1;

3'd1:

x1 <= x1 + 10'd1;

3'd2:

x2 <= x2 + 10'd1;

3'd3:

x3 <= x3 + 10'd1;

3'd4:

x4 <= x4 + 10'd1;

3'd5:

x5 <= x5 + 10'd1;

3'd6:

x6 <= x6 + 10'd1;

default:;

endcase

end

4'd11: begin

x0 <= 10'd390;

x1 <= 10'd390;

x2 <= 10'd435;

x3 <= 10'd390;

x4 <= 10'd480;

x5 <= 10'd390;

x6 <= 10'd390;

y0 <= 10'd290;

y1 <= 10'd290;

y2 <= 10'd313;

y3 <= 10'd268;

y4 <= 10'd223;

y5 <= 10'd268;

y6 <= 10'd313;

state0 <= 3'd1;

state1 <= 3'd1;

state2 <= 3'd5;

state3 <= 1'd0;

state4 <= 2'd2;

state5 <= 3'd1;

state6 <= 3'd1;

end

4'd12: begin

x0 <= 10'd252;

x1 <= 10'd342;

x2 <= 10'd297;

x3 <= 10'd252;

x4 <= 10'd432;

x5 <= 10'd252;

x6 <= 10'd252;

y0 <= 10'd276;

y1 <= 10'd276;

y2 <= 10'd321;

y3 <= 10'd122;

y4 <= 10'd321;

y5 <= 10'd122;

y6 <= 10'd122;

state0 <= 3'd3;

state1 <= 3'd1;

state2 <= 3'd7;

state3 <= 1'd1;

state4 <= 2'd3;

state5 <= 3'd6;

state6 <= 3'd0;

end

4'd13: begin

x0 = 10'd320;

y0 = 10'd240;

x1 = 10'd320;

y1 = 10'd240;

x2 = 10'd384;

y2 = 10'd176;

x3 = 10'd320;

y3 = 10'd176;

x4 = 10'd352;

y4 = 10'd208;

x5 = 10'd288;

y5 = 10'd208;

x6 = 10'd320;

y6 = 10'd240;

state3 = 1'b1;

state4 = 2'd1;

state0 = 3'd0;

state1 = 3'd0;

state2 = 3'd0;

state5 = 3'd0;

state6 = 3'd0;

end

4'd14: begin

if((x3-1<=x5 && x5<=x3+1) && (x3-1<=x6 && x6<=x3+1) && ((x3-1<=x0 && x0<=x3+1 && x3+89<=x1 && x1<=x3+91 && state0==3 && state1==1)||(x3-1<=x1 &&

x1<=x3+1 && x3+89<=x0 && x0<=x3+91 && state0==7 && state1==5)) && ((x3+44)<=x2 && x2<=x3+46) && (x3+179<=x4 && x4<=x3+181))

if((y3-1<=y5 && y5<=y3+1) && (y3-1<=y6 && y6<=y3+1) && (y3+153<=y0 && y3+155>=y0) && (y1-1<=y0 && y0<=y1+1) && (y0+44<=y4 && y0+46<=y4) && (y4-1<=y2 && y4+1<=y2) && ((state5==6 && state6==0)||(state6==4 && state5==2)) && (state3==1) && (state4==3) && (state2==7))

begin

x0 = 10'd320;

y0 = 10'd240;

x1 = 10'd320;

y1 = 10'd240;

x2 = 10'd384;

y2 = 10'd176;

x3 = 10'd320;

y3 = 10'd176;

x4 = 10'd352;

y4 = 10'd208;

x5 = 10'd288;

y5 = 10'd208;

x6 = 10'd320;

y6 = 10'd240;

state3 = 1'b1;

state4 = 2'd1;

state0 = 3'd0;

state1 = 3'd0;

state2 = 3'd0;

state5 = 3'd0;

state6 = 3'd0;

end

default: begin

choose <= 3'd7;

end

endcase

end

endmodule

（3）接受中间模块送来的数据，并对其进行坐标范围和状态的识别、计算，最后在显示器中显示，代码如下：

module io_vga(

iCLK_50, // DE2_70 clock 50MHZ

iCLRN, // clear_N connect to iSW[0]

// to ADV7123

choose,

x0,x1,x2,x3,x4,x5,x6,

y0,y1,y2,y3,y4,y5,y6,

state0,state1,state2,state3,state4,state5,state6,

oVGA_R,

oVGA_G,

oVGA_B,

oVGA_SYNC_N,

oVGA_BLANK_N,

oVGA_CLOCK,

// to VGA

oVGA_HS,

oVGA_VS);

input iCLK_50;

input iCLRN;

input [2:0]choose;

input [9:0]x0,x1,x2,x3,x4,x5,x6,y0,y1,y2,y3,y4,y5,y6;

input [2:0]state0,state1,state2,state5,state6;

input state3;

input [1:0]state4;

output reg [9:0] oVGA_R , oVGA_G , oVGA_B;

output oVGA_SYNC_N , oVGA_BLANK_N , oVGA_CLOCK;

output oVGA_HS , oVGA_VS;

reg vga_clk;

reg [9:0] h_count , v_count;

reg out0,out1,out2,out3,out4,out5,out6;

/*-----------------------------------------------------------------

常量定义

------------------------------------------------------------------*/

// Horizontal Parameter ( Pixel )

parameter H_SYNC_CYC = 96;

parameter H_SYNC_BACK = 48;

parameter H_SYNC_ACT = 640;

parameter H_SYNC_FRONT= 16;

parameter H_SYNC_TOTAL= 800; // 96+48+640+16=800 // Virtical Parameter ( Line )

parameter V_SYNC_CYC = 2;

parameter V_SYNC_BACK = 32;

parameter V_SYNC_ACT = 480;

parameter V_SYNC_FRONT= 11;

parameter V_SYNC_TOTAL= 525; // 2+32+480+11=525 // Start Offset

parameter X_START = H_SYNC_CYC+H_SYNC_BACK;

// 96 + 48=144 before 640

parameter Y_START = V_SYNC_CYC+V_SYNC_BACK;

// 2 + 32=34 before 480

/*----------------------------------------------------------------- */

// oVGA_CLK Generator, 50MHZ to 25MHZ

always @(posedge iCLK_50 or negedge iCLRN) begin

if(iCLRN == 0)

vga_clk <= 1'b1;

else

vga_clk <= ~vga_clk;

end

// H_Sync Counter

always @(posedge vga_clk or negedge iCLRN) begin

if(iCLRN==0)

h_count <= 10'd0;

else if (h_count == H_SYNC_TOTAL)

h_count <= 10'd0;

else

h_count = h_count + 10'd1;

end

// V_Sync Counter

always @(posedge vga_clk or negedge iCLRN) begin

if (iCLRN==0)

v_count <= 10'd0;

else if (h_count == H_SYNC_TOTAL) begin

if(v_count == V_SYNC_TOTAL)

v_count <= 10'd0;

else

v_count = v_count + 10'd1;

end

always @(posedge vga_clk) begin

case(state0)

3'd0:

out0 = (h_count>=X_START+x0-64) && (h_count<=X_START+x0) && (((v_count>=Y_START+y0-64) && (v_count<=Y_START+y0) && (h_count-(x0+X_START)+64<=v_count-(y0+Y_START)+64)) || ((v_count>=Y_START+y0) && (v_count<=Y_START+y0+64) && (v_count+h_count-(x0+X_START)-(y0+Y_START)+64<64)));

3'd1:

out0 = (h_count>=X_START+x0-90) && (v_count>=Y_START+y0-90) && (h_count<=X_START+x0) && (v_count<=Y_START+y0) && (h_count+v_count-(x0+X_START)-(y0+Y_START)+180>90);

3'd2:

out0 = (v_count>=Y_START+y0-64) && (v_count<=Y_START+y0) && (((h_count>=X_START+x0-64) && (h_count<=X_START+x0) &&

(h_count-(x0+X_START)+64>=v_count-(y0+Y_START)+64)) || ((h_count>=X_START+x0) && (h_count<=X_START+x0+64) && (h_count+v_count+64-(x0+X_START)-(y0+Y_START)<64)));

3'd3:

out0 = (h_count>=X_START+x0) && (v_count>=Y_START+y0-90) && (h_count<=X_START+x0+90) && (v_count<=Y_START+y0) && (h_count-(x0+X_START)<=v_count-(y0+Y_START)+90);

3'd4:

out0 = (h_count>=X_START+x0) && (h_count<=X_START+x0+64) && (((v_count<=Y_START+y0) && (v_count>=Y_START+y0-64) && (h_count+v_count-(x0+X_START)-(y0+Y_START)+64>=64)) || ((v_count>=Y_START+y0) && (v_count<=Y_START+y0+64) && (h_count-(x0+X_START)>=v_count-(y0+Y_START))));

3'd5:

out0 = (h_count>=X_START+x0) && (v_count>=Y_START+y0) && (h_count<=X_START+x0+90) && (v_count<=Y_START+y0+90) && (h_count+v_count-(x0+X_START)-(y0+Y_START)<=90);

3'd6:

out0 = (v_count>=Y_START+y0) && (v_count<=Y_START+y0+64) && (((h_count<=X_START+x0+64) && (h_count>=X_START+x0) && (h_count-(x0+X_START)<=v_count-(y0+Y_START))) || ((h_count<=X_START+x0) && (h_count>=X_START+x0-64) && (h_count+v_count-(x0+X_START)-(y0+Y_START)+64>=64)));

3'd7:

out0 = (h_count>=X_START+x0-90) && (v_count>=Y_START+y0) && (h_count<=X_START+x0) && (v_count<=Y_START+y0+90) && (h_count-(x0+X_START)+90>=v_count-(y0+Y_START));

endcase

case(state1)

3'd0:

out1 = (v_count>=Y_START+y1) && (v_count<=Y_START+y1+64) && (((h_count<=X_START+x1+64) && (h_count>=X_START+x1) && (h_count-(x1+X_START)<=v_count-(y1+Y_START))) || ((h_count<=X_START+x1) && (h_count>=X_START+x1-64) && (h_count+v_count-(x1+X_START)-(y1+Y_START)+64>=64)));

3'd1:

out1 = (h_count>=X_START+x1-90) && (v_count>=Y_START+y1) && (h_count<=X_START+x1) && (v_count<=Y_START+y1+90) && (h_count-(x1+X_START)+90>=v_count-(y1+Y_START));

3'd2:

out1 = (h_count>=X_START+x1-64) && (h_count<=X_START+x1) && (((v_count>=Y_START+y1-64) && (v_count<=Y_START+y1) && (h_count-(x1+X_START)+64<=v_count-(y1+Y_START)+64)) || ((v_count>=Y_START+y1) && (v_count<=Y_START+y1+64) && (v_count+h_count-(x1+X_START)-(y1+Y_START)+64<64)));

3'd3:

out1 = (h_count>=X_START+x1-90) && (v_count>=Y_START+y1-90) && (h_count<=X_START+x1) && (v_count<=Y_START+y1) && (h_count+v_count-(x1+X_START)-(y1+Y_START)+180>90);

3'd4:

out1 = (v_count>=Y_START+y1-64) && (v_count<=Y_START+y1) && (((h_count>=X_START+x1-64) && (h_count<=X_START+x1) && (h_count-(x1+X_START)+64>=v_count-(y1+Y_START)+64)) || ((h_count>=X_START+x1) && (h_count<=X_START+x1+64) && (h_count+v_count+64-(x1+X_START)-(y1+Y_START)<64)));

3'd5:

out1 = (h_count>=X_START+x1) && (v_count>=Y_START+y1-90) && (h_count<=X_START+x1+90) && (v_count<=Y_START+y1) && (h_count-(x1+X_START)<=v_count-(y1+Y_START)+90);

3'd6:

out1 = (h_count>=X_START+x1) && (h_count<=X_START+x1+64) && (((v_count<=Y_START+y1) && (v_count>=Y_START+y1-64) && (h_count+v_count-(x1+X_START)-(y1+Y_START)+64>=64)) || ((v_count>=Y_START+y1) && (v_count<=Y_START+y1+64) && (h_count-(x1+X_START)>=v_count-(y1+Y_START))));

3'd7:

out1 = (h_count>=X_START+x1) && (v_count>=Y_START+y1) && (h_count<=X_START+x1+90) && (v_count<=Y_START+y1+90) && (h_count+v_count-(x1+X_START)-(y1+Y_START)<=90);

endcase

case(state2)

3'd0:

out2 = (h_count>=X_START+x2-64) && (v_count>=Y_START+y2) && (h_count<=X_START+x2) && (v_count<=Y_START+y2+64) && (h_count-(x2+X_START)+64>=v_count-(y2+Y_START));

3'd1:

out2 = (h_count>=X_START+x2-45) && (h_count<=X_START+x2) && (((v_count>=Y_START+y2-45) && (v_count<=Y_START+y2) && (h_count-(x2+X_START)+45<=v_count-(y2+Y_START)+45)) || ((v_count>=Y_START+y2) && (v_count<=Y_START+y2+45) && (v_count+h_count-(x2+X_START)-(y2+Y_START)+45<45)));

3'd2:

out2 = (h_count>=X_START+x2-64) && (v_count>=Y_START+y2-64) && (h_count<=X_START+x2) && (v_count<=Y_START+y2) && (h_count+v_count-(x2+X_START)-(y2+Y_START)+128>64);

3'd3:

out2 = (v_count>=Y_START+y2-45) && (v_count<=Y_START+y2) && (((h_count>=X_START+x2-45) && (h_count<=X_START+x2) && (h_count-(x2+X_START)+45>=v_count-(y2+Y_START)+45)) || ((h_count>=X_START+x2) && (h_count<=X_START+x2+45) && (h_count+v_count+45-(x2+X_START)-(y2+Y_START)<45)));

3'd4:

out2 = (h_count>=X_START+x2) && (v_count>=Y_START+y2-64) && (h_count<=X_START+x2+64) && (v_count<=Y_START+y2) && (h_count-(x2+X_START)<=v_count-(y2+Y_START)+64);

3'd5:

out2 = (h_count>=X_START+x2) && (h_count<=X_START+x2+45) &&

(((v_count<=Y_START+y2) && (v_count>=Y_START+y2-45) && (h_count+v_count-(x2+X_START)-(y2+Y_START)+45>=45)) || ((v_count>=Y_START+y2) && (v_count<=Y_START+y2+45) && (h_count-(x2+X_START)>=v_count-(y2+Y_START))));

3'd6:

out2 = (h_count>=X_START+x2) && (v_count>=Y_START+y2) && (h_count<=X_START+x2+64) && (v_count<=Y_START+y2+64) && (h_count+v_count-(x2+X_START)-(y2+Y_START)<=64);

3'd7:

out2 = (v_count>=Y_START+y2) && (v_count<=Y_START+y2+45) && (((h_count<=X_START+x2+45) && (h_count>=X_START+x2) && (h_count-(x2+X_START)<=v_count-(y2+Y_START))) || ((h_count<=X_START+x2) && (h_count>=X_START+x2-45) && (h_count+v_count-(x2+X_START)-(y2+Y_START)+45>=45)));

endcase

case(state3)

1'b0:

out3 = (h_count>=X_START+x3) && (v_count>=Y_START+y3) && (h_count<=X_START+x3+45) && (v_count<=Y_START+y3+45);

1'b1:

out3 = ((h_count>=X_START+x3-32) && (h_count<=X_START+x3) && (v_count>=Y_START+y3) && (v_count<=Y_START+y3+32) && (h_count-(X_START+x3)+32+v_count-(Y_START+y3)>=32)) || ((h_count>=X_START+x3) && (v_count>=Y_START+y3) && (h_count<=X_START+x3+32) && (v_count<=Y_START+y3+32) && (h_count-(X_START+x3)<=v_count-(Y_START+y3))) ||

((h_count>=X_START+x3-32) && (h_count<=X_START+x3) && (v_count>=Y_START+y3+32) && (v_count<=Y_START+y3+64) && (h_count-(X_START+x3)+32>=v_count-(Y_START+y3)-32)) || ((h_count>=X_START+x3) && (h_count<=X_START+x3+32) && (v_count>=Y_START+y3+32) && (v_count<=Y_START+y3+64) && (h_count-(X_START+x3)+v_count-(Y_START+y3)-32<=32));

endcase

case(state4)

2'd0:

out4 = (v_count>=Y_START+y4) && (v_count<=Y_START+y4+45) && (((h_count>=X_START+x4) && (h_count<=X_START+x4+45) && (h_count-(X_START+x4)>=v_count-(Y_START+y4))) || ((h_count>=X_START+x4+45) && (h_count<=X_START+x4+90) && (h_count-(X_START+x4)-45<=v_count-(Y_START+y4))));

2'd1:

out4 = (h_count>=X_START+x4) && (h_count<=X_START+x4+32) && (((v_count>=Y_START+y4) && (v_count<=Y_START+y4+32) && (h_count-(X_START+x4)<=v_count-(Y_START+y4))) || ((v_count>=Y_START+y4+32) && (v_count<=Y_START+y4+64)) || ((v_count>=Y_START+y4+64) && (v_count<=Y_START+y4+96) && (h_count-(X_START+x4)>=v_count-(Y_START+y4)-64)));

2'd2:

out4 = (h_count>=X_START+x4-45) && (v_count>=Y_START+y4) && (h_count<=X_START+x4) && (v_count<=Y_START+y4+90) &&

(h_count-(X_START+x4)+45+v_count-(Y_START+y4)>=45) && (h_count-(X_START+x4)+v_count-(Y_START+y4)<=45);

2'd3:

out4 = (h_count>=X_START+x4-90) && (v_count>=Y_START+y4) && (h_count<=X_START+x4) && (v_count<=Y_START+y4+45) && (h_count-(X_START+x4)+90+v_count-(Y_START+y4)>=45) && (h_count-(X_START+x4)+45+v_count-(Y_START+y4)<=45);

endcase

case(state5)

3'd0:

out5 = (v_count>=Y_START+y5-32) && (v_count<=Y_START+y5) && (((h_count>=X_START+x5-32) && (h_count<=X_START+x5) && (h_count-(x5+X_START)+32>=v_count-(y5+Y_START)+32)) || ((h_count>=X_START+x5) && (h_count<=X_START+x5+32) && (h_count+v_count+32-(x5+X_START)-(y5+Y_START)<32)));

3'd1:

out5 = (h_count>=X_START+x5) && (v_count>=Y_START+y5-45) && (h_count<=X_START+x5+45) && (v_count<=Y_START+y5) && (h_count-(x5+X_START)<=v_count-(y5+Y_START)+45);

3'd2:

out5 = (h_count>=X_START+x5) && (h_count<=X_START+x5+32) && (((v_count<=Y_START+y5) && (v_count>=Y_START+y5-32) && (h_count+v_count-(x5+X_START)-(y5+Y_START)+32>=32)) || ((v_count>=Y_START+y5) && (v_count<=Y_START+y5+32) && (h_count-(x5+X_START)>=v_count-(y5+Y_START))));

3'd3:

out5 = (h_count>=X_START+x5) && (v_count>=Y_START+y5) && (h_count<=X_START+x5+45) && (v_count<=Y_START+y5+45) && (h_count+v_count-(x5+X_START)-(y5+Y_START)<=45);

3'd4:

out5 = (v_count>=Y_START+y5) && (v_count<=Y_START+y5+32) && (((h_count<=X_START+x5+32) && (h_count>=X_START+x5) && (h_count-(x5+X_START)<=v_count-(y5+Y_START))) || ((h_count<=X_START+x5) && (h_count>=X_START+x5-32) && (h_count+v_count-(x5+X_START)-(y5+Y_START)+32>=32)));

3'd5:

out5 = (h_count>=X_START+x5-45) && (v_count>=Y_START+y5) && (h_count<=X_START+x5) && (v_count<=Y_START+y5+45) && (h_count-(x5+X_START)+45>=v_count-(y5+Y_START));

3'd6:

out5 = (h_count>=X_START+x5-32) && (h_count<=X_START+x5) && (((v_count>=Y_START+y5-32) && (v_count<=Y_START+y5) && (h_count-(x5+X_START)+32<=v_count-(y5+Y_START)+32)) || ((v_count>=Y_START+y5) && (v_count<=Y_START+y5+32) && (v_count+h_count-(x5+X_START)-(y5+Y_START)+32<32)));

3'd7:

out5 = (h_count>=X_START+x5-45) && (v_count>=Y_START+y5-45) && (h_count<=X_START+x5) && (v_count<=Y_START+y5) &&

(h_count+v_count-(x5+X_START)-(y5+Y_START)+90>45);

endcase

case(state6)

3'd0:

out6 = (h_count>=X_START+x6) && (h_count<=X_START+x6+32) && (((v_count<=Y_START+y6) && (v_count>=Y_START+y6-32) && (h_count+v_count-(x6+X_START)-(y6+Y_START)+32>=32)) || ((v_count>=Y_START+y6) && (v_count<=Y_START+y6+32) && (h_count-(x6+X_START)>=v_count-(y6+Y_START))));

3'd1:

out6 = (h_count>=X_START+x6) && (v_count>=Y_START+y6) && (h_count<=X_START+x6+45) && (v_count<=Y_START+y6+45) && (h_count+v_count-(x6+X_START)-(y6+Y_START)<=45);

3'd2:

out6 = (v_count>=Y_START+y6) && (v_count<=Y_START+y6+32) && (((h_count<=X_START+x6+32) && (h_count>=X_START+x6) && (h_count-(x6+X_START)<=v_count-(y6+Y_START))) || ((h_count<=X_START+x6) && (h_count>=X_START+x6-32) && (h_count+v_count-(x6+X_START)-(y6+Y_START)+32>=32)));

3'd3:

out6 = (h_count>=X_START+x6-45) && (v_count>=Y_START+y6) && (h_count<=X_START+x6) && (v_count<=Y_START+y6+45) && (h_count-(x6+X_START)+45>=v_count-(y6+Y_START));

3'd4:

out6 = (h_count>=X_START+x6-32) && (h_count<=X_START+x6) && (((v_count>=Y_START+y6-32) && (v_count<=Y_START+y6) && (h_count-(x6+X_START)+32<=v_count-(y6+Y_START)+32)) || ((v_count>=Y_START+y6) && (v_count<=Y_START+y6+32) && (v_count+h_count-(x6+X_START)-(y6+Y_START)+32<32)));

3'd5:

out6 = (h_count>=X_START+x6-45) && (v_count>=Y_START+y6-45) && (h_count<=X_START+x6) && (v_count<=Y_START+y6) && (h_count+v_count-(x6+X_START)-(y6+Y_START)+90>45);

3'd6:

out6 = (v_count>=Y_START+y6-32) && (v_count<=Y_START+y6) && (((h_count>=X_START+x6-32) && (h_count<=X_START+x6) && (h_count-(x6+X_START)+32>=v_count-(y6+Y_START)+32)) || ((h_count>=X_START+x6) && (h_count<=X_START+x6+32) && (h_count+v_count+32-(x6+X_START)-(y6+Y_START)<32)));

3'd7:

out6 = (h_count>=X_START+x6) && (v_count>=Y_START+y6-45) && (h_count<=X_START+x6+45) && (v_count<=Y_START+y6) && (h_count-(x6+X_START)<=v_count-(y6+Y_START)+45);

endcase

if (out0) begin

oVGA_R <= 10'b1111111111;

oVGA_G <= 10'b0000000000;

oVGA_B <= 10'b0000000000;

end

else if (out1) begin

oVGA_R <= 10'b0000000000;

oVGA_G <= 10'b1111111111;

oVGA_B <= 10'b0000000000;

end

else if (out2) begin

oVGA_R <= 10'b0000000000;

oVGA_G <= 10'b0000000000;

oVGA_B <= 10'b1111111111;

end

else if (out3) begin

oVGA_R <= 10'b1111111111;

oVGA_G <= 10'b1111111111;

oVGA_B <= 10'b0000000000;

end

else if (out4) begin

oVGA_R <= 10'b1111111111;

oVGA_G <= 10'b0000000000;

oVGA_B <= 10'b1111111111;

end

else if (out5) begin

oVGA_R <= 10'b0000000000;

oVGA_G <= 10'b1111111111;

oVGA_B <= 10'b1111111111;

end

else if (out6) begin

oVGA_R <= 10'b1000000000;

oVGA_G <= 10'b1000000000;

oVGA_B <= 10'b1000000000;

end

else begin

oVGA_R <= 10'b0000000000;

oVGA_G <= 10'b0000000000;

oVGA_B <= 10'b0000000000;

end

case(choose)

3'd0:

if(out0) begin

oVGA_R <= 10'b1111111111;

oVGA_G <= 10'b1111111111;

oVGA_B <= 10'b1111111111;

end

3'd1:

if(out1) begin

oVGA_R <= 10'b1111111111;

oVGA_G <= 10'b1111111111;

oVGA_B <= 10'b1111111111;

end

3'd2:

if(out2) begin

oVGA_R <= 10'b1111111111;

oVGA_G <= 10'b1111111111;

oVGA_B <= 10'b1111111111;

end

3'd3:

if(out3) begin

oVGA_R <= 10'b1111111111;

oVGA_G <= 10'b1111111111;

oVGA_B <= 10'b1111111111;

end

3'd4:

if(out4) begin

oVGA_R <= 10'b1111111111;

oVGA_G <= 10'b1111111111;

oVGA_B <= 10'b1111111111;

end

3'd5:

if(out5) begin

oVGA_R <= 10'b1111111111;

oVGA_G <= 10'b1111111111;

oVGA_B <= 10'b1111111111;

end

3'd6:

if(out6) begin

oVGA_R <= 10'b1111111111;

oVGA_G <= 10'b1111111111;

oVGA_B <= 10'b1111111111;

end

3'd7:;

endcase

end

assign oVGA_HS = (h_count >= 10'd96);

assign oVGA_VS = (v_count >= 10'd2);

assign oVGA_SYNC_N = 1'b0;

assign oVGA_BLANK_N = oVGA_HS & oVGA_VS; assign oVGA_CLOCK = vga_clk;

基于Libero的数字逻辑设计仿真和验证实验报告(实验1)

实验报告 1、基本门电路一、实验目的 1、熟悉EDA工具的使用；仿真基本门电路。掌握基于Verilog的基本门电路的设计及其验证。 2、熟悉利用EDA工具进行设计及仿真的流程。基本门电路的程序烧录及验证。 3、学习针对实际门电路芯片74HC00、74HC02、74HC0 4、74HC08、74HC32、74HC86进行VerilogHDL设计的方法。二、实验环境 Libero仿真软件。三、实验内容 1、掌握Libero软件的使用方法。 2、进行针对74系列基本门电路的设计，并完成相应的仿真实验。 3、参考教材中相应章节的设计代码、测试平台代码（可自行编程），完成74HC00、74HC02、74HC0 4、74HC08、74HC32、74HC86相应的设计、综合及仿真。 4、提交针对74HC00、74HC02、74HC04、74HC08、74HC32、74HC86（任选一个．．．．）的综合结果，以及相应的仿真结果。四、实验结果和数据处理 1、所有．．模块及测试平台代码清单 //74HC00代码-与非门 // module HC00(A,B,Y); input [4:1]A,B;

assign Y=~(A&B); endmodule //74HC00测试平台代码 // `timescale 1ns/1ns module testbench(); reg [4:1]a,b; wire [4:1]y; HC00 u1(a,b,y); initial begin a=4'b0000;b=4'b0001; #10 b=b<<1; #10 b=b<<1; #10 b=b<<1; a=4'b1111;b=4'b0001; #10 b=b<<1; #10 b=b<<1; #10 b=b<<1; end endmodule //74HC02代码-或非门 // module HC02(A,B,Y);

数字钟课设报告

1.本实验中所用元器件： 1)计数器：74ls190,74ls192,74ls161 2)译码器：7448七段显示译码器 3)共阴数码管 2.各元器件基本介绍： a)74ls190是十进制计数器，具有同步置零和异步预置数的功能。 b)741S192是同步十进制可逆计数器，它具有双时钟输入，并具有异步置零和异步预置数的功能。 c)74ls161为二进制同步计数器，具有同步预置数，异步清零以及保持的功能。 d)7448七段显示译码器是驱动显示器的核心部件，它可以将输入代码转化成相应的数字显示代码，并在数码管上显示出来。 e)共阴数码管的阴极连接在一起，当某个发光二极管的阳极为高电平时，二极管点亮相应的段被显示。

3.各元器件功能及相关图注意：74ls190与74ls191逻辑图和功能表均相同74ls192与74ls193逻辑图和功能表均相同 74ls192（双时钟） 192 引脚排列图 74ls192功能表

74ls192逻辑符号 74ls190（单时钟）引脚排列图

74ls190功能表当置入控制端（LD）为低电平时，不管时钟CP的状态如何，输出端（Q0-Q3）即可预置成与数据输入端（D0～D3）相一致的状态。190的计数是同步的，靠CP加在4个触发器上而实现。当计数控制端（CT）为低电平时，在CP上升沿作用下Q0-03同时变化，从而消除了异步计数器中出现的计数尖峰。当计数方式控制（UD）为低电平时进行加计数，当计数方式控制（UD）为高电平时进行减计数。只有在CP为高电平时CT和UD才可以跳变

74ls161（二进制计数器）管脚图介绍时钟CP 四个数据输入端A~D 清零RD 使能S1S2 置数LD 数据输出端QA~QD

数字钟设计报告——数字电路实验报告

. 数字钟设计实验报告专业:通信工程 :王婧班级:111041B 学号:111041226 .

数字钟的设计目录一、前言 (3) 二、设计目的 (3) 三、设计任务 (3) 四、设计方案 (3) 五、数字钟电路设计原理 (4) （一）设计步骤 (4) （二）数字钟的构成 (4) （三）数字钟的工作原理 (5) 六、总结 (9) １

一、前言此次实验是第一次做EDA实验，在学习使用软硬件的过程中，自然遇到很多不懂的问题，在老师的指导和同学们的相互帮助下，我终于解决了实验过程遇到的很多难题，成功的完成了实验，实验结果和预期的结果也是一致的，在这次实验中，我学会了如何使用Quartus II软件，如何分层设计点路，如何对实验程序进行编译和仿真和对程序进行硬件测试。明白了一定要学会看开发板资料以清楚如何给程序的输入输出信号配置管脚。这次实验为我今后对 EDA的进一步学习奠定了更好的理论基础和应用基础。通过本次实验对数电知识有了更深入的了解，将其运用到了实际中来，明白了学习电子技术基础的意义，也达到了其培养的目的。也明白了一个道理：成功就是在不断摸索中前进实现的，遇到问题我们不能灰心、烦躁，甚至放弃，而要静下心来仔细思考，分部检查，找出最终的原因进行改正，这样才会有进步，才会一步步向自己的目标靠近，才会取得自己所要追求的成功。２

二、设计目的 1.掌握数字钟的设计方法。 2熟悉集成电路的使用方法。 3通过实训学会数字系统的设计方法； 4通过实训学习元器件的选择及集成电路手册查询方法； 5通过实训掌握电子电路调试及故障排除方法； 6熟悉数字实验箱的使用方法。三、设计任务设计一个可以显示星期、时、分、秒的数字钟。要求： 1、24小时为一个计数周期； 2、具有整点报时功能； 3、定时闹铃（未完成）四、设计方案一个基本的数字钟电路主要由译码显示器、“时”，“分”，“秒”计数器和定时器组成。干电路系统由秒信号发生器、“时、３

数字钟设计报告——数字电路实验报告

数字钟设计实验报告专业:通信工程姓名:王婧班级:111041B 学号:111041226

数字逻辑实验报告。编码器

数字逻辑实验实验报告脚分配、1）分析输入、输出，列出方程。根据方程和IP 核库判断需要使用的门电路以及个数。 2）创建新的工程，加载需要使用的IP 核。 3）创建BD 设计文件，添加你所需要的IP 核，进行端口设置和连线操作。 4）完成原理图设计后，生成顶层文件（Generate Output Products）和HDL 代码文件（Create HDL Wrapper）。 5）配置管脚约束（I/O PLANNING），为输入指定相应的拨码开关，为输出指定相应的led 灯显示。

6）综合、实现、生成bitstream。 7）仿真验证，依据真值表，在实验板验证试验结果。

实验报告说明数字逻辑课程组实验名称列入实验指导书相应的实验题目。实验目的目的要明确，要抓住重点，可以从理论和实践两个方面考虑。可参考实验指导书的内容。在理论上，验证所学章节相关的真值表、逻辑表达式或逻辑图的实际应用，以使实验者获得深刻和系统的理解，在实践上，掌握使用软件平台及设计的技能技巧。一般需说明是验证型实验还是设计型实验，是创新型实验还是综合型实验。实验环境实验用的软硬件环境（配置）。实验内容（含电路原理图/Verilog程序、管脚分配、仿真结果等；扩展内容也列入本栏）这是实验报告极其重要的内容。这部分要写明经过哪几个步骤。可画出流程图，再配以相应的文字说明，这样既可以节省许多文字说明，又能使实验报告简明扼要，清楚明白。实验结果分析数字逻辑的设计与实验结果的显示是否吻合，如出现异常，如何修正并得到正确的结果。实验方案的缺陷及改进意见在实验过程中发现的问题，个人对问题的改进意见。心得体会、问题讨论对本次实验的体会、思考和建议。

数字钟课程设计实验报告

《电子技术课程设计报告》教学院：电气与电子信息工程学院专业班级：xx级电子信息工程（x）班学号：xxxxxxxxxxxx 学生：坏水指导教师：xxxxxxxxxxxx 时间：2011.10.10~10.23 地点：电子技术实验室

课程设计成绩评定表

电子技术课程设计任务书 2011～2012学年第一学期学生：坏水专业班级：xx电信本x班指导教师：xxxxxxxxx 工作部门：电气与电子信息工程学院一、课程设计题目：多功能数字钟电路的设计/直流稳压电源的设计二、课程设计容（含技术指标）： ①拟定多功能数字钟和直流稳压电源的组成框图，要现电路的基本功能，使用的器件少，成本低； ②画出数字钟和直流稳压电源的主体电路逻辑图； ③测试多功能数字钟的逻辑功能，同时满足基本功能与扩展功能的要求； ④设计并安装各单元电路，要求布线整齐、美观，便于级联与调试；

四、基本要求 1.基本功能：要求设计出+5V的直流稳压电源。数字钟要求以数字形式显示时、分、秒的时间。小时计数器的计时要求为“12翻1”，要求具有手动校时功能。 2.扩展功能：定时控制，其时间自定；仿广播电台正点报时，自动报整点时数或触摸报整点时数（主要体现在理论知识上进行电路设计）。 (一）实训题目:直流稳压电源和多功能数字钟。 (二）实训目的: 1、巩固和加深学生对模拟电子技术，数字逻辑电路等课程基本知识的理解，综合运用课程中所学到的理论知识去独立完成一个实际课题。 2、根据课程需要，通过查阅手册和文献资料，培养学生独立分析和解决实际问题的能力。 3、通过电路方案的分析、论证和比较，设计计算和选用元气件，通过电路组装，调试和检测环节，掌握电路的分析方法和设计方法。 4、熟用常用电子元气件的类型和特性，并掌握合理选用原则。 5、掌握电路图、PCB图的设计方法，学会电路的安装与调试。 6、掌握常用仪器、仪表的正确使用方法，学会电路整机指标的测试方法。（三）实训要求

数字电路实验报告

数字电路实验报告姓名：张珂班级：10级8班学号：2010302540224

实验一：组合逻辑电路分析一．实验用集成电路引脚图 1．74LS00集成电路 2．74LS20集成电路二、实验内容 1、组合逻辑电路分析逻辑原理图如下：

U1A 74LS00N U2B 74LS00N U3C 74LS00N X1 2.5 V J1 Key = Space J2 Key = Space J3 Key = Space J4 Key = Space VCC 5V GND 图1.1组合逻辑电路分析电路图说明：ABCD 按逻辑开关“1”表示高电平，“0”表示低电平；逻辑指示灯：灯亮表示“1”，灯不亮表示“0”。真值表如下： A B C D Y 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 1 1 1 0 1 0 0 0 0 1 0 1 0 0 1 1 0 0 0 1 1 1 1 1 0 0 0 0 1 0 0 1 0 1 0 1 0 0 1 0 1 1 1 1 1 0 0 1 1 1 0 1 1 1 1 1 0 1 1 1 1 1 1 表1.1 组合逻辑电路分析真值表实验分析：由实验逻辑电路图可知：输出X1=AB CD =AB+CD ，同样，由真值表也能推出此方程，说明此逻辑电路具有与或功能。 2、密码锁问题：密码锁的开锁条件是：拨对密码，钥匙插入锁眼将电源接通，当两个条件同时满足时，开锁信号为“1”，将锁打开；否则，报警信号为“1”，则接通警铃。

试分析下图中密码锁的密码ABCD 是什么？密码锁逻辑原理图如下： U1A 74LS00N U2B 74LS00N U3C 74LS00N U4D 74LS00N U5D 74LS00N U6A 74LS00N U7A 74LS00N U8A 74LS20D GND VCC 5V J1 Key = Space J2 Key = Space J3 Key = Space J4 Key = Space VCC 5V X1 2.5 V X2 2.5 V 图 2 密码锁电路分析实验真值表记录如下：实验真值表 A B C D X1 X2 0 0 0 0 0 1 0 0 0 1 0 1 0 0 1 0 0 1 0 0 1 1 0 1 0 1 0 0 0 1 0 1 0 1 0 1 0 1 1 0 0 1 0 1 1 1 0 1 1 0 0 0 0 1 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 1 0 1 1 1 0 0 0 1 1 1 0 1 0 1 1 1 1 0 0 1 1 1 1 1 0 1 表1.2 密码锁电路分析真值表实验分析：由真值表（表1.2）可知：当ABCD 为1001时，灯X1亮，灯X2灭；其他情况下，灯X1灭，灯X2亮。由此可见，该密码锁的密码ABCD 为1001.因而，可以得到：X1=ABCD ，X2=1X 。

北京邮电大学数字电路实验报告

北京邮电大学数字电路与逻辑设计实验实验报告实验名称：QuartusII原理图输入法设计与实现学院：北京邮电大学班级：姓名：学号：

一．实验名称和实验任务要求实验名称：QuartusII原理图输入法设计与实现实验目的：⑴熟悉用QuartusII原理图输入法进行电路设计和仿真。 ⑵掌握QuartusII图形模块单元的生成与调用； ⑶熟悉实验板的使用。实验任务要求：⑴掌握QuartusII的基础上，利用QuartusII用逻辑门设计实现一个半加器，生成新的半加器图像模块。 ⑵用实验内容（1）中生成的半加器模块以及逻辑门实现一个全加器，仿真验证其功能，并能下载到实验板上进行测试，要求用拨码开关设定输入信号，发光二级管显示输出信号。 ⑶用3线—8线译码器（74L138）和逻辑门实现要求的函数：CBA F+ C + =,仿真验证其 + B C B A A A B C 功能，，并能下载到实验板上进行测试，要求用拨码开关设定输入信号，发光二级管显示输出信号。二．设计思路和过程半加器的设计实现过程：⑴半加器的应有两个输入值，两个输出值。 a表示加数，b表示被加数，s表示半加和， co表示向高位的进位。

⑵由数字电路与逻辑设计理论知识可知 b a s ⊕=;b a co ?= 选择两个逻辑门：异或门和与门。a,b 为异或门和与门的输入，S 为异或门的输出，C 为与门的输出。 (3)利用QuartusII 仿真实现其逻辑功能，并生成新的半加器图形模块单元。 (4)下载到电路板，并检验是否正确。全加器的设计实现过程：⑴全加器可以由两个半加器和一个或门构成。全加器有三个输入值a,b,ci ，两个输出值s,co ：a 为被加数，b 为加数，ci 为低位向高位的进位。 ⑵全加器的逻辑表达式为： c b a s ⊕⊕= b a ci b a co ?+?⊕=)( ⑶利用全加器的逻辑表达式和半加器的逻辑功能，实现全加器。用3线—8线译码器（74L138）和逻辑门设计实现函数 CBA A B C A B C A B C F +++= 设计实现过程：⑴利用QuartusII 选择译码器（74L138）的图形模块

华中科技大学数字逻辑实验报告

华中科技大学数字逻辑实验报告姓名: 专业班级: 学号: 指导老师：完成时间：

实验一：组合逻辑电路的设计一、实验目的： 1．掌握组合逻辑电路的功能测试。 2．验证半加器和全加器的逻辑功能 3．学会二进制的运算规律。二、实验所用组件：二输入四与门74LS08,二输入四与非门74LS00,二输入四异或门74LS86,六门反向器74LS04芯片，三输入三与非门74L10，电线若干。三、实验内容：内容A：全加全减器。实验要求：一位全加/全减法器，如图所示：电路做加法还是做减法运算是由M决定的，当M=0做加法，M=1做减法。当作为全加法起时输入A.B和Cin分别为加数，被加数和低位来的进位，S和数，Co位向上位的进位。当作为全减法器时输入信号A,B和Cin分别为被减数，减数和低位来的借位，S为差，Co为向上的借位。实验步骤： 1．根据功能写出输入/输出观察表：

2． 3．做出卡诺图，确定输出和激励的函数表达式：

4．根据逻辑表达式作出电路的平面图： 5．检查导线以及芯片是否完好无损坏，根据平面图和逻辑表达式连接电路。实验结果：电路连接好后，经检测成功实现了一位全加/全减法器的功能。内容B：舍入与检测电路的设计：试验要求：用所给定的集合电路组件设计一个多输出逻辑电路，该电路的输入为8421码，F1为“四

舍五入”输出信号，F2为奇偶检测输出信号。当电路检测到输入的代码大宇或等于（5）10时，电路的输出F1=1；其他情况F1=0。当输入代码中含1的个数为奇数时，电路的输出F2=1，其他情况F2=0。该电路的框图如下所示：（1）按照所设计的电路图接线，注意将电路的输入端接试验台的开关，通过拨动开关输入8421代码，电路输入按至试验台显示灯。（2）每输入一个代码后观察显示灯，并将结果记录在输入/输出观察表中。实验步骤 1．按照所给定的实验要求填写出F1，F2理论上的真值表。 2．根据真值表给出F1和F2的卡诺图。

数字电子钟课程设计实验报告

中北大学信息与通信工程学院通信工程专业《电子线路及系统》课程设计任务书2016/2017 学年第一学期学生姓名：张涛学号：李子鹏学号：课程设计题目：数字电子钟的设计起迄日期：2017年1月4日～2017年7月10日课程设计地点：科学楼指导教师：姚爱琴 2017年月日课程设计任务书

中北大学信息与通信工程学院通信工程专业《电子线路及系统》课程设计开题报告2016/2017 学年第一学期题目：数字电子钟的设计学生姓名：张涛学号：李子鹏学号：

指导教师：姚爱琴 2017 年 1 月 6 日中北大学信息与通信工程学院通信工程专业《电子线路及系统》课程设计说明书2016/2017 学年第二学期题目：数字电子钟的设计学生姓名：张涛学号：李子鹏学号：指导教师：姚爱琴 2017 年月日

目录 1 引言 (6) 2 数字电子钟设计方案 (6) 2.1 数字计时器的设计思想 (6) 2.2数字电路设计及元器件参数选择 (6) 2.2.2 时、分、秒计数器 (7) 2.2.3 计数显示电路 (8) 2.2.5 整点报时电路 (10) 2.2.6 总体电路 (10) 2.3 安装与调试 (11) 2.3.1 数字电子钟PCB图 (11) 3 设计单元原理说明 (11) 3.1 555定时器原理 (12) 3.2 计数器原理 (12) 3.3 译码和数码显示电路原理 (12) 3.4 校时电路原理 (12) 4 心得与体会 (12) 1 引言数字钟是一种用数字电子技术实现时，分，秒计时的装置，具有较高的准确性和直观性等各方面的优势，而得到广泛的应用。此次设计数字电子钟是为了了解数字钟的原理，在设计数字电子钟的过程中，用数字电子技术的理论和制作实践相结合，进一步加深数字电子技术课程知识的理解和应用，同时学会使用Multisim电子设计软件。 2数字电子钟设计方案 2.1 数字计时器的设计思想要想构成数字钟，首先应选择一个脉冲源——能自动地产生稳定的标准时间脉冲信号。而脉冲源产生的脉冲信号地频率较高，因此，需要进行分频，使得高频脉冲信号变成适合于计时的低频脉冲信号，即“秒脉冲信号”（频率为1Hz）。经过分频器输出的秒脉冲信号到计数器中进行计数。由于计时的规律是：60秒=1分，60分=1小时，24小时=1天，就需要分别设计60进制，24进制计数器，并发出驱动信号。各计数器输出信号经译码器、驱动器到数字显示器，是“时”、“分”、“秒”得以数字显示出来。值得注意的是：任何记时装置都有误差，因此应考虑校准时间电路。校时电路一般

数字秒表的设计与实现实验报告

电子科技大学《数字秒表课程设计》姓名: xxx 学号：学院：指导老师：xx

摘要 EDA技术作为电子工程领域的一门新技术，极大的提高了电子系统设计的效率和可靠性。文中介绍了一种基于FPGA在ISE10.1软件下利用VHDL语言结合硬件电路来实现数字秒表的功能的设计方法。采用VHDL硬件描述语言，运用ModelSim等EDA仿真工具。该设计具有外围电路少、集成度高、可靠性强等优点。通过数码管驱动电路动态显示计时结果。给出部分模块的VHDL源程序和仿真结果,仿真结果表明该设计方案的正确,展示了VHDL语言的强大功能和优秀特性。关键词：FPGA, VHDL, EDA, 数字秒表

目录第一章引言 (4) 第二章设计背景 (5) 2.1 方案设计 (5) 2.2 系统总体框图 (5) 2.3 -FPGA实验板 (5) 2.4 系统功能要求 (6) 2.5 开发软件 (6) 2.5.1 ISE10.1简介 (6) 2.5.2 ModelSim简介 (6) 2.6 VHDL语言简介 (7) 第三章模块设计 (8) 3.1 分频器 (8) 3.2 计数器 (8) 3.3 数据锁存器 (9) 3.4 控制器 (9) 3.5 扫描控制电路 (10) 3.6 按键消抖电路 (11) 第四章总体设计 (12) 第五章结论 (13) 附录 (14)

第一章引言数字集成电路作为当今信息时代的基石，不仅在信息处理、工业控制等生产领域得到普及应用，并且在人们的日常生活中也是随处可见，极大的改变了人们的生活方式。面对如此巨大的市场，要求数字集成电路的设计周期尽可能短、实验成本尽可能低，最好能在实验室直接验证设计的准确性和可行性，因而出现了现场可编程逻辑门阵列FPGA。对于芯片设计而言，FPGA的易用性不仅使得设计更加简单、快捷，并且节省了反复流片验证的巨额成本。对于某些小批量应用的场合，甚至可以直接利用FPGA实现，无需再去订制专门的数字芯片。文中着重介绍了一种基于FPGA利用VHDL硬件描述语言的数字秒表设计方法，在设计过程中使用基于VHDL的EDA工具ModelSim对各个模块仿真验证，并给出了完整的源程序和仿真结果。

数字逻辑实验报告(数字时钟设计)

数字逻辑实验报告

实验三、综合实验电路一、实验目的：通过一个综合性实验项目的设计与实现，进一步加深理论教学与实验软硬件平台的实践训练，为设计性实验做好充分准备。二、实验原理：根据要求的简单设计性的电路设计实验，应用基本器件与MSI按照电路设计步骤搭建出初级电路；设计型、综合型的较复杂实验电路三、实验设备与器件：主机与实验箱四、实验内容：（1）实验任务：根据所学习的器件，按照电路开发步骤搭建一个时钟，要求实现的基本功能有计时功能、校对时间功能、整点报时、秒表等功能。（2）实验任务分析：完成该数字时钟，采用同步时序电路，对于计时的的功能，由于时间的秒分时的进位分别是60、60、24，所以可以应用74LS163计数器分别设计2个模60计数器以及一个模24计数器，那么需要有7个秒输出，7个分输出，6个小时的输出；对于校对时间的功能，由74LS163的特性可知，当该器件处于工作状态时，每来一个CLK脉冲，计数值加1，所以可以手动控制给CLK脉冲，来进行时间的校对；对于整点报时功能，可以采用一个比较电路，当时间的分秒数值全部为零时，那么此时可以接通报时装置，可以在电路中设置报时的的时间；对于秒表功能，有两种方案，可以单独重新设计一个秒表装置，采用模100计数器以及两个模60计数器，可以进行优化，使用原先的两个模60计数器，这样可以简化电路，是电路简洁。（3）实验设计流程：

（4）输入输出表：（5）各个功能模块的实现： A、计时功能模块的实现（电路图及说明）秒表部分及说明

说明：该部分是实现功能正常计时中的秒部分的计时工作。如图所示，图中采用两个74LS163来做一个模60计时器，计数的起止范围是0~59，（第一个74LS163采用模10计数，起止为0~9，第二个74LS163的计数起止范围是0~5），两个器件采用级联方式，用预置位方法实现跳转；该部分有7个秒输出，接到BCD译码显示器。注解：第一个163器件： LDN端统一接到清零端ABCD端接地 ENP端接到VCC高电平ENT接高电平VCC 第二个163器件： LDN端统一接到清零端ABCD端接地 ENP端接到VCC高电平ENT接高电平第一个163的预置位段分钟部分以及说明：

基于单片机的电子时钟课程设计报告

目录一、引言········ 二、设计课题········· 三、系统总体方案········· 四、系统硬件设计······ 1.硬件电路原理图 2.元件清单五、系统软件设计········· 1.软件流程图 2.程序清单六、系统实物图········ 七、课程设计体会········ 八、参考文献及网站········· 九、附录·········

一．引言单片机因将其主要组成部分集成在一个芯片上而得名，就是把中央处理器、随机存储器、只读存储器、中断系统、定时器/计数器以及I/O接口电路等部件集成在一个芯片上。基于单片机设计的数字钟精确度较高，因为在程序的执行过程中，任何指令都不影响定时器的正常计数，即便程序很长也不会影响中断的时间。数字钟是采用数字电路实现对日期、时、分、秒，数字显示的计时装置，由于数字集成电路的发展和石英晶体振荡器的广泛应用，使得数字钟的精度，远远超过老式钟表，钟表的数字化给人们生产生活带来了极大的方便，而且大大地扩展了钟表的报时功能。数字钟已成为人们日常生活中的必需品，广泛应用于家庭、车站、码头、剧院、办公室等场所，给人们的生活、学习、工作带来极大的方便。不仅如此，在现代化的进程中，也离不开电子钟的相关功能和原理，比如机械手的控制、家务的自动化、定时自动报警、按时自动打铃、时间程序自动控制、定时广播、自动起闭路灯、定时开关烘箱、通断动力设备、甚至各种定时电气的自动启用等，所有这些，都是以钟表数字化为基础的。而且是控制的核心部分。因此，研究数字钟及扩大其应用，有着非常现实的意义。本设计使用12MHZ晶振与单片机AT89C51相连接，以AT89C51芯片为核心，采用动态扫描方式显示，通过使用该单片机，加之在显示电路部分使用HD74LS373驱动电路，实现在8个LED数码管上显示时间，通过4个按键进行调时、复位等功能，在实现各功能时数码管进行相应显示。软件部分用C语言实现，分为显示、延迟、调时、复位等部分。通过软硬件结合达到最终目的。

数字电路组合逻辑电路设计实验报告

数字电路组合逻辑电路设计实验报告 The Standardization Office was revised on the afternoon of December 13, 2020

实验三组合逻辑电路设计（含门电路功能测试）

一、实验目的 1.掌握常用门电路的逻辑功能 2.掌握小规模集成电路设计组合逻辑电路的方法 3.掌握组合逻辑电路的功能测试方法二、实验设备与器材 Multisim 、74LS00 四输入2与非门、示波器、导线三、实验原理 TTL集成逻辑电路种类繁多，使用时应对选用的器件做简单逻辑功能检查，保证实验的顺利进行。测试门电路逻辑功能有静态测试和动态测试两种方法。静态测试时，门电路输入端加固定的高（H）、低电平，用示波器、万用表、或发光二极管（LED）测

出门电路的输出响应。动态测试时，门电路的输入端加脉冲信号，用示波器观测输入波形与输出波形的同步关系。下面以74LS00为例，简述集成逻辑门功能测试的方法。74LS00为四输入2与非门，电路图如3-1所示。74LS00是将四个二输入与非门封装在一个集成电路芯片中，共有14条外引线。使用时必须保证在第14脚上加+5V电压，第7脚与底线接好。整个测试过程包括静态、动态和主要参数测试三部分。表3-1 74LS00与非门真值表 1.门电路的静态逻辑功能测试静态逻辑功能测试用来检查门电路的真值表，确认门电路的逻辑功能正确与否。实验时，可将74LS00中的一个与非门的输入端A、B分别作为输入逻辑变量，加高、低电平，观测输出电平是否符合74LS00的真值表（表3-1）描述功能。

数字逻辑设计实验报告-实验13教材

浙江大学城市学院实验报告课程名称数字逻辑设计实验实验项目名称实验十二数据选择器应用学生姓名专业班级学号实验成绩指导老师（签名）日期注意： ● 务请保存好各自的源代码，已备后用。 ● 完成本实验后,将实验项目文件和实验报告，压缩为rar 文件，上传ftp 。如没有个人文件夹，请按学号_姓名格式建立。 ftp://wujzupload:123456@10.66.28.222:2007/upload ● 文件名为：学号_日期_实验XX ，如30801001_20100305_实验0 1 一. 实验目的和要求 1. 掌握数据选择器的逻辑功能和使用方法。 2. 学习用数据选择器构成组合逻辑电路的方法。二. 实验内容、原理及实验结果与分析 1、用74LS151实现逻辑函数要求实现BC A AC C B A Y ++=，自己写出设计过程，画出接线图，并验证其逻辑功能。计算得到m0=m7=0，m2=m4=m5=m6=1，m1=m3=D (1) 设计原理图 (2) 仿真，模拟验证，若组合成总线显示时，需要注意高低位

(3)组合输出信号 (4)配置管脚 (5)下载到FPGA

(6) 74LS151的输入端接逻辑电平输出（拨位开关），输出端Z 接逻辑电平显示（发光二极管）。逐项测试电路的逻辑功能，记录测试结果。 2、用74LS151实现逻辑函数要求实现逻辑函数C B CD A B A F ++=，自己写出设计过程，画出接线图，并验证其逻辑功能。芯片插法，电源、地线接法与实验内容1相同，这里只需要自己实现逻辑函数，然后连线实现其功能。 (1) 设计原理图 (2) 仿真，模拟验证，若组合成总线显示时，需要注意高低位

北邮-数字电路与逻辑设计实验-实验报告(上)

北京邮电大学电路实验中心<数字电路与逻辑设计实验（上）> 实验报告班级： xxxx 学院： xxx 实验室： xxx 审阅教师：姓名（班内序号）： xxx 学号： xxx 实验时间： xxx 评定成绩：

目录实验1 Quartus II 原理图输入法设计与实现 (3) 一、实验目的 (3) 二、实验所用器材 (3) 三、实验任务要求 (3) 四、实验原理图 (3) 五、实验仿真波形图及分析 (4) 实验2 用VHDL 设计与实现组合逻辑电路 (5) 一、实验目的 (5) 二、实验所用器材 (5) 三、实验任务要求 (5) 四、VHDL代码 (5) 五、实验仿真波形图及分析 (7) 实验3 用VHDL 设计与实现时序逻辑电路 (8) 一、实验目的 (8) 二、实验所用器材 (8) 三、实验任务要求 (8) 四、模块端口说明及连接图 (8) 五、VHDL代码 (9) 六、实验仿真波形图及分析 (10) 实验4 用VHDL 设计与实现数码管动态扫描控制器 (10) 一、实验目的 (10) 二、实验所用器材 (11) 三、实验任务要求 (11) 四、模块端口说明及连接图 (11) 五、VHDL代码 (11) 六、实验仿真波形图及分析 (15) 故障及问题分析 (16) 总结和结论 (17)

实验1 Quartus II 原理图输入法设计与实现一、实验目的（1）熟悉用Quartus II原理图输入法进行电路设计和仿真；（2）掌握Quartus II 图形模块单元的生成与调用；（3）熟悉实验板的使用。二、实验所用器材（1）计算机；（2）直流稳压电源；（3）数字系统与逻辑设计实验开发板。三、实验任务要求（1）用逻辑门设计实现一个半加器，仿真验证其功能，并生成新的半加器图形模块单元。（2）用（1）中生成的半加器模块和逻辑门设计实现一个全加器，仿真验证其功能，并下载到实验板测试，要求用拨码开关设定输入信号，发光二极管显示输出信号。（3）用3线-8线译码器（74LS138）和逻辑门设计实现函数+CBA，仿真验证其功能，并下载到实验板测试。要求用拨码开关设定输入信号，发光二极管显示输出信号。四、实验原理图（1）半加器原理图（2）全加器原理图

数字系统设计软件实验报告

实验一QuartusⅡ9.1软件的使用一、实验目的： 1、通过实现书上的例子，掌握QUARTUSII9.1软件的使用； 2、编程实现3-8译码电路以掌握VHDL组合逻辑的设计以及QUARTUSII9.1软件的使用。二、实验流程： 1、仔细阅读书上的操作指南，学会在QuartusⅡ9.1中创建新的工程，创建过程如下所示： 1）、建立新设计项目： ①启动QuartusⅡ9.1软件，在软件的管理器窗口选File下拉菜单，即File→New Project Wizard，则出现新建工程向导窗口。如下所示： ②点击Next按钮，将弹出新建工程设置窗口，如下图所示。在新建工程设置窗口中设置好工程的存放路径、工程名称等。

③点击Next进入添加文件窗口，如下图。由于尚未创建文件，跳过该步骤。 ④点击Next按钮，进入选择目标芯片窗口。在这里我们选择Cyclone系列的EP1C6Q240C8，如下图：

⑤点击Next按钮，进入EDA工具设置窗口，通常选择默认的“None”，表示选择QuartusⅡ自带的仿真器和综合器。如下图： ⑥点击Next按钮，弹出New Project Wizard概要对话框，在这个窗口中列出了所有前面设置的结果。若有错误则点击Back回去修改，否则点击Finish结束，即完成新工程的设定工作。如下图：

2）、文本设计输入： ①在QuartusⅡ主界面菜单栏中选择File下拉菜单中的New，弹出新建设计文件窗口，选择VHDL File项，点击OK按钮即可打开VHDL文本编辑窗口，其默认文件名为“Vhdl.vhd”。 ②出现文本编辑窗口后，我们可以直接在空白界面中键入所设计的VHDL文本。这时我们将书本中的程序输入到文本编辑环境中去。程序如下： library IEEE; use IEEE.std_logic_1164.all; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity count10 is port(clk,load,en:in std_logic; data_in:in std_logic_vector(3 downto 0); seg:out std_logic_vector(6 downto 0)); end count10; architecture beha of count10 is signal qout:std_logic_vector(3 downto 0); signal q_temp:std_logic_vector(3 downto 0); begin process(clk,load) begin

EDA数字逻辑实验报告

实验报告课程名称_数字逻辑及系统设计实验学生学院____计算机____________ 专业班级软件2012（2）班 _ 学号 3112006177 学生姓名陈海兵指导教师_____林小平 _________ 2013年 12 月24 日

一、实验目的 1. 熟练掌握基本门电路的主要用途以及验证它们的逻辑功能。 2. 熟练掌握常用组合逻辑电路的基本原理及其逻辑电路功能。 3. 熟练掌握常用时序逻辑电路的基本原理及其逻辑电路功能。 4. 掌握Libero IDE 基于FPGA 的设计流程。 5. 熟悉FPGA 的设计与开发流程。熟悉芯片烧录的流程及步骤。二、实验要求 1. 要求每人能独立完成实验。严禁抄袭。 2. 能独立搭建Libero IDE 软件基础环境，掌握FPGA 的开发流程。 3. 按照实验指导书中P56-69的实验步骤进行设计，每一步骤均需要截图显示。 4. 完成3次仿真（综合前，综合后，布局布线后），并将仿真波形截图显示。 5. 将程序烧录到Actel Proasic3 A3P030 FPGA 核心板，在数字逻辑及系统实验箱上完成连线，验证代码的正确性。 6. 纸制版的封面单面打印，其他页面必须双面打印。全班刻一张光盘。三、实验内容 1. 设计题目：用3-8译码器74HC138实现举重比赛的裁判表决电路的组合逻辑函数，写出模块代码和测试平台代码。 2. 74HC138功能表参照教材中P53表2-9，引脚图参照实验指导书中P30图2-16。 3. 把每一个步骤的实验结果截图，按实验指导书中P6图1-7中所列FPGA 引脚，手工分配引脚，最后通过烧录器烧录至FPGA 核心板上。 4. 按分配的引脚连线，实测相应功能并记录结果。四、实验结果与截图 1. 模块及测试平台代码清单。模块代码 // 74HC138.v module decoder3_8_1(DataIn,Enable1,Enable2,Enable3,Eq,y); input [2:0]DataIn; input Enable1,Enable2,Enable3; output [7:0]Eq; reg [7:0]Eq; output y; reg y; integer I; always @(DataIn or Enable1 or Enable2 or Enable3) begin if(Enable1||Enable2||!Enable3) Eq=0; AC BC AB Y ++=

数电课程设计报告数字钟的设计

数电课程设计报告第一章设计背景与要求设计要求第二章系统概述 2.1设计思想与方案选择 2.2各功能块的组成 2.3工作原理第三章单元电路设计与分析 3.1各单元电路的选择 3.2设计及工作原理分析第四章电路的组构与调试 4.1遇到的主要问题 4.2现象记录及原因分析 4.3解决措施及效果 4.4功能的测试方法，步骤，记录的数据第五章结束语 5.1对设计题目的结论性意见及进一步改进的意向说明5.2总结设计的收获与体会附图（电路总图及各个模块详图）参考文献

第一章设计背景与要求一．设计背景与要求在公共场所，例如车站、码头，准确的时间显得特别重要，否则很有可能给外出办事即旅行袋来麻烦。数字钟是一种用数字电路技术实现时、分、秒计时的装置，与机械式时钟相比具有更高的准确度和直观性，且无机械装置，具有更长的使用寿命，因此得到了广泛的使用。数字钟是一种典型的数字电路，包括了组合逻辑电路和时序电路。设计一个简易数字钟，具有整点报时和校时功能。（1）以四位LED数码管显示时、分，时为二十四进制。（2）时、分显示数字之间以小数点间隔，小数点以1Hz频率、50%占空比的亮、灭规律表示秒计时。（3）整点报时采用蜂鸣器实现。每当整点前控制蜂鸣器以低频鸣响4次，响1s、停1s，直到整点前一秒以高频响1s，整点时结束。（4）才用两个按键分别控制“校时”或“校分”。按下校时键时，是显示值以0~23循环变化；按下“校分”键时，分显示值以0~59循环变化，但时显示值不能变化。二．设计要求电子技术是一门实践性很强的课程，加强工程训练，特别是技能的培养，对于培养学生的素质和能力具有十分重要的作用。在电子信息类本科教学中，课程设计是一个重要的实践环节，它包括选

中山大学数字电路与逻辑设计实验报告

中山大学数字电路与逻辑设计实验报告院系信息科学与技术学院学号专业计算机科学类实验人 3、实验题目：AU(Arithmetic Unit,算术单元）设计。实验内容：设计一个半加半减器，输入为 S、A、B,其中S为功能选择口。当S=0时，输出A+B及进位；当S=1时，输出A-B及借位。 S 输入1 输入2 输出Y 进/借位Cn 0 A B A+B 进位 1 A B A-B 借位利用三种方法实现。（1）利用卡诺图简化后只使用门电路实现。（2）使用74LS138实现。（3）使用74LS151实现，可分两次单独记录和/差结果、进位借位结果或使用两块74LS151实现。实验分析：真值表 S A B Y Cn 0 0 0 0 0 0 0 1 1 0 0 1 0 1 0 0 1 1 0 1 1 0 0 0 0 1 0 1 1 1 1 1 0 1 0 1 1 1 0 0 卡诺图： S AB 0 1 通过卡诺图可得：Y=A B+A B 00 01 11 100 0 1 1 0 0 1 1

S AB 0 1 00 Cn=AB S +A BS 01 =(A S +A S)B 11 10 实验设计：（1）利用门电路实现。 ①利用74LS197的八进制输出端Q1、Q2、Q3作为B 、A 、S 的输入。 ②用异或门74LS86实现输出Y. ③用74LS86实现A ⊕B ，再用74LS08与B 实现与门。（2）利用74LS138实现 ①将74LS197的Q3、Q2、Q1作为74LS138的S2、S1、S0输入，G2A 、G2B 接低电平，G1接高电平。 ②将74LS138的Y1、Y5、Y2、Y6利用74LS20实现与非门作为输出Y 。 ③ 将74LS138的Y3、Y5利用74LS00实现与非门作为输出Cn 。 0 0 0 1 1 0 0 0