hong.com

Final
- 2025-08-06
- 2025-08-07
- 2025-08-08
- 2025-08-11
- 2025-08-12
- 2025-08-13
- 2025-08-14
- 2025-08-18
- 2025-08-19
Project
- C Language
  - game instructions
- FFT
  - game instructions
Study
- C Language
- Linux
  - Day1
  - Day2
  - Day3
  - Day4
  - Day5
  - Day6
  - Day7
  - Day8
  - SKIN_Project copy
  - SKIN_Project
  - perceptron
- System Verilog
  - Day1
  - Day2
  - Day3
- VLSI Circuits Design
Home

Contact

Copyright © 2024 | Yankos

Home > Final

💖 星野アイ (◍•ᴗ•◍)♡ ✧*。

Final

2025-08-19
RISC-V I-TYPE Review funct3 를 통해 SLTI, SLTIU 구분 해야함 SLTI 경우 부호비트를 생각해서 늘려줘야 함 shift 는 전부 unsigned, 그래서 SLTIU 도 immExtend 에서 같이 처리 /*** immExtend ***/ `OP_TYPE_I: begin case (func3) 3'b001: immExt = {27'b0, instrCode[24:20]}; // SLLI 3'b011: immExt = {20'b0, instrCode[31:20]}; // SRLI, SRAI 3'b101: immExt = {27'b0, instrCode[24:20]}; // SLTIU default:immExt = {{20{instrCode[31]}}, instrCode[31:20]}; endcase end /*** ROM ***/ //rom[x]=32'b imm12 _ rs1 _f3 _ rd _ op // I-Type rom[6] = 32'b000000000001_00001_000_01001_0010011;// addi x9, x1, 1 rom[7] = 32'b000000000100_00010_111_01010_0010011;// andi x10, x2, 4 rom[8] = 32'b000000000001_00010_110_01011_0010011;// ori x11, x2, 1 rom[9] = 32'b000000000011_00001_001_01100_0010011;// slli x12, x1, 1 → 2b00001000 << 3 = 11 * 2^3 = 88 왼쪽 쉬프트: x « n = x × 2ⁿ 오른쪽 쉬프트: x » n = floor(x ÷ 2ⁿ) RISC-V B-TYPE 비교해서 점프하겠다. 결국 명령어의 주소를 바꾸겠다는 뜻. PC의 값을 바꾸면 나오는 명령어가 바뀜 = Branch (C언어: if, for, while, switch 등) (rs1, rs2로 연산하기 위해) ALU 안에 비교기 처리 /*** ControlUnit ***/ `OP_TYPE_B: aluControl = operator; /*** alu ***/ always_comb begin : branch btaken = 1'b0; case (aluControl[2:0]) `BEQ: btaken = (a == b); `BNE: btaken = (a != b); `BLT: btaken = ($signed(a) < $signed(b)); `BGE: btaken = ($signed(a) >= $signed(b)); `BLTU: btaken = (a < b); `BGEU: btaken = (a >= b); endcase end /*** DataPath ***/ logic [3:0] PC_4_AdderResult, PC_Imm_AdderResult, PCSrcMuxOut; logic PCSrcMuxSel; logic btaken; adder U_PC_Imm_Adder ( .a(immExt), .b(PCOutData), .y(PC_Imm_AdderResult) ); adder U_PC_4_Adder ( .a(32'd4), .b(PCOutData), .y(PC_4_AdderResult) ); assign PCSrcMuxSel = btaken & branch; mux_2x1 U_PCSrcMux ( .sel(PCSrcMuxSel), .x0 (PC_4_AdderResult), .x1 (PC_Imm_AdderResult), .y (PCSrcMuxOut) ); ROM[5] 참 -> rom[8] 점프 (20->32) /*** ROM ***/ //rom[x]=32'b imm7 _ rs2 _ rs1 _f3 _ imm5_ op // B-Type rom[5] = 32'b0000000_00010_00010_000_01100_1100011; // beq x2, x2, 12 //rom[x]=32'b imm12 _ rs1 _f3 _ rd _ op // L-Type rom[6] = 32'b000000001000_00000_010_01000_0000011; // lw x8, 8(x0) //rom[x]=32'b imm12 _ rs1 _f3 _ rd _ op // I-Type rom[7] = 32'b000000000001_00001_000_01001_0010011; // addi x9, x1, 1 rom[8] = 32'b000000000100_00010_111_01010_0010011; // andi x10, x2, 4 ROM[5] 거짓 -> rom[8] (20->24) /*** ROM ***/ //rom[x]=32'b imm7 _ rs2 _ rs1 _f3 _ imm5_ op // B-Type rom[5] = 32'b0000000_00010_00000_000_01100_1100011; // beq x2, x0, 12 //rom[x]=32'b imm12 _ rs1 _f3 _ rd _ op // L-Type rom[6] = 32'b000000001000_00000_010_01000_0000011; // lw x8, 8(x0) RISC-V TYPE C언어로 if문 해서 점프, 컴파일러에서 만들어줌 규칙성
Final · 2025-08-19
2025-08-18
RISC-V (RV32I Instruction Set) ‘R-Type’ RA1 : “Read Address 1” — 읽을 레지스터의 주소(번호). rs1(명령어 [19:15])가 들어감. 5비트. RA2 : “Read Address 2” — 읽을 레지스터의 주소(번호). rs2(명령어 [24:20])가 들어감. 5비트. WA : “Write Address” — 쓸 레지스터의 주소(번호). rd(명령어 [11:7]). 5비트. RD1 : “Read Data 1” — x[rs1]에서 읽혀 나온 데이터. ALU 피연산자 a로 연결. RD2 : “Read Data 2” — x[rs2]에서 읽혀 나온 데이터. ALU 피연산자 b로 연결. WD : “Write Data” — 쓸 데이터. R-type이면 보통 ALU 결과(aluResult). we : “Write Enable” — 클록 상승엣지에 we=1이면 x[WA] ← WD로 기록. Instruction Memory(ROM/Flash) : 명령어를 저장하고 PC가 지정한 주소의 명령어를 읽어준다. PC(Program Counter) : 현재 명령어의 주소를 보관하고 다음 주소(보통 PC+4 또는 분기/점프)를 제시한다. Control Unit : opcode(+funct3/7)를 해독해 ALU·레지스터·메모리·PC 제어 신호(aluControl 등)를 생성한다. 효율적이고 범용적인 명령어를 만들기 위해 교수님과 같이 R-Type 설계 I_Type과 동일한 funtion 부분이 몇 군데 보임 ControlUnit 에서 operator 값과 aluControl 신호가 동일하므로 R-Type 이면 aluControl = operator → 7’b0110011: aluControl = operator; 가독성을 높이기 위해 defines.sv 생성 → `include “defines.sv” S-Type (Store) 설계, RAM 필요 R-Type(산술/논리): 레지스터끼리만 연산해 결과를 다시 레지스터에 씀. 실행 중 “데이터 메모리”를 읽거나 쓰지 않음. 필요한 메모리는 명령을 읽어오는 Instruction Memory(보통 ROM/Flash)뿐. S-Type(Store): 레지스터 값을 데이터 메모리로 저장(쓰기) 해야 함. 실행 중 내용이 바뀌어야 하므로 쓰기 가능한 메모리(RAM)가 필수. S-Type Descript : Memory[주소] = Data ↔ M[rs1+imm] = rs2 (Memory[주소]=RAM, imm=상수) imm exted : 부호비트를 생각해서 처리, imm=opset 값, 해당 주소로부터 올라갈(+) 수도 있고 내려갈(-) 수도 있음, 비트부호 확장 필요, 최상위 비트를 20번 copy signals 늘어남에 따라 묶어줌. → {regFileWe, aluSrcMuxSel, busWe} = signals; // [2:0]signals L-Type I-Type
Final · 2025-08-18
2025-08-14
RISC-V Design RISC-V (리스크 파이브) 2010년부터 미국 UC 버클리에서 개발 중인 무료 오픈 소스 RISC 명령어셋 아키텍처 Base: RV32I Version: 2.0 1. Single-Cycle Architecture 모든 명령어가 1 clock에 동작 가장 시간이 오래 걸리는 명령어를 기준으로 클럭 주기를 설계해야 함 장점: 구조가 매우 단순함 단점: 전체 실행 속도가 느림 2. Multi-Cycle Architecture 명령어 유형(type)에 따라 필요한 clock 수가 다름 명령어에 따라 실행 시간을 단축할 수 있음 장점: Single-Cycle보다 빠름 단점: 구조가 다소 복잡함 구현 목표 ① Single-Cycle로 먼저 구현 및 이해 ② Multi-Cycle로 전환 + ARMA BUS + 주변장치(Peripherals) 연동 3. Pipeline Architecture (현재 구현 X) 장점: Single-Cycle보다 훨씬 빠름 단점: 구조가 매우 복잡함 x0 → zero : 항상 0 값을 가지는 레지스터 x1 → ra (Return Address) : 함수 호출 후 복귀 주소 저장 x2 → sp (Stack Pointer) : 스택의 최상단 주소 저장 x3 → gp (Global Pointer) : 전역 변수 접근용 포인터 … (이후 x31까지 각자 용도 지정) → 어셈블리어에서는 x0, x1 대신 zero, ra, sp, gp 등의 별칭(alias)으로 표기됨 CPU 기본 모듈 (하버드 구조) Register File → CPU 내부 레지스터 집합, 연산 및 데이터 임시 저장 ALU (Arithmetic Logic Unit) → 산술 및 논리 연산 수행 ROM / Flash (Instruction Memory) → 프로그램 명령어 저장 ※ ROM은 한 번 쓰면 지울 수 없으므로, 대부분 Flash 메모리(비휘발성) 사용 RAM (Data Memory) → 프로그램 실행 중 데이터 임시 저장 (휘발성) PC (Program Counter) → 현재 실행 중인 명령어의 주소를 가리키는 레지스터 Instruction, CPU, RAM 까지 Single-Cycle 구현 Peri는 Multi-Cycle 이후 구현 Block Diagram Signal 이해 Register Source 1 (5) : 5bit RS1 Register Source 2 (5) : 5bit RS2 Register Destination (5) : 5bit RD Opcode (7) : 7bit type 구분 Funct7 (7) : 7bit 연산 구분 Funct3 (3) : 3bit 연산 구분 ADD : rd(WAddr) = rs1(RA1) + rs2(RA2) / add : x7(rd), x5(rs1), x6(rs2) = x7 = x5(Data) + x6(Data) < Data Path > < Code : Data Path > `timescale 1ns / 1ps module DataPath ( input logic clk, input logic reset, input logic [31:0] instrCode, input logic regFileWe, input logic [ 1:0] aluControl, output logic [31:0] instrMemAddr ); logic [31:0] aluResult, RFData1, RFData2; logic [31:0] PCSrcData, PCOutData; assign instrMemAddr = PCOutData; RegisterFile U_RegFile ( .clk(clk), .we (regFileWe), .RA1(instrCode[19:15]), .RA2(instrCode[24:20]), .WA (instrCode[11:7]), .WD (aluResult), .RD1(RFData1), .RD2(RFData2) ); alu U_ALU ( .aluControl(aluControl), .a (RFData1), .b (RFData2), .result (aluResult) ); register U_PC ( .clk (clk), .reset(reset), .en (1'b1), .d (PCSrcData), .q (PCOutData) ); adder U_PC_Adder ( .a(32'd4), .b(PCOutData), .y(PCSrcData) ); endmodule module alu ( input logic [ 1:0] aluControl, input logic [31:0] a, input logic [31:0] b, output logic [31:0] result ); always_comb begin result = a + b; case (aluControl) 2'b00: result = a + b; 2'b01: result = a - b; 2'b10: result = a & b; 2'b11: result = a | b; endcase end endmodule module RegisterFile ( input logic clk, input logic we, input logic [ 4:0] RA1, input logic [ 4:0] RA2, input logic [ 4:0] WA, input logic [31:0] WD, output logic [31:0] RD1, output logic [31:0] RD2 ); logic [31:0] mem[0:2**5-1]; always_ff @(posedge clk) begin if (we) mem[WA] <= WD; end assign RD1 = (RA1 != 0) ? mem[RA1] : 32'b0; assign RD2 = (RA2 != 0) ? mem[RA2] : 32'b0; endmodule module register ( input logic clk, input logic reset, input logic en, input logic [31:0] d, output logic [31:0] q ); always_ff @(posedge clk, posedge reset) begin if (reset) begin q <= 0; end else begin if (en) q <= d; end end endmodule module adder ( input logic [31:0] a, input logic [31:0] b, output logic [31:0] y ); assign y = a + b; endmodule < Schematic : DataPath > < Code : Control Unit > `timescale 1ns / 1ps module ControlUnit ( input logic [31:0] instrCode, output logic regFileWe, output logic [ 1:0] aluControl ); // logic 은 선언하면서 연결이 안되기 때문에 wire 사용 (logic 사용시 assign 필요) wire [6:0] opcode = instrCode[6:0]; wire [3:0] operator = {instrCode[30], instrCode[14:12]}; always_comb begin regFileWe = 1'b0; case (opcode) 7'b0110011: regFileWe = 1'b1; endcase end always_comb begin aluControl = 2'bx; case (opcode) 7'b0110011: begin // R-Type aluControl = 2'bx; case (operator) 4'b0000: aluControl = 2'b00; // add 4'b1000: aluControl = 2'b01; // sub 4'b0111: aluControl = 2'b10; // and 4'b0110: aluControl = 2'b11; // or endcase end endcase end endmodule < Code : CPU_RV32I > `timescale 1ns / 1ps module CPU_RV32I ( input logic clk, input logic reset, input logic [31:0] instrCode, output logic [31:0] instrMemAddr ); logic regFileWe; logic [1:0] aluControl; ControlUnit U_ControlUnit (.*); DataPath U_DataPath (.*); endmodule < Schematic : CPU_RV32I > < Code : ROM > `timescale 1ns / 1ps module ROM ( input logic [31:0] addr, output logic [31:0] data ); logic [31:0] rom[0:61]; initial begin //rom[x]=32'b func7 _ rs2 _ rs1 _f3 _ rd _ op rom[0] = 32'b0000000_00001_00010_000_00100_0110011; // add x4, x2, x1 rom[1] = 32'b0100000_00001_00010_000_00101_0110011; // sub x5, x2, x1 rom[2] = 32'b0000000_00000_00011_111_00110_0110011; // and x6, x3, x0 rom[3] = 32'b0000000_00000_00011_110_00111_0110011; // or x7, x3, x0 end // 하위 2bit 를 없애면 4(2^2)의 배수로 표현이 됨, 4byte 단위로 이동 가능 assign data = rom[addr[31:2]]; endmodule < Code : MCU > `timescale 1ns / 1ps module MCU ( input logic clk, input logic reset ); logic [31:0] instrCode; logic [31:0] instrMemAddr; ROM U_ROM ( .addr(instrMemAddr), .data(instrCode) ); CPU_RV32I U_CPU_RV32I (.*); endmodule < Schematic : MCU > < Simulation > < 파일 > sources (Class) MCU.sv ROM.sv CPU_RV32I.sv ControlUnit.sv DataPath.sv sim (Class) RV32I_tb.sv HW < Design Specification > RISC-V RV32I R-Type 명령어 설계 < Code : DataPath (alu) > //... module alu ( input logic [ 3:0] aluControl, input logic [31:0] a, input logic [31:0] b, output logic [31:0] result ); always_comb begin result = 32'b0; case (aluControl) 4'b0000: result = a + b; 4'b0001: result = a - b; 4'b0010: result = a << b; 4'b0011: result = a >> b; 4'b0100: result = a >>> b; 4'b0101: result = ($signed(a) < $signed(b)) ? 1 : 0; 4'b0110: result = (a < b) ? 1 : 0; 4'b0111: result = a ^ b; 4'b1000: result = a | b; 4'b1001: result = a & b; endcase end endmodule //... < Code : ControlUnit > `timescale 1ns / 1ps module ControlUnit ( input logic [31:0] instrCode, output logic regFileWe, output logic [ 3:0] aluControl ); // logic 은 선언하면서 연결이 안되기 때문에 wire 사용 (logic 사용시 assign 필요) wire [6:0] opcode = instrCode[6:0]; wire [3:0] operator = {instrCode[30], instrCode[14:12]}; always_comb begin regFileWe = 1'b0; case (opcode) 7'b0110011: regFileWe = 1'b1; endcase end always_comb begin aluControl = 4'bx; case (opcode) 7'b0110011: begin // R-Type aluControl = 4'bx; case (operator) 4'b0000: aluControl = 4'b0000; // ADD 4'b1000: aluControl = 4'b0001; // SUB 4'b0001: aluControl = 4'b0010; // SLL 4'b0101: aluControl = 4'b0011; // SRL 4'b1101: aluControl = 4'b0100; // SRA 4'b0010: aluControl = 4'b0101; // SLT 4'b0011: aluControl = 4'b0110; // SLTU 4'b0100: aluControl = 4'b0111; // XOR 4'b0110: aluControl = 4'b1000; // OR 4'b0111: aluControl = 4'b1001; // AND endcase end endcase end endmodule < Code : ROM > `timescale 1ns / 1ps module ROM ( input logic [31:0] addr, output logic [31:0] data ); logic [31:0] rom[0:61]; initial begin //rom[x]=32'b func7 _ rs2 _ rs1 _f3 _ rd _ op rom[0] = 32'b0000000_00010_00001_000_00011_0110011; // add x3, x1, x2 rom[1] = 32'b0100000_00010_00001_000_00011_0110011; // sub x3, x1, x2 rom[2] = 32'b0000000_00010_00001_001_00011_0110011; // sll x3, x1, x2 rom[3] = 32'b0000000_00010_00001_101_00011_0110011; // srl x3, x1, x2 rom[4] = 32'b0100000_00010_00001_101_00011_0110011; // sra x3, x1, x2 rom[5] = 32'b0000000_00010_00001_010_00011_0110011; // slt x3, x1, x2 rom[6] = 32'b0000000_00010_00001_011_00011_0110011; // sltu x3, x1, x2 rom[7] = 32'b0000000_00010_00001_100_00011_0110011; // xor x3, x1, x2 rom[8] = 32'b0000000_00010_00001_110_00011_0110011; // or x3, x1, x2 rom[9] = 32'b0000000_00010_00001_111_00011_0110011; // and x3, x1, x2 end // 하위 2bit 를 없애면 4(2^2)의 배수로 표현이 됨, 4byte 단위로 이동 가능 assign data = rom[addr[31:2]]; endmodule < Simulation > < 파일 > sources (HW) MCU ROM CPU_RV32I ControlUnit DataPath sim (HW) RV32I_tb
Final · 2025-08-14
2025-08-13
📌 직무분석 방법 본인의 직무선택 기준과 선택 직무의 구체적 역할 및 필요 역량 확인 지원 직무 수행에 필요한 본인이 준비한 역량 파악 직무 수행에 있어 가장 부족한 역량 확인 부족한 역량 보완을 위한 노력 계획 및 입사 후 포부 작성 KSA 분석 해당 직무에 필요한 지식(K), 기술(S), 태도(A) 기술 위주의 팀플 경험 기재 구조 예시 : 하는 일 → 필요한 KSA → 자신이 보유한 KSA → 근거 사례 → 미보유 KSA → 보유 계획 작성 유의사항 겸손 X / 강점 역량 O 사례를 통한 입증 팀 단위의 직무 관련 경험 강조 (팀원과의 불화 없음을 간접적으로 전달) 📌 구체적인 직무분석 방법 1.고용24 + NCS 직업정보, 평가기준, 직무기술서 확인 2.기업 홈페이지 직무소개 페이지, 회사 공식 정보 3.동영상 채널 현직자 인터뷰, 업계 근황 4.취업포털 사이트 자소설, 사람인(현직자 인터뷰, 7~10년차 경력자 역량 참고), 잡코리아, 잡플래닛 5.직무 관련 커뮤니티 블라인드, 코멘토, 잇다 6.기타 산업기사 자격증이 있다면 실제 기사와 매칭 후 견해 반영 포트폴리오·면접 중요성 상승 📌 직무분석 구조 예시 기업 기본정보 비전, 미션, 전략 비전 수립 이유, 실천 사례 회사개요, 창업이념, 경영화두, CEO 인사말, 신년사, 기업 SNS, 사보 → “그 미션을 함께 수행하기 위해 지원함” 인재상·핵심가치 기업의 인재상 정의 및 재해석 해당 인재상이 필요한 이유 이해 사업현황 수익 구조, 아이템, 매출·영업이익 추진과제 산업 경쟁요소 기준 강점·약점 분석 장기 발전 가능성, 최신 이슈, 지원 정보 신년사에서 키워드 활용 Note: 자소서는 1·2번까지만, 면접은 4개 전부 준비 📌 기업 분석 필수 자료 기업 홈페이지 회사소개, 연혁, 경영이념, 인재상, 비전·미션, 제품·서비스, 브랜드, 사내소식 최근 보도자료 신규사업, 중점사업, 업계 이슈, 신년사 사업목표 DART(사업보고서) 사업규모, 전략, 재무현황 사업소개, 분기보고서, 재무제표, 매출·순이익·증가율 파악 추가 참고 구글 기업사업보고서, IR홍보자료 중소기업: 기술로드맵, 현황 정보시스템, 나이스 기업정보, 한국기업평가 📌 산업분석 주요 산업과 이슈의 맥락 파악 공기업 참고 사이트: ALIO, 디베이팅 데이, 잡플래닛 (자기 기준 설정), DBR 📌 입사지원서 작성 포인트 직무 경험과 KSA 분석 반영 회사 맞춤형 스토리 애매한 이력서 → 서류 탈락 위험 포트폴리오: 그림 위주, 간결하게 작성 전 점검사항 필수분석 여부 강점/경험 정리 직무적합성(제3자 관점 검토) 지나친 겸손 X / 적절한 어필 O 단점 불필요 노출 📌 이력서 팁(KDT) 주소: 도로명까지만 학력: 최근 졸업 2개만 자격사항: 중요도 순 기재 📌 자소서 작성 흐름 직무 파악 필요한 역량 분석 해당 역량 정리 경험 사례 정리 항목별 배치 KSA 우선순위 고려 작성 요령 인사담당자 관점 객관화·수치화 두괄식 → 결론(강점) → 본론(STAR) → 결론 📌 자소서 기본 구성 성장과정: 직무에 맞는 성향 성격소개: 강점 + 보완 노력 직무경험: 역할, 역량 향상, 배운 점 지원동기·포부: 산업 특성·이슈, 회사 방향, 직무 필요성, 적합성, 향후 계획
Final · 2025-08-13
2025-08-12
Dedicated Processor Sum Counter Design < C언어 > i = 0; sum = 0; while (i <= 10) { sum = sum + i i = i + 1; outport = sum; } halt; < Design Specification > i 저장 → Register 1개 sum 저장할 → Register 1개 출력을 저장할 → Register 1게 while 문 → Comparator 덧셈 연산 → Adder < Data Path > < ASM > < Code : DataPath > `timescale 1ns / 1ps module DataPath ( input logic clk, input logic reset, input logic SumSrcMuxSel, input logic ISrcMuxSel, input logic SumEn, input logic IEn, input logic AdderSrcMuxSel, input logic OutPortEn, output logic ILe10, output logic [7:0] OutPort ); logic [7:0] SumSrcMuxOut, ISrcMuxOut; logic [7:0] SumRegOut, IRegOut; logic [7:0] AdderResult, AdderSrcMuxOut; Mux_2x1 U_SumSrcMux ( .sel(SumSrcMuxSel), .x0 (0), .x1 (AdderResult), .y (SumSrcMuxOut) ); Mux_2x1 U_ISrcMux ( .sel(ISrcMuxSel), .x0 (0), .x1 (AdderResult), .y (ISrcMuxOut) ); Register U_SumReg ( .clk (clk), .reset(reset), .en (SumEn), .d (SumSrcMuxOut), .q (SumRegOut) ); Register U_IReg ( .clk (clk), .reset(reset), .en (IEn), .d (ISrcMuxOut), .q (IRegOut) ); Comparator U_ILe10 ( .a (IRegOut), .b (10), .lt(ILe10) ); Mux_2x1 U_AdderSrcMux ( .sel(AdderSrcMuxSel), .x0 (SumRegOut), .x1 (1), .y (AdderSrcMuxOut) ); Adder U_Adder ( .a (AdderSrcMuxOut), .b (IRegOut), .sum(AdderResult) ); Register U_OutPort ( .clk (clk), .reset(reset), .en (OutPortEn), .d (SumRegOut), .q (OutPort) ); endmodule module Register ( input logic clk, input logic reset, input logic en, input logic [7:0] d, output logic [7:0] q ); always_ff @(posedge clk, posedge reset) begin if (reset) begin q <= 0; end else begin if (en) begin q <= d; end end end endmodule module Mux_2x1 ( input logic sel, input logic [7:0] x0, input logic [7:0] x1, output logic [7:0] y ); always_comb begin y = 8'b0; case (sel) 1'b0: y = x0; 1'b1: y = x1; endcase end endmodule module Adder ( input logic [7:0] a, input logic [7:0] b, output logic [7:0] sum ); assign sum = a + b; endmodule module Comparator ( input logic [7:0] a, input logic [7:0] b, output logic lt ); assign lt = a < b; endmodule module OutBuf ( input logic en, input logic [7:0] x, output logic [7:0] y ); assign y = en ? x : 8'bx; endmodule < Schematic > < Code : ControlUnit > `timescale 1ns / 1ps module ControlUnit ( input logic clk, input logic reset, input logic ILe10, output logic SumSrcMuxSel, output logic ISrcMuxSel, output logic SumEn, output logic IEn, output logic AdderSrcMuxSel, output logic OutPortEn ); typedef enum { S0, S1, S2, S3, S4, S5 } state_e; state_e state, next_state; always_ff @(posedge clk, posedge reset) begin if (reset) begin state <= S0; end else begin state <= next_state; end end always_comb begin next_state = state; SumSrcMuxSel = 0; ISrcMuxSel = 0; SumEn = 0; IEn = 0; AdderSrcMuxSel = 0; OutPortEn = 0; case (state) S0: begin // i = 0, sum = 0 SumSrcMuxSel = 0; ISrcMuxSel = 0; SumEn = 1; IEn = 1; AdderSrcMuxSel = 0; // X OutPortEn = 0; next_state = S1; end S1: begin // iLe10 SumSrcMuxSel = 0; ISrcMuxSel = 0; SumEn = 0; IEn = 0; AdderSrcMuxSel = 0; OutPortEn = 0; if (ILe10) next_state = S2; else next_state = S5; end S2: begin // sum = sum + i SumSrcMuxSel = 1; ISrcMuxSel = 1; SumEn = 1; IEn = 0; AdderSrcMuxSel = 0; OutPortEn = 0; next_state = S3; end S3: begin // i = i + 1 SumSrcMuxSel = 1; ISrcMuxSel = 1; SumEn = 0; IEn = 1; AdderSrcMuxSel = 1; OutPortEn = 0; next_state = S4; end S4: begin // OutPort = sum SumSrcMuxSel = 1; ISrcMuxSel = 1; SumEn = 0; IEn = 0; AdderSrcMuxSel = 0; OutPortEn = 1; next_state = S1; end S5: begin // halt SumSrcMuxSel = 1; ISrcMuxSel = 1; SumEn = 0; IEn = 0; AdderSrcMuxSel = 0; OutPortEn = 0; next_state = S5; end endcase end endmodule < Code : DedicatedProcessor > `timescale 1ns / 1ps module DedicatedProcessor ( input logic clk, input logic reset, output logic [7:0] OutPort ); logic SumSrcMuxSel; logic ISrcMuxSel; logic SumEn; logic IEn; logic AdderSrcMuxSel; logic OutPortEn; logic ILe10; DataPath U_DataPath (.*); ControlUnit U_ControlUnit (.*); endmodule < Comment > IReg와 SumReg 두 개의 레지스터로 각각 i 값과 누적합(sum)을 저장한다. OutPort 레지스터는 최종 출력값을 클럭 경계에서 안정적으로 내보낸다. 각 연산에 필요한 피연산자 선택은 MUX를 통해 이루어지며, 하나의 Adder를 공유한다. Comparator(ILe10)는 i ≤ 10 조건을 하드웨어 신호로 변환해 Control Unit이 루프 종료를 판단하도록 한다. < 고찰 > 하나의 Adder로 두 연산을 번갈아 처리하므로 하드웨어 자원 절약 MUX와 Enable 신호로 동작 타이밍과 데이터 경로를 완전히 제어 가능 < Simulation > < Code : top > `timescale 1ns / 1ps module top ( input logic clk, input logic reset, output logic [3:0] fndCom, output logic [7:0] fndFont ); logic clk_10hz; logic [7:0] OutPort; clk_div_10hz U_ClkDiv ( .clk (clk), .reset (reset), .clk_10hz(clk_10hz) ); DedicatedProcessor U_DedicatedProcessor ( .clk (clk_10hz), .reset (reset), .OutPort(OutPort) ); fndController U_FndController ( .clk (clk), .reset (reset), .number ({6'b0, OutPort}), .fndCom (fndCom), .fndFont(fndFont) ); endmodule module clk_div_10hz ( input logic clk, input logic reset, output logic clk_10hz ); //logic [23:0] div_counter; logic [$clog2(10_000_000)-1:0] div_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin div_counter <= 0; clk_10hz <= 1'b0; end else begin if (div_counter == 10_000_000 - 1) begin div_counter <= 0; clk_10hz <= 1'b1; end else begin div_counter <= div_counter + 1; clk_10hz <= 1'b0; end end end endmodule < Schematic > < 파일 > sources (Class) top.sv DedicatedProcessor.sv DataPath.sv ControlUnit.sv fndController.sv simulation (Class) DedicatedProcessor_tb.sv constrs (Class) Basys-3-Master.xdc Register File Design < Design Specification > 데이터 출력: 2개의 Read Port(RD1, RD2)를 통해 ALU로 데이터 전달 주소 지정: 각 Read Port는 별도의 Read Address 입력을 가짐 예: RD1 주소 입력에 0을 주면, 레지스터 0번 데이터 출력 RD2 주소 입력에 2를 주면, 레지스터 2번 데이터 출력 데이터 쓰기: Write Address 입력에 저장할 레지스터 번호 지정 write_en 신호를 1로 하고 클럭 엣지에 맞춰 데이터 저장 예: Write Address = 3, write_en = 1 → 레지스터 3번에 데이터 저장 출력 특성: 별도의 read_enable 없이, 주소가 유효하면 항상 해당 데이터 출력 주소 변경 시 즉시 해당 레지스터 값 출력 < C언어 > R1 = 0; // i R2 = 0; // sum R3 = 1; while (R1 <= 10) { R2 = R2 + R1 R1 = R1 + R3; outport = R2; } halt; < Data Path > < Code : DataPath > `timescale 1ns / 1ps module DataPath ( input logic clk, input logic reset, input logic RFSrcMuxSel, input logic [2:0] RAddr1, input logic [2:0] RAddr2, input logic [2:0] WAddr, input logic we, input logic OutPortEn, output logic R1Le10, output logic [7:0] OutPort ); logic [7:0] AddrResult, RFSrcMuxOut; logic [7:0] RData1, RData2; Mux_2x1 U_RFSrcMux ( .sel(RFSrcMuxSel), .x0 (AddrResult), .x1 (8'b1), .y (RFSrcMuxOut) ); RegFile U_RegFile ( .clk (clk), .RAddr1(RAddr1), .RAddr2(RAddr2), .WAddr (WAddr), .we (we), .Wdata (RFSrcMuxOut), .RData1(RData1), .RData2(RData2) ); Comparator U_R1Le10 ( .a (RData1), .b (8'd10), .lte(R1Le10) ); Adder U_Adder ( .a (RData1), .b (RData2), .sum(AddrResult) ); Register U_Register ( .clk (clk), .reset(reset), .en (OutPortEn), .d (RData1), .q (OutPort) ); endmodule module RegFile ( input logic clk, input logic [2:0] RAddr1, input logic [2:0] RAddr2, input logic [2:0] WAddr, input logic we, input logic [7:0] Wdata, output logic [7:0] RData1, output logic [7:0] RData2 ); logic [7:0] mem[0:2**3-1]; // [0:2**(Number of addresses)-1] always_ff @(posedge clk) begin if (we) begin mem[WAddr] <= Wdata; end end assign RData1 = (RAddr1 == 0) ? 8'b0 : mem[RAddr1]; assign RData2 = (RAddr2 == 0) ? 8'b0 : mem[RAddr2]; endmodule module Register ( input logic clk, input logic reset, input logic en, input logic [7:0] d, output logic [7:0] q ); always_ff @(posedge clk, posedge reset) begin if (reset) begin q <= 0; end else begin if (en) begin q <= d; end end end endmodule module Mux_2x1 ( input logic sel, input logic [7:0] x0, input logic [7:0] x1, output logic [7:0] y ); always_comb begin y = 8'b0; case (sel) 1'b0: y = x0; 1'b1: y = x1; endcase end endmodule module Adder ( input logic [7:0] a, input logic [7:0] b, output logic [7:0] sum ); assign sum = a + b; endmodule module Comparator ( input logic [7:0] a, input logic [7:0] b, output logic lte ); assign lte = a <= b; endmodule < Schematic > Homework_1 < Design Specification > Register File 의 Data Path 이어서 ControlUnit, DedicatedProcessor 설계 동작: RegisterFile 을 이용하여 0 ~ 10 누적 합을 fnd에 출력 < ASM > < Code : ControlUnit > `timescale 1ns / 1ps module ControlUnit ( input logic clk, input logic reset, input logic R1Le10, output logic RFSrcMuxSel, output logic [2:0] RAddr1, output logic [2:0] RAddr2, output logic [2:0] WAddr, output logic we, output logic OutPortEn ); typedef enum { S0, S1, S2, S3, S4, S5, S6, S7 } state_e; state_e state, next_state; always_ff @(posedge clk, posedge reset) begin if (reset) begin state <= S0; end else begin state <= next_state; end end always_comb begin next_state = state; RFSrcMuxSel = 0; RAddr1 = 0; RAddr2 = 0; WAddr = 0; we = 0; OutPortEn = 0; case (state) S0: begin RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd1; we = 1; OutPortEn = 0; next_state = S1; end S1: begin RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd2; we = 1; OutPortEn = 0; next_state = S2; end S2: begin RFSrcMuxSel = 1; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd3; we = 1; OutPortEn = 0; next_state = S3; end S3: begin RFSrcMuxSel = 0; RAddr1 = 4'd1; RAddr2 = 4'd0; WAddr = 4'd0; we = 0; OutPortEn = 0; if (R1Le10) next_state = S4; else next_state = S7; end S4: begin RFSrcMuxSel = 0; RAddr1 = 4'd1; RAddr2 = 4'd2; WAddr = 4'd2; we = 1; OutPortEn = 0; next_state = S5; end S5: begin RFSrcMuxSel = 0; RAddr1 = 4'd1; RAddr2 = 4'd3; WAddr = 4'd1; we = 1; OutPortEn = 0; next_state = S6; end S6: begin RFSrcMuxSel = 0; RAddr1 = 4'd2; RAddr2 = 4'd0; WAddr = 4'd0; we = 0; OutPortEn = 1; next_state = S3; end S7: begin RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd0; we = 0; OutPortEn = 0; next_state = S7; end endcase end endmodule < Code : DedicatedProcessor > `timescale 1ns / 1ps module DedicatedProcessor ( input logic clk, input logic reset, output logic [7:0] OutPort ); logic RFSrcMuxSel; logic [2:0] RAddr1; logic [2:0] RAddr2; logic [2:0] WAddr; logic we; logic OutPortEn; logic R1Le10; DataPath U_DataPath (.*); ControlUnit U_ControlUnit (.*); endmodule < Commnet > RegFile에 i, sum, (필요 시) 상수 레지스터를 배치하고, RAddr1/2로 두 피연산자를 선택, WAddr로 연산 결과의 목적지를 지정한다. RFSrcMux는 연산 결과(AddrResult) 또는 즉치값 1 중 하나를 Wdata로 선택해 초기화/증가를 모두 하나의 Adder로 처리할 수 있게 한다. OutPort는 RData1을 샘플/홀드하여 외부로 안정적으로 출력한다(Enable로 출력 타이밍 제어). < 고찰 > 유연성: 주소만 바꿔 i, sum, 상수 등 다양한 조합을 같은 하드웨어로 처리 자원 공유: Adder 1개로 증가와 누적을 모두 수행 → 면적 절약 가독성/확장성: 상수 0은 주소 0로, 상수 1은 한 번 기록 후 재사용하는 패턴으로 컨트롤이 단순 < Video > < 파일 > sources (Homework) top.sv ControlUnit.sv DataPath.sv DedicatedProcessor.sv fndController.sv constrs (Homework) Basys-3-Master.xdc Homework_2 < Design Specification > ALU를 만들어 DedicatedProcessor 설계 R1 = 1, R2 = 0, R3 = 0, R4 = 0 R2 = R1 + R1 R3 = R2 + R1 R4 = R3 - R1 R1 = R1 | R2 R4 < R2; // Yes: R4 = R3 - R1; // No: R4 = R4 & R3; R4 = R4 & R3 R4 = R2 + R3 R2 < R4 // Yes: R2 = R1 + R1; // No: hlat hlat < Data Path > < ASM > < Code : ControlUnit > `timescale 1ns / 1ps module ControlUnit ( input logic clk, input logic reset, input logic lte, output logic RFSrcMuxSel, output logic [2:0] RAddr1, output logic [2:0] RAddr2, output logic [2:0] WAddr, output logic we, output logic OutPortEn, output logic [1:0] ALUop ); typedef enum { S0, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13 } state_e; state_e state, next_state; always_ff @(posedge clk, posedge reset) begin if (reset) begin state <= S0; end else begin state <= next_state; end end always_comb begin next_state = state; RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd0; we = 0; OutPortEn = 0; ALUop = 4'd0; case (state) S0: begin // R1 = 1 RFSrcMuxSel = 1; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd1; we = 1; OutPortEn = 0; ALUop = 4'd0; next_state = S1; end S1: begin // R2 = 0 RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd2; we = 1; OutPortEn = 0; ALUop = 4'd0; next_state = S2; end S2: begin // R3 = 0 RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd3; we = 1; OutPortEn = 0; ALUop = 4'd0; next_state = S3; end S3: begin // R4 = 0 RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd4; we = 1; OutPortEn = 0; ALUop = 4'd0; next_state = S4; end S4: begin // R2 = R1 + R1 RFSrcMuxSel = 0; RAddr1 = 4'd1; RAddr2 = 4'd1; WAddr = 4'd2; we = 1; OutPortEn = 0; ALUop = 4'd0; next_state = S5; end S5: begin // R3 = R2 + R1 RFSrcMuxSel = 0; RAddr1 = 4'd2; RAddr2 = 4'd1; WAddr = 4'd3; we = 1; OutPortEn = 0; ALUop = 4'd0; next_state = S6; end S6: begin // R4 = R3 = R1 RFSrcMuxSel = 0; RAddr1 = 4'd3; RAddr2 = 4'd1; WAddr = 4'd4; we = 1; OutPortEn = 0; ALUop = 4'd1; next_state = S7; end S7: begin // R1 = R1 | R2 RFSrcMuxSel = 0; RAddr1 = 4'd1; RAddr2 = 4'd2; WAddr = 4'd1; we = 1; OutPortEn = 0; ALUop = 4'd3; next_state = S8; end S8: begin // R4 < R2 RFSrcMuxSel = 0; RAddr1 = 4'd4; RAddr2 = 4'd2; WAddr = 4'd0; we = 0; OutPortEn = 0; ALUop = 4'd0; if (lte) next_state = S5; else next_state = S9; end S9: begin // R4 = R4 & R3 RFSrcMuxSel = 0; RAddr1 = 4'd4; RAddr2 = 4'd3; WAddr = 4'd4; we = 1; OutPortEn = 0; ALUop = 4'd2; next_state = S10; end S10: begin // R4 = R2 + R3 RFSrcMuxSel = 0; RAddr1 = 4'd2; RAddr2 = 4'd3; WAddr = 4'd4; we = 1; OutPortEn = 0; ALUop = 4'd0; next_state = S11; end S11: begin // OutProt = R4 RFSrcMuxSel = 0; RAddr1 = 4'd4; RAddr2 = 4'd0; WAddr = 4'd0; we = 0; OutPortEn = 1; ALUop = 4'd0; next_state = S12; end S12: begin // R2 < R4 RFSrcMuxSel = 0; RAddr1 = 4'd2; RAddr2 = 4'd4; WAddr = 4'd0; we = 0; OutPortEn = 0; ALUop = 4'd0; if (lte) next_state = S4; else next_state = S13; end S13: begin // half RFSrcMuxSel = 0; RAddr1 = 4'd0; RAddr2 = 4'd0; WAddr = 4'd0; we = 0; OutPortEn = 0; ALUop = 4'd0; next_state = S13; end endcase end endmodule < Code : Data Path > //... module ALU ( input logic [1:0] sel, input logic [7:0] a, input logic [7:0] b, output logic [7:0] alu_result ); always_comb begin alu_result = a + b; case (sel) 2'd0: alu_result = a + b; 2'd1: alu_result = a - b; 2'd2: alu_result = a & b; 2'd3: alu_result = a | b; endcase end endmodule //... < Schematic > < Comment > 반복별 레지스터 값 1회: R1=3, R2=2, R3=3, R4=5 → Yes 2회: R1=7, R2=6, R3=9, R4=15 → Yes 3회: R1=15, R2=14, R3=21, R4=35 → Yes 4회: R1=31, R2=30, R3=45, R4=75 → Yes 5회: R1=63, R2=62, R3=93, R4=155 → Yes 6회: R1=127, R2=126, R3=189, R4=59 → No ⇒ halt 첫 번째 반복 시작 값: (R1, R2, R3, R4) = (1, 0, 0, 0) 계산 순서: R2 = R1 + R1 (1 + 1 = 2) ➞ (1, 2, 0, 0) R3 = R2 + R1 (2 + 1 = 3) ➞ (1, 2, 3, 0) R4 = R3 - R1 (3 - 1 = 2) ➞ (1, 2, 3, 2) R1 = R1 | R2 (1 | 2 = 3) ➞ (3, 2, 3, 2) R4 = R4 & R3 (2 & 3 = 2) ➞ (3, 2, 3, 2) R4 = R2 + R3 (2 + 3 = 5) ➞ (3, 2, 3, 5) 조건 확인: R4 > R2 (5 > 2) ➞ Yes, 계속 진행 두 번째 반복 시작 값: (R1, R2, R3, R4) = (3, 2, 3, 5) 계산 순서: R2 = R1 + R1 (3 + 3 = 6) ➞ (3, 6, 3, 5) R3 = R2 + R1 (6 + 3 = 9) ➞ (3, 6, 9, 5) R4 = R3 - R1 (9 - 3 = 6) ➞ (3, 6, 9, 6) R1 = R1 | R2 (3 | 6 = 7) ➞ (7, 6, 9, 6) R4 = R4 & R3 (6 & 9 = 0) ➞ (7, 6, 9, 0) R4 = R2 + R3 (6 + 9 = 15) ➞ (7, 6, 9, 15) 조건 확인: R4 > R2 (15 > 6) ➞ Yes, 계속 진행 세 번째 반복 시작 값: (R1, R2, R3, R4) = (7, 6, 9, 15) 계산 순서: R2 = R1 + R1 (7 + 7 = 14) ➞ (7, 14, 9, 15) R3 = R2 + R1 (14 + 7 = 21) ➞ (7, 14, 21, 15) R4 = R3 - R1 (21 - 7 = 14) ➞ (7, 14, 21, 14) R1 = R1 | R2 (7 | 14 = 15) ➞ (15, 14, 21, 14) R4 = R4 & R3 (14 & 21 = 4) ➞ (15, 14, 21, 4) R4 = R2 + R3 (14 + 21 = 35) ➞ (15, 14, 21, 35) 조건 확인: R4 > R2 (35 > 14) ➞ Yes, 계속 진행 네 번째 반복 시작 값: (R1, R2, R3, R4) = (15, 14, 21, 35) 계산 순서: R2 = R1 + R1 (15 + 15 = 30) ➞ (15, 30, 21, 35) R3 = R2 + R1 (30 + 15 = 45) ➞ (15, 30, 45, 35) R4 = R3 - R1 (45 - 15 = 30) ➞ (15, 30, 45, 30) R1 = R1 | R2 (15 | 30 = 31) ➞ (31, 30, 45, 30) R4 = R4 & R3 (30 & 45 = 12) ➞ (31, 30, 45, 12) R4 = R2 + R3 (30 + 45 = 75) ➞ (31, 30, 45, 75) 조건 확인: R4 > R2 (75 > 30) ➞ Yes, 계속 진행 다섯 번째 반복 시작 값: (R1, R2, R3, R4) = (31, 30, 45, 75) 계산 순서: R2 = R1 + R1 (31 + 31 = 62) ➞ (31, 62, 45, 75) R3 = R2 + R1 (62 + 31 = 93) ➞ (31, 62, 93, 75) R4 = R3 - R1 (93 - 31 = 62) ➞ (31, 62, 93, 62) R1 = R1 | R2 (31 | 62 = 63) ➞ (63, 62, 93, 62) R4 = R4 & R3 (62 & 93 = 28) ➞ (63, 62, 93, 28) R4 = R2 + R3 (62 + 93 = 155) ➞ (63, 62, 93, 155) 조건 확인: R4 > R2 (155 > 62) ➞ Yes, 계속 진행 여섯 번째 반복 (마지막) 시작 값: (R1, R2, R3, R4) = (63, 62, 93, 155) 계산 순서 R2 = R1 + R1 (63 + 63 = 126) ➞ (63, 126, 93, 155) R3 = R2 + R1 (126 + 63 = 189) ➞ (63, 126, 189, 155) R4 = R3 - R1 (189 - 63 = 126) ➞ (63, 126, 189, 126) R1 = R1 | R2 (63 | 126 = 127) ➞ (127, 126, 189, 126) R4 = R4 & R3 (126 & 189 = 120) ➞ (127, 126, 189, 120) R4 = R2 + R3 (126 + 189 = 315) ➞ (127, 126, 189, 59) 조건 확인: R4 > R2 (59 > 126) ➞ No, 중단 (Halt) 8bit Wrapping (오버플로우): 8비트 레지스터는 255까지만 표현 가능하므로, 315는 256을 뺀 나머지 값인 59가 된다. < 파일 > sources (Homework) ControlUnit.sv DataPath.sv DedicatedProcessor.sv simulation (Homework) DedicatedProcessor_tb.sv
Final · 2025-08-12
2025-08-11
Uart + UpDownCounter Design < Block Design > < Code : uart > `timescale 1ns / 1ps module uart ( // global signal input logic clk, input logic reset, // transmitter signal input logic start, input logic [7:0] tx_data, output logic tx_busy, output logic tx_done, output logic tx, // receiver signal output logic [7:0] rx_data, output logic rx_done, input logic rx ); logic br_tick; baudrate_gen U_BRAUD_GEN ( .clk (clk), .reset (reset), .br_tick(br_tick) ); transmitter U_Transmitter ( .clk (clk), .reset (reset), .br_tick(br_tick), .start (start), .tx_data(tx_data), .tx_busy(tx_busy), .tx_done(tx_done), .tx (tx) ); receiver U_Receiver ( .clk (clk), .reset (reset), .br_tick(br_tick), .rx_data(rx_data), .rx_done(rx_done), .rx (rx) ); endmodule module baudrate_gen ( input logic clk, input logic reset, output logic br_tick ); logic [$clog2(100_000_000 / 9600 / 16)-1:0] br_counter; //logic [3:0] br_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin br_counter <= 0; br_tick <= 1'b0; end else begin if (br_counter == 100_000_000 / 9600 / 16 - 1) begin //if (br_counter == 10 - 1) begin br_counter <= 0; br_tick <= 1'b1; end else begin br_counter <= br_counter + 1; br_tick <= 1'b0; end end end endmodule module transmitter ( input logic clk, input logic reset, input logic br_tick, input logic start, input logic [7:0] tx_data, output logic tx_busy, output logic tx_done, output logic tx ); typedef enum { IDLE, START, DATA, STOP } tx_state_e; tx_state_e tx_state, tx_next_state; logic [7:0] temp_data_reg, temp_data_next; logic tx_reg, tx_next; logic [3:0] tick_cnt_reg, tick_cnt_next; logic [2:0] bit_cnt_reg, bit_cnt_next; logic tx_done_reg, tx_done_next; logic tx_busy_reg, tx_busy_next; assign tx = tx_reg; assign tx_busy = tx_busy_reg; assign tx_done = tx_done_reg; always_ff @(posedge clk, posedge reset) begin if (reset) begin tx_state <= IDLE; temp_data_reg <= 0; tx_reg <= 1'b1; tick_cnt_reg <= 0; bit_cnt_reg <= 0; tx_done_reg <= 0; tx_busy_reg <= 0; end else begin tx_state <= tx_next_state; temp_data_reg <= temp_data_next; tx_reg <= tx_next; tick_cnt_reg <= tick_cnt_next; bit_cnt_reg <= bit_cnt_next; tx_done_reg <= tx_done_next; tx_busy_reg <= tx_busy_next; end end always_comb begin tx_next_state = tx_state; temp_data_next = temp_data_reg; tx_next = tx_reg; tick_cnt_next = tick_cnt_reg; bit_cnt_next = bit_cnt_reg; tx_done_next = tx_done_reg; tx_busy_next = tx_busy_reg; case (tx_state) IDLE: begin tx_next = 1'b1; tx_done_next = 0; tx_busy_next = 0; if (start) begin tx_next_state = START; temp_data_next = tx_data; tick_cnt_next = 0; bit_cnt_next = 0; tx_busy_next = 1; end end START: begin tx_next = 1'b0; if (br_tick) begin if (tick_cnt_reg == 15) begin tx_next_state = DATA; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end DATA: begin tx_next = temp_data_reg[0]; if (br_tick) begin if (tick_cnt_reg == 15) begin tick_cnt_next = 0; if (bit_cnt_reg == 7) begin tx_next_state = STOP; bit_cnt_next = 0; end else begin temp_data_next = {1'b0, temp_data_reg[7:1]}; bit_cnt_next = bit_cnt_reg + 1; end end else begin tick_cnt_next = tick_cnt_reg + 1; end end end STOP: begin tx_next = 1'b1; if (br_tick) begin if (tick_cnt_reg == 15) begin tx_next_state = IDLE; tx_done_next = 1; tx_busy_next = 0; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end endcase end endmodule module receiver ( input logic clk, input logic reset, input logic br_tick, output logic [7:0] rx_data, output logic rx_done, input logic rx ); typedef enum { IDLE, START, DATA, STOP } rx_state_e; rx_state_e rx_state, rx_next_state; logic [4:0] tick_cnt_reg, tick_cnt_next; logic [2:0] bit_cnt_reg, bit_cnt_next; logic [7:0] rx_data_reg, rx_data_next; logic rx_done_next, rx_done_reg; assign rx_data = rx_data_reg; assign rx_done = rx_done_reg; always_ff @(posedge clk, posedge reset) begin if (reset) begin rx_state <= IDLE; tick_cnt_reg <= 0; bit_cnt_reg <= 0; rx_data_reg <= 0; rx_done_reg <= 0; end else begin rx_state <= rx_next_state; tick_cnt_reg <= tick_cnt_next; bit_cnt_reg <= bit_cnt_next; rx_data_reg <= rx_data_next; rx_done_reg <= rx_done_next; end end always_comb begin rx_next_state = rx_state; rx_done_next = rx_done; tick_cnt_next = tick_cnt_reg; bit_cnt_next = bit_cnt_reg; rx_data_next = rx_data_reg; case (rx_state) IDLE: begin rx_done_next = 0; if (rx == 1'b0) begin rx_next_state = START; tick_cnt_next = 0; bit_cnt_next = 0; rx_data_next = 0; end end START: begin if (br_tick) begin if (tick_cnt_reg == 7) begin tick_cnt_next = 0; rx_next_state = DATA; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end DATA: begin if (br_tick) begin if (tick_cnt_reg == 15) begin tick_cnt_next = 0; rx_data_next = {rx, rx_data_reg[7:1]}; if (bit_cnt_reg == 7) begin bit_cnt_next = 0; rx_next_state = STOP; end else begin bit_cnt_next = bit_cnt_reg + 1; end end else begin tick_cnt_next = tick_cnt_reg + 1; end end end STOP: begin if (br_tick) begin if (tick_cnt_reg == 23) begin tick_cnt_next = 0; rx_done_next = 1; rx_next_state = IDLE; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end endcase end endmodule < Simulation : uart > < Code : UpDownCounter > `timescale 1ns / 1ps module UpDownCounter ( input logic clk, input logic reset, input logic btn_mode, input logic btn_run_stop, input logic btn_clear, input logic [ 7:0] rx_data, input logic rx_done, output logic [ 1:0] led_mode, output logic [ 1:0] led_run_stop, output logic [13:0] count ); logic tick_10hz; logic mode, run_stop, clear; clk_div_10hz U_CLK_DIV_10hz ( .clk (clk), .reset (reset), .run_stop (run_stop), .clear (clear), .tick_10hz(tick_10hz) ); up_down_counter U_UP_DOWN_COUNTER ( .clk (clk), .reset(reset), .tick (tick_10hz), .mode (mode), .clear(clear), .count(count) ); control_unit U_CU ( .clk (clk), .reset (reset), .btn_mode (btn_mode), .btn_run_stop(btn_run_stop), .btn_clear (btn_clear), .rx_data (rx_data), .rx_done (rx_done), .mode (mode), .run_stop (run_stop), .clear (clear), .led_mode (led_mode), .led_run_stop(led_run_stop) ); endmodule // ... module control_unit ( input logic clk, input logic reset, input logic btn_mode, input logic btn_run_stop, input logic btn_clear, input logic [7:0] rx_data, input logic rx_done, output logic mode, output logic run_stop, output logic clear, output logic [1:0] led_mode, output logic [1:0] led_run_stop ); /************************** MODE FSM **************************/ typedef enum { UP, DOWN } state_mode_e; state_mode_e state_mode, next_state_mode; // transition logic always_ff @(posedge clk, posedge reset) begin if (reset) begin state_mode <= UP; end else begin state_mode <= next_state_mode; end end // output logic always_comb begin next_state_mode = state_mode; mode = 0; led_mode = 2'b00; case (state_mode) UP: begin led_mode = 2'b01; mode = 0; if (btn_mode) begin next_state_mode = DOWN; end if (rx_done) begin if (rx_data == 8'h4d || rx_data == 8'h6d) begin // M, m next_state_mode = DOWN; end end end DOWN: begin led_mode = 2'b10; mode = 1; if (btn_mode) begin next_state_mode = UP; end if (rx_done) begin if (rx_data == 8'h4d || rx_data == 8'h6d) begin // M, m next_state_mode = UP; end end end endcase end /********************* RUN STOP CLEAR FSM *********************/ typedef enum { STOP, RUN, CLEAR } state_counter_e; state_counter_e state_counter, next_state_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin state_counter <= STOP; end else begin state_counter <= next_state_counter; end end always_comb begin next_state_counter = state_counter; run_stop = 0; clear = 0; led_run_stop = 2'b00; case (state_counter) STOP: begin led_run_stop = 2'b01; if (btn_run_stop) next_state_counter = RUN; else if (btn_clear) next_state_counter = CLEAR; if (rx_done) begin if (rx_data == 8'h52 || rx_data == 8'h72) begin // R, r next_state_counter = RUN; end end if (rx_done) begin if (rx_data == 8'h43 || rx_data == 8'h63) begin // C, c next_state_counter = CLEAR; end end end RUN: begin run_stop = 1; led_run_stop = 2'b10; if (btn_run_stop) next_state_counter = STOP; if (rx_done) begin if (rx_data == 8'h53 || rx_data == 8'h73) begin // S, s next_state_counter = STOP; end end end CLEAR: begin clear = 1; next_state_counter = STOP; end endcase end endmodule < Schematic > < 파일 > sources (Class) top_UpDownCounter.sv uart.sv button_detector.sv UpDownCounter.sv tfndController.svext simulation (Class) uart_tb.sv constrs (Class) Basys-3-Master.xdc CPU CISC(Complex Instruction Set Computer) micro processor에게 명령을 내리는데 필요한 모든 명령어 셋을 갖추고 있는 processor이다. 따라서 복잡하고 기능이 많은 명령어로 구성되어있다. 과거에는 컴퓨터 메모리 용량이 크지 않아서 sw 프로그램의 용량을 줄이기 위해 하나의 명령어로 여러 작업을 수행하도록 했기 때문에 CISC를 많이 사용하였다. 장점: 복합적이고 기능이 많기 때문에 하위 호환성?이 좋다. 따라서 호환성이 절대적으로 필요한 PC 환경에서는 CISC를 사용하는 것이 좋다. 단점: 하지만 트랜지스터 집적에 있어서 효율성이 떨어지기 때문에 성능 향상을 방해하는 요인이 될 수 있으며, 전력 소모가 크고, 가격이 비싸다는 등의 단점이 있다. 용도: 다양한 명령어를 포함하고 있어 일반적으로 우리가 사용하는 범용 컴퓨터(general purpose computer)의 CPU로 많이 사용된다. RISC(Reduced Instruction Set Computer) CISC 내부에 갖추어진 모든 명령어들 중 불과 20%에 해당하는 명령어들만이 전체 80% 이상의 일을 처리한다. 따라서 CISC와 같이 필요한 모든 명령어 셋을 갖고 있는 것은 비효율적일 수 있다. 이를 극복하기 위해 등장한 것이 RISC이다. 장점: RISC는 적은 수의 명령어들(사용 빈도가 높은 20%의 명령어들)로 구성된 processor이다. 따라서 CISC보다 더 빠른 속도?로 동작할 수 있으며, 단순하고, 전력소모가 적고, 가격도 저렴하다. (Tr 갯수 ↓) 단점: 하지만 하드웨어가 간단한 대신 소프트웨어(Compiler)가 크고 복잡해졌으며, 하위 호환성이 부족하다는 단점이 있다. 용도: RISC 구조는 파이프라인 중첩이 가능해서 같은 수의 명령어에 대해 적은 clock으로 처리가 가능하며 발열과 전력 소모도 줄일 수 있다. 따라서 임베디드 프로세서에서는 RISC 구조를 많이 사용한다. (MIPS, ARM) 앞으로의 학습 및 구현 계획 RISC-V Instruction Set 이해 RV32I (Base Integer ISA) 구현 1.Single-Cycle Processor (모든 명령어를 1 클럭 내에 실행) 2.Multi-Cycle Processor (명령어 종류에 따라 실행 클럭 수가 다름) 3.Pipeline 구조 CPU (선택 사항 / 미구현 예정) DedicatedProcessor_Counter Design < Design Specification > 0~9 까지 카운트하는 Processor를 설계 A = 0 (Data) < C 언어 > A = 0; while (A < 10) { output = A; A = A + 1; } halt; < Data Path > < ASM > < Code : DedicatedProcessor_Counter > `timescale 1ns / 1ps module DedicatedProcessor_Counter ( input logic clk, input logic reset, output logic [7:0] OutBuffer ); logic ASrcMuxSel; logic AEn; logic ALt10; logic OutBufEn; logic [$clog2(10_000_000)-1:0] div_counter; logic clk_10hz; always_ff @(posedge clk, posedge reset) begin if (reset) begin div_counter <= 0; end else begin if (div_counter == 10_000_000 - 1) begin div_counter <= 0; clk_10hz <= 1'b1; end else begin div_counter <= div_counter + 1; clk_10hz <= 1'b0; end end end ControlUnit U_ControlUnit ( .clk(clk_10hz), // bitstream .* ); DataPath U_DataPath ( .clk(clk_10hz), // bitstream .* ); endmodule module Register ( input logic clk, input logic reset, input logic en, input logic [7:0] d, output logic [7:0] q ); always_ff @(posedge clk, posedge reset) begin if (reset) begin q <= 0; end else begin if (en) begin q <= d; end end end endmodule module Mux_2x1 ( input logic sel, input logic [7:0] x0, input logic [7:0] x1, output logic [7:0] y ); always_comb begin y = 8'b0; case (sel) 1'b0: y = x0; 1'b1: y = x1; endcase end endmodule module Adder ( input logic [7:0] a, input logic [7:0] b, output logic [7:0] sum ); assign sum = a + b; endmodule module Comparator ( input logic [7:0] a, input logic [7:0] b, output logic lt ); assign lt = a < b; endmodule module OutBuf ( input logic en, input logic [7:0] x, output logic [7:0] y ); assign y = en ? x : 8'bx; endmodule module ControlUnit ( input logic clk, input logic reset, input logic ALt10, output logic ASrcMuxSel, output logic AEn, output logic OutBufEn ); typedef enum { S0, S1, S2, S3, S4 } state_e; state_e state, next_state; always_ff @(posedge clk, posedge reset) begin if (reset) begin state <= S0; end else begin state <= next_state; end end always_comb begin ASrcMuxSel = 0; AEn = 0; OutBufEn = 0; next_state = state; case (state) S0: begin ASrcMuxSel = 0; AEn = 1; OutBufEn = 0; next_state = S1; end S1: begin ASrcMuxSel = 1; AEn = 0; OutBufEn = 0; if (ALt10) next_state = S2; else next_state = S4; end S2: begin ASrcMuxSel = 1; AEn = 0; OutBufEn = 1; next_state = S3; end S3: begin ASrcMuxSel = 1; AEn = 1; OutBufEn = 0; next_state = S1; end S4: begin ASrcMuxSel = 1; AEn = 0; OutBufEn = 0; next_state = S4; end endcase end endmodule module DataPath ( input logic clk, input logic reset, input logic ASrcMuxSel, input logic AEn, input logic OutBufEn, output logic ALt10, output logic [7:0] OutBuffer ); logic [7:0] AdderResult, ASrcMuxOut, ARegOut; Mux_2x1 U_ASrcMux ( .sel(ASrcMuxSel), .x0 (8'b0), .x1 (AdderResult), .y (ASrcMuxOut) ); Register U_A_Reg ( .clk (clk), .reset(reset), .en (AEn), .d (ASrcMuxOut), .q (ARegOut) ); Comparator U_ALt10 ( .a (ARegOut), .b (8'd10), .lt(ALt10) ); Adder U_Adder ( .a (ARegOut), .b (8'd1), .sum(AdderResult) ); // OutBuf U_OutBuf ( // .en(OutBufEn), // .x (ARegOut), // .y (OutBuffer) // ); Register U_OutReg ( .clk (clk), .reset(reset), .en (OutBufEn), .d (ARegOut), .q (OutBuffer) ); endmodule < Comment > DataPath Comparator 출력(ALt10)은 C의 while (A < 10)을 하드웨어로 치환한 제어 분기 입력으로 필수다. 레지스터별 Enable은 A 업데이트와 출력 샘플링의 타이밍을 독립 제어해 정확한 순서·정지·초기화를 보장한다. 동일 엣지에서 OutReg와 AReg를 함께 샘플링함으로써 C의 “output=A; A=A+1;”를 클럭 하나로 정확히 구현한다. < Schematic > < Simulation > < 파일 > sources (Class) DedicatedProcessor_Counter.sv simulation (Class) DedicatedProcessor_Counter_tb.sv constrs (Class) Basys-3-Master.xdc Homework < Design Specification > 0+1+2+3+…+9+10 = 55 와 같이 누적으로 덧셈 결과 출력이 되도록 구현 FND에 누적 값을 출력 < C 언어 > a = 0; b = 0; while (a <= 10) { b = b + a; // 누적 a = a + 1; // 증가 } output = b; // 55 < Data Path > < ASM > < Code : top > `timescale 1ns / 1ps module top ( input logic clk, input logic reset, output logic [3:0] fndCom, output logic [7:0] fndFont ); logic [7:0] data; DedicatedProcessor U_DedicatedProcessor ( .clk(clk), .reset(reset), .OutBuffer(data) ); fndController U_fndController ( .clk(clk), .reset(reset), .number(data), .fndCom(fndCom), .fndFont(fndFont) ); endmodule < Code : DedicatedProcessor (DataPath) > //... module DataPath ( input logic clk, input logic reset, input logic ASrcMuxSel, input logic AEn, input logic OutBufEn, output logic ALt10, output logic [7:0] OutBuffer ); logic [7:0] AdderResult, ASrcMuxOut, ARegOut; logic [7:0] SumResult, BSrcMuxOut, BRegOut; Mux_2x1 U_ASrcMux ( .sel(ASrcMuxSel), .x0 (8'b0), .x1 (AdderResult), .y (ASrcMuxOut) ); Register U_A_Reg ( .clk (clk), .reset(reset), .en (AEn), .d (ASrcMuxOut), .q (ARegOut) ); Comparator U_ALt10 ( .a (ARegOut), .b (8'd11), // 8'd11 .lt(ALt10) ); Adder U_Adder ( .a (ARegOut), .b (8'd1), .sum(AdderResult) ); // OutBuf U_OutBuf ( // .en(OutBufEn), // .x (ARegOut), // .y (OutBuffer) // ); // Register U_OutReg ( // .clk (clk), // .reset(reset), // .en (OutBufEn), // .d (ARegOut), // .q (OutBuffer) // ); /*************** B ***************/ Mux_2x1 U_BSrcMux ( .sel(ASrcMuxSel), .x0 (8'b0), .x1 (SumResult), .y (BSrcMuxOut) ); Register U_B_Reg ( .clk (clk), .reset(reset), .en (AEn), .d (BSrcMuxOut), .q (BRegOut) ); Adder U_Sum ( .a (AdderResult), .b (BRegOut), .sum(SumResult) ); Register U_OutReg ( .clk (clk), .reset(reset), .en (OutBufEn), .d (BRegOut), .q (OutBuffer) ); endmodule //... < Comment > DataPath 누적값(B)에 현재 항(A 또는 A+1)을 더하는 덧셈기와 누적값을 저장하는 레지스터(B Reg)를 추가 A와 B는 동일한 Enable(AEn)과 초기화 경로(ASrcMuxSel=0)를 공유하여 루프 갱신 시 동시 업데이트가 가능 출력 레지스터를 두어 글리치 방지와 타이밍 여유를 확보 < simulation > < Video > < 고찰 > DataPath에 누적기 경로를 추가함으로써, 단순 카운트가 아닌 누적 연산까지 지원하는 구조를 구현할 수 있었다. 각 레지스터의 Enable과 조건 제어를 통해 출력 안정성과 연산 정확성을 확보하였다. < 파일 > sources (Homework) top.sv DedicatedProcessor.sv fndController.sv simulation (Homework) DedicatedProcessor_tb.sv constrs (Homework) Basys-3-Master.xdc
Final · 2025-08-11
2025-08-08
Run_Stop_Clear_Counter Design < Code : UpDownCounter > `timescale 1ns / 1ps module UpDownCounter ( input logic clk, input logic reset, input logic btn_mode, input logic btn_run_stop, input logic btn_clear, output logic [ 1:0] led_mode, output logic [ 1:0] led_run_stop, output logic [13:0] count ); logic tick_10hz; logic mode, run_stop, clear; clk_div_10hz U_Clk_Div_10hz ( .clk (clk), .reset (reset), .run_stop (run_stop), .clear (clear), .tick_10hz(tick_10hz) ); up_down_counter U_Up_Down_Counter ( .clk (clk), .reset(reset), .tick (tick_10hz), .mode (mode), .clear(clear), .count(count) ); control_unit U_Control_Unit ( .clk (clk), .reset (reset), .btn_mode (btn_mode), .btn_run_stop(btn_run_stop), .btn_clear (btn_clear), .mode (mode), .run_stop (run_stop), .clear (clear), .led_mode (led_mode), .led_run_stop(led_run_stop) ); endmodule module clk_div_10hz ( input logic clk, input logic reset, input logic run_stop, input logic clear, output logic tick_10hz ); //logic [23:0] div_counter; logic [$clog2(10_000_000)-1:0] div_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin div_counter <= 0; tick_10hz <= 1'b0; end else begin if (run_stop) begin if (div_counter == 10_000_000 - 1) begin div_counter <= 0; tick_10hz <= 1'b1; end else begin div_counter <= div_counter + 1; tick_10hz <= 1'b0; end end if (clear) begin div_counter <= 0; tick_10hz <= 1'b0; end end end endmodule module up_down_counter ( input logic clk, input logic reset, input logic tick, input logic mode, input logic clear, output logic [13:0] count ); always_ff @(posedge clk, posedge reset) begin if (reset) begin count <= 0; end else begin if (clear) begin count <= 0; end if (mode == 1'b0) begin // up counter if (tick) begin if (count == 9999) begin count <= 0; end else begin count <= count + 1; end end end else begin // down counter if (tick) begin if (count == 0) begin count <= 9999; end else begin count <= count - 1; end end end end end endmodule module control_unit ( input logic clk, input logic reset, input logic btn_mode, input logic btn_run_stop, input logic btn_clear, output logic mode, output logic run_stop, output logic clear, output logic [1:0] led_mode, output logic [1:0] led_run_stop ); /******************** MODE FSM ********************/ typedef enum { UP, DOWN } state_mode_e; state_mode_e state_mode, next_state_mode; // state memory always_ff @(posedge clk, posedge reset) begin if (reset) begin state_mode <= UP; end else begin state_mode <= next_state_mode; end end // transition logic always_comb begin next_state_mode = state_mode; mode = 0; led_mode = 2'b00; case (state_mode) UP: begin led_mode = 2'b01; if (btn_mode) begin next_state_mode = DOWN; end end DOWN: begin mode = 1; led_mode = 2'b10; if (btn_mode) begin next_state_mode = UP; end end endcase end /******************** RUN STOP CLEAR FSM ********************/ typedef enum { STOP, RUN, CLEAR } state_counter_e; state_counter_e state_counter, next_state_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin state_counter <= STOP; end else begin state_counter <= next_state_counter; end end always_comb begin next_state_counter = state_counter; run_stop = 0; clear = 0; led_run_stop = 2'b00; case (state_counter) STOP: begin led_run_stop = 2'b01; if (btn_run_stop) next_state_counter = RUN; else if (btn_clear) next_state_counter = CLEAR; end RUN: begin run_stop = 1; led_run_stop = 2'b10; if (btn_run_stop) next_state_counter = STOP; end CLEAR: begin clear = 1; next_state_counter = STOP; end endcase end endmodule < Comment > clk_div_10hz run_stop과 clear 신호를 받아 상태에 따라 카운터 동작을 제어한다. up_down_counter clear 신호를 받아 카운터 값을 즉시 초기화한다. → 예기치 않은 상태에서도 원하는 시점에 카운터를 안정적으로 리셋할 수 있다. control_unit 하나의 control_unit에서 상태 구분용 제어 신호를 받아 여러 개의 FSM(mode, run/stop/clear)을 동시에 처리한다. 각 FSM에서 led_mode와 led_run_stop 출력을 직접 생성하도록 설계하여 가독성과 직관성이 향상된다. < 파일 > sources (Class) top_UpDownCounter.sv button_detector.sv UpDownCounter.sv fndController.sv constrs (Class) Basys-3-Master.xdc Serial 통신 프로토콜 1. UART 비동기(Asynchronous) 통신 방식 Baud rate(bps, bit per second) 설정 값에 따라 송수신 속도 결정 송·수신 양측의 속도 설정이 다르면 통신 불가 동기 신호가 없어 에러율이 상대적으로 높음 송수신 속도에 제한이 있음 1:1 통신만 가능 (멀티포인트 불가) 송·수신 측에서 내부 클럭을 생성하여 타이밍 유지 2. I²C 동기(Synchronous) 통신 방식 SCL(클럭)과 SDA(데이터) 2선으로 동작 슬레이브 주소(Address)를 지정해 통신 → SPI보다 속도가 느림 N:N 통신 가능 (하나의 버스에 여러 마스터·슬레이브 연결 가능) Chip Select 신호선 불필요 (주소로 구분) 송신 또는 수신 중 한 방향만 가능 (Half-duplex) 3. SPI 동기(Synchronous) 통신 방식 SCLK(클럭), MOSI, MISO, CS(Chip Select) 신호 사용 클럭에 맞춰 매우 빠른 데이터 전송 가능 → 세 방식 중 가장 빠름 1:N 통신 (마스터 1개, 다수 슬레이브 가능) 슬레이브 선택을 위해 Chip Select 신호선 사용 송수신 동시 가능 (Full-duplex) UART / I²C / SPI 비교 구분 UART I²C SPI 통신 방식 비동기 동기 동기 데이터선 Tx, Rx SDA, SCL MOSI, MISO, SCLK, CS 속도 낮음 중간 빠름 통신 구조 1:1 N:N 1:N Chip Select X X O Duplex Full Half Full 장점 간단, 배선 적음 배선 적음, 다중 지원 빠름, 동시 송수신 단점 느림, 멀티 불가 SPI보다 느림 배선 많음, CS 관리 필요 Uart (Transmitter) Design < Block Design > < FSM (Transmitter) > < ASM (Transmitter) > < Code : Uart (Transmitter) > `timescale 1ns / 1ps module uart ( input logic clk, input logic reset, input logic start, input logic [7:0] tx_data, output logic tx, output logic tx_busy, output logic tx_done ); logic br_tick; baudrate_gen U_Baudrate_Gen ( .clk (clk), .reset (reset), .br_tick(br_tick) ); transmitter U_Transmitter ( .clk (clk), .reset (reset), .br_tick(br_tick), .start (start), .tx_data(tx_data), .tx_busy(tx_busy), .tx_done(tx_done), .tx (tx) ); endmodule module baudrate_gen ( input logic clk, input logic reset, output logic br_tick ); //logic [$clog2(100_000_000/9600/16)-1:0] br_counter; logic [3:0] br_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin br_counter <= 0; br_tick <= 1'b0; end else begin //if (br_counter == 100_000_000 / 9600 / 16 - 1) begin // 9600hz 9600bps if (br_counter == 10 - 1) begin br_counter <= 0; br_tick <= 1'b1; end else begin br_counter <= br_counter + 1; br_tick <= 1'b0; end end end endmodule module transmitter ( input logic clk, input logic reset, input logic br_tick, input logic start, input logic [7:0] tx_data, output logic tx_busy, output logic tx_done, output logic tx ); typedef enum { IDLE, START, DATA, STOP } tx_state_e; tx_state_e tx_state, tx_next_state; logic [7:0] temp_data_next, temp_data_reg; logic tx_reg, tx_next; logic [3:0] tick_cnt_reg, tick_cnt_next; logic [2:0] bit_cnt_reg, bit_cnt_next; logic tx_done_reg, tx_done_next; logic tx_busy_reg, tx_busy_next; assign tx = tx_reg; assign tx_busy = tx_busy_reg; assign tx_done = tx_done_reg; always_ff @(posedge clk, posedge reset) begin if (reset) begin tx_state <= IDLE; temp_data_reg <= 0; tx_reg <= 1'b1; tick_cnt_reg <= 0; bit_cnt_reg <= 0; tx_done_reg <= 0; tx_busy_reg <= 0; end else begin tx_state <= tx_next_state; temp_data_reg <= temp_data_next; tx_reg <= tx_next; tick_cnt_reg <= tick_cnt_next; bit_cnt_reg <= bit_cnt_next; tx_done_reg <= tx_done_next; tx_busy_reg <= tx_busy_next; end end always_comb begin tx_next_state = tx_state; temp_data_next = temp_data_reg; tx_next = tx_reg; tick_cnt_next = tick_cnt_reg; bit_cnt_next = bit_cnt_reg; tx_done_next = tx_done_reg; tx_busy_next = tx_busy_reg; case (tx_state) IDLE: begin tx_next = 1'b1; tx_done_next = 0; tx_busy_next = 0; if (start) begin tx_next_state = START; temp_data_next = tx_data; tick_cnt_next = 0; bit_cnt_next = 0; tx_busy_next = 1; end end START: begin tx_next = 1'b0; if (br_tick) begin if (tick_cnt_reg == 15) begin tx_next_state = DATA; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end DATA: begin tx_next = temp_data_reg[0]; if (br_tick) begin if (tick_cnt_reg == 15) begin tick_cnt_next = 0; if (bit_cnt_reg == 7) begin tx_next_state = STOP; bit_cnt_next = 0; end else begin temp_data_next = {1'b0, temp_data_reg[7:1]}; bit_cnt_next = bit_cnt_reg + 1; end end else begin tick_cnt_next = tick_cnt_reg + 1; end end end STOP: begin tx_next = 1'b1; if (br_tick) begin if (tick_cnt_reg == 15) begin tx_next_state = IDLE; tx_done_next = 1; tx_busy_next = 0; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end endcase end endmodule < Comment > baudrate_gen 시스템 클럭(100 MHz)에서 UART 통신 속도 9600bps, 16배 오버샘플링(표준 UART 수신 방식) 조건에 맞춰 br_tick을 생성하는 모듈이다. 카운터 최대값을 100_000_000 / 9600 / 16 - 1로 설정하여, 해당 주기마다 br_tick을 1클럭 동안 High로 만들어 transmitter와 receiver가 동일한 baudrate 클럭에 동기화되도록 한다. transmitter UART 송신기를 구현한 모듈로, start 신호 입력 시 데이터(tx_data)를 UART 프레임 구조(1 start bit + 8 data bits + 1 stop bit)로 직렬 전송한다. FSM(IDLE → START → DATA → STOP)으로 동작하며, 각 비트 전송은 baudrate 오버샘플링(16배) 기준 br_tick 신호에 맞춰 진행된다. 데이터 구동 시 LSB부터 순차적으로 전송하며, 모든 비트 전송이 완료되면 tx_done을 1로 설정하고 tx_busy를 0으로 복귀시켜 다음 전송을 준비한다. < 파일 > sources (Class) uart.sv sim (Class) uart_tb.sv Homework < Design Specification > receiver 설계 → uart 구현 uart + up down counter → PC 제어 (ComPortMaster) “r” : run 상태 ”s” : stop 상태 “c” : clear 상태 “m” : mode변경 < Block Diagram > < FSM (receiver) > < ASM (receiver) > < Code : uart > `timescale 1ns / 1ps module uart ( input logic clk, input logic reset, input logic rx, output logic tx, output logic [7:0] uart_data ); logic br_tick; logic rx_done; logic [7:0] rx_data; assign uart_data = rx_done ? rx_data : 8'b0; baudrate_gen U_Baudrate_Gen ( .clk (clk), .reset (reset), .br_tick(br_tick) ); receiver U_Receiver ( .clk (clk), .reset (reset), .br_tick(br_tick), .rx (rx), .rx_data(rx_data), .rx_done(rx_done) ); transmitter U_Transmitter ( .clk (clk), .reset (reset), .br_tick(br_tick), .start (rx_done), .tx_data(rx_data), .tx_busy(), .tx_done(), .tx (tx) ); endmodule module baudrate_gen ( input logic clk, input logic reset, output logic br_tick ); logic [$clog2(100_000_000/9600/16)-1:0] br_counter; // logic [3:0] br_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin br_counter <= 0; br_tick <= 1'b0; end else begin if (br_counter == 100_000_000 / 9600 / 16 - 1) begin // 9600hz 9600bps // if (br_counter == 10 - 1) begin br_counter <= 0; br_tick <= 1'b1; end else begin br_counter <= br_counter + 1; br_tick <= 1'b0; end end end endmodule module receiver ( input logic clk, input logic reset, input logic br_tick, input logic rx, output logic [7:0] rx_data, output logic rx_done ); typedef enum { IDLE, START, DATA, STOP } rx_state_e; rx_state_e rx_state, rx_next_state; logic [7:0] rx_data_reg, rx_data_next; logic [4:0] tick_cnt_reg, tick_cnt_next; logic [2:0] bit_cnt_reg, bit_cnt_next; logic rx_done_reg, rx_done_next; assign rx_done = rx_done_reg; assign rx_data = rx_data_reg; always_ff @(posedge clk, posedge reset) begin if (reset) begin rx_state <= IDLE; rx_data_reg <= 0; tick_cnt_reg <= 0; bit_cnt_reg <= 0; rx_done_reg <= 0; end else begin rx_state <= rx_next_state; rx_data_reg <= rx_data_next; tick_cnt_reg <= tick_cnt_next; bit_cnt_reg <= bit_cnt_next; rx_done_reg <= rx_done_next; end end always_comb begin rx_next_state = rx_state; rx_data_next = rx_data_reg; tick_cnt_next = tick_cnt_reg; bit_cnt_next = bit_cnt_reg; rx_done_next = rx_done_reg; case (rx_state) IDLE: begin rx_done_next = 0; if (rx == 0) begin rx_next_state = START; rx_data_next = 0; tick_cnt_next = 0; bit_cnt_next = 0; end end START: begin if (br_tick) begin if (tick_cnt_reg == 7) begin rx_next_state = DATA; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end DATA: begin if (br_tick) begin if (tick_cnt_reg == 15) begin tick_cnt_next = 0; rx_data_next = {rx, rx_data_reg[7:1]}; if (bit_cnt_reg == 7) begin rx_next_state = STOP; bit_cnt_next = 0; end else begin bit_cnt_next = bit_cnt_reg + 1; end end else begin tick_cnt_next = tick_cnt_reg + 1; end end end STOP: begin if (br_tick) begin if (tick_cnt_reg == 23) begin rx_next_state = IDLE; rx_done_next = 1; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end endcase end endmodule module transmitter ( input logic clk, input logic reset, input logic br_tick, input logic start, input logic [7:0] tx_data, output logic tx_busy, output logic tx_done, output logic tx ); typedef enum { IDLE, START, DATA, STOP } tx_state_e; tx_state_e tx_state, tx_next_state; logic [7:0] temp_data_next, temp_data_reg; logic tx_reg, tx_next; logic [3:0] tick_cnt_reg, tick_cnt_next; logic [2:0] bit_cnt_reg, bit_cnt_next; logic tx_done_reg, tx_done_next; logic tx_busy_reg, tx_busy_next; assign tx = tx_reg; assign tx_busy = tx_busy_reg; assign tx_done = tx_done_reg; always_ff @(posedge clk, posedge reset) begin if (reset) begin tx_state <= IDLE; temp_data_reg <= 0; tx_reg <= 1'b1; tick_cnt_reg <= 0; bit_cnt_reg <= 0; tx_done_reg <= 0; tx_busy_reg <= 0; end else begin tx_state <= tx_next_state; temp_data_reg <= temp_data_next; tx_reg <= tx_next; tick_cnt_reg <= tick_cnt_next; bit_cnt_reg <= bit_cnt_next; tx_done_reg <= tx_done_next; tx_busy_reg <= tx_busy_next; end end always_comb begin tx_next_state = tx_state; temp_data_next = temp_data_reg; tx_next = tx_reg; tick_cnt_next = tick_cnt_reg; bit_cnt_next = bit_cnt_reg; tx_done_next = tx_done_reg; tx_busy_next = tx_busy_reg; case (tx_state) IDLE: begin tx_next = 1'b1; tx_done_next = 0; tx_busy_next = 0; if (start) begin tx_next_state = START; temp_data_next = tx_data; tick_cnt_next = 0; bit_cnt_next = 0; tx_busy_next = 1; end end START: begin tx_next = 1'b0; if (br_tick) begin if (tick_cnt_reg == 15) begin tx_next_state = DATA; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end DATA: begin tx_next = temp_data_reg[0]; if (br_tick) begin if (tick_cnt_reg == 15) begin tick_cnt_next = 0; if (bit_cnt_reg == 7) begin tx_next_state = STOP; bit_cnt_next = 0; end else begin temp_data_next = {1'b0, temp_data_reg[7:1]}; bit_cnt_next = bit_cnt_reg + 1; end end else begin tick_cnt_next = tick_cnt_reg + 1; end end end STOP: begin tx_next = 1'b1; if (br_tick) begin if (tick_cnt_reg == 15) begin tx_next_state = IDLE; tx_done_next = 1; tx_busy_next = 0; tick_cnt_next = 0; end else begin tick_cnt_next = tick_cnt_reg + 1; end end end endcase end endmodule < Comment > uart Baudrate Generator: 시스템 클럭(예: 100 MHz)에서 UART 속도(9600 bps, 16배 오버샘플링)에 맞춘 br_tick 생성. 송·수신 모듈 모두 이 신호로 타이밍 동기화. Receiver: rx 입력을 샘플링해 8비트 데이터(rx_data) 복원, 수신 완료 시 rx_done=1 출력. Transmitter: rx_done 신호를 start로 받아, 수신한 데이터를 그대로 직렬 송신(tx). uart_data: rx_done 시점에만 유효 데이터를 출력, 그 외에는 0 유지. 전체적으로 수신한 데이터를 즉시 재전송(Echo)하는 구조이며, 모든 시퀀스는 br_tick 기반으로 송·수신 동기를 유지한다. receiver UART 수신기. rx의 start-bit(낙하) 감지 후 16배 오버샘플링 기준 br_tick에 맞춰 비트 중앙에서 샘플링한다. < Code : top_Uart_UpDownCounter > `timescale 1ns / 1ps module top_Uart_UpDownCounter ( input logic clk, input logic reset, input logic [2:0] btn, input logic rx, output logic tx, output logic [1:0] led_mode, output logic [1:0] led_run_stop, output logic [3:0] fndCom, output logic [7:0] fndFont ); logic [7:0] uart_data; uart U_Uart ( .clk (clk), .reset (reset), .rx (rx), .tx (tx), .uart_data(uart_data) ); top_UpDownCounter U_Top_UpDownCounter ( .clk (clk), .reset (reset), .btn (btn), .uart_data (uart_data), .led_mode (led_mode), .led_run_stop(led_run_stop), .fndCom (fndCom), .fndFont (fndFont) ); endmodule < Code : UpDownCounter (control_unit) > // ... module control_unit ( input logic clk, input logic reset, input logic btn_mode, input logic btn_run_stop, input logic btn_clear, input logic [7:0] uart_data, output logic mode, output logic run_stop, output logic clear, output logic [1:0] led_mode, output logic [1:0] led_run_stop ); /******************** MODE FSM ********************/ typedef enum { UP, DOWN } state_mode_e; state_mode_e state_mode, next_state_mode; // state memory always_ff @(posedge clk, posedge reset) begin if (reset) begin state_mode <= UP; end else begin state_mode <= next_state_mode; end end // transition logic always_comb begin next_state_mode = state_mode; mode = 0; led_mode = 2'b00; case (state_mode) UP: begin led_mode = 2'b01; if (btn_mode || (uart_data == "m")) begin next_state_mode = DOWN; end end DOWN: begin mode = 1; led_mode = 2'b10; if (btn_mode || (uart_data == "m")) begin next_state_mode = UP; end end endcase end /******************** RUN STOP CLEAR FSM ********************/ typedef enum { STOP, RUN, CLEAR } state_counter_e; state_counter_e state_counter, next_state_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin state_counter <= STOP; end else begin state_counter <= next_state_counter; end end always_comb begin next_state_counter = state_counter; run_stop = 0; clear = 0; led_run_stop = 2'b00; case (state_counter) STOP: begin led_run_stop = 2'b01; if (btn_run_stop || (uart_data == "r")) next_state_counter = RUN; else if (btn_clear || (uart_data == "c")) next_state_counter = CLEAR; end RUN: begin run_stop = 1; led_run_stop = 2'b10; if (btn_run_stop || (uart_data == "s")) next_state_counter = STOP; end CLEAR: begin clear = 1; next_state_counter = STOP; end endcase end endmodule < Schematic > < Video > < 고찰 > control_unit에서 UART 데이터를 입력받아 상태 변경 사항을 업데이트하도록 설계 → 확장성 확보 < 파일 > sources (Homework) top_Uart_UpDownCounter.sv uart.sv top_UpDownCounter.sv button_detector.sv UpDownCounter.sv fndController.sv constrs (Homework) Basys-3-Master.xdc
Final · 2025-08-08
2025-08-07
디지털 회로 기본 및 타이밍 특성 D-flip flop , Latch 차이 메모리 기능의 유무 → 둘 다 메모리 기능이 있지만, 동작 방식에 차이가 있음 Latch: 입력 신호가 활성화된 동안 값을 계속 반영함 (레벨 민감) D Flip-Flop: 클록 상승/하강 에지에서만 값을 반영 (엣지 트리거) 조합회로 (Combinational Circuit) 현재 입력에 의해서만 출력이 결정됨 과거 입력이나 상태와는 무관 예시: AND, OR, MUX, Decoder 등 순차회로 (Sequential Circuit) 클록 신호에 따라 동작 (동기식 설계) 출력은 현재 입력 + 이전 상태에 의존 예시: D Flip-Flop, 레지스터, FSM 등 SR Latch S=0, R=0 → Q=유지, Q′=유지 → 정상 상태 (Hold) S=0, R=1 → Q=0, Q′=1 → Reset 동작 S=1, R=0 → Q=1, Q′=0 → Set 동작 S=1, R=1 → Q=0, Q′=0 → 금지 상태 (Invalid) D Latch D=0, S=0, R=1 → Reset D=1, S=1, R=0 → Set Gated D Latch Gate=0, D=x, Q=유지, Q’=유지 → Hold 상태 Gate=1, D=0, Q=0, Q’=1 → Reset 동작 Gate=1, D=1, Q=1, Q’=0 → Set 동작 D-Filp Flop D Flip-Flop은 Master-Slave 구조의 두 개의 D-Latch로 구성 Master: 클록이 0일 때 입력 값을 저장 Slave: 클록이 1일 때 Master의 값을 출력에 전달 따라서 클록의 상승/하강 엣지에만 출력이 바뀜 (엣지 트리거) Metastability 클록 엣지 시점에 입력(D)이 변할 경우, 출력(Q)이 일정 시간 동안 정의되지 않은 상태에 머무를 수 있음 Setup Time: 클록 엣지 이전 일정 시간 동안 D 입력이 안정적으로 유지되어야 함 Hold Time: 클록 엣지 이후 일정 시간 동안도 D 입력이 유지되어야 함 Metastability 방지 방법 – 동기화 회로 (Synchronizer) 외부 신호(비동기 입력 등)는 클록 도메인에 따라 metastable 위험이 있음 D Flip-Flop을 2개 이상 직렬로 연결 첫 번째 F/F는 신호를 잠시 받아들이고 두 번째 F/F는 클록에 동기화된 안정된 출력을 생성 Glitch (순간 출력 오류) 조합 회로에서 입력이 동시에 변할 때, 내부 게이트의 전파 지연 차이로 인해 일시적인 잘못된 출력이 발생할 수 있음 클록 엣지 직전까지 출력이 안정되지 않으면 시스템 오동작 가능성 존재 Propagation Delay (전파 지연) 입력 변화 이후 출력이 안정될 때까지의 시간 지연 조합 회로가 복잡하거나 깊이가 깊을수록 지연 시간이 길어짐 예: FFT filter 설계 시 곱셈 연산은 시간이 오래 걸리므로, 중간에 레지스터를 삽입하여 처리 Pipeline 처리 연산 중간에 레지스터를 추가하여 연산 단계를 여러 클록 사이클로 분할 조합 논리의 길이를 줄여 glitch를 방지할 수 있음 복잡한 연산을 분할 처리해 클록 타이밍 여유 확보 가능 한 클럭 내에 연산이 끝나도록 회로를 구성하면 안정적인 시스템 설계 가능 Button_Detector Design < Block Diagram > < Code : button_detector > `timescale 1ns / 1ps module button_detector ( input logic clk, input logic reset, input logic i_btn, output logic rising_edge, output logic falling_edge, output logic both_edge ); logic clk_1khz; logic debounce; logic [ 7:0] shift_reg; logic [$clog2(100_000)-1:0] div_counter; // create 1kHz pulse (for button sampling) always_ff @(posedge clk, posedge reset) begin if (reset) begin div_counter <= 0; clk_1khz <= 1'b0; end else begin if (div_counter == 100_000 - 1) begin div_counter <= 0; clk_1khz <= 1'b1; end else begin div_counter <= div_counter + 1; clk_1khz <= 1'b0; end end end shift_register U_SHIFT_REG ( .clk (clk_1khz), .reset (reset), .i_data(i_btn), .o_data(shift_reg) ); assign debounce = &shift_reg; // assign o_btn = debounce; logic [1:0] edge_reg; // edge detector (rising/falling/both) always_ff @(posedge clk, posedge reset) begin if (reset) begin edge_reg <= 0; end else begin edge_reg[0] <= debounce; edge_reg[1] <= edge_reg[0]; end end assign rising_edge = edge_reg[0] & ~edge_reg[1]; assign falling_edge = ~edge_reg[0] & edge_reg[1]; assign both_edge = rising_edge | falling_edge; endmodule module shift_register ( input logic clk, input logic reset, input logic i_data, output logic [7:0] o_data ); always_ff @(posedge clk, posedge reset) begin if (reset) begin o_data <= 0; end else begin o_data <= {i_data, o_data[7:1]}; // right shift //o_data <= {o_data[6:0], i_data};// left shift end end endmodule < Comment > shift_register 시프트 레지스터의 기본 형태를 구현한 예시로, 구조와 동작 원리를 익혀두면 좋다. Right shift : 새로운 입력(i_data)이 MSB 위치로 들어가고, 기존 데이터는 오른쪽(LSB 방향)으로 한 비트씩 이동한다. Left shift : 새로운 입력(i_data)이 LSB 위치로 들어가고, 기존 데이터는 왼쪽(MSB 방향)으로 한 비트씩 이동한다. edge detector edge_reg를 통해 현재 debounce와 직전 상태를 저장. rising_edge : 0→1 변화를 검출. falling_edge : 1→0 변화를 검출. both_edge : 상승 또는 하강 변화를 모두 검출. < Code : UpDownCounter > `timescale 1ns / 1ps module UpDownCounter ( input logic clk, input logic reset, input logic button, output logic [13:0] count ); logic tick_10hz; logic mode; clk_div_10hz U_CLK_DIV_10hz ( .clk (clk), .reset (reset), .tick_10hz(tick_10hz) ); up_down_counter U_UP_DOWN_COUNTER ( .clk (clk), .reset(reset), .tick (tick_10hz), .mode (mode), .count(count) ); control_unit U_CU ( .clk(clk), .reset(reset), .button(button), .mode(mode) ); endmodule module up_down_counter ( input logic clk, input logic reset, input logic tick, input logic mode, output logic [13:0] count ); always_ff @(posedge clk, posedge reset) begin if (reset) begin count <= 0; end else begin if (mode == 1'b0) begin // up counter if (tick) begin if (count == 9999) begin count <= 0; end else begin count <= count + 1; end end end else begin // down counter if (tick) begin if (count == 0) begin count <= 9999; end else begin count <= count - 1; end end end end end endmodule module clk_div_10hz ( input logic clk, input logic reset, output logic tick_10hz ); //logic [23:0] div_counter; logic [$clog2(10_000_000)-1:0] div_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin div_counter <= 0; tick_10hz <= 1'b0; end else begin if (div_counter == 10_000_000 - 1) begin div_counter <= 0; tick_10hz <= 1'b1; end else begin div_counter <= div_counter + 1; tick_10hz <= 1'b0; end end end endmodule module control_unit ( input logic clk, input logic reset, input logic button, output logic mode ); typedef enum { UP, DOWN } state_e; state_e state, next_state; // transition logic always_ff @(posedge clk, posedge reset) begin if (reset) begin state <= UP; end else begin state <= next_state; end end // output logic always_comb begin next_state = state; case (state) UP: begin mode = 0; if (button) begin next_state = DOWN; end end DOWN: begin mode = 1; if (button) begin next_state = UP; end end endcase end endmodule < Comment > control_unit 버튼 입력에 따라 UP, DOWN 상태를 전환하는 FSM을 구현 typedef enum을 사용하여 상태 이름(UP, DOWN)을 열거형으로 선언 < Schematic > < 파일 > sources (Class) top_UpDownCounter.sv button_detector.sv UpDownCounter.sv fndController.sv constrs (Class) Basys-3-Master.xdc Homework < Design Specification > button 3개 사용 : run_stop 버튼, clear 버튼, mode 버튼 mode = 0 : up counting / mode = 1 : down counting up counter : led[0] on down counter : led[1] on stop : led[2] on run : led[3] on < FSM > < Code : UpDownCounter > //... module up_down_counter ( input logic clk, input logic reset, input logic tick, input logic mode, input logic clear, output logic toggle_state, output logic [13:0] count ); always_ff @(posedge clk or posedge reset) begin if (reset) begin toggle_state <= 0; end else begin if (mode) begin toggle_state <= ~toggle_state; end end end always_ff @(posedge clk, posedge reset) begin if (reset | clear) begin count <= 0; end else begin if (toggle_state == 1'b0) begin // up counter if (tick) begin if (count == 9999) begin count <= 0; end else begin count <= count + 1; end end end else begin // down counter if (tick) begin if (count == 0) begin count <= 9999; end else begin count <= count - 1; end end end end end endmodule module cu ( input logic clk, input logic reset, input logic btn_L, input logic btn_R, output logic runstop, output logic clear ); typedef enum { STOP, RUN, CLEAR } state_e; state_e state, next_state; always_ff @(posedge clk, posedge reset) begin if (reset) begin state <= STOP; end else begin state <= next_state; end end always_comb begin next_state = state; runstop = 0; clear = 0; case (state) STOP: begin runstop = 0; clear = 0; if (btn_L) begin next_state = CLEAR; end else if (btn_R) begin next_state = RUN; end end CLEAR: begin clear = 1; if (btn_L) begin next_state = STOP; end end RUN: begin runstop = 1; if (btn_R) begin next_state = STOP; end end endcase end endmodule module state_led ( input logic runstop, input logic clear, input logic mode, output logic [3:0] led ); // (condition) ? true : false assign led[1:0] = mode ? 2'b10 : 2'b01; assign led[3:2] = runstop ? 2'b10 : 2'b01; endmodule < Schematic > < Video > < 고찰 > led 변수명을 led_mode, led_runstop처럼 의미를 명확히 알 수 있도록 개선해야 함 기능별로 분리하여 코드의 확장성을 확보할 필요가 있음 하나의 control_unit에서 상태를 구분하는 제어 신호들을 받아, 여러 개의 FSM을 동시에 처리하는 구조를 고려함. (mode FSM은 기존대로 유지) < 파일 > sources (Homework) top_UpDownCounter.sv button_debounce.sv UpDownCounter.sv fndController.sv constrs (Homework) Basys-3-Master.xdc
Final · 2025-08-07
2025-08-06
Review : Counter Design < Design Specification > up/down counter 설계 mode 0 : up counter mode 1 : down counter 0.1초 간격으로 counting 동작 FND에 숫자값 출력 (0000~9999) 전원이 인가되면 mode에 맞게 counting 동작 < Block Design > < Code : UpDownCounter > `timescale 1ns / 1ps module UpDownCounter ( input logic clk, input logic reset, input logic sw_mode, output logic [13:0] count ); logic tick_10hz; clk_div_10hz U_CLK_DIV_10hz ( .clk (clk), .reset (reset), .tick_10hz(tick_10hz) ); up_down_counter U_UP_DOWN_COUNTER ( .clk (clk), .reset(reset), .tick (tick_10hz), .mode (sw_mode), .count(count) ); endmodule module clk_div_10hz ( input logic clk, input logic reset, output logic tick_10hz ); //logic [23:0] div_counter; logic [$clog2(10_000_000)-1:0] div_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin div_counter <= 0; tick_10hz <= 1'b0; end else begin if (div_counter == 10_000_000 - 1) begin div_counter <= 0; tick_10hz <= 1'b1; end else begin div_counter <= div_counter + 1; tick_10hz <= 1'b0; end end end endmodule module up_down_counter ( input logic clk, input logic reset, input logic tick, input logic mode, output logic [13:0] count ); always_ff @(posedge clk, posedge reset) begin if (reset) begin count <= 0; end else begin if (mode == 1'b0) begin // up counter if (tick) begin if (count == 9999) begin count <= 0; end else begin count <= count + 1; end end end else begin // down counter if (tick) begin if (count == 0) begin count <= 9999; end else begin count <= count - 1; end end end end end endmodule < Comment > clk_div_10hz system clock = 100_000_000Hz = 100MHz (1초에 1억 싸이클) clk_div_10hz → 10_000_000 싸이클마다 tick_10hz를 1로 출력 (0.1초 주기) 즉, tick_10hz는 10Hz로 동작 (1초에 10번 펄스 발생) up_down_counter 초기에 up_counter와 down_counter를 각각 따로 설계하고 top 모듈에서 sw를 통해 출력만 선택(MUX)하려 했으나, 이 경우 mode 전환 시 현재 카운터 값이 아닌 선택된 다른 카운터의 이전 값이 갑자기 출력될 우려가 있었다. → 결과적으로 출력 값이 불연속적으로 변할 수 있음 따라서 하나의 순차회로(counter)에서 mode를 입력으로 받아, 동일한 레지스터(count)에 대해 up/down 제어를 하는 방식이 연속적인 동작을 보장하고 설계 목표에도 더 적합하다고 판단했다. < Code : FndController > `timescale 1ns / 1ps module FndController ( input logic clk, input logic reset, input logic [13:0] number, output logic [ 3:0] fndCom, output logic [ 7:0] fndFont ); logic tick_1khz; logic [1:0] count; logic [3:0] digit_1, digit_10, digit_100, digit_1000, digit; clk_div_1khz U_CLK_DIV_1KHZ ( .clk (clk), .reset (reset), .tick_1khz(tick_1khz) ); counter_2bit U_COUNTER_2BIT ( .clk (clk), .reset(reset), .tick (tick_1khz), .count(count) ); decoder_2x4 U_DECODER_2X4 ( .x(count), .y(fndCom) ); digitSplitter U_DIGITSPLITTER ( .number (number), .digit_1 (digit_1), .digit_10 (digit_10), .digit_100 (digit_100), .digit_1000(digit_1000) ); mux_4x1 U_MUX_4X1 ( .sel(count), .x0 (digit_1), .x1 (digit_10), .x2 (digit_100), .x3 (digit_1000), .y (digit) ); BCDtoFND_Decoder U_BCDTOFND_DECODER ( .bcd(digit), .fnd(fndFont) ); endmodule module clk_div_1khz ( input logic clk, input logic reset, output logic tick_1khz ); logic [$clog2(100_000):0] div_counter; always_ff @(posedge clk, posedge reset) begin if (reset) begin div_counter <= 0; tick_1khz <= 0; end else begin if (div_counter == 100_000 - 1) begin div_counter <= 0; tick_1khz <= 1; end else begin div_counter <= div_counter + 1; tick_1khz <= 0; end end end endmodule module counter_2bit ( input logic clk, input logic reset, input logic tick, output logic [1:0] count ); always_ff @(posedge clk, posedge reset) begin if (reset) begin count <= 0; end else begin if (tick) begin count <= count + 1; end end end endmodule module decoder_2x4 ( input logic [1:0] x, output logic [3:0] y ); always_comb begin case (x) 2'b00: y = 4'b1110; 2'b01: y = 4'b1101; 2'b10: y = 4'b1011; 2'b11: y = 4'b0111; endcase end endmodule module digitSplitter ( input logic [13:0] number, output logic [ 3:0] digit_1, output logic [ 3:0] digit_10, output logic [ 3:0] digit_100, output logic [ 3:0] digit_1000 ); assign digit_1 = number % 10; assign digit_10 = number / 10 % 10; assign digit_100 = number / 100 % 10; assign digit_1000 = number / 1000 % 10; endmodule module mux_4x1 ( input logic [1:0] sel, input logic [3:0] x0, input logic [3:0] x1, input logic [3:0] x2, input logic [3:0] x3, output logic [3:0] y ); always_comb begin y = 4'b0000; case (sel) 2'b00: y = x0; 2'b01: y = x1; 2'b10: y = x2; 2'b11: y = x3; endcase end endmodule module BCDtoFND_Decoder ( input logic [3:0] bcd, output logic [7:0] fnd ); always_comb begin case (bcd) 4'h0: fnd = 8'hc0; 4'h1: fnd = 8'hf9; 4'h2: fnd = 8'ha4; 4'h3: fnd = 8'hb0; 4'h4: fnd = 8'h99; 4'h5: fnd = 8'h92; 4'h6: fnd = 8'h82; 4'h7: fnd = 8'hf8; 4'h8: fnd = 8'h80; 4'h9: fnd = 8'h90; 4'ha: fnd = 8'h88; 4'hb: fnd = 8'h83; 4'hc: fnd = 8'hc6; 4'hd: fnd = 8'ha1; 4'he: fnd = 8'h86; 4'hf: fnd = 8'h8e; default: fnd = 8'hff; endcase end endmodule < Comment > clk_div_1khz 1ms 마다 tick_1khz를 생성 counter_2bit tick 받을 때마다 count 0→1→2→3 순환 decoder_2x4 count에 따라 FND의 자릿수 선택 (fndCom 출력) digitSplitter 14비트 입력 숫자를 천/백/십/일의 4자리로 분할 mux_4x1 count 자리에 해당하는 자릿수 값을 선택 BCDtoFND_Decoder 자릿수 값을 FND 디코딩 (fndFont 출력) < Code : top_UpDownCounter > `timescale 1ns / 1ps module top_UpDownCounter ( input logic clk, input logic reset, input logic sw_mode, output logic [3:0] fndCom, output logic [7:0] fndFont ); logic [13:0] count; UpDownCounter U_UPDOWNCOUNTER ( .clk (clk), .reset (reset), .sw_mode(sw_mode), .count (count) ); FndController U_FNDCONTROLLER ( .clk (clk), .reset (reset), .number (count), .fndCom (fndCom), .fndFont(fndFont) ); endmodule < Schematic > < 파일 > sources (Class) top_UpDownCounter.sv UpDownCounter.sv FndController.sv constrs (Class) Basys-3-Master.xdc Homework < Design Specification > mode 버튼을 눌렀다 뗐을 때 up_counter → down_counter mode 버튼을 눌렀다 뗐을 때 down_counter → up_counter mode 버튼 1개로 counter 동작 toggle < 구상 > 기존 스위치 입력을 버튼 입력으로 대체하고자 했으며, 버튼 특성상 노이즈가 발생하므로 디바운싱 처리가 필요하다고 판단했다. 특히, 버튼을 눌렀다 떼는 순간(falling edge)에만 동작이 발생해야 하므로, 엣지 검출 기반 동작 설계가 이번 구현의 핵심이 되었다. < Code : btn_debounce > `timescale 1ns / 1ps module btn_debounce ( input logic clk, input logic rst, input logic i_btn, output logic o_btn ); parameter F_COUNT = 10_000; logic [$clog2(F_COUNT)-1:0] r_counter; logic r_clk; logic [7:0] q_reg, q_next; logic w_debounce; // 10,000Hz clock divider (0.1ms) always_ff @(posedge clk, posedge rst) begin if (rst) begin r_counter <= 0; r_clk <= 0; end else begin if (r_counter == (F_COUNT - 1)) begin r_counter <= 0; r_clk <= 1'b1; end else begin r_counter <= r_counter + 1; r_clk <= 1'b0; end end end // shift register always_comb begin q_next = {i_btn, q_reg[7:1]}; end always_ff @(posedge r_clk, posedge rst) begin if (rst) begin q_reg <= 0; end else begin q_reg <= q_next; end end // 8 input and gate assign w_debounce = &q_reg; logic r_edge_q; // edge detector always_ff @(posedge clk, posedge rst) begin if (rst) begin r_edge_q <= 0; end else begin r_edge_q <= w_debounce; end end // rising edge // assign o_btn = (~r_edge_q) & w_debounce; // falling edge assign o_btn = r_edge_q & ~w_debounce; endmodule < Comment > 10,000Hz clock divider 0.1ms 마다 tick_1khz를 생성 shift register 0.1ms마다 버튼 입력 i_btn을 가장 상위 비트에 넣고, 기존 값은 한 칸씩 오른쪽으로 밀어 저장 → 최근 0.8ms 간의 입력 이력을 저장 8 input and gate 8비트 shift register의 모든 비트가 1일 때만 w_debounce = 1 → 버튼이 0.8ms 이상 안정적으로 눌렸는지를 판별 edge detector w_debounce의 상태를 한 클럭 지연시킨 r_edge_q와 비교 → 현재 상태와 이전 상태의 차이를 기반으로 버튼 변화 시점을 감지 falling edge r_edge_q = 1, w_debounce = 0인 경우에만 o_btn = 1 → 버튼이 떼어지는 순간(falling edge)만 한 클럭 동안 출력 < Code : UpDownCounter (up_down_counter) > // ... logic toggle_state; always_ff @(posedge clk or posedge reset) begin if (reset) begin toggle_state <= 0; end else begin if (mode) begin toggle_state <= ~toggle_state; end end end //... // counter 변환 조건 변경 : mode → toggle_state < Schematic > < Video > < 고찰 > 단순히 일정 시간 동안 버튼이 눌렸는지를 판단하는 방식이 아닌, 현재 상태와 이전 상태의 차이를 기반으로 버튼이 눌리는 순간과 떼어지는 순간을 감지하는 엣지 검출(edge detection) 방식이 새로웠다. 또한, shift register를 활용해 버튼 입력의 이력을 저장함으로써 노이즈에 강한 안정적인 디바운싱 로직을 구현할 수 있다는 점이 인상 깊었다. < 파일 > sources (Homework) top_UpDownCounter.sv button_debounce.sv UpDownCounter.sv fndController.sv constrs (Homework) Basys-3-Master.xdc
Final · 2025-08-06

Touch background to close