TI C2000 DSP를 사용한 Boost 컨버터 디지털 제어기 설계-PCMC

1. 서론

Boost 컨버터는 입력 DC 전압을 더 높은 출력 DC 전압으로 변환하는 스위칭 레귤레이터로, 디지털 제어기를 통해 높은 효율성과 정밀도를 제공합니다. TI의 C2000 DSP(F28379D)는 고속 ADC, PWM, CMPSS, CLA를 제공하여 디지털 전력 변환에 적합합니다. 본 문서는 TI C2000 DSP를 활용하여 Boost 컨버터의 디지털 제어기를 설계하는 절차를 상세히 기술하며, 피크 전류 모드 제어(PCMC)를 구현합니다. UART를 통한 RUN/STOP 제어, 외부 스위치 입력, 소프트 스타트, 과전압/과전류 보호(OVP/OCP)를 포함합니다. 설계 과정은 요구사항 정의, 하드웨어 설계, 아날로그 및 디지털 모델링, 제어기 이산화, DSP 코드 구현, 시뮬레이션 및 검증을 다룹니다. 

2. 설계 요구사항

Boost 컨버터의 디지털 제어기 설계 요구사항은 다음과 같습니다:

• 입력 전압 (\( V_{in} \)): 5V
• 출력 전압 (\( V_{out} \)): 12V
• 출력 전류 (\( I_{out} \)): 1A
• 스위칭 주파수 (\( f_{sw} \)): 200kHz (\( T_{sw} = \frac{1}{f_{sw}} = 5 \mu s \))
• 샘플링 주기 (\( T_s \)): 5μs (PWM과 동기화)
• 전류 모드: 연속 전도 모드 (CCM)
• 제어 방식: VMC 및 PCMC
• 하드웨어 플랫폼: TI Delfino F28379D LaunchPad (200MHz 시스템 클럭) + 커스터마이징된 Boost 컨버터 보드
• 성능 목표:
  • 출력 전압 리플: \( \Delta V_{out} \leq 120mV \) (1% 이하)
  • 과도 응답 시간: \( \leq 100\mu s \) (부하/전압 스텝 응답)
  • 위상 마진: 45°~60°
  • 대역폭: 약 20kHz (\( f_{sw}/10 \))
• 추가 요구사항:
  • ADC: 12비트, 3.3V 기준
  • PWM: Up-Down 모드, 200MHz 시스템 클럭
  • 안정성: 듀티 사이클 제한 (0.1~0.9), ADC 입력 범위 보호
  • 디버깅: UART (SCIA, 115200 baud)로 \( V_{out}, I_{out} \), 상태 모니터링
  • 보호: 과전압 (\( V_{out} > 13.2V \)), 과전류 (\( I_{out} > 1.5A \))
  • 기능: UART 명령('R'/'S'), 외부 스위치(GPIO4), 소프트 스타트 (10ms)
  • 최적화: CLA로 PI 연산, IQmath로 고정소수점 연산, Pre-warping

3. 하드웨어 설계

커스터마이징된 Boost 컨버터는 입력 5V, 출력 12V, 1A, 200kHz, CCM에 최적화된 전원단과 센싱 회로로 구성됩니다. 하드웨어는 TI Delfino F28379D LaunchPad와 호환되며, UART, 외부 스위치, 보호 기능을 지원합니다.

3.1 인덕터 설계

- 인덕터 리플 전류 (\( \Delta I_L \)): \( I_{out} \times 0.3 = 1A \times 0.3 = 0.3A \).
- 인덕터 값 계산:
\[ L = \frac{V_{in} \cdot D \cdot (1 - D)}{f_{sw} \cdot \Delta I_L} \]
여기서 \( D = 1 - \frac{V_{in}}{V_{out}} = 1 - \frac{5}{12} \approx 0.583 \).
대입: \( V_{in} = 5V \), \( D = 0.583 \), \( f_{sw} = 200 \times 10^3 Hz \), \( \Delta I_L = 0.3A \).
\[ L = \frac{5 \cdot 0.583 \cdot (1 - 0.583)}{200 \times 10^3 \cdot 0.3} \approx 20.2 \times 10^{-6} H = 20.2 \mu H \]
- 선택: 22μH 인덕터 (포화 전류 ≥ 2A, DCR ≤ 50mΩ, 예: Coilcraft MSS7341-223MLB).

3.2 커패시터 설계

- 전압 리플 (\( \Delta V_{out} \)): \( V_{out} \times 0.01 = 12V \times 0.01 = 0.12V \).
- 커패시터 값 계산:
\[ C = \frac{I_{out} \cdot D}{f_{sw} \cdot \Delta V_{out}} \]
대입: \( I_{out} = 1A \), \( D = 0.583 \), \( f_{sw} = 200 \times 10^3 Hz \), \( \Delta V_{out} = 0.12V \).
\[ C = \frac{1 \cdot 0.583}{200 \times 10^3 \cdot 0.12} \approx 24.3 \times 10^{-6} F = 24.3 \mu F \]
- 선택: 33μF 세라믹 커패시터 (ESR ≤ 10mΩ, 25V 이상, 예: Murata GRM31CR61E226KE15L).

3.3 스위치 및 다이오드

• 스위치 (MOSFET): N-채널, 30V, 20A (TI CSD88584Q5DC, \( R_{DS(on)} \leq 10m\Omega \)), ePWM1A(GPIO0)로 구동, 저측에 위치.
• 다이오드: 쇼트키, 30V, 5A (Diodes Inc. B530C, 저전압 강하). 효율 향상을 위해 다이오드를 고측 MOSFET으로 교체하여 동기 정류를 구현할 수 있음 (예: 동일 스펙의 MOSFET, ePWM1B(GPIO1)로 구동).
• 게이트 드라이버: UCC27424, 4A 듀얼 채널, 3.3V 로직 호환, MOSFET 구동, 데드타임 66.7ns 설정 (동기 정류 시 데드타임 필수).

