Event Bus

Lab 2: Event Bus Integration (EventBus + Advanced IPC)

Part 4 - IPC & Event Bus

---

1. โครงสร้างภาพรวม (Overview)

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

Event-Driven Architecture คือรูปแบบสถาปัตยกรรมที่ใช้ในระบบ Industrial, SCADA, IoT ทุกระดับ:

• Loose Coupling: ลด dependency ระหว่างโมดูล ทำให้ขยายระบบได้ง่าย

• Publish-Subscribe: หลายโมดูลสามารถ subscribe event เดียวกัน ไม่ต้องรู้จักกัน

• Scalability: เพิ่ม subscriber ได้โดยไม่ต้องแก้ publisher

ในระบบ Embedded จริง ไม่มี feature ใดทำงานอิสระ ทุกอย่างต้อง บูรณาการ เข้าด้วยกัน:

• Smart Factory HMI: หน้าจอเดียวต้องแสดง sensor data + ควบคุม actuator + แสดง event log + monitor สถานะระบบ

• Medical Device: Patient monitor ต้องรวม ECG + SpO2 + Blood Pressure + Alarm ทั้งหมด

• Automotive Dashboard: Instrument cluster ต้องรวม speed + RPM + fuel + warning lights

• Building Management System: HVAC control + lighting + security + energy monitoring ในระบบเดียว

Lab นี้เป็นแบบ progressive learning -- เริ่มจาก Part A ที่สร้าง Event Bus ด้วย simulated/IPC data แล้วก้าวสู่ Part B ที่บูรณาการ Event Bus + IPC + Logging + GPIO real hardware เข้าด้วยกัน

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

Part A (Ex4 - Event Bus):

1. Event Bus Pattern: Publish-Subscribe สำหรับ Embedded Systems

2. Event Types: EVENT_IMU, EVENT_ADC, EVENT_BUTTON

3. Multiple Subscribers: หลาย handler ต่อ 1 event

4. State Machine: ออกแบบ state machine ที่ขับเคลื่อนด้วย event

Part B (Ex8 - Advanced Integration):

1. System Integration: รวม 4 subsystems (IPC, EventBus, Logging, Hardware)

2. Layout Helpers: ใช้ aic_col_create(), aic_row_create(), aic_full_size(), aic_pad() สร้าง UI อย่างรวดเร็ว

3. Event Bus Pub/Sub: Decouple sensor reads จาก UI updates ผ่าน publish/subscribe

4. IPC Statistics Monitoring: ติดตาม TX/RX/Error counts แบบ real-time

5. Multi-Sensor Dashboard: แสดง IMU + ADC + Button + LED ในหน้าเดียว

6. Combined Init Pattern: ลำดับการ initialize subsystems ที่ถูกต้อง

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

Part A: สร้าง Event Bus infrastructure (subscribe, publish, dispatch) + UI แสดง event log + statistics โดยรับข้อมูลจาก IPC callback ผ่าน flag-based pattern

Part B: สร้าง Dashboard บน CM55 ด้วย layout helpers ที่ประกอบด้วย LED row, Button state, IMU display, ADC display, Stats row -- โดยรวม IPC + EventBus + Logging + GPIO เข้าด้วยกัน

---

2. หลักการทางเทคนิค (Technical Principles)

2.1 Event-Driven Architecture

+-----------------------------------------------------------------------+
|               Event-Driven Architecture Overview                      |
+-----------------------------------------------------------------------+
|                                                                       |
|  Traditional (Polling):                                               |
|  +----------------------------------------------+                     |
|  |  while(1) {                                  |                     |
|  |      if (button_pressed()) handle_btn();     | <- Wastes CPU       |
|  |      if (sensor_ready())  read_sensor();     |    checking things  |
|  |      if (timer_expired()) update_ui();       |    that haven't     |
|  |  }                                           |    happened yet     |
|  +----------------------------------------------+                     |
|                                                                       |
|  Event-Driven:                                                        |
|  +----------------------------------------------+                     |
|  |                 EVENT BUS                    |                     |
|  |                                              |                     |
|  |  Publishers              Subscribers         |                     |
|  |  ----------              -----------         |                     |
|  |  IPC Callback --+   +-- UI Handler           |                     |
|  |  Button ISR  ---+   +-- Log Handler          |                     |
|  |  Timer       ---+   +-- LED Handler          |                     |
|  |  Sensor      ---+   +-- State Machine        |                     |
|  |                                              |                     |
|  |  Publisher ไม่ต้องรู้ว่า Subscriber คือใคร         |                     |
|  |  Subscriber ไม่ต้องรู้ว่า Publisher คือใคร         |                     |
|  +----------------------------------------------+                     |
|                                                                       |
+-----------------------------------------------------------------------+

2.2 Publish-Subscribe Flow

 Publisher                    Event Bus                 Subscribers
 ---------                   ---------                 -----------
    |                            |                         |
    | publish(EVENT_IMU, data)   |                         |
    | -------------------------> |                         |
    |                            | dispatch to all         |
    |                            | subscribers of          |
    |                            | EVENT_IMU               |
    |                            | ----------------------> | handler_1(data)
    |                            | ----------------------> | handler_2(data)
    |                            | ----------------------> | handler_3(data)
    |                            |                         |
    |                            |                         |
    | publish(EVENT_BUTTON, data)|                         |
    | -------------------------> |                         |
    |                            | ----------------------> | btn_handler(data)
    |                            |                         |

2.3 Event Bus Architecture (Part A)

+-----------------------------------------------------------------------+
|                     Event Bus Architecture                            |
+-----------------------------------------------------------------------+
|                                                                       |
|  +-------------+                    +------------------------------+  |
|  | IPC Callback |   flag-based      |        EVENT BUS             |  |
|  | (IPC Task)   | ---------------->  |                             |  |
|  | imu_ready=1  |   imu_data        |  subscribers[EVENT_IMU][]    |  |
|  | btn_ready=1  |   btn_data        |  +-- [0] ui_chart_handler    |  |
|  +-------------+                    |  +-- [1] log_handler         |  |
|                                      |  +-- [2] threshold_handler  |  |
|  +-------------+   publish()         |  +-- [3] (empty)            |  |
|  | LVGL Timer   | ---------------->  |                             |  |
|  | (50ms poll)  |                    |  subscribers[EVENT_BUTTON][]|  |
|  | check flags  |                    |  +-- [0] led_toggle_handler |  |
|  | -> publish() |                    |  +-- [1] state_handler      |  |
|  +-------------+                    |  +-- [2] log_handler         |  |
|                                      |                             |  |
|  +-------------+   publish()         |  subscribers[EVENT_ADC][]   |  |
|  | Timer        | ---------------->  |  +-- [0] gauge_handler      |  |
|  | (1s tick)    |                    |  +-- [1] threshold_handler  |  |
|  | EVENT_TIMER  |                    |                             |  |
|  +-------------+                    +------------------------------+  |
|                                                                       |
|  KEY: ทุกอย่างทำงานใน LVGL context (thread-safe)                        |
|       IPC callback ใช้ flag-based pattern ก่อน publish                  |
|                                                                       |
+-----------------------------------------------------------------------+

2.4 Integration Architecture (Part B)

+===================================================================+
|           ADVANCED FEATURES - INTEGRATION ARCHITECTURE            |
+===================================================================+
|                                                                   |
|  CM55 Core (LVGL + Application Logic)                             |
|  =============================================                    |
|                                                                   |
|  +----------------+  +----------------+  +------------------+     |
|  |   IPC Layer    |  |  Event Bus     |  |  Logging System  |     |
|  |                |  |                |  |                  |     |
|  | cm55_ipc_*()   |  | aic_event_*()  |  | aic_log_init()   |     |
|  | set_led()      |  | subscribe()    |  | CM55_LOGI()      |     |
|  | get_stats()    |  | publish_imu()  |  | CM55_LOGW()      |     |
|  | is_init()      |  | publish_adc()  |  | CM55_LOGE()      |     |
|  +-------+--------+  +-------+--------+  +--------+---------+     |
|          |                    |                     |             |
|          v                    v                     v             |
|  +------------------------------------------------------------+   |
|  |               LVGL UI Dashboard                            |   |
|  |                                                            |   |
|  | [Title] Part 4 Ex8: Advanced                               |   |
|  | [Subtitle] IPC + EventBus + Logging + HW                   |   |
|  |                                                            |   |
|  | [LED Row]  [*R][L1]  [*G][L2]  [*B][L3]     <- IPC send    |   |
|  |                                                            |   |
|  | [Button]   BTN1: Released/Pressed            <- GPIO read  |   |
|  |                                                            |   |
|  | [IMU]      Accel (EventBus)                  <- EventBus   |   |
|  |            X: +0.05  Y: -0.12  Z: +9.81                    |   |
|  |                                                            |   |
|  | [ADC]      ADC: 2048 (1.65V)                 <- EventBus   |   |
|  |                                                            |   |
|  | [Stats]    Events: 42  IPC TX:10 RX:8 Err:0  <- Monitor    |   |
|  +------------------------------------------------------------+   |
|                                                                   |
|  ========================== IPC PIPE ==========================   |
|                                                                   |
|  CM33-NS Core (Hardware + Sensors)                                |
|  =============================================                    |
|  +----------+ +----------+ +----------+ +----------+              |
|  | LED GPIO | |  Button  | |   IMU    | |   ADC    |              |
|  | Handler  | |  Poller  | |  Reader  | |  Reader  |              |
|  +----------+ +----------+ +----------+ +----------+              |
|                                                                   |
+===================================================================+

