C 语言在无操作系统环境下的运行机制：从裸机到嵌入式系统

在传统的操作系统环境中，C 程序运行在操作系统的保护下，可以调用系统 API、使用标准库、享受内存管理和进程调度等服务。但在无操作系统的环境下（裸机环境），C 程序需要直接与硬件交互，自己管理内存，处理中断，甚至需要自己实现启动代码。这种环境常见于嵌入式系统、微控制器、固件开发等领域。本文将从多个维度深入解析 C 语言在无操作系统环境下的运行机制，帮助你理解底层系统的工作原理。

第一章：无操作系统环境概述

1.1 什么是无操作系统环境

定义

裸机环境（Bare Metal）：

没有操作系统的运行环境
程序直接运行在硬件上
完全控制硬件资源
需要自己实现所有底层功能

典型场景：

嵌入式系统：微控制器（MCU）、单片机
固件开发：BIOS、Bootloader、设备驱动
实时系统：硬实时系统、软实时系统
专用设备：路由器、工控机、IoT 设备

与有操作系统环境的区别

有操作系统环境：

✅ 操作系统提供系统调用
✅ 标准库可用（如 stdio.h、stdlib.h）
✅ 内存管理由操作系统负责
✅ 中断和异常由操作系统处理
✅ 多任务调度由操作系统管理

无操作系统环境：

❌ 没有系统调用
❌ 标准库不可用（需要自己实现）
❌ 需要自己管理内存
❌ 需要自己处理中断
❌ 需要自己实现任务调度（如果需要）

1.2 为什么需要无操作系统环境

资源限制

内存限制：

嵌入式系统内存通常很小（几 KB 到几 MB）
操作系统本身占用大量内存
裸机程序可以更高效利用内存

存储限制：

Flash 存储空间有限
操作系统占用大量存储空间
裸机程序可以更小

性能要求：

实时性要求高
操作系统调度可能引入延迟
裸机程序可以精确控制执行时间

成本考虑

硬件成本：

不需要运行操作系统的强大硬件
可以使用低成本微控制器
降低整体系统成本

开发成本：

某些简单应用不需要操作系统
裸机开发可能更简单直接
减少系统复杂度

1.3 典型应用场景

微控制器应用

STM32、AVR、PIC：

8 位、16 位、32 位微控制器
通常运行裸机程序
用于传感器、执行器控制

Arduino：

基于 AVR 微控制器
提供简化的编程接口
底层仍然是裸机运行

固件开发

BIOS/UEFI：

计算机启动固件
初始化硬件
加载操作系统

Bootloader：

嵌入式系统启动程序
初始化系统
加载应用程序

设备驱动：

硬件设备的底层驱动
直接操作硬件寄存器
提供上层接口

第二章：启动流程与初始化

2.1 系统启动流程

上电复位（Power-On Reset）

硬件复位：

系统上电时，硬件自动复位
CPU 从复位向量（Reset Vector）开始执行
通常是内存的固定地址（如 0x00000000）

复位向量：

存储第一条指令的地址
通常是启动代码（Startup Code）的入口
由链接脚本定义

示例（ARM Cortex-M）：

1
2
3
4
5
6
7
8
9


// 复位向量表（通常在启动文件中定义）
__attribute__((section(".isr_vector")))
void (* const g_pfnVectors[])(void) = {
    (void (*)(void))((unsigned long)&_estack),  // 初始栈指针
    Reset_Handler,                                // 复位处理函数
    NMI_Handler,                                  // NMI中断
    HardFault_Handler,                            // 硬件错误
    // ... 其他中断向量
};

启动代码（Startup Code）

启动代码的作用：

初始化栈指针（Stack Pointer）
初始化数据段（Data Section）
初始化 BSS 段（未初始化数据）
调用 main() 函数

典型的启动代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


