嵌入式开发速查表

// 栈大小配置示例
Stack_Size      EQU     0x00004000  // 16KB，默认1KB(0x400)对复杂应用往往不足

// PLL配置示例（STM32F407，168MHz）
HSE 8MHz → PLLM分频至1MHz → PLLN倍频336MHz → PLLP分频2 → 168MHz SYSCLK

// ESP32板卡管理器索引示例
https://dl.espressif.com/dl/package_esp32_index.json

// 熔丝位配置示例（ATmega328P）
low_fuses=0xFF
high_fuses=0xDE
extended_fuses=0xFD

// 安装后验证
idf.py --version
xtensa-esp32-elf-gcc --version

# Name,   Type, SubType, Offset,  Size,    Flags
nvs,      data, nvs,     0x9000,  0x6000,
otadata,  data, ota,     0xf000,  0x2000,
app0,     app,  ota_0,   0x10000, 0x1F0000,
app1,     app,  ota_1,   0x200000,0x1F0000,
spiffs,   data, spiffs,  0x3F0000,0x10000,

# 交叉编译工具链安装
sudo apt install gcc-arm-linux-gnueabihf  # 32位
sudo apt install gcc-aarch64-linux-gnu    # 64位

# 安装验证
gpio -v        # 查看版本（需≥2.6）
gpio readall   # 输出引脚状态表

# 启用I2C
dtparam=i2c_arm=on

# 启用SPI
dtparam=spi=on

# 软件I2C任意引脚
dtoverlay=i2c-gpio,i2c_gpio_sda=23,i2c_gpio_scl=24

project/
├── src/                    # 源文件
│   ├── main.c
│   ├── startup/            # 启动文件
│   ├── hal/                # 硬件抽象层
│   ├── app/                # 应用程序
│   └── middleware/         # RTOS、协议栈
├── inc/                    # 头文件
│   ├── hal/
│   ├── app/
│   └── config/             # 全局配置
├── lib/                    # 第三方库
│   ├── CMSIS/
│   ├── HAL_Driver/
│   └── FreeRTOS/
├── doc/                    # 文档
├── tools/                  # 脚本工具
└── Makefile/CMakeLists.txt

#ifndef PROJECT_MODULE_H
#define PROJECT_MODULE_H
// 内容
#endif /* PROJECT_MODULE_H */

// 版本宏定义
#define FIRMWARE_VERSION_MAJOR  2
#define FIRMWARE_VERSION_MINOR  1
#define FIRMWARE_VERSION_PATCH  0
#define FIRMWARE_VERSION ((MAJOR<<16)|(MINOR<<8)|PATCH)

// 编译器检测
#ifdef __GNUC__
    // GCC特定代码
#elif defined(__ARMCC_VERSION)
    // ARMCC特定代码
#endif

// NVIC优先级分组配置
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);

// SysTick配置示例
SysTick_Config(SystemCoreClock / 1000);  // 1ms中断

// 注意：HAL_Delay基于SysTick但会阻塞
// 实时应用应改用定时器中断或RTOS延时

// 链接脚本关键符号
extern uint32_t _sidata;  // Flash源地址
extern uint32_t _sdata;   // RAM目标起始
extern uint32_t _edata;   // RAM目标结束
extern uint32_t _sbss;    // .bss起始
extern uint32_t _ebss;    // .bss结束

cmake_minimum_required(VERSION 3.16)
project(firmware C ASM)

set(CMAKE_C_COMPILER arm-none-eabi-gcc)
set(CMAKE_CXX_COMPILER arm-none-eabi-g++)

add_executable(firmware src/main.c ...)
target_compile_definitions(firmware PRIVATE 
    STM32F407xx 
    USE_HAL_DRIVER)
target_link_options(firmware PRIVATE 
    -TSTM32F407VGTx_FLASH.ld)

# 启用LTO和代码消除
CFLAGS += -ffunction-sections -fdata-sections -flto
LDFLAGS += --gc-sections

// PA5配置为50MHz推挽输出
RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;  // 使能GPIOA时钟
GPIOA->CRL &= ~(0xF << 20);           // 清除位20-23
GPIOA->CRL |=  (0x3 << 20);           // MODE=11(50MHz), CNF=00(推挽)