2.5 Initialization Sequence (Part B -- Critical!)

+===================================================================+
|              INITIALIZATION SEQUENCE (CRITICAL ORDER)             |
+===================================================================+
|                                                                   |
|  +-------------------+                                            |
|  |   Start Ex8       |                                            |
|  +--------+----------+                                            |
|           |                                                       |
|           v                                                       |
|  +-------------------+   aic_gpio_init() ต้องมาก่อน                 |
|  | 1. GPIO Init      |   --> return bool (ready/not ready)        |
|  |  aic_gpio_init()  |   --> ถ้า false: ข้าม HW functions           | 
|  +--------+----------+                                            |
|           |                                                       |
|           v                                                       |
|  +-------------------+   aic_sensors_init() ต้องมาก่อน              |
|  | 2. Sensors Init   |   aic_adc_read() เสมอ!                     |
|  | aic_sensors_init()|                                            |
|  +--------+----------+                                            |
|           |                                                       |
|           v                                                       |
|  +-------------------+   Event Bus ต้อง init ก่อน subscribe         |
|  | 3. Event Bus Init |                                            |
|  |  aic_event_init() |                                            |
|  +--------+----------+                                            |
|           |                                                       |
|           v                                                       |
|  +-------------------+   Logging ใช้ได้ทันทีหลัง init                  |
|  | 4. Logging Init   |                                            |
|  |  aic_log_init()   |                                            |
|  +--------+----------+                                            |
|           |                                                       |
|           v                                                       |
|  +-------------------+   สร้าง UI objects                          |
|  | 5. Build UI       |   (ต้องสร้างก่อน subscribe)                   |
|  |  Layout helpers   |                                            |
|  +--------+----------+                                            |
|           |                                                       |
|           v                                                       |
|  +-------------------+   ตอนนี้ UI objects พร้อมแล้ว                  |
|  | 6. Subscribe      |   จึง subscribe event ได้                    |
|  |  aic_event_sub()  |                                            |
|  +--------+----------+                                            |
|           |                                                       |
|           v                                                       |
|  +-------------------+   Timer เริ่มทำงาน                           |
|  | 7. Create Timer   |   --> ระบบเริ่มทำงานจริง                      |
|  | lv_timer_create() |                                            |
|  +-------------------+                                            |
|                                                                   |
+===================================================================+

---

3. Part A: Event Bus (Ex4 - Simulated + IPC Data)

Part A สอนการสร้าง Event Bus infrastructure ตั้งแต่ต้น -- ออกแบบ event types, subscriber system, publish/dispatch mechanism แล้วทดสอบด้วย IPC data + timer events

3.1 Event Types

/*******************************************************************************
 * Event Type Definitions
 ******************************************************************************/
typedef enum {
    EVENT_NONE = 0,

    /* Sensor Events */
    EVENT_IMU,              /* IMU data received */
    EVENT_ADC,              /* ADC data received */
    EVENT_TEMP,             /* Temperature data */

    /* Input Events */
    EVENT_BUTTON,           /* Button press/release */
    EVENT_TOUCH,            /* Touch screen event */

    /* System Events */
    EVENT_IPC_CONNECTED,    /* IPC pipe established */
    EVENT_IPC_ERROR,        /* IPC communication error */
    EVENT_TIMER,            /* Periodic timer tick */

    /* Application Events */
    EVENT_THRESHOLD,        /* Sensor value exceeded threshold */
    EVENT_STATE_CHANGE,     /* State machine transition */

    EVENT_TYPE_COUNT        /* จำนวน event types ทั้งหมด */
} event_type_t;

3.2 Event Data Structure

/*******************************************************************************
 * Event Data
 ******************************************************************************/
typedef struct {
    event_type_t type;          /* ประเภท event */
    uint32_t     timestamp;     /* เวลาที่เกิด event (ms) */
    int32_t      value;         /* ค่าตัวเลข */
    void         *data;         /* ข้อมูลเพิ่มเติม (optional) */
} event_t;

/* Event Names (สำหรับ display) */
static const char *event_names[] = {
    "NONE", "IMU", "ADC", "TEMP",
    "BUTTON", "TOUCH",
    "IPC_OK", "IPC_ERR", "TIMER",
    "THRESH", "STATE"
};

3.3 Event Bus Core

/*******************************************************************************
 * Event Bus Infrastructure
 ******************************************************************************/
#define MAX_SUBSCRIBERS_PER_EVENT  4
#define EVENT_QUEUE_SIZE          16

/* Subscriber callback type */
typedef void (*event_handler_t)(const event_t *event, void *user_data);

/* Subscriber entry */
typedef struct {
    event_handler_t handler;
    void           *user_data;
    bool            active;
} subscriber_t;

/* Event Bus */
static subscriber_t subscribers[EVENT_TYPE_COUNT][MAX_SUBSCRIBERS_PER_EVENT];
static uint32_t event_counts[EVENT_TYPE_COUNT];     /* จำนวน events ต่อ type */
static uint32_t total_events = 0;

/*******************************************************************************
 * Subscribe to an event type
 * return: subscriber index (0-3) or -1 on failure
 ******************************************************************************/
static int event_subscribe(event_type_t type, event_handler_t handler,
                           void *user_data)
{
    if (type >= EVENT_TYPE_COUNT || handler == NULL) return -1;

    for (int i = 0; i < MAX_SUBSCRIBERS_PER_EVENT; i++) {
        if (!subscribers[type][i].active) {
            subscribers[type][i].handler   = handler;
            subscribers[type][i].user_data = user_data;
            subscribers[type][i].active    = true;
            return i;
        }
    }
    return -1;  /* Full */
}

/*******************************************************************************
 * Unsubscribe from an event type
 ******************************************************************************/
static void event_unsubscribe(event_type_t type, int index)
{
    if (type < EVENT_TYPE_COUNT && index >= 0
        && index < MAX_SUBSCRIBERS_PER_EVENT) {
        subscribers[type][index].active = false;
    }
}

/*******************************************************************************
 * Publish an event (dispatch to all subscribers)
 *
 * NOTE: เรียกจาก LVGL context เท่านั้น!
 * ถ้าต้อง publish จาก IPC callback ให้ใช้ flag-based pattern
 ******************************************************************************/
static void event_publish(event_type_t type, int32_t value, void *data)
{
    if (type >= EVENT_TYPE_COUNT) return;

    event_t event = {
        .type      = type,
        .timestamp = lv_tick_get(),
        .value     = value,
        .data      = data
    };

    event_counts[type]++;
    total_events++;

    /* Dispatch to all active subscribers */
    for (int i = 0; i < MAX_SUBSCRIBERS_PER_EVENT; i++) {
        if (subscribers[type][i].active) {
            subscribers[type][i].handler(&event,
                subscribers[type][i].user_data);
        }
    }
}

/*******************************************************************************
 * Initialize Event Bus
 ******************************************************************************/
static void event_bus_init(void)
{
    memset(subscribers, 0, sizeof(subscribers));
    memset(event_counts, 0, sizeof(event_counts));
    total_events = 0;
}

3.4 Step-by-Step Implementation

Step 1: ประกาศ Variables

/* part4_ex4_event_bus.c */
#include "lvgl.h"
#include "ipc/cm55_ipc_pipe.h"

#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>

/*******************************************************************************
 * LVGL Objects
 ******************************************************************************/