// startup.c（简化示例）
extern unsigned long _estack;      // 栈顶地址（由链接脚本定义）
extern unsigned long _sidata;      // 初始化数据起始地址
extern unsigned long _sdata;        // 数据段起始地址
extern unsigned long _edata;        // 数据段结束地址
extern unsigned long _sbss;         // BSS段起始地址
extern unsigned long _ebss;         // BSS段结束地址

// 复位处理函数
void Reset_Handler(void) {
    // 1. 初始化数据段（从Flash复制到RAM）
    unsigned long *src = &_sidata;
    unsigned long *dst = &_sdata;
    while (dst < &_edata) {
        *dst++ = *src++;
    }
    
    // 2. 初始化BSS段（清零）
    dst = &_sbss;
    while (dst < &_ebss) {
        *dst++ = 0;
    }
    
    // 3. 调用main函数
    main();
    
    // 4. 如果main返回，进入无限循环
    while (1) {
        // 不应该到达这里
    }
}

2.2 内存布局

内存区域

Flash（程序存储器）：

存储程序代码和常量
非易失性，断电后数据保留
通常只读（某些支持写入）

RAM（数据存储器）：

存储变量和运行时数据
易失性，断电后数据丢失
可读写

典型内存布局：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


高地址
┌─────────────┐
│   栈(Stack)  │  ← 向下增长
├─────────────┤
│             │
│   堆(Heap)   │  ← 向上增长（如果使用）
├─────────────┤
│   BSS段      │  ← 未初始化全局变量
├─────────────┤
│   数据段     │  ← 已初始化全局变量
├─────────────┤
│   代码段     │  ← 程序代码
└─────────────┘
低地址

链接脚本（Linker Script）

链接脚本的作用：

定义内存布局
指定代码和数据的位置
控制链接过程

示例链接脚本（ARM）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


/* STM32F103链接脚本示例 */
MEMORY
{
    FLASH (rx)  : ORIGIN = 0x08000000, LENGTH = 64K
    RAM (xrw)   : ORIGIN = 0x20000000, LENGTH = 20K
}

SECTIONS
{
    /* 代码段 */
    .text : {
        *(.isr_vector)    /* 中断向量表 */
        *(.text)          /* 代码 */
        *(.rodata)        /* 只读数据 */
    } > FLASH
    
    /* 数据段（在Flash中的初始值） */
    _sidata = LOADADDR(.data);
    
    /* 数据段（在RAM中） */
    .data : {
        _sdata = .;
        *(.data)
        _edata = .;
    } > RAM AT > FLASH
    
    /* BSS段 */
    .bss : {
        _sbss = .;
        *(.bss)
        _ebss = .;
    } > RAM
}

2.3 初始化序列

系统初始化

时钟初始化：

配置系统时钟
配置外设时钟
设置时钟分频器

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


void SystemClock_Config(void) {
    // 配置系统时钟为72MHz（STM32F103示例）
    // 1. 使能HSE（外部高速时钟）
    RCC->CR |= RCC_CR_HSEON;
    while (!(RCC->CR & RCC_CR_HSERDY));
    
    // 2. 配置PLL
    RCC->CFGR |= RCC_CFGR_PLLSRC_HSE;
    RCC->CFGR |= RCC_CFGR_PLLMUL9;  // 8MHz * 9 = 72MHz
    RCC->CR |= RCC_CR_PLLON;
    while (!(RCC->CR & RCC_CR_PLLRDY));
    
    // 3. 选择PLL作为系统时钟
    RCC->CFGR |= RCC_CFGR_SW_PLL;
    while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL);
}

外设初始化：

初始化 GPIO
初始化 UART、SPI、I2C 等外设
配置中断

示例：

1
2
3
4
5
6
7
8


void GPIO_Init(void) {
    // 使能GPIOA时钟
    RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;
    
    // 配置PA5为推挽输出（LED）
    GPIOA->CRL &= ~(0xF << (5 * 4));
    GPIOA->CRL |= (0x3 << (5 * 4));  // 推挽输出，50MHz
}

