系统优化¶

// 分析实际栈使用情况
CONFIG_THREAD_STACK_INFO=y

// 在代码中查询栈使用
size_t unused;
k_thread_stack_space_get(k_current_get(), &unused);
printk("Stack unused: %zu bytes\n", unused);

// 根据实际使用调整栈大小
#define MY_THREAD_STACK_SIZE 512  // 从默认 1024 减小到 512
K_THREAD_STACK_DEFINE(my_thread_stack, MY_THREAD_STACK_SIZE);

// 避免使用 k_malloc/k_free
// char *buf = k_malloc(256);

// 使用内存池
K_MEM_POOL_DEFINE(my_pool, 64, 256, 4, 4);

void *buf = k_mem_pool_malloc(&my_pool, 256);
// 使用完毕后释放
k_mem_pool_free(&my_pool, &buf);

// 避免动态分配
// struct sensor_data *data = k_malloc(sizeof(struct sensor_data));

// 使用静态分配
static struct sensor_data data;

#include <zephyr/kernel.h>
#include <zephyr/sys/printk.h>

void print_thread_stats(void)
{
    struct k_thread *thread;
    k_thread_runtime_stats_t stats;

    printk("Thread Name          CPU Usage\n");
    printk("--------------------------------\n");

    // 遍历所有线程
    K_THREAD_FOREACH(thread) {
        k_thread_runtime_stats_get(thread, &stats);
        uint32_t usage = (stats.execution_cycles * 100) / 
                         k_cycle_get_32();
        printk("%-20s %3u%%\n", 
               k_thread_name_get(thread), usage);
    }
}

// 避免：多个小任务频繁切换
void task1(void) {
    while (1) {
        process_sensor1();
        k_sleep(K_MSEC(10));
    }
}

void task2(void) {
    while (1) {
        process_sensor2();
        k_sleep(K_MSEC(10));
    }
}

// 推荐：合并为一个任务
void combined_task(void) {
    while (1) {
        process_sensor1();
        process_sensor2();
        k_sleep(K_MSEC(10));
    }
}

// 避免：为每个事件创建线程
void button_handler(const struct device *dev, 
                    struct gpio_callback *cb, uint32_t pins)
{
    // 在中断上下文中处理（不推荐）
    process_button_event();
}

// 推荐：使用工作队列
static struct k_work button_work;

void button_work_handler(struct k_work *work)
{
    process_button_event();
}

void button_handler(const struct device *dev, 
                    struct gpio_callback *cb, uint32_t pins)
{
    k_work_submit(&button_work);
}

void init_button(void)
{
    k_work_init(&button_work, button_work_handler);
}

// 避免：在 ISR 中执行复杂操作
void uart_isr(const struct device *dev)
{
    uint8_t data;
    uart_poll_in(dev, &data);

    // 复杂处理（不推荐）
    process_data(data);
    update_display();
    log_data(data);
}

// 推荐：ISR 只做最少的工作
static struct k_fifo uart_fifo;

void uart_isr(const struct device *dev)
{
    uint8_t data;
    uart_poll_in(dev, &data);

    // 只将数据放入队列
    k_fifo_put(&uart_fifo, &data);
}

// 在线程中处理
void uart_thread(void)
{
    while (1) {
        uint8_t *data = k_fifo_get(&uart_fifo, K_FOREVER);
        process_data(*data);
        update_display();
        log_data(*data);
    }
}

// 避免：CPU 轮询传输数据
void spi_transfer_polling(const struct device *dev, 
                          uint8_t *tx_buf, uint8_t *rx_buf, size_t len)
{
    for (size_t i = 0; i < len; i++) {
        spi_transceive(dev, &tx_buf[i], 1, &rx_buf[i], 1);
    }
}

// 推荐：使用 DMA 传输
void spi_transfer_dma(const struct device *dev, 
                      uint8_t *tx_buf, uint8_t *rx_buf, size_t len)
{
    struct spi_buf tx_bufs[] = {
        { .buf = tx_buf, .len = len }
    };
    struct spi_buf rx_bufs[] = {
        { .buf = rx_buf, .len = len }
    };
    struct spi_buf_set tx = { .buffers = tx_bufs, .count = 1 };
    struct spi_buf_set rx = { .buffers = rx_bufs, .count = 1 };

    // DMA 传输，CPU 可以做其他事情
    spi_transceive(dev, &spi_cfg, &tx, &rx);
}

// 对齐到缓存行大小（通常 32 或 64 字节）
#define CACHE_LINE_SIZE 32

