자료 소스 코드

소개글

- 1번 arith.v 코드

`timescale 1ns / 1ps
module arith(A, B, Y1, Y2, Y3 /*, Y4, Y5*/ ); // Y4, Y5는 주석 처리 하였습니다.
input [2:0] A, B; // 3비트 입력 A, B값 선언
output [3:0] Y1; // 4비트 출력 Y1선언
output [5:0] Y3; // 6비트 출력 Y3선언
output [2:0] Y2 /*Y4, Y5*/; // 3비트 출력 Y2선언
reg [3:0] Y1; // Y1을 레지스터로 선언
reg [5:0] Y3; // Y3을 레지스터로 선언
reg [2:0] Y2 /* Y4, Y5*/; // Y2를 레지스터로 선언

always@(A or B) // A또는 B의 비트가 바뀔때마다 실행함
begin
Y1 = A + B; //Addition //덧셈
Y2 = A - B; // Subtraction //뺄셈
Y3 = A * B; //Multiplication //곱셈
// Y4 = A / B; //Division //(주석처리)나눗셈
// Y5 = A % B; //Modulus of A divided by B //(주석처리)나머지를 구함
end
endmodule
- tb_arith.v 테스트 벤치 코드

`timescale 1ns / 1ps // 시간주기를 1ns = 1000ps로 지정
module tb_arith; // Y4, Y5는 주석처리 하였습니다
reg [2:0] A, B; // 신호 A, B를 3비트 레지스터로 선언
wire [3:0] Y1; // Y1을 wire선언
wire [5:0] Y3; // Y3을 wire선언
wire [2:0] Y2 /*, Y4, Y5*/; // Y2를 wire선언

arith inst0 (.A(A), .B(B), .Y1(Y1), .Y2(Y2), .Y3(Y3) /*, .Y4(Y4), .Y5(Y5)*/ ); // 실제회로와 테스트벤치 회로를 연결
initial begin // .A(A0)하면 함수 내부에서 A는 A0으로 대체
#1 A = 3`b111; // 1번째 타임에서 A에 3비트 111 대입
B = 3`b011; // B에 3비트 011 대입
#3 $stop;

컴파일 실행환경

- 1번 arith.v 코드
- 2번 relation.v 코드
- 3번 comparison.v 코드
- 4번 bitwise.v 코드
- tb_bitwise.v 코드
- 5번 shift.v 코드
- 6번 reduction.v 코드
- 7번 conditional.v 코드

본문내용

- 1번 arith.v 코드

`timescale 1ns / 1ps
module arith(A, B, Y1, Y2, Y3 /*, Y4, Y5*/ ); // Y4, Y5는 주석 처리 하였습니다.
input [2:0] A, B; // 3비트 입력 A, B값 선언
output [3:0] Y1; // 4비트 출력 Y1선언
output [5:0] Y3; // 6비트 출력 Y3선언
output [2:0] Y2 /*Y4, Y5*/; // 3비트 출력 Y2선언
reg [3:0] Y1; // Y1을 레지스터로 선언
reg [5:0] Y3; // Y3을 레지스터로 선언
reg [2:0] Y2 /* Y4, Y5*/; // Y2를 레지스터로 선언

always@(A or B) // A또는 B의 비트가 바뀔때마다 실행함
begin
Y1 = A + B; //Addition //덧셈
Y2 = A - B; // Subtraction //뺄셈
Y3 = A * B; //Multiplication //곱셈
// Y4 = A / B; //Division //(주석처리)나눗셈
// Y5 = A % B; //Modulus of A divided by B //(주석처리)나머지를 구함
end
endmodule
- tb_arith.v 테스트 벤치 코드

