RTEMS C 语言用户指南

RTEMS C 语言用户指南

c_user.RTEMS_C语言用户指南.双语.V20131224.pdf
RTEMS 的c_user文档的原创翻译。

目录

前 言 49
1 概述 55
1.1  简介 55
1.2  实时应用系统 56
1.3  实时执行器 57
1.4  RTEMS应用架构 59
1.5  RTEMS内部架构 60
1.6  用户定制和扩展 64
1.7  可移植性 64
1.8  内存需求 65
1.9  读者 65
1.10  约定 66
1.11  手册组织 67
2  关键概念 73
2.1  简介 73
2.2  对象 73
2.2.1  对象名称 74
2.2.2  对象ID 75
2.2.2.1  32位对象ID格式 75
2.2.2.2  16位对象ID格式 76
2.2.3  对象ID描述 77
2.3  通信和同步 78
2.4  时间 80
2.5  内存管理 82
3  RTEMS数据类型 83
3.1  简介 83
3.2  数据类型列表 83
4  调度概念 93
4.1  简介 93
4.2  调度算法 93
4.2.1  优先级调度 94
4.2.2  确定性优先级调度 96
4.2.3  简单优先级调度 96
4.2.4  简单SMP优先级调度 97
4.2.5  最早截止期限优先调度 97
4.2.6  恒定带宽服务器调度（CBS） 99
4.3  调度修改机制 100
4.3.1  任务优先级和调度 101
4.3.2  抢占 101
4.3.3  时间片轮转 101
4.3.4  手动轮转 102
4.4  分发任务 102
4.5  任务状态转换 103
5  初始化管理器 111
5.1  简介 111
5.2  背景知识 111
5.2.1  初始化任务 112
5.2.2  系统初始化 112
5.2.3  空闲任务 113
5.2.4  初始化管理器失败 113
5.3  操作 115
5.3.1  初始化RTEMS 115
5.3.2  关闭RTEMS 117
5.4  指令 117
5.4.1  INITIALIZE_DATA_STRUCTURES - 初始化RTEMS数据结构 118
5.4.2  INITIALIZE _BEFORE_DRIVERS – 设备驱动前的初始化 119
5.4.3  INITIALIZE_DEVICE_DRIVERS – 初始化设备驱动程序 120
5.4.4  INITIALIZE_START_MULTITASKING – 完成初始化并启动多任务 122
5.4.5  SHUTDOWN_EXECUTIVE – 关闭RTEMS 124
6  任务管理器 125
6.1  简介 125
6.2  背景知识 126
6.2.1  任务定义 127
6.2.2  任务控制块 127
6.2.3  任务状态 128
6.2.4  任务优先级 129
6.2.5  任务模式 130
6.2.6  访问任务参数 133
6.2.7  浮点考虑 133
6.2.8  每任务变量 135
6.2.9  建立任务属性集 136
6.2.10  建立一个模式和掩码 137
6.3  操作 139
6.3.1  创建任务 139
6.3.2  获取任务ID 140
6.3.3  启动和重启任务 140
6.3.4  挂起和恢复任务 141
6.3.5  延迟当前执行的任务 142
6.3.6  改变任务优先级 142
6.3.7  改变任务模式 143
6.3.8  记事本位置 143
6.3.9  任务删除 143
6.4  指令 144
6.4.1  TASK_CREATE – 创建一个任务 145
6.4.2  TASK_IDENT – 获得一个任务的ID 150
6.4.3  TASK_SELF - 获取调用者ID 152
6.4.4  TASK_START – 启动一个任务 153
6.4.5  TASK_RESTART – 重启一个任务 155
6.4.6  TASK_DELETE – 删除一个任务 157
6.4.7  TASK_SUSPEND – 挂起一个任务 159
6.4.8  TASK_RESUME – 恢复一个任务 161
6.4.9  TASK_IS_SUSPENDED – 确定一个任务是否挂起 163
6.4.10  TASK_SET_PRIORITY – 设置任务优先级 164
6.4.11  TASK_MODE – 改变当前任务模式 166
6.4.12  TASK_GET_NOTE – 获得任务记事本入口 169
6.4.13  TASK_SET_NOTE – 设置任务记事本入口 171
6.4.14  TASK_WAKE_AFTER – 在间隔后唤醒 173
6.4.15  TASK_WAKE_WHEN – 在指定的时间唤醒 174
6.4.16  ITERATE_OVER_ALL_THREADS – 遍历任务 175
6.4.17  TASK_VARIABLE_ADD – 关联每任务变量 176
6.4.18  TASK_VARIABLE_GET – 获取每任务变量的值 178
6.4.19  TASK_VARIABLE_DELETE – 移除每任务变量 180
7  中断管理器 181
7.1  简介 181
7.2  背景知识 181
7.2.1  处理一个中断 182
7.2.2  RTEMS中断级 184
7.2.3  通过RTEMS禁用中断 184
7.3  操作 185
7.3.1  建立一个ISR 185
7.3.2  ISR可以调用的指令 185
7.4  指令 187
7.4.1  INTERRUPT_CATCH – 建立一个ISR 188
7.4.2  INTERRUPT_DISABLE – 禁用中断 189
7.4.3  INTERRUPT_ENABLE – 启用中断 190
7.4.4  INTERRUPT_FLASH – 临时中断 191
7.4.5  INTERRUPT_IS_IN_PROGRESS - 是否正在运行一个ISR 192
8  时钟管理器 193
8.1  简介 193
8.2  背景知识 194
8.2.1  必要的支持 194
8.2.2  时间和日期数据结构 194
8.2.3  时钟节拍和时间片轮转 195
8.2.4  延时 196
8.2.5  超时 196
8.3  操作 197
8.3.1  通知一个节拍 197
8.3.2  设置时间 197
8.3.3  获取时间 198
8.4  指令 199
8.4.1  设置日期和时间 200
8.4.2  CLOCK_GET – 获得日期和时间信息 202
8.4.3  CLOCK_GET_TOD – 获得符合TOD格式的日期和时间 204
8.4.4  CLOCK_GET_TOD_TIMEVAL – 获得符合timeval格式的日期和时间 205
8.4.5  CLOCK_GET_SECONDS_SINCE EPOCH – 获得自新纪元以来的秒数 207
8.4.6  CLOCK_GET_TICKS_PER_SECOND – 获得每秒的节拍数 209
8.4.7  CLOCK_GET_TICKS_SINCE BOOT – 获得自引导以来的节拍数 210
8.4.8  CLOCK_GET_UPTIME – 获得自引导以来的时间 211
8.4.9  CLOCK_GET_UPTIME_TIMEVAL – 获得自引导以来符合timeval格式的时间 212
8.4.10  CLOCK_GET_UPTIME_SECONDS – 获得自引导以来的秒数 213
8.4.11  CLOCK_SET_NANOSECONDS_EXTENSION - 从最近的节拍处理程序安装纳秒功能 214
8.4.12  CLOCK_TICK – 通知一个时钟节拍 216
9  定时器管理器 217
9.1  简介 217
9.2  背景知识 218
9.2.1  必要的支持 218
9.2.2  定时器 218
9.2.3  定时器服务器 219
9.2.4  定时器服务例程 219
9.3  操作 220
9.3.1  创建一个定时器 220
9.3.2  获取定时器ID 220
9.3.3  开始一个间隔定时器 221
9.3.4  开始一个日历时间定时器 221
9.3.5  取消一个定时器 222
9.3.6  重置一个定时器 222
9.3.7  开始定时器服务器 222
9.3.8  删除一个定时器 223
9.4  操作 223
9.4.1  TIMER_CREATE – 创建一个定时器 224
9.4.2  TIMER _IDENT – 获得一个定时器的ID 225
9.4.3  TIMER_CANCEL – 取消一个定时器 226
9.4.4  TIMER_DELETE – 删除一个定时器 227
9.4.5  TIMER_FIRE_AFTER -  在间隔之后触发定时器 228
9.4.6  TIMER_FIRE_WHEN – 在指定的时间触发定时器 229
9.4.7  TIMER_INITIATE_SERVER – 为基于任务的定时器开始服务器 231
9.4.8  TIMER_SERVER_FIRE_AFTER – 在间隔之后触发基于任务的定时器 233
9.4.9  TIMER_SERVER_FIRE_WHEN – 在指定的时间触发基于任务的定时器 235
9.4.10  TIMER_RESET – 重置一个间隔定时器 237
10  单调速率管理器 239
10.1  简介 239
10.2  背景知识 240
10.2.1  单调速率管理器所必要的支持 240
10.2.2  周期统计 240
10.2.3  单调速率管理器定义 242
10.2.4  单调速率调度算法 243
10.2.5  可调度性分析 246
10.2.5.1  假设 246
10.2.5.2  处理器利用率规则 247
10.2.5.3  处理器利用率规则示例 247
10.2.5.4  最早截止期限规则 248
10.2.5.5  最早截止期限规则示例 249
10.2.5.6  放宽假设 251
10.2.5.7  延伸阅读 252
10.3  操作 253
10.3.1  创建一个单调速率周期 253
10.3.2  操纵一个周期 253
10.3.3  获取一个周期的状态 254
10.3.4  取消一个周期 255
10.3.5  删除一个单调速率周期 255
10.3.6  示例 255
10.3.7  简单周期任务 256
10.3.8  多周期任务 258
10.4  指令 261
10.4.1  RATE_MONOTONIC_CREATE – 创建一个单调速率周期 262
10.4.2  RATE_MONOTONIC_IDENT – 获得一个周期的ID 263
10.4.3  RATE _MONOTONIC_CANCEL – 取消一个周期 264
10.4.4  RATE_MONOTONIC_DELETE – 删除一个单调速率周期 265
10.4.5  RATE_MONOTONIC_PERIOD – 推断当前的/启动下一个周期 266
10.4.6  RATE_MONOTONIC_GET STATUS – 从一个周期获取状态 268
10.4.7  RATE_MONOTONIC_GET_STATISTICS – 从一个周期获取统计数据 270
10.4.8  RATE_MONOTONIC_RESET_STATISTICS – 为一个周期重置统计数据 272
10.4.9  RATE_MONOTONIC_RESET_ALL_STATISTICS – 为所有周期重置统计信息 273
10.4.10  RATE_MONOTONIC_REPORT_STATISTICS – 打印周期统计报告 274
11  信号量管理器 276
11.1  简介 276
11.2  背景知识 276
11.2.1  嵌套资源访问 278
11.2.2  优先级反转 278
11.2.3  优先级继承 279
11.2.4  优先级置项 280
11.2.5  创建一个信号量属性集 281
11.2.6  建立一个信号量获取选项集 284
11.3  操作 285
11.3.1  创建一个信号量 285
11.3.2  获取信号量ID 286
11.3.3  捕获一个信号量 286
11.3.4  释放一个信号量 287
11.3.5  删除一个信号量 288
11.4  指令 288
11.4.1  SEMAPHORE_CREATE – 创建一个信号量 289
11.4.2  SEMAPHORE_IDENT – 获得一个信号量的ID 293
11.4.3  SEMAPHORE_DELETE – 删除一个信号量 295
11.4.4  SEMAPHORE_OBTAIN – 捕获一个信号量 297
11.4.5  SEMAPHORE_RELEASE – 释放一个信号量 300
11.4.6  SEMAPHORE_FLUSH – 解锁所有任务以等待一个信号量 302
12  屏障管理器 305
12.1  简介 305
12.2  背景知识 305
12.2.1  自动与手动屏障比较 306
12.2.2  建立屏障属性集 306
12.3  操作 308
12.3.1  创建一个屏障 308
12.3.2  获取屏障ID 308
12.3.3  在一个屏障等待 308
12.3.4  释放一个屏障 309
12.3.5  删除一个屏障 309
12.4  指令 310
12.4.1  BARRIER_CREATE – 创建一个屏障 311
12.4.2  BARRIER_IDENT – 获得一个屏障的ID 313
12.4.3  BARRIER_DELETE – 删除一个屏障 314
12.4.4  BARRIER_OBTAIN – 捕获一个屏障 315
12.4.5  BARRIER_RELEASE – 释放一个屏障 317
13  消息管理器 319
13.1  简介 319
13.2  背景知识 320
13.2.1  消息 320
13.2.2  消息队列 320
13.2.3  建立一个消息队列属性集 321
13.2.4  建立一个MESSAGE_QUEUE_RECEIVE选项集 322
13.3  操作 322
13.3.1  创建一个消息队列 323
13.3.2  获取消息队列ID 323
13.3.3  接收一个消息 324
13.3.4  发送一个消息 324
13.3.5  广播一个消息 325
13.3.6  删除一个消息队列 325
13.4  指令 326
13.4.1  MESSAGE_QUEUE_CREATE – 创建一个队列 327
13.4.2  MESSAGE_QUEUE_IDENT – 获得一个队列的ID 330
13.4.3  MESSAGE_QUEUE_DELETE – 删除一个队列 332
13.4.4  MESSAGE_QUEUE_SEND – 放置消息到一个队列的后面 334
13.4.5  MESSAGE_QUEUE_URGENT – 放置消息到一个队列的前面 336
13.4.6  MESSAGE_QUEUE_BROADCAST – 广播N个消息到一个队列 338
13.4.7  MESSAGE_QUEUE_RECEIVE – 从一个队列接收消息 340
13.4.8  MESSAGE_QUEUE_GET_NUMBER_PENDING – 获得一个挂起队列的消息数量 343
13.4.9  MESSAGE_QUEUE_FLUSH – 清空一个队列的所有消息 344
14  事件管理器 345
14.1  简介 345
14.2  背景知识 345
14.2.1  事件集 345
14.2.2  建立一个事件集或条件 346
14.2.3  建立一个EVEN_RECEIVE选项集 347
14.3  操作 348
14.3.1  发送一个事件集 348
14.3.2  接收一个事件集 349
14.3.3  确定挂起的事件集 349
14.3.4  接收所有挂起的事件 350
14.4  指令 350
14.4.1  EVENT_SEND – 发送事件集到一个任务 351
14.4.2  EVENT_RECEIVE – 接收事件条件 353
15  信号管理器 357
15.1  简介 357
15.2  背景知识 357
15.2.1  信号管理器定义 357
15.2.2  ASR和ISR的比较 358
15.2.3  建立一个信号集 359
15.2.4  建立一个ASR模式 359
15.3  操作 361
15.3.1  建立一个ASR 361
15.3.2  发送一个信号集 362
15.3.3  处理一个ASR 363
15.4  指令 363
15.4.1  SIGNAL_CATCH – 建立一个ASR 364
15.4.2  SIGNAL_SEND – 发送信号集到一个任务 366
16  分区管理器 369
16.1  简介 369
16.2  背景知识 369
16.2.1  分区管理器定义 369
16.2.2  建立一个分区属性集 370
16.3  操作 371
16.3.1  创建一个分区 371
16.3.2  获取分区ID 371
16.3.3  捕获一个缓冲区 372
16.3.4  释放一个缓冲区 372
16.3.5  删除一个分区 372
16.4  指令 372
16.4.1  PARTITION_CREATE – 创建一个分区 374
16.4.2  PARTITION_IDENT – 获得一个分区的ID 377
16.4.3  PARTITION_DELETE – 删除一个分区 379
16.4.4  PARTITION_GET_BUFFER – 从一个分区获得缓冲区 381
16.4.5  PARTITION_RETURN_BUFFER - 将缓冲区返回给一个分区 383
17  区域管理器 385
17.1  简介 385
17.2  背景知识 385
17.2.1  区域管理器定义 386
17.2.2  建立一个属性集 386
17.2.3  建立一个选项集 387
17.3  操作 388
17.3.1  创建一个区域 388
17.3.2  获取区域ID 389
17.3.3  增加内存到一个区域 389
17.3.4  捕获一个段 390
17.3.5  释放一个段 390
17.3.6  获取一个段的大小 391
17.3.7  改变一个段的大小 391
17.3.8  删除一个区域 391
17.4  指令 392
17.4.1  REGION_CREATE –创建一个区域 393
17.4.2  REGION _IDENT – 获得一个区域的ID 395
17.4.3  REGION_DELETE – 删除一个区域 396
17.4.4  REGION_EXTEND – 增加内存到一个区域 397
17.4.5  REGION_GET_SEGMENT – 从一个区域获得段 398
17.4.6  REGION_RETURN_SEGMENT – 将段返回给一个区域 401
17.4.7  REGION_GET_SEGMENT_SIZE – 获取一个段的大小 403
17.4.8  REGION_RESIZE_SEGMENT – 改变一个段的大小 404
18  双端口内存管理器 407
18.1  简介 407
18.2  背景知识 407
18.3  操作 408
18.3.1  创建一个端口 408
18.3.2  获取端口ID 408
18.3.3  转换一个地址 409
18.3.4  删除一个DPMA端口 409
18.4  指令 409
18.4.1  PORT_CREATE – 创建一个端口 411
18.4.2  PORT_IDENT – 获得一个端口的ID 413
18.4.3  PORT_DELETE – 删除一个端口 414
18.4.4  PORT_EXTERNAL_TO_INTERNAL - 将外部地址转换到内部地址 415
18.4.5  PORT_INTERNAL_TO_EXTERNAL - 将内部地址转换到外部地址 416
19  I/O管理器 417
19.1  简介 417
19.2  背景知识 418
19.2.1  设备驱动表 418
19.2.2  主、次设备号 419
19.2.3  设备名称 419
19.2.4  设备驱动环境 420
19.2.5  运行时驱动注册 420
19.2.6  设备驱动接口 421
19.2.7  设备驱动初始化 422
19.3  操作 423
19.3.1  注册和查找名称 423
19.3.2  访问一个设备驱动 423
19.4  指令 423
19.4.1  IO_REGISTER_DRIVER – 注册一个设备驱动 425
19.4.2  IO_UNREGISTER_DRIVER – 注销一个设备驱动 427
19.4.3  IO_INITIALIZE – 初始化一个设备驱动 428
19.4.4  IO_REGISTER_NAME – 注册一个设备 429
19.4.5  IO_LOOKUP_NAME – 查找一个设备 430
19.4.6  IO_OPEN – 打开一个设备 431
19.4.7  IO_CLOSE – 关闭一个设备 432
19.4.8  IO_READ – 从一个设备读 433
19.4.9  IO_WRITE – 写到一个设备 434
19.4.10  IO_CONTROL – 特殊设备服务 435
20  致命错误管理器 437
20.1  简介 437
20.2  背景知识 437
20.3  操作 438
20.3.1  通知一个致命错误 438
20.4  指令 440
20.4.1  FATAL_ERROR_OCCURRED – 调用致命错误处理程序 441
20.4.2  FATAL - 使用错误源调用致命错误处理程序 442
20.4.3  EXCEPTION_FRAME_PRINT – 打印异常帧 443
20.4.4  FATAL_SOURCE_DESCRIPTION – 返回对一个致命源的描述 444
20.4.5  INTERNAL_ERROR_DESCRIPTION - 返回对一个内部错误码的描述 445
21  板级支持包 447
21.1  简介 447
21.2  复位和初始化 447
21.2.1  中断堆栈要求 449
21.2.2  处理器具有一个单独的中断堆栈 450
21.2.3  处理器不具有单独的中断堆栈 450
21.3  设备驱动 451
21.3.1  时钟节拍设备驱动 451
21.4  用户扩展 452
21.5  多处理器通信接口（MPCI） 454
21.5.1  紧耦合系统 454
21.5.2  松耦合系统 455
21.5.3  混合耦合系统 455
21.5.4  异构系统 456
22  用户扩展管理器 457
22.1  简介 457
22.2  背景知识 457
22.2.1  扩展集 458
22.2.2  TCB扩展区 460
22.2.3  扩展 461
22.2.3.1  TASK_CREATE扩展 461
22.2.3.2  TASK_START扩展 462
22.2.3.3  TASK_RESTART扩展 463
22.2.3.4  TASK_DELETE扩展 463
22.2.3.5  TASK_SWITCH扩展 464
22.2.3.6  TASK_BEGIN扩展 465
22.2.3.7  TASK_EXITTED扩展 465
22.2.3.8  FATAL错误扩展 466
22.2.4  调用顺序 467
22.3  操作 468
22.3.1  创建一个扩展集 469
22.3.2  获取扩展集ID 469
22.3.3  删除一个扩展集 469
22.4  指令 470
22.4.1  EXTENSION_CREATE – 创建一个扩展集 471
22.4.2  EXTENSION_IDENT – 获得一个扩展集的ID 472
22.4.3  EXTENSION_DELETE – 删除一个扩展集 473
23  配置一个系统 475
23.1  简介 475
23.2  默认值选择哲学 476
23.3  确定RTEMS工作区大小 476
23.4  RTEMS工作区大小估计的潜在问题 479
23.5  配置示例 480
23.5.1  无限对象 483
23.5.2  每个对象类无限对象实例 485
23.5.3  无限对象实例 486
23.5.4  启用无限对象实例 486
23.5.5  指定无限对象分配大小 487
23.6  经典API配置 488
23.6.1  指定最大经典API任务 488
23.6.2  禁用经典API记事本 489
23.6.3  指定最大经典API定时器 490
23.6.4  指定最大经典API信号量 491
23.6.5  指定最大经典API消息队列 491
23.6.6  指定最大经典API屏障 492
23.6.7  指定最大经典API周期 493
23.6.8  指定最大经典API分区 493
23.6.9  指定最大经典API区域 494
23.6.10  指定最大经典API端口 495
23.6.11  指定最大经典API用户扩展 495
23.7  经典API初始化任务表配置 496
23.7.1  实例化经典API初始化任务表 496
23.7.2  指定经典API初始化任务入口点 497
23.7.3  指定经典API初始化任务名称 498
23.7.4  指定经典API初始化任务栈大小 498
23.7.5  指定经典API初始化任务优先级 499
23.7.6  指定经典API初始化任务属性 500
23.7.7  指定经典API初始化任务模式 501
23.7.8  指定经典API初始化任务参数 501
23.7.9  不使用生成的初始化任务表 502
23.8  POSIX API配置 503
23.8.1  指定最大POSIX API线程 503
23.8.2  指定最大POSIX API互斥体 504
23.8.3  指定最大POSIX API条件变量 505
23.8.4  指定最大POSIX API键 505
23.8.5  指定最大POSIX API定时器 506
23.8.6  指定最大POSIX API排队信号 507
23.8.7  指定最大POSIX API消息队列 507
23.8.8  指定最大POSIX API消息队列描述符 508
23.8.9  指定最大POSIX API信号量 509
23.8.10  指定最大POSIX API屏障 509
23.8.11  指定最大POSIX API自旋锁 510
23.8.12  指定最大POSIX API读/写锁 511
23.9  POSIX初始化线程表配置 511
23.9.1  实例化POSIX API初始化线程表 512
23.9.2  指定POSIX API初始化线程入口点 513
23.9.3  指定POSIX API初始化线程栈大小 513
23.9.4  不使用生成的POSIX初始化线程表 514
23.10  基本系统信息 515
23.10.1  单独或统一的工作区 515
23.10.2  每个时钟节拍的长度 516
23.10.3  指定时间片轮转量子 517
23.10.4  指定线程优先级数量 518
23.10.5  指定最大任务大小 519
23.10.6  配置中断堆栈的大小 520
23.10.7  预留任务/线程栈内存在最小值上方 521
23.10.8  自动归零RTEMS工作区和C程序堆 522
23.10.9  启用任务栈使用检查 523
23.10.10  指定应用特定的用户扩展 523
23.11  配置自定义任务栈分配 524
23.11.1  自定义任务栈分配器初始化 524
23.11.2  自定义任务栈分配器 525
23.11.3  自定义任务栈析构函数 526
23.12  为经典API消息缓冲区配置内存 527
23.12.1  为单个经典消息API消息队列计算内存 527
23.12.2  为所有经典消息API消息队列预留内存 528
23.13  不常用的配置参数 529
23.13.1  指定内存开销 529
23.13.2  不生成配置信息 530
23.14  C库支持配置 531
23.14.1  启用Malloc家族统计 531
23.14.2  指定文件描述符的最大数量 532
23.14.3  禁用POSIX Termios支持 532
23.14.4  指定POSIX Termios的最大端口 533
23.15  文件系统配置参数 534
23.15.1  提供应用程序特定的挂载表 534
23.15.2  配置miniIMFS作为根文件系统 535
23.15.3  配置devFS作为根文件系统 536
23.15.4  禁用文件系统支持 536
23.16  块设备缓存配置 537
23.16.1  启用块设备缓存 537
23.16.2  缓存大小 538
23.16.3  缓冲区最小大小 539
23.16.4  缓冲区最大大小 539
23.16.5  换出任务交换周期 540
23.16.6  换出任务最大块保持时间 540
23.16.7  换出任务优先级 541
23.16.8  每个预读请求的最大块 542
23.16.9  每个写请求的最大块 542
23.16.10  块设备缓存任务的任务栈大小 543
23.16.11  预读任务优先级 543
23.16.12  换出工作者任务计数 544
23.16.13  换出工作者任务优先级 545
23.17  BSP特定的设置 545
23.17.1  禁用BSP配置设置 545
23.17.2  指定BSP支持sbrk() 546
23.17.3  指定BSP特定空闲任务 547
23.17.4  指定BSP空闲任务栈大小的建议值 548
23.17.5  指定BSP特定用户扩展 549
23.17.6  指定BSP特定中断堆栈大小 549
23.17.7  指定BSP特定最大设备数量 550
23.17.8  BSP推荐的已清除的RTEMS工作区 551
23.17.9  指定BSP先决条件驱动 551
23.18  空闲任务配置 552
23.18.1  指定应用特定的空闲任务体 552
23.18.2  指定空闲任务栈大小 553
23.18.3  指定空闲任务执行应用初始化 554
23.19  调度算法配置 555
23.19.1  使用确定性优先级调度 555
23.19.2  使用简单优先级调度 556
23.19.3  使用最早截止期限优先调度 557
23.19.4  使用恒定带宽服务调度 558
23.19.5  使用简单SMP优先级调度 559
23.19.6  配置一个用户提供的调度 560
23.20  SMP特定配置参数 561
23.20.1  指定应用使用多核心（是SMP） 561
23.20.2  指定SMP系统最大处理器数量 562
23.21  设备驱动表 563
23.21.1  指定应用定义的设备驱动表 563
23.21.2  指定最大设备驱动数量 564
23.21.3  指定最大设备数量 565
23.21.4  启用控制台设备驱动 566
23.21.5  启用时钟驱动 566
23.21.6  启用基准定时器驱动 567
23.21.7  指定时钟和基准定时器驱动是不需要的 568
23.21.8  启用实时时钟驱动 569
23.21.9  启用看门狗设备驱动 570
23.21.10  启用图像帧缓冲设备驱动 570
23.21.11  启用根设备驱动 571
23.21.12  指定应用必需的设备驱动 572
23.21.13  指定额外的应用设备驱动 573
23.21.14  启用/dev/null设备驱动 574
23.21.15  启用/dev/zero设备驱动 574
23.22  多处理配置 575
23.22.1  指定应用将使用多处理 575
23.22.2  配置多处理器配置的节点号 576
23.22.3  配置多处理器配置的最大节点数量 577
23.22.4  配置多处理器配置的最大全局对象数量 577
23.22.5  配置多处理器配置的最大代理服务器数量 578
23.22.6  配置多处理器配置的MPCI 579
23.22.7  不生成多处理器配置表 580
23.23  Ada任务 580
23.23.1  指定应用包含Ada代码 581
23.23.2  指定Ada任务的最大数量 582
23.23.3  指定假Ada任务的最大数量 582
23.24  配置数据结构 583
24  多处理管理器 585
24.1  简介 585
24.2  背景知识 586
24.2.1  节点 587
24.2.2  全局对象 587
24.2.3  全局对象表 588
24.2.4  远程操作 588
24.2.5  代理服务器 590
24.2.6  多处理器配置表 591
24.3  多处理器通信接口层 591
24.3.1  INITIALIZATION 593
24.3.2  GET_PACKET 594
24.3.3  RETURN_PACKET 595
24.3.4  RECEIVE_PACKET 595
24.3.5  SEND_PACKET 596
24.3.6  支持异构环境 597
24.4  操作 599
24.4.1  通知一个数据包 599
24.5  指令 599
24.5.1  MULTIPROCESSING_ANNOUNCE – 通知一个包的到达 600
25  栈边界检查 601
25.1  简介 601
25.2  背景知识 601
25.2.1  任务栈 601
25.2.2  执行 602
25.3  操作 603
25.3.1  初始化栈边界检查器 603
25.3.2  检查溢出的任务栈 604
25.3.3  报告任务栈的使用率 604
25.3.4  当一个任务溢出栈时 605
25.4  例程 605
25.4.1  STACK_CHECKER_IS_BLOWN - 有当前任务溢出它的栈 606
25.4.2  STACK_CHECKER_REPORT_USAGE - 报告任务栈的使用率 607
26  CPU使用率统计 609
26.1  简介 609
26.2  背景知识 609
26.3  操作 610
26.3.1  报告CPU使用率统计 610
26.3.2  复位CPU使用率统计 611
26.4  指令 612
26.4.1  cpu_usage_report - 报告CPU使用率统计 613
26.4.2  cpu_usage_reset - 复位CPU使用率统计 614
27  对象服务 615
27.1  简介 615
27.2  背景知识 616
27.2.1  API 616
27.2.2  对象类 616
27.2.3  对象名称 617
27.3  操作 617
27.3.1  分解和重组一个对象ID 618
27.3.2  打印一个对象ID 619
27.4  指令 620
27.4.1  BUILD_NAME - 建立取自于字符的对象名称 621
27.4.2  OBJECT_GET_CLASSIC_NAME - 从ID查找名称 622
27.4.3  OBJECT_GET_NAME – 以字符串形式获取对象名称 623
27.4.4  OBJECT_SET_NAME - 设置对象名称 624
27.4.5  OBJECT_ID_GET_API – 从ID获取API 626
27.4.6  OBJECT_ID_GET_CLASS - 从ID获取类 627
27.4.7  OBJECT_ID_GET_NODE -从ID获取节点 628
27.4.8  OBJECT_ID_GET_INDEX - 从ID获取索引 629
27.4.9  BUILD_ID - 从组件建立对象ID 630
27.4.10  OBJECT_ID_API_MINIMUM - 获取最小API值 631
27.4.11  OBJECT_ID_API_MAXIMUM - 获取最大API值 632
27.4.12  OBJECT_API_MINIMUM_CLASS - 获取最小类值 633
27.4.13  OBJECT_API_MAXIMUM_CLASS - 获取最大类值 634
27.4.14  OBJECT_GET_API_NAME - 获取API名称 635
27.4.15  OBJECT_GET_API_CLASS_NAME - 获取类名称 636
27.4.16  OBJECT_GET_CLASS_INFORMATION - 获取类信息 637
28  链表 639
28.1  简介 639
28.2  背景知识 640
28.2.1  节点 641
28.2.2  控件 642
28.3  操作 642
28.3.1  多线程 642
28.3.2  创建一个链表 643
28.3.3  遍历一个链表 644
28.4  指令 645
28.4.1  用节点初始化链表 646
28.4.2  初始化成空的 647
28.4.3  是NULL节点吗？ 648
28.4.4  头部 649
28.4.5  尾部 650
28.4.6  两个节点相等吗？ 651
28.4.7  链表是空的吗？ 652
28.4.8  这是链表上的第一个节点吗？ 653
28.4.9  这是链表上的最后一个节点吗？ 654
28.4.10  这个链表只有一个节点吗？ 655
28.4.11  返回链表的节点数量（无保护） 656
28.4.12  这个节点是链表的头部吗？ 657
28.4.13  这个节点是链表的尾部吗？ 658
28.4.14  提取节点 659
28.4.15  获得第一个节点 660
28.4.16  插入一个节点 661
28.4.17  添加一个节点 662
28.4.18  追加一个节点 663
29  Timespec助手 665
29.1  简介 665
29.2  背景知识 666
29.2.1  时间存储约定 666
29.3  操作 666
29.3.1  设置和获取timespec值 666
29.3.2  timespec数学函数 667
29.3.3  比较struct timespec实例 668
29.3.4  转换和有效性检查 668
29.4  指令 668
29.4.1  TIMESPEC_SET - 设置struct timespec实例 669
29.4.2  TIMESPEC_ZERO - 归零struct timespec实例 670
29.4.3  TIMESPEC IS VALID - 检查struct timespec实例的有效性 671
29.4.4  TIMESPEC_ADD_TO - 两个struct timespec实例相加 672
29.4.5  TIMESPEC_SUBTRACT - 两个struct timespec实例相减 673
29.4.6  TIMESPEC_DIVIDE - 两个struct timespec实例相除 674
29.4.7  TIMESPEC_DIVIDE_BY_INTEGER - struct timespec实例除以整数 676
29.4.8  TIMESPEC_LESS_THAN - 小于运算符 677
29.4.9  TIMESPEC_GREATER_THAN - 大于运算符 678
29.4.10  TIMESPEC_EQUAL_TO - 检查timespec等式 679
29.4.11  TIMESPEC_GET_SECONDS - 获得struct timespec实例的秒部分 680
29.4.12  TIMESPEC_GET_NANOSECONDS - 获得struct timespec实例的纳秒部分 681
29.4.13  TIMESPEC_TO_TICKS - 转换struct timespec实例到节拍 682
29.4.14  TIMESPEC_FROM_TICKS - 转换节拍到struct timespec表示法 683
30  恒定带宽服务器调度器API 685
30.1  简介 685
30.2  背景知识 686
30.2.1  恒定带宽服务器定义 686
30.2.2  处理周期任务 687
30.2.3  注册回调函数 687
30.2.4  限制 688
30.3  操作 689
30.3.1  设置服务器 689
30.3.2  附加任务到服务器 689
30.3.3  从服务器分离任务 690
30.3.4  示例 690
30.4  指令 692
30.4.1  CBS_INITIALIZE - 初始化CBS库 693
30.4.2  CBS_CLEANUP - 清除CBS库 694
30.4.3  CBS_CREATE_SERVER - 创建新的带宽服务器 695
30.4.4  CBS_ATTACH_THREAD - 附加线程到服务器 697
30.4.5  CBS_DETACH_THREAD - 从服务器分离线程 698
30.4.6  CBS_DESTROY_SERVER - 销毁带宽服务器 699
30.4.7  CBS_GET_SERVER_ID - 获得服务器的ID 700
30.4.8  CBS_GET_PARAMETERS - 获得服务器的调度参数 701
30.4.9  CBS_SET_PARAMETERS - 设置调度参数 702
30.4.10  CBS_GET_EXECUTION_TIME - 获得已流逝的执行时间 703
30.4.11  CBS_GET-REMAINING_BUDGET - 获得剩余的执行时间 704
30.4.12  CBS_GET_APPROVED_BUDGET - 获得调度器核准的执行时间 705
31  指令状态码 707
32  实例应用 709
33  术语 711
命令和变量索引 735
概念索引 737