struct __aligned(CACHE_LINE_SIZE) sensor_data {
    uint32_t timestamp;
    float temperature;
    float humidity;
    uint8_t status;
};

// 避免伪共享
struct __aligned(CACHE_LINE_SIZE) thread_data {
    uint32_t counter;
    // 填充到缓存行大小
    uint8_t padding[CACHE_LINE_SIZE - sizeof(uint32_t)];
};

// 避免：多次拷贝
void process_data_copy(uint8_t *input, size_t len)
{
    uint8_t temp[256];
    memcpy(temp, input, len);  // 第一次拷贝

    uint8_t output[256];
    transform(temp, output, len);  // 第二次拷贝

    send_data(output, len);
}

// 推荐：原地处理或使用指针
void process_data_inplace(uint8_t *input, size_t len)
{
    transform_inplace(input, len);  // 原地转换
    send_data(input, len);  // 直接发送
}

// 强制内联小函数
static inline __attribute__((always_inline)) 
uint32_t fast_multiply(uint32_t a, uint32_t b)
{
    return a * b;
}

// 避免内联大函数
__attribute__((noinline))
void complex_processing(void)
{
    // 复杂处理逻辑
}

#include <zephyr/kernel.h>
#include <zephyr/timing/timing.h>

void benchmark_function(void)
{
    timing_t start, end;
    uint64_t cycles;

    timing_init();
    timing_start();

    start = timing_counter_get();

    // 被测试的函数
    function_to_benchmark();

    end = timing_counter_get();
    cycles = timing_cycles_get(&start, &end);

    uint64_t ns = timing_cycles_to_ns(cycles);
    printk("Execution time: %llu ns (%llu cycles)\n", ns, cycles);
}

static uint32_t irq_entry_time;
static uint32_t irq_latency_max = 0;

void gpio_isr(const struct device *dev, 
              struct gpio_callback *cb, uint32_t pins)
{
    uint32_t now = k_cycle_get_32();
    uint32_t latency = now - irq_entry_time;

    if (latency > irq_latency_max) {
        irq_latency_max = latency;
    }
}

void trigger_interrupt(void)
{
    irq_entry_time = k_cycle_get_32();
    // 触发中断
}

void measure_response_time(void)
{
    uint32_t start, end, response_time;
    uint32_t min_time = UINT32_MAX;
    uint32_t max_time = 0;
    uint32_t total_time = 0;
    uint32_t count = 1000;

    for (uint32_t i = 0; i < count; i++) {
        start = k_cycle_get_32();

        // 触发事件并等待响应
        trigger_event();
        wait_for_response();

        end = k_cycle_get_32();
        response_time = end - start;

        if (response_time < min_time) min_time = response_time;
        if (response_time > max_time) max_time = response_time;
        total_time += response_time;
    }

    printk("Response time statistics:\n");
    printk("  Min: %u cycles\n", min_time);
    printk("  Max: %u cycles (WCRT)\n", max_time);
    printk("  Avg: %u cycles\n", total_time / count);
    printk("  Jitter: %u cycles\n", max_time - min_time);
}

// 任务 1：周期 10ms，优先级最高
#define TASK1_PRIORITY 5
#define TASK1_PERIOD K_MSEC(10)

void task1(void)
{
    while (1) {
        // 处理高频任务
        k_sleep(TASK1_PERIOD);
    }
}

// 任务 2：周期 50ms，优先级中等
#define TASK2_PRIORITY 7
#define TASK2_PERIOD K_MSEC(50)

void task2(void)
{
    while (1) {
        // 处理中频任务
        k_sleep(TASK2_PERIOD);
    }
}

// 任务 3：周期 100ms，优先级最低
#define TASK3_PRIORITY 9
#define TASK3_PERIOD K_MSEC(100)

void task3(void)
{
    while (1) {
        // 处理低频任务
        k_sleep(TASK3_PERIOD);
    }
}

// 任务 1：截止时间 5ms，优先级最高
#define TASK1_PRIORITY 5
#define TASK1_DEADLINE K_MSEC(5)

// 任务 2：截止时间 20ms，优先级中等
#define TASK2_PRIORITY 7
#define TASK2_DEADLINE K_MSEC(20)

// 任务 3：截止时间 50ms，优先级最低
#define TASK3_PRIORITY 9
#define TASK3_DEADLINE K_MSEC(50)

// 关键中断：最高优先级
#define CRITICAL_IRQ_PRIORITY 0

// 重要中断：高优先级
#define IMPORTANT_IRQ_PRIORITY 2

// 普通中断：中等优先级
#define NORMAL_IRQ_PRIORITY 4