`timescale 1ns / 1ps // 시간주기를 1ns = 1000ps로 지정
module tb_arith; // Y4, Y5는 주석처리 하였습니다
reg [2:0] A, B; // 신호 A, B를 3비트 레지스터로 선언
wire [3:0] Y1; // Y1을 wire선언
wire [5:0] Y3; // Y3을 wire선언
wire [2:0] Y2 /*, Y4, Y5*/; // Y2를 wire선언

arith inst0 (.A(A), .B(B), .Y1(Y1), .Y2(Y2), .Y3(Y3) /*, .Y4(Y4), .Y5(Y5)*/ ); // 실제회로와 테스트벤치 회로를 연결
initial begin // .A(A0)하면 함수 내부에서 A는 A0으로 대체
#1 A = 3`b111; // 1번째 타임에서 A에 3비트 111 대입
B = 3`b011; // B에 3비트 011 대입
#3 $stop; // 순차적실행이므로 4번째 타임에서 정지
end
endmodule


☑ arith.v 에서 Y3 = A * B; 부분에서
WARNING:Xst:643 - "arith.v" line 15: The result of a 3x3-bit multiplication is partially used. Only the 5 least significant bits are used. If you are doing this on purpose, you may safely ignore this warning. Otherwise, make sure you are not losing information, leading to unexpected circuit behavior. 이 발생하여 이를 해결하기 위해 Y3의 출력 비트를 기존의[4:0]에서 [5:0]로 수정하였습니다.
- arith.v 의 Wave



- arith.v 의 RTL Schematic

TimeScale
1
2
3
4
A
x
111
111
111
B
x
011
011
011
Y1 = A + B
x
1010
1010
1010
Y2 = A * B
x
010101
010101
010101
Y3 = A - B
x
100
100
100



- 2번 relation.v 코드

`timescale 1ns / 1ps
module relation (A, B, Y1, Y2, Y3, Y4);
input[2:0] A, B; // 입력 3비트 A, B선언
output Y1, Y2, Y3, Y4; // 출력 Y1, Y2, Y3, Y4선언(2비트)

reg Y1, Y2, Y3, Y4; // 레지스터 Y1, Y2, Y3, Y4 선언

always@(A or B) // A 또는 B값이 변화할때마다 실행됨
begin
Y1 = A < B; // B가 A보다 크면 1을 아니라면 0을 대입
Y2 = A <= B; // B가 A보다 크거나 같으면 1을 아니라면 0을 대입
Y3 = A > B; // B가 A보다 작으면 1을 아니라면 0을 대입.
if (A >= B) // 조건문
Y4 = 1; // A가 B보다 크거나 같을 경우 Y4에 1을 대입
else
Y4 = 0; // 그 외의 경우 Y4에 0을 대입
end
endmodule
- tb_relation.v 코드

`timescale 1ns / 1ps // 시간 단위를 1ns = 1000ps으로 지정
module tb_relation;
reg [2:0] A, B; // 3비트 신호 A, B를 레지스터 선언
wire Y1, Y2, Y3, Y4; // Y1, Y2, Y3, Y4를 wire 선언

relation inst0 (.A(A), .B(B), .Y1(Y1), .Y2(Y2), .Y3(Y3), .Y4(Y4)); // 실제회로와 테스트벤치 회로를 연결
initial begin
#1 A = 3`b111; B=3`b101; //1타임동안 A에 111, B에 101 대입
#1 A = 3`b101; B=3`b101; //다음 1타임동안 A에 101, B에 101 대입

#2 $stop; //순차적으로 실행되므로 4번째 타임에서 중지
end
endmodule
- reration.v 의 Wave

- reration.v 의 RTL Schematic

TimeScale
1
2
3
4
A
x
111
101
101
B
x
101
101
101
Y1 = A < B
x
0
0
0
Y2 = A <= B
x
0
1
1
Y3 = A > B
x
1
0
0
Y4 = A >= B
x
1
1
1

- 3번 comparison.v 코드

`timescale 1ns / 1ps // 시간 단위를 1ns = 1000ps으로 지정
module comparison(A, B, C, D, E, F, Y);
input [2:0] A, B, C, D, E, F; // 3비트 입력 A, B, C, D, E, F 선언
output Y; // 2비트 출력 Y 선언

reg Y; // Y를 레지스터로 선언

always@(A or B or C or D or E or F) // A또는 B또는 C또는 D또는 E또는 F에 변화가있을때마다
begin // 수행됨
if((A==B)&&((C>D)||!(E<=F))) // 조건 (A==B)&&((C>D)||!(E<=F))이
Y = 1; // 참이면 Y = 1
else
Y = 0; // 거짓이면 Y = 0
end
endmodule
- tb_comparison.v 코드