// 原子操作：BSRR/BRR
GPIOA->BSRR = (1<<5);        // 置位PA5
GPIOA->BRR = (1<<5);         // 复位PA5（避免读-改-写竞争）

// USART1重映射到PB6/PB7
RCC->APB2ENR |= RCC_APB2ENR_AFIOEN;
AFIO->MAPR |= AFIO_MAPR_USART1_REMAP;

// STM32F4 AFR配置
GPIOA->AFR[0] |= (0x7 << 20);  // PA5复用功能AF7

// 上拉输入配置
GPIOA->CRL &= ~(0xF << 20);
GPIOA->CRL |=  (0x8 << 20);  // MODE=00(输入), CNF=10(上拉)
GPIOA->ODR |=  (1 << 5);     // 使能上拉

// HSE→PLL→SYSCLK配置示例
RCC->CR |= RCC_CR_HSEON;            // 使能HSE
while(!(RCC->CR & RCC_CR_HSERDY));  // 等待就绪
FLASH->ACR |= FLASH_ACR_LATENCY_5WS; // Flash等待周期

RCC->PLLCFGR = (PLLM << 0) | (PLLN << 6) | (PLLP << 16) | 
               RCC_PLLCFGR_PLLSRC_HSE;
RCC->CR |= RCC_CR_PLLON;            // 使能PLL
while(!(RCC->CR & RCC_CR_PLLRDY));  // 等待锁定