1  Overview
1  概述

1.1  Introduction
1.1  简介
RTEMS, Real-Time Executive for Multiprocessor Systems, is a real-time executive (kernel) which provides a high performance environment for embedded military applications including the following features:
RTEMS，多处理器系统上的实时执行器，是一个为嵌入式军事应用提供高性能环境的实时执行器（内核），包括以下特征：

 multitasking capabilities
 多任务处理能力

 homogeneous and heterogeneous multiprocessor systems
 同构和异构多处理器系统

 event-driven, priority-based, preemptive scheduling
 事件驱动，基于优先级，抢占式调度

 optional rate monotonic scheduling
 可选的单调速率调度

 intertask communication and synchronization
 任务间通信和同步

 priority inheritance
 优先级继承

 responsive interrupt management
 快速的中断管理

 dynamic memory allocation
 动态内存分配

 high level of user configurability
 高度用户可配置性

This manual describes the usage of RTEMS for applications written in the C programming language. Those implementation details that are processor dependent are provided in the Applications Supplement documents. A supplement document which addresses specific architectural issues that affect RTEMS is provided for each processor type that is supported.
本指南描述了RTEMS在C编程语言编写应用程序时的用法。那些依赖于处理器的实现细节是在应用程序增补文档里提供的。为每个支持的处理器类型提供一个增补文档，解决影响RTEMS的特定的架构问题。