第三章：内存管理

3.1 静态内存分配

全局变量和静态变量

全局变量：

在程序启动时分配
生命周期贯穿整个程序
存储在数据段或 BSS 段

示例：

1
2
3
4
5
6
7


int global_var = 10;        // 存储在数据段（已初始化）
int global_uninit;          // 存储在BSS段（未初始化）

void function(void) {
    static int static_var = 20;  // 静态局部变量
    // ...
}

栈内存

局部变量：

存储在栈上
函数返回时自动释放
大小有限（通常几KB）

示例：

1
2
3
4
5


void function(void) {
    int local_var = 30;      // 存储在栈上
    char buffer[100];        // 栈上数组
    // 函数返回时自动释放
}

栈溢出：

栈空间有限
大数组或深度递归可能导致栈溢出
需要小心使用

3.2 动态内存分配

实现 malloc/free

在没有操作系统的情况下：

标准库的 malloc/free 不可用
需要自己实现内存管理
通常实现简单的堆管理器

简单的堆管理器实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// 简单的内存池实现
#define HEAP_SIZE 4096
static char heap[HEAP_SIZE];
static size_t heap_offset = 0;

void* malloc(size_t size) {
    if (heap_offset + size > HEAP_SIZE) {
        return NULL;  // 内存不足
    }
    
    void* ptr = &heap[heap_offset];
    heap_offset += size;
    return ptr;
}

void free(void* ptr) {
    // 简单实现：不实际释放内存
    // 复杂实现需要维护空闲块链表
}

更复杂的实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


// 内存块结构
typedef struct block {
    size_t size;
    struct block* next;
    int free;
} block_t;

#define BLOCK_SIZE sizeof(block_t)
static char heap[HEAP_SIZE];
static block_t* free_list = NULL;

void* malloc(size_t size) {
    if (size == 0) return NULL;
    
    // 对齐到4字节
    size = (size + 3) & ~3;
    
    block_t* current = free_list;
    block_t* prev = NULL;
    
    // 查找空闲块
    while (current) {
        if (current->free && current->size >= size) {
            // 找到合适的块
            if (current->size > size + BLOCK_SIZE) {
                // 分割块
                block_t* new_block = (block_t*)((char*)current + BLOCK_SIZE + size);
                new_block->size = current->size - size - BLOCK_SIZE;
                new_block->free = 1;
                new_block->next = current->next;
                current->next = new_block;
            }
            current->free = 0;
            return (char*)current + BLOCK_SIZE;
        }
        prev = current;
        current = current->next;
    }
    
    return NULL;  // 没有可用内存
}

void free(void* ptr) {
    if (ptr == NULL) return;
    
    block_t* block = (block_t*)((char*)ptr - BLOCK_SIZE);
    block->free = 1;
    
    // 合并相邻的空闲块（可选）
}

3.3 内存映射

直接内存访问

内存映射 I/O（MMIO）：

硬件寄存器映射到内存地址
通过读写内存地址来操作硬件
使用 volatile 关键字防止编译器优化

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


// GPIO寄存器定义（STM32示例）
typedef struct {
    volatile uint32_t CRL;   // 配置寄存器低
    volatile uint32_t CRH;   // 配置寄存器高
    volatile uint32_t IDR;   // 输入数据寄存器
    volatile uint32_t ODR;   // 输出数据寄存器
    volatile uint32_t BSRR;  // 位设置/清除寄存器
    volatile uint32_t BRR;   // 位清除寄存器
    volatile uint32_t LCKR;  // 锁定寄存器
} GPIO_TypeDef;

// GPIO基地址
#define GPIOA_BASE 0x40010800
#define GPIOA ((GPIO_TypeDef*)GPIOA_BASE)

// 使用
void set_led(void) {
    GPIOA->BSRR = (1 << 5);  // 设置PA5为高电平
}

