// FreeRTOSのモノリシック設計例
// 全ての機能がカーネル空間で動作
void vTaskFunction(void *pvParameters) {
    // ファイルシステム操作
    FILE *fp = fopen("/data/config.txt", "r");
    
    // ネットワーク通信
    socket_send(socket_fd, data, len);
    
    // デバイス制御
    gpio_set_level(GPIO_NUM_2, 1);
    
    // 全て同一カーネル空間で実行
}

// QNXのマイクロカーネル設計例
// 各サービスが独立したプロセス

// ファイルシステムプロセス
int filesystem_process() {
    // ファイルI/O処理のみ
    return file_operation();
}

// ネットワークプロセス
int network_process() {
    // ネットワーク処理のみ
    return network_operation();
}

// カーネルはメッセージ配送のみ
kernel_send_message(dest_process, message);

// FreeRTOS 静的メモリ割り当て例
#define TASK_STACK_SIZE 1024
#define TASK_COUNT 5

// コンパイル時にメモリ確保
StaticTask_t task_buffers[TASK_COUNT];
StackType_t task_stacks[TASK_COUNT][TASK_STACK_SIZE];

void create_static_tasks(void) {
    for(int i = 0; i < TASK_COUNT; i++) {
        xTaskCreateStatic(
            task_function,           // タスク関数
            "Task",                  // タスク名
            TASK_STACK_SIZE,         // スタックサイズ
            (void*)i,                // パラメータ
            tskIDLE_PRIORITY + 1,    // 優先度
            &task_stacks[i][0],      // スタック領域
            &task_buffers[i]         // タスクバッファ
        );
    }
}

// Zephyr 動的メモリ管理例
#include <zephyr/kernel.h>

// ヒープからメモリ動的確保
void *dynamic_allocation_example(size_t size) {
    void *ptr = k_malloc(size);
    if (ptr == NULL) {
        printk("Memory allocation failed\n");
        return NULL;
    }
    
    // 使用後は必ず解放
    // k_free(ptr);
    return ptr;
}

// メモリプールを使用した効率的な管理
K_MEM_POOL_DEFINE(my_pool, 16, 64, 8, 4);

void pool_allocation_example(void) {
    void *block;
    int ret = k_mem_pool_alloc(&my_pool, &block, 32, K_NO_WAIT);
    if (ret == 0) {
        // メモリブロック使用
        k_mem_pool_free(&my_pool, &block);
    }
}

// QNX メモリ保護例
#include <sys/mman.h>

void memory_protection_demo(void) {
    // 読み取り専用メモリ領域作成
    void *readonly_mem = mmap(NULL, 4096, 
                              PROT_READ, 
                              MAP_PRIVATE | MAP_ANON, 
                              -1, 0);
    
    // 書き込み保護されたメモリ領域作成
    void *protected_mem = mmap(NULL, 4096,
                               PROT_READ | PROT_WRITE,
                               MAP_PRIVATE | MAP_ANON,
                               -1, 0);
    
    // メモリ保護属性変更
    mprotect(protected_mem, 4096, PROT_READ);
}

// 測定用コード例
#define DWT_CYCCNT_REG    (*((volatile uint32_t*)0xE0001004))

typedef struct {
    uint32_t min_cycles;
    uint32_t max_cycles;
    uint32_t avg_cycles;
    uint32_t samples;
} perf_stats_t;

perf_stats_t context_switch_test(void) {
    perf_stats_t stats = {0xFFFFFFFF, 0, 0, 0};
    uint32_t total_cycles = 0;
    
    for(int i = 0; i < 1000; i++) {
        uint32_t start = DWT_CYCCNT_REG;
        
        // タスク切り替えを強制
        taskYIELD();
        
        uint32_t end = DWT_CYCCNT_REG;
        uint32_t cycles = end - start;
        
        if(cycles < stats.min_cycles) stats.min_cycles = cycles;
        if(cycles > stats.max_cycles) stats.max_cycles = cycles;
        total_cycles += cycles;
        stats.samples++;
    }
    
    stats.avg_cycles = total_cycles / stats.samples;
    return stats;
}