static lv_obj_t *label_title      = NULL;
static lv_obj_t *label_state      = NULL;
static lv_obj_t *label_event_log  = NULL;
static lv_obj_t *label_stats      = NULL;
static lv_obj_t *led_status       = NULL;
static lv_obj_t *chart_events     = NULL;

/* Chart series (event frequency per type) */
static lv_chart_series_t *ser_freq = NULL;

/*******************************************************************************
 * Flag-Based Pattern (IPC -> Event Bus bridge)
 ******************************************************************************/
static volatile bool     imu_event_pending    = false;
static volatile bool     button_event_pending = false;
static volatile bool     adc_event_pending    = false;
static volatile int32_t  pending_imu_value    = 0;
static volatile int32_t  pending_btn_value    = 0;
static volatile int32_t  pending_adc_value    = 0;

/*******************************************************************************
 * Event Log (ring buffer)
 ******************************************************************************/
#define EVENT_LOG_SIZE  10
#define EVENT_LOG_BUF   1024

static char event_log_entries[EVENT_LOG_SIZE][64];
static uint32_t event_log_idx = 0;
static char event_log_display[EVENT_LOG_BUF];

Step 2: IPC Callback (Bridge to Event Bus)

/*******************************************************************************
 * IPC Receive Callback
 *
 * CRITICAL: ทำงานใน IPC Task - ห้ามเรียก event_publish() โดยตรง!
 * ตั้ง flag เพื่อให้ LVGL timer publish event แทน
 ******************************************************************************/
static void ipc_event_callback(const ipc_msg_t *msg, void *user_data)
{
    (void)user_data;

    switch (msg->cmd) {
        case IPC_CMD_IMU_DATA: {
            const ipc_imu_data_t *imu = (const ipc_imu_data_t *)msg->data;
            /* ส่งค่า magnitude ของ accel */
            pending_imu_value = (int32_t)imu->accel_x;
            imu_event_pending = true;
            break;
        }

        case IPC_CMD_BUTTON_EVENT: {
            pending_btn_value = (int32_t)msg->value;  /* 1=pressed, 0=released */
            button_event_pending = true;
            break;
        }

        case IPC_CMD_ADC_DATA: {
            const ipc_adc_data_t *adc = (const ipc_adc_data_t *)msg->data;
            pending_adc_value = (int32_t)adc->adc_ch0;
            adc_event_pending = true;
            break;
        }

        default:
            break;
    }
}

Step 3: Event Handlers (Subscribers)

/*******************************************************************************
 * Event Log Handler - จดบันทึกทุก event
 ******************************************************************************/
static void event_log_handler(const event_t *event, void *user_data)
{
    (void)user_data;

    uint32_t ts = event->timestamp / 1000;
    snprintf(event_log_entries[event_log_idx % EVENT_LOG_SIZE],
        64, "%02u:%02u:%02u [%s] val=%d",
        (unsigned int)((ts / 3600) % 24),
        (unsigned int)((ts / 60) % 60),
        (unsigned int)(ts % 60),
        event_names[event->type],
        (int)event->value);
    event_log_idx++;

    /* สร้าง display string */
    event_log_display[0] = '\0';
    int pos = 0;
    uint32_t total = (event_log_idx < EVENT_LOG_SIZE)
        ? event_log_idx : EVENT_LOG_SIZE;
    uint32_t start = (event_log_idx < EVENT_LOG_SIZE)
        ? 0 : (event_log_idx % EVENT_LOG_SIZE);

    for (uint32_t i = 0; i < total; i++) {
        uint32_t idx = (start + i) % EVENT_LOG_SIZE;
        int w = snprintf(event_log_display + pos,
            EVENT_LOG_BUF - pos, "%s\n", event_log_entries[idx]);
        if (w > 0) pos += w;
    }

    lv_label_set_text(label_event_log, event_log_display);
}

/*******************************************************************************
 * UI Stats Handler - อัปเดตสถิติ
 ******************************************************************************/
static void event_stats_handler(const event_t *event, void *user_data)
{
    (void)event;
    (void)user_data;

    lv_label_set_text_fmt(label_stats,
        "Total:%u  IMU:%u  ADC:%u  BTN:%u  TMR:%u",
        (unsigned int)total_events,
        (unsigned int)event_counts[EVENT_IMU],
        (unsigned int)event_counts[EVENT_ADC],
        (unsigned int)event_counts[EVENT_BUTTON],
        (unsigned int)event_counts[EVENT_TIMER]);
}

/*******************************************************************************
 * LED Handler - กระพริบ LED เมื่อมี event
 ******************************************************************************/
static void event_led_handler(const event_t *event, void *user_data)
{
    (void)user_data;

    switch (event->type) {
        case EVENT_IMU:
            lv_led_set_color(led_status,
                lv_palette_main(LV_PALETTE_BLUE));
            break;
        case EVENT_BUTTON:
            lv_led_set_color(led_status,
                lv_palette_main(LV_PALETTE_GREEN));
            break;
        case EVENT_ADC:
            lv_led_set_color(led_status,
                lv_palette_main(LV_PALETTE_YELLOW));
            break;
        case EVENT_THRESHOLD:
            lv_led_set_color(led_status,
                lv_palette_main(LV_PALETTE_RED));
            break;
        default:
            lv_led_set_color(led_status,
                lv_palette_main(LV_PALETTE_GREY));
            break;
    }
    lv_led_on(led_status);
}

/*******************************************************************************
 * Threshold Handler - ตรวจจับค่าเกิน threshold
 ******************************************************************************/
#define IMU_THRESHOLD  5000   /* ค่า accelerometer ที่ถือว่าสูง */

static void event_threshold_handler(const event_t *event, void *user_data)
{
    (void)user_data;

    if (event->type == EVENT_IMU) {
        int32_t abs_val = (event->value >= 0) ? event->value : -(event->value);
        if (abs_val > IMU_THRESHOLD) {
            /* Publish threshold event */
            event_publish(EVENT_THRESHOLD, event->value, NULL);
            CM55_LOGW("Threshold exceeded! IMU=%d", (int)event->value);
        }
    }
}

Step 4: Bridge Timer (Flag -> Event Bus)

/*******************************************************************************
 * Bridge Timer - แปลง IPC flags เป็น Event Bus events
 * ทำงานใน LVGL context จึง publish ได้อย่างปลอดภัย
 ******************************************************************************/
static void bridge_timer_cb(lv_timer_t *timer)
{
    (void)timer;

    /* ===== IMU Event ===== */
    if (imu_event_pending) {
        imu_event_pending = false;
        event_publish(EVENT_IMU, pending_imu_value, NULL);
    }

    /* ===== Button Event ===== */
    if (button_event_pending) {
        button_event_pending = false;
        event_publish(EVENT_BUTTON, pending_btn_value, NULL);
    }

    /* ===== ADC Event ===== */
    if (adc_event_pending) {
        adc_event_pending = false;
        event_publish(EVENT_ADC, pending_adc_value, NULL);
    }
}

/*******************************************************************************
 * Periodic Timer - publish EVENT_TIMER ทุก 5 วินาที
 ******************************************************************************/
static void periodic_timer_cb(lv_timer_t *timer)
{
    (void)timer;
    uint32_t uptime = lv_tick_get() / 1000;
    event_publish(EVENT_TIMER, (int32_t)uptime, NULL);
}

/*******************************************************************************
 * Sensor Request Timer - ร้องขอ sensor data จาก CM33
 ******************************************************************************/
static void sensor_poll_timer_cb(lv_timer_t *timer)
{
    (void)timer;
    if (!cm55_ipc_is_init()) return;
    cm55_ipc_request_sensor(IPC_CMD_IMU_DATA);
}

Step 5: สร้าง UI Layout + Main Entry

/*******************************************************************************
 * Main Entry Point
 ******************************************************************************/
