# IAR 学习文档

## 1. IAR 简介

IAR Embedded Workbench 是常用的嵌入式集成开发环境，主要用于单片机工程的创建、代码编写、编译、链接、下载和调试。

在嵌入式开发中，IAR 通常用于完成以下工作：

1. 创建和管理嵌入式工程；
2. 编写 `.c`、`.h`、`.s` 等源码文件；
3. 配置芯片型号、编译选项和链接文件；
4. 编译生成可执行文件；
5. 连接仿真器进行下载和调试；
6. 查看变量、寄存器、内存、调用堆栈等调试信息。

![IAR主界面](pictures/IAR_01_主界面.png)

## 2. 工程操作

工程操作主要包括工作区、工程、分组和文件的创建、打开、添加等操作。

在 IAR 中，需要先理解 **工作区** 和 **工程** 的关系：

```text
工作区 Workspace：用于管理一个或多个工程。

工程 Project：用于管理具体的源码文件、头文件、启动文件、链接文件和工程配置。
```

一个工作区中可以包含多个工程，一个工程中可以包含多个分组和文件。

## 3. 各类型文件含义

IAR 工程中常见文件类型如下：

| 文件类型      | 作用                                         |
| ------------- | -------------------------------------------- |
| `.eww`        | IAR 工作区文件，用于保存工作区信息           |
| `.ewp`        | IAR 工程文件，用于保存工程配置和文件组织     |
| `.ewd`        | IAR 调试配置文件                             |
| `.c`          | C 源文件，用于编写程序代码                   |
| `.h`          | 头文件，用于声明函数、变量、宏定义等         |
| `.s` / `.asm` | 汇编文件，常用于启动文件或底层代码           |
| `.icf`        | 链接配置文件，用于配置 Flash、RAM 等存储空间 |
| `.a`          | 静态库文件，用于封装后的库调用               |
| `.out`        | 编译链接后生成的调试输出文件                 |
| `.hex`        | 可下载或烧录的十六进制文件                   |
| `.bin`        | 二进制烧录文件                               |

简单理解：

```text
.eww：打开整个工作区
.ewp：打开单个工程
.c / .h：写代码用
.icf：配置芯片存储地址
.a：静态库文件
.hex / .bin：烧录文件
```

## 4. 新建 / 打开工作区

工作区用于管理一个或多个 IAR 工程。

### 4.1 新建工作区

操作步骤：

1. 打开 IAR Embedded Workbench；
2. 点击顶部菜单栏 **File**；
3. 选择 **New Workspace**；
4. 创建完成后，IAR 会生成一个新的空工作区；
5. 后续可以在该工作区中创建或添加工程。

操作路径：

```text
File → New Workspace
```

![新建工作区](pictures/IAR_03_新建工作区.png)

### 4.2 保存工作区

新建工作区后，需要保存工作区文件。

操作步骤：

1. 点击顶部菜单栏 **File**；
2. 选择 **Save Workspace As**；
3. 选择保存路径；
4. 输入工作区名称；
5. 点击保存。

操作路径：

```text
File → Save Workspace As
```

![保存工作区](pictures/IAR_04_保存工作区.png)

保存后会生成 `.eww` 文件。

例如：

```text
test.eww
```

![保存工作区](pictures/eww.png)

### 4.3 打开工作区

如果已经有现成的 IAR 工作区，可以直接打开 `.eww` 文件。

操作步骤：

1. 点击顶部菜单栏 **File**；
2. 选择 **Open**；
3. 选择 **Workspace**；
4. 找到对应的 `.eww` 文件；
5. 点击打开。

操作路径：

```text
File → Open Workspace
```

![打开工作区](pictures/IAR_05_打开工作区.png)

## 5. 新建 / 打开工程

工程用于管理具体的源码文件、头文件、启动文件、链接文件以及编译调试配置。

### 5.1 新建工程

操作步骤：

1. 打开 IAR；
2. 点击顶部菜单栏 **Project**；
3. 选择 **Create New Project**；
4. 选择工程类型；
5. 一般选择 C 工程或空工程；
6. 选择工程保存路径；
7. 输入工程名称；
8. 点击保存。

操作路径：

```text
Project → Create New Project
```

![新建工程](pictures/IAR_06_新建工程.png)

创建完成后，工作区中会出现新建的工程。

![新建工程完成](pictures/IAR_07_新建工程完成.png)

### 5.2 打开工程

如果已有 `.ewp` 工程文件，可以通过打开工作区或添加工程的方式使用。

通常推荐打开 `.eww` 工作区文件，因为工作区中会保存工程结构和相关配置。

如果只需要打开工程，可以使用添加工程的方式。

## 6. 工作区中导入 / 添加工程

一个工作区中可以添加多个工程。

例如，一个工作区中可以同时包含：

```text
Application 工程
Bootloader 工程
Library 工程
```

### 6.1 添加已有工程

操作步骤：

1. 打开一个工作区；
2. 点击顶部菜单栏 **Project**；
3. 选择 **Add Existing Project**；
4. 找到需要添加的 `.ewp` 工程文件；
5. 点击打开；
6. 工程会被添加到当前工作区中。

操作路径：

```text
Project → Add Existing Project
```

### 6.2 设置活动工程

