안녕하세요! 이번에는 요청을 받은 내용인 델타-시그마 변조(Delta-Sigma Modulation)라는 고급 기법을 다뤄보겠습니다. 이 기술을 마스터하면 16비트, 24비트급의 고품질 아날로그 출력을 만들 수 있습니다! 지금까지의 제 글만 보신 분들 기준으로는 상당히 고급 기법이기 때문에, 다 못따라오셔도 괜찮습니다.

이번 편의 목표

• 델타-시그마 변조의 핵심 원리 이해
• PWM vs 델타-시그마의 차이점과 장단점
• 1비트 ADC와 DAC의 동작 원리 파악
• 마이크로컨트롤러로 델타-시그마 변조 구현
• 노이즈 셰이핑(Noise Shaping)의 마법 체험

PWM의 한계와 델타-시그마의 등장

PWM의 근본적 문제점

전통적인 PWM은 간단하고 효과적이지만, 고품질 아날로그 출력에는 한계가 있습니다:

듀티 사이클 50% PWM (1kHz):
████░░░░████░░░░████░░░░████░░░░
│◄─ 1ms ─►│◄─ 1ms ─►│◄─ 1ms ─►│

스펙트럼 분석:
DC 성분: 원하는 신호 ✓
1kHz:    매우 큰 노이즈 ✗
2kHz:    큰 노이즈 ✗  
3kHz:    중간 노이즈 ✗

PWM의 주요 한계:

• 고정된 주파수에 강한 노이즈 집중
• 필터 설계 복잡: 특정 주파수만 제거해야 함
• EMI 문제: 강한 고조파 성분
• 오디오 응용 한계: 가청 주파수 대역의 노이즈

델타-시그마 변조란?

델타-시그마 변조는 오버샘플링과 노이즈 셰이핑을 결합한 혁신적인 기법입니다:

델타-시그마 변조된 신호:
█░█░░█░█░███░░█░░█░█░███░█░░█░░█

스펙트럼 분석:
DC 성분:     원하는 신호 ✓
저주파:      매우 작은 노이즈 ✓
고주파:      노이즈가 밀려남 ✓ → 쉽게 필터링

델타-시그마의 혁신:

• 노이즈 셰이핑: 노이즈를 고주파로 밀어냄
• 1비트 출력: 디지털 회로로 쉽게 구현
• 고품질: 16비트, 24비트급 정밀도 달성
• 간단한 필터: 저역 통과 필터만 있으면 됨

델타-시그마 변조의 핵심 원리

기본 구조와 동작

입력신호 → [+] → 적분기 → 비교기 → 출력(1비트)
          ↑             ↓
          └── [반전] ←──┘
              (피드백)

동작 원리:

1. 입력 신호와 피드백 신호의 차이(델타) 계산
2. 그 차이를 적분(시그마)
3. 적분 결과를 임계값과 비교해서 1비트 출력
4. 출력을 피드백으로 되돌림

왜 이렇게 동작할까?

핵심 아이디어: 지역적 균형

입력이 0.3 (30%)인 경우를 시뮬레이션해보면:

입력: 0.3, 출력: 0 → 오차: +0.3 → 적분: 0.3
입력: 0.3, 출력: 0 → 오차: +0.3 → 적분: 0.6  
입력: 0.3, 출력: 1 → 오차: -0.7 → 적분: -0.1
입력: 0.3, 출력: 0 → 오차: +0.3 → 적분: 0.2
입력: 0.3, 출력: 0 → 오차: +0.3 → 적분: 0.5
입력: 0.3, 출력: 1 → 오차: -0.7 → 적분: -0.2

출력 패턴: 0 0 1 0 0 1 0 0 1 ...
평균: 1/3 ≈ 0.33 ≈ 입력값!

마법의 비밀:

• 적분기가 장기간 평균 오차를 0으로 만들려고 함
• 결과적으로 출력의 평균이 입력값과 같아짐
• 고주파 노이즈는 발생하지만 쉽게 필터링 가능

1차 델타-시그마 변조기 구현

기본 알고리즘

c

// 1차 델타-시그마 변조기 구조체
typedef struct {
    int16_t integrator;     // 적분기 (16비트)
    uint8_t output_pin;     // 출력 핀
    int16_t input_value;    // 입력 값 (-32768 ~ 32767)
    uint8_t output_state;   // 현재 출력 상태
} DeltaSigma_t;