RCC->CFGR |= RCC_CFGR_SW_PLL;       // 切换系统时钟
while((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL);

// APB2ENR控制的高速外设
RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;  // GPIOA
RCC->APB2ENR |= RCC_APB2ENR_USART1EN; // USART1
RCC->APB2ENR |= RCC_APB2ENR_SPI1EN;   // SPI1

// APB1ENR控制的低速外设
RCC->APB1ENR |= RCC_APB1ENR_USART2EN; // USART2
RCC->APB1ENR |= RCC_APB1ENR_I2C1EN;   // I2C1
RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;   // TIM2

// 中断使能
NVIC->ISER[0] = (1 << USART1_IRQn);  // 使能USART1中断

// 优先级配置（抢占优先级2，子优先级0）
NVIC->IP[USART1_IRQn] = (2 << 6) | (0 << 4);

// 全局中断控制
__enable_irq();    // 使能全局中断
__disable_irq();   // 禁用全局中断

// PA0外部中断配置
RCC->APB2ENR |= RCC_APB2ENR_AFIOEN;  // 使能AFIO时钟
AFIO->EXTICR[0] &= ~AFIO_EXTICR1_EXTI0;  // 清除配置
AFIO->EXTICR[0] |= AFIO_EXTICR1_EXTI0_PA; // 选择PA0

EXTI->IMR |= EXTI_IMR_MR0;   // 使能中断
EXTI->RTSR |= EXTI_RTSR_TR0; // 上升沿触发
// 或EXTI->FTSR |= EXTI_FTSR_TR0; // 下降沿触发

NVIC_EnableIRQ(EXTI0_IRQn);  // 使能中断向量

// 标准中断服务程序结构
void USART1_IRQHandler(void)
{
    volatile uint32_t data;
    
    if(USART1->SR & USART_SR_RXNE) {
        data = USART1->DR;  // 读取数据清除中断标志
        
        // 设置标志，主循环处理
        rx_flag = 1;
        rx_data = data;
    }
    
    // 清除其他标志...
    USART1->SR &= ~USART_SR_TC;
}

f_TIM = f_CK_PSC / ((PSC+1) × (ARR+1))

// TIM6基本定时器配置
RCC->APB1ENR |= RCC_APB1ENR_TIM6EN;  // 使能时钟
TIM6->PSC = 71;      // 预分频
TIM6->ARR = 999;     // 自动重载值
TIM6->DIER |= TIM_DIER_UIE;  // 使能更新中断
TIM6->CR1 |= TIM_CR1_CEN;    // 启动定时器

NVIC_EnableIRQ(TIM6_IRQn);   // 使能中断

// TIM2_CH1 PWM配置（PA0，1kHz 50%占空比）
RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;
RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;

GPIOA->CRL &= ~(0xF << 0);
GPIOA->CRL |=  (0xB << 0);  // AF模式

TIM2->PSC = 71;      // 72MHz/72 = 1MHz
TIM2->ARR = 999;     // 1MHz/1000 = 1kHz
TIM2->CCR1 = 500;    // 50%占空比
TIM2->CCMR1 |= TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2; // PWM模式1
TIM2->CCER |= TIM_CCER_CC1E;  // 使能输出
TIM2->CR1 |= TIM_CR1_CEN;

// 编码器接口配置
TIM2->SMCR |= TIM_SMCR_SMS_0 | TIM_SMCR_SMS_1; // 编码器模式3
TIM2->CCER |= TIM_CCER_CC1P | TIM_CCER_CC2P;   // 双边沿检测
TIM2->ARR = 0xFFFF;  // 16位计数器
TIM2->CR1 |= TIM_CR1_CEN;

// UART句柄定义
UART_HandleTypeDef huart1 = {
    .Instance = USART1,
    .Init = {
        .BaudRate = 115200,
        .WordLength = UART_WORDLENGTH_8B,
        .StopBits = UART_STOPBITS_1,
        .Parity = UART_PARITY_NONE,
        .Mode = UART_MODE_TX_RX,
    },
    .pRxBuffPtr = rxBuffer,
    .RxXferSize = sizeof(rxBuffer),
};

// 错误处理示例
HAL_StatusTypeDef status = HAL_UART_Transmit(&huart1, data, size, 1000);
if(status != HAL_OK) {
    if(huart1.ErrorCode & HAL_UART_ERROR_ORE) {
        // 溢出错误处理
        __HAL_UART_FLUSH_DRREGISTER(&huart1);
    }
}

// CubeMX生成的时钟配置代码示例
void SystemClock_Config(void)
{
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

    // 自动生成PLL配置...
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
    RCC_OscInitStruct.HSEState = RCC_HSE_ON;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    RCC_OscInitStruct.PLL.PLLM = 8;
    RCC_OscInitStruct.PLL.PLLN = 336;
    RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
    HAL_RCC_OscConfig(&RCC_OscInitStruct);
}

// 用户代码保护区域示例
/* USER CODE BEGIN 2 */
// 用户初始化代码
/* USER CODE END 2 */

/* USER CODE BEGIN WHILE */
while (1)
{
    // 用户主循环代码
}
/* USER CODE END WHILE */

// GPIO初始化与基本操作
HAL_GPIO_Init()      // 初始化
HAL_GPIO_WritePin()  // 输出
HAL_GPIO_ReadPin()   // 输入
HAL_GPIO_TogglePin() // 翻转

// 中断处理
HAL_GPIO_EXTI_IRQHandler()  // 统一中断入口
HAL_GPIO_EXTI_Callback()    // 用户回调（__weak）

// 中断配置示例
GPIO_InitTypeDef GPIO_InitStruct = {
    .Pin = GPIO_PIN_0,
    .Mode = GPIO_MODE_IT_RISING,  // 上升沿触发
    .Pull = GPIO_NOPULL,
};
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

// 设置中断优先级
HAL_NVIC_SetPriority(EXTI0_IRQn, 2, 0);
HAL_NVIC_EnableIRQ(EXTI0_IRQn);

// 基础I2C通信
HAL_I2C_Master_Transmit(&hi2c1, dev_addr, 
                       data, size, timeout);
HAL_I2C_Master_Receive(&hi2c1, dev_addr, 
                      data, size, timeout);

// 存储器读写（自动发送器件地址+存储器地址）
HAL_I2C_Mem_Write(&hi2c1, dev_addr, mem_addr, 
                 mem_addr_size, data, size, timeout);
HAL_I2C_Mem_Read(&hi2c1, dev_addr, mem_addr, 
                mem_addr_size, data, size, timeout);

// SPI初始化配置
hspi.Instance = SPI1;
hspi.Init.Mode = SPI_MODE_MASTER;
hspi.Init.Direction = SPI_DIRECTION_2LINES;  // 全双工
hspi.Init.DataSize = SPI_DATASIZE_8BIT;
hspi.Init.CLKPolarity = SPI_POLARITY_LOW;    // CPOL=0
hspi.Init.CLKPhase = SPI_PHASE_1EDGE;        // CPHA=0, Mode 0
hspi.Init.NSS = SPI_NSS_SOFT;                // 软件片选
hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
HAL_SPI_Init(&hspi);

// 全双工交换
HAL_SPI_TransmitReceive(&hspi, tx_data, rx_data, 
                       size, timeout);

// DMA模式大数据量传输
HAL_SPI_Transmit_DMA(&hspi, tx_data, size);
HAL_SPI_Receive_DMA(&hspi, rx_data, size);

// ADC多通道DMA配置
ADC_ChannelConfTypeDef sConfig = {0};
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Rank = ADC_REGULAR_RANK_1;
sConfig.SamplingTime = ADC_SAMPLETIME_15CYCLES;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);