void clear_led(void) {
    GPIOA->BRR = (1 << 5);   // 设置PA5为低电平
}

第四章：中断处理

4.1 中断机制

中断向量表

中断向量表：

存储中断处理函数的地址
每个中断有对应的处理函数
由硬件自动调用

示例（ARM Cortex-M）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// 中断向量表
__attribute__((section(".isr_vector")))
void (* const g_pfnVectors[])(void) = {
    (void (*)(void))((unsigned long)&_estack),
    Reset_Handler,
    NMI_Handler,
    HardFault_Handler,
    MemManage_Handler,
    BusFault_Handler,
    UsageFault_Handler,
    0, 0, 0, 0,
    SVC_Handler,
    DebugMon_Handler,
    0,
    PendSV_Handler,
    SysTick_Handler,
    // 外设中断
    EXTI0_IRQHandler,
    EXTI1_IRQHandler,
    // ...
};

中断处理函数

中断处理函数的特点：

函数名必须与向量表中的名称匹配
通常使用 __attribute__((interrupt)) 或 __irq 标记
应该尽可能短，避免长时间占用

示例：

1
2
3
4
5
6
7
8
9


// 外部中断处理函数
void EXTI0_IRQHandler(void) {
    // 清除中断标志
    EXTI->PR |= EXTI_PR_PR0;
    
    // 处理中断
    // 切换LED状态
    GPIOA->ODR ^= (1 << 5);
}

4.2 中断配置

中断使能和优先级

中断使能：

需要在相应的外设和 NVIC（嵌套向量中断控制器）中使能
通常需要配置中断触发方式

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


void EXTI_Config(void) {
    // 1. 配置GPIO为输入
    GPIOA->CRL &= ~(0xF << (0 * 4));
    GPIOA->CRL |= (0x8 << (0 * 4));  // 浮空输入
    
    // 2. 配置EXTI
    AFIO->EXTICR[0] |= 0x0;  // PA0连接到EXTI0
    EXTI->IMR |= EXTI_IMR_MR0;  // 使能EXTI0中断
    EXTI->RTSR |= EXTI_RTSR_TR0;  // 上升沿触发
    
    // 3. 配置NVIC
    NVIC->ISER[0] |= (1 << 6);  // 使能EXTI0中断（中断号6）
    NVIC->IP[6] = 0x10;  // 设置优先级
}

中断嵌套

中断优先级：

高优先级中断可以打断低优先级中断
相同优先级中断不能互相打断
需要合理设置优先级

示例：

1
2
3
4
5
6
7
8
9


// 设置中断优先级
void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) {
    NVIC->IP[IRQn] = (priority << 4);
}

// 使能中断
void NVIC_EnableIRQ(IRQn_Type IRQn) {
    NVIC->ISER[IRQn >> 5] = (1 << (IRQn & 0x1F));
}

4.3 临界区保护

禁用中断

临界区：

需要原子操作的代码段
不能被中断打断
需要禁用中断保护

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


// 进入临界区
void enter_critical(void) {
    __disable_irq();
}

// 退出临界区
void exit_critical(void) {
    __enable_irq();
}

// 使用
void critical_section(void) {
    enter_critical();
    // 临界区代码
    shared_variable++;
    exit_critical();
}

更安全的方式：

1
2
3
4
5


// 保存和恢复中断状态
uint32_t primask = __get_PRIMASK();
__disable_irq();
// 临界区代码
__set_PRIMASK(primask);

第五章：硬件访问

5.1 寄存器操作

位操作

设置位：

1
2
3
4
5


// 使用OR操作设置位
GPIOA->BSRR = (1 << 5);  // 设置第5位

// 或使用
GPIOA->ODR |= (1 << 5);

清除位：

1
2
3
4
5


// 使用AND操作清除位
GPIOA->BRR = (1 << 5);  // 清除第5位

// 或使用
GPIOA->ODR &= ~(1 << 5);

