Spectrum Analyzer

Lab 6: Spectrum Analyzer

Part 3 - Oscilloscope & Signal Processing

---

1. โครงสร้างภาพรวมของ Lab

Why? - ทำไมต้องเรียนรู้เรื่องนี้

• FFT คือหัวใจของ Signal Analysis: Fast Fourier Transform เปลี่ยนสัญญาณจาก Time Domain ไปเป็น Frequency Domain ช่วยให้เห็น "ส่วนประกอบความถี่" ของสัญญาณ ซึ่งมองไม่เห็นจาก oscilloscope ธรรมดา

• Power Quality Analysis: ในระบบไฟฟ้า FFT ใช้วิเคราะห์ Harmonics, THD (Total Harmonic Distortion), Inter-harmonics เพื่อประเมินคุณภาพไฟฟ้าตาม IEEE 519

• Vibration Monitoring: ในโรงงาน FFT ใช้ตรวจจับปัญหาเครื่องจักร (bearing fault, imbalance, misalignment) จาก vibration spectrum

• Smart Energy: Power meter รุ่นใหม่ใช้ FFT วิเคราะห์กำลังไฟฟ้าแบบ real-time สำหรับ Smart Grid, Energy Audit

• EE Application: ออกแบบ Anti-aliasing filter, Power Quality Analyzer, Vibration-based Predictive Maintenance, Audio Equalizer

What? - จะได้เรียนรู้อะไร

1. FFT Concept: Time Domain to Frequency Domain transformation

2. Simplified FFT Implementation: DFT algorithm สำหรับ embedded (ไม่ต้องใช้ library)

3. Bar Chart Spectrum Display: แสดง frequency bins ด้วย bar chart

4. Frequency Resolution & Nyquist: เข้าใจ bin resolution, maximum frequency

5. Peak Frequency Detection: ค้นหาความถี่ที่มีพลังงานสูงสุด

6. Dual View: Time domain + Frequency domain แสดงพร้อมกัน

How? - จะทำอย่างไร

1. สร้างสัญญาณ test (sine, square, ฯลฯ) ที่เลือกได้

2. คำนวณ FFT (Simplified DFT) ของสัญญาณ

3. แสดง spectrum ด้วย Bar chart (bins สีฟ้า)

4. ค้นหาและแสดง peak frequency

5. เพิ่ม gain control สำหรับปรับ sensitivity

6. สร้าง dual view (waveform + spectrum)

---

2. หลักการทำงานและ Flowchart

2.1 FFT Concept

┌─────────────────────────────────────────────────────────────┐
│                    FFT CONCEPT                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   Time Domain (Waveform)       Frequency Domain (Spectrum)  │
│                                                             │
│      ╭──╮   ╭──╮                      ▓                     │
│     ╱    ╲ ╱    ╲                     ▓                     │
│   ╱       ╲       ╲     FFT          ▓▓                     │
│                        ─────►        ▓▓▓                    │
│   Input: N samples               ▓▓▓▓▓▓▓                    │
│   (e.g., 256)                  ─────────────                │
│                                0   f1  f2  fmax (Hz)        │
│                                                             │
│   Output: N/2 frequency bins                                │
│                                                             │
└─────────────────────────────────────────────────────────────┘

2.2 Frequency Bins

┌─────────────────────────────────────────────────────────────┐
│                   FREQUENCY BINS                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   FFT Size: 256                                             │
│   Sample Rate: 44100 Hz                                     │
│   Bins: 128 (= 256/2)                                       │
│                                                             │
│   Bin Resolution = Sample Rate / FFT Size                   │
│                  = 44100 / 256 = 172.3 Hz                   │
│                                                             │
│   Bin 0:    0 - 172 Hz    (DC + low freq)                   │
│   Bin 1:  172 - 344 Hz                                      │
│   Bin 2:  344 - 517 Hz                                      │
│   ...                                                       │
│   Bin 127: 21756 - 22050 Hz (Nyquist)                       │
│                                                             │
│   Maximum frequency = Sample Rate / 2 = 22050 Hz            │
│                                                             │
└─────────────────────────────────────────────────────────────┘

---

3. ฟังก์ชันสำคัญ

3.1 FFT Functions

Function	Description
simple_dft()	Simplified DFT calculation
find_peak_frequency()	ค้นหา dominant frequency
generate_test_signal()	สร้างสัญญาณทดสอบ

3.2 LVGL Bar Chart Setup

Function	Description
lv_chart_set_type(chart, LV_CHART_TYPE_BAR)	Bar chart mode
lv_obj_set_style_pad_column(chart, 2, 0)	CRITICAL: spacing ระหว่าง bar

