子系统使用¶

#include <zephyr/logging/log.h>

// 注册日志模块（模块名，默认日志级别）
LOG_MODULE_REGISTER(my_module, LOG_LEVEL_INF);

void my_function(void)
{
    int value = 42;

    // 不同级别的日志
    LOG_ERR("Error message: %d", value);
    LOG_WRN("Warning message: %d", value);
    LOG_INF("Info message: %d", value);
    LOG_DBG("Debug message: %d", value);

    // 十六进制数据输出
    uint8_t data[] = {0x01, 0x02, 0x03, 0x04};
    LOG_HEXDUMP_INF(data, sizeof(data), "Data dump:");
}

// sensor.c
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(sensor, LOG_LEVEL_DBG);

void sensor_read(void)
{
    LOG_INF("Reading sensor data...");
    int value = 25;
    LOG_DBG("Sensor value: %d", value);
}

// main.c
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(main, LOG_LEVEL_INF);

extern void sensor_read(void);

int main(void)
{
    LOG_INF("Application started");

    while (1) {
        sensor_read();
        k_sleep(K_SECONDS(1));
    }

    return 0;
}

#include <zephyr/shell/shell.h>
#include <zephyr/logging/log.h>

LOG_MODULE_REGISTER(sensor_shell, LOG_LEVEL_INF);

// 传感器读取命令
static int cmd_sensor_read(const struct shell *sh, size_t argc, char **argv)
{
    ARG_UNUSED(argc);
    ARG_UNUSED(argv);

    int value = 25;  // 模拟读取传感器
    shell_print(sh, "Sensor value: %d", value);

    return 0;
}

// 传感器配置命令
static int cmd_sensor_config(const struct shell *sh, size_t argc, char **argv)
{
    if (argc < 2) {
        shell_error(sh, "Usage: sensor config <rate>");
        return -EINVAL;
    }

    int rate = atoi(argv[1]);
    shell_print(sh, "Sensor rate set to: %d Hz", rate);

    return 0;
}

// 传感器校准命令
static int cmd_sensor_calibrate(const struct shell *sh, size_t argc, char **argv)
{
    shell_print(sh, "Calibrating sensor...");
    k_sleep(K_MSEC(500));
    shell_print(sh, "Calibration complete");

    return 0;
}

// 定义子命令
SHELL_STATIC_SUBCMD_SET_CREATE(sub_sensor,
    SHELL_CMD(read, NULL, "Read sensor value", cmd_sensor_read),
    SHELL_CMD(config, NULL, "Configure sensor rate", cmd_sensor_config),
    SHELL_CMD(calibrate, NULL, "Calibrate sensor", cmd_sensor_calibrate),
    SHELL_SUBCMD_SET_END
);

// 注册顶层命令
SHELL_CMD_REGISTER(sensor, &sub_sensor, "Sensor commands", NULL);

static int cmd_handler(const struct shell *sh, size_t argc, char **argv)
{
    // sh: Shell 实例指针，用于输出
    // argc: 参数个数（包括命令本身）
    // argv: 参数数组

    // 输出普通信息
    shell_print(sh, "Normal message");

    // 输出警告信息（黄色）
    shell_warn(sh, "Warning message");

    // 输出错误信息（红色）
    shell_error(sh, "Error message");

    // 输出信息（绿色）
    shell_info(sh, "Info message");

    return 0;  // 返回 0 表示成功，负数表示错误
}

#include <zephyr/storage/flash_map.h>
#include <zephyr/logging/log.h>

LOG_MODULE_REGISTER(flash_example, LOG_LEVEL_INF);