3.4 센싱 및 제어 회로

• 전압 센싱:
  • 분압 회로: \( R_1 = 10k\Omega \), \( R_2 = 3.3k\Omega \), 출력 전압을 0~3.3V로 스케일링.
  • ADC 입력: ADCINA0 (GPIO2), 12비트, 3.3V 기준.
• 전류 센싱 (PCMC):
  • 션트 저항: 0.05Ω (1% 정밀도, 1W 이상, 예: Vishay WSL1206R0500FEA).
  • ADC 입력: ADCINA1 (GPIO3), CMPSS1로 피크 전류 비교.
  • 옵션: INA240 전류 센서 앰프(고정밀도, -4V~80V CMRR).
• 외부 스위치:
  • GPIO4: 풀업 저항(10kΩ), Low=RUN, High=STOP.
  • 스위치: 푸시 버튼 또는 토글 스위치, 디바운싱 회로(100nF 병렬 커패시터).
• UART 디버깅:
  • SCIA: GPIO28(TX), GPIO29(RX), 115200 baud.
  • FTDI 칩(예: FT232R) 또는 XDS110 내장 UART 사용.

3.5 하드웨어 플랫폼

• F28379D LaunchPad: 200MHz 듀얼 코어, 12비트 ADC, 16채널 PWM, CLA 지원.
• 커스터마이징된 Boost 컨버터 보드:
  • 전원단: MOSFET(CSD88584Q5DC), 쇼트키 다이오드(B530C).
  • 인덕터: 22μH, 커패시터: 33μF.
  • 센싱: 전압 분압기, 0.05Ω 션트, INA240(옵션).
  • 입출력: 5V 입력(최소 3A), 12V/1A 출력, 동적 부하 지원(12Ω 저항).
• 외부 장비:
  • 전원 공급기: 5V, 3A DC.
  • 오실로스코프: Tektronix TBS2000 (리플, 과도 응답 측정).
  • 부하: 12Ω 저항(1A 정격), 동적 부하(0.5A~1A 스텝).

4. 아날로그 모델링

4.1 State-Space 평균화 모델

CCM에서 상태 변수는 인덕터 전류 (\( i_L \))와 출력 커패시터 전압 (\( v_C \))입니다.

• 스위치 온 (\( D \)):
  \[ L \frac{di_L}{dt} = v_{in}, \quad C \frac{dv_C}{dt} = -\frac{v_C}{R} \]
• 스위치 오프 (\( 1-D \)):
  \[ L \frac{di_L}{dt} = v_{in} - v_C, \quad C \frac{dv_C}{dt} = i_L - \frac{v_C}{R} \]
• 평균화:
  \[ \frac{d}{dt} \begin{bmatrix} i_L \\ v_C \end{bmatrix} = \begin{bmatrix} 0 & -\frac{1-D}{L} \\ \frac{1-D}{C} & -\frac{1}{R C} \end{bmatrix} \begin{bmatrix} i_L \\ v_C \end{bmatrix} + \begin{bmatrix} \frac{1}{L} \\ 0 \end{bmatrix} v_{in} \]
  출력: \( y = v_C = [0 \ 1] \begin{bmatrix} i_L \\ v_C \end{bmatrix} \).

4.2 소신호 모델

- 상태 변수 분리: \( i_L = I_L + \hat{i}_L \), \( v_C = V_C + \hat{v}_C \), \( d = D + \hat{d} \).
- VMC 전달 함수 (\( G_{vd}(s) \)):
\[ G_{vd}(s) = \frac{V_{out} \cdot (1-D)}{1 + s \frac{L}{(1-D)^2 R} + s^2 \frac{L C}{(1-D)^2}} \]
대입: \( V_{out} = 12V \), \( D = 0.583 \), \( L = 22 \mu H \), \( C = 33 \mu F \), \( R = 12 \Omega \).
\[ \omega_0 = \frac{1-D}{\sqrt{L C}} \approx 5.73 \times 10^4 \, \text{rad/s}, \quad Q = \frac{R (1-D)}{ \sqrt{\frac{L}{C}}} \approx 1.15 \]
- PCMC 전달 함수 (\( G_{id}(s) \)):
\[ G_{id}(s) = \frac{V_{out}}{s L + R_L + \frac{1-D}{s C} \parallel R} \] (내전류 루프 근사 모델)

4.3 MATLAB 모델링

% Boost 컨버터 플랜트 모델
Vout = 12; D = 0.583; L = 22e-6; C = 33e-6; R = 12;
Gvd = tf(Vout*(1-D), [L*C/(1-D)^2, L/(R*(1-D)^2), 1]); % VMC 전달 함수
figure; bode(Gvd); grid on; % 주파수 응답
figure; step(Gvd); grid on; % 계단 응답
    

5. 디지털 제어기 설계

• VMC: 단일 전압 루프, 간단, 안정성 높음, 과도 응답 느림.
• PCMC: 전압/전류 이중 루프, 빠른 응답, 부하 변화에 강인, Slope compensation 필요.

5.1 아날로그 PI 제어기

- 전달 함수:
\[ G_c(s) = K_p + \frac{K_i}{s} = \frac{K_p s + K_i}{s} \]
\( K_p = 0.15 \), \( K_i = 1500 \) (MATLAB pidTuner, 위상 마진 45°~60°, 대역폭 20kHz).
- MATLAB 튜닝:

Kp = 0.15; Ki = 1500;
Gc = tf([Kp Ki], [1 0]);
G_loop = series(Gc, Gvd);
margin(G_loop); grid on;
    

5.2 이산화 (Tustin 변환 with Pre-warping)

- Pre-warping 주파수: 20kHz.
- Tustin 변환:
\[ s = \frac{\omega_p}{\tan(\omega_p T_s / 2)} \cdot \frac{z - 1}{z + 1}, \quad \omega_p = 2 \pi \cdot 20 \times 10^3, \quad T_s = 5 \times 10^{-6} \]
- 이산 PI 제어기:
\[ G_c(z) \approx \frac{0.1538 z - 0.1462}{z - 1} \]
차분 방정식: \( u[n] = u[n-1] + 0.1538 e[n] - 0.1462 e[n-1] \)
- MATLAB:

Ts = 5e-6;
Gc_d = c2d(Gc, Ts, 'tustin', 'PrewarpFrequency', 2e4);
[num, den] = tfdata(Gc_d, 'v'); % 출력: [0.1538, -0.1462], [1, -1]
    

5.3 PCMC 추가 설계

- 전류 루프: CMPSS1로 인덕터 전류를 \( I_{ref} = 2.4A \)와 비교.
- Slope compensation: \( m_c = 0.015 V/\mu s \).
- MATLAB:

mc = 0.015e6; % Slope compensation (V/s)
Iref = 2.4; % 피크 전류 참조
    

6. TI C2000 DSP 구현

F28379D(200MHz)에서 PCMC를 구현하며, CLA, IQmath, UART, RUN/STOP, 소프트 스타트, OVP/OCP를 통합합니다.

6.1 시스템 구성

• ADC: 12비트, 3.3V 기준, ADCINA0(전압), ADCINA1(전류).
• PWM: 200kHz Up-Down 모드, 주기 500 (200MHz / (2 * 200kHz)).
• CMPSS (PCMC): 내부 DAC로 피크 전류 참조.
• CLA: PI 연산.
• UART: SCIA, GPIO28(TX), GPIO29(RX), 115200 baud.
• 외부 스위치: GPIO4, 풀업, RUN/STOP 토글.
• GPIO: PWM(GPIO0), 전압(GPIO2), 전류(GPIO3), UART(GPIO28, GPIO29), 스위치(GPIO4).

6.2 PCMC 코드

// boost_pcmc.c: F28379D를 사용한 Boost 컨버터의 피크 전류 모드 제어(PCMC) 디지털 제어기
// - 목표: 입력 5V를 12V로 승압, 피크 전류 2.4A 유지
// - 주요 기능: ADC로 Vout/Iout 샘플링, PWM(200kHz)으로 MOSFET 제어, CLA로 PI 연산 오프로드
// - 하드웨어: TI F28379D DSP, 200MHz 시스템 클럭, ADCINA0(Vout), ADCINA1(Iout), ePWM1A(MOSFET), CMPSS1(전류 루프)
// - 추가 기능: 소프트 스타트(10ms), 과전압/과전류 보호(OVP/OCP), UART 디버깅, 스위치 디바운싱

#include "F28x_Project.h" // F28379D 헤더 파일 (레지스터 정의: ADC, PWM, GPIO 등)
#include "IQmathLib.h"    // 고정소수점 연산 라이브러리 (IQ24 형식)

// 하드웨어 파라미터 정의
#define INDUCTOR_L _IQ(100e-6)  // 인덕터 값: 100uH (Slope compensation 계산용)
#define VOUT_DIVIDER _IQ(3.636) // Vout 분압비: 12V를 3.3V로 스케일링 (12/3.3 ≈ 3.636)

// 제어기 파라미터 (IQ24 고정소수점 형식)
#define VREF _IQ(12.0)          // 목표 출력 전압: 12V (Boost 컨버터 출력)
#define KP _IQ(0.15)            // 비례 게인: 0.15 (MATLAB pidTuner, 위상 마진 45°~60°, 대역폭 ~1kHz)
#define KI _IQ(1500.0)          // 적분 게인: 1500 (오차 누적 제어, 안정성 보장)
#define TS _IQ(0.000005)        // 샘플링 주기: 5us (200kHz PWM 동기화)
#define ADC_VREF _IQ(3.3)       // ADC 기준 전압: 3.3V (12비트 ADC 기준)
#define ADC_MAX _IQ(4095.0)     // 12비트 ADC 최대값 (2^12 - 1)
#define PWM_PERIOD 500          // PWM 주기: 200MHz / (2 * 200kHz) = 500 (Up-Down 모드)
#define DUTY_MIN _IQ(0.1)       // 최소 듀티 사이클: 0.1 (MOSFET 보호, 과도한 전류 방지)
#define DUTY_MAX _IQ(0.9)       // 최대 듀티 사이클: 0.9 (시스템 안정성 보장)
#define DUTY_INIT _IQ(0.583)    // 초기 듀티 사이클: 1 - Vin/Vout = 1 - 5/12 (Vin=5V, Vout=12V)
#define IREF _IQ(2.4)           // 목표 피크 전류: 2.4A (PCMC 전류 루프 기준)
#define SHUNT_R _IQ(0.05)       // 션트 저항: 0.05Ω (Iout 측정용)
#define SLOPE_COMP _IQ(0.0175)  // Slope compensation: 0.0175 V/us (mc > 0.5 * (Vout-Vin)/L * Rshunt = 0.5 * (12-5)/100e-6 * 0.05)
#define V_OVP _IQ(13.2)         // 과전압 보호 임계값: 12V + 10% (13.2V)
#define I_OCP _IQ(2.6)          // 과전류 보호 임계값: 2.4A + 0.2A 마진
#define SOFT_START_TIME _IQ(0.01) // 소프트 스타트 시간: 10ms (부팅 시 전류 급등 방지)
#define SOFT_START_STEPS 2000   // 소프트 스타트 스텝 수: 10ms / 5us = 2000
#define DEBOUNCE_COUNT 10       // 스위치 디바운싱 카운트: 5us * 10 = 50us
#define ERROR_COUNT_MAX 10      // ADC 에러 최대 횟수: 10회 초과 시 FAULT
#define FAULT_RECOVERY_TIME 100000 // FAULT 복구 시간: 1초 (100ms * 10)