// 전역 변수
volatile DeltaSigma_t ds_modulator;

// 델타-시그마 변조기 초기화
void delta_sigma_init(uint8_t pin) {
    ds_modulator.integrator = 0;
    ds_modulator.output_pin = pin;
    ds_modulator.input_value = 0;
    ds_modulator.output_state = 0;
    
    // 출력 핀 설정
    DDRB |= (1 << pin);
    
    // Timer2를 100kHz로 설정 (델타-시그마 샘플링 주파수)
    TCCR2A = (1 << WGM21);  // CTC 모드
    TCCR2B = (1 << CS21);   // 프리스케일러 8
    OCR2A = 19;             // 100kHz = 16MHz / (8 * (19+1))
    TIMSK2 |= (1 << OCIE2A); // 비교 매치 인터럽트 활성화
}

// 1차 델타-시그마 변조 알고리즘
void delta_sigma_process(void) {
    // 에러 계산: 입력 - 이전 출력
    int16_t error = ds_modulator.input_value;
    if (ds_modulator.output_state) {
        error -= 32767;  // HIGH 출력일 때
    } else {
        error += 32767;  // LOW 출력일 때
    }
    
    // 적분기 업데이트
    ds_modulator.integrator += error;
    
    // 출력 결정
    if (ds_modulator.integrator >= 0) {
        ds_modulator.output_state = 1;
        PORTB |= (1 << ds_modulator.output_pin);
    } else {
        ds_modulator.output_state = 0;
        PORTB &= ~(1 << ds_modulator.output_pin);
    }
}

// Timer2 비교 매치 인터럽트 (100kHz)
ISR(TIMER2_COMPA_vect) {
    delta_sigma_process();
}

2차 델타-시그마 변조기 구현

1차보다 훨씬 우수한 노이즈 특성을 가진 2차 변조기를 구현해봅시다.

2차 변조기의 장점

• 더 좋은 노이즈 셰이핑: 노이즈가 f² 비례로 증가
• 높은 SNR: 동일 주파수에서 더 나은 신호 대 잡음비
• 더 안정적: 큰 신호에서도 안정적 동작

c

// 2차 델타-시그마 변조기 구조체
typedef struct {
    int32_t integrator1;    // 첫 번째 적분기 (32비트)
    int32_t integrator2;    // 두 번째 적분기 (32비트)
    uint8_t output_pin;     // 출력 핀
    int16_t input_value;    // 입력 값
    uint8_t output_state;   // 현재 출력 상태
    float amplitude;        // 진폭 제어 (0.0 ~ 1.0)
} DeltaSigma2nd_t;

volatile DeltaSigma2nd_t ds2_modulator;

// 2차 델타-시그마 변조기 초기화
void delta_sigma_2nd_init(uint8_t pin) {
    ds2_modulator.integrator1 = 0;
    ds2_modulator.integrator2 = 0;
    ds2_modulator.output_pin = pin;
    ds2_modulator.input_value = 0;
    ds2_modulator.output_state = 0;
    ds2_modulator.amplitude = 0.5;
    
    // 출력 핀 설정
    DDRB |= (1 << pin);
    
    // Timer2를 200kHz로 설정 (더 높은 오버샘플링)
    TCCR2A = (1 << WGM21);  // CTC 모드
    TCCR2B = (1 << CS21);   // 프리스케일러 8
    OCR2A = 9;              // 200kHz = 16MHz / (8 * (9+1))
    TIMSK2 |= (1 << OCIE2A);
}