void flash_example(void)
{
    const struct flash_area *fa;
    uint8_t write_buf[256];
    uint8_t read_buf[256];
    int rc;

    // 打开 Flash 分区
    rc = flash_area_open(FLASH_AREA_ID(storage), &fa);
    if (rc != 0) {
        LOG_ERR("Failed to open flash area: %d", rc);
        return;
    }

    // 擦除 Flash（必须先擦除才能写入）
    rc = flash_area_erase(fa, 0, fa->fa_size);
    if (rc != 0) {
        LOG_ERR("Failed to erase flash: %d", rc);
        flash_area_close(fa);
        return;
    }

    // 准备写入数据
    for (int i = 0; i < sizeof(write_buf); i++) {
        write_buf[i] = i;
    }

    // 写入数据
    rc = flash_area_write(fa, 0, write_buf, sizeof(write_buf));
    if (rc != 0) {
        LOG_ERR("Failed to write flash: %d", rc);
        flash_area_close(fa);
        return;
    }

    // 读取数据
    rc = flash_area_read(fa, 0, read_buf, sizeof(read_buf));
    if (rc != 0) {
        LOG_ERR("Failed to read flash: %d", rc);
        flash_area_close(fa);
        return;
    }

    // 验证数据
    if (memcmp(write_buf, read_buf, sizeof(write_buf)) == 0) {
        LOG_INF("Flash read/write successful");
    } else {
        LOG_ERR("Flash data mismatch");
    }

    // 关闭 Flash 分区
    flash_area_close(fa);
}

#include <zephyr/fs/fs.h>
#include <zephyr/fs/littlefs.h>
#include <zephyr/storage/flash_map.h>
#include <zephyr/logging/log.h>

LOG_MODULE_REGISTER(littlefs_example, LOG_LEVEL_INF);

// 定义挂载点
FS_LITTLEFS_DECLARE_DEFAULT_CONFIG(storage);
static struct fs_mount_t lfs_mnt = {
    .type = FS_LITTLEFS,
    .fs_data = &storage,
    .storage_dev = (void *)FLASH_AREA_ID(storage),
    .mnt_point = "/lfs",
};

void littlefs_example(void)
{
    struct fs_file_t file;
    int rc;

    // 挂载文件系统
    rc = fs_mount(&lfs_mnt);
    if (rc != 0) {
        LOG_ERR("Failed to mount filesystem: %d", rc);
        return;
    }
    LOG_INF("Filesystem mounted at %s", lfs_mnt.mnt_point);

    // 初始化文件结构
    fs_file_t_init(&file);

    // 打开文件（创建或覆盖）
    rc = fs_open(&file, "/lfs/test.txt", FS_O_CREATE | FS_O_WRITE);
    if (rc != 0) {
        LOG_ERR("Failed to open file: %d", rc);
        return;
    }

    // 写入数据
    const char *data = "Hello, LittleFS!";
    rc = fs_write(&file, data, strlen(data));
    if (rc < 0) {
        LOG_ERR("Failed to write file: %d", rc);
        fs_close(&file);
        return;
    }
    LOG_INF("Wrote %d bytes", rc);

    // 关闭文件
    fs_close(&file);

    // 重新打开文件读取
    rc = fs_open(&file, "/lfs/test.txt", FS_O_READ);
    if (rc != 0) {
        LOG_ERR("Failed to open file for reading: %d", rc);
        return;
    }

    // 读取数据
    char read_buf[64];
    rc = fs_read(&file, read_buf, sizeof(read_buf) - 1);
    if (rc < 0) {
        LOG_ERR("Failed to read file: %d", rc);
        fs_close(&file);
        return;
    }
    read_buf[rc] = '\0';
    LOG_INF("Read: %s", read_buf);

    // 关闭文件
    fs_close(&file);

    // 列出目录内容
    struct fs_dir_t dir;
    fs_dir_t_init(&dir);

    rc = fs_opendir(&dir, "/lfs");
    if (rc != 0) {
        LOG_ERR("Failed to open directory: %d", rc);
        return;
    }

    struct fs_dirent entry;
    while (fs_readdir(&dir, &entry) == 0) {
        if (entry.name[0] == 0) {
            break;
        }
        LOG_INF("File: %s, size: %zu", entry.name, entry.size);
    }

    fs_closedir(&dir);
}

#include <zephyr/fs/nvs.h>
#include <zephyr/storage/flash_map.h>
#include <zephyr/logging/log.h>

LOG_MODULE_REGISTER(nvs_example, LOG_LEVEL_INF);

// NVS 文件系统实例
static struct nvs_fs fs;

// 配置参数 ID
#define NVS_ID_SENSOR_RATE    1
#define NVS_ID_SENSOR_OFFSET  2
#define NVS_ID_DEVICE_NAME    3