// 전역 변수: 상태 모니터링 및 제어
volatile _iq Vout = _IQ(0.0);     // 측정 출력 전압 (IQ24, 단위: V)
volatile _iq Iout = _IQ(0.0);     // 측정 인덕터 전류 (IQ24, 단위: A)
volatile _iq error = _IQ(0.0);    // 전압 오차: Vref - Vout (IQ24)
volatile _iq duty = _IQ(0.0);     // 현재 듀티 사이클 (소프트 스타트 초기 0)
volatile _iq error_prev = _IQ(0.0); // 이전 오차 (PI 제어용)
volatile _iq duty_prev = _IQ(0.0); // 이전 듀티 사이클 (PI 제어용)
volatile Uint16 error_count = 0;   // ADC 에러 카운터 (디버깅 및 FAULT 트리거용)
volatile Uint16 system_state = 0;  // 시스템 상태: 0(STOP), 1(RUN), 2(FAULT)
volatile Uint16 soft_start_count = 0; // 소프트 스타트 카운터 (0~2000)
volatile _iq duty_target = DUTY_INIT; // 목표 듀티 사이클 (소프트 스타트용)
volatile Uint32 fault_recovery_counter = 0; // FAULT 복구 카운터 (1초 대기)
volatile Uint16 switch_state = 1;  // 현재 스위치 상태: 0(RUN), 1(STOP)
volatile Uint16 debounce_counter = 0; // 디바운싱 카운터
volatile Uint16 last_switch_state = 1; // 이전 스위치 상태

// CLA 전용 변수: CPU-CLA 메모리 공유
#pragma DATA_SECTION(CLA_Vout, "Cla1DataRam0"); // CLA 데이터 RAM0에 할당
#pragma DATA_SECTION(CLA_Iout, "Cla1DataRam0");
#pragma DATA_SECTION(CLA_error, "Cla1DataRam0");
#pragma DATA_SECTION(CLA_duty, "Cla1DataRam0");
volatile _iq CLA_Vout;  // CLA용 Vout (IQ24)
volatile _iq CLA_Iout;  // CLA용 Iout (IQ24)
volatile _iq CLA_error; // CLA용 전압 오차 (IQ24)
volatile _iq CLA_duty;  // CLA용 듀티 사이클 (IQ24)

// 함수 선언
void initSystem(void);      // 시스템 클럭, PIE, CLA 초기화
void initGPIO(void);        // GPIO 설정: PWM, ADC, UART, 스위치
void initADC(void);         // ADC 설정: Vout/Iout 샘플링 (ADCA 모듈)
void initPWM(void);         // PWM 설정: 200kHz Up-Down 모드 (ePWM1)
void initCMPSS(void);       // CMPSS 설정: 전류 루프 (PCMC)
void initCLA(void);         // CLA 설정: PI 연산 오프로드
void initUART(void);        // UART 설정: SCIA, 115200 baud
void initInterrupts(void);  // 인터럽트 설정: ADCINT1, CLA Task 1, SCIA RX
void softStart(void);       // 소프트 스타트: 듀티 사이클 0에서 목표값까지 10ms 동안 선형 증가
void checkProtection(void); // 보호 기능: OVP(13.2V), OCP(2.6A) 확인 및 PWM 비활성화
void updateSystemState(Uint16 new_state); // 시스템 상태 업데이트 및 UART 전송
void debounceSwitch(void);  // 스위치 디바운싱: GPIO4 상태 안정화
__interrupt void adc_isr(void); // ADC ISR: Vout/Iout 샘플링, 보호 확인
__interrupt void cla_task1_isr(void); // CLA ISR: PI 및 전류 루프 연산
__interrupt void scia_rx_isr(void); // UART RX ISR: RUN('R'), STOP('S') 명령 처리
void scia_xmit(_iq data);  // UART 데이터 전송: Vout(mV), Iout(mA)
void scia_xmit_status(Uint16 status); // UART 상태 전송: 0(STOP), 1(RUN), 2(FAULT)

// 메인 함수: 시스템 및 주변장치 초기화 후 유휴 루프
void main(void) {
    initSystem();   // 시스템 클럭(200MHz), PIE, CLA 초기화
    initGPIO();     // GPIO 설정: PWM, ADC 입력, UART, 스위치
    initADC();      // ADC 초기화: ADCA 모듈, Vout/Iout 샘플링
    initPWM();      // PWM 초기화: ePWM1, 200kHz Up-Down 모드
    initCMPSS();    // CMPSS 초기화: PCMC 전류 루프
    initCLA();      // CLA 초기화: PI 연산 오프로드
    initUART();     // UART 초기화: SCIA, 115200 baud
    initInterrupts(); // 인터럽트 초기화: ADC, CLA, SCIA RX

    // 글로벌 인터럽트 활성화
    EALLOW;         // 보호된 레지스터 접근 허용
    EINT;           // 글로벌 인터럽트 활성화
    ERTM;           // 실시간 인터럽트 활성화
    EDIS;           // 보호된 레지스터 접근 비활성화

    updateSystemState(0); // 초기 상태: STOP(0), UART로 상태 전송

    // 유휴 루프: 스위치 상태 확인 및 UART 디버깅 데이터 전송
    while(1) {
        debounceSwitch(); // GPIO4 스위치 디바운싱 처리 (RUN/STOP 전환)
        if (error_count > ERROR_COUNT_MAX) { // ADC 에러 10회 초과 시 FAULT
            updateSystemState(2);
        }
        scia_xmit(Vout); // Vout 전송 (mV 단위)
        scia_xmit(Iout); // Iout 전송 (mA 단위)
        scia_xmit_status(system_state); // 상태 전송: 0(STOP), 1(RUN), 2(FAULT)
        DELAY_US(100000); // 100ms 주기로 데이터 전송
    }
}