`timescale 1ns / 1ps // 시간 단위를 1ns = 1000ps으로 지정
module tb_comparison;
reg [2:0] A, B, C, D, E, F; // 3비트 신호 A, B, C, D, E, F를 레지스터 선언
wire Y; // Y를 wire로 선언

comparison inst0 (.A(A), .B(B), .C(C), .D(D), .E(E), .F(F), .Y(Y)); // 실제회로와 테스트벤치 회로를 연결
initial begin
#1 A = 3`b111; B = 3`b111; C = 3`b111; D= 3`b101; E = 3`b111; F = 3`b101;
// 1번째 타임에서 A에 111, B에 111, C에 111, D에 101, E에 111, F에 101을 대입
#1 A = 3`b101; B = 3`b111; C = 3`b011; D= 3`b101; E = 3`b101; F = 3`b111;
// 2번째 타임에서 A에 101, B에 111, C에 011, D에 101, E에 101, F에 111을 대입
#3 $stop; // 순차적으로 실행되므로 5번째 타임에서 중지
end
endmodule


☑ (A==B)&&((C>D)||!(E<=F))조건에서
1번째 타임의 (A==B)조건이 true이고 (C>D)가 true, !(E<=F) = (E>F)가 ture이므로 최종 결과가 true가 됨
2번째 타임에서 (A==B)조건은 false이므로 뒤의 상태와 상관없이 결과가 false가 됨
- comparison.v 의 Wave











TimeScale
1
2
3
4
5
A
x
111
101
101
101
B
x
111
111
111
111
C
x
111
011
011
011
D
x
101
101
101
101
E
x
111
101
101
101
F
x
101
111
111
111
Y
x
1
0
0
0
- comparison.v 의 RTL Schematic
- 4번 bitwise.v 코드

`timescale 1ns / 1ps
module bitwise(A, B, Y);
input [6:0] A; // 7비트 입력 A 선언
input [5:0] B; // 6비트 입력 B 선언
output [6:0] Y; // 7비트 출력 Y 선언

reg [6:0] Y; // Y 레지스터 선언

always@(A or B)
begin
Y[0] = A[0] & B[0]; //Binary AND // #1에서 1 & 1 = 1 #2에서 1 & 0 = 0
Y[1] = A[1] | B[1]; //Binary OR // #1에서 1 | 0 = 1 #2에서 1 | 0 = 1
Y[2] = !(A[2] & B[2]); //Negated NAD // #1에서 !(1 & 1) = 0 #2에서 !(1 & 0) = 1
Y[3] = !(A[3] | B[3]); //Negated OR // #1에서 !(0 | 0) = 1 #2에서 !(1 | 0) = 0
Y[4] = A[4] ^ B[4]; //Binary XOR(0110) // #1에서 1 ^ 1 = 0 #2에서 1 ^ 0 = 1
Y[5] = A[5] -^ B[5]; //Binary NXOR(1001) // #1에서 0 -^ 1 = 0 #2에서 1 -^ 0 = 0
Y[6] = !A[6]; //Unary negation // #1에서 !1 = 0 #2에서 !1 = 0
end // #1에서 Y = 0001011, #2에서 Y = 0010110
endmodule
- tb_bitwise.v 코드

`timescale 1ns / 1ps
module tb_bitwise;
reg [6:0] A; // A 레지스터 선언
reg [5:0] B; // B 레지스터 선언
wire [6:0] Y; // Y wire 선언

bitwise inst0 (.A(A), .B(B), .Y(Y));
initial
begin
#1 A = 7`b1010111; B = 6`b110101; // 1번째 타임에서 A에 1010111, B에 110101 대입
#1 A = 7`b1111111; B = 6`b000000; // 2번째 타임에서 A에 1111111, B에 000000 대입

#3 $stop; // 순차적으로 실행되므로 5번째 타임에서 정지
end
endmodule

- bitwise.v 의 Wave










- comparison.v 의 RTL Schematic


!A[6]
A[5]-^B[5]
A[4]^B[4]
!(A[3]|B[3])
!(A[2]&B[2])
A[1]|B[1]
A[0]&B[0]
#1
[6]
[5]
[4]
[3]
[2]
[1]
[0]
A
1
0
1
0
1
1
1
B
x
1
1
0
1
0
1
Y
0
0
0
1
0
1
1
#2
[6]
[5]
[4]
[3]
[2]
[1]
[0]
A
1
1
1
1
1
1
1
B
x
0
0
0
0
0
0
Y
0
0
1
0
1
1
0

- 5번 shift.v 코드

`timescale 1ns / 1ps
module shift (A, Y1, Y2);
input [7:0] A; // 8비트의 입력 A 선언
output [7:0] Y1, Y2; // 8비트의 출력 Y1, Y2 선언

parameter B = 3; // 상수를 선언해준다
reg [7:0] Y1, Y2; // Y1, Y2를 레지스터로 선언

always@(A) // A 비트에 변화가 생길때마다 실행
begin
Y1 = A << B; // A 비트를 왼쪽으로 3번 쉬프트하고 나머지를 0으로 채움
Y2 = A >> B; // A 비트를 오른쪽으로 3번 쉬프트하고 나머지를 0으로 채움
end
endmodule
- tb_shift.v 코드

`timescale 1ns / 1ps
module tb_shift;
reg [7:0] A; // A를 레지스터로 선언
wire [7:0] Y1, Y2; // Y1, Y2를 wire로 선언

shift inst0 (.A(A), .Y1(Y1), .Y2(Y2)); // 실제회로와 테스트벤치 회로를 연결
initial
begin
#1 A = 8`b11010111; // 1번째 타임에 A에 11010111 대입