1.2  Real-time Application Systems
1.2  实时应用系统
Real-time application systems are a special class of computer applications. They have a complex set of characteristics that distinguish them from other software problems. Generally, they must adhere to more rigorous requirements. The correctness of the system depends not only on the results of computations, but also on the time at which the results are produced. The most important and complex characteristic of real-time application systems is that they must receive and respond to a set of external stimuli within rigid and critical time constraints referred to as deadlines. Systems can be buried by an avalanche of interdependent, asynchronous or cyclical event streams.
实时应用系统是一类特殊的计算机应用。他们有一套复杂的区别于其他软件问题的特征。一般来说，他们必须遵守更严格的要求。该系统的正确性不仅取决于计算的结果，而且取决于产生结果的时间。最重要和最复杂的实时应用系统的特点是，他们必须在被称为截止期限的严格的临界时间限制内接收并响应一组外部刺激。系统可能被相互依存、异步或循环事件流的雪崩埋葬。

Deadlines can be further characterized as either hard or soft based upon the value of the results when produced after the deadline has passed. A deadline is hard if the results have no value or if their use will result in a catastrophic event. In contrast, results which are produced after a soft deadline may have some value.
根据在截止期限过去之后所产生的结果的价值，截止期限可以进一步定性为硬还是软。如果结果没有任何价值，或者它们的使用将会造成灾难性的事件，截止期限是硬的。与此相反，软的截止期限之后所产生的结果可能有一定的价值。