// 시스템 초기화: 클럭, PIE, CLA 설정
void initSystem(void) {
    InitSysCtrl(); // 시스템 클럭 설정: 200MHz (외부 20MHz 크리스탈, PLL 배수 20, DIVSEL=2)
    DINT;          // 모든 인터럽트 비활성화
    InitPieCtrl(); // PIE 컨트롤러 초기화
    IER = 0x0000;  // 인터럽트 인에이블 레지스터 클리어
    IFR = 0x0000;  // 인터럽트 플래그 레지스터 클리어
    InitPieVectTable(); // PIE 벡터 테이블 초기화
    InitCla();     // CLA 초기화 (Control Law Accelerator)
}

// GPIO 초기화: PWM, ADC, UART, 외부 스위치 설정
void initGPIO(void) {
    EALLOW; // 보호된 레지스터 접근 허용
    // GPIO0: ePWM1A (MOSFET 제어)
    GpioCtrlRegs.GPAMUX1.bit.GPIO0 = 1; // MUX 설정: ePWM1A
    GpioCtrlRegs.GPADIR.bit.GPIO0 = 1;  // 출력 방향
    GpioCtrlRegs.GPAPUD.bit.GPIO0 = 0;  // 풀업 저항 활성화
    // GPIO2: ADCINA0 (Vout 센싱)
    GpioCtrlRegs.GPAMUX1.bit.GPIO2 = 0; // MUX 설정: GPIO (ADC 입력)
    GpioCtrlRegs.GPADIR.bit.GPIO2 = 0;  // 입력 방향
    GpioCtrlRegs.GPAQSEL1.bit.GPIO2 = 0; // 즉시 샘플링 (최소 지연)
    // GPIO3: ADCINA1 (Iout 센싱)
    GpioCtrlRegs.GPAMUX1.bit.GPIO3 = 0; // MUX 설정: GPIO (ADC 입력)
    GpioCtrlRegs.GPADIR.bit.GPIO3 = 0;  // 입력 방향
    GpioCtrlRegs.GPAQSEL1.bit.GPIO3 = 0; // 즉시 샘플링
    // GPIO4: 외부 스위치 (RUN/STOP, Low=RUN)
    GpioCtrlRegs.GPAMUX1.bit.GPIO4 = 0; // MUX 설정: GPIO
    GpioCtrlRegs.GPADIR.bit.GPIO4 = 0;  // 입력 방향
    GpioCtrlRegs.GPAPUD.bit.GPIO4 = 1;  // 내부 풀업 활성화
    GpioCtrlRegs.GPAQSEL1.bit.GPIO4 = 0; // 즉시 샘플링
    // GPIO28: SCIA TX (UART 전송)
    GpioCtrlRegs.GPBMUX1.bit.GPIO28 = 1; // MUX 설정: SCIA TX
    GpioCtrlRegs.GPBDIR.bit.GPIO28 = 1;  // 출력 방향
    // GPIO29: SCIA RX (UART 수신)
    GpioCtrlRegs.GPBMUX1.bit.GPIO29 = 1; // MUX 설정: SCIA RX
    GpioCtrlRegs.GPBDIR.bit.GPIO29 = 0;  // 입력 방향
    EDIS; // 보호된 레지스터 접근 비활성화
}

// ADC 초기화: ADCA 모듈로 Vout/Iout 샘플링 설정
void initADC(void) {
    EALLOW;
    // ADC 클럭 설정: SYSCLK(200MHz) / (2 * PRESCALE) = 200MHz / 16 = 12.5MHz
    AdcaRegs.ADCCTL2.bit.PRESCALE = 8; // PRESCALE=8, 최대 ADC 클럭 50MHz 내
    // SOC0: Vout 샘플링 (ADCINA0)
    AdcaRegs.ADCSOC0CTL.bit.CHSEL = 0; // 채널 선택: ADCINA0
    AdcaRegs.ADCSOC0CTL.bit.ACQPS = 14; // 샘플링 윈도우: 15 사이클 (15 / 12.5MHz ≈ 1.2us)
    AdcaRegs.ADCSOC0CTL.bit.TRIGSEL = 5; // 트리거: ePWM1 SOCA (PWM 동기화)
    // SOC1: Iout 샘플링 (ADCINA1)
    AdcaRegs.ADCSOC1CTL.bit.CHSEL = 1; // 채널 선택: ADCINA1
    AdcaRegs.ADCSOC1CTL.bit.ACQPS = 14; // 샘플링 윈도우: 15 사이클
    AdcaRegs.ADCSOC1CTL.bit.TRIGSEL = 5; // 트리거: ePWM1 SOCA
    // 인터럽트 설정
    AdcaRegs.ADCINTSEL1N2.bit.INT1SEL = 0; // ADCINT1: SOC0 완료 시 발생
    AdcaRegs.ADCINTSEL1N2.bit.INT1E = 1; // ADCINT1 활성화
    AdcaRegs.ADCINTFLGCLR.bit.ADCINT1 = 1; // ADCINT1 플래그 클리어
    AdcaRegs.ADCCTL1.bit.INTPULSEPOS = 1; // 인터럽트 펄스: 샘플링 완료 후
    AdcaRegs.ADCCTL1.bit.ADCPWDNZ = 1; // ADC 전원 활성화
    DELAY_US(1000); // ADC 안정화 대기: 최소 500us, 1ms로 설정
    EDIS;
}