如果工作区中有多个工程，需要选择当前要编译或调试的工程。

操作步骤：

1. 在工作区窗口中找到目标工程；

2. 右键点击该工程；

3. 选择 **Set as Active**；

   ![设置活动工程](pictures/IAR_09_设置活动工程.png)

4. 被设置为活动工程后，后续编译、下载、调试都会针对该工程进行。

## 7. 新建分组

分组用于在 IAR 工程中分类管理文件。

常见分组方式：

```text
Application
Driver
CMSIS
Startup
User
Library
```

注意：IAR 中的分组主要是工程内部的逻辑分类，不一定等同于电脑磁盘中的真实文件夹。

### 7.1 新建分组操作步骤

1. 在工作区窗口中右键点击工程名称；
2. 选择 **Add**；
3. 选择 **Add Group**；
4. 输入分组名称；
5. 点击确定。

操作路径：

```text
右键工程 → Add → Add Group
```

![新建分组](pictures/新建分组.png)

### 7.2 分组作用

分组可以让工程结构更加清晰。

例如：

```text
Driver：存放驱动文件
User：存放用户代码
Startup：存放启动文件
CMSIS：存放内核相关文件
```

![工程分组效果](pictures/IAR_11_工程分组效果.png)

## 8. 新建 / 打开文件

IAR 中可以新建源码文件，也可以打开已有文件。

## 8.1 新建文件

操作步骤：

1. 点击顶部菜单栏 **File**；
2. 选择 **New File** ；
3. 在编辑区输入代码；
4. 点击保存；
5. 选择保存路径；
6. 输入文件名，例如 `main.c`；
7. 保存后再将文件添加到工程中。

操作路径：

```text
File → New File
```

### 8.2 添加文件到工程

新建文件后，如果只是保存到了电脑目录中，还不一定属于 IAR 工程。

需要将文件添加到工程中。

操作步骤：

1. 右键点击对应分组；
2. 选择 **Add**；
3. 选择 **Add Files**；
4. 找到需要添加的 `.c` 或 `.h` 文件；
5. 点击打开。

操作路径：

```text
右键分组 → Add → Add Files
```

![添加文件到工程](pictures/IAR_13_添加文件到工程.png)

### 8.3 打开已有文件

操作步骤：

1. 点击顶部菜单栏 **File**；
2. 选择 **Open File**；
3. 选择需要打开的文件；
4. 点击打开。

操作路径：

```text
File → Open File
```

![打开文件](pictures/打开文件.png)

## 9. 工程目录与文件目录的关系

IAR 工程中的文件显示结构，不一定和电脑磁盘中的真实文件目录完全一致。

### 9.1 工程目录

工程目录是 IAR 左侧工作区中看到的结构。

例如：

```text
Project
|---Application
|   |---main.c
|---Driver
|   |---gpio.c
|---Startup
|   |---startup.s
```

这是 IAR 工程中的逻辑分组结构。

### 9.2 文件目录

文件目录是电脑磁盘中的真实文件存放位置。

例如：

```text
D:\Project\User\main.c
D:\Project\Driver\gpio.c
D:\Project\Startup\startup.s
```

### 9.3 二者区别

| 类型     | 含义                             |
| -------- | -------------------------------- |
| 工程目录 | IAR 中显示的逻辑结构             |
| 文件目录 | 电脑磁盘中的真实路径             |
| 分组     | 方便管理文件，不一定是真实文件夹 |
| 文件路径 | 文件在磁盘上的实际位置           |

简单理解：

```text
IAR 左侧看到的是工程管理结构；
电脑文件夹里看到的是真实文件位置。
```

## 10. 工程配置

工程配置主要通过 **Options** 窗口完成。

操作步骤：

1. 在工作区中选中工程；
2. 右键点击工程名称；
3. 选择 **Options**；
4. 在弹出的窗口中配置设备、编译器、链接器、调试器等内容。

操作路径：

```text
右键工程 → Options
```

也可以通过顶部菜单栏：

```text
Project → Options
```

![工程配置入口](pictures/IAR_16_工程配置入口.png)

## 11. 设备配置

设备配置用于选择当前工程使用的芯片型号。

### 11.1 配置步骤

1. 打开工程 **Options**；
2. 选择 **General Options**；
3. 找到 **Target** 选项；
4. 在 **Device** 中选择对应芯片型号；
5. 点击确定保存。

操作路径：

```text
Project → Options → General Options → Target → Device
```

![设备配置](pictures/IAR_17_设备配置.png)

### 11.2 作用

设备配置会影响编译器和调试器对芯片型号的识别。

如果设备选择错误，可能会导致：

```text
编译配置不匹配
下载失败
调试异常
芯片寄存器信息不正确
```

## 12. 编译配置

编译配置主要用于设置编译器相关选项，包括优化等级、预处理宏、头文件路径、硬件浮点等。

常用配置入口：

```text
Project → Options → C/C++ Compiler
```

![编译配置入口](pictures/IAR_18_编译配置入口.png)

## 13. 优化等级配置

优化等级用于控制编译器对代码的优化程度。

### 13.1 操作步骤

1. 打开工程 **Options**；
2. 选择 **C/C++ Compiler**；
3. 进入 **Optimizations** 相关页面；
4. 根据需要选择优化等级；
5. 点击确定保存。