切换位：

1
2


// 使用XOR操作切换位
GPIOA->ODR ^= (1 << 5);

读取位：

1
2
3
4


// 读取位
if (GPIOA->IDR & (1 << 0)) {
    // PA0为高电平
}

位域操作

使用位域结构：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


typedef struct {
    uint32_t MODE0  : 2;  // 位0-1
    uint32_t MODE1  : 2;  // 位2-3
    uint32_t MODE2  : 2;  // 位4-5
    uint32_t MODE3  : 2;  // 位6-7
    // ...
} GPIO_CRL_Bits;

// 使用
GPIO_CRL_Bits* crl = (GPIO_CRL_Bits*)&GPIOA->CRL;
crl->MODE5 = 0x3;  // 设置PA5为输出模式，50MHz

5.2 外设驱动

UART 驱动

UART 初始化：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


void UART_Init(void) {
    // 1. 使能时钟
    RCC->APB2ENR |= RCC_APB2ENR_USART1EN;
    RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;
    
    // 2. 配置GPIO
    // PA9: TX, 复用推挽输出
    GPIOA->CRH &= ~(0xF << (9 * 4));
    GPIOA->CRH |= (0xB << (9 * 4));
    // PA10: RX, 浮空输入
    GPIOA->CRH &= ~(0xF << (10 * 4));
    GPIOA->CRH |= (0x4 << (10 * 4));
    
    // 3. 配置UART
    USART1->BRR = 0x341;  // 115200 @ 72MHz
    USART1->CR1 |= USART_CR1_UE | USART_CR1_TE | USART_CR1_RE;
}

// 发送字符
void UART_SendChar(char c) {
    while (!(USART1->SR & USART_SR_TXE));
    USART1->DR = c;
}

// 发送字符串
void UART_SendString(const char* str) {
    while (*str) {
        UART_SendChar(*str++);
    }
}

// 接收字符
char UART_ReceiveChar(void) {
    while (!(USART1->SR & USART_SR_RXNE));
    return USART1->DR;
}

SPI 驱动

SPI 初始化：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


void SPI_Init(void) {
    // 1. 使能时钟
    RCC->APB2ENR |= RCC_APB2ENR_SPI1EN;
    
    // 2. 配置SPI
    SPI1->CR1 |= SPI_CR1_MSTR;  // 主模式
    SPI1->CR1 |= SPI_CR1_SSM | SPI_CR1_SSI;  // 软件NSS
    SPI1->CR1 |= SPI_CR1_SPE;  // 使能SPI
    
    // 3. 配置时钟分频
    SPI1->CR1 |= SPI_CR1_BR_0;  // fPCLK/2
}

// SPI发送/接收
uint8_t SPI_Transfer(uint8_t data) {
    while (!(SPI1->SR & SPI_SR_TXE));
    SPI1->DR = data;
    while (!(SPI1->SR & SPI_SR_RXNE));
    return SPI1->DR;
}

5.3 定时器

系统定时器（SysTick）

SysTick 配置：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


void SysTick_Init(uint32_t ticks) {
    SysTick->LOAD = ticks - 1;  // 重载值
    SysTick->VAL = 0;           // 当前值
    SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk |
                    SysTick_CTRL_TICKINT_Msk |
                    SysTick_CTRL_ENABLE_Msk;  // 使能
}

// SysTick中断处理函数
void SysTick_Handler(void) {
    // 处理系统滴答
    system_tick++;
}

延时函数：

1
2
3
4
5
6


volatile uint32_t system_tick = 0;

void Delay_ms(uint32_t ms) {
    uint32_t start = system_tick;
    while ((system_tick - start) < ms);
}

第六章：标准库的替代

6.1 标准库的限制

不可用的功能

标准 I/O：

printf、scanf 等不可用
需要自己实现或使用简化版本

内存管理：

malloc、free 需要自己实现
或使用静态分配