void part4_ex4_event_bus(void)
{
    /* ===== Initialize Event Bus ===== */
    event_bus_init();

    /* ===== ล้างหน้าจอ ===== */
    lv_obj_t *scr = lv_screen_active();
    lv_obj_clean(scr);
    lv_obj_set_style_bg_color(scr, lv_color_hex(0x0d1117), 0);

    /* ===== Title ===== */
    label_title = lv_label_create(scr);
    lv_label_set_text(label_title, "Event Bus System");
    lv_obj_set_style_text_font(label_title, &lv_font_montserrat_20, 0);
    lv_obj_set_style_text_color(label_title, lv_color_hex(0xd2a8ff), 0);
    lv_obj_align(label_title, LV_ALIGN_TOP_MID, 0, 5);

    /* ===== State Label ===== */
    label_state = lv_label_create(scr);
    lv_label_set_text(label_state, "State: IDLE");
    lv_obj_set_style_text_font(label_state, &lv_font_montserrat_16, 0);
    lv_obj_set_style_text_color(label_state, lv_color_hex(0x7ee787), 0);
    lv_obj_align(label_state, LV_ALIGN_TOP_LEFT, 10, 30);

    /* ===== LED Indicator ===== */
    led_status = lv_led_create(scr);
    lv_obj_set_size(led_status, 24, 24);
    lv_obj_align(led_status, LV_ALIGN_TOP_RIGHT, -10, 30);
    lv_led_set_color(led_status, lv_palette_main(LV_PALETTE_GREY));
    lv_led_off(led_status);

    /* ===== Stats Label ===== */
    label_stats = lv_label_create(scr);
    lv_label_set_text(label_stats, "Total:0  IMU:0  ADC:0  BTN:0  TMR:0");
    lv_obj_set_style_text_font(label_stats, &lv_font_montserrat_12, 0);
    lv_obj_set_style_text_color(label_stats, lv_color_hex(0x8b949e), 0);
    lv_obj_align(label_stats, LV_ALIGN_TOP_MID, 0, 55);

    /* ===== Event Log (Scrollable Container) ===== */
    lv_obj_t *log_panel = lv_obj_create(scr);
    lv_obj_set_size(log_panel, 300, 130);
    lv_obj_align(log_panel, LV_ALIGN_BOTTOM_MID, 0, -25);
    lv_obj_set_style_bg_color(log_panel, lv_color_hex(0x010409), 0);
    lv_obj_set_style_border_color(log_panel, lv_color_hex(0x30363d), 0);
    lv_obj_set_style_pad_all(log_panel, 5, 0);

    label_event_log = lv_label_create(log_panel);
    lv_label_set_text(label_event_log, "(waiting for events...)");
    lv_obj_set_width(label_event_log, 280);
    lv_label_set_long_mode(label_event_log, LV_LABEL_LONG_WRAP);
    lv_obj_set_style_text_font(label_event_log, &lv_font_montserrat_12, 0);
    lv_obj_set_style_text_color(label_event_log, lv_color_hex(0xc9d1d9), 0);

    /* ===== Subscribe Events ===== */
    /* Log handler - รับทุก event type */
    event_subscribe(EVENT_IMU,       event_log_handler, NULL);
    event_subscribe(EVENT_ADC,       event_log_handler, NULL);
    event_subscribe(EVENT_BUTTON,    event_log_handler, NULL);
    event_subscribe(EVENT_TIMER,     event_log_handler, NULL);
    event_subscribe(EVENT_THRESHOLD, event_log_handler, NULL);

    /* Stats handler */
    event_subscribe(EVENT_IMU,       event_stats_handler, NULL);
    event_subscribe(EVENT_ADC,       event_stats_handler, NULL);
    event_subscribe(EVENT_BUTTON,    event_stats_handler, NULL);
    event_subscribe(EVENT_TIMER,     event_stats_handler, NULL);

    /* LED handler */
    event_subscribe(EVENT_IMU,       event_led_handler, NULL);
    event_subscribe(EVENT_BUTTON,    event_led_handler, NULL);
    event_subscribe(EVENT_THRESHOLD, event_led_handler, NULL);

    /* Threshold handler */
    event_subscribe(EVENT_IMU, event_threshold_handler, NULL);

    /* ===== Register IPC Callback ===== */
    cm55_ipc_register_callback(ipc_event_callback, NULL);

    /* ===== Create Timers ===== */
    lv_timer_create(bridge_timer_cb, 50, NULL);         /* Flag -> Event */
    lv_timer_create(periodic_timer_cb, 5000, NULL);     /* Timer event */
    lv_timer_create(sensor_poll_timer_cb, 200, NULL);   /* Sensor poll */

    CM55_LOGI("Part4 Ex4: Event Bus initialized");
}

3.5 Subscriber Registration Map

+------------------------------------------------------------------------+
|                    Subscriber Registration Map                         |
+------------------------------------------------------------------------+
|                                                                        |
|  Event Type       Subscriber [0]     [1]           [2]          [3]    |
|  ----------       --------------     ----          ----         ----   |
|  EVENT_IMU        log_handler        stats_handler led_handler  thresh |
|  EVENT_ADC        log_handler        stats_handler (empty)      (empty)|
|  EVENT_BUTTON     log_handler        stats_handler led_handler  (empty)|
|  EVENT_TIMER      log_handler        stats_handler (empty)      (empty)|
|  EVENT_THRESHOLD  log_handler        led_handler   (empty)      (empty)|
|                                                                        |
|  Flow example (EVENT_IMU published):                                   |
|  1. event_publish(EVENT_IMU, value, NULL)                              |
|  2. -> event_counts[EVENT_IMU]++                                       |
|  3. -> log_handler(event)       <- บันทึก log                            |
|  4. -> stats_handler(event)     <- อัปเดตสถิติ                            |
|  5. -> led_handler(event)       <- เปลี่ยนสี LED                          |
|  6. -> threshold_handler(event) <- ตรวจค่าเกิน -> อาจ publish THRESHOLD  |
|                                                                        |
+------------------------------------------------------------------------+

---

4. Part B: Advanced IPC Integration (Ex8 - Real Hardware)

Part B ยกระดับจาก Part A โดยใช้ AIC Library APIs (aic_event_*, aic_gpio_*, layout helpers) แทน manual Event Bus -- รวม IPC + EventBus + Logging + GPIO real hardware เข้าด้วยกัน

4.1 Layout Helpers (AIC Layout System)

Function	Description	เทียบเท่า LVGL Manual
aic_col_create(parent)	สร้าง container แนวตั้ง (Flex Column)	lv_obj_set_flex_flow(obj, LV_FLEX_FLOW_COLUMN)
aic_row_create(parent)	สร้าง container แนวนอน (Flex Row)	lv_obj_set_flex_flow(obj, LV_FLEX_FLOW_ROW)
aic_full_size(obj)	ขยาย obj เต็ม parent	lv_obj_set_size(obj, LV_PCT(100), LV_PCT(100))
aic_pad(obj, px)	ตั้ง padding ทุกด้าน	lv_obj_set_style_pad_all(obj, px, 0)
aic_apply_dark_theme(scr)	ตั้งค่า dark theme	Multiple style calls
aic_create_footer(scr)	สร้าง footer bar	Custom footer creation
aic_xyz_display_create(...)	สร้าง XYZ display	3 labels + header

4.2 Layout Helpers vs Manual Positioning

/*******************************************************************************
 * BEFORE (Manual Positioning) - Lab ก่อนหน้า
 *
 * ข้อเสีย: ต้องคำนวณ pixel ทุกตำแหน่ง, แก้ไขยาก, ไม่ responsive
 ******************************************************************************/
lv_obj_t *panel = lv_obj_create(scr);
lv_obj_set_size(panel, 480, 272);
lv_obj_set_pos(panel, 0, 0);
lv_obj_set_style_bg_color(panel, lv_color_hex(0x0a0e27), 0);
lv_obj_clear_flag(panel, LV_OBJ_FLAG_SCROLLABLE);

lv_obj_t *title = lv_label_create(panel);
lv_obj_set_pos(title, 10, 5);
lv_obj_t *btn1 = lv_button_create(panel);
lv_obj_set_pos(btn1, 10, 40);
lv_obj_t *btn2 = lv_button_create(panel);
lv_obj_set_pos(btn2, 100, 40);   /* ต้องคำนวณ offset! */

/*******************************************************************************
 * AFTER (Layout Helpers) - Lab นี้
 *
 * ข้อดี: อัตโนมัติ, responsive, เพิ่ม/ลบ widgets ง่าย
 ******************************************************************************/
lv_obj_t *cont = aic_col_create(scr);    /* แนวตั้ง auto-layout */
aic_full_size(cont);                      /* เต็มจอ */
aic_pad(cont, 12);                        /* ขอบ 12px ทุกด้าน */

lv_obj_t *title = lv_label_create(cont);  /* อยู่บนสุด auto */
lv_obj_t *row = aic_row_create(cont);     /* แถวถัดไป auto */
lv_obj_t *btn1 = lv_button_create(row);   /* ซ้ายสุดในแถว */
lv_obj_t *btn2 = lv_button_create(row);   /* ถัดไปทางขวา auto */