操作路径：

```text
Project → Options → C/C++ Compiler → Optimizations
```

![优化等级配置](pictures/IAR_19_优化等级配置.png)

### 13.2 常见说明

| 优化等级 | 说明                 |
| -------- | -------------------- |
| None     | 不优化，适合调试     |
| Low      | 低优化               |
| Medium   | 中等优化             |
| High     | 高优化，适合正式发布 |

调试阶段一般选择较低优化，方便单步调试和查看变量。

正式发布时可以适当提高优化等级，减小代码体积或提升运行效率。

## 14. 硬件浮点配置

硬件浮点配置用于设置是否使用芯片的 FPU 浮点运算单元。

### 14.1 操作步骤

1. 打开工程 **Options**；
2. 选择 **General Options**；
3. 进入 **Target** 相关页面；
4. 找到 FPU 或 Floating Point 相关选项；
5. 根据芯片支持情况选择硬件浮点或软件浮点；
6. 点击确定保存。

操作路径：

```text
Project → Options → General Options → Target
```

![硬件浮点配置](pictures/IAR_20_硬件浮点配置.png)

### 14.2 注意事项

硬件浮点配置需要和芯片型号、启动文件、库配置保持一致。

如果芯片不支持 FPU，却选择了硬件浮点，可能导致程序运行异常。

## 15. 预处理配置

预处理配置主要包括宏定义和头文件搜索路径。

常用入口：

```text
Project → Options → C/C++ Compiler → Preprocessor
```

![预处理配置](pictures/IAR_21_预处理配置.png)

### 15.1 宏定义配置

在预处理页面中，可以添加工程需要的宏定义。

例如：

```text
USE_HAL_DRIVER
STM32F103xB
DEBUG
```

这些宏会影响条件编译。

示例：

```c
#ifdef DEBUG
    printf("debug mode");
#endif
```

### 15.2 头文件路径配置

如果工程中包含头文件，例如：

```c
#include "gpio.h"
#include "usart.h"
```

需要确保头文件所在目录已经添加到 Additional include directories 中。

常见路径示例：

```text
$PROJ_DIR$\User
$PROJ_DIR$\Driver
$PROJ_DIR$\CMSIS
$PROJ_DIR$\Inc
```

如果头文件路径没有配置正确，编译时可能会报错：

```text
Fatal Error: cannot open source input file
```

![](pictures/宏定义.png)

## 16. 链接文件配置

链接文件用于配置程序的存储空间分布，例如 Flash 和 RAM 的起始地址、大小等。

IAR 中常见链接文件后缀为：

```text
.icf
```

### 16.1 操作步骤

1. 打开工程 **Options**；
2. 选择 **Linker**；
3. 进入 **Config** 页面；
4. 勾选或选择自定义链接文件；
5. 添加对应的 `.icf` 文件路径；
6. 点击确定保存。

操作路径：

```text
Project → Options → Linker → Config
```

![链接文件配置](pictures/IAR_22_链接文件配置.png)

### 16.2 链接文件作用

链接文件决定代码和数据放到哪里。

常见内容包括：

```text
Flash 起始地址
Flash 大小
RAM 起始地址
RAM 大小
栈空间
堆空间
中断向量表位置
```

如果链接文件配置错误，可能导致程序无法正常启动或下载失败。

## 17. 文件路径配置

文件路径配置主要包括源码文件路径、头文件路径、库文件路径和输出路径。

在 IAR 中，建议使用相对路径，方便工程在不同电脑之间移动。

常见相对路径写法：

```text
$PROJ_DIR$
```

其中 `$PROJ_DIR$` 表示当前工程文件所在目录。

### 17.1 头文件路径配置

操作路径：

```text
Project → Options → C/C++ Compiler → Preprocessor
```

在 Additional include directories 中添加头文件目录。

![头文件路径配置](pictures/IAR_23_头文件路径配置.png)

### 17.2 库文件路径配置

库文件路径配置用于在工程中添加静态库文件，使工程在编译链接时能够使用库中的函数。

调用静态库时，一般需要配置两部分内容：

```text
1. 添加头文件路径
2. 添加静态库文件
```

#### 17.2.1 添加头文件路径

操作步骤：

1. 在 IAR 左侧工程窗口中，右键点击工程名称；

2. 选择：

   ```text
   Options
   ```

3. 在左侧选择：

   ```text
   C/C++ Compiler
   ```

4. 切换到：

   ```text
   Preprocessor
   ```

5. 在：

   ```text
   Additional include directories
   ```

   中添加头文件所在的文件夹路径。

   例如：

   ```text
   $PROJ_DIR$\Lib\Include
   ```

6. 点击 **OK** 保存配置。

![添加头文件路径](pictures\Snipaste_2026-07-08_14-35-54.png)

注意：这里添加的是头文件所在的**文件夹路径**，不是具体的 `.h` 文件。

正确写法：

```text
$PROJ_DIR$\Lib\Include
```

错误写法：

```text
$PROJ_DIR$\Lib\Include\lib_demo.h
```

#### 17.2.2 添加静态库文件

操作步骤：

1. 在 IAR 左侧工程窗口中，右键点击需要添加库文件的分组；

   如果没有专门的分组，可以先新建一个分组，例如：

   ```text
   Library
   ```