// 2차 델타-시그마 변조 알고리즘
void delta_sigma_2nd_process(void) {
    // 입력에 진폭 적용
    int32_t scaled_input = (int32_t)(ds2_modulator.input_value * ds2_modulator.amplitude);
    
    // 피드백 계산
    int32_t feedback = 0;
    if (ds2_modulator.output_state) {
        feedback = 32767L << 8;  // HIGH 출력일 때 (스케일링)
    } else {
        feedback = -32767L << 8; // LOW 출력일 때
    }
    
    // 첫 번째 적분기 업데이트
    int32_t error1 = (scaled_input << 8) - feedback;
    ds2_modulator.integrator1 += error1;
    
    // 두 번째 적분기 업데이트
    int32_t error2 = ds2_modulator.integrator1 - feedback;
    ds2_modulator.integrator2 += error2;
    
    // 오버플로우 방지
    #define MAX_INTEGRATOR 2147483647L
    if (ds2_modulator.integrator1 > MAX_INTEGRATOR) 
        ds2_modulator.integrator1 = MAX_INTEGRATOR;
    if (ds2_modulator.integrator1 < -MAX_INTEGRATOR) 
        ds2_modulator.integrator1 = -MAX_INTEGRATOR;
    if (ds2_modulator.integrator2 > MAX_INTEGRATOR) 
        ds2_modulator.integrator2 = MAX_INTEGRATOR;
    if (ds2_modulator.integrator2 < -MAX_INTEGRATOR) 
        ds2_modulator.integrator2 = -MAX_INTEGRATOR;
    
    // 출력 결정 (두 번째 적분기 기준)
    if (ds2_modulator.integrator2 >= 0) {
        ds2_modulator.output_state = 1;
        PORTB |= (1 << ds2_modulator.output_pin);
    } else {
        ds2_modulator.output_state = 0;
        PORTB &= ~(1 << ds2_modulator.output_pin);
    }
}

// Timer2 비교 매치 인터럽트 (200kHz)
ISR(TIMER2_COMPA_vect) {
    delta_sigma_2nd_process();
}

노이즈 셰이핑의 마법

1차 vs 2차 변조기 비교

특성	1차 델타-시그마	2차 델타-시그마
노이즈 전달 함수	H(f) = 2πf	H(f) = (2πf)²
노이즈 증가율	+20dB/decade	+40dB/decade
저주파 노이즈	적음	매우 적음
안정성	매우 안정	조건부 안정
CPU 사용률	낮음음	중간

주파수 응답 특성

1차 델타-시그마:
주파수 (Hz)  | 노이즈 레벨
10          | -60dB
100         | -40dB  
1000        | -20dB
10000       | 0dB

2차 델타-시그마:
주파수 (Hz)  | 노이즈 레벨
10          | -80dB
100         | -40dB
1000        | 0dB
10000       | +40dB

실전: 고품질 오디오 DAC 구현

16비트 오디오 생성기

c

#include <avr/pgmspace.h>
#include <math.h>

// 사인파 테이블 (256 샘플, 16비트 정밀도)
const int16_t sine_table[256] PROGMEM = {
    0, 804, 1608, 2410, 3212, 4011, 4808, 5602, 6393, 7179,
    7962, 8739, 9512, 10278, 11039, 11793, 12539, 13279, 14010, 14732,
    // ... (나머지 236개 값)
};

// 고품질 오디오 생성기
typedef struct {
    uint32_t phase_accumulator;
    uint32_t frequency_tuning_word;
    float amplitude;
    float integrator1, integrator2;
} audio_generator_t;

audio_generator_t audio_gen = {0};

// 오디오 초기화 (250kHz 샘플링)
void audio_init(void) {
    // Timer0를 250kHz로 설정
    TCCR0A = (1 << WGM01);
    TCCR0B = (1 << CS00);  // 분주 없음
    OCR0A = 63;            // 16MHz / 64 = 250kHz
    TIMSK0 = (1 << OCIE0A);
    
    DDRB |= (1 << PB0);  // 오디오 출력 핀
}

// 주파수 설정
void set_frequency(float freq_hz) {
    // DDS (Direct Digital Synthesis) 주파수 튜닝 워드
    audio_gen.frequency_tuning_word = (uint32_t)((freq_hz * 4294967296.0) / 250000.0);
}

// 진폭 설정 (0.0 ~ 1.0)
void set_amplitude(float amp) {
    audio_gen.amplitude = amp;
}

// 250kHz 인터럽트
ISR(TIMER0_COMPA_vect) {
    // DDS로 파형 생성
    audio_gen.phase_accumulator += audio_gen.frequency_tuning_word;
    uint8_t table_index = audio_gen.phase_accumulator >> 24;  // 상위 8비트
    
    // 사인파 값 읽기 (16비트)
    int16_t sine_value = pgm_read_word(&sine_table[table_index]);
    
    // 진폭 조절 및 DC 오프셋 추가
    float audio_sample = (sine_value / 32768.0) * audio_gen.amplitude * 0.5 + 0.5;
    
    // 2차 델타-시그마 변조
    float error = audio_sample - ((PORTB & (1 << PB0)) ? 1.0 : 0.0);
    audio_gen.integrator1 += error;
    audio_gen.integrator2 += audio_gen.integrator1;
    
    if (audio_gen.integrator2 >= 0.0) {
        PORTB |= (1 << PB0);
    } else {
        PORTB &= ~(1 << PB0);
    }
}