// 启动DMA连续转换
HAL_ADC_Start_DMA(&hadc1, (uint32_t*)adc_buffer, 
                 ADC_BUFFER_SIZE);

// PWM配置
TIM_OC_InitTypeDef sConfigOC = {0};
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 500;  // 占空比50%
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, 
                         TIM_CHANNEL_1);
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);

// 输入捕获
HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_1);

// DWT精确延时（Cortex-M）
static void DWT_Delay_us(uint32_t us) {
    uint32_t start = DWT->CYCCNT;
    uint32_t cycles = us * (SystemCoreClock / 1000000);
    while((DWT->CYCCNT - start) < cycles);
}

// 初始化仍用HAL
MX_GPIO_Init();

// 关键路径直接寄存器访问
GPIOA->BSRR = (1<<5);        // 置位PA5
GPIOA->BSRR = (1<<5)<<16;    // 复位PA5

// 批量操作
GPIOA->ODR ^= (1<<5);        // 翻转PA5

// 更新句柄State字段避免后续调用误判
huart1.gState = HAL_UART_STATE_READY;

// 精简printf实现（无浮点支持）
int _write(int file, char *ptr, int len) {
    HAL_UART_Transmit(&huart1, (uint8_t*)ptr, len, 100);
    return len;
}

// 错误示例
#define BUFFER_SIZE 128
// 其他地方
#define BUFFER_SIZE 256  // 重复定义

// 正确做法
#ifndef BUFFER_SIZE
#define BUFFER_SIZE 128
#endif

// 错误示例
#ifdef A && B  // 错误：解析为单个标识符

// 正确做法
#if defined(A) && defined(B)  // 正确

// 复杂逻辑建议展开
#if defined(A)
    #if defined(B)
        // A和B都定义
    #endif
#endif

// 错误示例
int main() {
    uart_init();  // 未声明
}

// 正确做法
// uart.h
void uart_init(void);

// main.c
#include "uart.h"

int main() {
    uart_init();
}

// 警告示例
uint8_t a = 200;
uint8_t b = 100;
uint8_t c = a + b;  // 可能溢出

// 正确做法
uint16_t c = (uint16_t)a + b;

// 使用stdint.h定宽类型
uint32_t counter;
int16_t temperature;

// 危险代码
int array[10];
for(int i = 0; i <= 10; i++) {  // 越界访问
    array[i] = i;
}

// 指针类型错误
uint32_t* ptr = (uint32_t*)0x40000000;
uint16_t value = *ptr;  // 可能的对齐错误

// GCC内联汇编
__asm volatile (
    "mov r0, #0\n"
    "msr control, r0\n"
    "isb\n"
    : : : "r0", "memory"
);

// CMSIS推荐方式
__set_CONTROL(0);
__ISB();