// PWM 초기화: ePWM1, 200kHz Up-Down 모드
void initPWM(void) {
    EALLOW;
    EPwm1Regs.TBCTL.bit.CTRMODE = 2; // Up-Down 카운트 모드 (대칭 PWM)
    EPwm1Regs.TBCTL.bit.PHSEN = 0; // 위상 동기화 비활성화 (단일 PWM)
    EPwm1Regs.TBCTL.bit.HSPCLKDIV = 1; // 고속 클럭 분주: /2
    EPwm1Regs.TBCTL.bit.CLKDIV = 0; // 클럭 분주: /1 (200MHz)
    EPwm1Regs.TBPRD = PWM_PERIOD; // 주기: 200MHz / (2 * 200kHz) = 500
    EPwm1Regs.CMPA.bit.CMPA = 0; // 초기 듀티: 0 (소프트 스타트)
    EPwm1Regs.TBCTR = 0; // 타이머 카운터 초기화
    EPwm1Regs.ETSEL.bit.SOCAEN = 1; // SOCA 활성화 (ADC 트리거)
    EPwm1Regs.ETSEL.bit.SOCASEL = 1; // SOCA 발생: 주기 시작 시
    EPwm1Regs.ETPS.bit.SOCAPRD = 1; // 매 주기마다 SOCA 발생
    EPwm1Regs.TBCTL.bit.FREE_SOFT = 2; // 소프트 스톱: PWM 비활성화 시 안전 정지
    EDIS;
}

// CMPSS 초기화: PCMC 전류 루프용 비교기 설정
void initCMPSS(void) {
    EALLOW;
    Cmpss1Regs.COMPCTL.bit.COMPDACE = 1; // CMPSS1 활성화
    Cmpss1Regs.COMPCTL.bit.COMPHSOURCE = 0; // 비교기 입력: 내부 DAC
    Cmpss1Regs.COMPDACCTL.bit.DACSOURCE = 0; // DAC 소스: DACHVALS 레지스터
    // DAC 초기값: Iref * Rshunt * (4095/3.3) = 2.4A * 0.05Ω * (4095/3.3)
    Cmpss1Regs.DACHVALS.bit.DACVAL = (Uint16)(_IQtoF(_IQmpy(IREF, SHUNT_R)) * ADC_MAX / _IQtoF(ADC_VREF));
    Cmpss1Regs.COMPCTL.bit.ASYNCHEN = 1; // 비동기 출력: PWM 트리거에 직접 연결
    EDIS;
}

// CLA 초기화: PI 연산을 CLA로 오프로드
void initCLA(void) {
    EALLOW;
    Cla1Regs.MVECT1 = (Uint16)((Uint32)&cla_task1_isr); // CLA Task 1 ISR 연결
    Cla1Regs.MCTL.bit.IACKE = 1; // 인터럽트 ACK 활성화
    Cla1Regs.MIER.bit.MINT1 = 1; // Task 1 인터럽트 활성화
    EDIS;
}

// UART 초기화: SCIA, 115200 baud, RUN/STOP 명령 수신
void initUART(void) {
    EALLOW;
    SciaRegs.SCICCR.all = 0x0007; // 1 stop bit, no parity, 8-bit 데이터
    SciaRegs.SCICTL1.all = 0x0003; // TX, RX 활성화
    SciaRegs.SCIHBAUD.all = 0x0000; // Baud rate 상위 비트
    SciaRegs.SCILBAUD.all = 216; // 115200 baud: 200MHz / ((0:216 + 1) * 8) ≈ 115207
    SciaRegs.SCICTL2.bit.RXBKINTENA = 1; // RX 인터럽트 활성화
    SciaRegs.SCICTL1.all = 0x0023; // SW reset 해제
    EDIS;
}

// UART 데이터 전송: Vout(mV), Iout(mA)
void scia_xmit(_iq data) {
    Uint16 val = (Uint16)(_IQtoF(data) * 1000); // IQ24를 mV/mA 단위로 변환
    if (SciaRegs.SCIFFTX.bit.TXFFST >= 15) { // TX 버퍼 오버플로우 체크
        SciaRegs.SCICTL1.bit.SWRESET = 0; // UART 리셋
        SciaRegs.SCICTL1.bit.SWRESET = 1;
        error_count++; // 에러 카운터 증가
        return;
    }
    while (SciaRegs.SCIFFTX.bit.TXFFST != 0); // TX 버퍼 비어질 때까지 대기
    SciaRegs.SCITXBUF.all = val; // 데이터 전송
}

// UART 상태 전송: 시스템 상태 (0: STOP, 1: RUN, 2: FAULT)
void scia_xmit_status(Uint16 status) {
    if (SciaRegs.SCIFFTX.bit.TXFFST >= 15) { // TX 버퍼 오버플로우 체크
        SciaRegs.SCICTL1.bit.SWRESET = 0;
        SciaRegs.SCICTL1.bit.SWRESET = 1;
        error_count++;
        return;
    }
    while (SciaRegs.SCIFFTX.bit.TXFFST != 0);
    SciaRegs.SCITXBUF.all = status;
}