// 멜로디 연주 예제
int main(void) {
    audio_init();
    set_amplitude(0.8);  // 80% 볼륨
    sei();
    
    // C 메이저 스케일 (도레미파솔라시도)
    float melody[] = {261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25};
    
    while(1) {
        for (int i = 0; i < 8; i++) {
            set_frequency(melody[i]);
            _delay_ms(500);  // 0.5초씩 연주
        }
        _delay_ms(1000);  // 1초 쉼
    }
    
    return 0;
}

PWM vs 델타-시그마 성능 비교

실측 비교 데이터

항목	8비트 PWM	1차 델타-시그마	2차 델타-시그마
샘플링 주파수	62.5kHz	100kHz	200kHz
유효 해상도	8비트	~12비트	~14비트
THD+N @ 1kHz	-40dB	-55dB	-65dB
출력 필터	큰 LC 필터	간단한 RC	작은 RC
CPU 사용률	1%	15%	25%
DC 정밀도	±20mV	±5mV	±2mV

스펙트럼 분석

PWM 스펙트럼 (1kHz 신호, 15.6kHz PWM):
주파수 (kHz) | 신호 레벨 (dB)
1            | 0      (원하는 신호) ✓
15.6         | -20    (PWM 기본파) ✗
31.2         | -26    (2차 고조파) ✗

델타-시그마 스펙트럼 (1kHz 신호, 200kHz 샘플링):
주파수 (kHz) | 신호 레벨 (dB)
1            | 0      (원하는 신호) ✓
10           | -60    (매우 약한 노이즈) ✓
50           | -20    (고주파 노이즈) → 쉽게 필터링

고급 델타-시그마 기법들

MASH 구조 (Multi-stAge noise sHaping)

c

// 3차 MASH 델타-시그마 구현
typedef struct {
    float integrator1, integrator2, integrator3;
    uint8_t output1, output2, output3;
} mash_modulator_t;

mash_modulator_t mash = {0};

uint8_t mash_delta_sigma(float input) {
    // 1차 스테이지
    float error1 = input - mash.output1;
    mash.integrator1 += error1;
    mash.output1 = (mash.integrator1 >= 0.0) ? 1 : 0;
    
    // 2차 스테이지 (1차의 오차를 입력으로)
    float error2 = error1 - mash.output2;
    mash.integrator2 += error2;
    mash.output2 = (mash.integrator2 >= 0.0) ? 1 : 0;
    
    // 3차 스테이지 (2차의 오차를 입력으로)
    float error3 = error2 - mash.output3;
    mash.integrator3 += error3;
    mash.output3 = (mash.integrator3 >= 0.0) ? 1 : 0;
    
    // 디지털 필터로 노이즈 셰이핑
    static uint8_t prev_out2 = 0, prev_out3 = 0, prev_prev_out3 = 0;
    
    uint8_t shaped_output = mash.output1 + 
                           (mash.output2 - prev_out2) + 
                           (mash.output3 - 2*prev_out3 + prev_prev_out3);
    
    // 상태 업데이트
    prev_prev_out3 = prev_out3;
    prev_out3 = mash.output3;
    prev_out2 = mash.output2;
    
    return shaped_output & 1;  // 1비트 출력
}

적응형 델타-시그마

c

// 입력 신호 크기에 따라 파라미터 조정
typedef struct {
    float integrator;
    float gain;           // 적응형 게인
    float leak_factor;    // 적분기 누설
} adaptive_ds_t;

adaptive_ds_t ads = {0, 1.0, 0.999};

uint8_t adaptive_delta_sigma(float input) {
    // 입력 신호의 변화율 측정
    static float prev_input = 0.0;
    float input_change = fabs(input - prev_input);
    
    // 급격한 변화 시 게인 증가 (빠른 추적)
    if (input_change > 0.1) {
        ads.gain = 1.5;
    } else {
        ads.gain = 1.0;
    }
    
    // 델타-시그마 계산
    static uint8_t output = 0;
    float error = input - output;
    ads.integrator = ads.integrator * ads.leak_factor + error * ads.gain;
    
    output = (ads.integrator >= 0.0) ? 1 : 0;
    prev_input = input;
    
    return output;
}

1비트 델타-시그마 ADC 구현

델타-시그마는 DAC뿐만 아니라 ADC로도 사용할 수 있습니다!

