一、 模块设计理念与学习目标
1.1 设计理念
核心思想：让学员在动手实践中建立认知，而非被动接收知识。通过“最小可行实验”快速获得正反馈，建立学习信心。
学习三角模型：
【理论认知】(20%)
/ \
/ \
【动手实践】(60%) -- 【成果验证】(20%)
1.2 学习目标
知识目标：
-
理解嵌入式实时系统的基本概念和特点
-
掌握VxWorks的基本架构和核心组件
-
能够独立搭建完整的VxWorks开发环境
-
能够创建、编译、烧写、运行第一个VxWorks程序
能力目标：
-
具备VxWorks开发环境故障排查能力
-
能够使用VxWorks Shell进行基本操作
-
理解VxWorks系统启动流程
-
掌握基本的嵌入式调试方法
情感目标：
-
建立对嵌入式实时系统开发的兴趣和信心
-
形成严谨、细致的开发习惯
-
培养解决问题的独立思考能力
二、 详细课程内容设计
2.1 子模块1.1：嵌入式实时系统基础（8学时）
理论部分（4学时）
专题1：实时系统核心概念解析
（图1-1：实时系统核心概念图谱）
【实时性】
│
┌───────────────┼───────────────┐
│ │ │
【硬实时】 【软实时】 【确定性】
│ │ │
截止期限必须满足 截止期限可容忍 响应时间可预测
│ │ │
医疗、航空电子 媒体播放 工业控制
汽车控制 通信系统
关键概念讲解：
-
实时性指标：
-
任务切换时间：< 5μs（VxWorks典型值）
-
中断延迟：< 1μs（无屏蔽情况下）
-
上下文切换开销：对比Linux（~20μs）与VxWorks（~3μs）
-
-
任务调度算法详解：
/* 优先级抢占调度示例 */
// Linux CFS调度器 vs VxWorks优先级调度
Linux: 公平性优先，通过vruntime动态调整
VxWorks: 实时性优先，固定优先级+抢占
// 调度器行为对比
Linux VxWorks
调度策略 完全公平调度(CFS) 优先级抢占+时间片轮转
优先级范围 0-139 (100-139实时) 0-255
时间片 动态计算 可配置（默认10ms）
抢占 支持 始终开启
-
实时系统vs通用操作系统对比表：
特性维度
通用OS (Linux/Windows)
实时OS (VxWorks/QNX)
实际影响
调度策略
公平性优先
实时性优先
RTOS任务响应可预测
中断处理
可能被屏蔽
立即响应
RTOS中断延迟<1μs
内存管理
虚拟内存+分页
物理内存为主
RTOS无页面置换延迟
系统调用
可能阻塞
确定性执行
RTOS系统调用时间固定
内核空间
可抢占
不可抢占
RTOS内核响应更一致
专题2：嵌入式系统开发流程
（图1-2：嵌入式实时系统开发全流程）
【需求分析】 → 【架构设计】 → 【详细设计】
↓ ↓ ↓
【环境搭建】 → 【编码实现】 → 【单元测试】
↓ ↓ ↓
【集成测试】 → 【系统测试】 → 【现场部署】
↓ ↓ ↓
【维护升级】 ← 【问题修复】 ← 【监控运行】
开发流程详解：
-
交叉开发环境模型：
主机(Host) 目标机(Target)
┌─────────────┐ ┌─────────────┐
│ 开发工具 │ │ 运行时环境 │
│ 编译器 │ 以太网/串口 │ VxWorks内核 │
│ 调试器 │◄────────────►│ 应用程序 │
│ 源码 │ │ 硬件驱动 │
└─────────────┘ └─────────────┘
-
开发工具链组成：
-
编辑器/IDE：Wind River Workbench, VS Code
-
编译器：GNU工具链 (gcc, ld, as) 或 Diab编译器
-
调试器：GDB + WDB代理
-
构建工具：GNU Make, CMake
-
版本控制：Git
-
烧写工具：tftp, U-Boot, Flash工具
-
实验部分（4学时）
实验1-1：实时性验证实验
实验目标：直观感受实时系统与通用系统的差异
实验设计：
/* Linux测试程序：非实时性演示 */
#include <stdio.h>
#include <time.h>
#include <sched.h>
void busy_work() {
volatile int i;
for(i = 0; i < 1000000; i++); // CPU密集型操作
}
int main() {
struct timespec start, end;
int delays[100];
for(int i = 0; i < 100; i++) {
clock_gettime(CLOCK_MONOTONIC, &start);
busy_work(); // 模拟任务执行
clock_gettime(CLOCK_MONOTONIC, &end);
long elapsed = (end.tv_sec - start.tv_sec) * 1000000 +
(end.tv_nsec - start.tv_nsec) / 1000;
delays[i] = elapsed;
usleep(1000); // 休眠1ms
}
// 分析抖动
int max = delays[0], min = delays[0];
for(int i = 1; i < 100; i++) {
if(delays[i] > max) max = delays[i];
if(delays[i] < min) min = delays[i];
}
printf("Linux执行时间抖动: %d us\n", max - min);
return 0;
}
对比实验：在VxWorks上运行相同逻辑
/* VxWorks测试程序：实时性演示 */
#include <vxWorks.h>
#include <sysLib.h>
#include <tickLib.h>
void busyWork(void) {
volatile int i;
for(i = 0; i < 1000000; i++); // 相同CPU操作
}
void rtTimingTest(void) {
int delays[100];
UINT32 start, end;
for(int i = 0; i < 100; i++) {
start = tickGet(); // 获取系统tick
busyWork();
end = tickGet();
delays[i] = (end - start) * (1000000 / sysClkRateGet());
taskDelay(1); // 延迟1个tick
}
// 分析抖动
int max = delays[0], min = delays[0];
for(int i = 1; i < 100; i++) {
if(delays[i] > max) max = delays[i];
if(delays[i] < min) min = delays[i];
}
printf("VxWorks执行时间抖动: %d us\n", max - min);
}
实验步骤：
-
在Linux Ubuntu上编译运行第一个程序
-
记录执行时间的最大值、最小值、平均值
-
在VxWorks模拟器上运行第二个程序
-
对比两者的时间抖动
-
使用示波器/逻辑分析仪观察实际输出（可选）
预期结果：
操作系统 最小执行时间(us) 最大执行时间(us) 抖动(us)
Linux 980 1520 540
VxWorks 995 1005 10
实验分析要点：
-
讨论Linux抖动大的原因（调度、中断、页面错误）
-
分析VxWorks抖动小的原因（优先级调度、内核不可抢占）
-
理解抖动对实时系统的影响
2.2 子模块1.2：VxWorks体系结构概览（6学时）
理论部分（3学时）
专题1：VxWorks架构演进
（图1-3：VxWorks架构演进图）
VxWorks 5.x (经典) VxWorks 6.x (增强) VxWorks 7.x (现代)
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ 应用层 │ │ 应用层 │ │ 应用层 │
├─────────────┤ ├─────────────┤ ├─────────────┤
│ 内核 │ │ 进程 │ │ 容器/RTP │
├─────────────┤ ├─────────────┤ ├─────────────┤
│ 硬件抽象 │ │ 内核 │ │ 内核 │
└─────────────┘ └─────────────┘ └─────────────┘
单片式设计 MMU保护 完全隔离
VxWorks 7核心架构详解：
/* VxWorks 7架构层次 */
1. 应用层
- 实时进程(RTP)：用户空间，有MMU保护
- 内核模块(Kernel Module)：内核空间，高性能
2. 操作系统层
- 微内核：任务调度、同步、通信
- 文件系统：HRFS, DOSFS, NFS
- 网络栈：TCP/IP, 网络驱动
3. 硬件抽象层
- BSP：板级支持包
- 驱动框架：统一设备模型
- 启动加载：U-Boot, UEFI
专题2：Wind微内核深度解析
内核对象模型：
（图1-4：VxWorks内核对象关系图）
【Wind内核】
│
┌───────────┼───────────┐
↓ ↓ ↓
【任务对象】 【同步对象】 【内存对象】
│ │ │
任务控制块 信号量 内存分区
(WIND_TCB) 消息队列 虚拟内存
事件标志 管道
互斥量 信号
关键数据结构：
/* 任务控制块(TCB)简化视图 */
typedef struct wind_tcb {
/* 任务标识 */
WIND_TCB_ID tcbId; // 任务ID
char name[TASK_NAME_LEN]; // 任务名
/* 调度信息 */
int priority; // 优先级(0-255)
UINT options; // 任务选项
/* 状态信息 */
UINT status; // 任务状态
void* pStackBase; // 栈基址
size_t stackSize; // 栈大小
int stackCurrent; // 当前栈使用
/* 上下文 */
void* psp; // 程序栈指针
void* pc; // 程序计数器
/* 链表指针 */
struct wind_tcb* pPrevReady; // 就绪队列前向
struct wind_tcb* pNextReady; // 就绪队列后向
} WIND_TCB;
内核启动流程：
1. ROM启动阶段
┌→ 硬件初始化 (CPU, MMU, Cache)
│ BSP早期初始化
│ 内存控制器配置
│
2. RAM启动阶段
│ 数据段/BSS段初始化
│ 内核数据结构初始化
│ 设备树解析
│
3. 内核初始化
│ 任务管理器初始化
│ 内存管理器初始化
│ 中断管理器初始化
│
4. 系统启动
└→ 创建root任务
驱动初始化
文件系统挂载
启动用户应用
实验部分（3学时）
实验1-2：系统内部结构探查
实验目标：通过Shell命令深入理解VxWorks内部结构
实验设计：
/* 系统信息探查脚本 */
#include <vxWorks.h>
#include <sysLib.h>
#include <memLib.h>
void systemProbe(void) {
/* 1. 显示系统基本信息 */
printf("=== 系统基本信息 ===\n");
printf("VxWorks版本: %s\n", vxWorksVersion);
printf("CPU架构: %s\n", CPU);
printf("BSP名称: %s\n", sysModel());
printf("内存大小: %d MB\n", sysPhysMemTop() / (1024 * 1024));
/* 2. 显示内核配置 */
printf("\n=== 内核配置参数 ===\n");
printf("最大任务数: %d\n", maxTasks);
printf("系统时钟频率: %d Hz\n", sysClkRateGet());
printf("空闲任务优先级: %d\n", IDLE_PRI);
/* 3. 显示内存布局 */
printf("\n=== 内存布局信息 ===\n");
printf("代码段起始: 0x%08lx\n", (ULONG)&_stext);
printf("数据段起始: 0x%08lx\n", (ULONG)&_sdata);
printf("BSS段结束: 0x%08lx\n", (ULONG)&_end);
/* 4. 显示当前任务信息 */
printf("\n=== 当前任务信息 ===\n");
printf("当前任务ID: 0x%x\n", taskIdCurrent());
printf("当前任务名: %s\n", taskName(taskIdCurrent()));
printf("当前优先级: %d\n", taskPriorityGet(taskIdCurrent()));
}
Shell命令实践：
# 任务相关命令
i # 显示所有任务信息
ti 0x2a # 显示特定任务详细信息
sp # 显示任务堆栈使用
# 内存相关命令
m # 显示内存使用统计
lm # 列出加载的模块
memShow # 显示内存分区信息
# 系统相关命令
version # 显示版本信息
devs # 显示设备列表
iosDevShow # 显示I/O设备
实验步骤：
-
启动VxWorks，进入Shell
-
运行系统探查程序
-
使用Shell命令验证程序输出
-
尝试修改系统参数（如时钟频率）
-
观察参数修改对系统的影响
实验任务清单：
-
[ ] 获取并记录系统版本信息
-
[ ] 列出所有运行中的任务及其状态
-
[ ] 查看内存使用情况，计算空闲内存
-
[ ] 查找并理解系统启动参数
-
[ ] 尝试修改任务优先级，观察调度变化
2.3 子模块1.3：开发环境搭建与配置（10学时）
理论部分（2学时）
专题1：开发环境架构详解
完整开发环境组成：
（图1-5：VxWorks开发环境架构图）
【开发主机】 【目标硬件】
┌──────────────────┐ ┌──────────────────┐
│ Wind River Workbench │ │ 目标板 │
│ ├─ 项目管理器 │ 以太网/TFTP │ ├─ Bootloader │
│ ├─ 编辑器 │◄────────────►│ ├─ VxWorks镜像 │
│ ├─ 编译器 │ 串口/调试 │ ├─ 应用程序 │
│ ├─ 调试器 │ │ └─ 硬件外设 │
│ └─ 分析工具 │ └──────────────────┘
└──────────────────┘
环境配置要点：
-
网络配置：
-
开发机IP：192.168.1.100/24
-
目标板IP：192.168.1.200/24
-
TFTP服务器目录：C:\tftproot
-
确保防火墙开放端口69(TFTP)、1717(WDB)
-
-
串口配置：
-
波特率：115200
-
数据位：8
-
停止位：1
-
校验位：无
-
流控：无
-
专题2：VxWorks工程结构解析
VIP工程结构：
my_project/
├── default/ # 默认构建配置
│ ├── vxWorks # 内核镜像
│ └── vxWorks.sym # 符号表
├── kernel/ # 内核配置
│ ├── configlette/ # 配置代码片段
│ └── project/ # 工程文件
├── usrapp/ # 用户应用
│ ├── src/ # 源代码
│ ├── include/ # 头文件
│ └── Makefile # 构建脚本
└── buildspec # 构建规范
关键配置文件：
# Makefile示例
TARGET_DIR = $(WIND_BASE)/target
CPU = ARMARCH7
TOOL = gnu
# 包含路径
EXTRA_INCLUDE = -I./include -I$(TARGET_DIR)/h
EXTRA_DEFINE = -D_VXWORKS_OS_ -DCPU_$(CPU)
# 编译选项
CFLAGS = -O2 -mcpu=cortex-a9 -mfloat-abi=hard
LDFLAGS = -r -nostdlib
# 源文件
SRCS = main.c task.c driver.c
OBJS = $(SRCS:.c=.o)
# 构建规则
all: usrapp.out
@echo "构建完成"
usrapp.out: $(OBJS)
$(LD) $(LDFLAGS) -o $@ $(OBJS)
实验部分（8学时）
实验1-3：开发环境完整搭建
实验目标：从零开始搭建可用的VxWorks开发环境
步骤1：软件安装与配置（2学时）
安装清单：
1. Wind River Workbench 4.x
- 安装路径：C:\windriver\workbench-4 (无空格)
- 选择组件：Workbench IDE, Compiler, Debugger
- 许可证配置：评估版（90天）
2. VxWorks源码和BSP
- 从Wind River获取对应版本的VxWorks Source
- 安装BSP：如fsl_imx6 (i.MX6开发板)
3. 工具链
- GNU工具链：arm-wrs-vxworks-gcc.exe
- 验证：arm-wrs-vxworks-gcc --version
4. 辅助工具
- TeraTerm/PuTTY (串口终端)
- Tftp32 (TFTP服务器)
- Wireshark (网络调试)
详细安装步骤：
:: 安装后环境验证脚本
@echo off
echo === VxWorks开发环境验证 ===
echo.
:: 1. 检查Workbench安装
if exist "C:\windriver\workbench-4\eclipse.exe" (
echo [√] Workbench安装成功
) else (
echo [×] Workbench未正确安装
)
:: 2. 检查工具链
set PATH=C:\windriver\workbench-4\gnu\4.8.3.0\arm-wrs-vxworks\bin;%PATH%
arm-wrs-vxworks-gcc --version > nul
if %errorlevel% equ 0 (
echo [√] 编译器工具链正常
) else (
echo [×] 编译器工具链异常
)
:: 3. 检查许可证
if exist "%WIND_HOME%\license\license.lic" (
echo [√] 许可证文件存在
) else (
echo [×] 未找到许可证文件
)
echo.
echo === 环境验证完成 ===
pause
步骤2：创建第一个VIP工程（3学时）
创建过程：
1. 启动Workbench
2. File → New → Wind River Workbench Project
3. 选择项目类型：VxWorks Image Project (VIP)
4. 输入项目名：FirstVxWorks
5. 选择BSP：fsl_imx6 (根据实际硬件)
6. 选择内核类型：VIP (VxWorks Image Project)
7. 选择工具链：GNU
8. 完成创建
工程配置详解：
/* 关键配置项说明 */
1. 内核组件选择
- INCLUDE_WINDVIEW (WindView分析工具)
- INCLUDE_SHELL (Shell支持)
- INCLUDE_NETWORK (网络支持)
- INCLUDE_POSIX_CLOCKS (POSIX时钟)
2. 内存配置
- LOCAL_MEM_LOCAL_ADRS: 0x80000000
- LOCAL_MEM_SIZE: 0x20000000 (512MB)
3. 启动参数
- boot device : fei
- processor number : 0
- host name : vxTarget
- file name : vxWorks
- inet on ethernet : fei:192.168.1.200
- inet on backplane:
- host inet : 192.168.1.100
- gateway inet :
- user :
- ftp password :
- flags : 0x0
实验任务：
-
[ ] 成功创建VIP工程
-
[ ] 配置正确的BSP
-
[ ] 选择必要的内核组件
-
[ ] 设置正确的内存映射
-
[ ] 配置网络启动参数
步骤3：编译与下载（3学时）
编译过程：
# 编译脚本示例
#!/bin/bash
# build.sh
echo "=== 开始构建VxWorks镜像 ==="
# 设置环境变量
export WIND_HOME=/opt/windriver
export WIND_BASE=$WIND_HOME/vxworks-7
export PATH=$WIND_BASE/host/bin:$PATH
# 进入工程目录
cd /projects/FirstVxWorks
# 清理旧构建
echo "清理旧文件..."
rm -rf default
# 执行构建
echo "开始编译..."
buildspec -project . -force
if [ $? -eq 0 ]; then
echo "编译成功!"
# 复制镜像到TFTP目录
cp default/vxWorks /tftpboot/
echo "镜像已复制到TFTP目录"
else
echo "编译失败!"
exit 1
fi
下载与启动：
1. 硬件连接检查：
- 串口：开发机COM3 ↔ 目标板UART1
- 网线：开发机 ↔ 目标板
- 电源：12V DC
2. 启动目标板，进入U-Boot：
=> printenv
=> setenv serverip 192.168.1.100
=> setenv ipaddr 192.168.1.200
=> setenv bootfile vxWorks
=> tftp 0x82000000 vxWorks
=> go 0x82000000
3. 观察启动信息：
[U-Boot] Starting application at 0x82000000
[...]
VxWorks启动输出...
[...]
Shell登录提示
常见问题排查：
/* 启动问题诊断 */
1. TFTP失败
- 检查IP设置
- 检查防火墙
- 检查TFTP服务器权限
2. 启动崩溃
- 检查内存配置
- 检查BSP匹配
- 查看串口错误信息
3. 网络不通
- ping测试
- 路由检查
- 网卡驱动加载
实验任务：
-
[ ] 成功编译生成vxWorks镜像
-
[ ] 通过TFTP下载到目标板
-
[ ] 系统正常启动，看到Shell提示符
-
[ ] 能够执行基本Shell命令
-
[ ] 通过网络连接成功
2.4 子模块1.4：第一个VxWorks程序（6学时）
理论部分（2学时）
专题1：VxWorks编程模型
任务vs线程对比：
|
特性 |
VxWorks任务 |
POSIX线程(pthread) |
|---|---|---|
|
创建 |
taskSpawn() |
pthread_create() |
|
终止 |
exit(), taskDelete() |
pthread_exit() |
|
同步 |
semaphore, message queue |
mutex, condition variable |
|
调度 |
优先级抢占 |
依赖系统策略 |
|
内存 |
共享地址空间 |
共享地址空间 |
|
错误处理 |
errno |
返回值 |
任务创建详解：
/* taskSpawn函数原型 */
TASK_ID taskSpawn(
char* name, // 任务名
int priority, // 优先级(0-255)
int options, // 选项
int stackSize, // 栈大小(字节)
FUNCPTR entryPoint, // 入口函数
int arg1, // 参数1
int arg2, // 参数2
int arg3, // 参数3
int arg4, // 参数4
int arg5, // 参数5
int arg6, // 参数6
int arg7, // 参数7
int arg8, // 参数8
int arg9, // 参数9
int arg10 // 参数10
);
专题2：VxWorks Shell编程
Shell交互模式：
/* Shell命令执行流程 */
用户输入命令 → Shell解析 → 查找函数 → 执行 → 返回结果
↓ ↓ ↓ ↓ ↓
命令行 分割参数 符号表查找 调用C函数 输出
常用Shell命令分类：
-
系统信息：i, devs, version, memShow
-
任务管理：sp, td, ts, priority
-
调试工具：lkup, lkAddr, checkStack
-
网络工具：ping, ifconfig, route
-
文件系统：ls, cd, copy, xcopy
实验部分（4学时）
实验1-4：第一个完整VxWorks应用程序
实验目标：创建包含多任务、同步、通信的完整应用
应用设计：
（图1-6：第一个应用架构图）
【主控任务】(优先级100)
│
┌─────┴─────┐
↓ ↓
【传感器任务】(120) 【执行器任务】(110)
│ │
读取传感器 控制执行器
│ │
写入消息队列 读取消息队列
↘ ↙
【日志任务】(90)
│
记录到文件/网络
完整实现代码：
/* 第一个完整的VxWorks应用：智能灯控系统 */
#include <vxWorks.h>
#include <taskLib.h>
#include <msgQLib.h>
#include <semLib.h>
#include <stdio.h>
#include <string.h>
/********************* 全局定义 *********************/
#define SENSOR_TASK_PRI 120
#define ACTUATOR_TASK_PRI 110
#define CONTROL_TASK_PRI 100
#define LOG_TASK_PRI 90
#define MAX_MSGS 10
#define MSG_SIZE sizeof(SensorData)
#define SENSOR_INTERVAL 100 // 100ms采样间隔
#define CONTROL_INTERVAL 200 // 200ms控制周期
/********************* 数据结构 *********************/
/* 传感器数据结构 */
typedef struct {
int light_level; // 光照强度(0-1000)
int motion_detected; // 运动检测(0/1)
UINT32 timestamp; // 时间戳
} SensorData;
/* 控制命令结构 */
typedef struct {
int light_power; // 灯光功率(0-100%)
int alarm_enabled; // 警报使能
} ControlCmd;
/********************* 全局变量 *********************/
MSG_Q_ID sensor_msgQ; // 传感器数据队列
MSG_Q_ID control_msgQ; // 控制命令队列
SEM_ID log_sem; // 日志互斥信号量
int system_running = 1; // 系统运行标志
/********************* 传感器任务 *********************/
void sensorTask(int arg)
{
SensorData data;
int count = 0;
printf("[传感器] 任务启动\n");
while(system_running) {
/* 模拟读取传感器数据 */
data.light_level = 500 + (count % 200); // 模拟光照变化
data.motion_detected = (count % 10 == 0) ? 1 : 0; // 每10次检测一次运动
data.timestamp = tickGet();
/* 发送到消息队列 */
if (msgQSend(sensor_msgQ, (char*)&data, sizeof(data),
NO_WAIT, MSG_PRI_NORMAL) != OK) {
printf("[传感器] 消息队列满，丢弃数据\n");
} else {
count++;
}
/* 固定间隔采样 */
taskDelay(sysClkRateGet() * SENSOR_INTERVAL / 1000);
}
printf("[传感器] 任务退出\n");
}
/********************* 控制任务 *********************/
void controlTask(int arg)
{
SensorData sensor_data;
ControlCmd cmd;
int msg_size;
printf("[控制] 任务启动\n");
while(system_running) {
/* 接收传感器数据 */
msg_size = sizeof(SensorData);
if (msgQReceive(sensor_msgQ, (char*)&sensor_data, msg_size,
WAIT_FOREVER) != ERROR) {
/* 智能控制逻辑 */
if (sensor_data.light_level < 300) {
cmd.light_power = 100; // 光线暗，全功率
} else if (sensor_data.light_level < 700) {
cmd.light_power = 50; // 中等光线，半功率
} else {
cmd.light_power = 10; // 光线强，低功率
}
/* 运动检测控制 */
cmd.alarm_enabled = sensor_data.motion_detected;
/* 发送控制命令 */
if (msgQSend(control_msgQ, (char*)&cmd, sizeof(cmd),
NO_WAIT, MSG_PRI_NORMAL) != OK) {
printf("[控制] 控制队列满\n");
}
printf("[控制] 光照:%d 运动:%d -> 功率:%d%% 警报:%s\n",
sensor_data.light_level,
sensor_data.motion_detected,
cmd.light_power,
cmd.alarm_enabled ? "ON" : "OFF");
}
/* 控制周期 */
taskDelay(sysClkRateGet() * CONTROL_INTERVAL / 1000);
}
printf("[控制] 任务退出\n");
}
/********************* 执行器任务 *********************/
void actuatorTask(int arg)
{
ControlCmd cmd;
int msg_size = sizeof(ControlCmd);
printf("[执行器] 任务启动\n");
while(system_running) {
/* 接收控制命令 */
if (msgQReceive(control_msgQ, (char*)&cmd, msg_size,
WAIT_FOREVER) != ERROR) {
/* 模拟执行控制命令 */
semTake(log_sem, WAIT_FOREVER);
printf("[执行器] 执行: 灯光功率=%d%%, 警报=%s\n",
cmd.light_power,
cmd.alarm_enabled ? "使能" : "禁用");
semGive(log_sem);
/* 这里可以添加实际硬件控制代码 */
// setLightPower(cmd.light_power);
// setAlarm(cmd.alarm_enabled);
}
}
printf("[执行器] 任务退出\n");
}
/********************* 日志任务 *********************/
void logTask(int arg)
{
printf("[日志] 任务启动\n");
while(system_running) {
/* 模拟日志记录 */
semTake(log_sem, WAIT_FOREVER);
printf("[日志] 系统运行正常，时间: %u ticks\n", tickGet());
semGive(log_sem);
/* 每秒记录一次 */
taskDelay(sysClkRateGet()); // 延迟1秒
}
printf("[日志] 任务退出\n");
}
/********************* 系统初始化 *********************/
void systemInit(void)
{
printf("=== 智能灯控系统初始化 ===\n");
/* 创建消息队列 */
sensor_msgQ = msgQCreate(MAX_MSGS, MSG_SIZE, MSG_Q_FIFO);
control_msgQ = msgQCreate(MAX_MSGS, sizeof(ControlCmd), MSG_Q_FIFO);
if (sensor_msgQ == NULL || control_msgQ == NULL) {
printf("错误: 消息队列创建失败\n");
return;
}
/* 创建信号量 */
log_sem = semMCreate(SEM_Q_PRIORITY | SEM_INVERSION_SAFE);
if (log_sem == NULL) {
printf("错误: 信号量创建失败\n");
return;
}
printf("系统资源初始化完成\n");
}
/********************* 任务创建 *********************/
void createTasks(void)
{
int task_id;
printf("开始创建任务...\n");
/* 创建传感器任务 */
task_id = taskSpawn("tSensor", SENSOR_TASK_PRI, 0, 2048,
(FUNCPTR)sensorTask, 0,0,0,0,0,0,0,0,0);
if (task_id == ERROR) {
printf("错误: 传感器任务创建失败\n");
}
/* 创建控制任务 */
task_id = taskSpawn("tControl", CONTROL_TASK_PRI, 0, 2048,
(FUNCPTR)controlTask, 0,0,0,0,0,0,0,0,0);
if (task_id == ERROR) {
printf("错误: 控制任务创建失败\n");
}
/* 创建执行器任务 */
task_id = taskSpawn("tActuator", ACTUATOR_TASK_PRI, 0, 2048,
(FUNCPTR)actuatorTask, 0,0,0,0,0,0,0,0,0);
if (task_id == ERROR) {
printf("错误: 执行器任务创建失败\n");
}
/* 创建日志任务 */
task_id = taskSpawn("tLog", LOG_TASK_PRI, 0, 2048,
(FUNCPTR)logTask, 0,0,0,0,0,0,0,0,0);
if (task_id == ERROR) {
printf("错误: 日志任务创建失败\n");
}
printf("所有任务创建完成\n");
}
/********************* 主函数 *********************/
void firstAppMain(void)
{
printf("\n");
printf("========================================\n");
printf(" 第一个VxWorks应用程序 - 智能灯控\n");
printf("========================================\n\n");
/* 系统初始化 */
systemInit();
/* 创建任务 */
createTasks();
printf("\n系统启动完成，按任意键停止...\n");
/* 等待用户输入停止 */
getchar();
/* 停止系统 */
system_running = 0;
/* 等待任务退出 */
taskDelay(sysClkRateGet() * 2);
/* 清理资源 */
if (sensor_msgQ != NULL) msgQDelete(sensor_msgQ);
if (control_msgQ != NULL) msgQDelete(control_msgQ);
if (log_sem != NULL) semDelete(log_sem);
printf("系统已安全停止\n");
}
实验步骤：
步骤1：代码集成与编译（1学时）
1. 在Workbench中创建用户应用模块
2. 添加源文件 first_app.c
3. 编写Makefile
4. 编译生成可执行文件
5. 将应用集成到VxWorks镜像中
集成方法：
# 应用集成配置
# 在VIP工程的usrAppInit.c中添加：
#include "first_app.h"
void usrAppInit(void)
{
#ifdef INCLUDE_USER_APPL
/* 启动用户应用 */
firstAppMain();
#endif
}
步骤2：系统烧写与运行（1学时）
1. 重新编译包含应用的VxWorks镜像
2. 通过TFTP下载到目标板
3. 启动系统，观察启动信息
4. 验证应用自动运行
步骤3：功能验证与调试（2学时）
验证清单：
-
[ ] 系统正常启动，看到应用启动信息
-
[ ] 所有4个任务成功创建
-
[ ] 传感器数据周期性产生
-
[ ] 控制逻辑正确执行
-
[ ] 执行器接收并执行命令
-
[ ] 日志任务周期性记录
-
[ ] 消息队列和信号量工作正常
-
[ ] 按任意键可安全停止系统
调试命令：
# 在Shell中验证系统状态
-> i # 查看所有任务
-> ti tSensor # 查看传感器任务详情
-> sp tSensor # 查看传感器任务栈使用
-> msgQShow 0x3a5b8c # 查看消息队列状态
-> semShow 0x3a5c00 # 查看信号量状态
预期输出：
========================================
第一个VxWorks应用程序 - 智能灯控
========================================
=== 智能灯控系统初始化 ===
系统资源初始化完成
开始创建任务...
所有任务创建完成
[传感器] 任务启动
[控制] 任务启动
[执行器] 任务启动
[日志] 任务启动
系统启动完成，按任意键停止...
[控制] 光照:520 运动:0 -> 功率:50% 警报:OFF
[执行器] 执行: 灯光功率=50%, 警报=禁用
[日志] 系统运行正常，时间: 1024 ticks
[控制] 光照:680 运动:0 -> 功率:50% 警报:OFF
[执行器] 执行: 灯光功率=50%, 警报=禁用
...
三、 模块评估与考核
3.1 知识掌握度评估
理论测试（30分）：
一、选择题（每题2分，共10分）
1. 下列哪个不是实时系统的核心特征？
A. 确定性 B. 公平性 C. 可靠性 D. 可预测性
2. VxWorks任务优先级的范围是？
A. 0-99 B. 0-255 C. 1-100 D. 任意整数
3. taskSpawn函数的第2个参数表示？
A. 任务名 B. 任务优先级 C. 栈大小 D. 选项
4. 下列哪个工具用于VxWorks镜像下载？
A. TFTP B. FTP C. SCP D. HTTP
5. VxWorks 7支持哪种内存保护机制？
A. MMU B. MPU C. 两者都支持 D. 都不支持
二、简答题（每题4分，共20分）
1. 简述硬实时系统和软实时系统的区别，各举一个应用实例。
2. 说明VxWorks系统启动的主要阶段。
3. 解释任务优先级反转现象及其解决方案。
4. 描述VxWorks开发环境的组成部分。
5. 说明消息队列和信号量在任务通信中的应用场景差异。
实践考核（70分）：
考核项目：智能温控系统实现
系统要求：
1. 创建3个任务：温度采集、温度控制、状态显示
2. 温度采集任务：每200ms读取模拟温度值
3. 温度控制任务：根据温度值控制加热/制冷
4. 状态显示任务：每秒显示系统状态
5. 使用消息队列传递温度数据
6. 使用信号量保护共享资源
7. 系统可安全启动和停止
评分标准：
/* 评分细则 */
1. 环境搭建 (10分)
- 开发环境完整搭建 (5分)
- 工程创建和配置正确 (5分)
2. 代码质量 (20分)
- 代码规范性 (5分)
- 错误处理完整性 (5分)
- 资源管理正确性 (5分)
- 注释完整性 (5分)
3. 功能实现 (30分)
- 任务创建和管理 (10分)
- 同步通信机制 (10分)
- 控制逻辑正确性 (10分)
4. 系统运行 (10分)
- 系统正常启动 (5分)
- 功能验证通过 (5分)
3.2 学习成果评估矩阵
|
评估维度 |
优秀 (85-100) |
良好 (70-84) |
合格 (60-69) |
需改进 (<60) |
|---|---|---|---|---|
|
理论知识 |
概念理解准确，能举一反三 |
概念基本掌握，能回答问题 |
概念基本了解，需提示 |
概念混淆，理解错误 |
|
环境搭建 |
独立完成，能解决异常 |
在指导下完成，能处理常见问题 |
需要较多帮助，耗时较长 |
无法独立完成搭建 |
|
编程能力 |
代码规范，逻辑清晰，错误处理完整 |
代码基本规范，功能完整 |
代码能运行，但质量一般 |
代码无法运行或问题多 |
|
调试能力 |
能独立调试解决复杂问题 |
能使用基本调试工具 |
需要帮助定位问题 |
无法有效调试 |
|
系统理解 |
深入理解系统架构和工作原理 |
理解核心机制 |
了解基本概念 |
对系统缺乏理解 |
四、 常见问题与解决方案
4.1 环境搭建常见问题
问题1：编译器找不到头文件
现象：
error: vxWorks.h: No such file or directory
解决方案：
1. 检查环境变量设置
echo $WIND_BASE
echo $PATH
2. 检查包含路径
CFLAGS添加: -I$(WIND_BASE)/target/h
3. 重新安装工具链
问题2：TFTP下载失败
现象：
TFTP error: 'Permission denied' (2)
解决方案：
1. 检查TFTP目录权限
chmod 777 /tftpboot
2. 检查SELinux状态
setenforce 0
3. 检查防火墙
systemctl stop firewalld
4. 检查文件权限
chmod 644 /tftpboot/vxWorks
问题3：系统启动崩溃
现象：
启动后立即重启或死机
解决方案：
1. 检查内存配置
- 确认RAM大小和地址正确
2. 检查BSP匹配
- 确认BSP与硬件匹配
3. 查看串口调试信息
- 分析崩溃前的输出
4. 使用最小配置启动
- 只包含基本组件
4.2 编程常见问题
问题4：任务栈溢出
现象：
系统不稳定，随机崩溃
检测方法：
1. 使用checkStack()函数
2. 在Shell中使用sp命令
3. 编译时使用栈保护选项
解决方案：
1. 增加栈大小
taskSpawn(..., 4096, ...) // 4KB栈
2. 优化栈使用
- 减少局部数组大小
- 避免深度递归
3. 添加栈溢出检测
#define INCLUDE_STACK_CHECK
问题5：优先级反转
现象：
高优先级任务等待低优先级任务
解决方案：
1. 使用优先级继承协议
semMCreate(SEM_INVERSION_SAFE)
2. 使用优先级天花板协议
semMCreate(SEM_Q_PRIORITY | SEM_INVERSION_SAFE)
3. 合理设计任务优先级
避免长时间的互斥访问
4.3 调试技巧
实时任务状态监控：
/* 任务状态监控工具 */
void taskMonitor(void)
{
int task_id = taskIdListGet(NULL, 0);
WIND_TCB* tcb_list = malloc(task_id * sizeof(WIND_TCB));
task_id = taskIdListGet(tcb_list, task_id);
printf("任务监控 - 时间: %u\n", tickGet());
printf("%-20s %-8s %-8s %-8s\n",
"任务名", "状态", "优先级", "栈使用");
for(int i = 0; i < task_id; i++) {
int stack_used = checkStack(tcb_list[i].tid);
printf("%-20s %-8d %-8d %-8d\n",
tcb_list[i].name,
tcb_list[i].status,
tcb_list[i].priority,
stack_used);
}
free(tcb_list);
}
系统性能分析：
# Shell性能分析命令
-> tt 0x1e6a00 100 # 跟踪任务执行
-> windShow # 显示WindView数据
-> perfShow # 显示性能计数器
-> intShow # 显示中断统计
五、 学习资源与延伸阅读
5.1 必读资料
官方文档：
-
VxWorks 7 Programmer's Guide
-
VxWorks 7 API Reference
-
Wind River Workbench User's Guide
-
Board Support Package Developer's Guide
推荐书籍：
-
实时系统与编程- 王田苗
-
嵌入式实时操作系统VxWorks及其开发环境Tornado- 陈智育
-
VxWorks高级程序设计- 刘森
在线资源：
-
Wind River官方知识库
-
VxWorks社区论坛
-
GitHub开源项目参考
5.2 进阶实验建议
实验1-5：系统性能测量
目标：测量关键实时性指标
内容：
1. 任务切换时间测量
2. 中断延迟测量
3. 系统调用开销分析
4. 内存分配时间统计
工具：逻辑分析仪，高精度计时器
实验1-6：故障注入测试
目标：验证系统鲁棒性
内容：
1. 内存耗尽测试
2. 栈溢出测试
3. 优先级反转测试
4. 死锁检测
工具：自定义测试框架
5.3 模块学习路线建议
建议学习节奏：
第1周：专注环境搭建和第一个程序
周一：理论1.1 + 实验1-1
周二：理论1.2 + 实验1-2
周三：理论1.3 + 实验1-3(前半)
周四：实验1-3(后半)
周五：理论1.4 + 实验1-4(前半)
周末：实验1-4(后半) + 复习
第2周：深入实践和问题解决
周一：调试技巧练习
周二：常见问题复现与解决
周三：扩展实验1-5
周四：扩展实验1-6
周五：项目考核
周末：知识整理与总结
六、 模块总结
模块一“基础与入门”是整个VxWorks培训的基石，成功完成本模块意味着：
-
建立了正确的实时系统认知：理解了实时系统的本质要求和VxWorks的设计哲学
-
掌握了完整的开发工具链：能够独立搭建、配置、使用VxWorks开发环境
-
具备了基本开发能力：能够创建、编译、调试VxWorks应用程序
-
形成了良好的开发习惯：了解了嵌入式实时编程的规范和最佳实践
关键收获：
-
理解了硬实时与软实时的区别及其对系统设计的影响
-
掌握了VxWorks任务模型和调度机制
-
能够使用消息队列、信号量等同步通信机制
-
具备了基本的系统调试和问题排查能力
后续学习方向：
完成本模块后，学员应该：
-
对模块二“核心机制深入”有强烈的学习兴趣
-
能够理解更复杂的同步通信机制
-
准备好学习中断处理、内存管理等高级主题
-
具备进行实际项目开发的基础能力
给学员的建议：
-
多动手，少空想：嵌入式开发是实践性很强的领域
-
善用工具：熟练掌握调试工具能事半功倍
-
理解原理：不仅要会用，还要知道为什么这样用
-
保持耐心：嵌入式开发会遇到各种奇怪问题，耐心是必备品质
通过本模块的系统学习，学员已经迈入了VxWorks开发的大门，为后续深入学习和实际项目开发奠定了坚实的基础。
扫一扫
3419
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