// 低优先级中断
#define LOW_IRQ_PRIORITY 6

// 配置中断
IRQ_CONNECT(TIMER_IRQ, CRITICAL_IRQ_PRIORITY, 
            timer_isr, NULL, 0);
IRQ_CONNECT(UART_IRQ, NORMAL_IRQ_PRIORITY, 
            uart_isr, NULL, 0);
IRQ_CONNECT(GPIO_IRQ, LOW_IRQ_PRIORITY, 
            gpio_isr, NULL, 0);

// 方法 1：禁用中断
unsigned int key = irq_lock();
// 关键代码段
critical_section();
irq_unlock(key);

// 方法 2：禁用线程抢占
k_sched_lock();
// 关键代码段
critical_section();
k_sched_unlock();

// 方法 3：使用互斥锁
static K_MUTEX_DEFINE(critical_mutex);

k_mutex_lock(&critical_mutex, K_FOREVER);
// 关键代码段
critical_section();
k_mutex_unlock(&critical_mutex);

#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>

#define TEST_PIN DT_GPIO_PIN(DT_ALIAS(led0), gpios)
#define TEST_PORT DT_GPIO_LABEL(DT_ALIAS(led0), gpios)

static uint32_t irq_timestamps[1000];
static uint32_t irq_count = 0;

void test_gpio_isr(const struct device *dev, 
                   struct gpio_callback *cb, uint32_t pins)
{
    if (irq_count < 1000) {
        irq_timestamps[irq_count++] = k_cycle_get_32();
    }
}

void measure_interrupt_latency(void)
{
    const struct device *gpio = device_get_binding(TEST_PORT);
    uint32_t trigger_time;

    // 配置 GPIO 中断
    gpio_pin_configure(gpio, TEST_PIN, GPIO_INPUT);
    gpio_pin_interrupt_configure(gpio, TEST_PIN, 
                                 GPIO_INT_EDGE_RISING);

    // 触发中断并测量延迟
    for (int i = 0; i < 1000; i++) {
        trigger_time = k_cycle_get_32();
        // 触发中断
        gpio_pin_set(gpio, TEST_PIN, 1);
        k_busy_wait(10);
        gpio_pin_set(gpio, TEST_PIN, 0);
        k_sleep(K_MSEC(1));
    }

    // 分析延迟
    uint32_t min_latency = UINT32_MAX;
    uint32_t max_latency = 0;
    uint64_t total_latency = 0;

    for (int i = 0; i < irq_count; i++) {
        uint32_t latency = irq_timestamps[i] - trigger_time;
        if (latency < min_latency) min_latency = latency;
        if (latency > max_latency) max_latency = latency;
        total_latency += latency;
    }

    printk("Interrupt latency:\n");
    printk("  Min: %u cycles (%.2f us)\n", 
           min_latency, (float)min_latency / sys_clock_hw_cycles_per_sec() * 1000000);
    printk("  Max: %u cycles (%.2f us)\n", 
           max_latency, (float)max_latency / sys_clock_hw_cycles_per_sec() * 1000000);
    printk("  Avg: %u cycles (%.2f us)\n", 
           (uint32_t)(total_latency / irq_count), 
           (float)(total_latency / irq_count) / sys_clock_hw_cycles_per_sec() * 1000000);
    printk("  Jitter: %u cycles (%.2f us)\n", 
           max_latency - min_latency, 
           (float)(max_latency - min_latency) / sys_clock_hw_cycles_per_sec() * 1000000);
}

void analyze_jitter(uint32_t *timestamps, size_t count)
{
    uint32_t intervals[count - 1];

    // 计算相邻事件的时间间隔
    for (size_t i = 1; i < count; i++) {
        intervals[i - 1] = timestamps[i] - timestamps[i - 1];
    }

    // 计算平均间隔
    uint64_t total = 0;
    for (size_t i = 0; i < count - 1; i++) {
        total += intervals[i];
    }
    uint32_t avg_interval = total / (count - 1);

    // 计算标准差（抖动）
    uint64_t variance = 0;
    for (size_t i = 0; i < count - 1; i++) {
        int32_t diff = intervals[i] - avg_interval;
        variance += diff * diff;
    }
    uint32_t std_dev = sqrt(variance / (count - 1));

    printk("Jitter analysis:\n");
    printk("  Average interval: %u cycles\n", avg_interval);
    printk("  Standard deviation: %u cycles\n", std_dev);
    printk("  Jitter (3σ): %u cycles\n", std_dev * 3);
}