---

4. Code เต็ม

4.1 Constants and Global Variables

#include "lvgl.h"
#include <math.h>
#include <stdlib.h>

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

#define FFT_SIZE            256
#define FFT_BINS            (FFT_SIZE / 2)
#define FFT_DISPLAY_BINS    64
#define FFT_SAMPLE_RATE     10000
#define TIME_DISPLAY_PTS    200

typedef enum {
    FFT_WAVE_SINE = 0,
    FFT_WAVE_SQUARE,
    FFT_WAVE_TRIANGLE,
    FFT_WAVE_SAWTOOTH,
    FFT_WAVE_DUAL_SINE,  /* 2 sine waves */
} fft_wave_type_t;

/* Buffers */
static int16_t fft_time_buffer[FFT_SIZE];
static uint16_t fft_mag_buffer[FFT_BINS];

/* UI elements */
static lv_obj_t *time_chart = NULL;
static lv_obj_t *fft_chart = NULL;
static lv_chart_series_t *time_series = NULL;
static lv_chart_series_t *fft_series = NULL;
static lv_obj_t *peak_freq_label = NULL;
static lv_timer_t *fft_timer = NULL;

static fft_wave_type_t fft_wave_type = FFT_WAVE_SINE;
static uint32_t fft_signal_freq = 440;
static uint8_t fft_gain = 50;

4.2 Simplified DFT Implementation

/* Simplified DFT - O(N^2) แต่เข้าใจง่าย
 * สำหรับ production ให้ใช้ FFT library (CMSIS-DSP, kiss_fft)
 */
static void simple_dft(const int16_t *input, uint16_t *output,
                        uint16_t N)
{
    uint16_t half_N = N / 2;

    for (uint16_t k = 0; k < half_N; k++) {
        double real_sum = 0;
        double imag_sum = 0;

        for (uint16_t n = 0; n < N; n++) {
            double angle = 2.0 * M_PI * k * n / N;
            real_sum += input[n] * cos(angle);
            imag_sum -= input[n] * sin(angle);
        }

        /* Magnitude = sqrt(real^2 + imag^2) */
        double mag = sqrt(real_sum * real_sum +
                         imag_sum * imag_sum);

        /* Normalize */
        output[k] = (uint16_t)(mag / N * 2);
    }
}

/* ค้นหา Peak frequency (skip DC bin) */
static uint32_t find_peak_frequency(const uint16_t *fft_output,
                                      uint16_t bins,
                                      uint32_t sample_rate)
{
    uint16_t max_val = 0;
    uint16_t max_idx = 1;  /* Skip DC (bin 0) */

    for (uint16_t i = 1; i < bins; i++) {
        if (fft_output[i] > max_val) {
            max_val = fft_output[i];
            max_idx = i;
        }
    }

    /* Convert bin index to frequency */
    float bin_resolution = (float)sample_rate / (bins * 2);
    return (uint32_t)(max_idx * bin_resolution);
}

4.3 Signal Generation

static void generate_test_signal(int16_t *buf, uint16_t count,
                                   fft_wave_type_t type, uint32_t freq)
{
    for (uint16_t i = 0; i < count; i++) {
        double t = (double)i / FFT_SAMPLE_RATE;
        double val = 0;

        switch (type) {
            case FFT_WAVE_SINE:
                val = sin(2.0 * M_PI * freq * t);
                break;

            case FFT_WAVE_SQUARE:
                val = (sin(2.0 * M_PI * freq * t) >= 0) ? 1.0 : -1.0;
                break;

            case FFT_WAVE_TRIANGLE: {
                double phase = fmod((double)i * freq / FFT_SAMPLE_RATE, 1.0);
                val = 4.0 * fabs(phase - 0.5) - 1.0;
                break;
            }

            case FFT_WAVE_SAWTOOTH: {
                double phase = fmod((double)i * freq / FFT_SAMPLE_RATE, 1.0);
                val = 2.0 * phase - 1.0;
                break;
            }

            case FFT_WAVE_DUAL_SINE:
                /* 2 sine waves: fundamental + 2.5x frequency */
                val = 0.7 * sin(2.0 * M_PI * freq * t)
                    + 0.5 * sin(2.0 * M_PI * freq * 2.5 * t);
                break;
        }

        /* เพิ่ม noise เล็กน้อย */
        int16_t noise = (rand() % 101) - 50;
        buf[i] = (int16_t)(val * 1000) + noise;
    }
}

4.4 Display Update