c

// 1비트 델타-시그마 ADC 구현
typedef struct {
    float integrator;
    uint16_t accumulator;
    uint16_t sample_count;
} ds_adc_t;

ds_adc_t ds_adc = {0, 0, 0};

// 아날로그 비교기 인터럽트
ISR(ANALOG_COMP_vect) {
    uint8_t comp_result = (ACSR & (1 << ACO)) ? 1 : 0;
    
    // 델타-시그마 피드백
    if (comp_result) {
        OCR2A = 255;  // DAC HIGH
    } else {
        OCR2A = 0;    // DAC LOW  
    }
    
    // 디지털 적분
    ds_adc.accumulator += comp_result;
    ds_adc.sample_count++;
}

// ADC 결과 읽기
uint16_t ds_adc_get_result(void) {
    if (ds_adc.sample_count == 0) return 0;
    
    // 오버샘플링 비율에 따른 분해능 향상
    uint16_t result = (ds_adc.accumulator * 65535UL) / ds_adc.sample_count;
    
    // 리셋
    ds_adc.accumulator = 0;
    ds_adc.sample_count = 0;
    
    return result;
}

델타-시그마 설계 계산

오버샘플링 비율과 SNR

c

// 이론적 SNR 계산
float calculate_theoretical_snr(uint8_t order, uint16_t osr) {
    // OSR: 오버샘플링 비율
    // order: 델타-시그마 차수
    
    float snr_db = 6.02 * order * log2(osr) + 1.76 - 5.17 * order;
    return snr_db;
}

// 예시 계산 결과
/*
1차, OSR=64:  42.1 dB SNR (약 7비트)
2차, OSR=64:  78.2 dB SNR (약 13비트)  
3차, OSR=128: 120.4 dB SNR (약 20비트)
*/

RC 필터 설계

c

// 간단한 RC 저역통과 필터 계산
void calculate_filter(float cutoff_freq, float* r_value, float* c_value) {
    // f_c = 1 / (2π RC)
    *r_value = 1000.0;  // 1kΩ
    *c_value = 1.0 / (2.0 * M_PI * *r_value * cutoff_freq);
    
    printf("차단주파수 %.1f Hz를 위한 필터:\n", cutoff_freq);
    printf("R = %.0f Ω\n", *r_value);
    printf("C = %.2f μF\n", *c_value * 1e6);
}

실전 프로젝트: 고품질 함수 발생기

완전한 델타-시그마 기반 함수 발생기를 구현해봅시다:

c

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <math.h>

#define SAMPLE_RATE 100000UL  // 100kHz
#define WAVETABLE_SIZE 1024

typedef enum {
    WAVE_SINE,
    WAVE_TRIANGLE,
    WAVE_SAWTOOTH,
    WAVE_SQUARE
} waveform_t;

typedef struct {
    uint32_t phase_acc;
    uint32_t freq_word;
    float amplitude;
    waveform_t waveform;
    float integrator1, integrator2;
    uint8_t output_pin;
} signal_generator_t;

signal_generator_t gen = {0, 0, 0.5, WAVE_SINE, 0, 0, PB0};

// 100kHz 인터럽트
ISR(TIMER1_COMPA_vect) {
    // 위상 누적
    gen.phase_acc += gen.freq_word;
    
    // 파형 생성
    float sample = 0.0;
    uint16_t table_index = gen.phase_acc >> 22;  // 상위 10비트
    
    switch(gen.waveform) {
        case WAVE_SINE:
            {
                int16_t sine_val = pgm_read_word(&sine_wave[table_index]);
                sample = (sine_val / 32768.0) * gen.amplitude;
            }
            break;
            
        case WAVE_TRIANGLE:
            if (table_index < 512) {
                sample = (table_index / 512.0) * gen.amplitude;
            } else {
                sample = ((1024 - table_index) / 512.0) * gen.amplitude;
            }
            break;
            
        case WAVE_SAWTOOTH:
            sample = (table_index / 1024.0) * gen.amplitude;
            break;
            
        case WAVE_SQUARE:
            sample = (table_index < 512) ? gen.amplitude : 0.0;
            break;
    }
    
    // DC 오프셋 추가 (0~1 범위로)
    sample = sample + 0.5;
    if (sample < 0.0) sample = 0.0;
    if (sample > 1.0) sample = 1.0;
    
    // 2차 델타-시그마 변조
    float current_output = (PORTB & (1 << gen.output_pin)) ? 1.0 : 0.0;
    float error = sample - current_output;
    
    gen.integrator1 += error;
    gen.integrator2 += gen.integrator1;
    
    if (gen.integrator2 >= 0.0) {
        PORTB |= (1 << gen.output_pin);
    } else {
        PORTB &= ~(1 << gen.output_pin);
    }
}