2. 选择：

   ```text
   Add → Add Files
   ```

3. 在文件选择窗口中，找到需要添加的静态库文件。

   例如：

   ```text
   lib_demo.a
   ```

4. 选中 `.a` 文件后，点击 **打开**；

5. 添加完成后，`.a` 静态库文件会显示在工程分组中；

6. 重新编译工程。

![添加静态库文件](pictures/IAR_库文件路径配置_添加静态库文件.png)

## 18. 输出文件路径配置

输出文件路径用于设置编译后生成文件的保存位置。

常见输出文件包括：

```text
.out
.hex
.bin
.map
```

## 18. 输出文件路径配置

输出文件路径配置用于设置 IAR 编译后生成文件的保存位置。

常见输出文件包括：

```text
.out
.hex
.bin
.map
.obj
```

其中，`.out`、`.obj`、`.map` 等文件一般会生成到工程的输出目录中。

### 18.1 操作步骤

1. 在 IAR 左侧工程窗口中，右键点击工程名称；

2. 选择：

   ```text
   Options
   ```

3. 在左侧选择：

   ```text
   General Options
   ```

4. 切换到：

   ```text
   Output
   ```

5. 在输出路径相关位置设置输出文件目录；

   常见输出目录包括：

   ```text
   Debug
   Release
   Exe
   Obj
   List
   ```

6. 根据需要修改输出文件保存路径；

7. 点击 **OK** 保存配置；

8. 重新编译工程，查看输出目录中是否生成对应文件。

![输出文件路径配置](pictures/IAR_输出文件路径配置.png)

### 18.2 Linker 中的 Output 配置说明

`Linker → Output` 主要用于配置链接器输出文件的相关信息。

链接器的作用是将编译生成的目标文件、库文件等内容进行链接，最终生成工程的输出文件。

操作路径：

```text
Project → Options → Linker → Output
```

![Linker输出配置](pictures/IAR_Linker_Output配置.png)

#### 操作步骤

1. 在 IAR 左侧工程窗口中，右键点击工程名称；

2. 选择：

   ```text
   Options
   ```

3. 在左侧选择：

   ```text
   Linker
   ```

4. 切换到：

   ```text
   Output
   ```

5. 根据需要查看或修改链接输出相关配置；

6. 点击 **OK** 保存配置；

7. 重新编译工程，查看输出文件是否正常生成。

#### 配置说明

`Linker → Output` 中主要关注链接后生成的输出文件。

常见输出文件包括：

```text
.out
.map
.hex
.bin
```

其中：

| 文件类型 | 说明                                               |
| -------- | -------------------------------------------------- |
| `.out`   | IAR 默认生成的调试输出文件，调试时常用             |
| `.map`   | 链接映射文件，用于查看函数、变量、段地址和内存占用 |
| `.hex`   | 十六进制文件，常用于程序烧录                       |
| `.bin`   | 二进制文件，也可用于程序烧录                       |

#### 注意事项

`Linker → Output` 主要和链接输出结果有关。

如果需要配置链接脚本，应到：

```text
Project → Options → Linker → Config
```

如果需要生成 `.hex` 或 `.bin` 文件，一般还需要配置：

```text
Project → Options → Output Converter
```

简单理解：

```text
Linker → Output：
查看或设置链接器最终输出文件相关内容。

Linker → Config：
配置链接文件，例如 .icf 文件。

Output Converter：
配置是否额外生成 .hex、.bin 等烧录文件。
```
## 19. 输出文件配置

输出文件配置用于设置是否生成 `.hex`、`.bin` 等文件。

### 19.1 生成 hex 文件

操作步骤：

1. 打开工程 **Options**；
2. 选择 **Output Converter**；
3. 勾选生成额外输出文件；
4. 选择 Intel HEX 格式；
5. 点击确定保存；
6. 重新编译工程。

操作路径：

```text
Project → Options → Output Converter
```

![生成hex文件](pictures/IAR_26.png)

### 19.2 生成 bin 文件

如果需要生成二进制文件，可以在输出转换配置中选择 binary 格式。

![生成bin文件](pictures/IAR_27.png)

### 19.3 输出文件说明

| 文件   | 作用                           |
| ------ | ------------------------------ |
| `.out` | 调试用输出文件                 |
| `.hex` | 常用于烧录                     |
| `.bin` | 二进制烧录文件                 |
| `.map` | 链接映射文件，用于分析内存占用 |

## 20. 调试器配置

调试器配置用于设置 IAR 使用哪种调试方式连接目标板。

常见调试器包括：

```text
Simulator
J-Link
ST-LINK
I-jet
CMSIS-DAP
```

### 20.1 操作步骤

1. 打开工程 **Options**；
2. 选择 **Debugger**；
3. 进入 **Setup** 页面；
4. 在 Driver 中选择调试器类型；
5. 根据实际硬件选择 J-Link、ST-LINK 或其他调试器；
6. 点击确定保存。

操作路径：

```text
Project → Options → Debugger → Setup → Driver
```

![调试器配置](pictures/IAR_28_调试器配置.png)

### 20.2 注意事项

调试器配置需要和实际连接的仿真器一致。