字符串处理：

部分字符串函数可以自己实现
或使用简化版本

6.2 实现简化版本

简化版 printf

实现思路：

支持基本格式：%d、%x、%s、%c
通过 UART 输出
使用递归或循环实现数字转换

示例实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67


void print_char(char c) {
    UART_SendChar(c);
}

void print_string(const char* str) {
    while (*str) {
        print_char(*str++);
    }
}

void print_number(uint32_t num, uint32_t base) {
    if (num >= base) {
        print_number(num / base, base);
    }
    char digit = num % base;
    if (digit < 10) {
        print_char('0' + digit);
    } else {
        print_char('A' + digit - 10);
    }
}

int printf(const char* format, ...) {
    va_list args;
    va_start(args, format);
    
    while (*format) {
        if (*format == '%') {
            format++;
            switch (*format) {
                case 'd': {
                    int num = va_arg(args, int);
                    if (num < 0) {
                        print_char('-');
                        num = -num;
                    }
                    print_number(num, 10);
                    break;
                }
                case 'x': {
                    uint32_t num = va_arg(args, uint32_t);
                    print_string("0x");
                    print_number(num, 16);
                    break;
                }
                case 's': {
                    char* str = va_arg(args, char*);
                    print_string(str);
                    break;
                }
                case 'c': {
                    char c = va_arg(args, int);
                    print_char(c);
                    break;
                }
                default:
                    print_char(*format);
            }
        } else {
            print_char(*format);
        }
        format++;
    }
    
    va_end(args);
    return 0;
}

字符串函数

基本字符串函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


// strlen
size_t strlen(const char* str) {
    size_t len = 0;
    while (str[len]) len++;
    return len;
}

// strcpy
char* strcpy(char* dest, const char* src) {
    char* p = dest;
    while ((*p++ = *src++));
    return dest;
}

// strcmp
int strcmp(const char* s1, const char* s2) {
    while (*s1 && *s1 == *s2) {
        s1++;
        s2++;
    }
    return *s1 - *s2;
}

// memset
void* memset(void* s, int c, size_t n) {
    unsigned char* p = (unsigned char*)s;
    while (n--) {
        *p++ = (unsigned char)c;
    }
    return s;
}

// memcpy
void* memcpy(void* dest, const void* src, size_t n) {
    unsigned char* d = (unsigned char*)dest;
    const unsigned char* s = (const unsigned char*)src;
    while (n--) {
        *d++ = *s++;
    }
    return dest;
}

第七章：编译与链接

7.1 交叉编译

交叉编译器

为什么需要交叉编译：

目标平台（如 ARM）与开发平台（如 x86）不同
需要在开发平台上编译目标平台的代码
使用交叉编译器（Cross Compiler）

常见的交叉编译器：

ARM：arm-none-eabi-gcc、arm-linux-gnueabihf-gcc
AVR：avr-gcc
MSP430：msp430-gcc

编译选项

基本编译选项：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# ARM Cortex-M编译示例
arm-none-eabi-gcc \
    -mcpu=cortex-m3 \      # CPU架构
    -mthumb \              # Thumb指令集
    -O2 \                  # 优化级别
    -g \                   # 调试信息
    -Wall \                # 警告
    -ffunction-sections \  # 函数分段
    -fdata-sections \      # 数据分段
    -c main.c -o main.o

链接选项：

1
2
3
4
5
6
7


arm-none-eabi-gcc \
    -mcpu=cortex-m3 \
    -mthumb \
    -T linker.ld \         # 链接脚本
    -Wl,--gc-sections \   # 删除未使用的段
    -Wl,-Map=output.map \ # 生成映射文件
    *.o -o output.elf

7.2 生成固件

生成二进制文件

ELF 到二进制：

1
2
3
4
5
6
7
8


# 生成二进制文件
arm-none-eabi-objcopy -O binary output.elf output.bin

