/*
 * 原生 C 模块计算 1000 位圆周率（Rabinowitz-Wagon spigot 算法）
 *
 * 计时用 esp_timer_get_time()（微秒），仅包裹纯计算主循环。
 */

#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#include "esp_log.h"
#include "esp_timer.h"

static const char *TAG = "pi1000_c";

/* Rabinowitz-Wagon spigot：逐位生成 pi 的数字（res[0] = 整数位 3） */
static uint32_t pi_digits(uint32_t n, uint8_t *res)
{
    uint32_t len = 10 * n / 3;
    uint32_t *a = (uint32_t *)malloc(len * sizeof(uint32_t));
    if (!a)
        return 0;
    for (uint32_t i = 0; i < len; i++)
        a[i] = 2;

    uint32_t nines = 0, predigit = 0;
    uint32_t r = 0;

    for (uint32_t j = 1; j <= n; j++) {
        uint32_t q = 0;
        for (uint32_t i = len; i >= 1; i--) {
            uint32_t x = 10 * a[i - 1] + q * i;
            uint32_t d = 2 * i - 1;
            a[i - 1] = x % d;
            q = x / d;
        }
        a[0] = q % 10;
        q = q / 10;

        if (q == 9) {
            nines++;
        } else if (q == 10) {
            res[r++] = (uint8_t)(predigit + 1);
            for (uint32_t k = 0; k < nines; k++)
                res[r++] = 0;
            predigit = 0;
            nines = 0;
        } else {
            if (j > 1)
                res[r++] = (uint8_t)predigit;
            predigit = q;
            if (nines > 0) {
                for (uint32_t k = 0; k < nines; k++)
                    res[r++] = 9;
                nines = 0;
            }
        }
    }
    res[r++] = (uint8_t)predigit;
    free(a);
    return r;
}

__attribute__((visibility("default")))
void app_main(void)
{
    const uint32_t DIGITS = 1000;

    /* 多算 3 个，截断取前 1000 位 */
    const uint32_t N = DIGITS + 3;
    uint8_t *digits = (uint8_t *)malloc((N + 8) * sizeof(uint8_t));

    int64_t t0 = esp_timer_get_time();
    uint32_t nd = pi_digits(N, digits);
    int64_t dt = esp_timer_get_time() - t0;

    if (!digits || nd < DIGITS + 1) {
        ESP_LOGE(TAG, "pi1000_c: failed (nd=%u)", nd);
        free(digits);
        return;
    }

    /* 拼接：整数位 3 + 1000 位小数（digits[0] = 3） */
    char *pi = (char *)malloc(DIGITS + 8);
    if (pi) {
        int o = 0;
        pi[o++] = '3';
        pi[o++] = '.';
        for (uint32_t i = 1; i <= DIGITS; i++)
            pi[o++] = (char)('0' + digits[i]);
        pi[o] = '\0';
        ESP_LOGI(TAG, "%s", pi);
        free(pi);
    }

    ESP_LOGI(TAG, "pi1000_c: %u digits in %lld ms", DIGITS, (long long)(dt / 1000));
    ESP_LOGI(TAG, "pi1000_c: done");

    free(digits);
}

//! wasm 应用计算 1000 位圆周率（Rabinowitz-Wagon spigot 算法）
//!
//! 计时用宿主提供的 bs_uptime（微秒），仅包裹纯计算主循环。

#![no_std]
#![no_main]

extern crate alloc;

use alloc::{format, string::String, vec, vec::Vec};
use core::panic::PanicInfo;

/* ---------------- 宿主 import（env 模块） ---------------- */
extern "C" {
    fn bs_log(json: *const u8, len: i32) -> i32;
    fn bs_result_len(id: i32) -> i32;
    fn bs_result_copy(id: i32, out: *mut u8, len: i32) -> i32;
    fn bs_result_free(id: i32);
    fn bs_delay_ms(ms: i32);
    fn bs_should_stop() -> i32;
    fn bs_uptime(j: *const u8, l: i32) -> i32;

    fn malloc(size: usize) -> *mut u8;
    fn free(p: *mut u8);
}