void nvs_example(void)
{
    int rc;

    // 获取 Flash 分区信息
    struct flash_sector sectors[8];
    const struct flash_area *fa;

    rc = flash_area_open(FLASH_AREA_ID(storage), &fa);
    if (rc != 0) {
        LOG_ERR("Failed to open flash area: %d", rc);
        return;
    }

    // 初始化 NVS
    fs.flash_device = fa->fa_dev;
    fs.offset = fa->fa_off;
    fs.sector_size = 4096;
    fs.sector_count = fa->fa_size / fs.sector_size;

    rc = nvs_mount(&fs);
    if (rc != 0) {
        LOG_ERR("Failed to mount NVS: %d", rc);
        flash_area_close(fa);
        return;
    }
    LOG_INF("NVS mounted successfully");

    // 写入整数值
    uint32_t sensor_rate = 100;
    rc = nvs_write(&fs, NVS_ID_SENSOR_RATE, &sensor_rate, sizeof(sensor_rate));
    if (rc < 0) {
        LOG_ERR("Failed to write sensor rate: %d", rc);
    } else {
        LOG_INF("Wrote sensor rate: %u", sensor_rate);
    }

    // 写入浮点数值
    float sensor_offset = 1.5f;
    rc = nvs_write(&fs, NVS_ID_SENSOR_OFFSET, &sensor_offset, sizeof(sensor_offset));
    if (rc < 0) {
        LOG_ERR("Failed to write sensor offset: %d", rc);
    } else {
        LOG_INF("Wrote sensor offset: %.2f", sensor_offset);
    }

    // 写入字符串
    const char *device_name = "MyDevice";
    rc = nvs_write(&fs, NVS_ID_DEVICE_NAME, device_name, strlen(device_name) + 1);
    if (rc < 0) {
        LOG_ERR("Failed to write device name: %d", rc);
    } else {
        LOG_INF("Wrote device name: %s", device_name);
    }

    // 读取整数值
    uint32_t read_rate;
    rc = nvs_read(&fs, NVS_ID_SENSOR_RATE, &read_rate, sizeof(read_rate));
    if (rc > 0) {
        LOG_INF("Read sensor rate: %u", read_rate);
    } else {
        LOG_ERR("Failed to read sensor rate: %d", rc);
    }

    // 读取浮点数值
    float read_offset;
    rc = nvs_read(&fs, NVS_ID_SENSOR_OFFSET, &read_offset, sizeof(read_offset));
    if (rc > 0) {
        LOG_INF("Read sensor offset: %.2f", read_offset);
    } else {
        LOG_ERR("Failed to read sensor offset: %d", rc);
    }

    // 读取字符串
    char read_name[32];
    rc = nvs_read(&fs, NVS_ID_DEVICE_NAME, read_name, sizeof(read_name));
    if (rc > 0) {
        LOG_INF("Read device name: %s", read_name);
    } else {
        LOG_ERR("Failed to read device name: %d", rc);
    }

    // 删除条目
    rc = nvs_delete(&fs, NVS_ID_SENSOR_RATE);
    if (rc == 0) {
        LOG_INF("Deleted sensor rate");
    }

    flash_area_close(fa);
}

// 使用内存缓存减少 Flash 访问
static struct {
    uint32_t sensor_rate;
    float sensor_offset;
    bool dirty;
} config_cache;

void config_load(void)
{
    nvs_read(&fs, NVS_ID_SENSOR_RATE, &config_cache.sensor_rate, 
             sizeof(config_cache.sensor_rate));
    nvs_read(&fs, NVS_ID_SENSOR_OFFSET, &config_cache.sensor_offset, 
             sizeof(config_cache.sensor_offset));
    config_cache.dirty = false;
}

void config_save(void)
{
    if (config_cache.dirty) {
        nvs_write(&fs, NVS_ID_SENSOR_RATE, &config_cache.sensor_rate, 
                  sizeof(config_cache.sensor_rate));
        nvs_write(&fs, NVS_ID_SENSOR_OFFSET, &config_cache.sensor_offset, 
                  sizeof(config_cache.sensor_offset));
        config_cache.dirty = false;
    }
}

void config_set_rate(uint32_t rate)
{
    config_cache.sensor_rate = rate;
    config_cache.dirty = true;
}

#include <zephyr/pm/device.h>
#include <zephyr/device.h>
#include <zephyr/logging/log.h>

LOG_MODULE_REGISTER(pm_example, LOG_LEVEL_INF);