Another distinguishing requirement of real-time application systems is the ability to coordinate or manage a large number of concurrent activities. Since software is a synchronous entity, this presents special problems. One instruction follows another in a repeating synchronous cycle. Even though mechanisms have been developed to allow for the processing of external asynchronous events, the software design efforts required to process and manage these events and tasks are growing more complicated.
另一个显著的实时应用系统的要求是协调和管理大量并发活动的能力。由于软件是一个同步的实体，这带来了特殊的问题。在一个循环的同步周期内一条指令接着另一条指令。虽然已经制定机制，允许外部异步事件的处理，但处理和管理这些事件和任务所需的软件设计工作正变得更加复杂。

The design process is complicated further by spreading this activity over a set of processors instead of a single processor. The challenges associated with designing and building real-time application systems become very complex when multiple processors are involved. New requirements such as interprocessor communication channels and global resources that must be shared between competing processors are introduced. The ramifications of multiple processors complicate each and every characteristic of a real-time system.
设计过程是通过在一组处理器，而不是一个单一的处理器扩展此活动而进一步复杂化。涉及多个处理器时，设计和建立实时应用系统相关的挑战变得非常复杂。引入了新的需求，比如处理器之间的通信通道和全局资源，必须在相互竞争的处理器之间共享。多个处理器的后果使实时系统的每个特性复杂化。