/* ---------------- 分配器：接宿主堆 ---------------- */
struct HostAlloc;
unsafe impl core::alloc::GlobalAlloc for HostAlloc {
    unsafe fn alloc(&self, layout: core::alloc::Layout) -> *mut u8 {
        malloc(layout.size())
    }
    unsafe fn dealloc(&self, ptr: *mut u8, _: core::alloc::Layout) {
        free(ptr)
    }
}

#[global_allocator]
static HOST_ALLOC: HostAlloc = HostAlloc;

/* ---------------- 工具 ---------------- */
fn log_msg(msg: &str) {
    let mut esc = String::with_capacity(msg.len() + 8);
    for c in msg.chars() {
        if c == '"' || c == '\\' {
            esc.push('\\');
        }
        esc.push(c);
    }
    let json = format!("{{\"level\":\"i\",\"tag\":\"pi1000_rust\",\"msg\":\"{}\"}}", esc);
    unsafe {
        let id = bs_log(json.as_ptr(), json.len() as i32);
        bs_result_free(id);
    }
}

/// 调 bs_uptime 返回开机微秒数（解析 {"ok":true,"us":N}）。
unsafe fn uptime_us() -> u64 {
    let id = bs_uptime(b"{}".as_ptr(), 2);
    if id < 0 {
        return 0;
    }
    let n = bs_result_len(id);
    let mut buf = vec![0u8; n.max(0) as usize];
    if n > 0 {
        bs_result_copy(id, buf.as_mut_ptr(), n);
    }
    bs_result_free(id);
    let s = core::str::from_utf8(&buf).unwrap_or("");
    let key = "\"us\":";
    if let Some(i) = s.find(key) {
        let rest = &s[i + key.len()..];
        let digits: String = rest
            .chars()
            .take_while(|c| c.is_ascii_digit())
            .collect();
        if let Ok(v) = digits.parse() {
            return v;
        }
    }
    0
}

/* ---------------- spigot 算法 ---------------- */

/// 生成 pi 的数字序列（res[0] = 整数位 3，res[1..] = 小数位）。
fn pi_digits(n: usize) -> Vec<u8> {
    let len = 10 * n / 3;
    let mut a = vec![2u32; len];
    let mut nines: u32 = 0;
    let mut predigit: u32 = 0;
    let mut res = Vec::with_capacity(n);

    for j in 1..=n {
        let mut q: u32 = 0;
        let mut i = len;
        while i >= 1 {
            let x = 10 * a[i - 1] + q * (i as u32);
            let d = (2 * i - 1) as u32;
            a[i - 1] = x % d;
            q = x / d;
            i -= 1;
        }
        a[0] = q % 10;
        q = q / 10;

        if q == 9 {
            nines += 1;
        } else if q == 10 {
            res.push((predigit + 1) as u8);
            for _ in 0..nines {
                res.push(0);
            }
            predigit = 0;
            nines = 0;
        } else {
            if j > 1 {
                res.push(predigit as u8);
            }
            predigit = q;
            if nines > 0 {
                for _ in 0..nines {
                    res.push(9);
                }
                nines = 0;
            }
        }
    }
    res.push(predigit as u8);
    res
}

/* ---------------- main ---------------- */

#[no_mangle]
pub extern "C" fn main() -> i32 {
    const DIGITS: usize = 1000;

    unsafe {
        let t0 = uptime_us();
        let digits = pi_digits(DIGITS + 3); // 多算几个，截断取前 1000 位
        let dt = uptime_us() - t0;

        // 拼接：整数位 3 + 1000 位小数（digits[0] = 3）
        let mut pi = String::with_capacity(DIGITS + 2);
        pi.push_str("3.");
        for i in 1..=DIGITS {
            pi.push((b'0' + digits[i]) as char);
        }
        log_msg(&pi);
        log_msg(&format!("pi1000_rust: {} digits in {} ms", DIGITS, dt / 1000));
    }

    log_msg("pi1000_rust: done");
    0
}

#[panic_handler]
fn panic(_: &PanicInfo) -> ! {
    core::arch::wasm32::unreachable()
}

-- 计算 1000 位圆周率（Rabinowitz-Wagon spigot 算法）
-- 参考 Simeon Simeonov 的 Pascal 原版（pi_spigot），本机已与权威前 100 位核对。