void device_power_example(void)
{
    const struct device *i2c_dev = DEVICE_DT_GET(DT_NODELABEL(i2c0));

    if (!device_is_ready(i2c_dev)) {
        LOG_ERR("I2C device not ready");
        return;
    }

    // 使用设备前确保其处于活动状态
    pm_device_action_run(i2c_dev, PM_DEVICE_ACTION_RESUME);

    // 使用 I2C 设备
    // ... I2C 操作 ...

    // 使用完毕后挂起设备以节省功耗
    pm_device_action_run(i2c_dev, PM_DEVICE_ACTION_SUSPEND);

    LOG_INF("Device suspended");
}

#include <zephyr/kernel.h>
#include <zephyr/pm/pm.h>
#include <zephyr/logging/log.h>

LOG_MODULE_REGISTER(sleep_example, LOG_LEVEL_INF);

void sleep_example(void)
{
    LOG_INF("Entering sleep mode");

    // 睡眠 5 秒（系统会自动选择合适的睡眠模式）
    k_sleep(K_SECONDS(5));

    LOG_INF("Woke up from sleep");
}

#include <zephyr/drivers/gpio.h>
#include <zephyr/pm/pm.h>
#include <zephyr/logging/log.h>

LOG_MODULE_REGISTER(wakeup_example, LOG_LEVEL_INF);

static const struct gpio_dt_spec button = GPIO_DT_SPEC_GET(DT_ALIAS(sw0), gpios);
static struct gpio_callback button_cb_data;

