juniha 님의 블로그

[디지털 집적회로 기초 설계 실습]_RTL부터 P&R 까지 통합 플로우_2

juniha — Sun, 19 Oct 2025 20:19:30 +0900

Place and Route

P&R (Place and Route)

• Standard cell 을 이용하여 배치와 연결 진행

•전원망구성 → 클록 트리 합성 → 신호 배선

Design Flow

• Floor planning : 다이 / 코어 크기 결정

• CTS : 스큐 / 지연목표에 맞춰 CLK 연결

• Routing : 글로벌 / 디테일 배선, DRC 수정

• Signoff : 물리 검증 후 GDSII 추출

P&R: Innovus 실행

Innovus실행

• 터미널 →cd .. →mkdir

• 실행위치: pwm_design 2innovus 입력 /2innovus

• Digital tool sourcing : souce ../.env_csh_innovus_genus

• 터미널 HiCSL →innovus 입력

P&R: Import Synthesis File

Technology/Physical Libraries

P&R: Power Assign

P&R: MMMC(Multi-Mode Multi-Corner) Setup

Timing Library Files

RC Corner

Delay Corner

Constraint Modes

Analysis View

설정완료

P&R: Specify Floorplan

Floorplan

Global Nets

Global VDD,VSS 설정

P&R: Add Power Line

Power Ring 추가

Ring configuration: width = 1 , spacing = 1 , offset = 1 (사용한공정drcrule에맞춰서설정)

Power Stripe 추가

Edit Pin

InputPin 설정

OutputPin 설정

P&R: Special Route

Cell 을위한Power Line 추가

P&R: Place Standard Cells

Standard Cell 배치

P&R: Routing

P&R: Check DRC

PVS 설정

DRC Run

DRC Metal 간격

• 임의로DRC 에러생성

DRC result

DRC result

• Error 가 있을 경우 위와 같이 메시지 표시

• 더블 클릭 시 해당 위치 하이라이트 표시

• Error를 고치기 위해서는 Size 또는 해당 부분만 옮겨서 DRC 문제 해결

P&R: Check LVS

PVS 설정

Black Box 설정

Power Net 설정

P&R: Timing Report 확인

Time Report 추출

Report분석

• 파일위치

• ./ pwm/2innovus/timingReports/pwm_preCTS_all.tarpt

• Begin point: 경로의 시작점

• End point: 경로의 종료점

• Path Group: 경로의 분류

• Analysis View: 분석 환경

• Slack: 타이밍 여유(Required Time -Arrival Time)

• Timing Path: 실제 신호가 거치는 셀 / 넷 / 핀의 리스트와 각 단계 별 propagation delay

P&R: Post Layout Simulation

SDF & Netlist 추출

Simulation Setting

• cd ../1genus/ rtl 폴더로이동 • Innovus에서추출한netlist, sdf파일을PLS 폴더로 이동

Test bench 작성

• PLS 폴더에작성

Netlist 수정

1genus/ filelist → pwm_layout.v HiCSL 로수정

Xcelium 실행

Waveform window 띄우기

Simulation 실행

P&R: Top Verilog 작성

module top_pwm (clk, reset, htime, ltime, pwmout,VDD, VSS);
    input clk;
    input reset;
    input [6:0] htime, ltime;
    input VDD;
    input VSS;
    output pwmout;
    
    PADI_ESD_Metal9 pad_clk (.PAD(clk));
    PADI_ESD_Metal9 pad_reset (.PAD(reset));
    PADI_ESD_Metal9 pad_htime0 (.PAD(htime[0]));
    PADI_ESD_Metal9 pad_htime1 (.PAD(htime[1]));
    PADI_ESD_Metal9 pad_htime2 (.PAD(htime[2]));
    PADI_ESD_Metal9 pad_htime3 (.PAD(htime[3]));
    PADI_ESD_Metal9 pad_htime4 (.PAD(htime[4]));
    PADI_ESD_Metal9 pad_htime5 (.PAD(htime[5]));
    PADI_ESD_Metal9 pad_htime6 (.PAD(htime[6]));
    PADI_ESD_Metal9 pad_ltime0 (.PAD(ltime[0]));        
    PADI_ESD_Metal9 pad_ltime1 (.PAD(ltime[1]));        
    PADI_ESD_Metal9 pad_ltime2 (.PAD(ltime[2]));        
    PADI_ESD_Metal9 pad_ltime3 (.PAD(ltime[3]));        
    PADI_ESD_Metal9 pad_ltime4 (.PAD(ltime[4]));        
    PADI_ESD_Metal9 pad_ltime5 (.PAD(ltime[5]));        
    PADI_ESD_Metal9 pad_ltime6 (.PAD(ltime[6]));  PADO_ESD_Metal9 pad_pwmout (.PAD(pwmout));
    PVDD_Metal9 pad_vdd(.VDD(VDD));
    PVSS_Metal9 pad_vss(.VSS(VSS));
    PCORNER_TL_Metal9 corner_TL();
    PCORNER_TR_Metal9 corner_TR();
    PCORNER_BL_Metal9 corner_BL();
    PCORNER_BR_Metal9 corner_BR();
    pwm pwm1(
         .clk(clk),
         .reset(reset),
         .htime(htime),
         .ltime(ltime),
         .pwmout(pwmout)
		);
 endmodule

Top 작성

• Pad 포함해서작성

• ../1genus/ outputs_pwm/top_pwm_syn.v 저장

P&R: Top Innovus 설정

Innouvs세팅

P&R: Top Flooorplan

Floorplan

P&R: Top IO Filler

IO Filler 추가

Power Stripe 추가

Cell 을위한Power line 추가

P&R: TopCell 배치

Standard cell 배치

Routing

Top Cell

결론

이번에 들은 디지털 집적회로 기초 설계 실습은 Verilog를 이용해 실제 IC 설계 과정을 처음부터 끝까지 경험해보는 수업이었습니다.

PWM 회로를 직접 설계하면서 Vivado로 RTL 코드를 작성하고 시뮬레이션을 통해 동작을 검증했습니다. 이후에는 Cadence의 Genus로 논리 합성(Synthesis)을 진행해, RTL 코드가 게이트 레벨 회로로 바뀌는 과정을 직접 확인했습니다.

그 다음 Innovus를 사용해서 Place & Route 단계까지 수행하면서, 회로를 실제 실리콘 위에 배치하고 배선하는 과정도 실습했어요. 마지막에는 **Post Layout Simulation(PLS)**을 통해 합성 전후의 지연 차이를 비교하며, 물리적 설계가 회로 동작에 미치는 영향을 배웠습니다.

이 과정을 통해 단순히 코드를 짜는 것뿐 아니라, 하드웨어 설계가 실제 칩으로 구현되기까지의 전체 흐름을 이해할 수 있었고, 각 툴의 역할과 설계 데이터의 연결 구조를 명확히 배울 수 있었습니다.
무엇보다 FPGA 수준이 아니라 ASIC 수준의 설계 절차를 직접 경험해본 게 큰 도움이 되었습니다.

[디지털 집적회로 기초 설계 실습]_RTL부터 P&R 까지 통합 플로우_1

juniha — Fri, 17 Oct 2025 22:38:26 +0900

강의 목표

본 강의는 디지털 IC 설계 입문자를 대상으로 한다. Cadence사의 Xcelium, Genus, Innovus를 활용해 RTL 설계, 합성, P&R에 이르는 전 과정을 단계별 실습으로 다룬다.
이를 통해 디지털 IC 설계의 전체적인 흐름을 파악하고 실무에 빠르게 적응할 수 있는 역량을 키운다.

강의 개요

PWM(Pulse Width Modulation)를 예제로 삼아 디지털 IC 설계에 필수적인 Cadence Xcelium, Genus, Innovus의 기본적인 사용법을 익힌다. Verilog RTL을 작성한 뒤 Xcelium으로 테스트벤치 기반 기능 검증을 수행하고, Genus로 제약(클록/타이밍) 설정 및 합성을 진행한다.
이후, Innovus에서 배치, 배선을 수행하고 Post-Layout RC 추출을 거쳐, 최종적으로 SDF을 적용한 Gate-Level Simulation으로 최종 동작을 확인한다.

Behavioral Simulation : 작성한 RTL 코드가 의도한대로 동작하는지 시뮬레이션
Synthesis : RTL 코드를 논리게이트(Netlist) 수준으로 변환하는 과정
Place and Route (P&R) : 논리 게이트를 실제 실리콘 상에서 배치 및 연결하는 과정
Behavioral Modeling
• 동작형태로구현
• 사람이이해하기쉽게표현
• 알고리즘/동작을 절차적으로표현→ 이해가쉽고 구현이 빠름

실습

RTL 설계 : Verilog 코드 작성