// 错误信息示例
undefined reference to `uart_init'
collect2: error: ld returned 1 exit status

# 检查符号表
nm -C object.o | grep uart_init

# 检查库符号
nm -C libuart.a | grep uart_init

// 错误示例：头文件中定义变量
// header.h
int global_var = 0;  // 错误：多重定义

// 正确做法
// header.h
extern int global_var;  // 声明

// source.c
int global_var = 0;     // 唯一定义

// 错误信息示例
region `RAM' overflowed by 1024 bytes
region `FLASH' overflowed by 2048 bytes

// 强制数据放入Flash
const uint8_t large_data[] __attribute__((section(".rodata"))) = {
    // 大量常量数据
};

// 波特率计算
// USARTDIV = f_CLK / (16 × BaudRate)
// 例如：72MHz时钟，115200波特率
// USARTDIV = 72000000 / (16 × 115200) ≈ 39.0625
// DIV_Fraction = 0.0625 × 16 ≈ 1
// DIV_Mantissa = 39
// 实际波特率 = 72000000 / (16 × (39 + 1/16)) ≈ 115079
// 误差 = |115079-115200|/115200 × 100% ≈ 0.1%

// USART硬件流控制配置
UART_HandleTypeDef huart1 = {
    .Instance = USART1,
    .Init = {
        .BaudRate = 115200,
        .HardwareFlowControl = UART_HWCONTROL_RTS_CTS,
        // 其他配置...
    },
};

// 环形缓冲区结构
typedef struct {
    uint8_t buffer[BUFFER_SIZE];
    volatile size_t head;
    volatile size_t tail;
} RingBuffer;

// 写入数据
void RingBuffer_Put(RingBuffer *rb, uint8_t data) {
    size_t next = (rb->head + 1) % BUFFER_SIZE;
    if(next != rb->tail) {  // 未满
        rb->buffer[rb->head] = data;
        rb->head = next;
    }
}

// 读取数据
bool RingBuffer_Get(RingBuffer *rb, uint8_t *data) {
    if(rb->head == rb->tail) return false;  // 空
    *data = rb->buffer[rb->tail];
    rb->tail = (rb->tail + 1) % BUFFER_SIZE;
    return true;
}

// DMA接收配置
HAL_UART_Receive_DMA(&huart1, rx_buffer, RX_BUFFER_SIZE);

// 空闲中断回调
void HAL_UART_IdleCallback(UART_HandleTypeDef *huart) {
    if(huart == &huart1) {
        // 计算接收长度
        size_t rx_count = RX_BUFFER_SIZE - 
                         __HAL_DMA_GET_COUNTER(huart1.hdmarx);
        
        // 处理接收到的数据
        process_frame(rx_buffer, rx_count);
        
        // 重新启动DMA接收
        HAL_UART_Receive_DMA(&huart1, rx_buffer, RX_BUFFER_SIZE);
    }
}

// I2C起始条件生成
I2C1->CR1 |= I2C_CR1_START;  // 发送起始条件
while(!(I2C1->SR1 & I2C_SR1_SB));  // 等待起始条件发送完成

// I2C停止条件生成
I2C1->CR1 |= I2C_CR1_STOP;  // 发送停止条件

// 7位地址示例
// 地址0x50，写操作
// 发送：0xA0 (1010 0000)

// 10位地址示例
// 地址0x123，读操作
// 第一字节：1111 0XX1 (X=地址高2位)
// 第二字节：XXXXXXXX (地址低8位)
// 发送：0xF1, 0x23

// 从设备时钟拉伸
// 硬件自动实现：拉低SCL

// 总线仲裁处理（主设备）
I2C1->CR1 |= I2C_CR1_SWRST;  // 软件复位I2C外设
// 重新初始化并尝试再次发送

// I2C总线死锁恢复
void I2C_RecoverBus(void) {
    // 配置SCL和SDA为GPIO模式
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.Pin = I2C_SCL_PIN | I2C_SDA_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(I2C_PORT, &GPIO_InitStruct);

    // 发送9个时钟脉冲
    for(int i = 0; i < 9; i++) {
        HAL_GPIO_WritePin(I2C_PORT, I2C_SCL_PIN, GPIO_PIN_RESET);
        HAL_Delay(1);
        HAL_GPIO_WritePin(I2C_PORT, I2C_SCL_PIN, GPIO_PIN_SET);
        HAL_Delay(1);
    }

    // 发送停止条件
    HAL_GPIO_WritePin(I2C_PORT, I2C_SDA_PIN, GPIO_PIN_RESET);
    HAL_Delay(1);
    HAL_GPIO_WritePin(I2C_PORT, I2C_SCL_PIN, GPIO_PIN_SET);
    HAL_Delay(1);
    HAL_GPIO_WritePin(I2C_PORT, I2C_SDA_PIN, GPIO_PIN_SET);
}

// SMBus PEC计算
uint8_t SMBus_CalculatePEC(uint8_t *data, size_t len) {
    uint8_t crc = 0;
    for(size_t i = 0; i < len; i++) {
        crc ^= data[i];
        for(int j = 0; j < 8; j++) {
            if(crc & 0x80) crc = (crc << 1) ^ 0x07;
            else crc <<= 1;
        }
    }
    return crc;
}

// 软件片选配置
hspi.Init.NSS = SPI_NSS_SOFT;
// 手动控制CS引脚
HAL_GPIO_WritePin(CS_GPIO_Port, CS_Pin, GPIO_PIN_RESET);
HAL_SPI_Transmit(&hspi, data, size, timeout);
HAL_GPIO_WritePin(CS_GPIO_Port, CS_Pin, GPIO_PIN_SET);

// 硬件片选配置
hspi.Init.NSS = SPI_NSS_HARD_OUTPUT;

// MSB/LSB配置
hspi.Init.FirstBit = SPI_FIRSTBIT_MSB;  // 默认
// 或
hspi.Init.FirstBit = SPI_FIRSTBIT_LSB;

// 数据大小配置
hspi.Init.DataSize = SPI_DATASIZE_8BIT;  // 默认
// 或
hspi.Init.DataSize = SPI_DATASIZE_16BIT;

// 全双工模式
uint8_t tx_data[] = {0x01, 0x02, 0x03};
uint8_t rx_data[3];
HAL_SPI_TransmitReceive(&hspi, tx_data, rx_data, 
                       sizeof(tx_data), timeout);

// 半双工模式配置
hspi.Init.Direction = SPI_DIRECTION_1LINE;
// 发送
HAL_SPI_Transmit(&hspi, tx_data, sizeof(tx_data), timeout);
// 切换方向
hspi.Init.Direction = SPI_DIRECTION_1LINE_RX;
// 接收
HAL_SPI_Receive(&hspi, rx_data, sizeof(rx_data), timeout);

// WiFi配置示例
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
ESP_ERROR_CHECK(esp_wifi_init(&cfg));

// STA模式
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
wifi_config_t sta_config = {
    .sta = {
        .ssid = "YourSSID",
        .password = "YourPassword",
    },
};
ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, 
                                   &sta_config));

// AP模式
wifi_config_t ap_config = {
    .ap = {
        .ssid = "ESP32_AP",
        .password = "12345678",
        .max_connection = 4,
    },
};
ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_AP, 
                                   &ap_config));

// WPA2-PSK配置
wifi_sta_config.sta.threshold.authmode = WIFI_AUTH_WPA2_PSK;

// WPA3配置（ESP32-C3/S3支持）
wifi_sta_config.sta.threshold.authmode = WIFI_AUTH_WPA3_PSK;

// 企业网络配置（EAP）
wifi_sta_config.sta.eap_method = WPA2_EAP_METHOD_TTLS;
wifi_sta_config.stap.identity = "username";
wifi_sta_config.sta.password = "password";

// TCP客户端示例
struct sockaddr_in dest_addr = {
    .sin_addr.s_addr = inet_addr("192.168.1.100"),
    .sin_family = AF_INET,
    .sin_port = htons(8080),
};
int sock = socket(AF_INET, SOCK_STREAM, 
                 IPPROTO_IP);
connect(sock, (struct sockaddr*)&dest_addr, 
       sizeof(dest_addr));
send(sock, data, size, 0);
recv(sock, buffer, sizeof(buffer), 0);
close(sock);

// UDP示例
struct sockaddr_in dest_addr = {
    .sin_addr.s_addr = inet_addr("192.168.1.100"),
    .sin_family = AF_INET,
    .sin_port = htons(8080),
};
int sock = socket(AF_INET, SOCK_DGRAM, 
                 IPPROTO_IP);
sendto(sock, data, size, 0, 
      (struct sockaddr*)&dest_addr, 
      sizeof(dest_addr));
recvfrom(sock, buffer, sizeof(buffer), 0, 
        NULL, NULL);
close(sock);

// HTTP GET请求
esp_http_client_config_t config = {
    .url = "http://example.com/data",
    .method = HTTP_METHOD_GET,
};
esp_http_client_handle_t client = 
    esp_http_client_init(&config);
esp_http_client_perform(client);
esp_http_client_cleanup(client);

// HTTPS服务器配置
httpd_config_t config = HTTPD_DEFAULT_CONFIG();
httpd_handle_t server;
httpd_start(&server, &config);
httpd_register_uri_handler(server, &uri_get);
httpd_register_uri_handler(server, &uri_post);

// Modem-sleep配置
esp_wifi_set_ps(WIFI_PS_MODEM);

// Light-sleep配置
esp_wifi_set_ps(WIFI_PS_LIGHT);

// Deep-sleep配置
esp_sleep_enable_timer_wakeup(time_us);
esp_deep_sleep_start();

// 强制常量数据放入Flash
const uint8_t large_array[] __attribute__((section(".rodata"))) = {
    // 大量常量数据
};

// Arduino中的PROGMEM
const char message[] PROGMEM = "Flash string";
Serial.print(F("Direct flash output"));

// .data区（有初值）
int initialized_var = 42;
uint8_t buffer[1024] = {0};

// .bss区（零初始化）
int uninitialized_var;
static uint8_t static_buffer[512];

// 启动文件中修改栈大小
Stack_Size      EQU     0x00004000  // 16KB

// 链接脚本中修改堆大小
_Min_Heap_Size  EQU     0x00002000  // 8KB

// CCM RAM使用示例（STM32F4）
__attribute__((section(".ccmram"))) uint32_t critical_data[100];

// 或指定绝对地址
uint32_t critical_data[100] __attribute__((at(0x10000000)));

// 常见错误示例
void* ptr = malloc(100);
// 使用ptr
// ...
// 忘记释放 - 内存泄漏

// 重复释放
free(ptr);
free(ptr);  // 错误

// 使用后释放
free(ptr);
// ...
*(uint8_t*)ptr = 42;  // 未定义行为

// 分块内存池
#define BLOCK_SIZE  32
#define BLOCK_COUNT 32

typedef struct {
    uint8_t blocks[BLOCK_COUNT][BLOCK_SIZE];
    uint8_t free[BLOCK_COUNT];
} MemPool;

void* mempool_alloc(MemPool* pool) {
    for(int i = 0; i < BLOCK_COUNT; i++) {
        if(pool->free[i]) {
            pool->free[i] = 0;
            return pool->blocks[i];
        }
    }
    return NULL;  // 无空闲块
}

void mempool_free(MemPool* pool, void* ptr) {
    // 计算块索引并标记为空闲
}

// 内存池块结构
typedef struct MemBlock {
    size_t size;
    struct MemBlock* next;
    uint8_t free;
} MemBlock;

// 内存池
typedef struct {
    uint8_t* base;
    MemBlock* free_list;
} MemoryPool;

void* mempool_alloc(MemoryPool* pool, size_t size) {
    // 查找足够大的空闲块
    // 分割块（如果需要）
    // 返回用户数据指针
}

void mempool_free(MemoryPool* pool, void* ptr) {
    // 合并相邻空闲块
    // 更新空闲链表
}

// 位图分配器
typedef struct {
    uint8_t* memory;
    uint8_t* bitmap;
    size_t total_units;
} BitmapAllocator;

void* bitmap_alloc(BitmapAllocator* alloc, size_t size) {
    size_t units_needed = (size + UNIT_SIZE - 1) / UNIT_SIZE;
    // 扫描位图找到连续空闲单元
    // 标记已分配
    // 返回内存指针
}

void bitmap_free(BitmapAllocator* alloc, void* ptr) {
    // 计算单元索引
    // 清除位图标记
}

// 编译选项生成栈使用信息
CFLAGS += -fstack-usage

// 输出文件：.su
// 格式：函数名:栈使用:静态/动态

// 水印模式检测
void Stack_InitWatermark(void) {
    uint32_t *stack_start = (uint32_t*)_estack;
    uint32_t *stack_end = (uint32_t*)(_estack - STACK_SIZE);
    for(uint32_t *p = stack_end; p < stack_start; p++) {
        *p = 0xDEADBEEF;
    }
}

size_t Stack_GetMaxUsage(void) {
    uint32_t *stack_end = (uint32_t*)(_estack - STACK_SIZE);
    uint32_t *p = stack_end;
    while(p < (uint32_t*)_estack && *p == 0xDEADBEEF) {
        p++;
    }
    return (uint8_t*)_estack - (uint8_t*)p;
}

// 递归改迭代示例
// 递归版本（危险）
int factorial(int n) {
    if(n <= 1) return 1;
    return n * factorial(n-1);
}

// 迭代版本（安全）
int factorial(int n) {
    int result = 1;
    for(int i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

// 大数组处理
// 错误：栈溢出
void process_data() {
    uint8_t large_buffer[4096];  // 太大！
    // 处理数据
}

// 正确：动态分配
void process_data() {
    uint8_t* buffer = malloc(4096);
    if(buffer) {
        // 处理数据
        free(buffer);
    }
}

// FreeRTOS任务栈配置
xTaskCreate(task_func, "Task", 
           STACK_SIZE, param, 
           priority, &task_handle);

// 检查任务栈使用
UBaseType_t uxHighWaterMark = 
    uxTaskGetStackHighWaterMark(task_handle);
// 返回值：最小剩余栈空间（以字为单位）

// 中断栈配置（启动文件中）
Stack_Size      EQU     0x00000800  // 中断栈2KB

// 优化前
int status_flags[8];  // 32位 * 8 = 256位

// 优化后
uint8_t status_flags;  // 8位，使用位操作访问
// 设置标志
status_flags |= (1 << FLAG_BIT);
// 清除标志
status_flags &= ~(1 << FLAG_BIT);
// 检查标志
if(status_flags & (1 << FLAG_BIT))

// Arduino
const char message[] PROGMEM = "Flash string";
strcpy_P(buffer, message);  // 复制到RAM使用
Serial.print(F("Direct flash output"));  // F()宏简化

// GCC
const uint8_t lookup_table[] __attribute__((section(".rodata"))) = {
    // 查找表数据
};

// ESP32
const char* __attribute__((const)) get_string() {
    return "Flash string";
}

// 优化前（可能填充）
struct Data {
    uint8_t flag;      // 1字节 + 3字节填充
    uint32_t value;    // 4字节
    uint16_t count;    // 2字节 + 2字节填充
};  // 总大小：12字节

// 优化后（无填充）
struct Data {
    uint32_t value;    // 4字节
    uint16_t count;    // 2字节
    uint8_t flag;      // 1字节
    uint8_t reserved;  // 1字节（预留）
};  // 总大小：8字节

// 强制紧凑（无填充）
struct __attribute__((packed)) PackedData {
    uint32_t value;
    uint16_t count;
    uint8_t flag;
};  // 总大小：7字节

// 强制内联（小型函数）
static inline uint8_t read_reg(uint8_t addr) {
    return *(volatile uint8_t*)(BASE_ADDR + addr);
}

// 避免内联（大型函数）
__attribute__((noinline)) 
void complex_function(void) {
    // 复杂代码
}

// LTO自动优化（链接时）
// 编译选项：-flto
void helper_function(void) {
    // 可能被内联到调用者
}

// 代码大小优先优化
CFLAGS += -Os -flto
LDFLAGS += -Wl,--gc-sections

// 性能优先优化
CFLAGS += -O2 -flto -ffast-math
LDFLAGS += -Wl,--gc-sections

// 调试友好优化
CFLAGS += -Og -g3

// 内存泄漏检测框架
struct MemBlock {
    void* ptr;
    size_t size;
    const char* file;
    int line;
    struct MemBlock* next;
};

static struct MemBlock* mem_list = NULL;

void* tracked_malloc(size_t size, const char* file, int line) {
    void* ptr = malloc(size);
    if(ptr) {
        struct MemBlock* block = malloc(sizeof(struct MemBlock));
        block->ptr = ptr;
        block->size = size;
        block->file = file;
        block->line = line;
        block->next = mem_list;
        mem_list = block;
    }
    return ptr;
}

void tracked_free(void* ptr) {
    // 从列表中移除并free
}

// 定期报告未释放块
void report_memory_leaks(void) {
    struct MemBlock* block = mem_list;
    while(block) {
        printf("Leak: %p, size %u, allocated at %s:%d\n",
               block->ptr, block->size, 
               block->file, block->line);
        block = block->next;
    }
}