4.3 Layout Structure ของ Part B

Screen (aic_apply_dark_theme)
  |
  +-- cont = aic_col_create(scr)         <- Column layout
  |     aic_full_size(cont)               <- Full screen
  |     aic_pad(cont, 12)                 <- 12px padding
  |     |
  |     +-- title label                   <- "Part 4 Ex8: Advanced"
  |     |
  |     +-- subtitle label                <- "IPC + EventBus + Logging + HW"
  |     |
  |     +-- led_row = aic_row_create()    <- Row layout for LEDs
  |     |     |
  |     |     +-- wrap[0] (80x60)         <- LED R + button L1
  |     |     +-- wrap[1] (80x60)         <- LED G + button L2
  |     |     +-- wrap[2] (80x60)         <- LED B + button L3
  |     |
  |     +-- btn_label                     <- "BTN1: Released"
  |     |
  |     +-- aic_xyz_display               <- "Accel (EventBus)"
  |     |     +-- X: +0.05                   XYZ labels
  |     |     +-- Y: -0.12
  |     |     +-- Z: +9.81
  |     |
  |     +-- adc_label                     <- "ADC: 2048 (1.65V)"
  |     |
  |     +-- stats_row = aic_row_create()  <- Row layout for stats
  |           +-- event_label             <- "Events: 42"
  |           +-- ipc_label               <- "IPC TX:10 RX:8 Err:0"
  |
  +-- aic_create_footer(scr)              <- Footer bar

4.4 Data Flow Diagram

+===================================================================+
|                     DATA FLOW DIAGRAM                             |
+===================================================================+
|                                                                   |
|  (1) LED Control Flow:                                            |
|  ~~~~~~~~~~~~~~~~~~~~~~                                           |
|  User Tap Button --> LVGL event_cb --> toggle state               |
|                 --> aic_gpio_led_set() (direct HW)                |
|                 --> cm55_ipc_set_led() (send to CM33)             |
|                 --> CM55_LOGI() (log the action)                  |
|                                                                   |
|  (2) Button Read Flow:                                            |
|  ~~~~~~~~~~~~~~~~~~~~~~                                           |
|  Timer (100ms) --> aic_gpio_button_read_raw()                     |
|                --> compare with last state (edge detect)          |
|                --> update UI label                                |
|                --> CM55_LOGI() if pressed (log the event)         |
|                                                                   |
|  (3) IMU Data Flow (Event Bus):                                   |
|  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~                                 |
|  Timer (100ms) --> imu_shared_read_accel()                        |
|                --> aic_event_publish_imu()  ----+                 |
|                --> direct UI update (backup)    |                 |
|                                                  v                |
|                                      +-------------------+        |
|                                      | Event Bus         |        |
|                                      | AIC_EVENT_IMU     |        |
|                                      +-------------------+        |
|                                                  |                |
|                                                  v                |
|                                      ex8_imu_event_cb()           |
|                                      --> update IMU labels        |
|                                      --> ex8_event_count++        |
|                                                                   |
|  (4) ADC Data Flow (Event Bus):                                   |
|  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~                                 |
|  Timer (100ms) --> aic_adc_read()                                 |
|                --> aic_event_publish_adc() -----+                 |
|                --> direct UI update (backup)    |                 |
|                                                 v                 |
|                                      +-------------------+        |
|                                      | Event Bus         |        |
|                                      | AIC_EVENT_ADC     |        |
|                                      +-------------------+        |
|                                                  |                |
|                                                  v                |
|                                      ex8_adc_event_cb()           |
|                                      --> update ADC label         |
|                                      --> ex8_event_count++        |
|                                                                   |
|  (5) IPC Stats Flow:                                              |
|  ~~~~~~~~~~~~~~~~~~~~                                             |
|  Timer (100ms) --> cm55_ipc_get_stats(&tx, &rx, &errors)          |
|                --> update stats label                             |
|                                                                   |
+===================================================================+

4.5 Event Bus Pub/Sub ใน Part B

+===================================================================+
|                EVENT BUS PUB/SUB IN PART B                        |
+===================================================================+
|                                                                   |
|  PUBLISHERS (ใน Timer Callback)                                   |
|  ==============================                                   |
|                                                                   |
|  ex8_timer_cb() (100ms)                                           |
|     |                                                             |
|     |-- imu_shared_read_accel(&ax, &ay, &az)                      |
|     |   |                                                         |
|     |   +-- aic_event_publish_imu(ax, ay, az, 0, 0, 0)            |
|     |       (publishes AIC_EVENT_IMU_UPDATE)                      |
|     |                                                             |
|     |-- aic_adc_read(AIC_ADC_CH0)                                 |
|     |   |                                                         |
|     |   +-- aic_event_publish_adc(0, raw, mv)                     |
|     |       (publishes AIC_EVENT_ADC_UPDATE)                      |
|     |                                                             |
|                                                                   |
|  SUBSCRIBERS (registered ใน part4_ex8_advanced)                   |
|  ==============================================                   |
|                                                                   |
|  AIC_EVENT_IMU_UPDATE --> ex8_imu_event_cb()                      |
|     +-- update X/Y/Z labels                                       |
|     +-- ex8_event_count++                                         |
|                                                                   |
|  AIC_EVENT_ADC_UPDATE --> ex8_adc_event_cb()                      |
|     +-- update ADC label (raw + voltage)                          |
|     +-- ex8_event_count++                                         |
|                                                                   |
+===================================================================+

4.6 Static Variables

/*******************************************************************************
 * Part 4 - Example 8: Advanced Features
 *
 * Combines IPC + Event Bus + Logging + Real Hardware.
 * Full-featured dashboard showing all Part 4 concepts.
 ******************************************************************************/

/* LVGL Widget References */
static lv_obj_t *ex8_led_widgets[3];   /* LED indicator widgets (R, G, B) */
static lv_obj_t *ex8_imu_labels[3];    /* IMU X/Y/Z value labels */
static lv_obj_t *ex8_adc_label;        /* ADC display label */
static lv_obj_t *ex8_btn_label;        /* Button state label */
static lv_obj_t *ex8_event_label;      /* Event counter label */
static lv_obj_t *ex8_ipc_label;        /* IPC stats label */
static lv_timer_t *ex8_timer;          /* Main update timer */

/* State Variables */
static bool ex8_led_states[3] = {false, false, false};  /* LED ON/OFF */
static bool ex8_gpio_ready = false;    /* GPIO init success? */
static bool ex8_btn1_last = false;     /* Last button state (for edge detect) */
static uint32_t ex8_event_count = 0;   /* Total Event Bus events received */

4.7 Event Bus Callbacks (Subscribers)

/*******************************************************************************
 * IMU Event Callback
 *
 * เรียกโดย Event Bus เมื่อมี AIC_EVENT_IMU_UPDATE
 * แปลง raw int16 (milli-g) กลับเป็น float แล้วแสดง
 ******************************************************************************/
static void ex8_imu_event_cb(aic_event_t event,
                              const aic_event_data_t *data,
                              void *user_data)
{
    (void)event;
    (void)user_data;

    if (data != NULL) {
        /* data->imu.ax/ay/az เป็น int16_t ในหน่วย milli-g */
        /* แปลงกลับเป็น g ก่อนแสดง */
        lv_label_set_text_fmt(ex8_imu_labels[0], "%+.2f",
            (double)(data->imu.ax / 1000.0f));
        lv_label_set_text_fmt(ex8_imu_labels[1], "%+.2f",
            (double)(data->imu.ay / 1000.0f));
        lv_label_set_text_fmt(ex8_imu_labels[2], "%+.2f",
            (double)(data->imu.az / 1000.0f));
    }
    ex8_event_count++;   /* นับจำนวน events ที่ได้รับ */
}

/*******************************************************************************
 * ADC Event Callback
 *
 * เรียกโดย Event Bus เมื่อมี AIC_EVENT_ADC_UPDATE
 * แสดง raw value + voltage
 ******************************************************************************/
static void ex8_adc_event_cb(aic_event_t event,
                              const aic_event_data_t *data,
                              void *user_data)
{
    (void)event;
    (void)user_data;

    if (data != NULL) {
        lv_label_set_text_fmt(ex8_adc_label, "ADC: %d (%.2fV)",
            data->adc.raw_value,
            (double)(data->adc.voltage_mv / 1000.0f));
    }
    ex8_event_count++;
}

4.8 LED Toggle Callback (IPC + GPIO + Logging)