static void update_fft_display(void)
{
    /* สร้างสัญญาณ */
    generate_test_signal(fft_time_buffer, FFT_SIZE,
                         fft_wave_type, fft_signal_freq);

    /* คำนวณ DFT */
    simple_dft(fft_time_buffer, fft_mag_buffer, FFT_SIZE);

    /* อัพเดท Time Domain chart */
    if (time_chart && time_series) {
        for (int i = 0; i < TIME_DISPLAY_PTS; i++) {
            int idx = i * FFT_SIZE / TIME_DISPLAY_PTS;
            int32_t val = ((int32_t)fft_time_buffer[idx] + 1100) * 100
                          / 2200;
            if (val < 0) val = 0;
            if (val > 100) val = 100;
            lv_chart_set_value_by_id(time_chart, time_series, i, val);
        }
        lv_chart_refresh(time_chart);
    }

    /* หาค่า max สำหรับ normalization (skip DC) */
    uint16_t fft_max = 1;
    for (int i = 1; i < FFT_BINS; i++) {
        if (fft_mag_buffer[i] > fft_max) fft_max = fft_mag_buffer[i];
    }

    /* อัพเดท FFT Bar chart */
    if (fft_chart && fft_series) {
        for (int i = 0; i < FFT_DISPLAY_BINS; i++) {
            int idx = i * FFT_BINS / FFT_DISPLAY_BINS;
            int32_t val = (int32_t)fft_mag_buffer[idx] * 100
                          * fft_gain / (fft_max * 50);
            if (val > 100) val = 100;
            if (val < 0) val = 0;
            lv_chart_set_value_by_id(fft_chart, fft_series, i, val);
        }
        lv_chart_refresh(fft_chart);
    }

    /* Peak frequency */
    uint32_t peak = find_peak_frequency(fft_mag_buffer, FFT_BINS,
                                         FFT_SAMPLE_RATE);
    if (peak_freq_label) {
        lv_label_set_text_fmt(peak_freq_label, "Peak: %u Hz",
                              (unsigned int)peak);
    }
}

4.5 Callbacks

static void fft_wave_cb(lv_event_t *e)
{
    if (lv_event_get_code(e) != LV_EVENT_VALUE_CHANGED) return;
    lv_obj_t *dd = lv_event_get_target(e);
    fft_wave_type = (fft_wave_type_t)lv_dropdown_get_selected(dd);
    update_fft_display();
}

static void fft_gain_cb(lv_event_t *e)
{
    if (lv_event_get_code(e) != LV_EVENT_VALUE_CHANGED) return;
    lv_obj_t *slider = lv_event_get_target(e);
    fft_gain = (uint8_t)lv_slider_get_value(slider);
}

static void fft_timer_cb(lv_timer_t *timer)
{
    (void)timer;
    update_fft_display();
}

4.6 Main Function