// 使用 Nordic Power Profiler Kit
void measure_power_consumption(void)
{
    printk("Starting power measurement...\n");

    // 正常运行模式
    printk("Active mode\n");
    k_sleep(K_SECONDS(5));

    // 进入低功耗模式
    printk("Sleep mode\n");
    k_sleep(K_SECONDS(5));

    // 深度睡眠模式
    printk("Deep sleep mode\n");
    k_sleep(K_SECONDS(5));
}

#include <zephyr/pm/pm.h>
#include <zephyr/pm/policy.h>

void low_power_task(void)
{
    while (1) {
        // 执行任务
        process_sensor_data();

        // 进入低功耗模式
        k_sleep(K_SECONDS(10));  // 自动进入最深的睡眠模式
    }
}

// 自定义电源策略
const struct pm_state_info *pm_policy_next_state(uint8_t cpu, int32_t ticks)
{
    // 如果空闲时间 > 1 秒，进入 Suspend 模式
    if (ticks > k_ms_to_ticks_ceil32(1000)) {
        return &pm_states[PM_STATE_SUSPEND_TO_RAM];
    }
    // 如果空闲时间 > 100ms，进入 Standby 模式
    else if (ticks > k_ms_to_ticks_ceil32(100)) {
        return &pm_states[PM_STATE_STANDBY];
    }
    // 否则进入 Idle 模式
    else {
        return &pm_states[PM_STATE_RUNTIME_IDLE];
    }
}

#include <zephyr/pm/device.h>

void power_down_peripherals(void)
{
    const struct device *uart = device_get_binding("UART_0");
    const struct device *spi = device_get_binding("SPI_1");
    const struct device *i2c = device_get_binding("I2C_0");

    // 关闭外设
    pm_device_action_run(uart, PM_DEVICE_ACTION_SUSPEND);
    pm_device_action_run(spi, PM_DEVICE_ACTION_SUSPEND);
    pm_device_action_run(i2c, PM_DEVICE_ACTION_SUSPEND);
}

void power_up_peripherals(void)
{
    const struct device *uart = device_get_binding("UART_0");
    const struct device *spi = device_get_binding("SPI_1");
    const struct device *i2c = device_get_binding("I2C_0");

    // 唤醒外设
    pm_device_action_run(uart, PM_DEVICE_ACTION_RESUME);
    pm_device_action_run(spi, PM_DEVICE_ACTION_RESUME);
    pm_device_action_run(i2c, PM_DEVICE_ACTION_RESUME);
}

void read_sensor_low_power(void)
{
    const struct device *i2c = device_get_binding("I2C_0");

    // 唤醒 I2C
    pm_device_action_run(i2c, PM_DEVICE_ACTION_RESUME);

    // 读取传感器
    uint8_t data[2];
    i2c_read(i2c, data, 2, SENSOR_ADDR);

    // 关闭 I2C
    pm_device_action_run(i2c, PM_DEVICE_ACTION_SUSPEND);
}

// 高性能模式：64 MHz
void set_high_performance_mode(void)
{
    // 设置 CPU 频率为 64 MHz
    clock_control_set_rate(clock_dev, 
                          CLOCK_CONTROL_NRF_SUBSYS_HF, 
                          64000000);
}

// 低功耗模式：16 MHz
void set_low_power_mode(void)
{
    // 设置 CPU 频率为 16 MHz
    clock_control_set_rate(clock_dev, 
                          CLOCK_CONTROL_NRF_SUBSYS_HF, 
                          16000000);
}

// 根据负载动态调整
void adaptive_frequency_scaling(void)
{
    uint32_t cpu_usage = get_cpu_usage();

    if (cpu_usage > 80) {
        set_high_performance_mode();
    } else if (cpu_usage < 20) {
        set_low_power_mode();
    }
}

// 主循环：持续运行
void main(void)
{
    const struct device *sensor = device_get_binding("SENSOR");

    while (1) {
        // 每 100ms 读取一次传感器
        read_sensor(sensor);
        k_sleep(K_MSEC(100));
    }
}

void main(void)
{
    const struct device *sensor = device_get_binding("SENSOR");

    // 关闭不需要的外设
    power_down_unused_peripherals();

    while (1) {
        // 唤醒传感器
        pm_device_action_run(sensor, PM_DEVICE_ACTION_RESUME);

        // 读取传感器
        read_sensor(sensor);

        // 关闭传感器
        pm_device_action_run(sensor, PM_DEVICE_ACTION_SUSPEND);

        // 进入深度睡眠 10 秒
        k_sleep(K_SECONDS(10));
    }
}

#include <zephyr/kernel.h>