/*******************************************************************************
 * LED Toggle Button Callback
 *
 * เมื่อ user tap ปุ่ม L1/L2/L3:
 * 1. Toggle internal state
 * 2. Update LVGL LED widget
 * 3. Control real GPIO LED (ถ้ามี)
 * 4. Send IPC command ไป CM33 (ถ้า IPC ready)
 * 5. Log the action
 *
 * user_data = LED index (0, 1, 2) ส่งมาตอน add_event_cb
 ******************************************************************************/
static void ex8_led_cb(lv_event_t *e)
{
    /* ดึง LED index จาก user_data */
    int id = (int)(intptr_t)lv_event_get_user_data(e);
    if (id < 0 || id > 2) return;

    /* (1) Toggle state */
    ex8_led_states[id] = !ex8_led_states[id];

    /* (2) Update LVGL LED widget */
    if (ex8_led_states[id]) {
        lv_led_on(ex8_led_widgets[id]);
    } else {
        lv_led_off(ex8_led_widgets[id]);
    }

    /* (3) Direct GPIO control (ถ้า init สำเร็จ) */
    if (ex8_gpio_ready) {
        aic_gpio_led_set((aic_led_t)id, ex8_led_states[id]);
    }

    /* (4) IPC + (5) Logging */
    if (cm55_ipc_is_init()) {
        cm55_ipc_set_led((uint8_t)id, ex8_led_states[id]);
        CM55_LOGI("LED%d -> %s", id,
            ex8_led_states[id] ? "ON" : "OFF");
    }
}

4.9 Timer Callback (Heart of the System)

/*******************************************************************************
 * Main Timer Callback (100ms interval)
 *
 * ทำ 4 อย่างทุก cycle:
 * 1. Poll button (edge detection)
 * 2. Read IMU + publish event
 * 3. Read ADC + publish event
 * 4. Update IPC statistics
 ******************************************************************************/
static void ex8_timer_cb(lv_timer_t *timer)
{
    (void)timer;

    /* ===== (1) Button Polling with Edge Detection ===== */
    if (ex8_gpio_ready) {
        bool pressed = aic_gpio_button_read_raw(AIC_BTN_USER);

        /* เฉพาะตอนสถานะเปลี่ยน (edge) เท่านั้น */
        if (pressed != ex8_btn1_last) {
            lv_label_set_text(ex8_btn_label,
                pressed ? "BTN1: PRESSED" : "BTN1: Released");
            lv_obj_set_style_text_color(ex8_btn_label,
                pressed ? AIC_COLOR_SUCCESS : AIC_COLOR_TEXT_DIM, 0);

            if (cm55_ipc_is_init() && pressed) {
                CM55_LOGI("BTN1 pressed");
            }
            ex8_btn1_last = pressed;  /* บันทึกสถานะล่าสุด */
        }
    }

    /* ===== (2) Read IMU + Publish via Event Bus ===== */
    float ax, ay, az;
    if (imu_shared_read_accel(&ax, &ay, &az)) {
        /* Publish ผ่าน Event Bus (subscribers จะได้รับ) */
        aic_event_publish_imu(
            (int16_t)(ax * 1000),    /* แปลง g -> milli-g */
            (int16_t)(ay * 1000),
            (int16_t)(az * 1000),
            0, 0, 0);               /* gyro (ไม่ใช้) */

        /* Direct update (backup path) */
        lv_label_set_text_fmt(ex8_imu_labels[0], "%+.2f", (double)ax);
        lv_label_set_text_fmt(ex8_imu_labels[1], "%+.2f", (double)ay);
        lv_label_set_text_fmt(ex8_imu_labels[2], "%+.2f", (double)az);
    }

    /* ===== (3) Read ADC + Publish via Event Bus ===== */
    uint16_t adc_raw = aic_adc_read(AIC_ADC_CH0);
    uint16_t mv = (uint16_t)(adc_raw * 3300 / 4095);  /* Raw -> millivolts */
    aic_event_publish_adc(0, adc_raw, mv);

    /* Direct update (backup path) */
    lv_label_set_text_fmt(ex8_adc_label, "ADC: %d (%.2fV)",
        adc_raw, (double)(mv / 1000.0f));

    /* ===== (4) Update Statistics ===== */
    lv_label_set_text_fmt(ex8_event_label, "Events: %u",
        (unsigned)ex8_event_count);

    uint32_t tx, rx, errors;
    cm55_ipc_get_stats(&tx, &rx, &errors);
    lv_label_set_text_fmt(ex8_ipc_label, "IPC TX:%u RX:%u Err:%u",
        (unsigned)tx, (unsigned)rx, (unsigned)errors);
}

4.10 Main Function (Full UI Build)

/*******************************************************************************
 * Main Entry: part4_ex8_advanced()
 *
 * Initialization order ต้องถูกต้อง!
 * GPIO -> Sensors -> EventBus -> Logging -> UI -> Subscribe -> Timer
 ******************************************************************************/
void part4_ex8_advanced(void)
{
    /* ===== Step 1-4: Initialize Subsystems ===== */
    ex8_gpio_ready = aic_gpio_init();   /* GPIO (return bool) */
    aic_sensors_init();                  /* Sensors (ต้องก่อน ADC read!) */
    aic_event_init();                    /* Event Bus */
    aic_log_init();                      /* Logging */

    /* ===== Step 5: Build UI ===== */
    lv_obj_t *scr = lv_screen_active();
    aic_apply_dark_theme(scr);

    /* Main column container */
    lv_obj_t *cont = aic_col_create(scr);
    aic_full_size(cont);
    aic_pad(cont, 12);

    /* Title + Subtitle */
    lv_obj_t *title = lv_label_create(cont);
    lv_label_set_text(title, "Part 4 Ex8: Advanced");
    lv_obj_set_style_text_color(title, AIC_COLOR_TEXT, 0);
    lv_obj_set_style_text_font(title, &lv_font_montserrat_18, 0);

    lv_obj_t *subtitle = lv_label_create(cont);
    lv_label_set_text(subtitle, "IPC + EventBus + Logging + HW");
    lv_obj_set_style_text_color(subtitle, AIC_COLOR_TEXT_DIM, 0);
    lv_obj_set_style_text_font(subtitle, &lv_font_montserrat_12, 0);

    /* === LED Row (aic_row_create) === */
    lv_obj_t *led_row = aic_row_create(cont);
    lv_color_t led_colors[] = {
        lv_color_hex(0xFF4444),   /* Red */
        lv_color_hex(0x44FF44),   /* Green */
        lv_color_hex(0x4444FF)    /* Blue */
    };
    const char *led_names[] = {"L1", "L2", "L3"};

    for (int i = 0; i < 3; i++) {
        /* Card wrapper for each LED + button pair */
        lv_obj_t *wrap = lv_obj_create(led_row);
        lv_obj_set_size(wrap, 80, 60);
        lv_obj_set_style_bg_color(wrap, AIC_COLOR_BG_CARD, 0);
        lv_obj_set_style_border_width(wrap, 0, 0);
        lv_obj_set_style_radius(wrap, 6, 0);
        lv_obj_set_flex_flow(wrap, LV_FLEX_FLOW_ROW);
        lv_obj_set_flex_align(wrap,
            LV_FLEX_ALIGN_CENTER,
            LV_FLEX_ALIGN_CENTER,
            LV_FLEX_ALIGN_CENTER);
        lv_obj_set_style_pad_all(wrap, 4, 0);
        lv_obj_remove_flag(wrap, LV_OBJ_FLAG_SCROLLABLE);

        /* LED widget */
        ex8_led_widgets[i] = lv_led_create(wrap);
        lv_led_set_color(ex8_led_widgets[i], led_colors[i]);
        lv_obj_set_size(ex8_led_widgets[i], 24, 24);
        lv_led_off(ex8_led_widgets[i]);

        /* Toggle button */
        lv_obj_t *btn = lv_button_create(wrap);
        lv_obj_set_size(btn, 40, 28);
        lv_obj_set_style_bg_color(btn, AIC_COLOR_PRIMARY, 0);
        lv_obj_add_event_cb(btn, ex8_led_cb, LV_EVENT_CLICKED,
                            (void *)(intptr_t)i);

        lv_obj_t *lbl = lv_label_create(btn);
        lv_label_set_text(lbl, led_names[i]);
        lv_obj_set_style_text_color(lbl, AIC_COLOR_TEXT, 0);
        lv_obj_center(lbl);
    }

    /* Button state label */
    ex8_btn_label = lv_label_create(cont);
    lv_label_set_text(ex8_btn_label, "BTN1: Released");
    lv_obj_set_style_text_color(ex8_btn_label, AIC_COLOR_TEXT_DIM, 0);

    /* IMU via Event Bus (aic_xyz_display helper) */
    aic_xyz_display_create(cont, "Accel (EventBus)", ex8_imu_labels);

    /* ADC via Event Bus */
    ex8_adc_label = lv_label_create(cont);
    lv_label_set_text(ex8_adc_label, "ADC: --- (-.--V)");
    lv_obj_set_style_text_color(ex8_adc_label, AIC_COLOR_TEXT, 0);

    /* Stats row */
    lv_obj_t *stats_row = aic_row_create(cont);

    ex8_event_label = lv_label_create(stats_row);
    lv_label_set_text(ex8_event_label, "Events: 0");
    lv_obj_set_style_text_color(ex8_event_label, AIC_COLOR_PRIMARY, 0);
    lv_obj_set_style_text_font(ex8_event_label, &lv_font_montserrat_12, 0);

    ex8_ipc_label = lv_label_create(stats_row);
    lv_label_set_text(ex8_ipc_label, "IPC TX:0 RX:0 Err:0");
    lv_obj_set_style_text_color(ex8_ipc_label, AIC_COLOR_TEXT_DIM, 0);
    lv_obj_set_style_text_font(ex8_ipc_label, &lv_font_montserrat_12, 0);

    aic_create_footer(scr);

    /* ===== Step 6: Subscribe to Events ===== */
    aic_event_subscribe(AIC_EVENT_IMU_UPDATE, ex8_imu_event_cb, NULL);
    aic_event_subscribe(AIC_EVENT_ADC_UPDATE, ex8_adc_event_cb, NULL);

    /* ===== Step 7: Start Timer ===== */
    ex8_timer = lv_timer_create(ex8_timer_cb, 100, NULL);

    /* Log startup */
    if (cm55_ipc_is_init()) {
        CM55_LOGI("Week6 Ex8: Advanced Features started");
    }
    printf("[Week6] Ex8: Advanced Features started\n");
}