void part3_ex6_spectrum_analyzer(void)
{
    lv_obj_t *scr = lv_screen_active();
    lv_obj_set_style_bg_color(scr, lv_color_hex(0x0a0a1e), 0);

    /* ===== Title Row ===== */
    lv_obj_t *title = lv_label_create(scr);
    lv_label_set_text(title, "Part 3 Ex6: Spectrum Analyzer");
    lv_obj_set_style_text_color(title, lv_color_hex(0xff6600), 0);
    lv_obj_align(title, LV_ALIGN_TOP_LEFT, 10, 3);

    /* Peak frequency label */
    peak_freq_label = lv_label_create(scr);
    lv_label_set_text(peak_freq_label, "Peak: -- Hz");
    lv_obj_set_style_text_color(peak_freq_label,
                                lv_color_hex(0xffff00), 0);
    lv_obj_align(peak_freq_label, LV_ALIGN_TOP_RIGHT, -10, 3);

    /* ===== Wave Type Dropdown ===== */
    lv_obj_t *wave_dd = lv_dropdown_create(scr);
    lv_dropdown_set_options(wave_dd,
        "Sine\nSquare\nTriangle\nSawtooth\nDual Sine");
    lv_dropdown_set_selected(wave_dd, 0);
    lv_obj_set_width(wave_dd, 110);
    lv_obj_align(wave_dd, LV_ALIGN_TOP_LEFT, 10, 22);
    lv_obj_add_event_cb(wave_dd, fft_wave_cb,
                        LV_EVENT_VALUE_CHANGED, NULL);

    /* Gain slider */
    lv_obj_t *gain_lbl = lv_label_create(scr);
    lv_label_set_text(gain_lbl, "Gain:");
    lv_obj_set_style_text_color(gain_lbl, lv_color_hex(0x00ffff), 0);
    lv_obj_align(gain_lbl, LV_ALIGN_TOP_LEFT, 140, 28);

    lv_obj_t *gain_slider = lv_slider_create(scr);
    lv_slider_set_range(gain_slider, 10, 100);
    lv_slider_set_value(gain_slider, 50, LV_ANIM_OFF);
    lv_obj_set_width(gain_slider, 120);
    lv_obj_align(gain_slider, LV_ALIGN_TOP_LEFT, 185, 28);
    lv_obj_add_event_cb(gain_slider, fft_gain_cb,
                        LV_EVENT_VALUE_CHANGED, NULL);

    /* ===== Time Domain Chart (ด้านบน) ===== */
    time_chart = lv_chart_create(scr);
    lv_obj_set_size(time_chart, 440, 90);
    lv_obj_align(time_chart, LV_ALIGN_TOP_MID, 0, 50);
    lv_chart_set_type(time_chart, LV_CHART_TYPE_LINE);
    lv_chart_set_point_count(time_chart, TIME_DISPLAY_PTS);
    lv_chart_set_range(time_chart, LV_CHART_AXIS_PRIMARY_Y, 0, 100);
    lv_chart_set_div_line_count(time_chart, 2, 5);

    lv_obj_set_style_bg_color(time_chart, lv_color_hex(0x001a00), 0);
    lv_obj_set_style_line_color(time_chart, lv_color_hex(0x002200),
                                LV_PART_MAIN);
    lv_obj_set_style_border_color(time_chart, lv_color_hex(0x004400), 0);
    lv_obj_set_style_border_width(time_chart, 1, 0);
    lv_obj_set_style_size(time_chart, 0, 0, LV_PART_INDICATOR);

    time_series = lv_chart_add_series(time_chart,
                      lv_color_hex(0x00ff00), LV_CHART_AXIS_PRIMARY_Y);

    /* ===== FFT Bar Chart (ด้านล่าง) ===== */
    fft_chart = lv_chart_create(scr);
    lv_obj_set_size(fft_chart, 440, 110);
    lv_obj_align(fft_chart, LV_ALIGN_BOTTOM_MID, 0, -22);
    lv_chart_set_type(fft_chart, LV_CHART_TYPE_BAR);
    lv_chart_set_point_count(fft_chart, FFT_DISPLAY_BINS);
    lv_chart_set_range(fft_chart, LV_CHART_AXIS_PRIMARY_Y, 0, 100);
    lv_chart_set_div_line_count(fft_chart, 4, 5);

    /* CRITICAL: Bar spacing */
    lv_obj_set_style_pad_column(fft_chart, 2, 0);

    /* Cyan theme */
    lv_obj_set_style_bg_color(fft_chart, lv_color_hex(0x001a1a), 0);
    lv_obj_set_style_line_color(fft_chart, lv_color_hex(0x003333),
                                LV_PART_MAIN);
    lv_obj_set_style_border_color(fft_chart, lv_color_hex(0x006666), 0);
    lv_obj_set_style_border_width(fft_chart, 1, 0);

    fft_series = lv_chart_add_series(fft_chart,
                     lv_color_hex(0x00ffff), LV_CHART_AXIS_PRIMARY_Y);

    /* Initialize bars to 0 */
    for (int i = 0; i < FFT_DISPLAY_BINS; i++) {
        lv_chart_set_value_by_id(fft_chart, fft_series, i, 0);
    }

    /* Frequency scale labels */
    lv_obj_t *f0 = lv_label_create(scr);
    lv_label_set_text(f0, "0 Hz");
    lv_obj_set_style_text_color(f0, lv_color_hex(0x666666), 0);
    lv_obj_align(f0, LV_ALIGN_BOTTOM_LEFT, 15, -5);

    lv_obj_t *fmax = lv_label_create(scr);
    lv_label_set_text_fmt(fmax, "%u Hz",
                          (unsigned int)(FFT_SAMPLE_RATE / 2));
    lv_obj_set_style_text_color(fmax, lv_color_hex(0x666666), 0);
    lv_obj_align(fmax, LV_ALIGN_BOTTOM_RIGHT, -15, -5);

    /* ===== Timer ===== */
    fft_timer = lv_timer_create(fft_timer_cb, 200, NULL);

    /* แสดงผลครั้งแรก */
    update_fft_display();
}

---

5. องค์ความรู้และเทคนิค

5.1 CRITICAL: Bar Chart Spacing