// 스위치 디바운싱: GPIO4 상태 안정화 (50us)
void debounceSwitch(void) {
    Uint16 current_state = GpioDataRegs.GPADAT.bit.GPIO4; // 현재 스위치 상태 읽기
    if (current_state != last_switch_state) { // 상태 변화 감지
        debounce_counter++;
        if (debounce_counter >= DEBOUNCE_COUNT) { // 50us 대기 후 상태 확정
            switch_state = current_state;
            debounce_counter = 0;
            if (switch_state == 0 && system_state == 0) { // Low: RUN
                updateSystemState(1);
            } else if (switch_state == 1 && system_state == 1) { // High: STOP
                updateSystemState(0);
            }
        }
    } else {
        debounce_counter = 0; // 상태 변화 없으면 카운터 리셋
    }
    last_switch_state = current_state; // 현재 상태 저장
}

// 소프트 스타트: 듀티 사이클을 0에서 DUTY_INIT까지 10ms 동안 선형 증가
void softStart(void) {
    if (soft_start_count < SOFT_START_STEPS) { // 10ms 미만
        // 듀티 증가: duty = (soft_start_count / SOFT_START_STEPS) * duty_target
        duty = _IQmpy(_IQdiv(_IQ(soft_start_count), _IQ(SOFT_START_STEPS)), duty_target);
        EPwm1Regs.CMPA.bit.CMPA = (Uint16)(_IQtoF(duty) * PWM_PERIOD); // PWM 듀티 업데이트
        soft_start_count++; // 카운터 증가
    } else {
        duty = duty_target; // 목표 듀티 도달
        EPwm1Regs.CMPA.bit.CMPA = (Uint16)(_IQtoF(duty) * PWM_PERIOD);
    }
}

// 보호 기능: OVP(13.2V), OCP(2.6A) 확인 및 복구
void checkProtection(void) {
    if (_IQtoF(Vout) > _IQtoF(V_OVP) || _IQtoF(Iout) > _IQtoF(I_OCP)) { // OVP 또는 OCP 트리거
        updateSystemState(2); // FAULT 상태로 전환
        EALLOW;
        EPwm1Regs.TBCTL.bit.CTRMODE = 3; // PWM 비활성화 (정지 모드)
        EPwm1Regs.CMPA.bit.CMPA = 0; // 듀티 0
        soft_start_count = 0; // 소프트 스타트 리셋
        duty = _IQ(0.0); // 듀티 초기화
        duty_prev = _IQ(0.0); // 이전 듀티 초기화
        fault_recovery_counter = FAULT_RECOVERY_TIME; // 복구 카운터 설정 (1초)
        EDIS;
    } else if (system_state == 2 && fault_recovery_counter > 0) { // FAULT 상태에서 복구 대기
        fault_recovery_counter--;
        if (fault_recovery_counter == 0) { // 1초 후 복구
            updateSystemState(0); // STOP 상태로 전환
        }
    }
}

// 시스템 상태 업데이트: RUN/STOP/FAULT 전환 및 UART 전송
void updateSystemState(Uint16 new_state) {
    if (new_state == system_state) return; // 동일 상태면 무시
    system_state = new_state; // 상태 업데이트
    EALLOW;
    if (system_state == 1) { // RUN 상태
        EPwm1Regs.TBCTL.bit.CTRMODE = 2; // PWM 활성화 (Up-Down 모드)
        soft_start_count = 0; // 소프트 스타트 초기화
        duty = _IQ(0.0); // 듀티 초기화
    } else { // STOP 또는 FAULT 상태
        EPwm1Regs.TBCTL.bit.CTRMODE = 3; // PWM 비활성화
        EPwm1Regs.CMPA.bit.CMPA = 0; // 듀티 0
        soft_start_count = 0; // 소프트 스타트 리셋
        duty = _IQ(0.0);
        duty_prev = _IQ(0.0);
    }
    EDIS;
    scia_xmit_status(system_state); // 상태를 UART로 전송
}

// 인터럽트 초기화: ADCINT1, CLA Task 1, SCIA RX 설정
void initInterrupts(void) {
    EALLOW;
    PieVectTable.ADCA1_INT = &adc_isr; // ADCINT1 ISR: Vout/Iout 샘플링
    PieVectTable.CLA1_1_INT = &cla_task1_isr; // CLA Task 1 ISR: PI 연산
    PieVectTable.SCIA_RX_INT = &scia_rx_isr; // SCIA RX ISR: UART 명령
    PieCtrlRegs.PIEIER1.bit.INTx1 = 1; // ADCINT1 활성화 (그룹 1)
    PieCtrlRegs.PIEIER11.bit.INTx1 = 1; // CLA 인터럽트 활성화 (그룹 11)
    PieCtrlRegs.PIEIER9.bit.INTx1 = 1; // SCIA RX 인터럽트 활성화 (그룹 9)
    IER |= M_INT1 | M_INT9 | M_INT11; // CPU 인터럽트 그룹 1, 9, 11 활성화
    EDIS;
}

// ADC ISR: Vout/Iout 샘플링, 보호 확인, CLA 트리거
__interrupt void adc_isr(void) {
    // Vout = ADCRESULT0 * (3.3V / 4095) * VOUT_DIVIDER (분압비 보정)
    Vout = _IQmpy(_IQ(AdcaResultRegs.ADCRESULT0), _IQdiv(ADC_VREF, ADC_MAX)) * VOUT_DIVIDER;
    // Iout = ADCRESULT1 * (3.3V / (4095 * 0.05Ω))
    Iout = _IQmpy(_IQ(AdcaResultRegs.ADCRESULT1), _IQdiv(ADC_VREF, _IQmpy(ADC_MAX, SHUNT_R)));
    // 입력 범위 확인: Vout(0~15V), Iout(0~3A)
    if (_IQtoF(Vout) < 0.0f || _IQtoF(Vout) > 15.0f || _IQtoF(Iout) < 0.0f || _IQtoF(Iout) > 3.0f) {
        error_count++; // ADC 에러 카운터 증가
        Vout = _IQ(0.0); // 기본값 설정
        Iout = _IQ(0.0);
    }
    CLA_Vout = Vout; // CLA로 Vout 전달
    CLA_Iout = Iout; // CLA로 Iout 전달
    checkProtection(); // OVP/OCP 확인
    if (system_state == 1) { // RUN 상태에서만 소프트 스타트 및 CLA 실행
        softStart();
        Cla1Regs.MIFRC.bit.INT1 = 1; // CLA Task 1 트리거
    }
    AdcaRegs.ADCINTFLGCLR.bit.ADCINT1 = 1; // ADCINT1 플래그 클리어
    PieCtrlRegs.PIEACK.all = PIEACK_GROUP1; // PIE 그룹 1 ACK
}