---

5. องค์ความรู้และเทคนิค (Patterns & Tips)

5.1 Integration Checklist Pattern

+===================================================================+
|         SUBSYSTEM INTEGRATION CHECKLIST                           |
+===================================================================+
|                                                                   |
|  [ ] 1. Init Order ถูกต้อง?                                         |
|        GPIO -> Sensors -> EventBus -> Logging -> UI -> Timer      |
|                                                                   |
|  [ ] 2. ทุก subsystem init สำเร็จ?                                  |
|        ตรวจ return value (เช่น ex8_gpio_ready)                     |
|        ถ้า fail: graceful degradation (ข้าม feature นั้น)             |
|                                                                   |
|  [ ] 3. Event Bus subscribe หลัง UI สร้างเสร็จ?                      |
|        subscribe ก่อน UI = crash (NULL labels)                     |
|                                                                   |
|  [ ] 4. Timer สร้างเป็นอันสุดท้าย?                                     |
|        Timer ทำงานทันที -> ทุกอย่างต้องพร้อมก่อน                         |
|                                                                   |
|  [ ] 5. NULL checks ครบ?                                          |
|        if (ex8_gpio_ready) { ... }                                |
|        if (cm55_ipc_is_init()) { ... }                            |
|        if (data != NULL) { ... }                                  |
|                                                                   |
|  [ ] 6. Thread safety?                                            |
|        ทุก UI update อยู่ใน LVGL context (timer/callback)            |
|        ไม่ call LVGL จาก IPC task โดยตรง                           |
|                                                                   |
+===================================================================+

5.2 Graceful Degradation Pattern

/*******************************************************************************
 * Graceful Degradation: ระบบทำงานได้แม้บาง subsystem ล้มเหลว
 ******************************************************************************/

/* GPIO ไม่พร้อม? ข้าม hardware functions */
ex8_gpio_ready = aic_gpio_init();

/* ใน timer: ตรวจก่อนใช้ */
if (ex8_gpio_ready) {
    bool pressed = aic_gpio_button_read_raw(AIC_BTN_USER);
    aic_gpio_led_set(id, state);
}

/* IPC ไม่พร้อม? ข้าม IPC commands */
if (cm55_ipc_is_init()) {
    cm55_ipc_set_led(id, state);
    CM55_LOGI("LED%d -> %s", id, state ? "ON" : "OFF");
}

/* IMU ไม่พร้อม? shared read return false */
float ax, ay, az;
if (imu_shared_read_accel(&ax, &ay, &az)) {
    /* อ่านได้: publish + update */
} else {
    /* อ่านไม่ได้: ไม่ crash, แค่ไม่ update */
}

5.3 Button Edge Detection

/*******************************************************************************
 * ตรวจจับ "เปลี่ยนสถานะ" ไม่ใช่ "สถานะปัจจุบัน"
 ******************************************************************************/
static bool btn1_last = false;

void timer_cb(lv_timer_t *t) {
    bool pressed = aic_gpio_button_read_raw(AIC_BTN_USER);
    if (pressed != btn1_last) {   /* สถานะเปลี่ยน! */
        if (pressed) {
            /* Rising edge: กด */
            CM55_LOGI("BTN1 pressed"); /* Log เฉพาะตอนกด */
        }
        btn1_last = pressed;
    }
    /* สถานะเหมือนเดิม -> ไม่ทำอะไร (ไม่ log ซ้ำ) */
}

5.4 Event Count as System Health Metric

/*******************************************************************************
 * ใช้ event count เป็น system health indicator
 ******************************************************************************/

/* ค่าที่ควรเห็น (ที่ 100ms timer):
 * - 10 IMU events/sec + 10 ADC events/sec = ~20 events/sec
 * - ถ้าน้อยกว่า: sensor อ่านไม่ได้ หรือ Event Bus มีปัญหา
 * - ถ้ามากกว่า: ปกติ (subscriber อื่นอาจ publish event เพิ่ม)
 */

static uint32_t ex8_event_count = 0;

/* ใน subscriber callback: */
ex8_event_count++;

/* ใน timer: แสดง */
lv_label_set_text_fmt(ex8_event_label, "Events: %u",
    (unsigned)ex8_event_count);

5.5 Design Patterns ที่เกี่ยวข้อง

Event Bus (Lab นี้)
    |
    +-- Observer Pattern
    |   +-- One publisher -> Many subscribers
    |
    +-- Mediator Pattern
    |   +-- Event Bus เป็น mediator ระหว่าง modules
    |
    +-- State Pattern
    |   +-- State machine ขับเคลื่อนด้วย events
    |
    +-- Command Pattern
        +-- IPC commands เป็น command objects

---

6. แบบฝึกหัด (Exercises)

Exercise 1: Event Counter Dashboard (Bar Chart) -- Part A

สร้าง dashboard แสดง bar chart ของจำนวน event แต่ละ type:

• แกน X: EVENT_IMU, EVENT_ADC, EVENT_BUTTON, EVENT_TIMER, EVENT_THRESHOLD

• แกน Y: จำนวน events

• อัปเดตทุก 1 วินาที

• แสดง event rate (events/sec) สำหรับแต่ละ type

Hints:

/* สร้าง Chart type BAR */
lv_obj_t *chart_bar = lv_chart_create(scr);
lv_chart_set_type(chart_bar, LV_CHART_TYPE_BAR);
lv_chart_set_point_count(chart_bar, 5);  /* 5 event types */

lv_chart_series_t *ser_bar = lv_chart_add_series(chart_bar,
    lv_palette_main(LV_PALETTE_CYAN), LV_CHART_AXIS_PRIMARY_Y);

/* อัปเดตใน timer */
void update_bar_chart(void) {
    lv_chart_set_value_by_id(chart_bar, ser_bar, 0, event_counts[EVENT_IMU]);
    lv_chart_set_value_by_id(chart_bar, ser_bar, 1, event_counts[EVENT_ADC]);
    lv_chart_set_value_by_id(chart_bar, ser_bar, 2, event_counts[EVENT_BUTTON]);
    lv_chart_set_value_by_id(chart_bar, ser_bar, 3, event_counts[EVENT_TIMER]);
    lv_chart_set_value_by_id(chart_bar, ser_bar, 4, event_counts[EVENT_THRESHOLD]);
    lv_chart_refresh(chart_bar);
}

Exercise 2: Event-Driven State Machine -- Part A

สร้าง state machine ที่มี 3 states:

• IDLE: ปกติ (สีเขียว) -- เมื่อได้ EVENT_BUTTON --> ไป ACTIVE

• ACTIVE: กำลังทำงาน (สีเหลือง) -- เมื่อได้ EVENT_THRESHOLD --> ไป ALERT

• ALERT: แจ้งเตือน (สีแดง กระพริบ) -- เมื่อได้ EVENT_BUTTON --> กลับ IDLE

State Diagram:
                 EVENT_BUTTON
    +-------+ ----------------> +--------+
    | IDLE  |                   |ACTIVE  |
    |(green)| <---------------- |(yellow)|
    +-------+   EVENT_BUTTON   +---+-----+
        ^                          |
        |     EVENT_BUTTON         | EVENT_THRESHOLD
        |                          v
        |                    +--------+
        +------------------- | ALERT  |
                             | (red)  |
                             +--------+

Hints:

typedef enum {
    STATE_IDLE = 0,
    STATE_ACTIVE,
    STATE_ALERT
} app_state_t;

static app_state_t current_state = STATE_IDLE;
static const char *state_names[] = { "IDLE", "ACTIVE", "ALERT" };
static const uint32_t state_colors[] = { 0x7ee787, 0xd29922, 0xf85149 };

static void state_machine_handler(const event_t *event, void *user_data);

Exercise 3: Sensor Threshold Alerts -- Part B

เพิ่มระบบ alert เมื่อค่า sensor เกิน threshold:

Requirements:

• เพิ่ม label "Alert: NONE" ใต้ ADC label

• ADC > 80% (raw > 3276): "Alert: HIGH VOLTAGE" สีแดง + LED1 on

• IMU |accel| > 15 m/s^2: "Alert: VIBRATION" สีส้ม + LED2 on

• ค่ากลับปกติ: "Alert: NONE" สีเขียว + LED off

• ส่ง CM55_LOGW("ALERT: ...") เมื่อ alert เปลี่ยนสถานะ (edge detect)

Hints:

• ใช้ static bool alert_active = false; สำหรับ edge detect (log เฉพาะตอนเปลี่ยน)

• Check thresholds ใน ex8_timer_cb() หลัง sensor read

static lv_obj_t *ex8_alert_label;
static bool alert_high_voltage = false;

/* เพิ่มใน timer callback: */
bool adc_high = (adc_raw > 3276);
if (adc_high != alert_high_voltage) {
    alert_high_voltage = adc_high;
    if (adc_high) {
        lv_label_set_text(ex8_alert_label, "Alert: HIGH VOLTAGE");
        lv_obj_set_style_text_color(ex8_alert_label, AIC_COLOR_ERROR, 0);
        if (cm55_ipc_is_init()) CM55_LOGW("ALERT: HIGH VOLTAGE");
    } else {
        lv_label_set_text(ex8_alert_label, "Alert: NONE");
        lv_obj_set_style_text_color(ex8_alert_label, AIC_COLOR_SUCCESS, 0);
    }
}

Exercise 4: IPC Health Card -- Part B

เพิ่ม IPC statistics card:

Requirements:

• TX Rate / RX Rate: messages/sec (delta per second)

• Error Rate: % (errors / total * 100)

• Status LED: green (OK) / red (error > 5%)

• Uptime: seconds since start

• ถ้า error > 5%: CM55_LOGW("IPC health degraded")

Hints:

• เก็บ last_tx, last_rx สำหรับ rate calculation

• สร้าง timer แยก 1 วินาที สำหรับ rate update

static uint32_t rate_last_tx = 0, rate_last_rx = 0;

static void rate_timer_cb(lv_timer_t *timer) {
    uint32_t tx, rx, errors;
    cm55_ipc_get_stats(&tx, &rx, &errors);

    uint32_t tx_rate = tx - rate_last_tx;
    uint32_t rx_rate = rx - rate_last_rx;
    rate_last_tx = tx;
    rate_last_rx = rx;

    lv_label_set_text_fmt(tx_rate_label, "TX: %u/s", (unsigned)tx_rate);
    lv_label_set_text_fmt(rx_rate_label, "RX: %u/s", (unsigned)rx_rate);
}

/* สร้าง timer 1 วินาที */
lv_timer_create(rate_timer_cb, 1000, NULL);

---

7. Quick Reference

Event Bus API (Part A)

event_bus_init();                                /* Initialize */
event_subscribe(EVENT_IMU, handler, user_data);  /* Subscribe */
event_unsubscribe(EVENT_IMU, index);             /* Unsubscribe */
event_publish(EVENT_IMU, value, data);           /* Publish */

typedef struct {
    event_type_t type;       /* EVENT_IMU, EVENT_BUTTON, ... */
    uint32_t     timestamp;  /* lv_tick_get() at publish time */
    int32_t      value;      /* Numeric payload */
    void         *data;      /* Pointer payload (optional) */
} event_t;

void my_handler(const event_t *event, void *user_data) {
    /* ทำงานใน LVGL context - เรียก lv_xxx() ได้ */
}

/* IPC -> Event Bus Bridge Pattern */
/* 1. IPC callback: ตั้ง flag (IPC Task) */
/* 2. Bridge timer: อ่าน flag -> event_publish() (LVGL Task) */
/* 3. Event Bus: dispatch to all subscribers */

AIC Event Bus API (Part B)

Function	Description
aic_event_init()	Initialize Event Bus
aic_event_subscribe(event, cb, user_data)	Subscribe to event type
aic_event_publish_imu(ax, ay, az, gx, gy, gz)	Publish IMU data event
aic_event_publish_adc(ch, raw, mv)	Publish ADC data event

Layout Helper Functions (Part B)

Function	Description
aic_col_create(parent)	สร้าง Flex Column container
aic_row_create(parent)	สร้าง Flex Row container
aic_full_size(obj)	ขยาย 100% x 100%
aic_pad(obj, px)	ตั้ง padding ทุกด้าน
aic_apply_dark_theme(scr)	ตั้ง dark background + colors
aic_xyz_display_create(par, title, labels[3])	สร้าง XYZ display panel
aic_create_footer(scr)	สร้าง footer bar

IPC + Hardware Functions (Part B)

Function	Description
cm55_ipc_is_init()	ตรวจว่า IPC พร้อมหรือยัง
cm55_ipc_set_led(id, state)	ส่งคำสั่ง LED ไป CM33
cm55_ipc_get_stats(&tx, &rx, &err)	ดึง IPC statistics
CM55_LOGI(fmt, ...)	Send INFO log to CM33 via IPC
aic_gpio_init()	Init GPIO, return bool (success)
aic_gpio_led_set(led, state)	Set LED ON/OFF
aic_gpio_button_read_raw(btn)	Read button state (true=pressed)
aic_sensors_init()	Init sensor subsystem
imu_shared_read_accel(&ax, &ay, &az)	Read accelerometer (float, g units)
aic_adc_read(channel)	Read ADC (uint16_t, 0-4095)

Architecture Principles

+===================================================================+
|           ARCHITECTURE PRINCIPLES                                 |
+===================================================================+
|                                                                   |
|  1. PROPER INIT ORDER                                             |
|     GPIO -> Sensors -> EventBus -> Logging -> UI -> Timer         |
|                                                                   |
|  2. GRACEFUL DEGRADATION                                          |
|     ถ้า subsystem fail -> ข้าม feature นั้น, ไม่ crash                 |
|                                                                   |
|  3. EVENT-DRIVEN DECOUPLING                                       |
|     Publisher ไม่รู้จัก subscriber (และกลับกัน)                         |
|     Timer -> publish -> Event Bus -> subscribers -> UI            |
|                                                                   |
|  4. LAYOUT HELPERS FOR PRODUCTIVITY                               |
|     Flex layout แทน manual pixel positioning                      |
|     aic_col + aic_row = responsive + maintainable                 |
|                                                                   |
+===================================================================+

Application ในงาน Industrial

Use Case	คำอธิบาย
SCADA System	Event-driven monitoring ของโรงงานทั้งหมด
PLC Programming	State machine สำหรับควบคุมกระบวนการผลิต
Alarm Management	จัดการ alarm ตามมาตรฐาน ISA-18.2
Industrial IoT	Edge computing ที่ประมวลผล event ก่อนส่งขึ้น cloud
Automotive ECU	Event-driven architecture สำหรับ ADAS, Body Control
Building Automation	BACnet/BMS event management สำหรับ HVAC, Lighting
Medical Device	Monitor: vitals + pump control + alarm + audit log