# 生成Intel HEX文件
arm-none-eabi-objcopy -O ihex output.elf output.hex

# 生成反汇编文件
arm-none-eabi-objdump -d output.elf > output.dis

烧录固件

烧录工具：

ST-Link：STMicroelectronics 的调试器
J-Link：SEGGER 的调试器
OpenOCD：开源的调试工具

使用 OpenOCD 烧录：

1
2
3


openocd -f interface/stlink.cfg \
        -f target/stm32f1x.cfg \
        -c "program output.elf verify reset exit"

第八章：实际应用示例

8.1 LED 闪烁程序

完整示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


#include "stm32f10x.h"

// 系统时钟配置
void SystemClock_Config(void) {
    // 使用内部8MHz时钟
    // 简化配置
}

// GPIO初始化
void GPIO_Init(void) {
    // 使能GPIOA时钟
    RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;
    
    // 配置PA5为推挽输出
    GPIOA->CRL &= ~(0xF << (5 * 4));
    GPIOA->CRL |= (0x3 << (5 * 4));
}

// 简单延时
void Delay(uint32_t count) {
    for (volatile uint32_t i = 0; i < count; i++);
}

// 主函数
int main(void) {
    SystemClock_Config();
    GPIO_Init();
    
    while (1) {
        // LED开
        GPIOA->BSRR = (1 << 5);
        Delay(1000000);
        
        // LED关
        GPIOA->BRR = (1 << 5);
        Delay(1000000);
    }
    
    return 0;
}

8.2 UART 通信程序

完整示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


#include "stm32f10x.h"

void UART_Init(void) {
    // 使能时钟
    RCC->APB2ENR |= RCC_APB2ENR_USART1EN | RCC_APB2ENR_IOPAEN;
    
    // 配置GPIO
    GPIOA->CRH &= ~(0xFF << 4);
    GPIOA->CRH |= (0xB << 4) | (0x4 << 8);  // PA9: TX, PA10: RX
    
    // 配置UART
    USART1->BRR = 0x341;  // 115200 @ 72MHz
    USART1->CR1 |= USART_CR1_UE | USART_CR1_TE | USART_CR1_RE;
}

void UART_SendChar(char c) {
    while (!(USART1->SR & USART_SR_TXE));
    USART1->DR = c;
}

void UART_SendString(const char* str) {
    while (*str) {
        UART_SendChar(*str++);
    }
}

int main(void) {
    SystemClock_Config();
    UART_Init();
    
    UART_SendString("Hello, World!\r\n");
    
    while (1) {
        // 主循环
    }
    
    return 0;
}

结语：理解底层系统

C 语言在无操作系统环境下的运行机制展示了计算机系统的最底层工作原理。理解这些机制不仅能帮助你开发嵌入式系统和固件，更能深入理解计算机系统的工作原理。

关键要点回顾：

启动流程：从复位向量到 main 函数的完整流程
内存管理：静态分配、栈、堆的实现
中断处理：中断向量表、中断处理函数、中断配置
硬件访问：寄存器操作、外设驱动、定时器
标准库替代：实现简化版的标准库函数
编译链接：交叉编译、链接脚本、固件生成

学习建议：

从简单开始：先实现 LED 闪烁等简单程序
理解硬件：阅读芯片手册，理解硬件特性
实践为主：通过实际项目加深理解
阅读源码：阅读优秀的嵌入式项目源码

应用领域：

嵌入式系统：微控制器、传感器、执行器
固件开发：BIOS、Bootloader、设备驱动
实时系统：硬实时系统、软实时系统
IoT 设备：智能设备、传感器网络

记住，无操作系统环境下的编程需要更深入的理解硬件和系统原理，但也提供了完全控制系统的能力。这种能力在嵌入式系统、实时系统等场景中是不可替代的。

愿每个程序员都能在底层系统编程中找到乐趣，用 C 语言直接与硬件对话，创造出高效、可靠的嵌入式系统。