如果使用 J-Link，就选择 J-Link；  
如果使用 ST-LINK，就选择 ST-LINK。

选择错误可能导致下载或调试失败。

## 21. 库相关配置

库相关配置主要用于设置工程使用的运行库，以及静态库的生成和调用方式。

在 IAR 中，库相关内容一般包括以下三部分：

```text
1. C 库配置
2. 静态库的封装
3. 静态库的调用
```

### 21.1 C 库配置

C 库配置用于设置工程使用的标准 C 库类型。

标准 C 库中包含一些常用函数，例如：

```c
printf();
memcpy();
strlen();
malloc();
```

在 IAR 中，可以根据工程需要选择不同的库配置。

#### 操作步骤

1. 在 IAR 左侧工程窗口中，右键点击工程名称；

2. 选择：

   ```text
   Options
   ```

3. 在左侧选择：

   ```text
   General Options
   ```

4. 找到：

   ```text
   Library Configuration
   ```

5. 根据工程需要选择对应的 C 库配置；

6. 点击 **OK** 保存配置。

![C库配置](pictures/IAR_库相关配置_C库配置.png)

#### 常见说明

不同库配置会影响工程对标准库函数的支持情况。

例如：

| 配置内容 | 说明                                                         |
| -------- | ------------------------------------------------------------ |
| None     | 不使用 / 不链接 C 运行库。                                   |
| Normal   | 使用 C/C++ 运行时库的普通配置。不支持区域设置接口，使用 C 区域设置；不支持文件描述符；printf 和 scanf 不支持多字节字符；strtod 不支持十六进制浮点数。 |
| Full     | 控制格式化输入输出函数的支持程度                             |
| Custom   | 使用 C/C++ 运行时库的完整配置。支持完整的区域设置接口，使用 C 区域设置；支持文件描述符；printf 和 scanf 支持多字节字符；strtod 支持十六进制浮点数。 |

在嵌入式工程中，如果程序空间较小，可以选择较精简的库配置；  
如果需要使用 `printf`、`sprintf` 等函数，则需要确认库配置是否支持相关功能。

### 21.2 静态库相关内容

静态库是将多个源文件编译后封装成的库文件。

IAR 中常见的静态库文件后缀为：

```text
.a
```

静态库通常由两部分组成：

```text
.h 头文件：提供函数声明
.a 库文件：提供函数实现
```

调用静态库时，其他工程通常不需要看到库内部的 `.c` 源文件，只需要使用 `.h` 头文件和 `.a` 库文件即可。

### 21.3 静态库的使用流程

静态库一般分为两个步骤：

```text
第一步：封装静态库
将多个 .c 文件编译生成 .a 库文件。

第二步：调用静态库
在其他工程中添加 .a 文件，并配置 .h 头文件路径。
```

简单理解：

```text
封装静态库：把源码打包成库。

调用静态库：在其他工程中使用这个库。
```

## 22. 静态库的封装

静态库封装是指将一个或多个 `.c` 源文件编译成一个 `.a` 静态库文件，供其他工程调用。

封装后的静态库可以隐藏具体实现代码，只向外提供头文件和库文件。

例如有以下文件：

```text
lib_demo.c
lib_demo.h
```

可以将 `lib_demo.c` 编译生成：

```text
lib_demo.a
```

然后其他工程只需要使用：

```text
lib_demo.h
lib_demo.a
```

即可调用库中的函数。

### 22.1 静态库封装前准备

封装静态库前，需要准备好需要封装的源码文件和头文件。

例如：

```text
lib_demo.c
lib_demo.h
```

其中：

```text
lib_demo.c：函数实现文件
lib_demo.h：函数声明文件
```

示例头文件内容：

```c
#ifndef __LIB_DEMO_H
#define __LIB_DEMO_H

void Lib_Demo_Init(void);
void Lib_Demo_Run(void);

#endif
```

示例源文件内容：

```c
#include "lib_demo.h"

void Lib_Demo_Init(void)
{
    /* 初始化代码 */
}

void Lib_Demo_Run(void)
{
    /* 运行代码 */
}
```

![静态库源码文件](pictures/IAR_静态库封装_源码文件.png)

### 22.2 新建静态库工程

操作步骤：

1. 打开 IAR；

2. 点击顶部菜单栏：

   ```text
   Project
   ```

3. 选择：

   ```text
   Create New Project
   ```

4. 在工程类型中选择空工程选项；

   ```text
   Empty project
   ```

5. 选择工程保存路径；

6. 输入工程名称，例如：

   ```text
   LibDemo
   ```

7. 点击保存，完成静态库工程创建。

![新建静态库工程](pictures/IAR_静态库封装_新建静态库工程.png)

### 22.3 添加需要封装的文件

静态库工程创建完成后，需要将需要封装的 `.c` 文件添加到工程中。

操作步骤：

1. 在左侧工程窗口中，右键点击静态库工程；

2. 选择：

   ```text
   Add → Add Files
   ```

3. 选择需要封装的 `.c` 文件；

   例如：

   ```text
   lib_demo.c
   ```

4. 点击打开；

5. 文件添加完成后，会显示在工程列表中。

![添加静态库源文件](pictures/IAR_静态库封装_添加源文件.png)

如果工程中需要分组管理文件，可以先新建分组，例如：