void button_pressed(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
{
    LOG_INF("Button pressed - woke up from sleep");
}

void wakeup_source_setup(void)
{
    if (!device_is_ready(button.port)) {
        LOG_ERR("Button device not ready");
        return;
    }

    // 配置按钮为输入，带上拉
    gpio_pin_configure_dt(&button, GPIO_INPUT);

    // 配置中断（下降沿触发）
    gpio_pin_interrupt_configure_dt(&button, GPIO_INT_EDGE_TO_ACTIVE);

    // 注册中断回调
    gpio_init_callback(&button_cb_data, button_pressed, BIT(button.pin));
    gpio_add_callback(button.port, &button_cb_data);

    LOG_INF("Wakeup source configured");
}

#include <zephyr/pm/pm.h>
#include <zephyr/logging/log.h>

LOG_MODULE_REGISTER(power_stats, LOG_LEVEL_INF);

void print_power_stats(void)
{
    // 获取电源管理统计信息
    struct pm_state_info info;

    for (int i = 0; i < PM_STATE_COUNT; i++) {
        if (pm_state_get(i, &info)) {
            LOG_INF("State %d: min_residency=%u, exit_latency=%u",
                    i, info.min_residency_us, info.exit_latency_us);
        }
    }
}

#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/pm/pm.h>
#include <zephyr/pm/device.h>
#include <zephyr/fs/nvs.h>
#include <zephyr/logging/log.h>

LOG_MODULE_REGISTER(low_power_app, LOG_LEVEL_INF);

// 采集间隔（秒）
#define SAMPLE_INTERVAL 60

// NVS 实例
static struct nvs_fs fs;

void sensor_sample_and_store(void)
{
    const struct device *sensor = DEVICE_DT_GET(DT_NODELABEL(sensor0));
    struct sensor_value temp;

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

    // 读取传感器数据
    sensor_sample_fetch(sensor);
    sensor_channel_get(sensor, SENSOR_CHAN_AMBIENT_TEMP, &temp);

    LOG_INF("Temperature: %d.%06d C", temp.val1, temp.val2);

    // 存储数据到 NVS
    uint32_t timestamp = k_uptime_get_32();
    nvs_write(&fs, timestamp, &temp, sizeof(temp));

    // 挂起传感器
    pm_device_action_run(sensor, PM_DEVICE_ACTION_SUSPEND);
}

int main(void)
{
    LOG_INF("Low power data logger started");

    // 初始化 NVS
    // ... NVS 初始化代码 ...

    while (1) {
        // 采集和存储数据
        sensor_sample_and_store();

        // 进入睡眠模式
        LOG_INF("Entering sleep for %d seconds", SAMPLE_INTERVAL);
        k_sleep(K_SECONDS(SAMPLE_INTERVAL));
    }

    return 0;
}

#include <zephyr/kernel.h>
#include <zephyr/shell/shell.h>
#include <zephyr/logging/log.h>

LOG_MODULE_REGISTER(main, LOG_LEVEL_INF);

// 模拟传感器模块
LOG_MODULE_DECLARE(sensor, LOG_LEVEL_DBG);

// 传感器读取函数
void sensor_read(void)
{
    LOG_DBG("Reading sensor...");
    int value = 25;
    LOG_INF("Sensor value: %d", value);
}

// Shell 命令：读取传感器
static int cmd_sensor_read(const struct shell *sh, size_t argc, char **argv)
{
    sensor_read();
    return 0;
}

// Shell 命令：设置日志级别
static int cmd_log_level(const struct shell *sh, size_t argc, char **argv)
{
    if (argc < 3) {
        shell_error(sh, "Usage: loglevel <module> <level>");
        shell_print(sh, "Levels: 0=OFF, 1=ERR, 2=WRN, 3=INF, 4=DBG");
        return -EINVAL;
    }

    const char *module = argv[1];
    int level = atoi(argv[2]);

    shell_print(sh, "Setting %s log level to %d", module, level);

    // 这里简化处理，实际应该使用 log_filter_set()
    return 0;
}

SHELL_STATIC_SUBCMD_SET_CREATE(sub_app,
    SHELL_CMD(sensor, NULL, "Read sensor", cmd_sensor_read),
    SHELL_CMD(loglevel, NULL, "Set log level", cmd_log_level),
    SHELL_SUBCMD_SET_END
);

SHELL_CMD_REGISTER(app, &sub_app, "Application commands", NULL);

int main(void)
{
    LOG_INF("Application started");

    while (1) {
        sensor_read();
        k_sleep(K_SECONDS(5));
    }

    return 0;
}

#include <zephyr/kernel.h>
#include <zephyr/fs/nvs.h>
#include <zephyr/storage/flash_map.h>
#include <zephyr/logging/log.h>

LOG_MODULE_REGISTER(calibration, LOG_LEVEL_INF);

static struct nvs_fs fs;

#define NVS_ID_CAL_OFFSET  1
#define NVS_ID_CAL_SCALE   2

typedef struct {
    float offset;
    float scale;
} sensor_calibration_t;

int calibration_init(void)
{
    int rc;
    const struct flash_area *fa;

    rc = flash_area_open(FLASH_AREA_ID(storage), &fa);
    if (rc != 0) {
        LOG_ERR("Failed to open flash area: %d", rc);
        return rc;
    }

    fs.flash_device = fa->fa_dev;
    fs.offset = fa->fa_off;
    fs.sector_size = 4096;
    fs.sector_count = fa->fa_size / fs.sector_size;

    rc = nvs_mount(&fs);
    if (rc != 0) {
        LOG_ERR("Failed to mount NVS: %d", rc);
        flash_area_close(fa);
        return rc;
    }

    LOG_INF("NVS initialized");
    flash_area_close(fa);
    return 0;
}

int calibration_save(sensor_calibration_t *cal)
{
    int rc;

    rc = nvs_write(&fs, NVS_ID_CAL_OFFSET, &cal->offset, sizeof(cal->offset));
    if (rc < 0) {
        LOG_ERR("Failed to write offset: %d", rc);
        return rc;
    }

    rc = nvs_write(&fs, NVS_ID_CAL_SCALE, &cal->scale, sizeof(cal->scale));
    if (rc < 0) {
        LOG_ERR("Failed to write scale: %d", rc);
        return rc;
    }

    LOG_INF("Calibration saved: offset=%.2f, scale=%.2f", cal->offset, cal->scale);
    return 0;
}

int calibration_load(sensor_calibration_t *cal)
{
    int rc;

    rc = nvs_read(&fs, NVS_ID_CAL_OFFSET, &cal->offset, sizeof(cal->offset));
    if (rc < 0) {
        LOG_WRN("Failed to read offset, using default");
        cal->offset = 0.0f;
    }

    rc = nvs_read(&fs, NVS_ID_CAL_SCALE, &cal->scale, sizeof(cal->scale));
    if (rc < 0) {
        LOG_WRN("Failed to read scale, using default");
        cal->scale = 1.0f;
    }

    LOG_INF("Calibration loaded: offset=%.2f, scale=%.2f", cal->offset, cal->scale);
    return 0;
}

int main(void)
{
    sensor_calibration_t cal;

    LOG_INF("Calibration example started");

    // 初始化 NVS
    if (calibration_init() != 0) {
        LOG_ERR("Failed to initialize calibration");
        return -1;
    }

    // 加载校准参数
    calibration_load(&cal);

    // 模拟校准过程
    LOG_INF("Performing calibration...");
    k_sleep(K_SECONDS(2));

    cal.offset = 1.5f;
    cal.scale = 0.98f;

    // 保存校准参数
    calibration_save(&cal);

    // 验证：重新加载
    sensor_calibration_t cal_verify;
    calibration_load(&cal_verify);

    if (cal_verify.offset == cal.offset && cal_verify.scale == cal.scale) {
        LOG_INF("Calibration verified successfully");
    } else {
        LOG_ERR("Calibration verification failed");
    }

    return 0;
}

#include <zephyr/kernel.h>
#include <zephyr/pm/pm.h>
#include <zephyr/pm/device.h>
#include <zephyr/fs/nvs.h>
#include <zephyr/storage/flash_map.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>

LOG_MODULE_REGISTER(low_power_logger, LOG_LEVEL_INF);

// 采集间隔（秒）
#define SAMPLE_INTERVAL 10

// NVS 实例
static struct nvs_fs fs;

// 按钮配置（用于唤醒）
static const struct gpio_dt_spec button = GPIO_DT_SPEC_GET_OR(DT_ALIAS(sw0), gpios, {0});
static struct gpio_callback button_cb_data;

// 数据结构
typedef struct {
    uint32_t timestamp;
    int16_t temperature;
    uint16_t humidity;
} sensor_data_t;

// 按钮中断回调
void button_pressed(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
{
    LOG_INF("Button pressed - manual wakeup");
}

int nvs_init(void)
{
    int rc;
    const struct flash_area *fa;

    rc = flash_area_open(FLASH_AREA_ID(storage), &fa);
    if (rc != 0) {
        return rc;
    }

    fs.flash_device = fa->fa_dev;
    fs.offset = fa->fa_off;
    fs.sector_size = 4096;
    fs.sector_count = fa->fa_size / fs.sector_size;

    rc = nvs_mount(&fs);
    flash_area_close(fa);

    return rc;
}

void sensor_sample(sensor_data_t *data)
{
    // 模拟传感器读取
    data->timestamp = k_uptime_get_32();
    data->temperature = 2500;  // 25.00°C
    data->humidity = 6500;     // 65.00%

    LOG_INF("Sampled: T=%d.%02d°C, H=%d.%02d%%",
            data->temperature / 100, data->temperature % 100,
            data->humidity / 100, data->humidity % 100);
}

void data_store(sensor_data_t *data)
{
    static uint16_t data_id = 100;

    int rc = nvs_write(&fs, data_id++, data, sizeof(sensor_data_t));
    if (rc < 0) {
        LOG_ERR("Failed to store data: %d", rc);
    } else {
        LOG_INF("Data stored with ID: %d", data_id - 1);
    }
}

void wakeup_source_init(void)
{
    if (!device_is_ready(button.port)) {
        LOG_WRN("Button not available");
        return;
    }

    gpio_pin_configure_dt(&button, GPIO_INPUT);
    gpio_pin_interrupt_configure_dt(&button, GPIO_INT_EDGE_TO_ACTIVE);
    gpio_init_callback(&button_cb_data, button_pressed, BIT(button.pin));
    gpio_add_callback(button.port, &button_cb_data);

    LOG_INF("Wakeup source configured");
}

int main(void)
{
    sensor_data_t data;
    int sample_count = 0;

    LOG_INF("Low power data logger started");

    // 初始化 NVS
    if (nvs_init() != 0) {
        LOG_ERR("Failed to initialize NVS");
        return -1;
    }
    LOG_INF("NVS initialized");

    // 配置唤醒源
    wakeup_source_init();

    while (1) {
        // 采集数据
        sensor_sample(&data);

        // 存储数据
        data_store(&data);

        sample_count++;
        LOG_INF("Sample count: %d", sample_count);

        // 进入睡眠模式
        LOG_INF("Entering sleep for %d seconds...", SAMPLE_INTERVAL);

        // 刷新日志缓冲区（异步日志模式）
        k_sleep(K_MSEC(100));

        // 睡眠
        k_sleep(K_SECONDS(SAMPLE_INTERVAL));

        LOG_INF("Woke up from sleep");
    }

    return 0;
}