1.3  Real-time Executive
1.3  实时执行器
Fortunately, real-time operating systems or real-time executives serve as a cornerstone on which to build the application system. A real-time multitasking executive allows an application to be cast into a set of logical, autonomous processes or tasks which become quite manageable. Each task is internally synchronous, but different tasks execute independently, resulting in an asynchronous processing stream. Tasks can be dynamically paused for many reasons resulting in a different task being allowed to execute for a period of time. The executive also provides an interface to other system components such as interrupt handlers and device drivers. System components may request the executive to allocate and coordinate resources, and to wait for and trigger synchronizing conditions. The executive system calls effectively extend the CPU instruction set to support efficient multitasking. By causing tasks to travel through well-defined state transitions, system calls permit an application to demand-switch between tasks in response to real-time events.
幸运的是，实时操作系统或实时执行器作为一个建立应用系统基石。实时多任务执行器允许应用程序被转换成一组逻辑、自主进程或变得很易于管理的任务。每个任务都是内部同步的，但不同的任务独立地执行，导致一个异步处理流。任务可以被动态地暂停的原因有很多，导致在一段时间内被允许执行不同的任务。执行器还提供了一个接口到其他系统组件，如中断处理程序和设备驱动程序。系统组件可请求执行器分配和协调资源，以等待和触发同步条件。执行器系统调用有效扩展了为支持高效的多任务的CPU指令集。通过使任务以良好定义的状态转换，系统调用允许一个应用程序响应实时事件的任务之间切换的需求。