```text
Source
Include
```

再将对应文件添加到分组中。

### 22.4 配置头文件路径

如果 `.c` 文件中包含了头文件，例如：

```c
#include "lib_demo.h"
```

需要确保 IAR 能找到对应的 `.h` 文件。

操作步骤：

1. 右键点击工程名称；

2. 选择：

   ```text
   Options
   ```

3. 在左侧选择：

   ```text
   C/C++ Compiler
   ```

4. 切换到：

   ```text
   Preprocessor
   ```

5. 在：

   ```text
   Additional include directories
   ```

   中添加头文件所在文件夹路径。

例如：

```text
$PROJ_DIR$\Include
```

6. 点击 **OK** 保存。

![静态库头文件路径配置](pictures/IAR_静态库封装_头文件路径配置.png)

注意：这里添加的是文件夹路径，不是具体的 `.h` 文件。

正确写法：

```text
$PROJ_DIR$\Include
```

错误写法：

```text
$PROJ_DIR$\Include\lib_demo.h
```

### 22.5 配置设备和编译选项

静态库工程也需要配置设备型号、输出类型和编译选项。

操作步骤：

1. 右键点击静态库工程；

2. 选择：

   ```text
   Options
   ```

3. 在左侧选择：

   ```text
   General Options
   ```

4. 在 **Target** 中选择和目标工程一致的芯片型号；

5. 切换到 **Output** 页面；

6. 将输出类型设置为：

   ```text
   Library
   ```

   或类似选项：

   ```text
   Static Library
   ```

   这一步很重要，如果没有选择 **Library**，工程可能会按照普通应用工程编译，最终不会生成 `.a` 静态库文件。

7. 在 **C/C++ Compiler** 中检查编译配置；

8. 如果工程使用浮点功能，需要确认浮点配置和调用该库的工程一致；

9. 点击 **OK** 保存配置。

![静态库设备和输出类型配置](pictures/IAR_静态库封装_设备和输出类型配置.png)

注意：静态库工程的芯片型号、编译器配置、浮点配置应尽量和后续调用该库的工程保持一致，否则可能出现链接失败或运行异常。

同时，静态库工程必须将输出类型设置为 **Library**，否则编译后可能不会生成 `.a` 文件。

### 22.6 编译生成静态库

配置完成后，可以编译静态库工程。

操作步骤：

1. 确认当前活动工程是静态库工程；

2. 点击顶部菜单栏：

   ```text
   Project → Make
   ```

   或：

   ```text
   Project → Rebuild All
   ```

3. 等待编译完成；

4. 查看 Build 窗口是否有错误；

5. 如果没有错误，会生成 `.a` 静态库文件。

   ![查看静态库文件](pictures/IAR_静态库封装_查看静态库文件.png)

### 22.7 查看生成的静态库文件

编译成功后，可以在工程输出目录中找到生成的 `.a` 文件。

常见输出目录可能类似：

```text
Debug\Exe
Release\Exe
```

生成的静态库文件示例：

```text
LibDemo.a
```

![查看静态库文件](pictures/IAR_静态库封装_查看静态库件.png)

### 22.8 静态库封装完成后需要提供的文件

静态库封装完成后，如果要给其他工程使用，一般需要提供以下文件：

```text
1. .a 静态库文件
2. .h 头文件
```

例如：

```text
LibDemo.a
lib_demo.h
```

其中：

```text
LibDemo.a：保存函数实现
lib_demo.h：提供函数声明
```

如果只提供 `.a` 文件，没有 `.h` 文件，其他工程不知道有哪些函数可以调用。

如果只提供 `.h` 文件，没有 `.a` 文件，编译可能能通过，但链接时会报错。

### 22.9 静态库封装总结

静态库封装流程可以总结为：

```text
准备 .c 和 .h 文件
→ 新建静态库工程
→ 添加 .c 文件到工程
→ 配置头文件路径
→ 配置设备和编译选项
→ 编译工程
→ 生成 .a 静态库文件
→ 提供 .a 文件和 .h 文件给其他工程使用
```

简单理解：

```text
.c 文件负责实现功能。

.h 文件负责声明接口。

.a 文件是编译后生成的静态库。

别人调用库时，需要 .h + .a。
```
## 23. 静态库的调用

静态库调用是指在应用工程中使用已经封装好的 `.a` 库文件。

### 23.1 添加头文件路径

如果调用库函数，需要先添加库对应的头文件路径。

操作路径：

```text
Project → Options → C/C++ Compiler → Preprocessor
```

在 Additional include directories 中添加库头文件目录。

![静态库头文件路径](pictures/IAR_32_静态库头文件路径.png)

### 23.2 添加静态库文件

操作步骤：

1. 在应用工程中右键点击分组；
2. 选择 **Add**；
3. 选择 **Add Files**；
4. 找到 `.a` 静态库文件；
5. 将静态库添加到工程中。

![添加静态库文件](pictures/IAR_33_添加静态库文件.png)

### 23.3 包含头文件并调用函数

在代码中包含库头文件：

```c
#include "lib_demo.h"
```

然后调用库中的函数：

```c
Lib_Demo_Init();
Lib_Demo_Run();
```

![调用静态库函数](pictures/IAR_34_调用静态库函数.png)