void generator_init(void) {
    // 출력 핀 설정
    DDRB |= (1 << gen.output_pin);
    
    // Timer1 설정 (100kHz)
    TCCR1A = 0;
    TCCR1B = (1 << WGM12) | (1 << CS10);  // CTC, 분주 없음
    OCR1A = (F_CPU / SAMPLE_RATE) - 1;
    TIMSK1 = (1 << OCIE1A);
    
    printf("Signal Generator Ready\n");
}

void set_frequency(float freq_hz) {
    gen.freq_word = (uint32_t)((freq_hz * 4294967296.0) / SAMPLE_RATE);
    printf("Frequency set to %.2f Hz\n", freq_hz);
}

void set_amplitude(float amp_percent) {
    gen.amplitude = amp_percent / 100.0;
    if (gen.amplitude > 1.0) gen.amplitude = 1.0;
    if (gen.amplitude < 0.0) gen.amplitude = 0.0;
    printf("Amplitude set to %.1f%%\n", amp_percent);
}

void set_waveform(waveform_t wave) {
    gen.waveform = wave;
    const char* wave_names[] = {"SINE", "TRIANGLE", "SAWTOOTH", "SQUARE"};
    printf("Waveform set to %s\n", wave_names[wave]);
}

int main(void) {
    generator_init();
    sei();
    
    // 기본 설정
    set_frequency(1000.0);  // 1kHz
    set_amplitude(50.0);    // 50%
    set_waveform(WAVE_SINE);
    
    printf("\nHigh-Quality Function Generator\n");
    printf("Delta-Sigma Modulation @ %lu Hz\n", SAMPLE_RATE);
    
    while(1) {
        // 사용자 입력 처리
        // ... (생략)
    }
    
    return 0;
}

실무 응용 팁

1. 안정성 확보

c

// 오버플로우 방지 및 안정성 개선
#define MAX_INTEGRATOR_VALUE 1000000L

void stability_check(void) {
    if (ds2_modulator.integrator1 > MAX_INTEGRATOR_VALUE) {
        ds2_modulator.integrator1 = MAX_INTEGRATOR_VALUE;
    }
    if (ds2_modulator.integrator1 < -MAX_INTEGRATOR_VALUE) {
        ds2_modulator.integrator1 = -MAX_INTEGRATOR_VALUE;
    }
}

2. 자동 게인 제어 (AGC)

c

void auto_gain_control(void) {
    static int32_t peak_detector = 0;
    int32_t current_sample = abs(ds2_modulator.input_value);
    
    // 피크 검출 (느린 공격, 빠른 릴리즈)
    if (current_sample > peak_detector) {
        peak_detector = current_sample;  // 빠른 공격
    } else {
        peak_detector = (peak_detector * 999) / 1000;  // 느린 릴리즈
    }
    
    // 게인 조정
    if (peak_detector > 20000) {
        ds2_modulator.amplitude *= 0.95;  // 게인 줄이기
    } else if (peak_detector < 10000) {
        ds2_modulator.amplitude *= 1.01;  // 게인 늘리기
    }
    
    // 게인 제한
    if (ds2_modulator.amplitude > 1.0) ds2_modulator.amplitude = 1.0;
    if (ds2_modulator.amplitude < 0.01) ds2_modulator.amplitude = 0.01;
}

델타-시그마의 실제 응용

상용 IC에서의 활용

오디오 DAC:

• PCM1792A (Burr-Brown): 24비트/192kHz 델타-시그마 DAC
• WM8741 (Wolfson): 하이엔드 오디오용 멀티비트 델타-시그마

정밀 ADC:

• ADS1220 (TI): 24비트 델타-시그마 ADC
• MCP3550 (Microchip): 22비트 델타-시그마 ADC

마이크로컨트롤러 내장 기능

c

// STM32의 내장 델타-시그마 모듈 사용
#ifdef STM32_DSCOMP
void stm32_delta_sigma_init(void) {
    COMP1->CSR |= COMP_CSR_COMP1MODE_1;  // 델타-시그마 모드
    COMP1->CSR |= COMP_CSR_COMP1EN;      // 비교기 활성화
}
#endif