// 割り込み応答時間測定
volatile uint32_t interrupt_start_time;
volatile uint32_t interrupt_end_time;

void EXTI_IRQHandler(void) {
    interrupt_start_time = DWT_CYCCNT_REG;
    
    // 割り込み処理
    critical_interrupt_handler();
    
    interrupt_end_time = DWT_CYCCNT_REG;
}

// 結果計算
uint32_t interrupt_latency = (interrupt_end_time - interrupt_start_time) / 400; // μs

// FreeRTOS最小構成例
#define configUSE_PREEMPTION              1
#define configUSE_TICK_HOOK               0
#define configUSE_IDLE_HOOK               0
#define configUSE_MALLOC_FAILED_HOOK      0
#define configUSE_DAEMON_TASK_STARTUP_HOOK 0
#define configUSE_TICK_HOOK               0
#define configUSE_CO_ROUTINES             0
#define configUSE_TIMERS                  0
#define configUSE_MUTEXES                 0
#define configUSE_COUNTING_SEMAPHORES     0

// この構成でのフットプリント: ROM 6KB, RAM 1KB

// FreeRTOSのタスク制御ブロック（TCB）構造
typedef struct tskTaskControlBlock {
    volatile StackType_t *pxTopOfStack;    // スタックポインタ
    ListItem_t xStateListItem;             // 状態リスト
    ListItem_t xEventListItem;             // イベントリスト
    UBaseType_t uxPriority;                // 優先度
    StackType_t *pxStack;                  // スタック開始アドレス
    char pcTaskName[configMAX_TASK_NAME_LEN]; // タスク名
    
    #if (configUSE_TRACE_FACILITY == 1)
    UBaseType_t uxTCBNumber;               // デバッグ用番号
    UBaseType_t uxTaskNumber;              // タスク番号
    #endif
    
    #if (configUSE_MUTEXES == 1)
    UBaseType_t uxBasePriority;            // 基本優先度
    UBaseType_t uxMutexesHeld;             // 保持ミューテックス数
    #endif
} tskTCB;