### 23.4 静态库调用注意事项

调用静态库时需要注意：

1. `.a` 文件已经添加到工程；
2. `.h` 头文件路径已经配置；
3. 函数声明和函数调用名称一致；
4. 静态库和当前工程芯片平台、编译配置兼容；
5. 如果库依赖其他文件，也需要一起添加。

## 24. 工程编译

IAR 中常用编译操作包括 Make 和 Rebuild All。

### 24.1 Make

Make 只编译发生变化的文件。

操作路径：

```text
Project → Make
```

或者点击工具栏中的 Make 按钮。

![Make编译](pictures/IAR_35_Make编译.png)

### 24.2 Rebuild All

Rebuild All 会重新编译整个工程。

操作路径：

```text
Project → Rebuild All
```

![RebuildAll编译](pictures/IAR_36_RebuildAll编译.png)

### 24.3 查看编译结果

编译完成后，可以在 Build 窗口查看结果。

常见结果：

```text
Errors：错误数量
Warnings：警告数量
```

如果 Errors 为 0，说明工程编译通过。

![编译结果](pictures/IAR_37_编译结果.png)

## 25. 工程调试

工程调试用于下载程序、运行程序、设置断点、查看变量和分析程序执行过程。

进入调试前，需要先完成：

1. 工程可以正常编译；
2. 调试器配置正确；
3. 开发板和仿真器连接正常；
4. 目标板供电正常。

常用调试入口：

```text
Project → Download and Debug
```

![下载并调试](pictures/IAR_38_下载并调试.png)

## 26. 断点

断点用于让程序运行到指定代码行时暂停，方便查看当前变量、寄存器和程序状态。

## 26.1 设置断点

操作步骤：

1. 打开需要调试的源码文件；
2. 找到需要暂停的代码行；
3. 点击该行左侧空白区域；
4. 出现红色圆点，表示断点设置成功。

![设置断点](pictures/IAR_39.png)

## 26.2 禁用断点

禁用断点是指暂时不使用该断点，但不删除断点。

操作步骤：

1. 找到已经设置的断点；

2. 右键点击断点；

3. 选择 Disable Breakpoint；

   ![禁用断点](pictures\IAR39.png)

4. 断点变为禁用状态。

![禁用断点](pictures/IAR_41.png)

## 26.3 启用断点

如果需要重新使用被禁用的断点，可以启用断点。

操作步骤：

1. 找到被禁用的断点；

2. 右键点击断点；

3. 选择 Enable Breakpoint；

   ![启用断点](pictures/启用断点.png)

4. 断点恢复启用状态。



## 26.4 删除断点

删除断点是指将断点完全移除。

操作步骤：

1. 点击已经设置断点的红点；
2. 红点消失，表示断点删除成功。

或者右键断点，选择删除断点。

## 26.5 条件断点

条件断点是指只有满足指定条件时，程序才会在该断点处暂停。

例如：

```text
count == 10
flag == 1
```

操作步骤：

1. 设置普通断点；

2. 右键点击断点；

3. 选择 Edit Breakpoint；

   ![条件断点](pictures/IAR_43.png)

4. 在条件栏中输入条件表达式；

5. 点击确定。

![条件断点](pictures/IAR44.png)

条件断点适合循环次数较多或只想观察特定条件下程序状态的情况。

## 27. 监控信息

监控信息用于查看变量的当前值。

IAR 中常用 Watch 窗口查看变量。

### 27.1 打开 Watch 窗口

调试模式下，点击菜单：

```text
View → Watch
```

![Watch窗口](pictures/IAR_44_Watch窗口.png)

### 27.2 添加监控变量

操作步骤：

1. 进入调试模式；
2. 打开 Watch 窗口；
3. 在 Watch 窗口中输入变量名；
4. 程序运行或单步执行时，可以查看变量值变化。

![添加监控变量](pictures/IAR_45_添加监控变量.png)

## 28. 寄存器信息

寄存器窗口用于查看 CPU 寄存器和外设寄存器信息。

### 28.1 打开寄存器窗口

调试模式下，点击菜单：

```text
View → Register
```

![寄存器窗口](pictures/IAR_46_寄存器窗口.png)

### 28.2 作用

寄存器窗口可以查看：

```text
通用寄存器
程序计数器 PC
堆栈指针 SP
状态寄存器
外设寄存器
```

在调试底层驱动或硬件问题时，寄存器窗口非常常用。

## 29. 内存信息

内存窗口用于查看指定地址处的内存数据。

### 29.1 打开内存窗口

调试模式下，点击菜单：

```text
View → Memory
```

![内存窗口](pictures/IAR_47_内存窗口.png)

### 29.2 查看指定地址

在 Memory 窗口中输入地址，例如：

```text
0x20000000
```

可以查看 RAM 中的数据。

也可以输入变量地址，查看变量在内存中的实际内容。

![查看内存地址](pictures/IAR_48_查看内存地址.png)

## 30. 栈信息

栈信息用于分析函数调用过程中栈空间的使用情况。

### 30.1 打开栈窗口

调试模式下，可以通过 View 菜单打开 Stack 相关窗口。

操作路径示例：

```text
View → Stack
```

![栈信息窗口](pictures/IAR_49.png)