By proper grouping of responses to stimuli into separate tasks, a system can now asynchronously switch between independent streams of execution, directly responding to external stimuli as they occur. This allows the system design to meet critical performance specifications which are typically measured by guaranteed response time and transaction throughput. The multiprocessor extensions of RTEMS provide the features necessary to manage the extra requirements introduced by a system distributed across several processors. It removes the physical barriers of processor boundaries from the world of the system designer, enabling more critical aspects of the system to receive the required attention. Such a system, based on an efficient real-time, multiprocessor executive, is a more realistic model of the outside world or environment for which it is designed. As a result, the system will always be more logical, efficient, and reliable.
对刺激的反应通过适当的分组到各自的任务，系统现在可以在独立的执行流之间异步切换，当外界刺激发生时直接作出反应。这可让系统设计满足关键的性能指标，典型的是通过对有保证的响应时间和事务吞吐量的测量。RTEMS的多处理器扩展提供了必要的由分布在多个处理器的系统所造成的额外要求的管理功能。它从系统设计人员的世界消除了处理器边界的物理障碍，使系统更关键的方面得到应有的关注。这样的系统，基于一个高效实时的、多处理器的执行器，它的设计是一个对外界或环境的更逼真的模型。其结果是，该系统将始终是更合理的、高效的和可靠的。

By using the directives provided by RTEMS, the real-time applications developer is freed from the problem of controlling and synchronizing multiple tasks and processors. In addition, one need not develop, test, debug, and document routines to manage memory, pass messages, or provide mutual exclusion. The developer is then able to concentrate solely on the application. By using standard software components, the time and cost required to develop sophisticated real-time applications is significantly reduced.
通过使用由 RTEMS 提供的指令，实时应用程序开发人员将从控制和同步多任务和多处理器的问题中解脱出来。此外，不需要开发、测试、调试和管理内存、传递消息或提供互斥的文档例程。开发人员可以仅仅专注于应用程序。通过使用标准的软件组件，需要开发复杂的实时应用程序的时间和成本显著降低。

全文下载地址：http://download.csdn.net/detail/zhumaill/7002665