void print_kernel_stats(void)
{
    struct k_thread *thread;

    printk("\n=== Kernel Statistics ===\n");
    printk("System uptime: %lld ms\n", k_uptime_get());
    printk("Cycle count: %u\n", k_cycle_get_32());

    printk("\n=== Thread Information ===\n");
    K_THREAD_FOREACH(thread) {
        printk("Thread: %s\n", k_thread_name_get(thread));
        printk("  State: %d\n", thread->base.thread_state);
        printk("  Priority: %d\n", thread->base.prio);

        #ifdef CONFIG_THREAD_STACK_INFO
        size_t unused;
        k_thread_stack_space_get(thread, &unused);
        printk("  Stack: %zu / %zu bytes used\n", 
               thread->stack_info.size - unused, 
               thread->stack_info.size);
        #endif
    }
}

#include <SEGGER_SYSVIEW.h>

void main(void)
{
    SEGGER_SYSVIEW_Conf();

    // 应用代码
}

#include <zephyr/arch/arm/aarch32/cortex_m/cmsis.h>

void dwt_init(void)
{
    // 启用 DWT
    CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;

    // 重置周期计数器
    DWT->CYCCNT = 0;

    // 启用周期计数器
    DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
}

uint32_t dwt_get_cycles(void)
{
    return DWT->CYCCNT;
}

void measure_function_cycles(void)
{
    uint32_t start, end, cycles;

    start = dwt_get_cycles();

    // 被测试的函数
    function_to_measure();

    end = dwt_get_cycles();
    cycles = end - start;

    printk("Function took %u cycles\n", cycles);
}

void enable_cache_profiling(void)
{
    // 启用 I-Cache miss 计数
    DWT->CTRL |= DWT_CTRL_CPIEVTENA_Msk;

    // 启用 D-Cache miss 计数
    DWT->CTRL |= DWT_CTRL_EXCEVTENA_Msk;
}

void print_cache_stats(void)
{
    uint32_t icache_miss = DWT->CPICNT;
    uint32_t dcache_miss = DWT->EXCCNT;

    printk("I-Cache misses: %u\n", icache_miss);
    printk("D-Cache misses: %u\n", dcache_miss);
}

#include <zephyr/sys/heap_listener.h>

static void heap_event_handler(enum heap_event_type event, 
                               void *mem, size_t size)
{
    switch (event) {
    case HEAP_EVENT_ALLOC:
        printk("Allocated %zu bytes at %p\n", size, mem);
        break;
    case HEAP_EVENT_FREE:
        printk("Freed memory at %p\n", mem);
        break;
    }
}

void init_heap_monitoring(void)
{
    static struct heap_listener listener = {
        .event_handler = heap_event_handler
    };

    heap_listener_register(&listener);
}

void check_stack_usage(void)
{
    struct k_thread *thread;

    printk("\n=== Stack Usage ===\n");
    K_THREAD_FOREACH(thread) {
        size_t unused;
        k_thread_stack_space_get(thread, &unused);

        size_t used = thread->stack_info.size - unused;
        float usage_percent = (float)used / thread->stack_info.size * 100;

        printk("%s: %zu / %zu bytes (%.1f%%)\n",
               k_thread_name_get(thread),
               used, thread->stack_info.size, usage_percent);

        if (usage_percent > 80) {
            printk("  WARNING: High stack usage!\n");
        }
    }
}

void main(void)
{
    const struct device *sensor = device_get_binding("SHT3X");
    const struct device *lora = device_get_binding("LORA");

    while (1) {
        // 读取传感器
        float temp, humidity;
        read_sensor(sensor, &temp, &humidity);

        // 发送数据
        send_lora(lora, temp, humidity);

        // 等待 10 分钟
        k_sleep(K_MINUTES(10));
    }
}

#define CONTROL_PERIOD_US 50

void motor_control_thread(void)
{
    while (1) {
        // 读取编码器
        int32_t position = read_encoder();

        // PID 控制
        float output = pid_calculate(position);

        // 更新 PWM
        update_pwm(output);

        // 等待下一个周期
        k_usleep(CONTROL_PERIOD_US);
    }
}

#define SAMPLE_RATE 100000
#define NUM_CHANNELS 8

void data_acquisition_thread(void)
{
    uint16_t samples[NUM_CHANNELS];

    while (1) {
        // 逐个通道采样
        for (int i = 0; i < NUM_CHANNELS; i++) {
            adc_read(adc_dev, i, &samples[i]);
        }

        // 处理数据
        process_samples(samples, NUM_CHANNELS);

        // 等待下一个采样周期
        k_usleep(10);  // 100 kHz = 10 us
    }
}