// 協調的スケジューリング例
void cooperative_task(void *pvParameters) {
    while(1) {
        // 長時間実行される処理
        for(int i = 0; i < 1000000; i++) {
            complex_calculation(i);
            
            // 定期的に他のタスクに制御を譲る
            if(i % 10000 == 0) {
                taskYIELD();
            }
        }
        
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

// 優先度継承ミューテックス
SemaphoreHandle_t priority_inheritance_mutex;

void setup_priority_inheritance(void) {
    priority_inheritance_mutex = xSemaphoreCreateMutex();
    
    // 優先度継承は自動的に処理される
    // 低優先度タスクがミューテックスを取得中に
    // 高優先度タスクが待機する場合、
    // 低優先度タスクの優先度が一時的に上がる
}

// TCP/IP スタック設定例
#define ipconfigUSE_DHCP                1
#define ipconfigUSE_DNS                 1
#define ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS 45
#define ipconfigEVENT_QUEUE_LENGTH      15

// HTTPサーバー実装例
void http_server_task(void *pvParameters) {
    Socket_t listening_socket;
    struct freertos_sockaddr bind_address;
    
    listening_socket = FreeRTOS_socket(FREERTOS_AF_INET, 
                                       FREERTOS_SOCK_STREAM, 
                                       FREERTOS_IPPROTO_TCP);
    
    bind_address.sin_port = FreeRTOS_htons(80);
    bind_address.sin_addr = FreeRTOS_htonl(INADDR_ANY);
    
    FreeRTOS_bind(listening_socket, &bind_address, sizeof(bind_address));
    FreeRTOS_listen(listening_socket, 5);
    
    while(1) {
        Socket_t client_socket = FreeRTOS_accept(listening_socket, NULL, NULL);
        if(client_socket != FREERTOS_INVALID_SOCKET) {
            // HTTP レスポンス処理
            handle_http_request(client_socket);
            FreeRTOS_closesocket(client_socket);
        }
    }
}

// device tree設定例（.dts ファイル）
/ {
    chosen {
        zephyr,console = &uart0;
        zephyr,sram = &sram0;
        zephyr,flash = &flash0;
    };
    
    leds {
        compatible = "gpio-leds";
        led0: led_0 {
            gpios = <&gpio0 13 GPIO_ACTIVE_LOW>;
            label = "Green LED 0";
        };
    };
    
    sensors {
        compatible = "zephyr,sensing";
        temp_sensor: temp_sensor {
            compatible = "nordic,nrf-temp";
            label = "Temperature sensor";
        };
    };
};

&uart0 {
    status = "okay";
    current-speed = <115200>;
    tx-pin = <6>;
    rx-pin = <8>;
};

// Device Tree API使用例
#include <zephyr/drivers/gpio.h>
#include <zephyr/device.h>

// Device Treeから自動生成されるマクロ
#define LED0_NODE DT_ALIAS(led0)
#define LED0_GPIO_LABEL DT_GPIO_LABEL(LED0_NODE, gpios)
#define LED0_GPIO_PIN DT_GPIO_PIN(LED0_NODE, gpios)
#define LED0_GPIO_FLAGS DT_GPIO_FLAGS(LED0_NODE, gpios)

void zephyr_gpio_example(void) {
    const struct device *gpio_dev = device_get_binding(LED0_GPIO_LABEL);
    
    gpio_pin_configure(gpio_dev, LED0_GPIO_PIN, 
                       GPIO_OUTPUT_ACTIVE | LED0_GPIO_FLAGS);
    
    while(1) {
        gpio_pin_toggle(gpio_dev, LED0_GPIO_PIN);
        k_msleep(1000);
    }
}

// Bluetooth LE実装例
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/gatt.h>

static const struct bt_data ad[] = {
    BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
    BT_DATA_BYTES(BT_DATA_UUID16_ALL, BT_UUID_16_ENCODE(BT_UUID_DIS_VAL)),
};

void bluetooth_init(void) {
    int err = bt_enable(NULL);
    if (err) {
        printk("Bluetooth init failed (err %d)\n", err);
        return;
    }
    
    err = bt_le_adv_start(BT_LE_ADV_CONN_NAME, ad, ARRAY_SIZE(ad), NULL, 0);
    if (err) {
        printk("Advertising failed to start (err %d)\n", err);
    }
}

// RT-Thread コンポーネント初期化
#include <rtthread.h>

// 自動初期化マクロ
INIT_BOARD_EXPORT(board_init);      // ボード初期化
INIT_PREV_EXPORT(early_init);       // 早期初期化
INIT_DEVICE_EXPORT(device_init);    // デバイス初期化
INIT_COMPONENT_EXPORT(component_init); // コンポーネント初期化
INIT_ENV_EXPORT(env_init);          // 環境初期化
INIT_APP_EXPORT(app_init);          // アプリケーション初期化

// デバイスドライバーフレームワーク
static struct rt_device_ops led_ops = {
    .init    = led_init,
    .open    = led_open,
    .close   = led_close,
    .read    = RT_NULL,
    .write   = led_write,
    .control = led_control
};

int led_driver_init(void) {
    struct rt_device *led_device = rt_device_create(RT_Device_Class_Miscellaneous, 0);
    led_device->ops = &led_ops;
    rt_device_register(led_device, "led", RT_DEVICE_FLAG_WRONLY);
    return 0;
}

// RT-Thread Studio 自動生成コード例
#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

// ピン定義（Studio GUIで設定）
#define LED_PIN_NUMBER    GET_PIN(B, 1)
#define BUTTON_PIN_NUMBER GET_PIN(A, 0)

static void led_thread_entry(void *parameter) {
    rt_pin_mode(LED_PIN_NUMBER, PIN_MODE_OUTPUT);
    
    while(1) {
        rt_pin_write(LED_PIN_NUMBER, PIN_HIGH);
        rt_thread_mdelay(500);
        rt_pin_write(LED_PIN_NUMBER, PIN_LOW);
        rt_thread_mdelay(500);
    }
}

// スレッド自動生成（Studio設定から）
static rt_thread_t led_thread = RT_NULL;

int led_thread_init(void) {
    led_thread = rt_thread_create("led_thread",
                                  led_thread_entry,
                                  RT_NULL,
                                  1024,
                                  25,
                                  10);
    if(led_thread != RT_NULL) {
        rt_thread_startup(led_thread);
    }
    return 0;
}

// GUIX Studio 自動生成コード例
#include "gx_api.h"
#include "demo_guix_washing_machine_resources.h"
#include "demo_guix_washing_machine_specifications.h"

// メインウィンドウ定義
GX_WINDOW main_window;
GX_BUTTON start_button;
GX_PROMPT status_prompt;

// イベント処理
UINT main_window_event_process(GX_WINDOW *widget, GX_EVENT *event_ptr) {
    switch(event_ptr->gx_event_type) {
    case GX_EVENT_SHOW:
        gx_window_event_process(widget, event_ptr);
        break;
        
    case GX_SIGNAL(ID_START_BUTTON, GX_EVENT_CLICKED):
        // 洗濯開始ボタンクリック処理
        start_washing_cycle();
        break;
        
    default:
        return gx_window_event_process(widget, event_ptr);
    }
    return GX_SUCCESS;
}

// NetX Duo TCP/IP設定
#include "nx_api.h"
#include "nx_ip.h"

#define DEMO_STACK_SIZE   2048
#define PACKET_SIZE       1536

NX_PACKET_POOL pool_0;
NX_IP ip_0;
ULONG pool_area[PACKET_SIZE * 10 / sizeof(ULONG)];

void netx_init(void) {
    // パケットプール作成
    nx_packet_pool_create(&pool_0, "NetX Packet Pool", 
                          PACKET_SIZE, pool_area, sizeof(pool_area));
    
    // IP インスタンス作成
    nx_ip_create(&ip_0, "NetX IP Instance 0", 
                 IP_ADDRESS(192, 168, 1, 100),
                 0xFFFFFF00UL, &pool_0, 
                 demo_driver, pointer, 2048, 1);
    
    // ARP, TCP, UDP有効化
    nx_arp_enable(&ip_0, (void *)arp_area, 1024);
    nx_tcp_enable(&ip_0);
    nx_udp_enable(&ip_0);
}

// QNX メッセージパッシング例
#include <sys/neutrino.h>
#include <sys/iomsg.h>

// サーバープロセス
typedef struct {
    struct _pulse pulse;
    int operation;
    int data;
} server_msg_t;

void *server_thread(void *arg) {
    int chid = ChannelCreate(0);
    server_msg_t msg;
    int rcvid;
    
    while(1) {
        rcvid = MsgReceive(chid, &msg, sizeof(msg), NULL);
        
        if(rcvid == 0) {
            // パルス受信
            handle_pulse(&msg.pulse);
        } else {
            // メッセージ受信
            process_request(&msg);
            MsgReply(rcvid, EOK, NULL, 0);
        }
    }
}

// クライアントプロセス
void client_request(int server_coid, int operation, int data) {
    server_msg_t msg;
    msg.operation = operation;
    msg.data = data;
    
    int result = MsgSend(server_coid, &msg, sizeof(msg), NULL, 0);
    if(result == -1) {
        perror("MsgSend failed");
    }
}

// QNX 用デバイスドライバ例
#include <sys/iofunc.h>
#include <sys/dispatch.h>

static resmgr_connect_funcs_t connect_funcs;
static resmgr_io_funcs_t io_funcs;
static iofunc_attr_t attr;

// デバイスI/O関数
int io_read(resmgr_context_t *ctp, io_read_t *msg, RESMGR_OCB_T *ocb) {
    int status;
    int nbytes = 0;
    
    if((status = iofunc_read_verify(ctp, msg, ocb, NULL)) != EOK) {
        return status;
    }
    
    // 実際のデバイス読み取り処理
    nbytes = device_read(msg->i.xtype & _IO_XTYPE_MASK,
                         (char *)msg + sizeof(msg->i),
                         msg->i.nbytes);
    
    _IO_SET_READ_NBYTES(ctp, nbytes);
    return _RESMGR_NPARTS(1);
}

// スマートメーター タスク構成
#define TASK_PRIORITY_HIGH      5
#define TASK_PRIORITY_NORMAL    3
#define TASK_PRIORITY_LOW       1

// クリティカルタスク（1ms周期）
void power_measurement_task(void *param) {
    TickType_t last_wake = xTaskGetTickCount();
    const TickType_t period = pdMS_TO_TICKS(1);
    
    while(1) {
        // 高精度電力測定
        float voltage = adc_read_voltage();
        float current = adc_read_current();
        float power = voltage * current;
        
        // データをキューに送信
        power_data_t data = {
            .timestamp = esp_timer_get_time(),
            .voltage = voltage,
            .current = current,
            .power = power
        };
        
        xQueueSend(power_data_queue, &data, 0);
        vTaskDelayUntil(&last_wake, period);
    }
}

// 通信タスク（100ms周期）
void communication_task(void *param) {
    power_data_t data;
    static uint32_t transmission_counter = 0;
    
    while(1) {
        // 電力データ受信
        if(xQueueReceive(power_data_queue, &data, portMAX_DELAY)) {
            // データバッファリング
            buffer_power_data(&data);
            
            // 定期送信（10秒間隔）
            if(++transmission_counter >= 100) {
                transmit_buffered_data();
                transmission_counter = 0;
            }
        }
    }
}

// ESP32 省電力モード実装
#include "esp_pm.h"
#include "esp_sleep.h"

void power_management_init(void) {
    // 動的周波数制御設定
    esp_pm_config_esp32_t pm_config = {
        .max_freq_mhz = 240,
        .min_freq_mhz = 10,
        .light_sleep_enable = true
    };
    esp_pm_configure(&pm_config);
    
    // ウェイクアップ設定
    esp_sleep_enable_timer_wakeup(1000000); // 1秒
    esp_sleep_enable_ext1_wakeup(GPIO_SEL_0, ESP_EXT1_WAKEUP_ANY_HIGH);
}

// アイドル時の省電力処理
void vApplicationIdleHook(void) {
    // CPU使用率が低い場合はライトスリープ
    if(system_load < 10) {
        esp_light_sleep_start();
    }
}

// QNX Safety Platform実装例
#include <sys/safety.h>

// セーフティマネージャー
typedef struct {
    uint32_t watchdog_counter;
    safety_state_t current_state;
    error_flags_t error_status;
} safety_manager_t;

// ASIL-D準拠の二重化システム
void dual_core_safety_check(void) {
    static uint32_t core0_result, core1_result;
    
    // Core 0での計算
    if(CPU_ID == 0) {
        core0_result = safety_critical_calculation(sensor_data);
    }
    
    // Core 1での独立計算
    if(CPU_ID == 1) {
        core1_result = safety_critical_calculation(sensor_data);
    }
    
    // 結果比較
    if(core0_result != core1_result) {
        safety_shutdown();
        log_safety_violation("Dual core mismatch");
    }
}

// ウォッチドッグタイマー
void safety_watchdog_task(void) {
    while(1) {
        if(!system_health_check()) {
            safety_reset_system();
        }
        
        hardware_watchdog_kick();
        delay(10); // 10ms
    }
}

// 車両制御システム
#define CONTROL_CYCLE_TIME_US   1000  // 1ms制御周期

void vehicle_control_task(void) {
    struct timespec cycle_time = {0, CONTROL_CYCLE_TIME_US * 1000};
    struct timespec next_activation;
    
    clock_gettime(CLOCK_MONOTONIC, &next_activation);
    
    while(1) {
        // センサーデータ取得
        sensor_fusion_data_t fused_data = get_sensor_fusion_data();
        
        // 経路計画
        trajectory_t trajectory = path_planning(fused_data);
        
        // 車両制御
        control_commands_t commands = vehicle_controller(trajectory, fused_data);
        
        // アクチュエーター出力
        apply_control_commands(commands);
        
        // 次回実行時刻まで待機
        nanosleep_until(&next_activation);
        timespec_add_ns(&next_activation, CONTROL_CYCLE_TIME_US * 1000);
    }
}

// RT-Thread モーション制御実装
#include <rtthread.h>
#include <rtdevice.h>

// モーションコントロールスレッド（100μs周期）
static struct rt_thread motion_thread;
static rt_uint8_t motion_thread_stack[2048];

void motion_control_thread_entry(void *parameter) {
    rt_tick_t last_tick = rt_tick_get();
    const rt_tick_t period_ticks = RT_TICK_PER_SECOND / 10000; // 100μs
    
    // 高精度タイマー設定
    rt_device_t timer_dev = rt_device_find("timer0");
    rt_device_open(timer_dev, RT_DEVICE_OFLAG_RDWR);
    
    while(1) {
        // 位置フィードバック読み取り
        encoder_data_t encoders[6];
        read_encoder_positions(encoders);
        
        // PID制御計算
        motor_commands_t commands;
        for(int axis = 0; axis < 6; axis++) {
            commands.axis[axis] = pid_controller(axis, 
                                               target_positions[axis],
                                               encoders[axis].position);
        }
        
        // モーター出力
        update_motor_outputs(commands);
        
        // 精密タイミング制御
        rt_thread_delay_until(&last_tick, period_ticks);
    }
}

// 安全監視スレッド
void safety_monitor_thread_entry(void *parameter) {
    while(1) {
        // 緊急停止ボタンチェック
        if(emergency_stop_pressed()) {
            disable_all_motors();
            set_safety_state(EMERGENCY_STOP);
        }
        
        // 動作範囲チェック
        for(int axis = 0; axis < 6; axis++) {
            if(position_out_of_range(axis)) {
                soft_stop_axis(axis);
                log_safety_event("Position limit exceeded", axis);
            }
        }
        
        rt_thread_mdelay(1); // 1ms周期
    }
}

// FreeRTOS統計情報取得
void system_monitor_task(void *param) {
    TaskStatus_t *task_status_array;
    UBaseType_t task_count;
    uint32_t total_runtime;
    
    while(1) {
        // タスク数取得
        task_count = uxTaskGetNumberOfTasks();
        
        // メモリ確保
        task_status_array = pvPortMalloc(task_count * sizeof(TaskStatus_t));
        
        if(task_status_array != NULL) {
            // タスク情報取得
            task_count = uxTaskGetSystemState(task_status_array,
                                              task_count,
                                              &total_runtime);
            
            // 統計情報出力
            printf("Task Name\t\tState\tPriority\tStack\tCPU%%\n");
            for(UBaseType_t i = 0; i < task_count; i++) {
                TaskStatus_t *task = &task_status_array[i];
                uint32_t cpu_percent = (task->ulRunTimeCounter * 100) / total_runtime;
                
                printf("%-16s\t%d\t%d\t\t%d\t%d%%\n",
                       task->pcTaskName,
                       task->eCurrentState,
                       task->uxCurrentPriority,
                       task->usStackHighWaterMark,
                       cpu_percent);
            }
            
            vPortFree(task_status_array);
        }
        
        vTaskDelay(pdMS_TO_TICKS(5000)); // 5秒間隔
    }
}

// Segger SystemView統合
#include "SEGGER_SYSVIEW.h"

void trace_init(void) {
    SEGGER_SYSVIEW_Conf();
    SEGGER_SYSVIEW_Start();
}

// カスタムイベント記録
void log_custom_event(const char* event_name, uint32_t value) {
    SEGGER_SYSVIEW_RecordU32(SYSVIEW_EVTMASK_USER, value);
    SEGGER_SYSVIEW_Print(event_name);
}

// Zephyr トレース機能
#include <zephyr/tracing/tracing.h>

// プロファイリング設定
CONFIG_TRACING=y
CONFIG_TRACING_CPU_STATS=y
CONFIG_THREAD_MONITOR=y
CONFIG_THREAD_NAME=y
CONFIG_THREAD_STACK_INFO=y

// システム統計出力
void print_system_stats(void) {
    struct k_thread *thread;
    
    printk("Thread monitoring:\n");
    printk("%-20s %-10s %-10s %-10s\n", 
           "Name", "State", "Priority", "Stack Used");
    
    K_THREAD_FOREACH(thread) {
        size_t unused;
        k_thread_stack_space_get(thread, &unused);
        
        printk("%-20s %-10d %-10d %-10d\n",
               k_thread_name_get(thread),
               thread->base.thread_state,
               k_thread_priority_get(thread),
               thread->stack_info.size - unused);
    }
}

// 汎用性能測定マクロ
#define PERF_COUNTER_INIT() \
    CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk; \
    DWT->CYCCNT = 0; \
    DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk

#define PERF_COUNTER_START() \
    uint32_t perf_start = DWT->CYCCNT

#define PERF_COUNTER_END(name) \
    uint32_t perf_end = DWT->CYCCNT; \
    uint32_t perf_cycles = perf_end - perf_start; \
    printf("%s: %lu cycles (%.2f us)\n", name, perf_cycles, \
           (float)perf_cycles / SystemCoreClock * 1000000)

// 使用例
void performance_test(void) {
    PERF_COUNTER_START();
    complex_algorithm();
    PERF_COUNTER_END("Complex Algorithm");
}

// スタック使用量監視
void stack_usage_monitor(void) {
    #if defined(__GNUC__)
    extern char _estack;
    register char *stack_ptr asm("sp");
    uint32_t stack_used = &_estack - stack_ptr;
    printf("Stack used: %lu bytes\n", stack_used);
    #endif
}

// スタックオーバーフロー検出と対策

// FreeRTOS スタックオーバーフローフック
void vApplicationStackOverflowHook(TaskHandle_t xTask, char *pcTaskName) {
    // スタックオーバーフローが発生したタスクを特定
    printf("Stack overflow in task: %s\n", pcTaskName);
    
    // 緊急停止処理
    taskDISABLE_INTERRUPTS();
    
    // システムリセット
    NVIC_SystemReset();
}

// 動的スタック監視
void monitor_stack_usage(void) {
    TaskHandle_t task_handles[10];
    UBaseType_t task_count = 10;
    
    task_count = uxTaskGetSystemState(NULL, 0, NULL);
    
    for(UBaseType_t i = 0; i < task_count; i++) {
        UBaseType_t high_water_mark = uxTaskGetStackHighWaterMark(task_handles[i]);
        if(high_water_mark < 100) { // 100 words = 400 bytes
            printf("Warning: Low stack space in task %d: %u words\n", 
                   i, high_water_mark);
        }
    }
}

// デッドロック検出システム
typedef struct {
    SemaphoreHandle_t mutex;
    TaskHandle_t owner;
    TickType_t acquire_time;
    const char* name;
} tracked_mutex_t;

tracked_mutex_t tracked_mutexes[MAX_TRACKED_MUTEXES];

bool safe_mutex_take(tracked_mutex_t *tracked_mutex, TickType_t timeout) {
    TickType_t start_time = xTaskGetTickCount();
    
    if(xSemaphoreTake(tracked_mutex->mutex, timeout) == pdTRUE) {
        tracked_mutex->owner = xTaskGetCurrentTaskHandle();
        tracked_mutex->acquire_time = start_time;
        return true;
    } else {
        // タイムアウト発生 - デッドロックの可能性
        printf("Mutex timeout: %s, potential deadlock\n", tracked_mutex->name);
        print_mutex_ownership_chain();
        return false;
    }
}

void deadlock_monitor_task(void *param) {
    while(1) {
        TickType_t current_time = xTaskGetTickCount();
        
        for(int i = 0; i < MAX_TRACKED_MUTEXES; i++) {
            if(tracked_mutexes[i].owner != NULL) {
                TickType_t hold_time = current_time - tracked_mutexes[i].acquire_time;
                
                if(hold_time > pdMS_TO_TICKS(5000)) { // 5秒以上保持
                    printf("Long mutex hold detected: %s held for %lu ms\n",
                           tracked_mutexes[i].name,
                           pdTICKS_TO_MS(hold_time));
                }
            }
        }
        
        vTaskDelay(pdMS_TO_TICKS(1000)); // 1秒チェック
    }
}

// メモリリーク監視システム
typedef struct mem_alloc {
    void *ptr;
    size_t size;
    const char *file;
    int line;
    TickType_t timestamp;
    struct mem_alloc *next;
} mem_alloc_t;

static mem_alloc_t *alloc_list = NULL;
static uint32_t total_allocated = 0;

void* debug_malloc(size_t size, const char *file, int line) {
    void *ptr = malloc(size);
    
    if(ptr != NULL) {
        mem_alloc_t *alloc = malloc(sizeof(mem_alloc_t));
        alloc->ptr = ptr;
        alloc->size = size;
        alloc->file = file;
        alloc->line = line;
        alloc->timestamp = xTaskGetTickCount();
        alloc->next = alloc_list;
        alloc_list = alloc;
        
        total_allocated += size;
        
        printf("MALLOC: %p (%u bytes) at %s:%d, total: %lu\n",
               ptr, size, file, line, total_allocated);
    }
    
    return ptr;
}

void debug_free(void *ptr) {
    mem_alloc_t **current = &alloc_list;
    
    while(*current != NULL) {
        if((*current)->ptr == ptr) {
            mem_alloc_t *to_free = *current;
            total_allocated -= to_free->size;
            
            printf("FREE: %p (%u bytes), total: %lu\n",
                   ptr, to_free->size, total_allocated);
            
            *current = to_free->next;
            free(to_free);
            break;
        }
        current = &(*current)->next;
    }
    
    free(ptr);
}

#define malloc(size) debug_malloc(size, __FILE__, __LINE__)
#define free(ptr) debug_free(ptr)

// タイマー精度問題の解決
static void precise_timer_callback(TimerHandle_t timer) {
    static TickType_t last_call_time = 0;
    TickType_t current_time = xTaskGetTickCount();
    
    if(last_call_time != 0) {
        TickType_t interval = current_time - last_call_time;
        if(interval > pdMS_TO_TICKS(102) || interval < pdMS_TO_TICKS(98)) {
            printf("Timer jitter detected: %lu ms\n", pdTICKS_TO_MS(interval));
        }
    }
    
    last_call_time = current_time;
    
    // 実際のタイマー処理
    timer_handler();
}

// 高精度タイマーの代替実装
void setup_high_precision_timer(void) {
    // ハードウェアタイマーを直接使用
    TIM_HandleTypeDef htim;
    htim.Instance = TIM2;
    htim.Init.Prescaler = 84 - 1; // 1MHz
    htim.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim.Init.Period = 1000 - 1; // 1ms
    
    HAL_TIM_Base_Init(&htim);
    HAL_TIM_Base_Start_IT(&htim);
}

// FreeRTOS コード
void freertos_task(void *param) {
    TickType_t last_wake = xTaskGetTickCount();
    
    while(1) {
        // 処理
        process_data();
        
        vTaskDelayUntil(&last_wake, pdMS_TO_TICKS(100));
    }
}

xTaskCreate(freertos_task, "task", 1024, NULL, 5, NULL);

// Zephyr 移植版
void zephyr_thread_entry(void) {
    while(1) {
        // 同じ処理
        process_data();
        
        k_msleep(100);
    }
}

K_THREAD_DEFINE(my_thread, 1024, zephyr_thread_entry, 
                NULL, NULL, NULL, 5, 0, 0);

// Phase 1: 基本タスク移植
void migrate_basic_tasks(void) {
    // 1. メインタスクのみ移植
    // 2. 基本的なI/O動作確認
    // 3. タイマー・割り込み動作確認
}

// Phase 2: 通信機能移植
void migrate_communication(void) {
    // 1. タスク間通信（キュー、セマフォ）
    // 2. ネットワーク通信
    // 3. シリアル通信
}

// Phase 3: 高度な機能移植
void migrate_advanced_features(void) {
    // 1. ファイルシステム
    // 2. OTA更新機能
    // 3. セキュリティ機能
}