// CLA ISR: PI 제어기 및 전류 루프 연산
__interrupt void cla_task1_isr(void) {
    if (system_state != 1) return; // RUN 상태가 아니면 연산 중지
    // 오차 계산: e[n] = Vref - Vout
    CLA_error = _IQmpy(VREF - CLA_Vout, _IQ(1.0));
    // 이산 PI 제어기: u[n] = u[n-1] + 0.1538 e[n] - 0.1462 e[n-1]
    // - 계수: MATLAB pidTuner에서 도출 (KP=0.15, KI=1500, Ts=5us)
    CLA_duty = duty_prev + _IQmpy(_IQ(0.1538), CLA_error) - _IQmpy(_IQ(0.1462), error_prev);
    // 듀티 사이클 제한: 0.1~0.9
    if (CLA_duty > DUTY_MAX) CLA_duty = DUTY_MAX;
    if (CLA_duty < DUTY_MIN) CLA_duty = DUTY_MIN;
    // Slope compensation: duty = duty - mc * Ts (subharmonic oscillation 방지)
    _iq comp_duty = CLA_duty - _IQmpy(SLOPE_COMP, TS);
    // CMPSS DAC 업데이트: (Iref + mc * Ts) * Rshunt * (4095/3.3)
    Cmpss1Regs.DACHVALS.bit.DACVAL = (Uint16)(_IQtoF(_IQmpy(IREF + _IQmpy(SLOPE_COMP, TS), SHUNT_R)) * ADC_MAX / _IQtoF(ADC_VREF));
    // PWM 업데이트: 소프트 스타트 완료 후 적용
    if (soft_start_count >= SOFT_START_STEPS) {
        EPwm1Regs.CMPA.bit.CMPA = (Uint16)(_IQtoF(comp_duty) * PWM_PERIOD);
    }
    error_prev = CLA_error; // 이전 오차 저장
    duty_prev = CLA_duty;   // 이전 듀티 저장
    Cla1Regs.MIRUN.bit.INT1 = 0; // CLA 인터럽트 클리어
}

// UART RX ISR: RUN('R'), STOP('S') 명령 처리
__interrupt void scia_rx_isr(void) {
    Uint16 rx_data = SciaRegs.SCIRXBUF.all; // 수신 데이터 읽기
    if (rx_data == 'R' && system_state == 0) { // 'R': STOP → RUN
        updateSystemState(1);
    } else if (rx_data == 'S' && system_state == 1) { // 'S': RUN → STOP
        updateSystemState(0);
    }
    SciaRegs.SCIFFRX.bit.RXFFOVRCLR = 1; // RX 오버플로우 플래그 클리어
    SciaRegs.SCIFFRX.bit.RXFFINTCLR = 1; // RX 인터럽트 플래그 클리어
    PieCtrlRegs.PIEACK.all = PIEACK_GROUP9; // PIE 그룹 9 ACK
}

7. 시뮬레이션 및 검증

7.1 MATLAB/Simulink 시뮬레이션

• PCMC:
  • Simscape: \( L = 22 \mu H \), \( C = 33 \mu F \), \( R = 12 \Omega \).
  • Discrete Transfer Function: [0.1538, -0.1462], [1, -1].
  • Slope compensation: \( m_c = 0.015 V/\mu s \).
  • 테스트: 부하 스텝 (0.5A → 1A), 전압 스텝 (12V → 13V), 소프트 스타트 (10ms).
• 기준:
  • 리플: \( \Delta V_{out} \leq 120mV \)
  • 과도 응답: \( \leq 100\mu s \)
  • 위상 마진: \( \geq 45^\circ \)
  • OVP: \( V_{out} \leq 13.2V \), OCP: \( I_{out} \leq 1.5A \).

7.2 하드웨어 테스트

• 장비: F28379D LaunchPad, 커스터마이징된 Boost 보드, 오실로스코프, 전원 공급기 (5V, 3A).
• 절차:
  1. CCS v12로 빌드/플래시.
  2. Simulink External Mode로 \( K_p \), \( K_i \), \( I_{ref} \) 튜닝.
  3. UART로 \( V_{out}, I_{out} \), 상태 모니터링 ('R'/'S' 명령 전송).
  4. 외부 스위치(GPIO4)로 RUN/STOP 테스트.
  5. 소프트 스타트, OVP, OCP 동작 확인.
• 기준:
  • \( V_{out} = 12V \pm 120mV \).
  • 위상 마진 \( \geq 45^\circ \).
  • 과도 응답 \( \leq 100\mu s \).
  • 소프트 스타트: 10ms 내 안정화.

8. 참고 자료

• TI 문서: TIDM-1001, SLUA416, SPRUHM8I, C2000Ware Digital Power SDK.
• MATLAB: Control System Toolbox, C2000 Microcontroller Blockset.
• 도구: powerSUITE, Code Composer Studio v12.