module pwm(
    input wire clk,             // 기준 클록 입력
    input wire [6:0] htime,     // PWM의 High 구간 길이 (클록 개수 단위)
    input wire [6:0] ltime,     // PWM의 Low 구간 길이 (클록 개수 단위)
    input wire reset,           // 비동기 리셋 신호 (1이면 초기화)
    output reg pwmout           // PWM 출력 신호
    );
    
    // 9비트 카운터 (최대 511까지 카운트 가능)
    // High/Low 구간의 총 길이(htime + ltime)만큼 카운트함
    reg [8:0] counter;
    
    //============================================================
    // 메인 동작 블록
    // - clk의 상승 엣지마다 counter를 증가시키며,
    //   counter 값에 따라 pwmout을 1 또는 0으로 출력한다.
    // - reset 신호가 들어오면 pwmout과 counter를 초기화한다.
    //============================================================
    always @(posedge clk or posedge reset) begin
        if (reset) begin 
            // 리셋이 들어올 경우 모든 상태 초기화
            pwmout  <= 1'b0;     // PWM 출력 Low로 초기화
            counter <= 9'b0;     // 카운터 0으로 초기화
        end else begin
            // 전체 주기 내에서 카운트 진행
            if (counter < (htime + ltime - 7'd1)) begin
                // 현재 counter가 htime보다 작으면 High 구간
                if (counter < htime) begin
                    pwmout <= 1'd1;   // High 출력
                end else begin
                    pwmout <= 1'd0;   // Low 출력
                end
                // 클록마다 카운터 증가
                counter <= counter + 9'd1;
            end else begin
                // 한 주기(htime + ltime) 종료 시점 → 카운터 리셋
                counter <= 9'd0;
            end
        end
    end
endmodule

PWM Module

• High 시간과Low 시간을조절할수있는PWM 출력신호생성

• Input ports: clk, htime[6:0], ltime[6:0], reset

• Output ports : pwmout

동작 설명

Board 정보입력 :

Zynq 7000 ZC702 Evaluation Board HiCSL 선택

RTL 설계 : Testbench 코드 작성

module pwm_tb();

    //============================================================
    // 입력 신호 정의
    //============================================================
    reg clk = 0;             // 클록 신호 (25ns 주기 → 40MHz)
    reg [6:0] htime;         // PWM High 구간 길이
    reg [6:0] ltime;         // PWM Low 구간 길이
    reg reset;               // 리셋 신호
    wire pwmout;             // PWM 출력 (테스트 대상 모듈의 출력)

    //============================================================
    // 클록 생성 블록
    //============================================================
    // 12.5ns마다 clk 반전 → 전체 주기 25ns (40MHz)
    always begin
        #12.5 clk = ~clk;
    end

    //============================================================
    // Reset 신호 생성 블록
    //============================================================
    // 시간 흐름에 따라 리셋 신호를 여러 번 활성화/비활성화하여
    // 모듈 초기화 동작을 테스트한다.
    initial begin
        reset = 1;    // 시작 시점에서 리셋 ON
        #10  reset = 0; // 10ns 후 리셋 OFF (정상 동작 시작)
        #50  reset = 1; // 50ns 뒤 다시 리셋 ON
        #10  reset = 0; // 10ns 후 리셋 OFF
    end

    //============================================================
    // 입력 파라미터 설정
    //============================================================
    // PWM의 High, Low 시간을 설정
    // → htime=3, ltime=7 이면 주기 10클록(250ns), 듀티비 30%
    initial begin 
        htime = 7'd3;    // High 구간: 3클록 (3 × 25ns = 75ns)
        ltime = 7'd7;    // Low 구간 : 7클록 (7 × 25ns = 175ns)
    end

    //============================================================
    // 시뮬레이션 종료 조건
    //============================================================
    // 1000ns(=1us) 후 자동 종료
    initial begin
        #1000;
        $finish;         // 시뮬레이션 강제 종료
    end

    //============================================================
    // DUT (Device Under Test) 인스턴스화
    //============================================================
    // 실제 PWM 모듈을 불러와 입력 신호를 연결
    pwm dut(
        .clk(clk),        // 클록 입력
        .htime(htime),    // High 구간 길이 입력
        .ltime(ltime),    // Low 구간 길이 입력
        .reset(reset),    // 리셋 입력
        .pwmout(pwmout)   // PWM 출력
    );
     
endmodule

Pwm_tb module

• PWM 회로의테스트벤치Verilog 코드작성

• clk, htime[6:0], ltime[6:0], reset

• pwmout(출력)

동작설명

• = 2 × 12.5 × 1

• 25ns 의 주기를 갖는 clk 생성

• reset 신호 생성

• htime, ltime 변수에 특정값 지정

• 시뮬레이션 종료 시간1000ns 로 지정

• pwmmodule 불러오기

RTL 설계: Testbench Simulation

시뮬레이션 출력 결과

RTL 설계: Xcelium툴 시뮬레이션을 위한 코드작성

RTL 설계: Xcelium을 위한 실행 파일 작성

<filelist>

rtl/pwm.v
rtl/pwm_tb.v

<run_xcelium.csh>

xrun -64bit -gui -f ./filelist -access +rwc -timescale 1ns/1ps

Xcelium 실행 옵션

• xrun : Xcelium 실행 명령어

• -64bit : 64비트 환경에서 실행

• -gui : gui 모드로 시뮬레이터 실행(Simvision)

• -ffilelist : 필요한 파일 목록

• -access + rwc : 변수 접근 권한(read,write,create)

• -timescale 1ns / 1ps : 시뮬레이션의 시간단위 / 정밀도

RTL 설계 : Xcelium Waveform Window

시뮬레이션 출력값

Vivado에서 검증한 값과 동일함을 확인

Synthesis

Synthesis : HDL 을 최적화된 게이트레벨 표현으로 변환하는 과정

Synthesis Design Flow

Synthesis Transformations

• RTL source 입력 및 변환: Verilog/VHDL 등으로 작성된 설계 소스준비

• Timing Constraints 입력: 타이밍, 전력, 면적 등 설계 목표를 SDC 파일 등으로입력

• 합성및최적화: 논리최적화와standard cell 라이브러리매핑을동시에수행

• 합성결과저장: .v , .sdf, .sdc 등 다양한 포맷의결과를저장

Synthesis : Timing Constraints 파일 작성

Synthesis: tcl 파일 작성 <tggenus_syn.tcl>

tclfile (Tool Command Language)

• 터미널 →vi tggenus_syn.tcl 입력

• Genus에서 쓰는 명령을 스크립트로 정리해 반복작업을 자동화

• 환경 변수부터 합성, 출력 파일까지 정의

• 1genus HiCSL 폴더에 배치

Synthesis: Genus 실행을 위한 csh 파일 생성

chmod_755 ./run_genus.csh 
./run_genus.csh

Synthesis: 출력된 Report 분석

Report_are

• 터미널 →v i ./reports_pwm / report_area.rpt

• Standard cell 을 기준으로 면적 계산

• 총면적 = 408.737 mm^2

Report_power

• v i ./reports_pwm/report_power.rpt

• 소모전력= 4.6 mW

Report_qor (Quality of Results)

• v i ./reports_pwm/report_qor.rpt

• 설계 핵심 지표를 요약

Report_timing

• 각 net 별로 도작 시간 분석

• Slack을 통해 Timing error 분석

Synthesis : Genus에서 Schematic 확인

Genus Main Window

• Genus 메인화면에서 PWM 회로도확인가능

• 확대하면 각 논리소자가 해당 표준 셀인스턴스로 매핑되어 표시

[대한 상공 회의소] 광주 인력개발원_ 프로젝트 발표회

juniha — Wed, 27 Aug 2025 15:24:00 +0900

행사 소개

행사명: AX 실무인재양성 협의체 출범 및 프로젝트 발표회
일시: 2025년 8월 7일 (목) 14:00
장소: 대한상공회의소 광주인력개발원 대강당
주최: 대한상공회의소 광주인력개발원

행사 주요 내용 요약

AI, 반도체 등 첨단산업 인재 양성을 위한 협의체 출범
지역 산업 주도의 실무인재 양성 시작을 알리는 자리
여러 프로젝트 성과 발표 및 향후 협력 방향 논의

참여 후기

지난 6개월 동안 광주 인력개발원에서 배운 내용을 바탕으로, 마지막 2인 프로젝트인 Smart Mobility Platform을 준비하여 발표할 기회를 가졌습니다. 단 5일이라는 짧은 준비 기간이었지만, 기업인사분들이 직접 참석한 자리에서 프로젝트를 소개하고 설명할 수 있었다는 점이 매우 뜻깊었습니다.학생의 시각에서 프로젝트를 바라봤을 때는 아이디어가 한정적이었지만, 이번 기회를 통해 기업인분들이 주신 여러 의견과 확장 아이디어를 접하면서 새로운 관점을 배울 수 있었습니다. “이런 방향으로 발전시켜보면 어떨까?” 하는 생각들이 떠오르면서 제 시야가 훨씬 넓어진 소중한 시간이었습니다.
이번 경험을 통해 단순한 기술 구현을 넘어, 현장에서 요구되는 실질적인 가치와 확장 가능성을 고민하는 태도의 중요성을 깨달았습니다. 앞으로도 이런 기회를 발판 삼아 더 배우고 성장해 나가고 싶습니다.
발표 과정에서는 긴장도 많이 했지만, 실제 기업 관계자분들 앞에서 설명하는 경험은 앞으로 취업 시장을 준비하는 데에 있어 큰 자산이 될 것이라 생각합니다. 특히 기업인분들의 다양한 질문과 관심이 처음에는 부담스럽게 느껴졌지만, 설명을 이어가면서 점점 제 발표 능력이 향상되는 것을 체감할 수 있었습니다.

[Project]Smart Mobility platform

juniha — Wed, 27 Aug 2025 14:47:06 +0900

Main Title : Smart Mobility platform

Subtitle
AXI-based Real - time Attitude Stabilization and Autonomous Obstacle Avoidance SoC Platform via 2D Distance Mapping

Development Environment & Tools

FPGA (Basys3): Xilinx Vivado
- Block Design, IP Integration, Verilog Compilation
Embedded SW Development: Xilinx Vitis
- Platform Creation, C Application
Simulation & Debugging:
- Vivado Simulator, Logic Analyzer, UART Monitor (CoolTerm)
Python & Scripting: LUT Generation

Programming Languages

Verilog HDL: Custom MyIP (FSM, Cartesian Transform, PWM, etc.)
C: I²C Control, AXI Register Access, LCD/OLED/UART Logic
Python: Sin/Cos LUT Auto-Generation Script

AXI4_Lite Interface

[그림 1] AXI Read & Write Channels

AXI4-Lite

For simple, low-throughput memory-mapped communication
(Example: to and from control and status registers)

Transfer Timing Diagram

[그림 2] Transfer Timing Diagram

AXI4_Transactions

[그림 3] AXI Read Transactions

[그림 4] AXI Write Transactions

[그림 5] AXI4 Signals

System Architecture

[그림 6] System Architecture

PWM (DC 모터)

Forward Mode

Start 버튼을 누르면 차량이 앞으로 이동합니다.
Stop 버튼을 누르면 정지합니다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

Turning Mode

Left / Right 버튼을 누르면 한쪽 바퀴가 회전하여 차량의 방향을 전환합니다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

Precise Angle Control

모터의 회전 시간을 기준으로 PWM 듀티 비율을 세밀하게 조정합니다.
일정하고 짧은 회전 시간 동안 동작하여 차량은 매번 약 10도씩 회전하며, 정확한 방향 제어가 가능합니다.
10도씩 회전하는 이유는 초음파 센서와 동일한 각도로 움직이기 위해 10도씩 회전하도록 설정하였습니다.

PWM (Servo_Motor)

원하는 각도는 스위치를 통해 선택되며, FND에는 현재 서보 각도가 10° 단위로 표시됩니다.
Enable 신호가 활성화되면 서보 모터는 10°씩 단계적으로 연속 회전합니다.

[그림 7 Servo_Motor ]

Servo Motor 1

회전 범위: 0° ~ 180°
환경 스캐닝(거리 측정) 용도로 사용

Servo Motor 2

프로토타입 구조상 회전 범위가 **0° ~ 140°**로 제한됨
초음파 센서와 결합되어 방향 제어 수행
최종 각도는 MPU6050 자세 데이터에 따라 보정됨

Auto-Leveling Behavior

자이로스코프가 수평 상태를 감지하면, Servo 2는 자동으로 **70°**로 설정됨
초음파 센서가 항상 수평 정렬 상태를 유지하도록 보장

Ultrasonic Sensor (HC-SR04)

초기 상태에서는 현재 서보 모터의 각도가 FND에 표시됩니다.
모드가 변경되면 FND에 초음파 센서로부터의 실시간 거리 값이 표시됩니다.
리셋 후 서보 모터는 0° 초기 위치로 복귀합니다.

Direction Selection Based on Distance Data

총 19개 방향(10° 간격)에서 거리 데이터를 수집합니다.
가장 먼 거리를 가진 방향을 식별합니다.
초음파 센서는 자동으로 회전하여 가장 먼 방향을 향합니다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

Temperature and Humidity Sensor (DHT11)

DHT11 센서를 이용해 주변 온도를 측정하고, 이를 초음파 거리 보정에 적용하여 오차를 줄입니다.
보정된 거리 값은 FND에 표시됩니다.

Distance Adjustment Values per Temperature

[그림 7] Distance Adjustment Values per Temperature

Equdation

[그림 8] Equation

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

I2C Communication Protocol

I2C OLED Display

MPU6050 센서 데이터를 I2C를 통해 OLED에 표시
자세(Attitude) 데이터를 실시간 OLED 화면으로 출력

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

UART Serial Output

MPU6050 센서 데이터를 UART로 출력
자세(Attitude) 데이터를 UART 직렬 통신으로 전송

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

Python Script Automation

Purpose

FPGA 메모리 IP에서 사용할 사인/코사인 값(.coe 파일) 을 자동 생성

Key Features

0° ~ 180° 구간에서 10° 간격으로 총 19개 포인트 샘플링
sin(θ), cos(θ) 값을 Q1.15 형식(16비트 signed 정수) 으로 변환
Vivado Block Memory Generator에서 사용할 수 있는 .coe 파일 자동 생성
생성 예시 파일: sin_lut.coe, cos_lut.coe

[그림 9] sin & cos Value Generator / .coe

Proto Type

[그림 10 ] Proto Type

Specific

MPU6050 기반 자세 안정화
0°~180° 스윕을 통한 장애물 거리 스캔
HC-SR04 & DHT11을 활용한 온도 보정 거리 측정
(각도, 거리) 데이터를 (X, Y) 좌표로 변환하여 2D 매핑
자율 장애물 회피 기능 구현

Implemented Code

https://juniha.tistory.com/134

[Smart Mobility platform] Implemented Code

AXI_Sensor IP 1. 사용 코드 _ Ultrasonic_DHT11// ============================================================================// module: ultrasonic_correction_dht11// - 초음파(raw) + DHT11(온도) → 보정된 거리(dist_corr)// - 나눗셈을 순

juniha.tistory.com

Summary & Conclusion

구현 과정

Summary & Conclusion

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

[그림 12] I2C_LCD / OLED 출력

[Smart Mobility platform] Implemented Code

juniha — Thu, 7 Aug 2025 10:24:09 +0900

AXI_Sensor IP

1. 사용 코드 _ Ultrasonic_DHT11

// ============================================================================
// module: ultrasonic_correction_dht11
//  - 초음파(raw) + DHT11(온도) → 보정된 거리(dist_corr)
//  - 나눗셈을 순차 서브트랙터(divider)로, 곱셈·나눗셈 파이프라이닝 적용
//  - 원 구조와 제어 흐름은 그대로 유지
// ============================================================================
module ultrasonic_correction_dht11 (
    input          iCLK,        // 시스템 클럭 (100MHz 가정)
    input          iRSTn,       // Active-low 리셋
    input          iEN,         // 초음파 측정 트리거(1clk 엣지)
    inout          ioDATA_DHT11,// DHT11 데이터 라인
    input          iECHO,       // 초음파 Echo 입력
    output         oTRIG,       // 초음파 Trig 출력
    output [11:0]  oDIST_CORR   // 보정된 거리(cm)
);

    //==========================================================================
    // 1) 내부 신호 선언
    //==========================================================================
    wire  [11:0] dist_raw;        // raw 거리(cm)
    wire   [7:0] temperature;     // DHT11 온도(°C)
    reg   [11:0] dist_corr;       // 보정 거리 출력

    // 파이프 스테이지 #1: 음속 인자 (0.1m/s 단위)
    reg   [11:0] factor_reg;
    // 파이프 스테이지 #2: 거리×인자 (24비트)
    reg   [23:0] mult_reg;
    // 파이프 스테이지 #3: 순차 뺄셈 나눗셈
    reg   [23:0] div_reg;
    reg   [11:0] quot_reg;
    reg          div_busy;

    //==========================================================================
    // 2) 출력 매핑
    //==========================================================================
    assign oDIST_CORR = dist_corr;

    //==========================================================================
    // 3) 하위 모듈 인스턴스화
    //==========================================================================
    ultrasonic_sensor u_us (
        .iCLK   (iCLK),
        .iRSTn  (iRSTn),
        .iEN    (iEN),
        .iECHO  (iECHO),
        .oTRIG  (oTRIG),
        .oDIST  (dist_raw),
        .oLED_DEBUG()
    );

    dht11_cntr u_dht (
        .iCLK        (iCLK),
        .iRSTn       (iRSTn),
        .ioDATA_DHT11(ioDATA_DHT11),
        .oHUMI       (),
        .oTEMP       (temperature),
        .oLED_DEBUG  ()
    );

    //==========================================================================
    // 4) 파이프라인 스테이지 #1: factor = (3310 + 6*T)/10  → 0.1m/s 단위
    //    6*T = (T<<2)+(T<<1), 3310는 상수
    //==========================================================================
    always @(posedge iCLK or negedge iRSTn) begin
        if (!iRSTn) begin
            factor_reg <= 12'd0;
        end else begin
            // 온도 기반 음속 인자 계산 (0.1m/s 단위)
            // 331.0m/s → 3310(0.1m/s), 0.6*T → 6*T
            factor_reg <= 12'd3310
                        + (temperature << 2)
                        + (temperature << 1);
        end
    end


    //==========================================================================
    // 5) 파이프라인 스테이지 #2: raw(cm) × factor(0.1m/s 단위): 시프트+덧셈 누적
    //==========================================================================
    integer i;
    always @(posedge iCLK or negedge iRSTn) begin
        if (!iRSTn) begin
            mult_reg <= 24'd0;
        end else begin
            for (i = 0; i < 12; i = i + 1) begin
                if (factor_reg[i])
                    mult_reg = mult_reg + ({12'd0, dist_raw} << i);
            end
        end
    end

    //==========================================================================
    // 6) 파이프라인 스테이지 #3: 순차적 나눗셈(div_reg ÷ 3430) → quot_reg
    //    - iEN 펄스가 오면 mult_reg 적재 후 busy 시작
    //    - 매 클럭 div_reg>=3430 이면 빼고 quot_reg++
    //    - div_reg<3430 이면 종료하고 결과 저장
    //==========================================================================
    always @(posedge iCLK or negedge iRSTn) begin
        if (!iRSTn) begin
            div_reg   <= 24'd0;
            quot_reg  <= 12'd0;
            dist_corr <= 12'd0;
            div_busy  <= 1'b0;
        end
        else if (iEN) begin
            // 새로운 측정 트리거
            div_reg   <= mult_reg;
            quot_reg  <= 12'd0;
            div_busy  <= 1'b1;
        end
        else if (div_busy) begin
            if (div_reg >= 24'd3430) begin
                // 빼기 반복
                div_reg  <= div_reg - 24'd3430;
                quot_reg <= quot_reg + 12'd1;
            end else begin
                // 나눗셈 완료
                div_busy  <= 1'b0;
                dist_corr <= quot_reg;
            end
        end
    end

endmodule

2. 사용코드 _Servo _tilt

//==============================================================================
// module: servo2_tilt_ctrl.v
//  - iSET_ANGLE 을 통한 단일 위치 이동 기능 추가
//  - FSM: S_IDLE → S_MOVE_SET → S_ADJUST → S_DONE → S_IDLE
//==============================================================================
module servo2_tilt_ctrl (
    input                   iCLK,         // 100 MHz 시스템 클럭
    input                   iRSTn,        // Active-low 리셋
    input                   iEN,          // 자동 보정 트리거(상승 엣지)
    input           [3:0]   iSET_ANGLE,   // 임의 이동 스텝(0~14)
    input   signed  [15:0]   iPITCH,       // MPU6050 피치 값(° 단위)
    output                  oSERVO_2,      // 서보2 PWM 출력
    output                  oEN_SERVO_1,  // Servo 1 트리거 신호로 재사용
    output          [7:0]   oANGLE2_CUR,  // 현재 서보2 각도(°)
    output          [15:0]  oLED_DEBUG    // 디버그용(상태 표시)
);

    //--------------------------------------------------------------------------
    // 1) 파라미터 선언
    //--------------------------------------------------------------------------
    localparam SYS_CLK_FREQ     = 100_000_000;   // 100 MHz
    localparam MYCLK_FREQ       = 2;             // 0.5 s 토글
    localparam VALUE_COUNT_SEC  = SYS_CLK_FREQ/(2*MYCLK_FREQ);
    localparam WIDTH_SEC        = $clog2(VALUE_COUNT_SEC);

    localparam CNT_MIN          = 4;   // 0° 듀티 (0.44 ms)
    localparam MAX_STEP         = 14;  // 0~14 → 0°~140°, 10° 단위

    //--------------------------------------------------------------------------
    // 2) 0.5 s 클럭 생성 & 네거티브 엣지 검출
    //--------------------------------------------------------------------------
    reg [WIDTH_SEC-1:0] rCnt_sec;
    reg                 rClk_sec;
    always @(posedge iCLK or negedge iRSTn) begin
        if (!iRSTn) begin
            rCnt_sec <= 0;
            rClk_sec <= 0;
        end
        else if (rCnt_sec == VALUE_COUNT_SEC-1) begin
            rCnt_sec <= 0;
            rClk_sec <= ~rClk_sec;
        end else
            rCnt_sec <= rCnt_sec + 1;
    end

    wire wClk_sec_neg;
    edge_detector u_edge_sec (
        .iCLK      (iCLK),
        .iRSTn     (iRSTn),
        .iSIG      (rClk_sec),
        .oEDGE_NEG (wClk_sec_neg)
    );
    
    wire wCLK_1M_neg;
    clock_div_1ms (
        .iCLK(iCLK),
        .iRSTn(iRSTn),
        .oEDGEn_DIV_1000(wCLK_1M_neg)
    );
    
    reg en_servo_1;
    assign oEN_SERVO_1 = en_servo_1;  // Servo_1 트리거로 재활용

    //--------------------------------------------------------------------------
    // 3) PWM 서보 IP 인스턴스
    //--------------------------------------------------------------------------
    reg  [3:0] rStep;                 // 0~14 스텝
    wire [7:0] wDuty2 = CNT_MIN + rStep;
    pwm_servo_180 u_pwm2 (
        .iCLK  (iCLK),
        .iRSTn (iRSTn),
        .iDUTY (wDuty2),
        .oPWM  (oSERVO_2)
    );

    //--------------------------------------------------------------------------
    // 4) 현재 각도(°) 출력
    //--------------------------------------------------------------------------
    assign oANGLE2_CUR = rStep * 10;

    //--------------------------------------------------------------------------
    // 5) prevEN, prevSET 샘플링
    //--------------------------------------------------------------------------
    reg       prevEN;
    reg [3:0] prevSET;
    always @(posedge iCLK or negedge iRSTn) begin
        if (!iRSTn) begin
            prevEN  <= 1'b0;
            prevSET <= 4'd0;
        end else begin
            prevEN  <= iEN;
            prevSET <= iSET_ANGLE;
        end
    end

    //--------------------------------------------------------------------------
    // 6) FSM 정의
    //--------------------------------------------------------------------------
    localparam [3:0]
        S_IDLE      = 4'b0001,
        S_MOVE_SET  = 4'b0010,  // ★ 임의 위치 이동
        S_ADJUST    = 4'b0100,  // 자동 보정
        S_DONE      = 4'b1000;

    reg [3:0] state, next_state;
    assign oLED_DEBUG = {en_servo_1, 11'd0, ~state};

    // Next-state 로직
    always @(*) begin
        next_state = state;
        case (state)
            S_IDLE: begin
                if (prevSET != iSET_ANGLE)
                    next_state = S_MOVE_SET;
                else if (!prevEN && iEN)
                    next_state = S_ADJUST;
            end

            S_MOVE_SET: begin
                // 0.5 s 후 완료
                if (wClk_sec_neg)
                    next_state = S_IDLE;
            end

            S_ADJUST: begin
                // 수평(스텝7) 도달 후 완료
                if ((rStep == 7) && wCLK_1M_neg)
                    next_state = S_DONE;
            end

            S_DONE: begin
                // DONE 후 바로 IDLE 복귀
                next_state = S_IDLE;
            end
        endcase
    end

    // State 레지스터 + rStep 제어
    always @(posedge iCLK or negedge iRSTn) begin
        if (!iRSTn) begin
            state <= S_IDLE;
            rStep <= 4'd7;  // 초기 수평(70°)
            en_servo_1 <= 0;
        end
        else begin
            state <= next_state;
            case (state)
                S_IDLE: begin
                    
                end

                S_MOVE_SET: begin
                    // ★ iSET_ANGLE 위치로 단일 이동
                    if (wClk_sec_neg && iSET_ANGLE <= MAX_STEP)
                        rStep <= iSET_ANGLE;
                end

                S_ADJUST: begin
                    // ★ iPITCH 기반 자동 보정
                    en_servo_1 <= 0;
                    if (wClk_sec_neg) begin
                        if (iPITCH >  3 && rStep < MAX_STEP)
                            rStep <= rStep + 1;
                        else if (iPITCH < -3 && rStep > 0)
                            rStep <= rStep - 1;
                        else
                            rStep <= 7;
                    end
                end

                S_DONE: begin
                    en_servo_1 <= 1;
                end
            endcase
        end
    end

endmodule

3. 사용 코드_Servo1_PWM

module servo_pwm_top (
    input          iCLK,        // 100MHz 시스템 클럭
    input          iRSTn,       // Active-low 리셋
    input          iEN,         // ★ 스윕 트리거 (상승 엣지)
    input   [4:0]  iSET_ANGLE,  // ★ 설정 각도 인덱스(0~18)
    output         oEN_SONIC,   // 거리 센서 트리거 신호로 재사용
    output         oSERVO,      // 서보 PWM 출력
    output  [4:0]  oANGLE_CUR,  // 현재 각도(°)
    output  [15:0] oLED_DEBUG
);

    //======================================================================
    // 1) 파라미터 선언
    //======================================================================
    localparam SYS_CLK_FREQ   = 100_000_000;
    localparam MYCLK_FREQ     = 2;                    // 0.5s 토글
    localparam VALUE_COUNT_SEC= SYS_CLK_FREQ/(2*MYCLK_FREQ);
    localparam WIDTH_SEC      = $clog2(VALUE_COUNT_SEC);

    localparam CNT_MIN        = 4;    // 0도 대응 (0.44ms)
    localparam CNT_MAX        = 22;   // 180도 대응 (2.44ms)
    localparam MAX_STEP       = 18;   // 0~18 → 0~180° (10° 단위)

    //======================================================================
    // 2) 500ms 타이밍 생성 & 네거티브 엣지 검출
    //======================================================================
    reg [WIDTH_SEC-1:0] rCnt_sec;
    reg                 rClk_sec;
    always @(posedge iCLK or negedge iRSTn) begin
        if (!iRSTn) begin
            rCnt_sec <= 0;
            rClk_sec <= 0;
        end else if (rCnt_sec == VALUE_COUNT_SEC-1) begin
            rCnt_sec <= 0;
            rClk_sec <= ~rClk_sec;
        end else
            rCnt_sec <= rCnt_sec + 1;
    end

    wire wClk_sec_neg;
    edge_detector UED (
        .iCLK    (iCLK),
        .iRSTn   (iRSTn),
        .iSIG    (rClk_sec),
        .oEDGE_NEG(wClk_sec_neg)
    );

    assign oEN_SONIC = wClk_sec_neg;  // 거리 센서 트리거로 재활용

    //======================================================================
    // 3) PWM 서보 드라이버 인스턴스
    //======================================================================
    // ★ FSM 출력 rDUTY (0~18)에 CNT_MIN 더해서 실제 듀티 생성
    reg  [7:0]    rDUTY;
    wire [4:0]    wPWM_DUTY = CNT_MIN + rDUTY;
    pwm_servo_180 U_SERVO (
        .iCLK    (iCLK),
        .iRSTn   (iRSTn),
        .iDUTY   (wPWM_DUTY),
        .oPWM    (oSERVO)
    );

    //======================================================================
    // 4) 현재 각도 & FND 표시
    //======================================================================
    // 10도 단위 → 실제 각도(°)
    assign oANGLE_CUR = rDUTY;

    //======================================================================
    // 5) FSM: IDLE → MOVE_SET → SWEEP → DONE → IDLE
    //======================================================================
    // ★ 상승 엣지/값 변경 감지용 레지스터
    reg       prevEN;
    reg [4:0] prevSET;
    always @(posedge iCLK or negedge iRSTn) begin
        if (!iRSTn) begin
            prevEN  <= 1'b0;
            prevSET <= 5'd0;
        end else begin
            prevEN  <= iEN;
            prevSET <= iSET_ANGLE;
        end
    end

    // 상태 정의
    localparam [3:0]
        S_IDLE     = 4'b0001,
        S_MOVE_SET = 4'b0010,
        S_SWEEP    = 4'b0100,
        S_DONE     = 4'b1000;

    reg [3:0] state, next_state;
    reg [4:0] rStep;  // 스윕 카운터 (0~18)

    assign oLED_DEBUG = ~state;

    // Next-State 로직
    always @(*) begin
        next_state = state;
        case (state)
            S_IDLE:
                // SET 값이 바뀌면 단일 이동
                if (prevSET != iSET_ANGLE)
                    next_state = S_MOVE_SET;
                // iEN 상승 엣지 시 전체 스윕
                else if (!prevEN && iEN)
                    next_state = S_SWEEP;
            S_MOVE_SET:
                // 1회 이동 후 바로 IDLE 복귀
                if (wClk_sec_neg)
                    next_state = S_IDLE;
            S_SWEEP:
                // 스텝 끝나면 DONE
                if (wClk_sec_neg && rStep == MAX_STEP)
                    next_state = S_DONE;
            S_DONE:
                // DONE 후 IDLE
                next_state = S_IDLE;
        endcase
    end

    // State 레지스터 + 출력 제어
    always @(posedge iCLK or negedge iRSTn) begin
        if (!iRSTn) begin
            state <= S_IDLE;
            rDUTY  <= 8'd0;
            rStep  <= 5'd0;
        end else begin
            state <= next_state;

            case (state)
                S_IDLE: begin
                    // 스윕 시작 시 스텝 카운터 리셋
                    if (!prevEN && iEN)
                        rStep <= 5'd0;
                end

                S_MOVE_SET: begin
                    // 단일 위치 이동: wClk_sec_neg 타이밍에 iSET_ANGLE 적용
                    if (wClk_sec_neg)
                        rDUTY <= iSET_ANGLE;
                end

                S_SWEEP: begin
                    // 전체 스윕: wClk_sec_neg마다 rStep→rDUTY
                    if (wClk_sec_neg) begin
                        rDUTY <= rStep;
                        rStep <= rStep + 1;
                    end
                end

                S_DONE: begin
                    rDUTY <= 9;
                end
            endcase
        end
    end

endmodule

4. 사용 코드 _좌표 변환

module cartesian_transform (
    input                               clk,        // 시스템 클럭
    input                               rstn,       // Active-low reset
    input      [4:0]                    angle_idx,  // 0→0°, 1→10° … 18→180°
    input      [11:0]                   dist_in,    // 보정된 거리(cm)
    output reg                          oREADY,
    output reg signed [11:0]            x_out,      // 변환된 X (cm)
    output reg signed [11:0]            y_out       // 변환된 Y (cm)
);

    // 고정소수점 폭
    localparam FP_BITS = 16;

    // 정수×고정소수점 곱셈 결과 폭
    wire signed [12+FP_BITS-1:0] mult_x;  
    wire signed [12+FP_BITS-1:0] mult_y;  

    // ★ sin/cos 값을 직접 할당할 레지스터
    reg signed [FP_BITS-1:0] sin_val;     // Q1.15
    reg signed [FP_BITS-1:0] cos_val;     // Q1.15

    // ① angle_idx 혹은 dist_in 이 바뀌면 새로운 좌표를 계산하고,
    //    그 계산값이 register에 승격되는 클럭 타이밍에 coord_valid 를 1로.
    wire new_input = (angle_idx != prev_angle_idx) || (dist_in != prev_dist_in);
    
    // ② prev_angle_idx, prev_dist_in 저장
    reg [4:0]  prev_angle_idx;
    reg [11:0] prev_dist_in;
    always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
        prev_angle_idx <= 0;
        prev_dist_in   <= 0;
      end else begin
        prev_angle_idx <= angle_idx;
        prev_dist_in   <= dist_in;
      end
    end
    
    // ③ coord_valid 펄스 생성
    reg coord_valid;
    always @(posedge clk or negedge rstn) begin
      if (!rstn)           coord_valid <= 1'b0;
      else if (new_input)  coord_valid <= 1'b1;
      else                  coord_valid <= 1'b0;
    end
    
    // ④ 바로 위 방법대로 oCOORD_RDY 펄스 만들기
    reg prev_coord_valid;
    always @(posedge clk or negedge rstn) begin
      if (!rstn)            prev_coord_valid <= 1'b0;
      else                  prev_coord_valid <= coord_valid;
    end
    
    always @(posedge clk or negedge rstn) begin
      if (!rstn)            oREADY <= 1'b0;
      else                  oREADY <= coord_valid & ~prev_coord_valid;
    end

    //--------------------------------------------------------------------------
    // 1) combinational LUT: angle_idx → sin_val, cos_val
    //--------------------------------------------------------------------------
    always @* begin
        case(angle_idx)
            // -- sin 테이블 (Q1.15)
            5'd0 :  sin_val = 16'h0000;
            5'd1 :  sin_val = 16'h163A;
            5'd2 :  sin_val = 16'h2BC7;
            5'd3 :  sin_val = 16'h4000;
            5'd4 :  sin_val = 16'h5247;
            5'd5 :  sin_val = 16'h620E;
            5'd6 :  sin_val = 16'h6EDA;
            5'd7 :  sin_val = 16'h7848;
            5'd8 :  sin_val = 16'h7E0E;
            5'd9 :  sin_val = 16'h8000;
           5'd10 :  sin_val = 16'h7E0E;
           5'd11 :  sin_val = 16'h7848;
           5'd12 :  sin_val = 16'h6EDA;
           5'd13 :  sin_val = 16'h620E;
           5'd14 :  sin_val = 16'h5247;
           5'd15 :  sin_val = 16'h4000;
           5'd16 :  sin_val = 16'h2BC7;
           5'd17 :  sin_val = 16'h163A;
           5'd18 :  sin_val = 16'h0000;
            default: sin_val = 16'h0000;
        endcase
    end

    always @* begin
        case(angle_idx)
            // -- cos 테이블 (Q1.15)
            5'd0 :  cos_val = 16'h8000;
            5'd1 :  cos_val = 16'h7E0E;
            5'd2 :  cos_val = 16'h7848;
            5'd3 :  cos_val = 16'h6EDA;
            5'd4 :  cos_val = 16'h620E;
            5'd5 :  cos_val = 16'h5247;
            5'd6 :  cos_val = 16'h4000;
            5'd7 :  cos_val = 16'h2BC7;
            5'd8 :  cos_val = 16'h163A;
            5'd9 :  cos_val = 16'h0000;
           5'd10 :  cos_val = 16'hE9C6;
           5'd11 :  cos_val = 16'hD439;
           5'd12 :  cos_val = 16'hC000;
           5'd13 :  cos_val = 16'hADB9;
           5'd14 :  cos_val = 16'h9DF2;
           5'd15 :  cos_val = 16'h9126;
           5'd16 :  cos_val = 16'h87B8;
           5'd17 :  cos_val = 16'h81F2;
           5'd18 :  cos_val = 16'h8000;
            default: cos_val = 16'h8000;
        endcase
    end

    //--------------------------------------------------------------------------
    // 2) 곱셈
    //    dist_in: unsigned[11:0], sin_val/cos_val: signed[15:0]
    //    → signed[27:0] 결과
    //--------------------------------------------------------------------------
    assign mult_x = $signed({1'b0, dist_in}) * sin_val;
    assign mult_y = $signed({1'b0, dist_in}) * cos_val;

    //--------------------------------------------------------------------------
    // 3) Q1.15 → 정수(cm) 변환: 위 곱셈 결과의 상위 비트 취함
    //    mult_x[27:15]  → signed[12:0] → x_out[11:0]으로 트렁케이트
    //--------------------------------------------------------------------------
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            x_out <= 0;
            y_out <= 0;
        end else begin
            x_out <= mult_x[27:16];  // (11+16-1 down to 16)
            y_out <= mult_y[27:16];
        end
    end

endmodule

AXI_VIHICLE_IP

1. 사용 코드 _DCMotor

// ============================================================================
// motor_autonomous_ctrl.v
//  - one-hot 5상태 FSM
//  - ST_IDLE → ST_FWD(지속) → ST_LEFT/RIGHT(0.245s) → ST_STOP(1clk) → ST_IDLE
// ============================================================================
module motor_autonomous_ctrl (
    input          iCLK,        // 100 MHz 시스템 클럭
    input          iRSTn,       // Active-low 리셋
    input          iEN_START,  // 전진 버튼 (펄스)
    input          iEN_STOP,   // 정지 버튼 (펄스)
    input          iEN_LEFT,   // 좌회전 버튼 (펄스)
    input          iEN_RIGHT,  // 우회전 버튼 (펄스)
    output         oMOTOR_A1,   // 왼쪽 모터 전진
    output         oMOTOR_A2,   // 왼쪽 모터 후진 (사용 안 함)
    output         oMOTOR_B1,   // 오른쪽 모터 전진
    output         oMOTOR_B2,   // 오른쪽 모터 후진 (사용 안 함)
    output [15:0]  oLED_DEBUG
);

    //--------------------------------------------------------------------------
    // 1) 상태(one-hot 5비트) 정의
    //--------------------------------------------------------------------------
    localparam [4:0]
        S_IDLE  = 5'b00001,  // 대기
        S_FWD   = 5'b00010,  // 전진(지속)
        S_STOP  = 5'b00100,  // 정지(1clk)
        S_LEFT  = 5'b01000,  // 좌회전(0.245s)
        S_RIGHT = 5'b10000;  // 우회전(0.245s)

    //--------------------------------------------------------------------------
    // 2) 0.245 s 타이머 (100 MHz → 24_500_000 클럭)
    //--------------------------------------------------------------------------
    localparam  ROTATE_TIME = 24_500_000;  // 10도 회전
    localparam  WIDTH_RT    = $clog2(ROTATE_TIME);

    //--------------------------------------------------------------------------
    // 3) 내부 신호
    //--------------------------------------------------------------------------
    wire                      wStartEdge, wStopEdge, wLeftEdge, wRightEdge;
    reg   [4:0]               rState, rNext;
    reg   [WIDTH_RT-1:0]      rTimerCnt;

    //--------------------------------------------------------------------------
    // 4) 버튼 엣지 검출 인스턴스
    //--------------------------------------------------------------------------
    edge_detector uED_START (
        .iCLK      (iCLK),
        .iRSTn     (iRSTn),
        .iSIG      (iEN_START),
        .oEDGE_NEG (wStartEdge)
    );
    
    edge_detector uED_STOP (
        .iCLK      (iCLK),
        .iRSTn     (iRSTn),
        .iSIG      (iEN_STOP),
        .oEDGE_NEG (wStopEdge)
    );
    
    edge_detector uED_LEFT (
        .iCLK      (iCLK),
        .iRSTn     (iRSTn),
        .iSIG      (iEN_LEFT),
        .oEDGE_NEG (wLeftEdge)
    );
    
    edge_detector uED_RIGHT (
        .iCLK      (iCLK),
        .iRSTn     (iRSTn),
        .iSIG      (iEN_RIGHT),
        .oEDGE_NEG (wRightEdge)
    );

    //--------------------------------------------------------------------------
    // 5) FSM Next-State 로직 (combinational)
    //--------------------------------------------------------------------------
    always @(*) begin
        rNext = rState;
        case (rState)

            // IDLE: START만 받아서 전진으로
            S_IDLE: begin
                if      (wStartEdge)   rNext = S_FWD;
                else                   rNext = S_IDLE;
            end

            // FWD: STOP/LEFT/RIGHT 에만 반응, 아니면 계속 전진
            S_FWD: begin
                if      (wStopEdge)    rNext = S_STOP;
                else if (wLeftEdge)    rNext = S_LEFT;
                else if (wRightEdge)   rNext = S_RIGHT;
                else                   rNext = S_FWD;
            end

            // STOP: 1clk 만 유지 후 IDLE
            S_STOP: rNext = S_IDLE;

            // LEFT: 0.245s 타이머 끝나면 IDLE, 아니면 계속 LEFT
            S_LEFT: begin
                if (rTimerCnt >= ROTATE_TIME)  rNext = S_IDLE;
                else                           rNext = S_LEFT;
            end

            // RIGHT: 0.245s 타이머 끝나면 IDLE, 아니면 계속 RIGHT
            S_RIGHT: begin
                if (rTimerCnt >= ROTATE_TIME)  rNext = S_IDLE;
                else                           rNext = S_RIGHT;
            end

            // 기본 복귀
            default: rNext = S_IDLE;
        endcase
    end

    //--------------------------------------------------------------------------
    // 6) FSM 상태 & 타이머 업데이트 (sequential)
    //--------------------------------------------------------------------------
    always @(posedge iCLK or negedge iRSTn) begin
        if (!iRSTn) begin
            rState    <= S_IDLE;
            rTimerCnt <= 0;
        end else begin
            rState <= rNext;

            // 좌/우 회전 중일 때만 카운터 ↑, entry 시 리셋
            if (rState == S_LEFT || rState == S_RIGHT) begin
                if (rState != rNext)
                    rTimerCnt <= 0;
                else
                    rTimerCnt <= rTimerCnt + 1;
            end
            else
                rTimerCnt <= 0;
        end
    end

    //--------------------------------------------------------------------------
    // 7) 모터 드라이브 (combinational)
    //--------------------------------------------------------------------------
    // 전진: A1,B1 = 1
    // 정지/IDLE: 모두 0
    // 좌회전: 왼쪽 A1만 =1
    // 우회전: 오른쪽 B1만 =1
    assign oMOTOR_A1 = (rState == S_FWD) || (rState == S_LEFT);
    assign oMOTOR_A2 = 0;
    assign oMOTOR_B1 = (rState == S_FWD) || (rState == S_RIGHT);
    assign oMOTOR_B2 = 0;

    //--------------------------------------------------------------------------
    // 8) 상태 디버그 출력
    //--------------------------------------------------------------------------
    assign oLED_DEBUG[4:0] = ~rState;

endmodule

VITIS_I2C_Control

1. 사용코드 _I2c 3 Sensor (MPU6050, TXT LCD, OLED)

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "platform.h"
#include "xil_printf.h"
#include "xparameters.h"
#include "xiic.h"
#include "sleep.h"
#include "font8x8_basic.h"

//------------------------------------------------------------------------------
// I²C 마스터 & 채널
//------------------------------------------------------------------------------
static XIic   iic_inst;
#define IIC_CHNL    XPAR_AXI_IIC_0_BASEADDR

//------------------------------------------------------------------------------
// 장치 7-bit 주소
//------------------------------------------------------------------------------
#define LCD_ADDR    0x3F    // Text LCD (PCF8574 기반)
#define OLED_ADDR   0x3C    // SSD1306 OLED
#define MPU_ADDR   0x68    // MPU6050

//------------------------------------------------------------------------------
// MPU6050 레지스터
//------------------------------------------------------------------------------
#define REG_PWR_MGMT1    0x6B
#define REG_SMPLRT_DIV   0x19
#define REG_CONFIG       0x1A
#define REG_GYRO_CONFIG  0x1B
#define REG_ACCEL_CONFIG 0x1C
#define REG_ACCEL_X_H    0x3B

//------------------------------------------------------------------------------
// OLED Control 바이트
//------------------------------------------------------------------------------
#define OLED_CTL_CMD   0x00
#define OLED_CTL_DAT   0x40

//------------------------------------------------------------------------------
// ASCII 폰트 (0x20~0x7F) extern 선언
// 반드시 font8x8_basic.h 를 프로젝트에 포함해야 합니다.
extern const uint8_t font8x8_basic[96][8];

//==============================================================================
// 전역 버퍼: OLED GDDRAM 에 대응 (페이지 0~7 × 컬럼 0~127)
//==============================================================================
static uint8_t oled_buf[8][128];

//------------------------------------------------------------------------------
// mpu 함수 선언
//------------------------------------------------------------------------------
void mpu_write_reg(uint8_t reg, uint8_t val);
void mpu_read_regs(uint8_t start_reg, uint8_t *dst, int len);
static int16_t compute_mpu_pitch(int16_t ax,int16_t ay,int16_t az);

//------------------------------------------------------------------------------
// lcd 함수 선언
//------------------------------------------------------------------------------
void LCD_WriteCommand(uint8_t cmd);
void LCD_WriteData(uint8_t d);
void LCD_Init(void);
void LCD_GotoXY(uint8_t row, uint8_t col);
void LCD_WriteSignedInt(int16_t v);

//------------------------------------------------------------------------------
// oled 함수 선언
//------------------------------------------------------------------------------
void oled_write_cmd(uint8_t cmd);
void oled_write_data(uint8_t d);
void oled_init(void);
void oled_clear(void);
void oled_puts_str(int page, int col, const char *s);

//------------------------------------------------------------------------------
// oled 픽셀 그리기 & 버퍼 업데이트 함수 선언
//------------------------------------------------------------------------------
void oled_update_column(int page, int col); 
void oled_draw_pixel(int x, int y);

//==============================================================================
// main: 초기화 → 루프(읽기→UART/LCD/OLED 출력)
//==============================================================================
int main(void) {
    uint8_t buf[14];
    int16_t ax, ay, az, gx, gy, gz;

    init_platform();
    xil_printf("\n\r=== I2C 3-Sensor Integrated test ===\n\r");

    // 1) I²C 마스터 초기화·시작
    XIic_Initialize(&iic_inst, IIC_CHNL);
    XIic_Start     (&iic_inst);
    msleep(10);

    // 2) LCD 초기화
    LCD_Init();
    msleep(10);

    // 3) OLED 초기화·클리어
    oled_init();
    oled_clear();
    msleep(10);

    // 4) MPU6050 슬립 해제·감도 설정
    mpu_write_reg(REG_PWR_MGMT1,    0x00);
    mpu_write_reg(REG_SMPLRT_DIV,   0x07);
    mpu_write_reg(REG_CONFIG,       0x06);
    mpu_write_reg(REG_GYRO_CONFIG,  0x18);
    mpu_write_reg(REG_ACCEL_CONFIG, 0x10);
    msleep(10);

    // 5) 메인 루프: 250 ms 간격으로 읽고 출력
    while (1) {
        // — MPU6050 6축 읽기 —
        mpu_read_regs(REG_ACCEL_X_H, buf, 14);
        ax = (buf[0]<<8)|buf[1];
        ay = (buf[2]<<8)|buf[3];
        az = (buf[4]<<8)|buf[5];
        gx = (buf[8]<<8)|buf[9];
        gy = (buf[10]<<8)|buf[11];
        gz = (buf[12]<<8)|buf[13];

        int16_t pitch = compute_mpu_pitch(ax, ay, az);

        // — UART 출력 —
        xil_printf("AX=%6d AY=%6d AZ=%6d  pitch =%4d\n\r", ax, ay, az, pitch);

        // — LCD: 2행에 AX~GZ 한 줄씩 —
        LCD_GotoXY(0,0);
        LCD_WriteSignedInt(ax);
        LCD_WriteSignedInt(ay);
        LCD_WriteSignedInt(az);
        LCD_GotoXY(1,0);
        LCD_WriteSignedInt(gx);
        LCD_WriteSignedInt(gy);
        LCD_WriteSignedInt(gz);

        // — OLED: 페이지0~5 에 AX~GZ 한 줄씩 출력 —
        char tmp[7];
        // 6자리 문자열: 부호+4숫자 + 널
        sprintf(tmp, "%+5d", ax);
        oled_puts_str(0, 0, tmp);
        sprintf(tmp, "%+5d", ay);
        oled_puts_str(1, 0, tmp);
        sprintf(tmp, "%+5d", az);
        oled_puts_str(2, 0, tmp);
        sprintf(tmp, "%+5d", gx);
        oled_puts_str(3, 0, tmp);
        sprintf(tmp, "%+5d", gy);
        oled_puts_str(4, 0, tmp);
        sprintf(tmp, "%+5d", gz);
        oled_puts_str(5, 0, tmp);

        sleep(1);

        // — (x=64,y=32)에 점 하나 찍기 —
        oled_draw_pixel(0, 0);
        sleep(1);
        oled_draw_pixel(120, 0);
        sleep(1);
        oled_draw_pixel(120, 60);
        sleep(1);
        oled_draw_pixel(0, 60);
        sleep(1);
        oled_draw_pixel(60, 30); 
        sleep(1);
    }

    cleanup_platform();
    return 0;
}

//------------------------------------------------------------------------------
// MPU6050 I²C 쓰기 헬퍼
//------------------------------------------------------------------------------
void mpu_write_reg(uint8_t reg, uint8_t val) {
    uint8_t buf[2] = { reg, val };
    XIic_Send(iic_inst.BaseAddress, MPU_ADDR, buf, 2, XIIC_STOP);
    while (XIic_IsIicBusy(iic_inst.BaseAddress));
}

//------------------------------------------------------------------------------
// MPU6050 I²C 연속 읽기 헬퍼
//------------------------------------------------------------------------------
void mpu_read_regs(uint8_t start_reg, uint8_t *dst, int len) {
    // 1) 읽을 레지스터 주소 전송 (Repeated Start 유지)
    XIic_Send(iic_inst.BaseAddress, MPU_ADDR, &start_reg, 1, 0);
    while (XIic_IsIicBusy(iic_inst.BaseAddress));
    // 2) 바로 읽기 → STOP
    XIic_Recv(iic_inst.BaseAddress, MPU_ADDR, dst, len, XIIC_STOP);
    while (XIic_IsIicBusy(iic_inst.BaseAddress));
}

//------------------------------------------------------------------------------
// @brief 근사: raw→pitch(°) 정수
//    sqrt≈max+0.5·min, atan2≈x/(1+0.28x²)
//------------------------------------------------------------------------------
static int16_t compute_mpu_pitch(int16_t ax,int16_t ay,int16_t az) {
    const float G=4096.0f;
    float x=(float)ax/G, y=(float)ay/G, z=(float)az/G;
    float ay0=y<0?-y:y, az0=z<0?-z:z;
    float vmax= ay0>az0? ay0:az0;
    float vmin= ay0>az0? az0:ay0;
    float denom = vmax + 0.5f*vmin + 1e-6f;
    float r = x/denom;
    float rad = r/(1.0f + 0.28f*r*r);
    float deg = rad * 57.2957795f;
    return (int16_t)(deg + (deg>=0?0.5f:-0.5f));
}

//------------------------------------------------------------------------------
// Text LCD 제어 함수들 (기존 코드 그대로)
//------------------------------------------------------------------------------
void LCD_WriteCommand(uint8_t cmd) {
    uint8_t high =  cmd   & 0xF0;
    uint8_t low  = (cmd<<4)& 0xF0;
    uint8_t seq[4] = {
        high|0x0C, high|0x08,
        low |0x0C, low |0x08
    };
    XIic_Send(iic_inst.BaseAddress, LCD_ADDR, seq, 4, XIIC_STOP);
    while (XIic_IsIicBusy(iic_inst.BaseAddress));
}

void LCD_WriteData(uint8_t d) {
    uint8_t high =  d     & 0xF0;
    uint8_t low  = (d <<4)& 0xF0;
    uint8_t seq[4] = {
        high|0x0D, high|0x08,
        low |0x0D, low |0x08
    };
    XIic_Send(iic_inst.BaseAddress, LCD_ADDR, seq, 4, XIIC_STOP);
    while (XIic_IsIicBusy(iic_inst.BaseAddress));
}

void LCD_Init(void) {
    msleep(50);
    LCD_WriteCommand(0x33); msleep(5);
    LCD_WriteCommand(0x32);
    LCD_WriteCommand(0x28);
    LCD_WriteCommand(0x0F);
    LCD_WriteCommand(0x06);
    LCD_WriteCommand(0x01); msleep(5);
}

void LCD_GotoXY(uint8_t row, uint8_t col) {
    uint8_t addr = 0x80 | (row<<6) | col;
    LCD_WriteCommand(addr);
}

// 부호 포함 5자리 찍기
void LCD_WriteSignedInt(int16_t v) {
    char tmp[6];
    // "%+5d" → 항상 부호, 총 5칸
    sprintf(tmp, "%+5d", v);
    for (int i = 0; i < 5; i++) {
        LCD_WriteData((uint8_t)tmp[i]);
    }
}

//------------------------------------------------------------------------------
// OLED 제어 함수들
//------------------------------------------------------------------------------
// Control + 명령어 1바이트
void oled_write_cmd(uint8_t cmd) {
    uint8_t buf[2] = { OLED_CTL_CMD, cmd };
    XIic_Send(iic_inst.BaseAddress, OLED_ADDR, buf, 2, XIIC_STOP);
    while (XIic_IsIicBusy(iic_inst.BaseAddress));
}

// Control + 데이터 1바이트
void oled_write_data(uint8_t d) {
    uint8_t buf[2] = { OLED_CTL_DAT, d };
    XIic_Send(iic_inst.BaseAddress, OLED_ADDR, buf, 2, XIIC_STOP);
    while (XIic_IsIicBusy(iic_inst.BaseAddress));
}

// SSD1306 초기화 (페이지 주소 모드 포함)
void oled_init(void) {
    const uint8_t seq[] = {
      0xAE,           // display off
      0x20,0x02,      // page addressing mode
      0xB0,           // page0
      0x00,0x10,      // col addr = 0
      0x40,           // start line = 0
      0x81,0x7F,      // contrast
      0xA1,           // seg remap
      0xC8,           // com scan dec
      0xA6,           // normal display
      0xA8,0x3F,      // multiplex 1/64
      0xD3,0x00,      // display offset
      0xD5,0x80,      // clk div
      0xD9,0x22,      // pre-charge
      0xDA,0x12,      // com pins
      0xDB,0x20,      // vcomh
      0x8D,0x14,      // charge pump on
      0xAF            // display on
    };
    for (int i = 0; i < (int)sizeof(seq); i++) {
        oled_write_cmd(seq[i]);
    }
}

// 전체 화면 클리어
void oled_clear(void) {
    for (int p = 0; p < 8; p++) {
        oled_write_cmd(0xB0 | p);
        oled_write_cmd(0x00);
        oled_write_cmd(0x10);
        for (int c = 0; c < 128; c++) {
            oled_write_data(0x00);
        }
    }
}

//------------------------------------------------------------------------------
// 문자열(부호 포함 숫자) 출력 helper
//------------------------------------------------------------------------------
// page: 0~7, col: 문자 단위(0~15), s: null-terminated 문자열
void oled_puts_str(int page, int col, const char *s) {
    // 1) 페이지·컬럼 설정
    oled_write_cmd(0xB0 | page);
    uint8_t x = col * 8;
    oled_write_cmd(0x00 | (x & 0x0F));
    oled_write_cmd(0x10 | ((x >> 4) & 0x0F));
    // 2) 글자별 8바이트 폰트 전송
    while (*s) {
        uint8_t buf[9];
        buf[0] = OLED_CTL_DAT;
        // ASCII 0x20~0x7F 대응
        memcpy(buf+1, font8x8_basic[(uint8_t)*s - 0x20], 8);
        XIic_Send(iic_inst.BaseAddress, OLED_ADDR, buf, 9, XIIC_STOP);
        while (XIic_IsIicBusy(iic_inst.BaseAddress));
        s++;
    }
}

//------------------------------------------------------------------------------
// OLED 픽셀 업데이트: 버퍼→실제 GDDRAM (한 컬럼만 갱신)
//------------------------------------------------------------------------------
void oled_update_column(int page, int col) { 
    oled_write_cmd(0xB0 | page);              // page 설정
    oled_write_cmd(0x00 | (col & 0x0F));      // col low
    oled_write_cmd(0x10 | ((col>>4)&0x0F));   // col high
    oled_write_data(oled_buf[page][col]);     // 버퍼값 전송
}

//------------------------------------------------------------------------------
// (x,y) 에 1픽셀 그리기 (버퍼 갱신 + 해당 컬럼만 갱신)
//------------------------------------------------------------------------------
void oled_draw_pixel(int x, int y) {       
    if (x<0||x>127||y<0||y>63) return;
    int page = y / 8;
    int bit  = y % 8;
    oled_buf[page][x] |= (1<<bit);            // 버퍼에 비트 세팅
    oled_update_column(page, x);              // 실제 화면에 바로 반영
}

Final System Control ( Vitis C )

1. 사용 코드_ Final C 동작제어 코드

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "platform.h"
#include "xil_printf.h"
#include "xparameters.h"
#include "xiic.h"
#include "sleep.h"
#include "font8x8_basic.h"
#include <math.h>
#include <stdlib.h>

//------------------------------------------------------------------------------
// I²C 마스터 & 채널
//------------------------------------------------------------------------------
XIic   iic_inst;
#define IIC_CHNL    XPAR_AXI_IIC_0_BASEADDR

//------------------------------------------------------------------------------
// AXI-Sensor-Hub MMIO 베이스 주소 & 레지스터 오프셋
//------------------------------------------------------------------------------
#define HUB_BASE    XPAR_AXI_SENSOR_HUB_0_BASEADDR

//------------------------------------------------------------------------------
// 장치 7-bit 주소
//------------------------------------------------------------------------------
#define LCD_ADDR    0x3F    // Text LCD (PCF8574 기반)
#define OLED_ADDR   0x3C    // SSD1306 OLED
#define MPU_ADDR    0x68    // MPU6050

//------------------------------------------------------------------------------
// MPU6050 레지스터
//------------------------------------------------------------------------------
#define REG_PWR_MGMT1    0x6B
#define REG_SMPLRT_DIV   0x19
#define REG_CONFIG       0x1A
#define REG_GYRO_CONFIG  0x1B
#define REG_ACCEL_CONFIG 0x1C
#define REG_ACCEL_X_H    0x3B

//------------------------------------------------------------------------------
// OLED Control 바이트
//------------------------------------------------------------------------------
#define OLED_CTL_CMD   0x00
#define OLED_CTL_DAT   0x40

//------------------------------------------------------------------------------
// ASCII 폰트 (0x20~0x7F) extern 선언
// 반드시 font8x8_basic.h 를 프로젝트에 포함해야 합니다.
extern const uint8_t font8x8_basic[96][8];

//==============================================================================
// 전역 버퍼: OLED GDDRAM 에 대응 (페이지 0~7 × 컬럼 0~127)
//==============================================================================
static uint8_t oled_buf[8][128];

//------------------------------------------------------------------------------
// mpu 함수 선언
//------------------------------------------------------------------------------
void mpu_write_reg(uint8_t reg, uint8_t val);
void mpu_read_regs(uint8_t start_reg, uint8_t *dst, int len);
static int16_t compute_mpu_pitch(int16_t ax,int16_t ay,int16_t az);

//------------------------------------------------------------------------------
// lcd 함수 선언
//------------------------------------------------------------------------------
void LCD_WriteCommand(uint8_t cmd);
void LCD_WriteData(uint8_t d);
void LCD_Init(void);
void LCD_GotoXY(uint8_t row, uint8_t col);
void LCD_WriteSignedInt(int16_t v);

//------------------------------------------------------------------------------
// oled 함수 선언
//------------------------------------------------------------------------------
void oled_write_cmd(uint8_t cmd);
void oled_write_data(uint8_t d);
void oled_init(void);
void oled_clear(void);
void oled_puts_str(int page, int col, const char *s);

//------------------------------------------------------------------------------
// oled 픽셀 그리기 & 버퍼 업데이트 함수 선언
//------------------------------------------------------------------------------
void oled_update_column(int page, int col); 
void oled_draw_pixel(int x, int y);

//==============================================================================
// main: 초기화 → 2D 매핑 → 최적 각도로 서보1 회전
//==============================================================================
int main(void) {
    uint8_t buf[14];
    int16_t ax, ay, az;

    init_platform();
    xil_printf("\n\r=== I2C Stabilization & Avoidance Test ===\n\r");

    volatile unsigned int *hub_reg = (volatile unsigned int *)HUB_BASE;
    //hub_reg[0] -> set_angle_1(wd)
    //hub_reg[1] -> set_angle_2(wd)
    //hub_reg[2] -> en_servo_2(wd)
    //hub_reg[3] -> mpu_pitch(wd)
    //hub_reg[4] -> x_out(rd)
    //hub_reg[5] -> y_out(rd)
    //hub_reg[6] -> ready(rd)

    // 1) I²C 마스터 초기화·시작
    XIic_Initialize(&iic_inst, IIC_CHNL);
    XIic_Start     (&iic_inst);
 //   msleep(10);

    // 2) LCD 초기화
    LCD_Init();
  //  msleep(10);

    // 3) OLED 초기화·클리어
    oled_init();
    oled_clear();
    msleep(10);

    // 4) MPU6050 슬립 해제·감도 설정
    mpu_write_reg(REG_PWR_MGMT1,    0x00);
    mpu_write_reg(REG_SMPLRT_DIV,   0x07);
    mpu_write_reg(REG_CONFIG,       0x06);
    mpu_write_reg(REG_GYRO_CONFIG,  0x18);
    mpu_write_reg(REG_ACCEL_CONFIG, 0x10);
 //   msleep(10);

    // 5) 메인 루프: 250 ms 간격으로 읽고 출력
    while (1) {
        hub_reg[0] = 14;
        hub_reg[1] = 3;
        hub_reg[2] = 0;
        hub_reg[3] = 0;

        const int NSTEP = 19;        // 0~18 인덱스
        int x_arr[NSTEP], y_arr[NSTEP];
        
        hub_reg[0] = 9;
        msleep(100);
        hub_reg[1] = 10;
        msleep(100);
        // — MPU6050 6축 읽기 —
        mpu_read_regs(REG_ACCEL_X_H, buf, 14);
        ax = (buf[0]<<8)|buf[1];
        ay = (buf[2]<<8)|buf[3];
        az = (buf[4]<<8)|buf[5];
        // gx = (buf[8]<<8)|buf[9];
        // gy = (buf[10]<<8)|buf[11];
        // gz = (buf[12]<<8)|buf[13];

        // “틸트(pitch)” 계산
        int16_t mpu_pitch = compute_mpu_pitch(ax, ay, az);

        // — UART 출력 —
        xil_printf("AX =%6d AY =%6d AZ =%6d     mpu_pitch =%4d\n\r", ax, ay, az, mpu_pitch);
//        msleep(100);

        LCD_GotoXY(0,0);
        LCD_WriteSignedInt(ax);
        LCD_WriteSignedInt(ay);
        LCD_WriteSignedInt(az);
print("1");
        hub_reg[2] = 1;
        usleep(1);

        print("2");


         msleep(10);
         hub_reg[3] = mpu_pitch;
print("3");

        oled_clear();
print("4");

        for (int idx = 0; idx < NSTEP; idx++) {
            // 1) trigger servomove/setangle 은 이미 밖에서 함
            // 2) hub_reg[6] 이 1 될 때까지 기다린다
            xil_printf("idx = %d", idx);

            while ((hub_reg[6] & 0x1) == 0) {
                usleep(1);
            }
            // 3) 1 이 올라왔으면 단 한 번만 읽고
            x_arr[idx] = (int)hub_reg[4];
            y_arr[idx] = (int)hub_reg[5];
            oled_draw_pixel(x_arr[idx], y_arr[idx]);
            // 4) flag clear
            hub_reg[6] = 0;
        }
        print("1");
print("20");

        msleep(100);

        // 최장 거리 좌표 찾기
        int sel_idx  = 0;
        int max_dsq  = 0;
        for (int idx = 0; idx < NSTEP; ++idx) {
            int dsq = x_arr[idx]*x_arr[idx] + y_arr[idx]*y_arr[idx];
            if (dsq > max_dsq) {
                max_dsq = dsq;
                sel_idx = idx;
            }
        }

        // 최장 거리 쪽으로 서보1 회전
        hub_reg[0] = sel_idx;
        msleep(500);

        // LCD 에 선택 각도(°) 표시
        LCD_GotoXY(1, 0);
        LCD_WriteSignedInt(sel_idx * 10);   // 인덱스→° (10° 단위)
        msleep(500);
    }

    cleanup_platform();
    return 0;
}

//------------------------------------------------------------------------------
// MPU6050 I²C 쓰기 헬퍼
//------------------------------------------------------------------------------
void mpu_write_reg(uint8_t reg, uint8_t val) {
    uint8_t buf[2] = { reg, val };
    XIic_Send(iic_inst.BaseAddress, MPU_ADDR, buf, 2, XIIC_STOP);
    while (XIic_IsIicBusy(iic_inst.BaseAddress));
}

//------------------------------------------------------------------------------
// MPU6050 I²C 연속 읽기 헬퍼
//------------------------------------------------------------------------------
void mpu_read_regs(uint8_t start_reg, uint8_t *dst, int len) {
    // 1) 읽을 레지스터 주소 전송 (Repeated Start 유지)
    XIic_Send(iic_inst.BaseAddress, MPU_ADDR, &start_reg, 1, 0);
    while (XIic_IsIicBusy(iic_inst.BaseAddress));
    // 2) 바로 읽기 → STOP
    XIic_Recv(iic_inst.BaseAddress, MPU_ADDR, dst, len, XIIC_STOP);
    while (XIic_IsIicBusy(iic_inst.BaseAddress));
}


//------------------------------------------------------------------------------
// @brief 근사: raw→pitch(°) 정수
//    sqrt≈max+0.5·min, atan2≈x/(1+0.28x²)
//------------------------------------------------------------------------------
static int16_t compute_mpu_pitch(int16_t ax,int16_t ay,int16_t az) {
    const float G=4096.0f;
    float x=(float)ax/G, y=(float)ay/G, z=(float)az/G;
    float ay0=y<0?-y:y, az0=z<0?-z:z;
    float vmax= ay0>az0? ay0:az0;
    float vmin= ay0>az0? az0:ay0;
    float denom = vmax + 0.5f*vmin + 1e-6f;
    float r = x/denom;
    float rad = r/(1.0f + 0.28f*r*r);
    float deg = rad * 57.2957795f;
    return (int16_t)(deg + (deg>=0?0.5f:-0.5f));
}


//------------------------------------------------------------------------------
// Text LCD 제어 함수들 (기존 코드 그대로)
//------------------------------------------------------------------------------
void LCD_WriteCommand(uint8_t cmd) {
    uint8_t high =  cmd   & 0xF0;
    uint8_t low  = (cmd<<4)& 0xF0;
    uint8_t seq[4] = {
        high|0x0C, high|0x08,
        low |0x0C, low |0x08
    };
    XIic_Send(iic_inst.BaseAddress, LCD_ADDR, seq, 4, XIIC_STOP);
    while (XIic_IsIicBusy(iic_inst.BaseAddress));
}

void LCD_WriteData(uint8_t d) {
    uint8_t high =  d     & 0xF0;
    uint8_t low  = (d <<4)& 0xF0;
    uint8_t seq[4] = {
        high|0x0D, high|0x08,
        low |0x0D, low |0x08
    };
    XIic_Send(iic_inst.BaseAddress, LCD_ADDR, seq, 4, XIIC_STOP);
    while (XIic_IsIicBusy(iic_inst.BaseAddress));
}

void LCD_Init(void) {
    msleep(50);
    LCD_WriteCommand(0x33); msleep(5);
    LCD_WriteCommand(0x32);
    LCD_WriteCommand(0x28);
    LCD_WriteCommand(0x0F);
    LCD_WriteCommand(0x06);
    LCD_WriteCommand(0x01); msleep(5);
}

void LCD_GotoXY(uint8_t row, uint8_t col) {
    uint8_t addr = 0x80 | (row<<6) | col;
    LCD_WriteCommand(addr);
}

// 부호 포함 5자리 찍기
void LCD_WriteSignedInt(int16_t v) {
    char tmp[6];
    // "%+5d" → 항상 부호, 총 5칸
    sprintf(tmp, "%+5d", v);
    for (int i = 0; i < 5; i++) {
        LCD_WriteData((uint8_t)tmp[i]);
    }
}

//------------------------------------------------------------------------------
// OLED 제어 함수들
//------------------------------------------------------------------------------
// Control + 명령어 1바이트
void oled_write_cmd(uint8_t cmd) {
    uint8_t buf[2] = { OLED_CTL_CMD, cmd };
    XIic_Send(iic_inst.BaseAddress, OLED_ADDR, buf, 2, XIIC_STOP);
    while (XIic_IsIicBusy(iic_inst.BaseAddress));
}

// Control + 데이터 1바이트
void oled_write_data(uint8_t d) {
    uint8_t buf[2] = { OLED_CTL_DAT, d };
    XIic_Send(iic_inst.BaseAddress, OLED_ADDR, buf, 2, XIIC_STOP);
    while (XIic_IsIicBusy(iic_inst.BaseAddress));
}

// SSD1306 초기화 (페이지 주소 모드 포함)
void oled_init(void) {
    const uint8_t seq[] = {
      0xAE,           // display off
      0x20,0x02,      // page addressing mode
      0xB0,           // page0
      0x00,0x10,      // col addr = 0
      0x40,           // start line = 0
      0x81,0x7F,      // contrast
      0xA1,           // seg remap
      0xC8,           // com scan dec
      0xA6,           // normal display
      0xA8,0x3F,      // multiplex 1/64
      0xD3,0x00,      // display offset
      0xD5,0x80,      // clk div
      0xD9,0x22,      // pre-charge
      0xDA,0x12,      // com pins
      0xDB,0x20,      // vcomh
      0x8D,0x14,      // charge pump on
      0xAF            // display on
    };
    for (int i = 0; i < (int)sizeof(seq); i++) {
        oled_write_cmd(seq[i]);
    }
}

// 전체 화면 클리어
void oled_clear(void) {
    for (int p = 0; p < 8; p++) {
        oled_write_cmd(0xB0 | p);
        oled_write_cmd(0x00);
        oled_write_cmd(0x10);
        for (int c = 0; c < 128; c++) {
            oled_write_data(0x00);
        }
    }
}

//------------------------------------------------------------------------------
// 문자열(부호 포함 숫자) 출력 helper
//------------------------------------------------------------------------------
// page: 0~7, col: 문자 단위(0~15), s: null-terminated 문자열
void oled_puts_str(int page, int col, const char *s) {
    // 1) 페이지·컬럼 설정
    oled_write_cmd(0xB0 | page);
    uint8_t x = col * 8;
    oled_write_cmd(0x00 | (x & 0x0F));
    oled_write_cmd(0x10 | ((x >> 4) & 0x0F));
    // 2) 글자별 8바이트 폰트 전송
    while (*s) {
        uint8_t buf[9];
        buf[0] = OLED_CTL_DAT;
        // ASCII 0x20~0x7F 대응
        memcpy(buf+1, font8x8_basic[(uint8_t)*s - 0x20], 8);
        XIic_Send(iic_inst.BaseAddress, OLED_ADDR, buf, 9, XIIC_STOP);
        while (XIic_IsIicBusy(iic_inst.BaseAddress));
        s++;
    }
}

//------------------------------------------------------------------------------
// OLED 픽셀 업데이트: 버퍼→실제 GDDRAM (한 컬럼만 갱신)
//------------------------------------------------------------------------------
void oled_update_column(int page, int col) { 
    oled_write_cmd(0xB0 | page);              // page 설정
    oled_write_cmd(0x00 | (col & 0x0F));      // col low
    oled_write_cmd(0x10 | ((col>>4)&0x0F));   // col high
    oled_write_data(oled_buf[page][col]);     // 버퍼값 전송
}

//------------------------------------------------------------------------------
// (x,y) 에 1픽셀 그리기 (버퍼 갱신 + 해당 컬럼만 갱신)
//------------------------------------------------------------------------------
void oled_draw_pixel(int x, int y) {       
    if (x<0||x>127||y<0||y>63) return;
    int page = y / 8;
    int bit  = y % 8;
    oled_buf[page][x] |= (1<<bit);            // 버퍼에 비트 세팅
    oled_update_column(page, x);              // 실제 화면에 바로 반영
}

[MicroBlaze] DHT11_iic

juniha — Tue, 29 Jul 2025 19:39:39 +0900

목적

DHT11 온습도 센서를 MicroBlaze RISC-V 기반 SoC 시스템에서 AXI-Lite 인터페이스를 통해 제어하고, 습도 및 온도 데이터를 읽어 UART로 출력

Diagram

사용 코드_myip_dht11_iic

`timescale 1 ns / 1 ps

	module myip_dht11_iic #
	(
		// Users to add parameters here

		// User parameters ends
		// Do not modify the parameters beyond this line


		// Parameters of Axi Slave Bus Interface S00_AXI
		parameter integer C_S00_AXI_DATA_WIDTH	= 32,
		parameter integer C_S00_AXI_ADDR_WIDTH	= 5
	)
	(
		// Users to add ports here
        inout dht11_data,
		output [15:0] debug_led,
		// User ports ends
		// Do not modify the ports beyond this line


		// Ports of Axi Slave Bus Interface S00_AXI
		input wire  s00_axi_aclk,
		input wire  s00_axi_aresetn,
		input wire [C_S00_AXI_ADDR_WIDTH-1 : 0] s00_axi_awaddr,
		input wire [2 : 0] s00_axi_awprot,
		input wire  s00_axi_awvalid,
		output wire  s00_axi_awready,
		input wire [C_S00_AXI_DATA_WIDTH-1 : 0] s00_axi_wdata,
		input wire [(C_S00_AXI_DATA_WIDTH/8)-1 : 0] s00_axi_wstrb,
		input wire  s00_axi_wvalid,
		output wire  s00_axi_wready,
		output wire [1 : 0] s00_axi_bresp,
		output wire  s00_axi_bvalid,
		input wire  s00_axi_bready,
		input wire [C_S00_AXI_ADDR_WIDTH-1 : 0] s00_axi_araddr,
		input wire [2 : 0] s00_axi_arprot,
		input wire  s00_axi_arvalid,
		output wire  s00_axi_arready,
		output wire [C_S00_AXI_DATA_WIDTH-1 : 0] s00_axi_rdata,
		output wire [1 : 0] s00_axi_rresp,
		output wire  s00_axi_rvalid,
		input wire  s00_axi_rready
	);
// Instantiation of Axi Bus Interface S00_AXI
	myip_dht11_iic_slave_lite_v1_0_S00_AXI # ( 
		.C_S_AXI_DATA_WIDTH(C_S00_AXI_DATA_WIDTH),
		.C_S_AXI_ADDR_WIDTH(C_S00_AXI_ADDR_WIDTH)
	) myip_dht11_iic_slave_lite_v1_0_S00_AXI_inst (
	   .dht11_data(dht11_data),
		.debug_led(debug_led),

		.S_AXI_ACLK(s00_axi_aclk),
		.S_AXI_ARESETN(s00_axi_aresetn),
		.S_AXI_AWADDR(s00_axi_awaddr),
		.S_AXI_AWPROT(s00_axi_awprot),
		.S_AXI_AWVALID(s00_axi_awvalid),
		.S_AXI_AWREADY(s00_axi_awready),
		.S_AXI_WDATA(s00_axi_wdata),
		.S_AXI_WSTRB(s00_axi_wstrb),
		.S_AXI_WVALID(s00_axi_wvalid),
		.S_AXI_WREADY(s00_axi_wready),
		.S_AXI_BRESP(s00_axi_bresp),
		.S_AXI_BVALID(s00_axi_bvalid),
		.S_AXI_BREADY(s00_axi_bready),
		.S_AXI_ARADDR(s00_axi_araddr),
		.S_AXI_ARPROT(s00_axi_arprot),
		.S_AXI_ARVALID(s00_axi_arvalid),
		.S_AXI_ARREADY(s00_axi_arready),
		.S_AXI_RDATA(s00_axi_rdata),
		.S_AXI_RRESP(s00_axi_rresp),
		.S_AXI_RVALID(s00_axi_rvalid),
		.S_AXI_RREADY(s00_axi_rready)
	);

	// Add user logic here

	// User logic ends

	endmodule

사용 코드 _myip_dht11_iic_slave_lite_v1_0_S00_AXI

`timescale 1 ns / 1 ps

	module myip_dht11_iic_slave_lite_v1_0_S00_AXI #
	(
		// Users to add parameters here

		// User parameters ends
		// Do not modify the parameters beyond this line

		// Width of S_AXI data bus
		parameter integer C_S_AXI_DATA_WIDTH	= 32,
		// Width of S_AXI address bus
		parameter integer C_S_AXI_ADDR_WIDTH	= 5
	)
	(
		// Users to add ports here
        inout dht11_data,
		output [15:0] debug_led,
		// User ports ends
		// Do not modify the ports beyond this line

		// Global Clock Signal
		input wire  S_AXI_ACLK,
		// Global Reset Signal. This Signal is Active LOW
		input wire  S_AXI_ARESETN,
		// Write address (issued by master, acceped by Slave)
		input wire [C_S_AXI_ADDR_WIDTH-1 : 0] S_AXI_AWADDR,
		// Write channel Protection type. This signal indicates the
    		// privilege and security level of the transaction, and whether
    		// the transaction is a data access or an instruction access.
		input wire [2 : 0] S_AXI_AWPROT,
		// Write address valid. This signal indicates that the master signaling
    		// valid write address and control information.
		input wire  S_AXI_AWVALID,
		// Write address ready. This signal indicates that the slave is ready
    		// to accept an address and associated control signals.
		output wire  S_AXI_AWREADY,
		// Write data (issued by master, acceped by Slave) 
		input wire [C_S_AXI_DATA_WIDTH-1 : 0] S_AXI_WDATA,
		// Write strobes. This signal indicates which byte lanes hold
    		// valid data. There is one write strobe bit for each eight
    		// bits of the write data bus.    
		input wire [(C_S_AXI_DATA_WIDTH/8)-1 : 0] S_AXI_WSTRB,
		// Write valid. This signal indicates that valid write
    		// data and strobes are available.
		input wire  S_AXI_WVALID,
		// Write ready. This signal indicates that the slave
    		// can accept the write data.
		output wire  S_AXI_WREADY,
		// Write response. This signal indicates the status
    		// of the write transaction.
		output wire [1 : 0] S_AXI_BRESP,
		// Write response valid. This signal indicates that the channel
    		// is signaling a valid write response.
		output wire  S_AXI_BVALID,
		// Response ready. This signal indicates that the master
    		// can accept a write response.
		input wire  S_AXI_BREADY,
		// Read address (issued by master, acceped by Slave)
		input wire [C_S_AXI_ADDR_WIDTH-1 : 0] S_AXI_ARADDR,
		// Protection type. This signal indicates the privilege
    		// and security level of the transaction, and whether the
    		// transaction is a data access or an instruction access.
		input wire [2 : 0] S_AXI_ARPROT,
		// Read address valid. This signal indicates that the channel
    		// is signaling valid read address and control information.
		input wire  S_AXI_ARVALID,
		// Read address ready. This signal indicates that the slave is
    		// ready to accept an address and associated control signals.
		output wire  S_AXI_ARREADY,
		// Read data (issued by slave)
		output wire [C_S_AXI_DATA_WIDTH-1 : 0] S_AXI_RDATA,
		// Read response. This signal indicates the status of the
    		// read transfer.
		output wire [1 : 0] S_AXI_RRESP,
		// Read valid. This signal indicates that the channel is
    		// signaling the required read data.
		output wire  S_AXI_RVALID,
		// Read ready. This signal indicates that the master can
    		// accept the read data and response information.
		input wire  S_AXI_RREADY
	);

    wire [7:0] humidity, temperature;

	// AXI4LITE signals
	reg [C_S_AXI_ADDR_WIDTH-1 : 0] 	axi_awaddr;
	reg  	axi_awready;
	reg  	axi_wready;
	reg [1 : 0] 	axi_bresp;
	reg  	axi_bvalid;
	reg [C_S_AXI_ADDR_WIDTH-1 : 0] 	axi_araddr;
	reg  	axi_arready;
	reg [1 : 0] 	axi_rresp;
	reg  	axi_rvalid;

	// Example-specific design signals
	// local parameter for addressing 32 bit / 64 bit C_S_AXI_DATA_WIDTH
	// ADDR_LSB is used for addressing 32/64 bit registers/memories
	// ADDR_LSB = 2 for 32 bits (n downto 2)
	// ADDR_LSB = 3 for 64 bits (n downto 3)
	localparam integer ADDR_LSB = (C_S_AXI_DATA_WIDTH/32) + 1;
	localparam integer OPT_MEM_ADDR_BITS = 2;
	//----------------------------------------------
	//-- Signals for user logic register space example
	//------------------------------------------------
	//-- Number of Slave Registers 8
	reg [C_S_AXI_DATA_WIDTH-1:0]	slv_reg0;
	reg [C_S_AXI_DATA_WIDTH-1:0]	slv_reg1;
	reg [C_S_AXI_DATA_WIDTH-1:0]	slv_reg2;
	reg [C_S_AXI_DATA_WIDTH-1:0]	slv_reg3;
	reg [C_S_AXI_DATA_WIDTH-1:0]	slv_reg4;
	reg [C_S_AXI_DATA_WIDTH-1:0]	slv_reg5;
	reg [C_S_AXI_DATA_WIDTH-1:0]	slv_reg6;
	reg [C_S_AXI_DATA_WIDTH-1:0]	slv_reg7;
	integer	 byte_index;

	// I/O Connections assignments

	assign S_AXI_AWREADY	= axi_awready;
	assign S_AXI_WREADY	= axi_wready;
	assign S_AXI_BRESP	= axi_bresp;
	assign S_AXI_BVALID	= axi_bvalid;
	assign S_AXI_ARREADY	= axi_arready;
	assign S_AXI_RRESP	= axi_rresp;
	assign S_AXI_RVALID	= axi_rvalid;
	 //state machine varibles 
	 reg [1:0] state_write;
	 reg [1:0] state_read;
	 //State machine local parameters
	 localparam Idle = 2'b00,Raddr = 2'b10,Rdata = 2'b11 ,Waddr = 2'b10,Wdata = 2'b11;
	// Implement Write state machine
	// Outstanding write transactions are not supported by the slave i.e., master should assert bready to receive response on or before it starts sending the new transaction
	always @(posedge S_AXI_ACLK)                                 
	  begin                                 
	     if (S_AXI_ARESETN == 1'b0)                                 
	       begin                                 
	         axi_awready <= 0;                                 
	         axi_wready <= 0;                                 
	         axi_bvalid <= 0;                                 
	         axi_bresp <= 0;                                 
	         axi_awaddr <= 0;                                 
	         state_write <= Idle;                                 
	       end                                 
	     else                                  
	       begin                                 
	         case(state_write)                                 
	           Idle:                                      
	             begin                                 
	               if(S_AXI_ARESETN == 1'b1)                                  
	                 begin                                 
	                   axi_awready <= 1'b1;                                 
	                   axi_wready <= 1'b1;                                 
	                   state_write <= Waddr;                                 
	                 end                                 
	               else state_write <= state_write;                                 
	             end                                 
	           Waddr:        //At this state, slave is ready to receive address along with corresponding control signals and first data packet. Response valid is also handled at this state                                 
	             begin                                 
	               if (S_AXI_AWVALID && S_AXI_AWREADY)                                 
	                  begin                                 
	                    axi_awaddr <= S_AXI_AWADDR;                                 
	                    if(S_AXI_WVALID)                                  
	                      begin                                   
	                        axi_awready <= 1'b1;                                 
	                        state_write <= Waddr;                                 
	                        axi_bvalid <= 1'b1;                                 
	                      end                                 
	                    else                                  
	                      begin                                 
	                        axi_awready <= 1'b0;                                 
	                        state_write <= Wdata;                                 
	                        if (S_AXI_BREADY && axi_bvalid) axi_bvalid <= 1'b0;                                 
	                      end                                 
	                  end                                 
	               else                                  
	                  begin                                 
	                    state_write <= state_write;                                 
	                    if (S_AXI_BREADY && axi_bvalid) axi_bvalid <= 1'b0;                                 
	                   end                                 
	             end                                 
	          Wdata:        //At this state, slave is ready to receive the data packets until the number of transfers is equal to burst length                                 
	             begin                                 
	               if (S_AXI_WVALID)                                 
	                 begin                                 
	                   state_write <= Waddr;                                 
	                   axi_bvalid <= 1'b1;                                 
	                   axi_awready <= 1'b1;                                 
	                 end                                 
	                else                                  
	                 begin                                 
	                   state_write <= state_write;                                 
	                   if (S_AXI_BREADY && axi_bvalid) axi_bvalid <= 1'b0;                                 
	                 end                                              
	             end                                 
	          endcase                                 
	        end                                 
	      end                                 

	// Implement memory mapped register select and write logic generation
	// The write data is accepted and written to memory mapped registers when
	// axi_awready, S_AXI_WVALID, axi_wready and S_AXI_WVALID are asserted. Write strobes are used to
	// select byte enables of slave registers while writing.
	// These registers are cleared when reset (active low) is applied.
	// Slave register write enable is asserted when valid address and data are available
	// and the slave is ready to accept the write address and write data.
	 

	always @( posedge S_AXI_ACLK )
	begin
	  if ( S_AXI_ARESETN == 1'b0 )
	    begin
	      slv_reg0 <= 0;
	      slv_reg1 <= 0;
	      slv_reg2 <= 0;
	      slv_reg3 <= 0;
	      slv_reg4 <= 0;
	      slv_reg5 <= 0;
	      slv_reg6 <= 0;
	      slv_reg7 <= 0;
	    end 
	  else begin
	    if (S_AXI_WVALID)
	      begin
	        case ( (S_AXI_AWVALID) ? S_AXI_AWADDR[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] : axi_awaddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] )
	          3'h0:
	            for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
	              if ( S_AXI_WSTRB[byte_index] == 1 ) begin
	                // Respective byte enables are asserted as per write strobes 
	                // Slave register 0
	                slv_reg0[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
	              end  
	          3'h1:
	            for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
	              if ( S_AXI_WSTRB[byte_index] == 1 ) begin
	                // Respective byte enables are asserted as per write strobes 
	                // Slave register 1
	                slv_reg1[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
	              end  
	          3'h2:
	            for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
	              if ( S_AXI_WSTRB[byte_index] == 1 ) begin
	                // Respective byte enables are asserted as per write strobes 
	                // Slave register 2
	                slv_reg2[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
	              end  
	          3'h3:
	            for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
	              if ( S_AXI_WSTRB[byte_index] == 1 ) begin
	                // Respective byte enables are asserted as per write strobes 
	                // Slave register 3
	                slv_reg3[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
	              end  
	          3'h4:
	            for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
	              if ( S_AXI_WSTRB[byte_index] == 1 ) begin
	                // Respective byte enables are asserted as per write strobes 
	                // Slave register 4
	                slv_reg4[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
	              end  
	          3'h5:
	            for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
	              if ( S_AXI_WSTRB[byte_index] == 1 ) begin
	                // Respective byte enables are asserted as per write strobes 
	                // Slave register 5
	                slv_reg5[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
	              end  
	          3'h6:
	            for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
	              if ( S_AXI_WSTRB[byte_index] == 1 ) begin
	                // Respective byte enables are asserted as per write strobes 
	                // Slave register 6
	                slv_reg6[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
	              end  
	          3'h7:
	            for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
	              if ( S_AXI_WSTRB[byte_index] == 1 ) begin
	                // Respective byte enables are asserted as per write strobes 
	                // Slave register 7
	                slv_reg7[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
	              end  
	          default : begin
	                      slv_reg0 <= slv_reg0;
	                      slv_reg1 <= slv_reg1;
	                      slv_reg2 <= slv_reg2;
	                      slv_reg3 <= slv_reg3;
	                      slv_reg4 <= slv_reg4;
	                      slv_reg5 <= slv_reg5;
	                      slv_reg6 <= slv_reg6;
	                      slv_reg7 <= slv_reg7;
	                    end
	        endcase
	      end
	  end
	end    

	// Implement read state machine
	  always @(posedge S_AXI_ACLK)                                       
	    begin                                       
	      if (S_AXI_ARESETN == 1'b0)                                       
	        begin                                       
	         //asserting initial values to all 0's during reset                                       
	         axi_arready <= 1'b0;                                       
	         axi_rvalid <= 1'b0;                                       
	         axi_rresp <= 1'b0;                                       
	         state_read <= Idle;                                       
	        end                                       
	      else                                       
	        begin                                       
	          case(state_read)                                       
	            Idle:     //Initial state inidicating reset is done and ready to receive read/write transactions                                       
	              begin                                                
	                if (S_AXI_ARESETN == 1'b1)                                        
	                  begin                                       
	                    state_read <= Raddr;                                       
	                    axi_arready <= 1'b1;                                       
	                  end                                       
	                else state_read <= state_read;                                       
	              end                                       
	            Raddr:        //At this state, slave is ready to receive address along with corresponding control signals                                       
	              begin                                       
	                if (S_AXI_ARVALID && S_AXI_ARREADY)                                       
	                  begin                                       
	                    state_read <= Rdata;                                       
	                    axi_araddr <= S_AXI_ARADDR;                                       
	                    axi_rvalid <= 1'b1;                                       
	                    axi_arready <= 1'b0;                                       
	                  end                                       
	                else state_read <= state_read;                                       
	              end                                       
	            Rdata:        //At this state, slave is ready to send the data packets until the number of transfers is equal to burst length                                       
	              begin                                           
	                if (S_AXI_RVALID && S_AXI_RREADY)                                       
	                  begin                                       
	                    axi_rvalid <= 1'b0;                                       
	                    axi_arready <= 1'b1;                                       
	                    state_read <= Raddr;                                       
	                  end                                       
	                else state_read <= state_read;                                       
	              end                                       
	           endcase                                       
	          end                                       
	        end                                         
	// Implement memory mapped register select and read logic generation
	  assign S_AXI_RDATA = (axi_araddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] == 3'h0) ? humidity : 
	       (axi_araddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] == 3'h1) ? temperature : 
	       (axi_araddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] == 3'h2) ? slv_reg2 : 
	       (axi_araddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] == 3'h3) ? slv_reg3 : 
	       (axi_araddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] == 3'h4) ? slv_reg4 : 
	       (axi_araddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] == 3'h5) ? slv_reg5 : 
	       (axi_araddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] == 3'h6) ? slv_reg6 : 
	       (axi_araddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] == 3'h7) ? 32'h1234 : 0; 
	// Add user logic here
    dht11_cntr dht11(      //fsm, asm은 알고리즘대로 그래서 상태가 많아서, fsm유한 상태 머신 
        .clk(S_AXI_ACLK), 
        .reset_p(~S_AXI_ARESETN),          //input도 reg선언이 안된다. inout도 입력이 있기 때문에 wire만 된다.
        .dht11_data(dht11_data),       //inout 포트는 reg선언이 안된다.
        .humidity(humidity), 
        .temperature(temperature),
        .debug_led(debug_led)   );
	// User logic ends

	endmodule

사용 코드_ Vitis

#include <stdio.h>               // 표준 입출력 함수 사용
#include "platform.h"           // 플랫폼 초기화 및 종료 함수 포함
#include "xil_printf.h"         // Xilinx 전용 출력 함수 (xil_printf)
#include "xparameters.h"        // 하드웨어 주소 등 시스템 파라미터 정의
#include "sleep.h"              // sleep 함수 사용을 위한 헤더

// DHT11 IP 코어의 베이스 주소를 정의 (xparameters.h에서 자동 정의된 매크로 사용)
#define dht_addr XPAR_MYIP_DHT11_IIC_0_BASEADDR

int main()
{
    // 플랫폼 초기화 (UART 설정 등 기본 하드웨어 설정)
    init_platform();
    
    // UART를 통해 간단한 출력 확인
    print("Hello World\n\r");
    print("Successfully ran Hello World application");

    // DHT11 센서 데이터를 읽을 수 있는 메모리 주소 포인터 생성
    // 이 주소는 사용자 정의 IP 코어가 메모리 맵에 매핑된 위치
    volatile unsigned int *dht11_instance = (volatile unsigned int*) dht_addr;

    while(1){
        // DHT11 센서의 습도 값을 읽어 UART로 출력 (레지스터 0번)
        xil_printf("Humidity : %d\n\r", dht11_instance[0]);

        // DHT11 센서의 온도 값을 읽어 UART로 출력 (레지스터 1번)
        xil_printf("Temperature : %d\n\r", dht11_instance[1]);

        // 3초 대기 (센서 업데이트 주기에 맞춰 딜레이)
        sleep(3);
    }

    // 플랫폼 종료 처리 (자원 정리 등)
    cleanup_platform();
    return 0;
}

동작 영상

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

결과

사용자 정의 IP(myip_dht11_iic_0) 내부에 구현된 FSM(dht11_cntr)이 DHT11 센서에 대해 아래 프로토콜을 자동으로 수행합니다:

센서 초기화한다.
데이터 요청 신호 전송한다.
센서 응답 대기 및 데이터 수신한다.
습도 및 온도 값 저장 (humidity, temperature)한다.
- dht11_instance[0]에서 습도 값을 읽는다,
- dht11_instance[1]에서 온도 값을 읽는다.
- 두 값을 UART로 PC에 출력되는 것을 확인 할 수 있다.

[MicroBlaze] Button_control

juniha — Mon, 28 Jul 2025 20:22:47 +0900

목적

MicroBlaze에서 외부 4비트 버튼 입력을 AXI GPIO로 읽고, UART를 통해 실시간으로 출력

Diagram

사용 코드

#include <stdio.h>             // 표준 입출력 함수
#include "platform.h"          // 플랫폼 초기화 및 종료 함수
#include "xil_printf.h"        // UART 출력용 함수 (xil_printf)
#include "xparameters.h"       // 하드웨어 주소 및 파라미터 정의
#include "xgpio.h"             // AXI GPIO 제어용 헤더
#include "sleep.h"             // sleep 함수 (초 단위)

#define BTN_ADDR XPAR_XGPIO_0_BASEADDR   // AXI GPIO의 기본 주소
#define BTN_CHANNEL 1                    // 버튼이 연결된 채널 번호 (채널 1)

int main()
{
    init_platform(); // 플랫폼 초기화 (UART, 캐시, 인터럽트 등)

    print("Hello World\n\r");
    print("Successfully ran Hello World application\n\r");

    XGpio_Config *cfg_ptr;  // GPIO 설정 구조체 포인터
    XGpio btn_device;       // 버튼용 GPIO 인스턴스
    u16 data = 0;           // 버튼 입력값 저장 변수 (최대 16비트)

    // GPIO 디바이스 설정 정보를 가져옴
    cfg_ptr = XGpio_LookupConfig(BTN_ADDR);

    // GPIO 디바이스 초기화
    XGpio_CfgInitialize(&btn_device, cfg_ptr, cfg_ptr->BaseAddress);

    // 채널 1을 입력으로 설정 (0: 출력, 1: 입력 → 0b1111 = 4비트 모두 입력)
    XGpio_SetDataDirection(&btn_device, BTN_CHANNEL, 0b1111);

    while(1){
        // 버튼 상태 읽기 (AXI GPIO에서 4비트 입력 읽음)
        data = XGpio_DiscreteRead(&btn_device, BTN_CHANNEL);

        // UART로 버튼 값 출력 (터미널에서 확인 가능)
        xil_printf("Button : %d\n\r", data);

        // 1초 대기 (버튼 polling 주기)
        sleep(1);
    }

    cleanup_platform(); // 플랫폼 정리 (실제로는 도달하지 않음)
    return 0;
}

동작 영상

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

결과

버튼비트 위치바이너리 값UART 출력 (%d)

btn[0]	bit 0	0001	1
btn[1]	bit 1	0010	2
btn[2]	bit 2	0100	4
btn[3]	bit 3	1000	8

누른 버튼 조합바이너리출력 값

btn[0] + btn[1]	0011	3
btn[2] + btn[3]	1100	12
btn[0] + btn[2]	0101	5
btn[1] + btn[3]	1010	10
모두 누름	1111	15

XGpio_DiscreteRead()는 각 버튼의 상태를 비트별로 읽어 정수로 반환되는 것을 확인 할 수 있다,
각 버튼은 2의 제곱수 단위 값(1, 2, 4, 8)을 가지고. 따라서 단일 버튼을 눌렀을 때 출력되는 값은 해당 버튼의 비트 위치에 따라 결정되는 것을 확인 할 수 있다.

[MicroBlaze] fnd_control

juniha — Mon, 28 Jul 2025 20:05:16 +0900

목적

MicroBlaze V RISC-V 프로세서를 이용하여 UART 통신을 통해 입력을 받고, 7세그먼트 디스플레이로 출력하는 임베디드 SoC 시스템을 구현

Diagram

사용 코드

`timescale 1 ps / 1 ps  // 시뮬레이션 시간 단위 및 정밀도 설정

//------------------------------------------------------------------------------
// Top-Level Wrapper Module for MicroBlaze V System
// 이 모듈은 Vivado IP Integrator로 생성된 MicroBlaze V 시스템(mblazeV_fnd)의
// 상위 래퍼로서 외부 핀과 내부 블록 디자인을 연결합니다.
//------------------------------------------------------------------------------
module mblazeV_fnd_wrapper
   (
    reset,                      // 외부 리셋 입력 (active-high)
    seven_seg_led_an_tri_o,    // 7세그먼트 애너드 제어 출력 (4비트)
    seven_seg_led_disp_tri_o,  // 7세그먼트 디스플레이 제어 출력 (8비트)
    sys_clock,                 // 외부 시스템 클록 입력
    usb_uart_rxd,              // UART 수신 데이터 (PC -> FPGA)
    usb_uart_txd               // UART 송신 데이터 (FPGA -> PC)
    );

  // 포트 선언
  input reset;
  output [3:0] seven_seg_led_an_tri_o;
  output [7:0] seven_seg_led_disp_tri_o;
  input sys_clock;
  input usb_uart_rxd;
  output usb_uart_txd;

  // 내부 배선 (포트와 동일 이름을 가진 wire로 연결됨)
  wire reset;
  wire [3:0] seven_seg_led_an_tri_o;
  wire [7:0] seven_seg_led_disp_tri_o;
  wire sys_clock;
  wire usb_uart_rxd;
  wire usb_uart_txd;

  //------------------------------------------------------------------------------
  // 인스턴스: mblazeV_fnd
  // Vivado Block Design으로 생성된 SoC 시스템 블록 인스턴스
  // MicroBlaze V 프로세서 및 AXI 기반 주변 장치(GPIO, UART 등)를 포함함
  //------------------------------------------------------------------------------
  mblazeV_fnd mblazeV_fnd_i (
        .reset(reset),
        .seven_seg_led_an_tri_o(seven_seg_led_an_tri_o),
        .seven_seg_led_disp_tri_o(seven_seg_led_disp_tri_o),
        .sys_clock(sys_clock),
        .usb_uart_rxd(usb_uart_rxd),
        .usb_uart_txd(usb_uart_txd)
  );

endmodule

동작 영상

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

결과

FPGA 보드의 MicroBlaze 시스템이 AXI GPIO를 통해 4자리 7세그먼트 FND를 제어하며, 초기값 7777에서 시작해 약 0.8초 간격으로 1씩 증가하는 것을 확인 할 수 있다.

[Project] Radar_System_사용 코드

juniha — Sun, 27 Jul 2025 18:44:40 +0900

사용 코드 _radar_system_top

module radar_system_top(
    input         clk, reset_p,
    input  [4:0]  btn,
    input         echo_1, echo_2,
    output        trig_1, trig_2,
    output        tx_uart,
    output        servo,
    output        scl, sda,
    output [7:0]  seg_7,
    output [3:0]  com,
    output [15:0] led_debug
);

    wire        btn_nedge;
    wire        en_sonic;
    wire [7:0]  angle;
    wire [11:0] dist1, dist2;
    wire        packet_sent;

    wire [15:0] bcd_angle, bcd_dist1, bcd_dist2;
    wire [15:0] sel_bcd;
    reg  [1:0]  disp_st;

    reg  [7:0]  en_graph;
    reg         data_ready, data_ready_d;
    wire        cg_pulse;

    assign led_debug = {4'b0, disp_st, en_sonic, cg_pulse, en_graph};

    // 버튼 엣지 검출
    button_cntr u_btn (
        .clk(clk),
        .reset_p(reset_p),
        .btn(btn[0]),
        .btn_pedge(),
        .btn_nedge(btn_nedge)
    );

    // 서보 PWM + 각도 생성
    servo_pwm_top u_srv (
        .clk(clk),
        .reset_p(reset_p),
        .en_sonic(en_sonic),
        .pwm(servo),
        .angle_cur(angle),
        .seg_7(),
        .com()
    );

    // 초음파 센서 1, 2
    ultrasonic_top u_s1 (
        .clk(clk),
        .reset_p(reset_p),
        .en(en_sonic),
        .echo(echo_1),
        .trig(trig_1),
        .dist(dist1),
        .seg_7(),
        .com(),
        .led_debug()
    );
    ultrasonic_top u_s2 (
        .clk(clk),
        .reset_p(reset_p),
        .en(en_sonic),
        .echo(echo_2),
        .trig(trig_2),
        .dist(dist2),
        .seg_7(),
        .com(),
        .led_debug()
    );

    // UART 송신 핸드셰이크
    always @(posedge clk or posedge reset_p) begin
        if (reset_p) begin
            data_ready   <= 1'b0;
            data_ready_d <= 1'b0;
        end else begin
            if (!data_ready && (dist1 != 0) && (dist2 != 0))
                data_ready <= 1'b1;
            else if (packet_sent)
                data_ready <= 1'b0;
            data_ready_d <= data_ready;
        end
    end
    assign cg_pulse = data_ready && !data_ready_d;

    // LCD 그래프
    always @(posedge clk or posedge reset_p) begin
        if (reset_p)
            en_graph <= 8'd0;
        else if (dist1 <  15)  en_graph <= 8'b0000_0001;
        else if (dist1 <  30)  en_graph <= 8'b0000_0011;
        else if (dist1 <  45)  en_graph <= 8'b0000_0111;
        else if (dist1 <  60)  en_graph <= 8'b0000_1111;
        else if (dist1 <  75)  en_graph <= 8'b0001_1111;
        else if (dist1 <  90)  en_graph <= 8'b0011_1111;
        else if (dist1 < 105)  en_graph <= 8'b0111_1111;
        else                   en_graph <= 8'b1111_1111;
    end

    // I2C LCD
    i2c_txtlcd_top u_lcd (
        .clk(clk),
        .reset_p(reset_p),
        .btn(btn[4:1]),
        .en_cg(cg_pulse),
        .en_graph(en_graph),
        .scl(scl),
        .sda(sda)
    );

    // UART 송신
    uart_packet_sender u_uart (
        .clk(clk),
        .reset_p(reset_p),
        .angle(angle),
        .distance1(dist1),
        .distance2(dist2),
        .send_packet(data_ready),
        .tx(tx_uart),
        .packet_sent(packet_sent)
    );

    // BCD 변환
    bin_to_dec u_b2d_ang (
        .bin(angle),
        .bcd(bcd_angle)
    );
    bin_to_dec u_b2d_d1 (
        .bin(dist1),
        .bcd(bcd_dist1)
    );
    bin_to_dec u_b2d_d2 (
        .bin(dist2),
        .bcd(bcd_dist2)
    );

    // FND 디스플레이 선택
    always @(posedge clk or posedge reset_p) begin
        if (reset_p)
            disp_st <= 2'd0;
        else if (btn_nedge) begin
            if (disp_st == 2)
                disp_st <= 0;
            else
                disp_st <= disp_st + 1;
        end
    end

    assign sel_bcd = (disp_st == 0) ? bcd_angle :
                     (disp_st == 1) ? bcd_dist1 : bcd_dist2;

    fnd_4digit_cntr u_fnd (
        .clk(clk),
        .reset_p(reset_p),
        .value(sel_bcd),
        .seg_7(seg_7),
        .com(com)
    );

endmodule

사용 코드 _ servo_pwm_top

module servo_pwm_top (
    input        clk,
    input        reset_p,
    output       en_sonic,      // 1 system clock cycle (trigger)
    output       pwm,           // 서보 PWM
    output [7:0] angle_cur,
    output [7:0] seg_7,
    output [3:0] com
);

    parameter SYS_CLK_FREQ     = 100_000_000;
    parameter MYCLK_FREQ       = 2;     // period = 500ms
    parameter VALUE_COUNT_SEC  = SYS_CLK_FREQ / (2 * MYCLK_FREQ);
    parameter WIDTH_SEC        = $clog2(VALUE_COUNT_SEC);

    parameter CNT_MIN          = 4;     // 0.44ms
    parameter CNT_MAX          = 22;    // 2.44ms
    parameter VALUE_COUNT      = CNT_MAX - CNT_MIN;   // 18 (count) -> 180 (degree)

    reg   [2*VALUE_COUNT-1:0]  r_cnt;
    reg   [4:0]                r_cnt_pwm;
    reg   [WIDTH_SEC-1:0]      r_cnt_sysclk;
    reg                        r_clk_sec;

    wire  [15:0] duty_bcd;
    wire         clk_sec_nedge;

    // Sonic 트리거 펄스
    assign en_sonic = clk_sec_nedge;
    assign angle_cur = ((r_cnt_pwm - CNT_MIN) << 3) + ((r_cnt_pwm - CNT_MIN) << 1);

    // 0.5초 주기 펄스 생성 및 네거티브 엣지
    always @(posedge clk or posedge reset_p) begin
        if(reset_p) begin
            r_cnt_sysclk <= 0;
            r_clk_sec    <= 0;
        end else if(r_cnt_sysclk == VALUE_COUNT_SEC-1) begin
            r_cnt_sysclk <= 0;
            r_clk_sec    <= ~r_clk_sec;
        end else begin
            r_cnt_sysclk <= r_cnt_sysclk + 1;
        end
    end

    edge_detector ed_sec (
        .clk(clk),
        .reset_p(reset_p),
        .sig(r_clk_sec),
        .p_edge(),             // 미사용
        .n_edge(clk_sec_nedge)
    );

    // 1초 주기로 각도 변화(180도 왕복)
    always @(posedge clk or posedge reset_p) begin
        if(reset_p) begin
            r_cnt     <= 0;
            r_cnt_pwm <= CNT_MIN;
        end else if(clk_sec_nedge) begin
            if(r_cnt >= VALUE_COUNT*2-1) begin
                r_cnt     <= 0;
                r_cnt_pwm <= CNT_MIN;
            end else if(r_cnt >= VALUE_COUNT) begin
                r_cnt     <= r_cnt + 1;
                r_cnt_pwm <= r_cnt_pwm - 1;
            end else begin
                r_cnt     <= r_cnt + 1;
                r_cnt_pwm <= r_cnt_pwm + 1;
            end
        end
    end

    pwm_servo_180 servo_inst (
        .clk(clk),
        .reset_p(reset_p),
        .duty(r_cnt_pwm),
        .pwm(pwm)
    );

    bin_to_dec bcd_conv (
        .bin({4'b0000, (r_cnt_pwm - CNT_MIN)}), // 8비트
        .bcd(duty_bcd)
    );

    fnd_4digit_cntr fnd_disp (
        .clk(clk),
        .reset_p(reset_p),
        .value(duty_bcd),
        .seg_7(seg_7),
        .com(com)
    );

endmodule

사용 코드 _ pwm_servo_180

module pwm_servo_180 (
    input             clk,
    input             reset_p,
    input  [7:0]      duty,      // 0~179 입력 (180 step)
    output            pwm        // PWM 출력
);

    parameter SYS_CLK_FREQ      = 100_000_000;
    parameter PWM_FREQ          = 50;
    parameter DUTY_STEP         = 180;
    parameter VALUE_COUNT_PWM   = SYS_CLK_FREQ / (2 * PWM_FREQ) / DUTY_STEP;
    parameter WIDTH_PWM         = $clog2(VALUE_COUNT_PWM);

    reg  [WIDTH_PWM-1:0] cnt_sysclk;
    reg                  pwm_freq_180;
    reg  [7:0]           cnt_duty;
    reg                  pwm_r;

    assign pwm = pwm_r;

    // 180Hz 분주 파형 생성 (duty 마다 2번)
    always @(posedge clk or posedge reset_p) begin
        if (reset_p) begin
            cnt_sysclk   <= 0;
            pwm_freq_180 <= 0;
        end else if (cnt_sysclk == VALUE_COUNT_PWM-1) begin
            cnt_sysclk   <= 0;
            pwm_freq_180 <= ~pwm_freq_180;
        end else begin
            cnt_sysclk   <= cnt_sysclk + 1;
        end
    end

    wire pwm_freq_180_nedge;
    edge_detector ed_pwm (
        .clk(clk),
        .reset_p(reset_p),
        .sig(pwm_freq_180),
        .p_edge(),                // 미사용
        .n_edge(pwm_freq_180_nedge)
    );

    always @(posedge clk or posedge reset_p) begin
        if (reset_p) begin
            cnt_duty <= 0;
            pwm_r    <= 0;
        end else if (pwm_freq_180_nedge) begin
            if (cnt_duty >= DUTY_STEP-1)
                cnt_duty <= 0;
            else
                cnt_duty <= cnt_duty + 1;
            if (cnt_duty < duty)
                pwm_r <= 1;
            else
                pwm_r <= 0;
        end
    end

endmodule

사용 코드 _ fnd_4digit_cntr

module fnd_4digit_cntr (
    input        clk,
    input        reset_p,
    input  [15:0] value,
    output [7:0]  seg_7,
    output [3:0]  com
);

    reg [3:0] hex_value;
    wire [3:0] com_wire;

    ring_counter u_ring_counter (
        .clk(clk),
        .reset_p(reset_p),
        .q(com_wire)
    );
    assign com = com_wire;

    always @(posedge clk or posedge reset_p) begin
        if (reset_p)
            hex_value <= 0;
        else begin
            case (com_wire)
                4'b1110: hex_value <= value[3:0];
                4'b1101: hex_value <= value[7:4];
                4'b1011: hex_value <= value[11:8];
                4'b0111: hex_value <= value[15:12];
                default: hex_value <= 0;
            endcase
        end
    end

    decoder_7seg_hex u_decoder (
        .iHEX_VALUE(hex_value),
        .oSEG_7(seg_7)
    );
endmodule

사용 코드 _ ring_counter

module ring_counter (
    input clk, reset_p,
    output reg [3:0] q
);
    parameter CNT_VALUE = 100_000;
    parameter WIDTH = $clog2(CNT_VALUE);

    reg [WIDTH-1:0] clk_div;
    wire clk_div_msb;

    always @(posedge clk or posedge reset_p) begin
        if (reset_p) clk_div <= 0;
        else         clk_div <= clk_div + 1;
    end

    edge_detector ed (
        .clk(clk),
        .reset_p(reset_p),
        .sig(clk_div[WIDTH-1]),
        .p_edge(clk_div_msb),
        .n_edge()
    );

    always @(posedge clk or posedge reset_p) begin
        if (reset_p)
            q <= 4'b1110;
        else if (clk_div_msb)
            q <= {q[2:0], q[3]};
    end
endmodule

사용 코드 _decoder_7seg

module decoder_7seg(
    input      [3:0] hex_value,    // 4비트 입력 (0~F)
    output reg [7:0] seg_7         // 7세그먼트(8비트, a~g, dp)
);

    always @(*) begin
        case (hex_value)
            4'h0 : seg_7 = 8'b0000_0011; // 0
            4'h1 : seg_7 = 8'b1001_1111; // 1
            4'h2 : seg_7 = 8'b0010_0101; // 2
            4'h3 : seg_7 = 8'b0000_1101; // 3
            4'h4 : seg_7 = 8'b1001_1001; // 4
            4'h5 : seg_7 = 8'b0100_1001; // 5
            4'h6 : seg_7 = 8'b0100_0001; // 6
            4'h7 : seg_7 = 8'b0001_1011; // 7
            4'h8 : seg_7 = 8'b0000_0001; // 8
            4'h9 : seg_7 = 8'b0001_1001; // 9
            4'hA : seg_7 = 8'b0001_0001; // A
            4'hB : seg_7 = 8'b1100_0001; // b
            4'hC : seg_7 = 8'b0110_0011; // C
            4'hD : seg_7 = 8'b1000_0101; // d
            4'hE : seg_7 = 8'b0110_0001; // E
            4'hF : seg_7 = 8'b0111_0001; // F
            default: seg_7 = 8'b0000_0000;
        endcase
    end

endmodule

사용 코드_ultrasonic_top

module ultrasonic_top (
    input         clk, reset_p,
    input         en,
    input         echo,
    output        trig,
    output [11:0] dist,
    output [7:0]  seg_7,
    output [3:0]  com,
    output [15:0] led_debug
);

    wire [15:0] fnd_dist;

    ultrasonic_sensor u_sensor (
        .clk(clk),
        .reset_p(reset_p),
        .en(en),
        .echo(echo),
        .trig(trig),
        .dist(dist),
        .led_debug(led_debug)
    );

    bin_to_dec u_bcd (
        .bin(dist),
        .bcd(fnd_dist)
    );

    fnd_4digit_cntr u_fnd (
        .clk(clk),
        .reset_p(reset_p),
        .value(fnd_dist),
        .seg_7(seg_7),
        .com(com)
    );
endmodule

사용 코드_ultrasonic_sensor

module ultrasonic_sensor(
    input        clk, reset_p,
    input        en, echo,
    output reg   trig,
    output reg [11:0] dist,
    output [15:0] led_debug
);

    parameter S_IDLE   = 3'd0,
              S_TRIG   = 3'd1,
              S_WAIT_R = 3'd2,
              S_WAIT_F = 3'd3,
              S_CALC   = 3'd4;

    reg [2:0] state, next_state;
    reg [15:0] cnt_us;
    reg [5:0] elap_us;
    reg [11:0] cm_cnt;
    reg prev_en;

    wire clk_us;
    clock_div_1us clkdiv(
        .clk(clk),
        .reset_p(reset_p),
        .clk_us(clk_us)  // 포트명 일치
    );

    assign led_debug[2:0] = state;
    assign led_debug[15:3] = 0;

    always @(posedge clk or posedge reset_p) begin
        if (reset_p) begin
            state <= S_IDLE;
            prev_en <= 1'b0;
        end else begin
            state <= next_state;
            prev_en <= en;
        end
    end

    always @(*) begin
        next_state = state;
        case(state)
            S_IDLE:   if (~prev_en && en) next_state = S_TRIG;
            S_TRIG:   if (cnt_us >= 10)  next_state = S_WAIT_R;
            S_WAIT_R: if (echo)          next_state = S_WAIT_F;
            S_WAIT_F: if (~echo)         next_state = S_CALC;
            S_CALC:   next_state = S_IDLE;
        endcase
    end

    always @(posedge clk or posedge reset_p) begin
        if (reset_p) begin
            trig <= 0;
            cnt_us <= 0;
            elap_us <= 0;
            cm_cnt <= 0;
            dist <= 0;
        end else begin
            case(state)
                S_IDLE: begin
                    trig <= 0; cnt_us <= 0; elap_us <= 0; cm_cnt <= 0;
                end
                S_TRIG: begin
                    trig <= 1;
                    if (clk_us) cnt_us <= cnt_us + 1;
                end
                S_WAIT_R: begin
                    trig <= 0; cnt_us <= 0;
                end
                S_WAIT_F: begin
                    if (clk_us) begin
                        elap_us <= elap_us + 1;
                        if (elap_us == 57) begin
                            elap_us <= 0;
                            cm_cnt <= cm_cnt + 1;
                        end
                    end
                end
                S_CALC: begin
                    dist <= cm_cnt;
                end
            endcase
        end
    end

endmodule

사용 코드 _ i2c_txtlcd_top

module i2c_txtlcd_top (
    input        clk, reset_p,
    input  [3:0] btn,
    input        en_cg,
    input  [7:0] en_graph,
    output       scl, sda,
    output [15:0] led_debug
);

    localparam VALUE_COUNT = 8_000_000;
    localparam WIDTH = $clog2(VALUE_COUNT);

    localparam S_IDLE    = 7'b0000001,
               S_INIT    = 7'b0000010,
               S_BYTE    = 7'b0000100,
               S_SH_R    = 7'b0001000,
               S_SH_L    = 7'b0010000,
               S_STRING  = 7'b0100000,
               S_SEND_CG = 7'b1000000;

    // --- 그래프 데이터 --- //
    reg [7:0] graph_line_0 [0:7];
    reg [7:0] graph_line_1 [0:7];
    reg [7:0] graph_line_2 [0:7];
    reg [7:0] graph_line_3 [0:7];
    reg [7:0] graph_line_4 [0:7];
    reg [7:0] graph_line_5 [0:7];
    reg [7:0] graph_line_6 [0:7];
    reg [7:0] graph_line_7 [0:7];
    integer i;
    initial begin
        for(i=0;i<8;i=i+1) begin
            graph_line_0[i]=8'h00; graph_line_1[i]=8'h00; graph_line_2[i]=8'h00; graph_line_3[i]=8'h00;
            graph_line_4[i]=8'h00; graph_line_5[i]=8'h00; graph_line_6[i]=8'h00; graph_line_7[i]=8'h00;
        end
        graph_line_0[7]=8'h1F;
        graph_line_1[6]=8'h1F; graph_line_1[7]=8'h1F;
        graph_line_2[5]=8'h1F; graph_line_2[6]=8'h1F; graph_line_2[7]=8'h1F;
        graph_line_3[4]=8'h1F; graph_line_3[5]=8'h1F; graph_line_3[6]=8'h1F; graph_line_3[7]=8'h1F;
        graph_line_4[3]=8'h1F; graph_line_4[4]=8'h1F; graph_line_4[5]=8'h1F; graph_line_4[6]=8'h1F; graph_line_4[7]=8'h1F;
        graph_line_5[2]=8'h1F; graph_line_5[3]=8'h1F; graph_line_5[4]=8'h1F; graph_line_5[5]=8'h1F; graph_line_5[6]=8'h1F; graph_line_5[7]=8'h1F;
        graph_line_6[1]=8'h1F; graph_line_6[2]=8'h1F; graph_line_6[3]=8'h1F; graph_line_6[4]=8'h1F; graph_line_6[5]=8'h1F; graph_line_6[6]=8'h1F; graph_line_6[7]=8'h1F;
        for(i=0;i<8;i=i+1) graph_line_7[i]=8'h1F;
    end

    reg  [WIDTH-1:0] cnt_clk;
    reg  [6:0]       state, next_state;
    reg              en_cnt_clk;
    reg              send, rs;
    reg  [3:0]       cnt_data, cnt_cg;
    reg              init_flag;
    reg  [7:0]       send_buffer;
    reg [39:0]       hello;
    reg  [2:0]       cnt_string;
    wire [4:0]       btn_pedge;
    wire             busy;
    reg  [3:0]       col_idx;

    assign led_debug = {7'b0, init_flag, en_cnt_clk, state};

    // 버튼 엣지 검출 인스턴스
    button_cntr u_btn0 (.clk(clk), .reset_p(reset_p), .btn(btn[0]), .btn_pedge(btn_pedge[0]), .btn_nedge());
    button_cntr u_btn1 (.clk(clk), .reset_p(reset_p), .btn(btn[1]), .btn_pedge(btn_pedge[1]), .btn_nedge());
    button_cntr u_btn2 (.clk(clk), .reset_p(reset_p), .btn(btn[2]), .btn_pedge(btn_pedge[2]), .btn_nedge());
    button_cntr u_btn3 (.clk(clk), .reset_p(reset_p), .btn(btn[3]), .btn_pedge(btn_pedge[3]), .btn_nedge());

    // I2C 송신 모듈
    i2c_lcd_send_byte u_i2c (
        .clk(clk),
        .reset_p(reset_p),
        .addr(7'h3F),
        .send_buffer(send_buffer),
        .send(send),
        .rs(rs),
        .scl(scl),
        .sda(sda),
        .busy(busy)
    );

    // 타이머 카운터
    always @(posedge clk or posedge reset_p)
        if (reset_p)         cnt_clk <= 0;
        else if (en_cnt_clk) cnt_clk <= cnt_clk + 1;
        else                 cnt_clk <= 0;

    // FSM 상태 전이
    always @(posedge clk or posedge reset_p)
        if (reset_p) state <= S_IDLE;
        else         state <= next_state;

    // FSM 본체
    always @(posedge clk or posedge reset_p) begin
        if (reset_p) begin
            next_state <= S_IDLE;
            en_cnt_clk <= 0; cnt_data <= 0; cnt_string <= 5; cnt_cg <= 0;
            init_flag <= 0; send <= 0; send_buffer <= 0; rs <= 0;
            hello <= "Hello";
        end else begin
            case (state)
            S_IDLE: begin
                if (!init_flag) begin
                    if (cnt_clk == VALUE_COUNT-1) begin
                        next_state <= S_INIT; en_cnt_clk <= 0;
                    end else en_cnt_clk <= 1;
                end else begin
                    if (btn_pedge[0]) next_state <= S_BYTE;
                    if (btn_pedge[1]) next_state <= S_SH_R;
                    if (btn_pedge[2]) next_state <= S_SH_L;
                    if (btn_pedge[3]) next_state <= S_STRING;
                    if (en_cg) begin next_state <= S_SEND_CG; cnt_data <= 0; end
                end
            end
            S_INIT: begin
                if (busy) begin
                    send <= 0;
                    if (cnt_data >= 6) begin cnt_data <= 0; init_flag <= 1; next_state <= S_IDLE; end
                end else if (!send) begin
                    send <= 1; cnt_data <= cnt_data + 1;
                    case (cnt_data)
                        0: send_buffer <= 8'h33;
                        1: send_buffer <= 8'h32;
                        2: send_buffer <= 8'h28;
                        3: send_buffer <= 8'h0c;
                        4: send_buffer <= 8'h01;
                        5: send_buffer <= 8'h06;
                    endcase
                end
            end
            S_BYTE: begin
                if (busy) begin
                    next_state <= S_IDLE; send <= 0;
                    if (cnt_data >= 9) cnt_data <= 0; else cnt_data <= cnt_data + 1;
                end else begin
                    rs <= 1; send_buffer <= "0" + cnt_data; send <= 1;
                end
            end
            S_SH_R: begin
                if (busy) begin next_state <= S_IDLE; send <= 0; end
                else begin rs <= 0; send_buffer <= 8'h1c; send <= 1; end
            end
            S_SH_L: begin
                if (busy) begin next_state <= S_IDLE; send <= 0; end
                else begin rs <= 0; send_buffer <= 8'h18; send <= 1; end
            end
            S_STRING: begin
                if (busy) begin
                    send <= 0;
                    if (!cnt_string) begin cnt_string <= 5; next_state <= S_IDLE; end
                end else if (!send) begin
                    rs <= 1; send <= 1; cnt_string <= cnt_string - 1;
                    case (cnt_string)
                        5: send_buffer <= hello[39:32];
                        4: send_buffer <= hello[31:24];
                        3: send_buffer <= hello[23:16];
                        2: send_buffer <= hello[15:8];
                        1: send_buffer <= hello[7:0];
                    endcase
                end
            end
            S_SEND_CG: begin
                if (busy) begin
                    send <= 0;
                    if (cnt_cg == 11) begin cnt_cg <= 0; next_state <= S_IDLE; end
                end else if (!send) begin
                    send <= 1;
                    case (cnt_cg)
                        0: begin rs <= 0; send_buffer <= 8'h40; end
                        1,2,3,4,5,6,7,8: begin
                            rs <= 1;
                            if      (en_graph[0]) send_buffer <= graph_line_0[cnt_cg-1];
                            else if (en_graph[1]) send_buffer <= graph_line_1[cnt_cg-1];
                            else if (en_graph[2]) send_buffer <= graph_line_2[cnt_cg-1];
                            else if (en_graph[3]) send_buffer <= graph_line_3[cnt_cg-1];
                            else if (en_graph[4]) send_buffer <= graph_line_4[cnt_cg-1];
                            else if (en_graph[5]) send_buffer <= graph_line_5[cnt_cg-1];
                            else if (en_graph[6]) send_buffer <= graph_line_6[cnt_cg-1];
                            else                  send_buffer <= graph_line_7[cnt_cg-1];
                        end
                        9:  begin rs <= 0; send_buffer <= 8'h80; end
                        10: begin rs <= 1; send_buffer <= 8'h00; end
                    endcase
                    cnt_cg <= cnt_cg + 1;
                end
            end
            default: next_state <= S_IDLE;
            endcase
        end
    end

endmodule

사용 코드_ i2c_lcd_send_byte

module i2c_lcd_send_byte (
    input        clk, reset_p,
    input  [6:0] addr,
    input  [7:0] send_buffer,
    input        send, rs,
    output       scl, sda,
    output reg   busy,
    output [15:0] led_debug
);

    localparam IDLE                    = 6'b00_0001;
    localparam SEND_HIGH_NIBBLE_DIS    = 6'b00_0010;
    localparam SEND_HIGH_NIBBLE_EN     = 6'b00_0100;
    localparam SEND_LOW_NIBBLE_DIS     = 6'b00_1000;
    localparam SEND_LOW_NIBBLE_EN      = 6'b01_0000;
    localparam SEND_DISABLE            = 6'b10_0000;

    reg [5:0] state, next_state;
    reg [7:0] data;
    reg       comm_start;
    reg [21:0] cnt_us;
    reg       en_cnt_us;

    wire send_pedge;
    wire clk_us;

    //assign led_debug = {8'b0, en_cnt_us, comm_start, state};

    clock_div_1us u_clkdiv (
        .clk(clk),
        .reset_p(reset_p),
        .clk_us(clk_us)
    );

    always @(posedge clk or posedge reset_p) begin
        if (reset_p)
            cnt_us <= 0;
        else if (clk_us && en_cnt_us)
            cnt_us <= cnt_us + 1;
        else if (!en_cnt_us)
            cnt_us <= 0;
    end

    edge_detector UED_send (
        .clk(clk),
        .reset_p(reset_p),
        .sig(send),	
        .p_edge(send_pedge),
        .n_edge()
    );

    I2C_master master (
        .clk(clk),
        .reset_p(reset_p),
        .addr(addr),
        .data(data),
        .rd_wr(1'b0),
        .comm_start(comm_start),
        .scl(scl),
        .sda(sda),
        .led_debug(led_debug)
    );

    always @(posedge clk or posedge reset_p) begin
        if (reset_p)
            state <= IDLE;
        else
            state <= next_state;
    end

    always @(posedge clk or posedge reset_p) begin
        if (reset_p) begin
            next_state <= IDLE;
            data <= 0;
            busy <= 0;
            en_cnt_us <= 0;
            comm_start <= 0;
        end else begin
            case (state)
                IDLE: begin
                    if (send_pedge) begin
                        next_state <= SEND_HIGH_NIBBLE_DIS;
                        busy <= 1;
                    end
                end
                SEND_HIGH_NIBBLE_DIS: begin
                    if (cnt_us <= 200) begin
                        data <= {send_buffer[7:4], 3'b100, rs};
                        comm_start <= 1;
                        en_cnt_us <= 1;
                    end else begin
                        next_state <= SEND_HIGH_NIBBLE_EN;
                        en_cnt_us <= 0;
                        comm_start <= 0;
                    end
                end
                SEND_HIGH_NIBBLE_EN: begin
                    if (cnt_us <= 200) begin
                        data <= {send_buffer[7:4], 3'b110, rs};
                        comm_start <= 1;
                        en_cnt_us <= 1;
                    end else begin
                        next_state <= SEND_LOW_NIBBLE_DIS;
                        en_cnt_us <= 0;
                        comm_start <= 0;
                    end
                end
                SEND_LOW_NIBBLE_DIS: begin
                    if (cnt_us <= 200) begin
                        data <= {send_buffer[3:0], 3'b100, rs};
                        comm_start <= 1;
                        en_cnt_us <= 1;
                    end else begin
                        next_state <= SEND_LOW_NIBBLE_EN;
                        en_cnt_us <= 0;
                        comm_start <= 0;
                    end
                end
                SEND_LOW_NIBBLE_EN: begin
                    if (cnt_us <= 200) begin
                        data <= {send_buffer[3:0], 3'b110, rs};
                        comm_start <= 1;
                        en_cnt_us <= 1;
                    end else begin
                        next_state <= SEND_DISABLE;
                        en_cnt_us <= 0;
                        comm_start <= 0;
                    end
                end
                SEND_DISABLE: begin
                    if (cnt_us <= 200) begin
                        data <= {send_buffer[3:0], 3'b100, rs};
                        comm_start <= 1;
                        en_cnt_us <= 1;
                    end else begin
                        next_state <= IDLE;
                        en_cnt_us <= 0;
                        comm_start <= 0;
                        busy <= 0;
                    end
                end
            endcase
        end
    end

endmodule

사용 코드 _uart_transmitter

module uart_transmitter(
    input wire clk,
    input wire reset_p,
    input wire [7:0] data_in,
    input wire send,
    output reg tx,
    output reg busy
);

    // 115200 baud rate, 100MHz 클록
    // Baud rate divisor = 100MHz / 115200 ≈ 868
    parameter BAUD_DIVISOR = 868;
    parameter IDLE = 2'b00;
    parameter START = 2'b01;
    parameter DATA = 2'b10;
    parameter STOP = 2'b11;
    
    reg [1:0] state;
    reg [31:0] baud_counter;
    reg [2:0] bit_counter;
    reg [7:0] shift_reg;
    
    always @(posedge clk or posedge reset_p) begin
        if (reset_p) begin
            state <= IDLE;
            tx <= 1'b1;
            busy <= 1'b0;
            baud_counter <= 32'b0;
            bit_counter <= 3'b0;
            shift_reg <= 8'b0;
        end else begin
            case (state)
                IDLE: begin
                    tx <= 1'b1;
                    busy <= 1'b0;
                    baud_counter <= 32'b0;
                    bit_counter <= 3'b0;
                    
                    if (send) begin
                        shift_reg <= data_in;
                        busy <= 1'b1;
                        state <= START;
                    end
                end
                
                START: begin
                    tx <= 1'b0;  // Start bit
                    baud_counter <= baud_counter + 1;
                    
                    if (baud_counter >= BAUD_DIVISOR) begin
                        baud_counter <= 32'b0;
                        state <= DATA;
                    end
                end
                
                DATA: begin
                    tx <= shift_reg[0];
                    baud_counter <= baud_counter + 1;
                    
                    if (baud_counter >= BAUD_DIVISOR) begin
                        baud_counter <= 32'b0;
                        shift_reg <= {1'b0, shift_reg[7:1]};
                        bit_counter <= bit_counter + 1;
                        
                        if (bit_counter >= 7) begin
                            bit_counter <= 3'b0;
                            state <= STOP;
                        end
                    end
                end
                
                STOP: begin
                    tx <= 1'b1;  // Stop bit
                    baud_counter <= baud_counter + 1;
                    
                    if (baud_counter >= BAUD_DIVISOR) begin
                        baud_counter <= 32'b0;
                        state <= IDLE;
                    end
                end
                
                default: state <= IDLE;
            endcase
        end
    end
    
endmodule

사용 코드 _ bin_to_dec

module bin_to_dec (
    input      [11:0] bin,     // 이진 입력 (최대 4095)
    output reg [15:0] bcd      // 변환된 4자리 BCD 출력
);
    reg [3:0] i;

    always @(bin) begin
        bcd = 0;
        for (i = 0; i < 12; i = i + 1) begin
            bcd = {bcd[14:0], bin[11 - i]};
            if(i < 11 && bcd[3:0] > 4)      bcd[3:0]   = bcd[3:0]   + 3;
            if(i < 11 && bcd[7:4] > 4)      bcd[7:4]   = bcd[7:4]   + 3;
            if(i < 11 && bcd[11:8] > 4)     bcd[11:8]  = bcd[11:8]  + 3;
            if(i < 11 && bcd[15:12] > 4)    bcd[15:12] = bcd[15:12] + 3;
        end
    end
endmodule

사용 코드_clock_div_1us

module clock_div_1us (
    input        clk, reset_p,
    output       cp_div_100,      // clock pulse (1us 기준 펄스)
    output       edge_n_div_100   // 1us 네거티브 엣지 펄스
);

    localparam CNT_VALUE_100 = 100;                // 10ns * 100 = 1us (100MHz 기준)
    localparam WIDTH = $clog2(CNT_VALUE_100);

    reg [WIDTH-1:0] cnt_sysclk;

    always @(posedge clk or posedge reset_p) begin
        if (reset_p) cnt_sysclk <= 0;
        else if (cnt_sysclk == CNT_VALUE_100 - 1) cnt_sysclk <= 0;
        else cnt_sysclk <= cnt_sysclk + 1;
    end

    assign cp_div_100 = (cnt_sysclk < CNT_VALUE_100/2) ? 1'b0 : 1'b1;

    edge_detector ed (
        .clk(clk),
        .reset_p(reset_p),
        .sig(cp_div_100),
        .p_edge(),              // (포지티브 엣지는 미사용)
        .n_edge(edge_n_div_100)
    );

endmodule

사용 코드_fnd_4digit_cntr

module fnd_4digit_cntr (
    input        clk, reset_p,
    input  [15:0] value,
    output [7:0]  seg_7,
    output [3:0]  com
);

    reg [3:0] hex_value;

    // 4자리 순환 제어 (One-hot)
    ring_counter ring_com(
        .clk   (clk),
        .reset_p (reset_p),
        .q     (com)
    );
    
    always @(posedge clk or posedge reset_p) begin
        if (reset_p)
            hex_value <= 0;
        else begin
            case (com)
                4'b1110: hex_value <= value[3:0];
                4'b1101: hex_value <= value[7:4];
                4'b1011: hex_value <= value[11:8];
                4'b0111: hex_value <= value[15:12];
                default: hex_value <= 0;
            endcase
        end
    end
    
    decoder_7seg dec(
        .hex_value(hex_value),
        .seg_7(seg_7)
    );

endmodule

사용 코드 _button_cntr

module button_cntr (
    input        clk, reset_p,
    input        btn,
    output       btn_pedge, btn_nedge
);

    localparam CNT_VALUE = 100_000;           // clk period = 10ns, 1ms count
    localparam WIDTH     = $clog2(CNT_VALUE);

    reg [WIDTH-1:0] clk_div;
    reg debounced_btn;
    wire clk_div_msb;

    // 1ms 분주 카운터
    always @(posedge clk or posedge reset_p) begin
        if (reset_p) clk_div <= 0;
        else         clk_div <= clk_div + 1;
    end

    // 1ms마다 펄스 생성 (엣지 디텍터)
    edge_detector ed_div (
        .clk(clk),
        .reset_p(reset_p),
        .sig(clk_div[WIDTH-1]),
        .p_edge(clk_div_msb),
        .n_edge() // 사용안함
    );

    // 디바운스: 1ms마다 샘플링
    always @(posedge clk or posedge reset_p) begin
        if (reset_p)            debounced_btn <= 0;
        else if (clk_div_msb)   debounced_btn <= btn;
    end

    // 버튼 엣지 검출기
    edge_detector ed_btn (
        .clk(clk),
        .reset_p(reset_p),
        .sig(debounced_btn),
        .p_edge(btn_pedge),
        .n_edge(btn_nedge)
    );

endmodule

사용 코드 _XDC 파일

## Basys3 rev B Board XDC (Radar Project 전용)

## Clock signal
set_property -dict { PACKAGE_PIN W5   IOSTANDARD LVCMOS33 } [get_ports clk]
create_clock -add -name sys_clk_pin -period 10.00 -waveform {0 5} [get_ports clk]

## Reset (SW0)
set_property -dict { PACKAGE_PIN V17   IOSTANDARD LVCMOS33 } [get_ports reset_p]

## LEDs (16bit)
set_property -dict { PACKAGE_PIN U16   IOSTANDARD LVCMOS33 } [get_ports {led_debug[0]}]
set_property -dict { PACKAGE_PIN E19   IOSTANDARD LVCMOS33 } [get_ports {led_debug[1]}]
set_property -dict { PACKAGE_PIN U19   IOSTANDARD LVCMOS33 } [get_ports {led_debug[2]}]
set_property -dict { PACKAGE_PIN V19   IOSTANDARD LVCMOS33 } [get_ports {led_debug[3]}]
set_property -dict { PACKAGE_PIN W18   IOSTANDARD LVCMOS33 } [get_ports {led_debug[4]}]
set_property -dict { PACKAGE_PIN U15   IOSTANDARD LVCMOS33 } [get_ports {led_debug[5]}]
set_property -dict { PACKAGE_PIN U14   IOSTANDARD LVCMOS33 } [get_ports {led_debug[6]}]
set_property -dict { PACKAGE_PIN V14   IOSTANDARD LVCMOS33 } [get_ports {led_debug[7]}]
set_property -dict { PACKAGE_PIN V13   IOSTANDARD LVCMOS33 } [get_ports {led_debug[8]}]
set_property -dict { PACKAGE_PIN V3    IOSTANDARD LVCMOS33 } [get_ports {led_debug[9]}]
set_property -dict { PACKAGE_PIN W3    IOSTANDARD LVCMOS33 } [get_ports {led_debug[10]}]
set_property -dict { PACKAGE_PIN U3    IOSTANDARD LVCMOS33 } [get_ports {led_debug[11]}]
set_property -dict { PACKAGE_PIN P3    IOSTANDARD LVCMOS33 } [get_ports {led_debug[12]}]
set_property -dict { PACKAGE_PIN N3    IOSTANDARD LVCMOS33 } [get_ports {led_debug[13]}]
set_property -dict { PACKAGE_PIN P1    IOSTANDARD LVCMOS33 } [get_ports {led_debug[14]}]
set_property -dict { PACKAGE_PIN L1    IOSTANDARD LVCMOS33 } [get_ports {led_debug[15]}]

## 7-Segment Display (FND)
set_property -dict { PACKAGE_PIN W7   IOSTANDARD LVCMOS33 } [get_ports {seg_7[7]}]
set_property -dict { PACKAGE_PIN W6   IOSTANDARD LVCMOS33 } [get_ports {seg_7[6]}]
set_property -dict { PACKAGE_PIN U8   IOSTANDARD LVCMOS33 } [get_ports {seg_7[5]}]
set_property -dict { PACKAGE_PIN V8   IOSTANDARD LVCMOS33 } [get_ports {seg_7[4]}]
set_property -dict { PACKAGE_PIN U5   IOSTANDARD LVCMOS33 } [get_ports {seg_7[3]}]
set_property -dict { PACKAGE_PIN V5   IOSTANDARD LVCMOS33 } [get_ports {seg_7[2]}]
set_property -dict { PACKAGE_PIN U7   IOSTANDARD LVCMOS33 } [get_ports {seg_7[1]}]
set_property -dict { PACKAGE_PIN V7   IOSTANDARD LVCMOS33 } [get_ports {seg_7[0]}]

set_property -dict { PACKAGE_PIN U2   IOSTANDARD LVCMOS33 } [get_ports {com[0]}]
set_property -dict { PACKAGE_PIN U4   IOSTANDARD LVCMOS33 } [get_ports {com[1]}]
set_property -dict { PACKAGE_PIN V4   IOSTANDARD LVCMOS33 } [get_ports {com[2]}]
set_property -dict { PACKAGE_PIN W4   IOSTANDARD LVCMOS33 } [get_ports {com[3]}]

## Buttons
set_property -dict { PACKAGE_PIN U18   IOSTANDARD LVCMOS33 } [get_ports btn[0]]  # Center
set_property -dict { PACKAGE_PIN T18   IOSTANDARD LVCMOS33 } [get_ports btn[1]]  # Up
set_property -dict { PACKAGE_PIN W19   IOSTANDARD LVCMOS33 } [get_ports btn[3]]  # Left
set_property -dict { PACKAGE_PIN T17   IOSTANDARD LVCMOS33 } [get_ports btn[2]]  # Right
set_property -dict { PACKAGE_PIN U17   IOSTANDARD LVCMOS33 } [get_ports btn[4]]  # Down

## Pmod Header JA - 초음파, 서보, I2C
set_property -dict { PACKAGE_PIN J1   IOSTANDARD LVCMOS33 } [get_ports {trig_1}]
set_property -dict { PACKAGE_PIN L2   IOSTANDARD LVCMOS33 } [get_ports {echo_1}]
set_property -dict { PACKAGE_PIN J2   IOSTANDARD LVCMOS33 } [get_ports {trig_2}]
set_property -dict { PACKAGE_PIN G2   IOSTANDARD LVCMOS33 } [get_ports {echo_2}]
set_property -dict { PACKAGE_PIN H1   IOSTANDARD LVCMOS33 } [get_ports {servo}]
set_property -dict { PACKAGE_PIN K2   IOSTANDARD LVCMOS33 } [get_ports {scl}]
set_property -dict { PACKAGE_PIN H2   IOSTANDARD LVCMOS33 } [get_ports {sda}]

## USB-RS232 Interface (UART TX)
set_property -dict { PACKAGE_PIN A18   IOSTANDARD LVCMOS33 } [get_ports tx_uart]

## Basys3 Power & Configuration
set_property CONFIG_VOLTAGE 3.3 [current_design]
set_property CFGBVS VCCO [current_design]
set_property BITSTREAM.GENERAL.COMPRESS TRUE [current_design]
set_property BITSTREAM.CONFIG.CONFIGRATE 33 [current_design]
set_property CONFIG_MODE SPIx4 [current_design]

동작 영상

초음파 레이더 시스템 실시간 동작 시연

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

360° 초음파 센서 데이터 실시간 시각화

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

[MicroBlaze] Switch_Led

juniha — Fri, 25 Jul 2025 21:09:56 +0900

목적

DIP 스위치 입력을 읽고, 해당 값을 LED에 출력하며 UART로 상태를 출력하는 기본 임베디드 제어 시스템 구현

Diagram

구성 블록

microblaze_riscv_0 (RISC-V 프로세서)

MicroBlaze V (RISC-V 기반) 임베디드 CPU
AXI 인터페이스(M_AXI_DP)를 통해 주변 장치와 연결
DLMB, ILMB: 데이터/명령 로컬 메모리 인터페이스

microblaze_riscv_0_local_memory

로컬 메모리 (LMB 기반)
명령(ILMB), 데이터(DLMB) 메모리 제공
SYS_Rst, LMB_Clk으로 클럭 및 리셋 동기화

axi_gpio_0

AXI GPIO 컨트롤러
GPIO 채널 1: led_16bits (출력)
GPIO 채널 2: dip_switches_16bits (입력)
AXI 인터페이스를 통해 프로세서와 연결됨

axi_uartlite_0

AXI UART Lite
USB UART 연결용
RX (usb_uart 입력), TX (usb_uart 출력)
UART 디버깅용 메시지 송수신 처리

axi_smc (AXI SmartConnect)

프로세서(M_AXI_DP)와 주변 장치(GPIO, UART) 사이의 AXI 버스 연결기
AXI Master(M00_AXI) → Slave(S_AXI) 연결 처리

proc_sys_reset_0 (Processor System Reset)

리셋 논리 제어
외부 리셋 + 디버그 리셋 + 클럭 안정성 → 다양한 reset 신호 생성 (mb_reset, peripheral_reset 등)

clk_wiz (Clocking Wizard)

외부 클럭(sys_clock)을 내부에서 사용할 주파수(clk_out1)로 변환
locked 신호를 통해 클럭 안정 여부 표시

mdm_1 (MicroBlaze Debug Module)

JTAG 디버깅 지원 (Xilinx SDK/Vitis 사용 시)
MBDEBUG_0, Debug_SYS_Rst 신호 출력

Diagram에 맞춰 작성된 코드

`timescale 1 ps / 1 ps  // 시뮬레이션 타임스케일 설정: 시간 단위 1ps, 정밀도 1ps

//-----------------------------------------------------------------------------
// Top-level wrapper module for the MicroBlazeV Hello World design
// This module wraps the block design system generated by Vivado IP Integrator
//-----------------------------------------------------------------------------

module microblazeV_hello_wrapper
   (
    dip_switches_16bits_tri_i, // 16비트 DIP 스위치 입력 (GPIO 입력으로 사용)
    led_16bits_tri_o,          // 16비트 LED 출력 (GPIO 출력으로 사용)
    reset,                     // 외부 비동기 리셋 입력 (active-high)
    sys_clock,                 // 시스템 클럭 입력
    usb_uart_rxd,             // UART 수신 데이터 (USB-UART 연결)
    usb_uart_txd              // UART 송신 데이터 (USB-UART 연결)
    );

  // 포트 선언 (외부 입출력 신호)
  input  [15:0] dip_switches_16bits_tri_i; // DIP 스위치 입력
  output [15:0] led_16bits_tri_o;          // LED 출력
  input         reset;                     // 리셋 입력
  input         sys_clock;                 // 시스템 클럭 입력
  input         usb_uart_rxd;              // UART 수신 (RX)
  output        usb_uart_txd;              // UART 송신 (TX)

  // 내부 와이어 연결 (포트 신호를 내부 모듈에 직접 연결)
  wire [15:0] dip_switches_16bits_tri_i;
  wire [15:0] led_16bits_tri_o;
  wire        reset;
  wire        sys_clock;
  wire        usb_uart_rxd;
  wire        usb_uart_txd;

  // microblazeV_hello 인스턴스화 (Vivado Block Design에서 생성된 시스템)
  microblazeV_hello microblazeV_hello_i (
        .dip_switches_16bits_tri_i(dip_switches_16bits_tri_i), // DIP 스위치 입력 연결
        .led_16bits_tri_o(led_16bits_tri_o),                   // LED 출력 연결
        .reset(reset),                                        // 리셋 신호 연결
        .sys_clock(sys_clock),                                // 시스템 클럭 연결
        .usb_uart_rxd(usb_uart_rxd),                          // UART RX 연결
        .usb_uart_txd(usb_uart_txd)                           // UART TX 연결
    );

endmodule

사용 코드 _ Vitis

#include <stdio.h>             // 표준 입출력 함수 사용
#include "platform.h"          // 플랫폼 초기화 및 정리 함수 포함 (init_platform, cleanup_platform 등)
#include "xil_printf.h"        // UART를 통한 출력용 printf 함수 제공 (xil_printf)
#include "sleep.h"             // sleep 함수 포함 (지연용)
#include "xparameters.h"       // 하드웨어 주소 정의 포함 (IP의 BaseAddress 등)
#include "xgpio.h"             // AXI GPIO 관련 함수 정의

// GPIO 채널 번호 정의
#define LED_CHANNEL 1          // 채널 1은 LED 출력용
#define SW_CHANNEL  2          // 채널 2는 DIP 스위치 입력용

int main()
{
    init_platform(); // 플랫폼 초기화 (UART, 인터럽트, 메모리 등 사용 가능하게 설정)

    print("Hello World\n\r");                        // UART를 통해 인사 메시지 출력
    print("Successfully ran Hello World application"); // 실행 성공 메시지

    XGpio_Config *cfg_ptr;   // GPIO 설정 구조체 포인터
    XGpio gpio_device;       // GPIO 장치 인스턴스 선언

    u32 data = 0;            // 스위치 입력 값을 저장할 변수

    // GPIO 장치 설정 정보 가져오기 (axi_gpio_0의 주소 기준)
    cfg_ptr = XGpio_LookupConfig(XPAR_AXI_GPIO_0_BASEADDR);

    // GPIO 장치 초기화 (구조체 포인터, 인스턴스, 베이스 주소)
    XGpio_CfgInitialize(&gpio_device, cfg_ptr, cfg_ptr->BaseAddress);

    // GPIO 방향 설정
    // LED 채널을 출력으로 설정 (0은 출력)
    XGpio_SetDataDirection(&gpio_device, LED_CHANNEL, 0);
    
    // DIP 스위치 채널을 입력으로 설정 (0xFFFF는 16비트 모두 입력)
    XGpio_SetDataDirection(&gpio_device, SW_CHANNEL, 0xffff);

    // 무한 루프: DIP 스위치 상태를 LED로 출력하고 UART로 보여줌
    while(1){
        // DIP 스위치 상태 읽기 (채널 2)
        data = XGpio_DiscreteRead(&gpio_device, SW_CHANNEL);

        // UART를 통해 스위치 상태 16진수로 출력
        xil_printf("switch inputs : %X\n\r", data);

        // 읽은 값을 LED에 출력 (채널 1)
        XGpio_DiscreteWrite(&gpio_device, LED_CHANNEL, data);

        // 1초 대기 (지연)
        sleep(1);
    }

    cleanup_platform(); // 플랫폼 종료 (사용 리소스 정리)
    return 0; // 프로그램 종료
}

동작 영상 _Switch

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

동작 영상 _LED

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

결과

DIP 스위치를 조작하면,
그 상태가 16개의 LED에 실시간으로 반영되고,
UART 터미널에는 현재 스위치 상태가 1초마다 출력되는 것을 확인

즉, 이 프로그램은 입력(DIP 스위치)을 읽고, 그 값을 출력(LED)에 반영하며, 동시에 UART를 통해 상태를 확인할 수 있다.