### 30.2 作用

栈信息可以帮助分析：

```text
函数调用占用的栈空间
局部变量使用情况
栈是否溢出
程序异常时的调用情况
```

## 31. 汇编信息

汇编窗口用于查看 C 代码对应的汇编指令。

### 31.1 打开汇编窗口

调试模式下，点击菜单：

```text
View → Disassembly
```

![汇编窗口](pictures/IAR_50_汇编窗口.png)

### 31.2 作用

汇编信息常用于：

```text
分析底层执行流程
查看编译后的指令
调试启动文件
分析中断入口
分析程序跑飞问题
```

## 32. 调用堆栈信息

调用堆栈用于查看当前程序是通过哪些函数调用到当前位置的。

### 32.1 打开调用堆栈窗口

调试模式下，点击菜单：

```text
View → Call Stack
```

![调用堆栈窗口](pictures/IAR_51_调用堆栈窗口.png)

### 32.2 作用

调用堆栈可以帮助分析函数调用关系。

例如程序停在某个函数中，可以通过调用堆栈查看：

```text
main
Task_Run
Driver_Init
Error_Handler
```

这样可以知道程序是怎么执行到当前位置的。

## 33. 单步调试

单步调试用于逐行或逐函数执行程序，方便观察程序运行流程。

常用单步调试功能包括：

```text
逐过程
逐语句
复位
跳出
```

## 33.1 逐过程

逐过程一般对应 Step Over。

作用是执行当前这一行代码，如果当前行是函数调用，则直接执行完整个函数，不进入函数内部。

操作方式：

```text
Debug → Step Over
```

![逐过程](pictures/IAR_52_逐过程.png)

适用场景：

```text
只关心当前函数执行结果，不需要进入函数内部。
```

## 33.2 逐语句

逐语句一般对应 Step Into。

作用是执行当前这一行代码，如果当前行是函数调用，则进入函数内部继续调试。

操作方式：

```text
Debug → Step Into
```

![逐语句](pictures/IAR_53_逐语句.png)

适用场景：

```text
需要查看函数内部具体执行过程。
```

## 33.3 复位

复位用于将程序重新复位到初始状态。

操作方式：

```text
Debug → Reset
```

![复位](pictures/IAR_54_复位.png)

适用场景：

```text
程序运行异常
需要重新从启动位置开始调试
需要重新观察初始化流程
```

## 33.4 跳出

跳出一般对应 Step Out。

作用是从当前函数中执行出去，返回到调用该函数的位置。

操作方式：

```text
Debug → Step Out
```

![跳出](pictures/IAR_55_跳出.png)

适用场景：

```text
已经进入某个函数内部，但不想继续逐行查看该函数。
```

## 34. 调试流程示例

一个常见的 IAR 调试流程如下：

1. 确认工程可以正常编译；
2. 配置正确的调试器；
3. 连接开发板和仿真器；
4. 点击 Download and Debug；
5. 设置断点；
6. 运行程序；
7. 程序停在断点处；
8. 查看 Watch 变量；
9. 查看寄存器、内存、调用堆栈；
10. 使用逐过程、逐语句、跳出等方式分析程序。

## 35. 常见问题

### 35.1 找不到头文件

现象：

```text
cannot open source input file
```

可能原因：

```text
头文件路径没有添加
文件没有加入工程
include 路径写错
```

解决方法：

1. 检查头文件是否存在；
2. 检查 include 路径是否正确；
3. 在 Preprocessor 中添加头文件路径。

### 35.2 链接失败

现象：

```text
Error while running linker
```

可能原因：

```text
链接文件配置错误
函数只声明未定义
库文件没有添加
内存空间不足
```

解决方法：

1. 检查 `.icf` 链接文件；
2. 检查所有 `.c` 文件是否加入工程；
3. 检查静态库是否添加；
4. 查看 `.map` 文件分析内存占用。

### 35.3 下载失败

可能原因：

```text
调试器选择错误
开发板未供电
仿真器未连接
芯片型号选择错误
```

解决方法：

1. 检查调试器连接；
2. 检查目标板供电；
3. 检查 Debugger 配置；
4. 检查 Device 设备型号配置。

### 35.4 断点不生效

可能原因：

```text
优化等级过高
代码没有执行到该位置
断点被禁用
程序已经跑飞
```

解决方法：

1. 降低优化等级；
2. 确认断点已启用；
3. 确认程序流程会执行到该位置；
4. 重新下载程序并调试。

## 36. 总结

IAR 学习主要包括工程操作、工程配置和工程调试三部分。

工程操作包括：

```text
新建/打开工作区
新建/打开工程
添加已有工程
新建分组
新建/打开文件
理解工程目录与文件目录关系
```

工程配置包括：

```text
设备配置
编译配置
优化等级
硬件浮点
预处理
链接文件
文件路径
输出文件
调试器
库相关配置
静态库封装
静态库调用
```

工程调试包括：

```text
设置断点
禁用断点
启用断点
删除断点
条件断点
查看变量
查看寄存器
查看内存
查看栈
查看汇编
查看调用堆栈
单步调试
```

通过以上学习，可以掌握 IAR 在嵌入式工程中的基本使用流程，为后续进行单片机程序开发、编译下载和调试分析打下基础。