#3 $stop; // 순차적으로 실행되므로 4번째 타임에서 중지
end
endmodule

- shift.v 의 Wave









- shift.v 의 RTL Schematic


shift
A
11010111
Y1(A<<B)
10111000
Y2(A>>B)
00011010

- 6번 reduction.v 코드

`timescale 1ns / 1ps
module reduction (A, Y1, Y2, Y3, Y4, Y5, Y6);
input [3:0] A; // 4비트 입력 A 선언
output Y1, Y2, Y3, Y4, Y5, Y6; // 출력 Y1, Y2, Y3, Y4, Y5, Y6 선언

reg Y1, Y2, Y3, Y4, Y5, Y6; // Y1, Y2, Y3, Y4, Y5, Y6 레지스터 선언

always@(A) // A값에 변화가 생길때마다 다음을 수행
begin
Y1 = & A; //Reduction AND // 모든입력이 1일 경우에만 1을 출력
Y2 = | A; //Reduction OR // 1이 적어도 1개 있을 경우 1을 출력
Y3 = ~& A; //Reduction NAND // 모든입력이 1일 경우에만 0을 출력
Y4 = ~| A; //Reduction NOR // 1이 하나도 없을 경우 1을 출력
Y5 = ^ A; //Reduction XOR // 입력이 모두 1일 경우 0을 출력
Y6 = ~^ A; //Reduction XNOR // 같은 비트가 나열될 경우 1을 출력
end

Y5 Y6




endmodule
- tb_reduction.v 코드

`timescale 1ns / 1ps
module tb_reduction;
reg [3:0] A;
wire Y1, Y2, Y3, Y4, Y5, Y6;

reduction inst0 (.A(A), .Y1(Y1), .Y2(Y2), .Y3(Y3), .Y4(Y4), .Y5(Y5), .Y6(Y6));
initial
begin
#1 A = 4`b1010; // 1번째 타임에 A에 1010 대입
#1 A = 4`b1111; // 2번째 타임에 A에 1111 대입

#3 $stop; // 순차적으로 진행되므로 5번째 타임에서 중지
end
endmodule

- reduction.v 의 Wave











- reduction.v 의 RTL Schematic



#1 A
Y
#2 A
Y

& A
Y1
1010
0
1111
1
모든입력1 = 1
| A
Y2
1010
1
1111
1
1이 적어도 1개 = 1
~& A
Y3
1010
1
1111
0
모든입력1 = 0
~| A
Y4
1010
0
1111
0
1이 하나도없을 경우 1
^ A
Y5
1010
0
1111
0

~^ A
Y6
1010
0
1111
0


- 7번 conditional.v 코드

`timescale 1ns / 1ps
module conditional(Time, Y);
input [2:0] Time; // 3비트 입력 Time 선언
output [2:0] Y; // 3비트 출력 Y 선언

reg [2:0] Y; // Y를 레지스터로 선언
parameter Zero = 3`b000; // 상수 Zero = 000 선언
parameter TimeOut = 3`b110; // 상수 TimeOut = 110 선언

always@(Time)
begin
Y = (Time != TimeOut) ? Time+1 : Zero; // ( Time != TimeOut ) 이 true이면 Y = Time + 1을
end // false이면 Y = Zero를 대입

if(Time != TimeOut)
Y = Time + 1;
else
Y = Zero;
ndmodule
- tb_conditional.v 코드

`timescale 1ns / 1ps
module tb_conditional;
reg [2:0] Time; // Time을 레지스터 선언
wire [2:0] Y; // Y를 wire 선언

conditional inst0 (.Time(Time), .Y(Y)); // 실제회로와 테스트벤치를 연결
initial
begin
#1 Time = 3`b000; // 첫 번째 타임에서 Time에 000 대입
#1 Time = 3`b010; // 두 번째 타임에서 Time에 010 대입
#1 Time = 3`b110; // 세 번째 타임에서 Time에 110 대입
#1 Time = 3`b100; // 네 번째 타임에서 Time에 100 대입
#1 Time = 3`b011; // 다섯 번째 타임에서 Time에 011 대입

#1 $stop; // 여섯 번째 타임에서 중지
end
endmodule
- conditional.v 의 Wave









- conditional.v 의 RTL Schematic

TimeScale
2
3
4
5
6
Time
000
010
110
100
011
TimeOut
110
110
110
110
110
Zero
000
000
000
000
000

Y = (Time != TimeOut) ? Time + 1 : Zero ;
True
✔
✔

✔
✔
False


✔


return
Y= Time+1
Y= Time+1
Y= Zero
Y= Time+1
Y= Time+1
Y
001
011
000
101
100

참고 자료

없음