/* ถ้าไม่ใส่ pad_column, bars จะรวมเป็นก้อนเดียว (solid block)!
 *
 * WRONG:
 * lv_chart_set_type(chart, LV_CHART_TYPE_BAR);
 * // ไม่มี pad_column -> solid block
 *
 * CORRECT:
 * lv_chart_set_type(chart, LV_CHART_TYPE_BAR);
 * lv_obj_set_style_pad_column(chart, 2, 0);  // 2px spacing
 *
 * ค่า pad_column ที่แนะนำ:
 * - 1px: bars แน่นมาก (สำหรับ 128+ bins)
 * - 2px: spacing ปกติ (สำหรับ 64 bins)
 * - 3-4px: spacing กว้าง (สำหรับ 32 bins หรือน้อยกว่า)
 */

5.2 Windowing Functions (สำหรับปรับปรุง FFT)

/* Window function ลด "spectral leakage" ทำให้ FFT แม่นยำขึ้น
 *
 * Rectangular (ไม่มี window): leakage สูง แต่ resolution ดี
 * Hanning: ลด leakage ดี compromise ที่นิยมใช้
 * Hamming: คล้าย Hanning แต่ sidelobe ต่ำกว่า
 *
 * Hanning window:
 * w[n] = 0.5 * (1 - cos(2*PI*n/(N-1)))
 */
static void apply_hanning(int16_t *buf, uint16_t N)
{
    for (uint16_t i = 0; i < N; i++) {
        double w = 0.5 * (1.0 - cos(2.0 * M_PI * i / (N - 1)));
        buf[i] = (int16_t)(buf[i] * w);
    }
}

5.3 Spectrum Characteristics ของ Waveform แต่ละชนิด

/* Spectrum ของ waveform แต่ละชนิดมีลักษณะเฉพาะ:
 *
 * Sine Wave:
 * - 1 peak ที่ fundamental frequency
 * - No harmonics (pure tone)
 *
 * Square Wave:
 * - Peaks ที่ odd harmonics (1st, 3rd, 5th, 7th, ...)
 * - Amplitude ลดลงเป็น 1/n
 * - Rich harmonic content
 *
 * Triangle Wave:
 * - Peaks ที่ odd harmonics เหมือน square
 * - แต่ amplitude ลดลงเป็น 1/n^2 (เร็วกว่า)
 * - Harmonics น้อยกว่า square wave
 *
 * Sawtooth Wave:
 * - Peaks ที่ ทุก harmonic (odd + even)
 * - Amplitude ลดลงเป็น 1/n
 * - Richest harmonic content
 *
 * ใช้ Spectrum Analyzer ยืนยัน Fourier Series ได้!
 */

5.4 DFT vs FFT Performance

/* DFT (Discrete Fourier Transform):
 * - O(N^2) complexity
 * - N=256: 65,536 operations
 * - ง่ายในการ implement
 * - เหมาะสำหรับการเรียนรู้
 *
 * FFT (Fast Fourier Transform):
 * - O(N*log2(N)) complexity
 * - N=256: 256 * 8 = 2,048 operations (32x เร็วกว่า!)
 * - ต้องใช้ library (CMSIS-DSP, kiss_fft)
 * - N ต้องเป็น power of 2
 *
 * สำหรับ PSoC Edge:
 * - CM55 มี DSP instructions สำหรับ FFT
 * - ใช้ CMSIS-DSP arm_rfft_q15() หรือ arm_rfft_f32()
 * - Real-time FFT ได้ง่ายสำหรับ N <= 1024
 */

---

6. แบบฝึกหัด

Exercise 1: Spectrum Display with Peak Marker

โจทย์: เพิ่ม Peak marker และ frequency label บน FFT chart:

• วาดเส้นแนวตั้ง (หรือ marker) ที่ตำแหน่ง peak frequency

• แสดง frequency label ที่จุด peak

• เพิ่ม "2nd Peak" detection (ความถี่ที่มีพลังงานสูงเป็นอันดับ 2)

• แสดง power ratio ระหว่าง 1st peak กับ 2nd peak

Exercise 2: Dual View Synchronized

โจทย์: สร้าง Time + Frequency dual view ที่ synchronized:

• Time domain chart (บน) แสดง waveform

• Frequency domain chart (ล่าง) แสดง spectrum

• เพิ่ม Slider ปรับ frequency (100-2000 Hz)

• เมื่อปรับ frequency ทั้ง 2 charts อัพเดทพร้อมกัน

• แสดง bin number และ frequency ของ peak

• ประยุกต์ใช้: Power Quality Analysis - สังเกต harmonics เมื่อเปลี่ยนจาก sine เป็น square

---

7. References

• FFT Explained

• ARM CMSIS-DSP FFT

• Window Functions

---