// ESP32의 델타-시그마 모듈 사용
#ifdef ESP32_DSIG
#include "driver/sigmadelta.h"

void esp32_delta_sigma_dac(void) {
    sigmadelta_config_t sigmadelta_cfg = {
        .channel = SIGMADELTA_CHANNEL_0,
        .sigmadelta_duty = 128,      // 50% 듀티
        .sigmadelta_prescale = 80,   // 분주비
        .sigmadelta_gpio = 18        // GPIO18 출력
    };
    sigmadelta_config(&sigmadelta_cfg);
}
#endif

결론: 델타-시그마의 힘

핵심 장점 정리

오디오 품질:

• 16비트 DAC 수준의 정밀도
• 낮은 THD+N (< 0.01%)
• 넓은 다이나믹 레인지

구현 용이성:

• 1비트 출력 → 간단한 디지털 회로
• 단순한 RC 필터면 충분
• 소프트웨어로 완전 구현 가능

비용 효율성:

• 고가의 멀티비트 DAC 불필요
• 정밀한 저항 매칭 불필요
• 마이크로컨트롤러만으로 고품질 달성

언제 사용해야 할까?

델타-시그마가 적합한 경우:

• 고품질 오디오 출력
• 정밀한 DC 전압 생성
• 낮은 주파수 신호 (<1kHz)
• 노이즈가 중요한 측정

PWM이 나은 경우:

• 모터 제어 (고주파 노이즈 OK)
• 간단한 밝기 조절
• 빠른 응답이 필요한 제어
• 실시간성이 중요한 시스템

도전 과제

초급 과제

1. 스테레오 출력: 두 개의 델타-시그마 변조기로 좌우 채널 구현
2. 볼륨 컨트롤: 포텐셔미터 입력으로 실시간 볼륨 조절

중급 과제

1. 다중 음색: 여러 사인파를 합성하여 화음 생성
2. ADSR 엔벨로프: Attack-Decay-Sustain-Release 구현

고급 과제

1. FIR 필터: 디지털 필터로 주파수 특성 개선
2. 실시간 스펙트럼: FFT 알고리즘으로 주파수 분석 표시

더 깊이 탐구하려면?

추천 학습 자료가 있습니다. 제가 봤던 자료들이죠.

이론:

• “Understanding Delta-Sigma Data Converters” (Schreier & Temes)
• “Delta-Sigma Data Converters” (Norsworthy et al.)

실험:

• MATLAB/Simulink Delta-Sigma Toolbox
• Python SciPy 신호 처리
• LTSpice 시뮬레이션

실무:

• TI의 Delta-Sigma ADC 개발 키트
• Analog Devices의 Sigma Studio
• Xilinx FPGA 델타-시그마 IP

다음 단계 프로젝트들

1. 고품질 오디오 DAC – 24비트/96kHz 수준
2. 정밀 측정기 – ±0.01% 정확도 멀티미터
3. 소음계 – 델타-시그마 ADC + 가중 필터
4. 함수 발생기 – 0.001Hz ~ 10MHz 범위

---

마무리

오늘은 델타-시그마 변조라는 고급 기법을 통해 PWM의 한계를 뛰어넘는 고품질 아날로그 출력을 구현해봤습니다.

핵심 포인트 정리:

• 델타-시그마 변조: 오버샘플링 + 노이즈 셰이핑으로 고품질 DAC 구현
• 2차 변조기: 1차보다 40dB 향상된 노이즈 특성
• 실무 응용: 오디오 DAC, 정밀 전압 출력, 센서 신호 처리
• 안정성: 오버플로우 방지와 AGC로 견고한 시스템 구축

델타-시그마 변조는 현대 전자공학의 숨은 보석 같은 기술입니다. 단순해 보이지만 그 안에는 깊은 수학적 원리와 놀라운 성능이 숨어있죠. 이제 여러분도 PWM을 넘어선 진짜 고품질 아날로그 출력을 만들 수 있습니다!

이정도 되면 산업용 수준의 아날로그 출력 시스템을 설계할 수 있는 능력을 갖추신 것이 됩니다. 현업에서 날아다닌다는 아니고요. 근데, 그럴 수 있을 겁니다. ㅎㅎ

궁금한 거 있으면 댓글 달아주세요. 검토하고 답변 드리겠습니다.