local sys = require("sys")

local DIGITS = 1000

-- Rabinowitz-Wagon spigot：逐位生成 pi 的数字（含整数位 3 在最前）。
local function pi_spigot(n)
    local len = math.floor(10 * n / 3)
    local a = {}
    for i = 1, len do a[i] = 2 end
    local nines, predigit = 0, 0
    local res = {}
    for j = 1, n do
        local q = 0
        for i = len, 1, -1 do
            local x = 10 * a[i] + q * i
            local d = 2 * i - 1
            a[i] = x % d
            q = math.floor(x / d)
        end
        a[1] = q % 10
        q = math.floor(q / 10)
        if q == 9 then
            nines = nines + 1
        elseif q == 10 then
            res[#res + 1] = predigit + 1
            for _ = 1, nines do res[#res + 1] = 0 end
            predigit, nines = 0, 0
        else
            if j > 1 then res[#res + 1] = predigit end
            predigit = q
            if nines > 0 then
                for _ = 1, nines do res[#res + 1] = 9 end
                nines = 0
            end
        end
    end
    res[#res + 1] = predigit
    return res
end

-- 计算 + 计时（多算几个，截断取前 DIGITS 位，避免 9 传播导致少位）
local t0 = sys.millis()
local digits = pi_spigot(DIGITS + 3)
local dt = sys.millis() - t0

-- 拼接输出：整数位 3 + DIGITS 位小数（res[1] = 整数位 3）
local pi = "3."
for i = 2, DIGITS + 1 do
    pi = pi .. tostring(digits[i])
end

print("pi1000_lua: " .. pi)
print(string.format("pi1000_lua: %d digits in %d ms", DIGITS, dt))
print("pi1000_lua: done")

-- 计算 1000 位圆周率（Rabinowitz-Wagon spigot 算法）
-- 参考 Simeon Simeonov 的 Pascal 原版（pi_spigot），本机已与权威前 100 位核对。

local sys = require("sys")

local DIGITS = 1000

-- Rabinowitz-Wagon spigot：逐位生成 pi 的数字（含整数位 3 在最前）。
local function pi_spigot(n)
    local len = (10 * n) // 3          -- 整数整除（不超 int32）
    local a = {}
    for i = 1, len do a[i] = 2 end
    local nines, predigit = 0, 0
    local res = {}
    local r = 0                         -- 本地计数器替代 #res + 1
    for j = 1, n do
        local q = 0
        for i = len, 1, -1 do
            local x = 10 * a[i] + q * i -- 全整数，int32 内安全
            local d = 2 * i - 1
            a[i] = x % d                -- 整数取模
            q = x // d                  -- 整数整除（OP_IDIV）
        end
        a[1] = q % 10
        q = q // 10
        if q == 9 then
            nines = nines + 1
        elseif q == 10 then
            r = r + 1; res[r] = predigit + 1
            for _ = 1, nines do r = r + 1; res[r] = 0 end
            predigit, nines = 0, 0
        else
            if j > 1 then r = r + 1; res[r] = predigit end
            predigit = q
            if nines > 0 then
                for _ = 1, nines do r = r + 1; res[r] = 9 end
                nines = 0
            end
        end
    end
    r = r + 1; res[r] = predigit
    return res
end

-- 计算 + 计时（多算几个，截断取前 DIGITS 位，避免 9 传播导致少位）
local t0 = sys.millis()
local digits = pi_spigot(DIGITS + 3)
local dt = sys.millis() - t0

-- 拼接输出：整数位 3 + DIGITS 位小数（res[1] = 整数位 3）
local pi = "3."
for i = 2, DIGITS + 1 do
    pi = pi .. tostring(digits[i])
end

print("pi1000_lua: " .. pi)
print(string.format("pi1000_lua: %d digits in %d ms", DIGITS, dt))
print("pi1000_lua: done")

# MicroPython 计算 1000 位圆周率（Rabinowitz-Wagon spigot 算法）
# 计时用 time.ticks_ms()，仅包裹纯计算主循环。

import time as _t

DIGITS = 1000

def pi_spigot(n):
    LEN = (10 * n) // 3          # 整数整除
    a = [2] * LEN                # 预分配列表
    nines = 0
    predigit = 0
    res = []
    for j in range(1, n + 1):
        q = 0
        for i in range(LEN, 0, -1):
            x = 10 * a[i - 1] + q * i
            d = 2 * i - 1
            a[i - 1] = x % d
            q = x // d
        a[0] = q % 10
        q = q // 10
        if q == 9:
            nines += 1
        elif q == 10:
            res.append(predigit + 1)
            res.extend([0] * nines)
            predigit = 0
            nines = 0
        else:
            if j > 1:
                res.append(predigit)
            predigit = q
            if nines > 0:
                res.extend([9] * nines)
                nines = 0
    res.append(predigit)
    return res

t0 = _t.ticks_ms()
digits = pi_spigot(DIGITS + 3)
dt = _t.ticks_diff(_t.ticks_ms(), t0)
pi = "3." + "".join(str(d) for d in digits[1:DIGITS + 1])
print("pi1000_py: " + pi)
print("pi1000_py: %d digits in %d ms" % (DIGITS, dt))
print("pi1000_py: done")

// 1. 接口与实现分离（头文件定义接口）
// sensor_interface.h
#ifndef SENSOR_INTERFACE_H
#define SENSOR_INTERFACE_H

typedef struct {
    int (*init)(void);
    int (*read)(float *value);
    int (*calibrate)(void);
} sensor_ops_t;

// 外部声明具体实现
extern sensor_ops_t dht22_ops;
extern sensor_ops_t bmp280_ops;

#endif

// 2. 依赖注入（便于测试和替换）
// main.c
void sensor_task(void *pvParameters) {
    // 通过指针传入具体实现，而非硬编码
    sensor_ops_t *sensor = &dht22_ops;  // 可轻松切换为 bmp280_ops
    
    sensor->init();
    
    while (1) {
        float value;
        if (sensor->read(&value) == 0) {
            publish_data(value);
        }
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

// 3. 配置与代码分离
// config.h
#define CONFIG_MQTT_BROKER      "mqtt.example.com"
#define CONFIG_MQTT_PORT        1883
#define CONFIG_MQTT_KEEPALIVE   60
#define CONFIG_WIFI_SSID        "MyNetwork"
#define CONFIG_WIFI_PASSWORD    "SecretPassword"

// Flash 分区表示例（ESP32 风格）
// 假设 Flash 总大小 4MB

typedef struct {
    uint32_t magic;         // 分区表魔数
    uint32_t version;       // 分区表版本
    uint32_t ota_seq;       // OTA 序列号（判断哪个分区是活动的）
    uint8_t  ota_data[32];  // OTA 状态数据
    uint32_t crc;           // CRC32 校验
} ota_data_t;

// 分区布局
// 0x0000 - 0x1000:   引导加载程序（Bootloader）
// 0x1000 - 0x2000:   分区表
// 0x2000 - 0x3000:   OTA 数据（ota_data）
// 0x3000 - 0x100000: 应用 A 区（约 988KB）
// 0x100000 - 0x1FD000: 应用 B 区（约 988KB）
// 0x1FD000 - 0x200000: NVS（非易失存储）

// OTA 升级流程
typedef enum {
    OTA_STATE_IDLE,
    OTA_STATE_DOWNLOADING,
    OTA_STATE_VERIFYING,
    OTA_STATE_FLASHING,
    OTA_STATE_VALIDATED,
    OTA_STATE_INVALID
} ota_state_t;

ota_state_t current_ota_state = OTA_STATE_IDLE;

// OTA 任务
void ota_task(void *pvParameters) {
    while (1) {
        // 1. 检查是否有新版本
        if (check_new_firmware_version()) {
            current_ota_state = OTA_STATE_DOWNLOADING;
            
            // 2. 下载新固件到非活动分区
            uint32_t inactive_partition = get_inactive_partition();
            int ret = download_firmware(inactive_partition);
            
            if (ret == 0) {
                current_ota_state = OTA_STATE_VERIFYING;
                
                // 3. 验证签名
                if (verify_firmware_signature(inactive_partition)) {
                    current_ota_state = OTA_STATE_VALIDATED;
                    
                    // 4. 更新 OTA 数据，标记下次从新分区启动
                    set_next_boot_partition(inactive_partition);
                    
                    // 5. 重启
                    esp_restart();
                } else {
                    current_ota_state = OTA_STATE_INVALID;
                    report_error("Signature verification failed");
                }
            } else {
                current_ota_state = OTA_STATE_IDLE;
                report_error("Download failed");
            }
        }
        
        // 每 6 小时检查一次
        vTaskDelay(pdMS_TO_TICKS(6 * 60 * 60 * 1000));
    }
}

// 完整的 OTA 升级流程（包含安全验证）
#include <mbedtls/sha256.h>
#include <mbedtls/pk.h>

typedef struct {
    uint32_t magic;             // 魔数：0xABCDEF00
    uint32_t version;           // 固件版本号
    uint32_t timestamp;         // 编译时间戳
    uint32_t image_size;        // 固件大小
    uint8_t  image_hash[32];    // SHA-256 哈希
    uint8_t  signature[64];     // ECDSA 签名
} firmware_header_t;

int perform_ota_update(const char *firmware_url) {
    firmware_header_t header;
    uint8_t download_buffer[4096];
    uint32_t total_downloaded = 0;
    
    // 1. 下载并解析头部
    int ret = http_download_range(firmware_url, 0, sizeof(header), &header);
    if (ret != 0) {
        ESP_LOGE("OTA", "Failed to download header");
        return -1;
    }
    
    // 2. 验证魔数
    if (header.magic != 0xABCDEF00) {
        ESP_LOGE("OTA", "Invalid firmware magic");
        return -2;
    }
    
    // 3. 验证签名（使用固化在设备中的公钥）
    ret = verify_signature_with_public_key(
        &header,
        header.signature,
        sizeof(header.signature),
        g_device_public_key
    );
    
    if (ret != 0) {
        ESP_LOGE("OTA", "Signature verification failed");
        return -3;
    }
    
    // 4. 擦除目标分区
    uint32_t target_partition = get_inactive_partition();
    spi_flash_erase_range(target_partition, header.image_size);
    
    // 5. 下载固件主体并写入 Flash
    ESP_LOGI("OTA", "Downloading firmware...");
    uint32_t offset = sizeof(header);
    
    while (total_downloaded < header.image_size) {
        uint32_t chunk_size = MIN(sizeof(download_buffer), header.image_size - total_downloaded);
        
        ret = http_download_range(firmware_url, offset, chunk_size, download_buffer);
        if (ret != 0) {
            ESP_LOGE("OTA", "Download failed at offset %lu", offset);
            return -4;
        }
        
        // 写入 Flash
        spi_flash_write(target_partition + offset, download_buffer, chunk_size);
        
        offset += chunk_size;
        total_downloaded += chunk_size;
        
        // 报告进度
        int progress = (total_downloaded * 100) / header.image_size;
        ESP_LOGI("OTA", "Progress: %d%%", progress);
        report_ota_progress(progress);
    }
    
    // 6. 验证下载的哈希
    uint8_t calculated_hash[32];
    calculate_flash_hash(target_partition, header.image_size, calculated_hash);
    
    if (memcmp(calculated_hash, header.image_hash, 32) != 0) {
        ESP_LOGE("OTA", "Hash verification failed");
        return -5;
    }
    
    // 7. 设置下次启动分区
    set_next_boot_partition(target_partition);
    
    ESP_LOGI("OTA", "OTA update successful, rebooting...");
    
    // 8. 重启
    vTaskDelay(pdMS_TO_TICKS(1000));  // 等待日志输出
    esp_restart();
    
    return 0;
}

// 回滚机制：如果新固件启动失败，自动回滚到旧版本
void app_main(void) {
    // 检查启动原因
    esp_reset_reason_t reset_reason = esp_reset_reason();
    
    if (reset_reason == ESP_RST_PANIC || reset_reason == ESP_RST_INT_WDT) {
        // 异常重启，可能是新固件有问题
        ESP_LOGE("BOOT", "Abnormal reset detected, rolling back...");
        
        // 回滚到之前的分区
        rollback_to_previous_partition();
    }
    
    // 标记当前分区为有效（看门狗机制）
    mark_current_partition_valid();
    
    // 正常运行
    run_application();
}

// ESP32 DVFS 配置
#include "esp_pm.h"

void configure_dvfs(void) {
    esp_pm_config_esp32_t pm_config = {
        .max_freq_mhz = 240,      // 最大频率
        .min_freq_mhz = 80,       // 最小频率
        .light_sleep_enable = true  // 启用 Light Sleep
    };
    
    esp_pm_configure(&pm_config);
}

// 根据负载动态调整频率
void adjust_frequency_based_on_load(void) {
    static uint32_t idle_count = 0;
    
    if (is_system_idle()) {
        idle_count++;
        
        if (idle_count > 100) {
            // 空闲时间长，降低频率
            esp_pm_cpu_freq_set(ESP_PM_CPU_FREQ_MAX_80M);
        }
    } else {
        idle_count = 0;
        
        // 有任务，提升频率
        esp_pm_cpu_freq_set(ESP_PM_CPU_FREQ_MAX_240M);
    }
}

// STM32 深度睡眠配置
#include <stm32l4xx_hal.h>

void enter_deep_sleep(uint32_t wake_time_ms) {
    // 1. 配置唤醒源（RTC、外部中断等）
    RTC_HandleTypeDef hrtc;
    
    // 配置 RTC 唤醒定时器
    hrtc.Instance = RTC;
    HAL_RTCEx_SetWakeUpTimer(&hrtc, wake_time_ms / 1000, RTC_WAKEUPCLOCK_CK_SPRE_16BITS);
    
    // 2. 配置 GPIO 为低功耗模式
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    
    // 所有未使用引脚设为模拟输入（最低功耗）
    for (int i = 0; i < 16; i++) {
        if (!is_pin_used(i)) {
            GPIO_InitStruct.Pin = (1 << i);
            GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
            GPIO_InitStruct.Pull = GPIO_NOPULL;
            HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
        }
    }
    
    // 3. 关闭未使用外设时钟
    __HAL_RCC_USART2_CLK_DISABLE();
    __HAL_RCC_SPI2_CLK_DISABLE();
    __HAL_RCC_I2C1_CLK_DISABLE();
    __HAL_RCC_ADC_CLK_DISABLE();
    
    // 4. 禁用 SysTick 中断（睡眠期间不需要）
    SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk;
    
    // 5. 进入 STOP2 模式（最低功耗，保留 SRAM 内容）
    HAL_PWREx_EnterSTOP2Mode(PWR_STOPENTRY_LOWPOWER);
    
    // 唤醒后从这里继续执行
    // 6. 恢复系统时钟
    SystemClock_Config();
    
    // 7. 恢复外设时钟
    __HAL_RCC_USART2_CLK_ENABLE();
    __HAL_RCC_SPI2_CLK_ENABLE();
    
    // 8. 重新配置 GPIO
    gpio_init_all();
    
    // 9. 清除唤醒标志
    __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
}

// 电池供电设备的功耗优化任务
void power_management_task(void *pvParameters) {
    uint32_t battery_voltage;
    
    while (1) {
        // 读取电池电压
        battery_voltage = read_battery_voltage();
        
        if (battery_voltage < 3300) {  // 低于 3.3V
            // 进入省电模式
            enter_power_saving_mode();
        } else if (battery_voltage < 3000) {  // 低于 3.0V
            // 紧急模式：只保留基本功能
            enter_emergency_mode();
        } else {
            // 正常模式
            enter_normal_mode();
        }
        
        // 每 5 分钟检查一次
        vTaskDelay(pdMS_TO_TICKS(5 * 60 * 1000));
    }
}

// WiFi 功耗优化（ESP32）
#include "esp_wifi.h"

void configure_wifi_power_save(void) {
    // 启用 WiFi 节能模式
    esp_wifi_set_ps(WIFI_PS_MAX_MODEM);
    
    // 配置 DTIM 监听间隔（越大越省电，但延迟越高）
    // DTIM = 3 表示每 3 个信标帧唤醒一次
    wifi_ps_type_t ps_type = WIFI_PS_MAX_MODEM;
    esp_wifi_set_ps(ps_type);
}

// BLE 广播功耗优化
#include "nimble/nimble_port.h"

void configure_ble_advertising(void) {
    // 配置广播参数
    struct ble_gap_adv_params adv_params;
    
    adv_params.conn_mode = BLE_GAP_CONN_MODE_NON;  // 不可连接
    adv_params.disc_mode = BLE_GAP_DISC_MODE_GEN;  // 可发现
    adv_params.itvl_min = 0x0640;  // 1 秒（0x0640 = 1000ms）
    adv_params.itvl_max = 0x0C80;  // 2 秒
    
    // 较长的广播间隔 = 更低的功耗
    ble_gap_adv_start(OWN_ADDR_TYPE_PUBLIC, NULL, BLE_HS_FOREVER,
                      &adv_params, NULL, NULL);
}

// MQTT 客户端实现（使用 Paho MQTT）
#include <MQTTClient.h>

// MQTT 配置
typedef struct {
    const char *broker_url;
    uint16_t port;
    const char *client_id;
    const char *username;
    const char *password;
    const char *publish_topic;
    const char *subscribe_topic;
    uint16_t keepalive;
    bool clean_session;
} mqtt_config_t;

// 全局 MQTT 客户端
static MQTTClient client;
static mqtt_config_t config = {
    .broker_url = "mqtt.example.com",
    .port = 1883,
    .client_id = "iot_device_001",
    .username = "device_user",
    .password = "device_pass",
    .publish_topic = "devices/001/data",
    .subscribe_topic = "devices/001/command",
    .keepalive = 60,
    .clean_session = false
};

// 连接回调
void on_connected(void *context) {
    ESP_LOGI("MQTT", "Connected to broker");
    
    // 订阅命令主题
    MQTTClient_subscribe(client, config.subscribe_topic, 1);
    
    // 发布上线消息
    MQTTClient_publish(client, "devices/001/status", 
                       strlen("online"), "online", 1, 0, NULL);
}

// 消息到达回调
void on_message_arrived(void *context, char *topicName, int topicLen, 
                        MQTTClient_message *message) {
    ESP_LOGI("MQTT", "Message arrived on topic %s", topicName);
    
    // 处理命令
    handle_command(message->payload, message->payloadlen);
    
    MQTTClient_freeMessage(&message);
    MQTTClient_free(topicName);
}

// 连接丢失回调
void on_connection_lost(void *context, char *cause) {
    ESP_LOGW("MQTT", "Connection lost: %s", cause);
    
    // 自动重连
    MQTTClient_reconnect(client, 5000);
}

// MQTT 初始化
int mqtt_init(void) {
    MQTTClient_create(&client, config.broker_url, config.client_id,
                      MQTTCLIENT_PERSISTENCE_NONE, NULL);
    
    MQTTClient_callbacks callbacks = {
        .on_connect = on_connected,
        .on_message = on_message_arrived,
        .on_connection_lost = on_connection_lost
    };
    
    MQTTClient_setCallbacks(client, NULL, &callbacks);
    
    MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
    conn_opts.keepAliveInterval = config.keepalive;
    conn_opts.cleansession = config.clean_session;
    conn_opts.username = config.username;
    conn_opts.password = config.password;
    conn_opts.automaticReconnect = 1;
    
    int rc = MQTTClient_connect(client, &conn_opts);
    if (rc != MQTTCLIENT_SUCCESS) {
        ESP_LOGE("MQTT", "Failed to connect: %d", rc);
        return -1;
    }
    
    return 0;
}

// 发布数据
int mqtt_publish_data(const uint8_t *data, size_t len) {
    MQTTClient_message pubmsg = MQTTClient_message_initializer;
    pubmsg.payload = (void *)data;
    pubmsg.payloadlen = len;
    pubmsg.qos = 1;  // QoS 1：至少送达一次
    pubmsg.retained = 0;
    
    return MQTTClient_publish(client, config.publish_topic, 
                              len, data, 1, 0, NULL);
}

// CoAP 客户端实现（使用 libcoap）
#include <coap3/coap.h>

// CoAP 资源定义
static coap_resource_t *resources[] = {
    NULL  // 资源列表结束标记
};

// CoAP 请求处理
static void
helloworld_get(coap_context_t *ctx, struct coap_resource_t *resource,
               coap_session_t *session, coap_pdu_t *pdu,
               coap_binary_t *token, coap_string_t *query,
               coap_pdu_t *response) {
    
    const char *payload = "Hello, World!";
    coap_add_data(response, strlen(payload), (const uint8_t *)payload);
}

// CoAP 服务器初始化
coap_context_t *coap_server_init(void) {
    coap_context_t *ctx;
    coap_address_t listen_addr;
    
    // 绑定到 5683 端口（CoAP 标准端口）
    coap_address_init(&listen_addr);
    listen_addr.addr.sin.sin_family = AF_INET;
    listen_addr.addr.sin.sin_addr.s_addr = INADDR_ANY;
    listen_addr.addr.sin.sin_port = htons(5683);
    
    ctx = coap_new_context(&listen_addr);
    if (!ctx) {
        return NULL;
    }
    
    // 注册资源
    coap_resource_t *r = coap_resource_init(coap_make_str_const("hello"), 0);
    coap_register_handler(r, COAP_REQUEST_GET, helloworld_get);
    coap_add_resource(ctx, r);
    
    return ctx;
}

import cv2
import numpy as np

def detect_color_shape(
    image, 
    color_lower=np.array([0, 120, 70]), 
    color_upper=np.array([10, 255, 255]),
    shape_type="circle",
    min_area=100,
    max_area=10000,
    circularity_threshold=0.8,
    aspect_ratio_range=(0.9, 1.1)
):
    """
    检测指定颜色和形状的物体
    
    参数:
        image: 输入 RGB/BGR 图像
        color_lower: HSV 颜色下限
        color_upper: HSV 颜色上限
        shape_type: "circle" / "square" / "rectangle"
        min_area: 最小面积（像素）
        max_area: 最大面积（像素）
        circularity_threshold: 圆形度阈值（0~1，越大越圆）
        aspect_ratio_range: 宽高比范围（方形接近 1）
    
    返回:
        detections: 检测结果列表 [(x, y, w, h, contour), ...]
        mask: 颜色分割掩码（用于调试）
    """
    # 1. 颜色空间转换：BGR → HSV
    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
    
    # 2. 颜色阈值分割
    mask = cv2.inRange(hsv, color_lower, color_upper)
    
    # 3. 形态学处理去除噪声
    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
    
    # 4. 查找轮廓
    contours, hierarchy = cv2.findContours(
        mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
    )
    
    detections = []
    
    for contour in contours:
        # 计算轮廓面积，过滤太小/太大的
        area = cv2.contourArea(contour)
        if area < min_area or area > max_area:
            continue
        
        # 计算轮廓周长
        perimeter = cv2.arcLength(contour, True)
        
        # 多边形逼近
        approx = cv2.approxPolyDP(contour, 0.04 * perimeter, True)
        
        # 获取外接矩形
        x, y, w, h = cv2.boundingRect(contour)
        
        # 形状判断
        matched = False
        
        if shape_type == "circle":
            # 圆形度 = 4π * 面积 / (周长^2)
            # 完美圆形 = 1，越不规则值越小
            circularity = 4 * np.pi * area / (perimeter * perimeter)
            if circularity >= circularity_threshold:
                matched = True
        
        elif shape_type == "square":
            # 宽高比接近 1，且顶点数约为 4
            aspect_ratio = float(w) / h
            if (len(approx) == 4 and 
                aspect_ratio >= aspect_ratio_range[0] and 
                aspect_ratio <= aspect_ratio_range[1]):
                matched = True
        
        elif shape_type == "rectangle":
            # 顶点数约为 4 即可
            if len(approx) == 4:
                matched = True
        
        elif shape_type == "triangle":
            if len(approx) == 3:
                matched = True
        
        if matched:
            center_x = x + w // 2
            center_y = y + h // 2
            detections.append((center_x, center_y, w, h, contour))
    
    return detections, mask