《嵌入式物联网：在字节和毫安之间寻找平衡》

// STM32 GPIO控制：点灯和读按键（仅核心逻辑）
#include "stm32f1xx_hal.h"

void gpio_init(void) {
    __HAL_RCC_GPIOC_CLK_ENABLE();  // 使能GPIOC时钟
    
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.Pin = GPIO_PIN_13;          // PC13接LED
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; // 推挽输出
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
    
    GPIO_InitStruct.Pin = GPIO_PIN_0;           // PA0接按键
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;     // 输入模式
    GPIO_InitStruct.Pull = GPIO_PULLUP;         // 内部上拉
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}

// 主循环中：按键按下翻转LED
void loop(void) {
    if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET) {
        HAL_Delay(50);  // 消抖（简单粗暴）
        if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET) {
            HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);  // 翻转LED
            while(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET);
        }
    }
}

// STM32外部中断配置（按键触发）
void EXTI0_IRQHandler(void) {
    if (__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_0) != RESET) {
        __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_0);  // 清中断标志
        
        // 中断服务函数（尽量简短）
        static uint32_t last_time = 0;
        uint32_t now = HAL_GetTick();
        
        if (now - last_time > 200) {  // 200ms防抖（不阻塞CPU）
            HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
            last_time = now;
        }
    }
}

// 定时器中断：每1秒采集一次温湿度（不占用CPU轮询）
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
    if (htim->Instance == TIM2) {
        // 触发DHT11采集（I2C或单总线）
        uint8_t temp = read_dht11_temperature();
        uint8_t humi = read_dht11_humidity();
        
        // 存入缓冲区，等待主循环发送到云端
        sensor_data.temperature = temp;
        sensor_data.humidity = humi;
        sensor_data.ready = 1;  // 标志位通知主循环
    }
}

// 配置RTC每30秒唤醒一次
void enter_stop_mode(void) {
    // 1. 关闭不需要的外设时钟（省电）
    __HAL_RCC_USART1_CLK_DISABLE();
    __HAL_RCC_I2C1_CLK_DISABLE();
    __HAL_RCC_GPIOB_CLK_DISABLE();
    
    // 2. 配置唤醒引脚（PA0作为WakeUp）
    HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);
    
    // 3. 设置RTC闹钟（30秒后唤醒）
    RTC_AlarmTypeDef sAlarm = {0};
    sAlarm.AlarmTime = get_current_time() + 30;  // 30秒后
    sAlarm.AlarmMask = RTC_ALARMMASK_NONE;
    HAL_RTC_SetAlarm_IT(&hrtc, &sAlarm, RTC_FORMAT_BIN);
    
    // 4. 进入停止模式（核心）
    HAL_PWR_EnterSTOPMode(PWR_MAINREGULATOR_ON, PWR_STOPENTRY_WFI);
    
    // 5. 醒来后重新初始化时钟（停止模式会关闭HSE/PLL）
    SystemClock_Config();  // 重新配置时钟为72MHz
    HAL_Delay(100);        // 等待时钟稳定
    
    // 6. 重新使能外设时钟
    __HAL_RCC_USART1_CLK_ENABLE();
    __HAL_RCC_I2C1_CLK_ENABLE();
}

// 主循环中的状态机（用标志位控制工作/休眠）
void main_loop(void) {
    while(1) {
        if (sensor_data.ready) {
            // 有数据，发送到云端
            send_to_cloud(sensor_data.temperature, sensor_data.humidity);
            sensor_data.ready = 0;
            
            // 发送完立即休眠
            enter_stop_mode();
        } else {
            // 无事发生，休眠
            enter_stop_mode();
        }
    }
}

假设电池容量 1000mAh
工作电流：50mA，持续时间 2秒（采集+发送）
休眠电流：50μA，持续时间 28秒（30秒周期）

平均电流 = (50mA × 2s + 0.05mA × 28s) / 30s = 3.38mA
电池寿命 = 1000mAh / 3.38mA ≈ 296小时 ≈ 12天

// 嵌入式主程序框架（状态机 + 低功耗）
typedef enum {
    STATE_INIT,
    STATE_SENSOR_READ,
    STATE_DATA_PROCESS,
    STATE_CLOUD_SEND,
    STATE_SLEEP
} SystemState;

SystemState current_state = STATE_INIT;

void main(void) {
    hardware_init();
    cloud_connect();
    
    while(1) {
        switch(current_state) {
            case STATE_INIT:
                // 初始化传感器、校准
                current_state = STATE_SENSOR_READ;
                break;
                
            case STATE_SENSOR_READ:
                read_all_sensors();
                current_state = STATE_DATA_PROCESS;
                break;
                
            case STATE_DATA_PROCESS:
                // 滤波、校准、异常值剔除
                filter_sensor_data();
                current_state = STATE_CLOUD_SEND;
                break;
                
            case STATE_CLOUD_SEND:
                if (cloud_is_connected()) {
                    mqtt_publish(sensor_data);
                } else {
                    // 存到Flash，下次重试
                    save_to_flash(sensor_data);
                }
                current_state = STATE_SLEEP;
                break;
                
            case STATE_SLEEP:
                // 进入低功耗，RTC 30秒后唤醒
                enter_stop_mode();
                current_state = STATE_SENSOR_READ;
                break;
        }
    }
}

# 嵌入式开发的三个不等式
嵌入式 ≠ 编程           # 硬件不懂软件，软件不懂硬件，产品就废了
低功耗 ≠ 关外设         # 要学会"睡多久、醒多快"的平衡
物联网 ≠ 联网           # 80%的问题出在传感器本身，不是网络

// 独立看门狗（IWDG）：防止程序跑飞，倒计时结束就复位
void watchdog_init(void) {
    IWDG_HandleTypeDef hiwdg;
    hiwdg.Instance = IWDG;
    hiwdg.Init.Prescaler = IWDG_PRESCALER_64;     // 时钟分频
    hiwdg.Init.Reload = 4095;                      // 倒计时最大值
    HAL_IWDG_Init(&hiwdg);
}

void main_loop(void) {
    while(1) {
        // 喂狗：在关键循环中重置倒计时
        HAL_IWDG_Refresh(&hiwdg);
        
        // 你的业务逻辑
        do_something();
    }
}