<4D F736F F D20C9BEB7B1BECDBCF2B5A5C6ACBBFAC8EBC3C5B5BDBEABCDA8BDDAD1A12E646F63>

Transcription

1 第 四 章 单 片 机 C 语 言 终 于 结 束 了 晦 涩 枯 燥 的 第 三 章, 我 自 己 也 长 吁 了 一 口 气, 现 在 我 真 的 是 非 常 同 情 那 些 教 专 业 基 础 课 或 者 工 程 数 学 的 老 师, 这 里 真 诚 的 说 一 声 : 辛 苦 你 们 了 这 一 章 要 轻 松 不 少, 相 信 就 算 是 刚 走 出 校 门 的 雏 鸟, 多 少 都 有 一 定 的 C 语 言 基 础, 大 学 好 象 都 要 过 一 个 计 算 机 等 级 考 试, 所 以 C 语 言 自 然 是 逃 不 了 你 不 要 指 望 我 给 你 讲 述 C 语 言 原 理 和 指 令 这 类 基 础 知 识, 我 更 不 会 给 你 讲 述 C++ 那 些 面 对 对 象 编 程 的 高 级 编 程 方 法, 这 一 章 讲 述 的 内 容 都 是 C 语 言 在 单 片 机 上 应 用 会 遇 到 的 一 些 有 意 思 的 现 象, 让 你 知 道 C 在 单 片 机 上 是 怎 么 工 作 的 当 然 也 会 告 诉 你 一 些 C 的 经 验 技 巧, 这 些 对 提 升 你 的 单 片 机 程 序 能 力 还 是 有 一 定 作 用 的 4.1. 单 片 机 C 语 言 早 期 单 片 机 编 程 是 没 有 C 语 言 支 持 的, 都 是 汇 编 甚 至 是 二 进 制 的 机 器 码, 随 着 电 脑 技 术 的 突 飞 猛 进, 单 片 机 编 程 不 再 安 于 汇 编 的 一 亩 三 分 地, 也 向 着 C 语 言 的 方 向 进 发 理 论 上 讲 单 片 机 实 现 C 语 言 编 程 不 存 在 丝 毫 问 题, 毕 竟 和 电 脑 是 同 根 生, 于 是 一 批 专 业 或 非 专 业 有 着 利 益 目 的 或 无 利 益 目 的 的 工 程 师 开 始 了 这 方 面 的 努 力 和 电 脑 最 大 的 不 同 是 单 片 机 种 类 繁 多, 不 象 电 脑 只 有 那 么 几 种 芯 片, 而 且 电 脑 CPU 的 发 展 遵 循 着 一 定 的 规 则, 不 同 CPU 要 求 做 到 指 令 兼 容, 单 片 机 做 这 样 的 要 求 显 然 不 现 实, 厂 商 不 可 能 接 受 都 遵 循 制 定 标 准 设 定 MCU 的 要 求 虽 然 单 片 机 种 类 繁 多, 但 大 部 分 单 片 机 还 是 会 采 用 通 用 构 架 进 行 设 计, 毕 竟 遵 循 一 定 标 准 可 以 不 用 厂 商 自 己 去 完 成 指 令 系 统 编 译 工 具 等 繁 琐 工 作, 所 以 市 面 上 流 行 的 单 片 机 内 核 其 实 并 不 多, 不 少 八 位 的 单 片 机 都 采 用 51 内 核, 高 端 的 MCU 内 核 更 是 集 中 在 ARM/MIPS 这 几 种 当 中 厂 商 设 计 的 MCU 通 常 都 会 沿 用 某 一 种 构 架, 也 就 是 厂 商 产 品 目 录 中 的 xx 系 列, 这 样 做 厂 商 可 以 节 省 开 发 成 本, 一 套 编 译 器 可 以 为 一 个 甚 至 多 个 系 列 的 MCU 所 用, 这 样 新 设 计 MCU 或 编 译 器 有 问 题 也 可 以 在 日 后 进 行 改 进, 如 果 弄 成 一 种 MCU 就 对 应 一 套 编 译 器 的 方 式, 神 仙 也 会 疯 掉 厂 商 为 了 占 领 更 多 的 市 场, 自 然 就 会 依 据 市 场 需 求 针 对 MCU 推 出 C 的 编 译 器, 不 过 这 种 做 法 所 退 出 的 C 编 译 器 质 量 局 限 于 厂 商 自 己 技 术 能 力, 通 常 说 这 类 编 译 器 可 以 用, 但 不 要 期 望 有 着 很 高 的 效 率 如 果 是 流 行 面 广 的 内 核, 会 有 另 外 一 种 方 式, 就 是 专 业 的 软 件 公 司 针 对 这 种 内 核 的 指 令 系 统 开 发 C 编 译 器, 象 KEIL C 就 是 一 例, 这 种 软 件 公 司 在 编 译 方 面 经 验 丰 富, 所 以 他 们 做 出 来 的 编 译 器 效 率 方 面 相 当 不 错, 只 要 是 他 们 编 译 器 支 持 的 内 核, 就 很 容 易 让 编 译 器 支 持 软 件 公 司 推 出 的 C 编 译 器 虽 然 好, 但 要 钱, 有 免 费 的 版 本 可 限 制 多 多, 技 术 世 界 从 来 不 缺 少 活 雷 锋,GCC 这 样 的 组 织 让 免 费 获 取 C 编 MCU EDU 第 134 页 作 者 :Dai ShangJu

2 译 器 成 为 了 现 实, 不 过 这 类 组 织 所 支 持 的 对 象 只 能 是 内 核 为 ARM/MIPS 的 高 端 通 用 MCU 想 要 做 好 单 片 机 的 C 编 译 器 则 必 须 具 备 这 两 个 条 件 : 一 是 熟 悉 MCU 的 硬 件 资 源 和 指 令 系 统, 二 是 熟 悉 C 语 言, 两 者 缺 一 不 可, 否 则 是 做 不 出 一 个 优 质 高 效 的 单 片 机 C 编 译 器 的 编 译 器 的 工 作 就 是 将 用 C 写 的 代 码 按 一 定 规 则 转 换 成 汇 编 指 令, 这 样 程 序 员 面 对 的 是 接 近 自 然 语 言 的 C 代 码, 对 程 序 的 结 构 控 制 含 义 理 解 等 会 容 易 不 少 由 于 转 换 操 作 依 赖 编 译 器, 虽 然 一 个 编 译 器 需 要 经 过 大 量 测 试 才 会 推 出, 但 测 试 无 法 涵 盖 所 有 的 编 程 可 能, 这 样 编 译 器 并 不 能 保 证 可 靠 性 为 百 分 百, 一 旦 有 错 误 产 生, 调 试 会 麻 烦 许 多, 毕 竟 错 误 不 是 程 序 员 而 是 编 译 器 产 生 的, 在 C 语 言 层 面 会 让 错 误 弄 得 一 头 雾 水, 当 然 程 序 员 对 C 和 汇 编 都 很 熟 悉 的 话 还 是 可 以 通 过 查 看 汇 编 代 码 的 方 式 来 查 找 编 译 器 错 误 同 电 脑 的 C 相 比 单 片 机 的 C 编 程 存 在 自 己 的 特 点 : 电 脑 用 C 写 程 序 奉 行 的 是 硬 件 无 关 的 原 则, 程 序 员 只 要 了 解 C 的 语 法 就 可 以, 就 是 深 入 到 驱 动 程 序 层 面 也 只 需 要 了 解 驱 动 程 序 的 接 口 就 够, 单 片 机 则 不 然,C 只 是 让 程 序 员 面 对 的 代 码 不 再 是 汇 编 格 式, 程 序 编 写 依 然 还 是 要 了 解 硬 件 特 性, 只 是 将 原 本 由 汇 编 写 的 硬 件 控 制 代 码 改 成 了 C 的 语 法 格 式 ; 为 了 最 大 程 度 的 利 用 单 片 机 的 各 种 指 令, 单 片 机 的 C 编 译 器 同 电 脑 的 C 编 译 器 相 比 可 能 会 有 多 不 同, 比 如 对 某 些 C 语 法 做 出 修 改, 象 KEIL C 对 51 系 列 的 单 片 机 就 多 出 了 位 变 量 的 定 义 和 操 作 的 语 法 ; 单 片 机 结 构 要 比 电 脑 简 单, 所 提 供 的 资 源 也 要 少 许 多, 希 望 能 支 持 C 编 程 也 主 要 是 为 了 让 程 序 结 构 简 单 明 晰, 所 以 C 的 控 制 流 程 语 法 就 已 经 够 用, 并 不 需 要 象 电 脑 一 样 在 标 准 C 的 基 础 上 继 续 类 似 C++ 各 种 改 进 但 也 不 是 绝 对, 现 在 各 种 嵌 入 式 平 台 也 还 是 尽 力 向 电 脑 方 向 靠 拢, 这 样 做 我 的 理 解 是 众 人 拾 柴 火 焰 高, 嵌 入 式 已 经 发 展 到 了 需 要 许 多 人 合 作 才 能 实 现 的 阶 段 单 片 机 用 C 编 程 便 捷 性 无 疑 是 大 为 提 高, 可 当 用 C 实 现 对 单 片 机 支 持 后 新 问 题 出 现, 这 就 是 目 前 我 们 国 家 的 现 状 是 做 单 片 机 的 大 多 是 电 子 信 息 类 的 专 业 出 生, 在 学 习 阶 段 以 控 制 方 面 的 知 识 为 主,C 只 是 做 为 辅 助 课 程 出 现, 更 不 用 说 软 件 工 程 之 类 的 课 程, 这 样 当 这 部 分 人 由 学 生 转 入 工 作 时 容 易 写 出 汇 编 C 代 码, 就 是 语 法 是 C 而 程 序 风 格 和 思 路 是 汇 编, 在 计 算 机 专 业 出 身 的 人 眼 里 看 为 垃 圾 代 码, 如 果 本 身 是 计 算 机 专 业 出 身 去 写 单 片 机 C 程 序 又 会 面 临 电 子 专 业 基 础 不 足 的 问 题 这 一 章 我 会 告 诉 习 惯 汇 编 的 单 片 机 程 序 员 一 些 C 的 经 验 和 技 巧, 相 信 通 过 这 章 的 学 习 会 让 你 对 C 的 单 片 机 编 程 有 更 深 的 认 识 4.2. for() 和 while() 循 环 不 同 程 序 员 都 有 自 己 的 编 程 风 格, 让 一 个 程 序 员 用 代 码 实 现 死 循 环,C 出 身 的 程 序 员 习 惯 会 用 for(;;) 和 while(1), 而 汇 编 出 身 的 程 序 员 则 习 惯 用 goto loop_label, 风 格 上 的 差 异 都 可 以 接 受, 但 如 果 深 入 到 代 码 效 率 层 面 就 会 发 现 不 同 的 循 环 方 式 效 率 也 会 存 在 差 别 用 C 语 言 写 出 循 环 100 次 的 九 种 不 同 实 现 方 式 : void MCU_CTest(void) MCU EDU 第 135 页 作 者 :Dai ShangJu

3 unsigned long i; unsigned long vtemp; //------loop mode //------loop mode //------loop mode //------loop mode //------loop mode //------loop mode //------loop mode //------loop mode //------loop mode //------end flag vtemp=0; 方 式 一 C 代 码 : vtemp=0; for(i=0;i<100;i++) vtemp=vtemp+i; 方 式 一 汇 编 代 码 说 明 : 0x1dc0: MOV R1,#0 ;vtemp=0, 第 一 种 循 环 0x1dc4: MOV R0,#0 ;i=0, 循 环 次 数 清 零 0x1dc8: CMP R0,#0x64 ; 将 i 和 100 比 较 0x1dcc: BCS 0x1de4 ;i 大 于 等 于 100 则 跳 到 地 址 0x1de4, 结 束 循 环 0x1dd0: B 0x1ddc ; 跳 转 到 地 址 0x1ddc 好 进 行 vtemp=vtemp+i 0x1dd4: ADD R0,R0,#0x1 ;i++ 0x1dd8: B 0x1dc8 ; 跳 转 到 地 址 0x1dc8 好 判 断 i 是 否 小 于 100 0x1ddc: ADD R1,R1,R0 ;vtemp=vtemp+i 0x1de0: B 0x1dd4 ; 跳 转 到 地 址 0x1dd4 0x1de4: MOV R1,#0 ;vtemp=0, 第 二 种 循 环 开 始 MCU EDU 第 136 页 作 者 :Dai ShangJu

4 图 ARM 汇 编 结 果 示 意 图 一 方 式 一 汇 编 代 码 执 行 流 程 : 0x1dc0: MOV R1,#0 ;vtemp=0, 第 一 种 循 环 0x1dc4: MOV R0,#0 ;i=0, 循 环 次 数 清 零 0x1dc8: CMP R0,#0x64 ; 将 i 和 100 比 较, 此 时 i 为 0, 第 一 次 循 环 0x1dcc: BCS 0x1de4 ; 比 较 结 果 不 用 跳 转 0x1dd0: B 0x1ddc ; 跳 转 到 地 址 0x1ddc 0x1ddc: ADD R1,R1,R0 ;vtemp=vtemp+i 0x1de0: B 0x1dd4 ; 跳 转 到 地 址 0x1dd4 0x1dd4: ADD R0,R0,#0x1 ;i++ 0x1dd8: B 0x1dc8 ; 跳 转 到 地 址 0x1dc8 0x1dc8: CMP R0,#0x64 ; 将 i 和 100 比 较, 此 时 i 为 1, 第 二 次 循 环 0x1dcc: BCS 0x1de4 ; 比 较 结 果 不 用 跳 转 0x1dd0: B 0x1ddc ; 跳 转 到 地 址 0x1ddc 0x1ddc: ADD R1,R1,R0 ;vtemp=vtemp+i 0x1de0: B 0x1dd4 ; 跳 转 到 地 址 0x1dd4 0x1dd4: ADD R0,R0,#0x1 ;i++ MCU EDU 第 137 页 作 者 :Dai ShangJu

5 0x1dd8: B 0x1dc8 ; 跳 转 到 地 址 0x1dc8 0x1dc8: CMP R0,#0x64 ; 将 i 和 100 比 较, 此 时 i 为 2, 第 三 次 循 环 方 式 一 执 行 一 次 循 环 需 要 7 条 指 令, 其 中 真 正 跳 转 3 次 方 式 二 C 代 码 : vtemp=0; i=0; while(i<100) vtemp=vtemp+i; i++; 方 式 二 汇 编 代 码 说 明 : 0x1de4: MOV R1,#0 ;vtemp=0, 第 二 种 循 环 0x1de8: MOV R0,#0 ;i=0, 循 环 次 数 清 零 0x1dec: NOP ; 空 操 作 0x1df0: CMP R0,#0x64 ; 将 i 和 100 比 较 0x1df4: BCS 0x1e04 ;i 大 于 等 于 100 则 跳 到 地 址 0x1de4, 结 束 循 环 0x1df8: ADD R1,R1,R0 ;vtemp=vtemp+i 0x1dfc: ADD R0,R0,#0x1 ;i++ 0x1e00: B 0x1df0 ; 跳 转 到 地 址 0x1df0 0x1e04: MOV R1,#0 ;vtemp=0, 第 三 种 循 环 开 始 MCU EDU 第 138 页 作 者 :Dai ShangJu

6 图 ARM 汇 编 结 果 示 意 图 二 1 次 方 式 二 汇 编 代 码 执 行 流 程 比 方 式 一 要 简 单, 执 行 阴 影 部 分 循 环 只 需 要 5 条 指 令, 其 中 真 正 跳 转 为 节 约 篇 幅 其 它 方 式 只 将 汇 编 代 码 整 理 出 来, 不 贴 图 加 以 说 明 方 式 三 C 代 码 : vtemp=0; i=0; while((i++)<100) vtemp=vtemp+i; 方 式 三 汇 编 代 码 说 明 : 0x1e04: MOV R1,#0 ;vtemp=0, 第 三 种 循 环 0x1e08: MOV R0,#0 ;i=0, 循 环 次 数 清 零 0x1e0c: NOP ; 空 操 作 0x1e10: MOV R2,R0 ; 将 i 的 值 用 中 间 变 量 保 存 起 来 0x1e14: ADD R0,R0,0x1 ;i++ 0x1e18: CMP R2,#0x64 ; 未 加 之 前 的 i 和 100 进 行 比 较 0x1e1c: BCS 0x1e28 ; 大 于 等 于 100 跳 转 到 地 址 0x1e28, 结 束 循 环 0x1e20: ADD R1,R1,R0 ;vtemp=vtemp+i 0x1e24: B 0x1e10 ; 跳 转 到 地 址 0x1e10 0x1e28: MOV R1,#0 ;vtemp=0, 第 四 种 循 环 开 始 方 式 三 汇 编 代 码 执 行 阴 影 部 分 循 环 需 要 6 条 指 令, 其 中 真 正 跳 转 1 次 方 式 四 C 代 码 : vtemp=0; i=0; do vtemp=vtemp+i; while((i++)<100); 方 式 四 汇 编 代 码 说 明 : MCU EDU 第 139 页 作 者 :Dai ShangJu

7 0x1e28: MOV R1,#0 ;vtemp=0, 第 四 种 循 环 0x1e2c: MOV R0,#0 ;i=0, 循 环 次 数 清 零 0x1e30: NOP ; 空 操 作 0x1e34: ADD R1,R1,R0 ;vtemp=vtemp+i 0x1e38: MOV R2,R0 ; 将 i 未 加 之 前 的 值 保 存 起 来 0x1e3c: ADD R0,R0,#0x1 ;i++ 0x1e40: CMP R2,#0x64 ; 将 未 加 之 前 的 i 和 100 进 行 比 较 0x1e44: BCC 0x1e34 ; 小 于 100 跳 转 到 地 址 0x1e34 0x1e48: MOV R1,#0 ;vtemp=0, 第 五 种 循 环 开 始 方 式 四 汇 编 代 码 执 行 阴 影 部 分 循 环 需 要 5 条 指 令, 其 中 真 正 跳 转 1 次 方 式 五 C 代 码 : vtemp=0; i=0; do vtemp=vtemp+i; i++; while(i<100); 方 式 五 汇 编 代 码 说 明 : 0x1e48: MOV R1,#0 ;vtemp=0, 第 五 种 循 环 0x1e4c: MOV R0,#0 ;i=0, 循 环 次 数 清 零 0x1e50: NOP ; 空 操 作 0x1e54: ADD R1,R1,R0 ;vtemp=vtemp+i 0x1e58: ADD R0,R0,#0x1 ;i++ 0x1e5c: CMP R0,#0x64 ; 将 未 加 之 前 的 i 和 100 进 行 比 较 0x1e60: BCC 0x1e54 ; 小 于 100 跳 转 到 地 址 0x1e54 0x1e64: MOV R1,#0 ;vtemp=0, 第 五 种 循 环 开 始 方 式 五 汇 编 代 码 执 行 阴 影 部 分 循 环 需 要 4 条 指 令, 其 中 真 正 跳 转 1 次 方 式 六 C 代 码 : vtemp=0; i=100; while(i--) MCU EDU 第 140 页 作 者 :Dai ShangJu

8 vtemp=vtemp+i; 方 式 六 汇 编 代 码 说 明 : 0x1e64: MOV R1,#0 ;vtemp=0, 第 六 种 循 环 0x1e68: MOV R0,#0x64 ;i=100, 循 环 次 数 设 置 为 100 0x1e6c: NOP ; 空 操 作 0x1e70: SUB R2,R0,#0x1 ;i--, 减 的 结 果 放 到 到 中 间 变 量 中 0x1e74: MOV R0,R2 ;i--, 将 减 得 的 结 果 取 回 0x1e78: CMN R2,#0x1 ; 将 i 和 1 进 行 比 较 0x1e7c: BEQ 0x1e88 ; 等 于 跳 转 到 地 址 0x1e88, 结 束 循 环 0x1e80: ADD R1,R1,R0 ;vtemp=vtemp+i 0x1e84: B 0x1e70 ; 跳 转 到 地 址 0x1e70 0x1e88: MOV R1,#0 ;vtemp=0, 第 七 种 循 环 开 始 方 式 六 汇 编 代 码 执 行 阴 影 部 分 循 环 需 要 6 条 指 令, 其 中 真 正 跳 转 1 次 方 式 七 C 代 码 : vtemp=0; i=100; while(i) vtemp=vtemp+i; i--; 方 式 七 汇 编 代 码 说 明 : 0x1e88: MOV R1,#0 ;vtemp=0, 第 七 种 循 环 0x1e8c: MOV R0,#0x64 ;i=100, 循 环 次 数 设 置 为 100 0x1e90: NOP ; 空 操 作 0x1e94: CMP R0,#0x0 ; 将 i 和 比 较 0x1e98: BEQ 0x1ea8 ; 比 较 结 果 相 等 跳 转 到 地 址 0x1ea8, 结 束 循 环 0x1e9c: ADD R1,R1,R0 ;vtemp=vtemp+i 0x1ea0: SUB R0,R0,#0x1 ;i-- 0x1ea4: B 0x1e94 ; 跳 转 到 地 址 0x1e94 0x1ea8: MOV R1,#0 ;vtemp=0, 第 八 种 循 环 开 始 方 式 七 汇 编 代 码 执 行 阴 影 部 分 循 环 需 要 5 条 指 令, 其 中 真 正 跳 转 1 次 MCU EDU 第 141 页 作 者 :Dai ShangJu

9 方 式 八 C 代 码 : vtemp=0; i=100; do vtemp=vtemp+i; while(i--); 方 式 八 汇 编 代 码 说 明 : 0x1ea8: MOV R1,#0 ;vtemp=0, 第 八 种 循 环 0x1eac: MOV R0,#0x64 ;i=100, 循 环 次 数 设 置 为 100 0x1eb0: NOP ; 空 操 作 0x1eb4: ADD R1,R1,R0 ;vtemp=vtemp+i 0x1eb8: SUB R2,R0,#0x1 ;i--, 减 的 结 果 放 到 到 中 间 变 量 中 0x1ebc: MOV R0,R2 ;i--, 将 减 得 的 结 果 取 回 0x1ec0: CMN R2,#0x1 ; 将 i 和 1 比 较 0x1ec4: BNE 0x1eb4 ; 不 相 等 跳 转 到 地 址 0x1eb4 0x1ec8: MOV R1,#0 ;vtemp=0, 第 九 种 循 环 开 始 方 式 八 汇 编 代 码 执 行 阴 影 部 分 循 环 需 要 5 条 指 令, 其 中 真 正 跳 转 1 次 方 式 九 C 代 码 : vtemp=0; i=100; do vtemp=vtemp+i; i--; while(i); 方 式 九 汇 编 代 码 说 明 : 0x1ec8: MOV R1,#0 ;vtemp=0, 第 九 种 循 环 0x1ecc: MOV R0,#0x64 ;i=100, 循 环 次 数 设 置 为 100 0x1ed0: NOP ; 空 操 作 0x1ed4: ADD R1,R1,R0 ;vtemp=vtemp+i 0x1ed8: SUB R0,R0,#0x1 ;i-- 0x1edc: CMP R0,#0 ; 将 i 和 0 进 行 比 较 0x1ee0: BNE 0x1ed4 ; 比 较 结 果 不 相 等 跳 转 到 地 址 0x1ed4 MCU EDU 第 142 页 作 者 :Dai ShangJu

10 0x1ee4: MOV R1,#0 ;vtemp=0, 所 有 循 环 结 束 方 式 九 汇 编 代 码 执 行 阴 影 部 分 循 环 需 要 4 条 指 令, 其 中 真 正 跳 转 1 次 对 比 九 种 不 同 循 环 方 式 的 汇 编 代 码, 可 以 看 出 方 式 一 的 汇 编 指 令 最 多, 执 行 一 次 循 环 所 耗 费 的 时 间 最 长, 方 式 五 和 方 式 九 的 汇 编 指 令 最 少, 执 行 一 次 循 环 所 耗 费 的 时 间 也 最 短 这 些 循 环 方 式 效 率 满 足 do while() > while() > for() 的 规 律, 而 在 实 际 中 这 三 种 C 语 言 循 环 控 制 方 式 使 用 频 率 刚 好 相 反,do while() < while() < for() 刚 接 触 C 语 言 编 程 的 新 人, 最 喜 欢 用 的 就 是 for() 方 式, 殊 不 知 这 种 方 式 效 率 最 低, 所 以 如 果 是 用 C 语 言 进 行 单 片 机 编 程, 进 入 到 熟 练 阶 段 后 一 定 注 意 循 环 方 式 对 代 码 效 率 的 影 响 有 兴 趣 的 朋 友 可 以 仔 细 对 比 这 几 种 方 式 的 汇 编 代 码, 从 中 你 可 以 找 出 编 译 器 对 C 代 码 进 行 编 译 的 规 律 : 基 本 上 按 照 C 语 言 的 顺 序 对 应 编 译, 对 i++/ i-- 这 类 先 用 再 加 的 特 殊 语 句 是 先 将 i 的 值 取 出 来 放 到 中 间 变 量 里 面, 然 后 将 i 进 行 加 减 处 理, 循 环 体 中 的 i 用 中 间 变 量 进 行 替 代 4.3. 循 环 里 的 i++ 与 i 循 环 里 面 i++ 和 i-- 的 使 用 效 果 上 也 会 有 一 些 区 别, 上 一 节 中 我 们 列 举 了 九 种 C 语 言 的 循 环 实 现 方 式, 其 中 方 式 五 和 方 式 九 的 效 率 最 高, 这 两 种 方 式 一 个 采 用 的 是 i++, 另 一 个 采 用 i--, 从 产 生 的 汇 编 指 令 看 两 者 有 着 相 同 的 效 率, 好 象 没 有 什 么 区 别? 别 着 急, 接 下 来 我 让 你 相 信 确 实 有 区 别, 而 且 明 白 区 别 是 什 么 原 因 造 成 的 方 式 五 : vtemp=0; i=0; do vtemp=vtemp+i; i++; while(i<100); 循 环 部 分 汇 编 代 码 0x1e54: ADD R1,R1,R0 ;vtemp=vtemp+i 0x1e58: ADD R0,R0,#0x1 ;i++ 0x1e5c: CMP R0,#0x64 ; 将 未 加 之 前 的 i 和 100 进 行 比 较 0x1e60: BCC 0x1e54 ; 小 于 100 跳 转 到 地 址 0x1e54 方 式 九 : vtemp=0; MCU EDU 第 143 页 作 者 :Dai ShangJu

11 i=100; do vtemp=vtemp+i; i--; while(i); 循 环 部 分 汇 编 代 码 0x1ed4: ADD R1,R1,R0 ;vtemp=vtemp+i 0x1ed8: SUB R0,R0,#0x1 ;i-- 0x1edc: CMP R0,#0 ; 将 i 和 0 进 行 比 较 * 这 条 指 令 可 以 不 要 0x1ee0: BNE 0x1ed4 ; 比 较 结 果 不 相 等 跳 转 到 地 址 0x1ed4 图 ARM 汇 编 结 果 示 意 图 三 对 于 方 式 五 代 码 已 经 没 有 可 以 更 精 简 的 空 间, 而 方 式 九 我 们 可 以 看 出 循 环 部 分 的 第 三 条 汇 编 指 令 不 是 必 须 的, 因 为 前 一 条 代 码 是 执 行 i-1 操 作, 当 相 减 的 结 果 等 于 0 的 时 候 会 将 CPU 的 状 态 寄 存 器 里 面 的 Z 状 态 标 志 位 置 上, 表 示 当 前 相 减 结 果 等 于 0, 而 BNE 指 令 是 通 过 对 Z 状 态 标 志 位 来 进 行 判 断, 当 Z 状 态 标 志 位 被 置 位 就 跳 转 到 后 面 所 带 的 地 址, 否 则 执 行 下 一 条 指 令, 这 样 我 们 将 第 三 条 汇 编 指 令 去 掉 后 还 可 以 同 样 得 到 正 确 的 程 序 执 行 结 果 那 编 译 器 能 不 能 去 掉 第 三 条 汇 编 指 令 呢? 答 案 是 肯 定 的, 这 里 我 暂 时 先 不 展 示 编 译 器 可 以 去 掉 它 的 结 果, 因 为 用 我 现 在 的 编 译 器 要 得 到 这 样 的 结 果 需 要 使 用 到 C 语 言 编 译 的 优 化 功 能, 下 一 节 我 会 专 门 对 优 化 进 行 讲 述, 到 时 再 为 大 家 展 示 可 以 不 要 第 三 条 指 令 的 原 因 是 利 用 了 单 片 机 指 令 系 统 的 一 个 规 律, 当 进 行 CPU 进 行 运 算 处 理 后 会 将 状 态 寄 存 器 里 面 Z/C/DC/S 等 标 志 位 置 位 或 清 零 来 表 示 进 位 借 位 等 零 状 态, 条 件 跳 转 指 令 MCU EDU 第 144 页 作 者 :Dai ShangJu

12 都 是 依 据 这 些 状 态 位 来 决 定 是 否 进 行 跳 转 进 行 循 环 控 制 如 果 没 有 特 殊 的 循 环 控 制 指 令 ( 某 些 单 片 机 会 提 供 循 环 控 制 指 令, 只 要 设 定 循 环 寄 存 器 就 可 以 让 指 定 的 代 码 循 环 执 行 想 要 的 次 数 ) 就 需 要 用 一 个 变 量 进 行 加 减 来 计 算 循 环 次 数, 通 常 在 C 语 言 里 面 会 用 i++/ i 方 式 来 实 现 如 果 是 i++ 方 式, 循 环 一 次 都 要 和 需 要 循 环 的 次 数 进 行 比 较, 然 后 依 据 比 较 结 果 才 知 道 是 否 还 需 要 继 续 循 环, 但 采 用 i-- 则 不 一 样, 当 达 到 想 要 的 循 环 次 数 时 i 自 减 的 结 果 为 零, 这 时 可 以 直 接 利 用 状 态 寄 存 器 里 等 零 成 立 这 一 条 件, 选 用 合 适 的 条 件 跳 转 指 令 来 实 现 跳 转, 比 如 BNE/BEQ 就 是 通 过 判 断 状 态 寄 存 器 里 等 零 是 否 成 立 来 决 定 是 否 跳 转 采 用 i++ 方 式 也 并 不 是 不 能 达 到 与 i-- 同 样 样 的 效 果 signed long i=-100; do i++; while(i); // 这 里 一 样 可 以 在 i 加 到 0 的 时 候 退 出 循 环 但 这 种 负 数 往 上 加 的 方 式 和 日 常 习 惯 不 一 致, 会 让 人 们 觉 得 别 扭, 所 以 在 进 行 循 环 控 制 的 时 候, 建 议 多 用 i-- 的 方 式, 会 在 符 合 人 们 日 常 习 惯 的 同 时 得 到 更 高 的 代 码 效 率, 请 记 住 i-- 比 i++ 效 率 高 这 一 结 论 但 从 程 序 可 靠 性 方 面 来 说 i-- 会 不 如 i++ i=100; while(i) // 当 i 不 为 0 则 继 续 循 环 i--; while(i<100) // 当 i 小 于 100 则 继 续 循 环 i++; 如 果 在 循 环 过 程 中 i 因 为 意 外 原 因 导 致 内 容 被 改 变, 比 如 循 环 了 一 半 时 i 被 意 外 改 成 了 10000, i-- 方 式 还 要 循 环 次 才 能 退 出 循 环, 而 i++ 方 式 即 刻 退 出 循 环, 这 样 i++ 和 与 i-- 相 比 i++ 能 早 一 些 从 错 误 中 返 回 4.4. 优 化 的 方 法 与 效 果 用 C 编 程 很 方 便 的 一 点 是 代 码 容 易 模 块 化 循 环 和 跳 转 之 类 的 操 作 很 好 实 现, 免 去 了 汇 编 编 程 那 样 需 要 用 许 多 标 号 来 标 示 程 序 结 构 以 实 现 循 环 或 跳 转 C 语 言 采 用 大 括 号 将 代 码 进 行 分 块, 除 MCU EDU 第 145 页 作 者 :Dai ShangJu

13 了 可 以 用 大 括 号 来 标 示 循 环 选 择 等 块 外 函 数 也 是 用 大 括 号 前 后 包 括 成 一 个 整 体 C 语 言 将 变 量 分 为 全 局 变 量 和 局 部 变 量 两 类, 局 部 变 量 的 作 用 域 被 限 定 在 一 个 函 数 之 内, 全 局 变 量 的 作 用 域 要 大, 可 以 在 不 同 函 数 中 使 用 和 汇 编 相 比,C 程 序 直 观 易 懂, 但 这 个 直 观 易 懂 建 立 在 C 语 言 语 法 规 则 基 础 之 上, 会 受 到 语 法 的 制 约, 用 C 编 程 也 会 要 求 程 序 员 尽 量 让 程 序 结 构 和 层 次 分 明, 这 样 才 能 更 好 的 体 现 C 语 言 的 优 点 C 的 这 个 特 性 存 在 一 个 不 足, 就 是 前 面 的 要 求 会 让 C 代 码 效 率 和 空 间 方 面 的 性 能 下 降, 因 为 用 C 编 写 程 序 需 要 转 换 成 与 MCU 指 令 对 应 汇 编 代 码 才 能 被 解 释 执 行, 转 换 的 过 程 是 按 照 一 定 规 则 进 行 的, 所 以 转 换 出 来 的 代 码 不 一 定 能 达 到 直 接 用 汇 编 代 码 编 写 那 么 简 洁, 加 上 C 代 码 对 程 序 结 构 和 层 次 要 求 间 隔 清 晰, 在 编 程 时 容 易 产 生 一 些 冗 余 代 码 看 下 面 一 段 C 代 码, 对 于 代 码 作 用 一 目 了 然 的 位 置 可 以 不 添 加 注 释 行 01:void MCU_CTestFunc(void) 行 02: 行 03: unsigned char vadcx,vadcy; 行 04:... 行 05: vadcx=getadcx();// 将 ADC 得 到 的 电 压 值 存 入 中 间 变 量 行 06: if(vadcx>100) 行 07: printf("x_voltage>100"); 行 08: else if(vadcx>50) 行 09: printf("x_voltage>50"); 行 10: else 行 11: printf("x_voltage<=50"); 行 12: vadcy=getadcy();// 将 ADC 得 到 的 电 压 值 存 入 中 间 变 量 行 13: if(vadcy>100) 行 14: printf("y_voltage>100"); 行 15: else if(vadcy>50) 行 16: printf("y_voltage>50"); 行 17: else 行 18: printf("y_voltage<=50"); 行 19:... 行 20: 行 05 和 行 12 先 将 ADC 转 换 得 到 电 压 值 存 入 中 间 变 量, 以 免 在 行 位 置 再 次 进 行 ADC 转 换 操 作, 可 以 减 少 代 码 执 行 时 间 ; 行 05 和 行 12 分 别 用 vadcx 和 vadcy 来 保 存 电 压 值, 目 的 是 让 程 序 结 构 清 晰, 使 X 和 Y 两 部 分 代 码 更 为 直 观 如 果 我 们 将 代 码 中 vadcx 和 vadcy 合 并 为 vadc, 结 果 并 不 影 响 对 程 序 的 功 能, 还 能 节 省 出 一 个 RAM 空 间,vAdcX 和 vadcy 在 代 码 空 间 上 就 产 生 了 冗 余 MCU EDU 第 146 页 作 者 :Dai ShangJu

14 在 用 汇 编 进 行 编 程 时, 程 序 要 求 会 发 生 变 化, 因 为 汇 编 语 言 非 常 不 直 观, 需 要 在 代 码 里 面 尽 可 能 多 的 加 入 注 释, 加 上 使 用 汇 编 编 程 时 程 序 员 会 重 视 代 码 的 空 间 和 效 率, 从 而 形 成 C 编 程 中 vadcx 和 vadcy 代 码 空 间 冗 余 的 几 率 会 降 低 行 01: vadc EQU 0x40 ;RAM 0x40 用 来 存 放 ADC 转 换 得 到 的 电 压 值 行 02:... 行 03:getADCX: ; 对 X 电 压 进 行 ADC 转 换 函 数 行 04:... 行 05: LDA ADC_REG ; 将 ADC 转 换 结 果 读 入 累 加 器 行 06: STA vadc ; 将 累 加 器 中 的 值 存 入 vadc 行 07: RET ; 函 数 返 回, 此 时 vadc 存 放 ADC 转 换 结 果 行 08:... 行 09:MCU_ASMTestFunc: 行 10:... 行 11: CALL getadcx ; 调 用 X 电 压 转 换 函 数, 执 行 完 vadc 为 X 电 压 行 12:... ; 其 它 代 码 显 示 X 电 压 区 域 行 13: CALL getadcy ; 调 用 Y 电 压 转 换 函 数, 执 行 完 vadc 为 Y 电 压 行 14:... ; 其 它 代 码 显 示 Y 电 压 区 域 行 15:... 行 16: RET 汇 编 代 码 与 C 代 码 相 比 可 以 看 出 如 果 汇 编 不 加 上 注 释 会 很 难 看 懂 代 码 的 意 思, 因 为 这 些 注 释 的 存 在 可 以 不 用 象 C 代 码 那 样 用 vadcx 和 vadcy 两 个 变 量 名, 只 用 vadc 就 可 以 依 靠 注 释 让 代 码 段 清 功 能 明 晰 我 们 可 以 将 C 代 码 中 的 vadcx 和 vadcy 合 并 为 vadc, 但 这 样 做 需 要 C 程 序 员 改 变 约 定 俗 成 的 程 序 风 格, 实 际 上 我 们 不 改 变 C 代 码 也 同 样 能 实 现 vadcx 和 vadcy 合 并, 编 译 器 通 过 对 程 序 的 扫 描 可 以 知 道 在 函 数 MCU_CTestFunc() 内 vadcx 和 vadcy 只 用 来 临 时 存 放 电 压 值, 而 且 两 个 电 压 值 不 会 同 时 出 现, 这 样 就 可 以 在 编 译 的 时 候 给 vadcx 和 vadcy 分 配 同 一 个 RAM, 程 序 前 半 段 给 vadcx 用, 后 半 段 给 vadcy 用, 这 种 做 法 就 是 编 译 器 的 优 化 编 译 器 对 C 代 码 编 译 最 简 单 的 方 法 就 是 将 每 一 条 C 代 码 都 转 换 成 相 应 汇 编 指 令, 这 种 处 理 方 法 得 到 的 汇 编 指 令 从 结 构 层 次 上 和 原 始 C 代 码 基 本 上 一 致, 只 要 RAM 等 资 源 够 用, 就 能 比 较 容 易 做 到 编 译 出 的 汇 编 代 码 功 能 和 C 代 码 一 样 优 化 则 是 编 译 器 依 据 自 己 的 经 验, 将 C 代 码 编 译 转 换 成 汇 编 指 令 时 在 保 证 代 码 执 行 结 果 正 确 的 前 提 下 做 出 一 些 特 殊 调 整 来 改 良 代 码 空 间 和 效 率 ( 详 见 完 整 版 ) MCU EDU 第 147 页 作 者 :Dai ShangJu

15 4.5. 全 局 变 量 的 风 险 不 少 单 片 机 程 序 员 喜 欢 用 全 局 变 量 传 递 控 制 信 息, 比 如 中 断 标 志 什 么 的, 这 样 做 的 优 点 是 简 单 方 便, 程 序 员 可 以 灵 活 的 设 定 自 己 想 传 递 的 控 制 信 息 内 容 用 全 局 变 量 传 递 控 制 信 息 不 能 随 心 所 欲, 需 要 遵 循 一 些 规 则, 最 常 见 的 是 不 要 让 多 方 同 时 进 行 写 操 作 的 可 能 性 存 在, 比 如 一 个 全 局 变 量 x, 在 主 程 序 和 中 断 程 序 中 都 会 对 其 进 行 写 操 作, 这 是 风 险 系 数 非 常 高 的 操 作, 因 为 这 样 有 可 能 刚 好 在 主 程 序 在 更 改 x 内 容 的 时 候 中 断 产 生, 中 断 程 序 又 对 x 写 入 另 外 的 内 容, 从 而 导 致 程 序 判 断 出 错, 这 一 点 只 要 稍 有 经 验 的 工 程 师 都 会 知 道, 但 实 际 开 发 中 工 程 师 有 可 能 知 道 这 种 风 险 但 不 能 很 好 的 避 免 其 产 生, 接 下 来 我 会 通 过 两 个 例 子 来 介 绍 两 种 常 见 的 风 险 疏 忽 变 量 宽 度 与 单 片 机 位 宽 不 一 致 时 中 断 使 用 全 局 变 量 导 致 出 错 假 定 现 在 有 一 款 8bits 的 单 片 机, 我 们 用 一 个 周 期 为 1ms 的 timer 中 断 做 为 系 统 时 钟,timer 每 中 断 一 次 会 将 一 个 32bits 的 变 量 加 一, 程 序 通 过 这 个 变 量 知 道 单 片 机 上 电 后 已 经 运 行 的 时 间 例 子 采 用 C 语 言 编 程, 单 片 机 指 令 系 统 为 6502 汇 编 指 令 C 代 码 unsigned long last_time; unsigned long ms_counter; unsigned long get_mscounter(void) return ms_counter; void main(void)... ms_counter=0; init_timer0_irq(); enable_irq(); while(1) last_time=get_mscounter();... while(get_mscounter()<(last_time+100)); void timer0_irq(void) MCU EDU 第 148 页 作 者 :Dai ShangJu

16 CLR_TIMER0_INT_FLAG; ms_counter++; C 代 码 汇 编 指 令 执 行 示 意 unsigned long last_time; // 汇 编 指 令 用 来 存 储 变 量 last_time 的 4 字 节 RAM 变 量 //DB LAST_TIME_BYTE1 //DB LAST_TIME_BYTE2 //DB LAST_TIME_BYTE3 //DB LAST_TIME_BYTE4 unsigned long ms_counter; // 汇 编 指 令 用 来 存 储 变 量 ms_counter 的 4 字 节 RAM 变 量 //DB MS_COUNTER_BYTE1 //DB MS_COUNTER_BYTE2 //DB MS_COUNTER_BYTE3 //DB MS_COUNTER_BYTE4 // 汇 编 指 令 用 来 存 储 函 数 返 回 参 数 的 4 字 节 RAM 变 量 //DB FUNC_RETURN_BYTE1 //DB FUNC_RETURN_BYTE2 //DB FUNC_RETURN_BYTE3 //DB FUNC_RETURN_BYTE4 // 汇 编 指 令 用 于 计 算 处 理 的 4 字 节 RAM 变 量 //DB CALC_TEMP_BYTE1 //DB CALC_TEMP_BYTE2 //DB CALC_TEMP_BYTE3 //DB CALC_TEMP_BYTE4 unsigned long get_mscounter(void) return ms_counter; // 将 ms_counter 的 内 容 存 放 到 函 数 返 回 参 数 的 4 字 节 RAM 变 量 中 //LDA MS_COUNTER_BYTE1 ;A=MS_COUNTER_BYTE1 //STA FUNC_RETURN_BYTE1 ;FUNC_RETURN_BYTE1=A //LDA MS_COUNTER_BYTE2 ;A=MS_COUNTER_BYTE2 MCU EDU 第 149 页 作 者 :Dai ShangJu

17 //STA FUNC_RETURN_BYTE2 ;FUNC_RETURN_BYTE2=A //LDA MS_COUNTER_BYTE3 ;A=MS_COUNTER_BYTE3 //STA FUNC_RETURN_BYTE3 ;FUNC_RETURN_BYTE3=A //LDA MS_COUNTER_BYTE4 ;A=MS_COUNTER_BYTE4 //STA FUNC_RETURN_BYTE4 ;FUNC_RETURN_BYTE4=A //RTS ; 函 数 返 回 void main(void)... ms_counter=0; // 将 ms_counter 清 零 //LDA #0 ;A=0 //STA MS_COUNTER_BYTE1 ;MS_COUNTER_BYTE1=A //LDA #0 ;A=0 //STA MS_COUNTER_BYTE2 ;MS_COUNTER_BYTE2=A //LDA #0 ;A=0 //STA MS_COUNTER_BYTE3 ;MS_COUNTER_BYTE3=A //LDA #0 ;A=0 //STA MS_COUNTER_BYTE4 ;MS_COUNTER_BYTE4=A init_timer0_irq(); // 对 timer0 中 断 进 行 设 置, 不 示 意 汇 编 指 令 enable_irq(); // 开 中 断, 不 示 意 汇 编 指 令 while(1) //ADDRESS_1 为 while(1) 死 循 环 地 址 //ADDRESS_1: ; 地 址 1 last_time=get_mscounter(); // 得 到 当 前 循 环 的 起 始 时 间 //JSR get_mscounter ; 调 用 函 数 get_mscounter //LDA FUNC_RETURN_BYTE1 ;A=FUNC_RETURN_BYTE1 //STA LAST_TIME_BYTE1 ;LAST_TIME_BYTE1=A //LDA FUNC_RETURN_BYTE2 ;A=FUNC_RETURN_BYTE2 //STA LAST_TIME_BYTE2 ;LAST_TIME_BYTE2=A MCU EDU 第 150 页 作 者 :Dai ShangJu

18 //LDA FUNC_RETURN_BYTE3 ;A=FUNC_RETURN_BYTE3 //STA LAST_TIME_BYTE3 ;LAST_TIME_BYTE3=A //LDA FUNC_RETURN_BYTE4 ;A=FUNC_RETURN_BYTE4 //STA LAST_TIME_BYTE4 ;LAST_TIME_BYTE4=A... while(get_mscounter()<(last_time+100)); // 如 果 循 环 时 间 达 到 100ms 则 开 始 下 一 次 循 环, 未 考 虑 溢 出 问 题 //ADDRESS_2: ; 地 址 2 //JSR get_mscounter ; 调 用 函 数 get_mscounter //CLC ; 清 C 进 位 标 志 位 //LDA LAST_TIME_BYTE1 ;A=LAST_TIME_BYTE1 //ADC #100 ;A=A+100+C, 如 果 有 进 位 则 C 置 1 //STA LAST_TIME_BYTE1 ;LAST_TIME_BYTE1=A, 不 影 响 C 状 态 //LDA LAST_TIME_BYTE2 ;LAST_TIME_BYTE2, 不 影 响 C 状 态 //ADC #0 ;A=A+0+C, 如 果 有 进 位 则 C 置 1 //STA LAST_TIME_BYTE2 ;LAST_TIME_BYTE2=A, 不 影 响 C 状 态 //LDA LAST_TIME_BYTE3 ;LAST_TIME_BYTE3, 不 影 响 C 状 态 //ADC #0 ;A=A+0+C, 如 果 有 进 位 则 C 置 1 //STA LAST_TIME_BYTE3 ;LAST_TIME_BYTE3=A, 不 影 响 C 状 态 //LDA LAST_TIME_BYTE4 ;LAST_TIME_BYTE4, 不 影 响 C 状 态 //ADC #0 ;A=A+0+C, 如 果 有 进 位 则 C 置 1 //STA LAST_TIME_BYTE4 ;LAST_TIME_BYTE4=A, 忽 略 溢 出 情 况 //LDA FUNC_RETURN_BYTE4 ;A=FUNC_RETURN_BYTE4 //CMP LAST_TIME_BYTE4 ; 比 较 A 和 LAST_TIME_BYTE4 //BCS ADDRESS_3 ; 如 果 A 小 于 LAST_TIME_BYTE4 跳 转 到 地 址 3 //LDA FUNC_RETURN_BYTE3 ;A=FUNC_RETURN_BYTE3 //CMP LAST_TIME_BYTE3 ; 比 较 A 和 LAST_TIME_BYTE3 //BCS ADDRESS_3 ; 如 果 A 小 于 LAST_TIME_BYTE3 跳 转 到 地 址 3 //LDA FUNC_RETURN_BYTE2 ;A=FUNC_RETURN_BYTE2 //CMP LAST_TIME_BYTE2 ; 比 较 A 和 LAST_TIME_BYTE2 //BCS ADDRESS_3 ; 如 果 A 小 于 LAST_TIME_BYTE2 跳 转 到 地 址 3 //LDA FUNC_RETURN_BYTE1 ;A=FUNC_RETURN_BYTE1 //CMP LAST_TIME_BYTE1 ; 比 较 A 和 LAST_TIME_BYTE1 //BCS ADDRESS_3 ; 如 果 A 小 于 LAST_TIME_BYTE1 跳 转 到 地 址 3 //JMP ADDRESS_2 ; 跳 转 到 地 址 2 MCU EDU 第 151 页 作 者 :Dai ShangJu

19 //ADDRESS_3: ; 地 址 3 //JMP ADDRESS_1 ; 跳 转 到 地 址 1 //RTS ; 函 数 返 回 void timer0_irq(void) CLR_TIMER0_INT_FLAG; // 清 中 断 标 志 位 操 作, 不 示 意 汇 编 指 令 ms_counter++; // 将 ms_counter 加 一 //CLC ; 清 C 进 位 标 志 位 //LDA MS_COUNTER_BYTE1 ;A=MS_COUNTER_BYTE1 //ADC #1 ;A=A+1+C, 如 果 有 进 位 则 C 置 1 //STA MS_COUNTER_BYTE1 ;MS_COUNTER_BYTE1=A, 不 影 响 C 状 态 //LDA MS_COUNTER_BYTE2 ;A=MS_COUNTER_BYTE2, 不 影 响 C 状 态 //ADC #0 ;A=A+0+C, 如 果 有 进 位 则 C 置 1 //STA MS_COUNTER_BYTE2 ;MS_COUNTER_BYTE2=A, 不 影 响 C 状 态 //LDA MS_COUNTER_BYTE3 ;A=MS_COUNTER_BYTE3, 不 影 响 C 状 态 //ADC #0 ;A=A+0+C, 如 果 有 进 位 则 C 置 1 //STA MS_COUNTER_BYTE3 ;MS_COUNTER_BYTE3=A, 不 影 响 C 状 态 //LDA MS_COUNTER_BYTE4 ;A=MS_COUNTER_BYTE4, 不 影 响 C 状 态 //ADC #0 ;A=A+0+C, 如 果 有 进 位 则 C 置 1 //STA MS_COUNTER_BYTE4 ;MS_COUNTER_BYTE4=A, 忽 略 溢 出 情 况 //RTI ; 中 断 函 数 返 回 注 : 汇 编 代 码 和 C 代 码 只 是 示 意 用, 不 能 直 接 理 解 成 实 际 情 况 来 看 看 前 面 代 码 什 么 情 况 下 会 出 错, 在 位 置 1 和 位 置 2, 程 序 都 有 调 用 函 数 get_mscounter(), 如 果 在 位 置 1 调 用 函 数 时 ms_counter 的 值 为 0x0000FFFF, 当 函 数 get_mscounter() 运 行 到 汇 编 指 令 的 位 置 3 的 时 候 timer 中 断 产 生,ms_counter 的 值 加 一 变 为 0x , 正 确 的 结 果 应 该 是 调 用 函 数 get_mscounter() 后 last_time 的 值 为 0x0000FFFF 或 0x , 但 现 在 结 果 变 成 了 另 外 的 值 0x0001FFFF 程 序 运 行 到 位 置 1 时 : MS_COUNTER_BYTE1=0xFF MS_COUNTER_BYTE2=0xFF MCU EDU 第 152 页 作 者 :Dai ShangJu

20 MS_COUNTER_BYTE3=0x00 MS_COUNTER_BYTE4=0x00 程 序 运 行 到 位 置 3 时 : LAST_TIME_BYTE1=MS_COUNTER_BYTE1=0xFF LAST_TIME_BYTE2=MS_COUNTER_BYTE2=0xFF MS_COUNTER_BYTE3=0x00 MS_COUNTER_BYTE4=0x00 LAST_TIME_BYTE3 和 LAST_TIME_BYTE4 还 未 取 得 新 的 值 此 时 timer 中 断 产 生, 转 去 执 行 中 断 程 序 : MS_COUNTER_BYTE1=0x00 MS_COUNTER_BYTE2=0x00 MS_COUNTER_BYTE3=0x01 MS_COUNTER_BYTE4=0x00 中 断 返 回 后 继 续 取 LAST_TIME_BYTE3 和 LAST_TIME_BYTE4 的 新 值 : LAST_TIME_BYTE1 保 持 0xFF 不 变 LAST_TIME_BYTE2 保 持 0xFF 不 变 LAST_TIME_BYTE3=MS_COUNTER_BYTE3=0x01 LAST_TIME_BYTE4=MS_COUNTER_BYTE4=0x00 于 是 last_time 得 到 错 误 的 值 0x0001FFFF 当 程 序 运 行 到 位 置 2 进 行 循 环 判 断 时, 循 环 控 制 出 错, 原 本 100ms 的 循 环 周 期 变 成 需 要 等 待 65 秒 才 能 继 续 下 一 次 循 环 要 避 免 此 种 风 险 的 发 生 是 变 量 位 宽 改 为 与 单 片 机 位 宽 一 致, 或 者 将 中 断 修 改 的 变 量 读 回 来 后 进 行 一 次 重 复 比 较, 满 足 前 后 读 回 的 值 一 样 的 才 当 作 有 效 值 修 改 后 的 代 码 unsigned long last_time,current_time; unsigned long ms_counter; unsigned long get_mscounter(void) return ms_counter; void main(void)... ms_counter=0; init_timer0_irq(); MCU EDU 第 153 页 作 者 :Dai ShangJu

21 enable_irq(); while(1) do // 连 续 两 次 读 得 的 值 一 样 才 有 效 last_time=get_mscounter(); while(last_time!=get_mscounter());... do do // 连 续 两 次 读 得 的 值 一 样 才 有 效 current_time=get_mscounter(); while(current_time!=get_mscounter()); while(current_time<(last_time+100)); 再 来 看 另 外 一 种 情 况, 单 片 机 依 然 为 8bits, 中 断 和 主 程 序 会 修 改 同 一 个 变 量, 于 是 程 序 通 过 一 个 8bits 变 量 保 护 标 志 位 来 对 主 程 序 的 操 作 进 行 保 护, 当 中 断 或 主 程 序 需 要 修 改 变 量 的 时 候, 先 查 看 变 量 保 护 标 志 位, 如 果 不 为 0 暂 不 进 行 修 改, 如 果 为 0 则 将 变 量 保 护 标 志 位 设 为 非 0 值, 然 后 进 行 修 改 变 量 操 作, 修 改 完 毕 将 变 量 保 护 标 志 位 清 0 以 允 许 主 程 序 或 中 断 继 续 修 改 变 量 假 定 C 语 言 编 程, 单 片 机 指 令 系 统 为 6502 汇 编 指 令 ( 详 见 完 整 版 ) 4.6. 变 量 类 型 与 代 码 效 率 毋 庸 置 疑, 单 片 机 处 理 和 其 宽 度 相 等 的 数 据 效 率 最 高, 比 如 16bits 的 单 片 机 去 处 理 32bits 位 宽 数 据 需 要 32bits 数 据 分 成 16bits 高 低 两 部 分 后 才 能 处 理, 效 率 自 然 要 低 不 少 采 用 ARM 内 核 的 单 片 机 会 有 点 特 殊,ARM 内 核 本 身 是 32bits, 但 其 支 持 STRB/LDRB 这 样 的 特 殊 指 令, 该 指 令 可 以 直 接 读 写 8bits 的 数 据, 所 以 ARM 处 理 8bits 数 据 的 时 候 效 率 不 一 定 要 比 32bits 低, 但 同 样 去 传 递 一 块 数 据, 显 然 还 是 用 32bits 的 要 快, 只 是 需 要 在 数 据 块 边 缘 用 8bits 数 据 进 行 对 齐 处 理 MCU EDU 第 154 页 作 者 :Dai ShangJu

22 既 然 处 理 数 据 的 效 率 和 单 片 机 位 宽 有 关, 那 么 我 们 在 用 C 语 言 对 单 片 机 编 程 时 就 需 要 考 虑 单 片 机 位 宽, 只 有 这 样 才 能 保 证 程 序 具 有 良 好 的 效 率, 假 设 现 在 有 两 个 单 片 机, 一 个 为 8bits, 另 外 一 个 为 32bits, 需 要 我 们 用 这 两 款 单 片 机 编 写 一 段 程 序, 将 一 段 数 据 复 制 到 其 它 位 置 程 序 一 void Copy_TestFunc(char * desbuf,char * srcbuf,unsigned long size) while(size) *desbuf=*srcbuf; // 复 制 1 字 节 size--; // 计 数 器 减 一 desbuf++; // 目 的 地 址 加 一 srcbuf++; // 源 地 址 加 一 程 序 二 void Copy_TestFunc(char * desbuf,char * srcbuf,unsigned long size) long *p1,*p2; // 用 于 32bits 传 送 short *p3,*p4; // 用 于 16bits 传 送 char *p5,*p6; // 用 于 8bits 传 送 if((((long)desbuf&0x3)==0)&&(((long)srcbuf&0x3)==0)) //32bits mode // 目 的 地 址 和 源 地 址 都 满 足 4 字 节 对 齐 p1=(long *)desbuf; // 得 到 目 的 地 址 long 指 针 p2=(long *)srcbuf; // 得 到 源 地 址 long 指 针 while(size>=4) // 还 有 不 少 于 4 字 节 的 数 据 需 要 传 送 就 循 环 *p1=*p2; // 源 地 址 传 送 4 字 节 到 目 的 地 址 size-=4; // 计 数 器 减 4 p1++; // 目 的 地 址 long 指 针 自 加, 实 际 上 是 加 了 4 p2++; // 源 地 址 long 指 针 自 加, 实 际 上 是 加 了 4 p5=(char *)p1; // 目 的 地 址 改 用 char 指 针 p6=(char *)p2; // 源 地 址 改 用 char 指 针 while(size) // 每 次 循 环 复 制 1 字 节 到 结 束 MCU EDU 第 155 页 作 者 :Dai ShangJu

23 *p5=*p6; size--; p5++; p6++; else if((((long)desbuf&0x1)==0)&&(((long)srcbuf&0x1)==0)) //16bits mode // 目 的 地 址 和 源 地 址 都 满 足 2 字 节 对 齐 p3=(short *)desbuf; // 得 到 目 的 地 址 short 指 针 p4=(short *)srcbuf; // 得 到 源 地 址 short 指 针 while(size>=2) // 还 有 不 少 于 2 字 节 的 数 据 需 要 传 送 就 循 环 *p3=*p4; // 源 地 址 传 送 2 字 节 到 目 的 地 址 size-=2; // 计 数 器 减 2 p1++; // 目 的 地 址 long 指 针 自 加, 实 际 上 是 加 了 4 p2++; // 源 地 址 long 指 针 自 加, 实 际 上 是 加 了 4 if(size) (char *)p3=(char *)p4;// 此 时 只 剩 余 1 字 节 需 要 复 制 else //8bits mode // 目 的 地 址 或 源 地 址 不 满 足 2 字 节 对 齐 while(size) // 每 次 循 环 复 制 1 字 节 到 结 束 *desbuf=*srcbuf; size--; desbuf++; srcbuf++; MCU EDU 第 156 页 作 者 :Dai ShangJu

24 程 序 二 与 程 序 一 相 比 程 序 结 构 要 复 杂 一 些, 会 根 据 源 地 址 和 目 的 地 址 的 状 态 自 动 选 择 传 送 方 式 对 于 8bits 的 单 片 机, 每 次 只 能 传 一 个 8bits 的 数 据, 所 以 无 论 程 序 一 或 者 程 序 二 单 片 机 都 会 一 个 字 节 一 个 字 节 的 传 送, 显 然 程 序 一 的 速 度 要 快 对 于 32bits 的 单 片 机 结 果 会 大 不 一 样, 如 果 只 是 传 送 几 个 字 节, 程 序 二 和 程 序 一 比 并 没 有 什 么 优 势, 甚 至 会 更 慢, 但 当 传 送 的 数 据 个 数 多 而 且 起 始 地 址 满 足 4 字 节 对 齐 时, 程 序 二 一 条 指 令 就 可 以 传 送 4 个 字 节, 传 送 的 速 度 几 乎 可 以 达 到 程 序 一 的 4 倍 所 以 在 用 C 语 言 对 单 片 机 编 程 时, 同 样 的 C 代 码 用 到 不 同 的 单 片 机 上 效 率 可 能 大 相 径 庭, 我 们 需 要 结 合 单 片 机 的 硬 件 特 性 进 行 编 程 才 能 得 到 高 效 代 码 标 准 C 提 供 了 不 少 库 函 数, 这 些 库 函 数 功 能 完 善 而 且 高 效, 使 用 它 可 以 让 编 程 人 员 方 便 不 少, 但 要 留 意 这 些 库 函 数 有 可 能 已 经 基 于 32bits 平 台 做 出 了 类 似 前 面 程 序 二 的 特 殊 处 理, 在 非 32bits 的 单 片 机 上 很 有 可 能 不 能 体 现 出 高 效 的 特 性 4.7. 慎 用 int 现 在 用 C 编 写 的 程 序 是 不 计 其 数, 提 供 软 硬 件 服 务 的 厂 商 具 有 雷 锋 精 神 的 程 序 爱 好 者 写 出 了 各 种 各 样 的 C 程 序 代 码, 以 便 其 他 人 在 他 们 所 提 供 C 代 码 的 基 础 上 更 快 的 完 成 产 品 开 发, 纵 观 这 些 C 代 码, 你 会 发 现 里 面 大 量 使 用 int 进 行 数 据 定 义, 实 际 上 这 不 是 一 个 好 的 做 法 早 期 的 C 语 言 有 一 个 定 义 上 的 缺 陷, 对 int 的 描 述 不 够 严 谨, 只 是 定 义 其 为 整 形 变 量, 单 纯 从 语 法 上 说 这 个 定 义 不 存 在 什 么 问 题, 可 是 C 语 言 需 要 在 相 应 的 硬 件 平 台 上 运 行 才 有 实 际 意 义, 而 C 语 言 没 有 进 一 步 明 确 不 同 硬 件 平 台 下 int 位 宽 由 硬 件 平 台 决 定 这 一 点, 从 而 导 致 后 面 对 int 出 现 多 种 不 同 的 理 解 不 同 的 硬 件 平 台 所 支 持 的 数 据 位 宽 可 能 会 不 一 样, 在 计 算 机 技 术 发 展 过 程 中, 主 流 的 CPU 经 历 了 8bits 16bits 32bits 64bits 这 样 的 转 变, 不 同 的 人 在 理 解 int 时 往 往 会 基 于 当 时 流 行 的 CPU 加 入 自 己 的 个 人 理 解, 我 记 得 很 清 楚 国 内 一 很 知 名 的 C 语 言 教 材 早 期 版 本 里 面 对 int 解 释 就 是 16bits, 正 是 这 样 教 材 的 疏 漏 使 得 更 多 人 将 int 理 解 成 16bits, 后 来 32bits 处 理 器 的 流 行, 大 家 又 错 误 地 默 认 int 为 32bits 对 int 的 这 种 理 解 不 对, 实 际 上 int 并 没 有 一 个 具 体 的 位 宽 限 制, 由 所 用 硬 件 平 台 (MCU) 和 编 译 器 共 同 决 定 位 宽 为 多 少, 通 常 情 况 下 编 译 器 会 将 int 的 位 宽 定 为 与 所 用 MCU 的 位 宽 一 致, 这 样 MCU 对 定 义 为 int 的 数 据 进 行 处 理 时 因 为 刚 好 是 整 数 不 用 取 舍 或 拼 凑 而 最 为 方 便 不 同 的 MCU 和 所 提 供 的 编 译 器 对 int 的 解 释 各 不 相 同,8bits 16bits 32bits 64bits 都 有 可 能, 如 果 在 程 序 中 使 用 int 来 定 义 数 据 类 型, 就 会 将 一 些 不 确 定 因 素 引 入 程 序 中, 使 得 程 序 的 风 险 系 数 增 高 比 如 编 程 人 员 忽 视 了 编 译 器 对 int 定 义 的 位 宽, 习 惯 性 的 将 int 理 解 成 现 在 大 家 所 默 认 的 32bits, 如 果 现 在 我 们 用 一 个 MCU 在 C 语 言 下 开 发 了 一 款 产 品, 所 用 的 MCU 和 编 译 器 为 16bits 宽 度, 产 品 需 要 显 示 开 机 后 的 时 间, 显 示 精 度 需 要 达 到 秒, 程 序 员 在 程 序 里 变 量 SecondCounter 来 纪 MCU EDU 第 157 页 作 者 :Dai ShangJu

25 录 开 机 时 间, 程 序 员 将 unsigned int 错 误 的 理 解 成 了 32bits, 认 为 用 unsigned int 定 义 的 SecondCounter 可 以 保 证 所 记 录 的 开 机 时 间 超 过 100 年, 完 全 满 足 任 何 用 户 的 需 求 然 而 编 译 器 实 际 是 按 16bits 来 处 理, 只 能 记 录 到 65535/ 小 时 这 个 产 品 大 多 数 应 用 都 只 是 在 正 常 上 班 时 段, 早 上 上 班 时 开 机, 晚 上 下 班 时 关 机, 内 部 测 试 和 用 户 试 用 都 是 按 早 开 机 晚 关 机 器 模 式 进 行, 运 行 结 果 一 切 正 常, 于 是 开 始 量 产 然 而 另 外 客 户 使 用 中 发 现 了 问 题, 该 客 户 不 是 早 开 机 晚 关 机 模 式, 而 是 三 班 倒, 需 要 一 周 甚 至 一 个 月 才 关 机 一 次, 产 品 根 本 无 法 满 足 客 户 的 需 求, 结 果 是 只 能 将 已 经 生 产 的 机 器 当 作 问 题 机 处 理 这 种 情 况 主 要 还 是 因 为 开 发 人 员 的 疏 忽 导 致, 另 外 一 种 情 况 就 和 人 为 疏 忽 无 关, 用 C 语 言 编 程 一 大 优 点 就 是 移 植 容 易, 可 以 很 快 从 一 个 硬 件 平 台 转 换 到 另 外 一 个 硬 件 平 台 上 产 品 最 初 阶 段 是 采 用 32bits 的 MCU, 编 译 器 解 释 int 为 32bits, 程 序 员 理 解 没 有 错 误 也 是 32bits, 产 品 程 序 成 功 完 成, 运 行 一 切 正 常 32bits 的 MCU 价 格 比 较 贵, 成 本 上 和 其 它 同 类 产 品 不 具 竞 争 力, 现 发 现 有 一 款 16bits 的 MCU 可 以 满 足 性 能 需 求, 而 且 价 格 要 低 不 少, 于 是 希 望 改 用 这 款 16bits 的 MCU 先 前 已 经 写 好 的 程 序 由 于 使 用 了 大 量 的 int, 直 接 移 植 到 16bits 的 MCU 编 译 器 就 将 原 来 解 释 为 32bits 的 int 改 解 释 为 16bits, 显 然 存 在 数 据 溢 出 的 风 险, 就 需 要 我 们 对 原 程 序 中 所 有 int 都 进 行 修 订 如 果 我 们 将 原 来 的 int 全 部 替 换 为 long 就 可 以 避 免 数 据 溢 出 的 风 险, 但 这 样 做 需 要 我 们 将 程 序 里 面 所 有 的 int 定 义 逐 个 找 出 来 进 行 替 换, 有 一 个 遗 漏 都 不 算 成 功 移 植, 虽 然 我 们 可 以 用 编 辑 工 具 提 供 的 替 换 功 能, 但 替 换 功 能 会 将 所 有 int 字 符 都 替 换 掉, 会 将 本 不 需 要 更 改 的 地 方 改 错 如 果 我 们 一 开 始 就 将 int 用 long 来 定 义, 移 植 过 程 根 本 不 需 要 担 心 数 据 类 型 解 释 不 对 的 问 题, 使 得 移 植 程 序 的 工 作 量 会 大 为 减 少 正 是 这 些 因 素 的 存 在, 我 的 建 议 是 尽 量 少 在 程 序 中 使 用 int 进 行 数 据 定 义,C 语 言 提 供 更 为 精 准 的 数 据 类 别 char short long long long 分 别 严 格 对 应 8bits 16bits 32bits 64bits, 任 何 编 译 器 编 译 出 来 的 结 果 都 一 定 满 足 这 种 对 应 关 系, 这 样 定 义 出 来 的 数 据 宽 度 和 硬 件 无 关, 在 任 何 硬 件 平 台 上 编 译 出 来 的 宽 度 都 是 一 样 的, 所 以 用 它 们 定 义 数 据 类 型 会 更 好 请 记 住 : 用 C 编 写 程 序 的 时 候, 一 定 要 谨 慎 使 用 int, 最 好 是 不 用 4.8. 危 险 的 指 针 刚 接 触 C 语 言 的 人 可 能 会 不 大 明 白 指 针 到 底 是 什 么, 从 我 的 个 人 理 解, 指 针 就 是 存 储 器 的 地 址, 但 不 能 完 全 的 等 同 地 址, 指 针 除 了 直 接 提 供 地 址 信 息 外, 另 外 指 针 类 型 还 间 接 告 诉 大 家 所 指 向 的 地 址 包 含 多 少 内 容 用 一 个 例 子 来 帮 助 大 家 理 解 指 针, 假 设 现 在 你 是 一 个 统 领 部 队 的 指 挥 长, 将 手 下 的 士 兵 成 一 列 纵 队 站 好, 第 一 个 士 兵 编 号 为 0, 第 二 个 编 号 为 1, 依 次 类 推, 这 里 编 号 你 就 可 以 对 应 为 存 储 器 的 地 址 为 了 便 于 管 理, 你 将 士 兵 用 班 排 连 的 组 织 来 进 行 管 理, 一 个 班 有 十 个 士 兵, 一 个 排 有 三 个 班, 一 个 连 有 三 个 排 和 另 外 一 个 独 立 的 炊 事 班 一 连 一 排 一 班 : 士 兵 编 号 0~9 MCU EDU 第 158 页 作 者 :Dai ShangJu

26 一 连 一 排 二 班 : 士 兵 编 号 10~19 一 连 一 排 三 班 : 士 兵 编 号 20~29 一 连 二 排 一 班 : 士 兵 编 号 30~39 一 连 二 排 二 班 : 士 兵 编 号 40~49 一 连 二 排 三 班 : 士 兵 编 号 50~59 一 连 三 排 一 班 : 士 兵 编 号 60~69 一 连 三 排 二 班 : 士 兵 编 号 70~79 一 连 三 排 三 班 : 士 兵 编 号 80~89 一 连 炊 事 班 : 士 兵 编 号 90~99 一 连 一 排 一 班 : 士 兵 编 号 100~109 二 连 一 排 二 班 : 士 兵 编 号 110~119 二 连 一 排 三 班 : 士 兵 编 号 120~129 二 连 二 排 一 班 : 士 兵 编 号 130~139 这 里 的 连 排 班 以 及 士 兵 编 号 就 可 以 理 解 成 指 针, 每 个 士 兵 是 最 基 本 的 组 成 单 位, 其 对 应 的 编 号 对 应 为 存 储 器 的 地 址, 一 连 二 排 二 班 表 示 编 号 40~49 的 士 兵, 他 们 现 在 位 于 队 伍 中 的 第 40+1 个 人 的 位 置, 一 共 十 个 人 现 在 需 要 一 个 班 的 士 兵 去 执 行 任 务, 你 就 可 以 通 过 班 号 选 择 执 行 任 务 的 班, 下 次 需 要 一 个 排 你 又 可 以 通 过 排 号 来 选 则 执 行 任 务 的 排, 这 种 方 式 就 类 似 指 针 的 操 作 前 面 例 子 也 许 还 不 能 很 好 的 解 释 指 针, 接 下 来 直 接 回 到 C 语 言 中 对 指 针 进 行 讲 解, 先 从 最 基 本 的 char/short/long 类 型 说 起 (little endian 模 式 ) char *p_char; // 定 义 一 个 类 型 为 char 的 指 针 short *p_short; // 定 义 一 个 类 型 为 short 的 指 针 long *p_long; // 定 义 一 个 类 型 为 long 的 指 针 在 C 语 言 里 用 * 号 来 表 示 指 针, 这 一 点 是 当 时 定 义 C 语 言 语 法 的 人 决 定 的, 没 有 为 什 么 可 言, 当 初 定 义 语 法 的 人 选 用 了 * 号 而 已, 如 果 当 时 选 用 的 是 其 它 符 号 现 在 也 就 是 其 它 符 号 p_char=(char *)0x1000; // 将 指 针 指 向 地 址 0x1000 p_short =(short *)0x1000; // 将 指 针 指 向 地 址 0x1000 p_long =(long *)0x1000; // 将 指 针 指 向 地 址 0x1000 *p_char=0x12; // 地 址 0x1000 内 容 为 0x12 *p_short=0x1234; // 地 址 0x1000 内 容 为 0x34, 地 址 0x1001 内 容 为 0x12 *p_long=0x ; // 地 址 0x1000 内 容 为 0x78, 地 址 0x1001 内 容 为 0x56, 地 址 0x1003 内 容 为 0x34, 地 址 0x1004 内 容 为 0x12 可 以 看 出 指 向 同 样 地 址 的 不 同 类 型 的 指 针 所 代 表 的 内 容 并 不 相 同,char 的 指 针 为 一 个 字 节 的 内 容, 而 short 和 long 却 分 别 为 两 个 字 节 和 四 个 字 节, 显 然 指 针 除 了 带 有 地 址 信 息 外 还 有 所 包 含 内 容 大 小 的 信 息, 这 就 是 指 针 与 地 址 所 不 同 的 地 方 MCU EDU 第 159 页 作 者 :Dai ShangJu

27 注 意 将 指 针 指 向 一 个 地 址 的 操 作 并 不 是 使 用 p_char=0x1000 这 样 的 语 句 直 接 等, 而 是 使 用 了 (char *) 进 行 强 制 转 换, 如 果 不 加 (char *) 的 话 编 译 会 报 告 错 误 这 是 C 语 言 使 用 指 针 时 的 一 个 限 制, 所 有 对 于 指 针 的 操 作 必 须 是 同 类 型 的 指 针 才 可 以 进 行, 对 于 0x1000 这 样 一 个 数 字, 虽 然 我 们 可 以 当 它 是 一 个 地 址, 但 用 做 指 针 的 时 候 需 要 表 明 指 针 类 型 才 能 使 用, 否 则 程 序 无 法 知 道 *0x1000 这 样 的 操 作 表 示 的 到 底 是 一 个 字 节 的 char 类 型 还 是 两 个 字 节 的 short 类 型,C 语 言 有 这 样 的 限 制 后 就 可 以 让 指 针 和 地 址 区 分 开 用 C 语 言 编 程 变 量 的 分 配 大 都 由 编 译 器 决 定, 也 就 是 说 程 序 员 可 以 不 用 理 会 所 用 变 量 究 竟 放 在 什 么 位 置, 而 用 C 语 言 对 单 片 机 编 程 许 多 时 候 需 要 直 接 对 某 个 地 址 进 行 读 写 操 作, 引 入 指 针 就 会 使 这 类 操 作 变 的 更 简 单 直 接 对 于 char 类 型 的 指 针, 每 个 指 针 只 对 应 一 个 字 节 的 内 容, 而 short 类 型 则 是 两 个 字 节,C 语 言 为 了 提 升 效 率 对 于 这 类 指 针 做 出 了 起 始 地 址 对 齐 的 要 求, 比 如 short 指 针 地 址 需 要 能 被 二 整 除, 而 long 指 针 地 址 则 需 要 能 被 四 整 除 这 里 不 想 对 什 么 是 指 针 这 样 的 概 念 性 问 题 阐 述 过 多, 总 之 一 点 是 指 针 让 程 序 控 制 存 储 器 空 间 变 的 非 常 简 捷, 但 正 是 这 个 简 捷 打 破 了 C 语 言 的 封 闭 性, 让 程 序 员 可 以 随 心 所 欲 的 去 读 写 存 储 器 空 间, 所 以 在 便 捷 的 同 时 也 给 程 序 带 来 了 一 定 的 风 险 性 现 在 需 要 用 程 序 来 完 成 这 样 的 功 能 : 从 地 址 0x1000 开 始 将 依 次 写 入 头 256 字 节, 为 了 检 验 程 序 是 否 写 入 正 确 还 需 要 将 写 入 内 容 回 读 回 来 进 行 校 验 正 确 的 代 码 : long i; char *p1,*p2; // 这 里 指 针 类 型 是 char p1=(long *)0x1000; // 将 指 针 p1 地 址 指 向 0x1000 p2=(long *)0x1000; // 将 指 针 p2 地 址 指 向 0x1000 for(i=0;i<256;i++) *p1=i; // 将 指 针 内 容 依 次 写 为 p1++; // 指 针 加 一, 指 针 所 指 向 地 址 随 之 加 一 for(i=0;i<256;i++) if(*p2!=i) while(1); // 如 果 校 验 出 错 则 进 入 这 个 死 循 环 p2++; // 指 针 加 一, 指 针 所 指 向 地 址 随 之 加 一 MCU EDU 第 160 页 作 者 :Dai ShangJu

28 错 误 的 代 码 : long i,*p1,*p2; // 这 里 指 针 类 型 是 long p1=(long *)0x1000; // 将 指 针 p1 地 址 指 向 0x1000 p2=(long *)0x1000; // 将 指 针 p2 地 址 指 向 0x1000 for(i=0;i<256;i++) *p1=i; // 将 指 针 内 容 依 次 写 为 p1++; // 指 针 加 一, 实 际 上 指 针 所 指 向 地 址 加 四 for(i=0;i<256;i++) if(*p2!=i) while(1); // 如 果 校 验 出 错 则 进 入 这 个 死 循 环 p2++; // 指 针 加 一, 实 际 上 指 针 所 指 向 地 址 加 四 错 误 代 码 的 原 因 是 未 能 正 确 使 用 指 针, 对 于 char 类 型 的 指 针, 执 行 自 加 或 者 加 一 操 作 后 指 针 地 址 同 样 是 加 一, 而 short 和 long 则 不 一 样, 分 别 加 二 和 加 四 char *p=0x1000; //char 类 型 指 针 p 指 向 地 址 0x1000 p++; // 执 行 完 该 指 令 后 指 针 p 指 向 地 址 0x1001, 注 意 这 里 指 针 地 址 加 一 long *p=0x1000; // char 类 型 指 针 p 指 向 地 址 0x1000 p++; // 执 行 完 该 指 令 后 指 针 p 指 向 地 址 0x1004, 注 意 这 里 指 针 地 址 加 四 正 确 写 入 的 结 果 : 地 址 内 容 0x1000 0x00 0x1001 0x01 0x1002 0x02 0x10FF 0xFF 错 误 写 入 的 结 果 : 地 址 内 容 0x1000 0x00 0x1001 0x00 多 写 入 的 0x00 0x1002 0x00 多 写 入 的 0x00 MCU EDU 第 161 页 作 者 :Dai ShangJu

29 0x1003 0x00 多 写 入 的 0x00 0x1004 0x01 0x1005 0x00 多 写 入 的 0x00 0x1006 0x00 多 写 入 的 0x00 0x1007 0x00 多 写 入 的 0x00 0x13FC 0xFF 0x13FD 0x00 多 写 入 的 0x00 0x13FE 0x00 多 写 入 的 0x00 0x13FF 0x00 多 写 入 的 0x00 可 以 看 出 错 误 是 每 写 一 个 数 据 会 另 外 在 后 面 多 写 入 三 个 0x00, 同 时 地 址 往 后 加 四, 虽 然 代 码 也 有 进 行 回 读 校 验 的 操 作, 但 回 读 操 作 完 全 是 写 入 操 作 的 逆 向 过 程, 所 以 这 个 校 验 不 会 发 现 该 错 误, 如 果 不 发 生 空 间 溢 出 错 误, 这 个 错 误 就 会 被 隐 藏 起 来 而 不 被 发 现, 从 外 表 看 程 序 运 行 一 切 正 常, 但 内 部 的 实 际 运 行 结 果 并 不 是 程 序 员 所 预 期 的 不 要 认 为 这 种 错 误 不 严 重, 如 果 位 于 0x1100~0x13FF 的 空 间 有 其 它 作 用, 前 面 的 错 误 就 会 导 致 这 部 分 空 间 的 内 容 被 错 误 修 改, 从 而 导 致 程 序 运 行 出 错, 严 重 的 可 以 让 程 序 崩 溃 使 用 指 针 最 大 的 风 险 是 容 易 产 生 空 间 溢 出 或 者 地 址 错 误 的 情 况, 用 C 语 言 对 数 组 或 者 变 量 进 行 读 写 的 时 候, 虽 然 程 序 员 不 清 楚 这 些 数 组 或 者 变 量 在 存 储 器 中 的 具 体 位 置, 但 读 写 操 作 是 用 数 组 或 变 量 名 来 进 行 读 写 的, 所 以 很 容 易 做 到 所 需 要 进 行 读 写 的 对 象 不 出 错, 如 果 在 编 写 程 序 时 因 为 书 写 等 原 因 让 名 称 出 错, 编 译 器 也 会 报 告 名 称 错 误, 这 样 读 写 到 错 误 位 置 的 几 率 会 相 当 小, 除 非 在 代 码 中 定 义 了 名 称 非 常 相 似 的 数 组 或 变 量 名 而 用 指 针 来 进 行 读 写 则 不 一 样, 需 要 程 序 员 自 我 对 读 写 的 位 置 进 行 保 护 确 认, 只 要 有 一 点 疏 漏 就 可 能 导 致 错 误 的 产 生 来 看 一 个 例 子, 这 个 例 子 是 因 为 其 它 用 途 方 便 而 定 义 了 四 个 64 字 节 的 数 组, 现 在 想 将 0~255 分 别 写 到 这 四 个 数 组 里 面 去, 数 组 Temp_BufA[] 写 入 0~63, 数 组 Temp_BufB[] 写 入 64~127, 数 组 Temp_BufC[] 写 入 128~191, 数 组 Temp_BufD[] 写 入 192~255 char Temp_Byte; char align(256) Temp_BufE[256]; // align(256) 表 示 起 始 地 址 需 要 256 字 节 对 齐 char Temp_BufA[64]; char Temp_BufB[64]; char Temp_BufC[64]; char Temp_BufD[64]; char *p; long i; p=temp_bufa; // 指 针 地 址 指 向 数 组 Temp_BufA[64] 的 首 字 节 地 址 MCU EDU 第 162 页 作 者 :Dai ShangJu

30 for(i=0;i<256;i++) *p++=i; // 依 次 写 为 可 能 不 少 人 会 认 为 这 段 程 序 没 有 问 题, 他 们 会 说 数 组 Temp_BufA[] 到 数 组 Temp_BufD[] 是 连 续 定 义 的, 在 程 序 里 面 所 占 用 的 存 储 空 间 自 然 也 是 连 续 的, 前 面 的 程 序 只 用 一 个 指 针 循 环 就 可 以 将 这 四 个 数 组 写 入 所 需 的 值, 所 以 程 序 不 但 没 有 问 题, 而 且 还 是 一 段 很 精 简 的 代 码, 值 得 大 家 学 习 实 际 情 况 并 不 如 此, 我 们 并 不 能 保 证 数 组 Temp_BufA[] 到 数 组 Temp_BufD[] 占 用 连 续 的 存 储 空 间, 有 可 能 这 四 个 数 组 是 被 间 隔 开 假 定 存 储 空 间 的 分 配 是 从 地 址 0x1000 开 始, 编 译 器 看 到 Temp_Byte, 于 是 将 地 址 0x1000 分 配 给 Temp_Byte 用, 可 接 下 来 的 是 数 组 Temp_BufE[], 需 要 256 字 节 对 齐, 显 然 不 能 再 将 0x1001 分 配 为 数 组 Temp_BufE[] 的 起 始 地 址, 而 是 分 配 0x1100 才 满 足 要 求 这 时 编 译 器 处 理 到 数 组 Temp_BufA[], 因 为 地 址 0x1001~0x10FF 区 间 还 没 有 被 分 配 出 去, 所 以 将 0x1001~0x1040 区 间 分 配 给 数 组 Temp_BufA[], 而 不 是 从 地 址 0x1200 开 始 分 配 与 数 组 Temp_BufA[] 一 样 数 组 Temp_BufB[] 和 数 组 Temp_BufC[] 会 被 分 配 到 地 址 0x1041~0x1080 和 0x1081~0x10C0 这 两 段 区 域 但 处 理 到 数 组 Temp_BufD[] 时 遇 到 新 问 题, 显 然 数 组 Temp_BufD[] 需 要 连 续 的 64 字 节, 而 现 在 从 地 址 0x10C1 开 始 到 0x10FF 只 有 63 个 字 节 的 剩 余 空 间, 所 以 数 组 Temp_BufD[] 所 分 配 的 空 间 只 好 分 配 为 地 址 0x1200~0x123F 这 一 段, 这 样 四 个 数 组 的 空 间 并 不 连 续, 如 果 运 行 前 面 的 代 码 自 然 就 会 得 到 错 误 的 结 果 按 前 面 假 定 编 译 器 可 以 得 出 的 存 储 器 分 配 空 间 如 下 ( 实 际 情 况 不 一 定 和 此 相 同 ): 地 址 内 容 0x1000 变 量 Temp_Byte 0x1001~0x1040 数 组 Temp_BufA[64] 0x1041~0x1080 数 组 Temp_BufB[64] 0x1081~0x10C0 数 组 Temp_BufC[64] 0x10C1~0x10C3 空 余 区 间 0x10C4~0x10C7 指 针 *p 0x10C8~0x10CB 变 量 i 0x10CC~0x10FF 空 余 区 间 0x1100~0x11FF 数 组 Temp_BufE[256] 0x1200~0x123F 数 组 Temp_BufD[64] 指 针 有 的 时 候 会 有 地 址 对 齐 的 要 求, 比 如 short 和 long 类 型 的 指 针 分 别 要 求 两 字 节 和 四 字 节 对 齐, 有 的 编 译 器 并 不 能 对 这 些 细 节 进 行 可 靠 的 检 查, 稍 有 不 慎 就 可 能 用 错 指 针 long *p; // 申 明 类 型 为 long 的 指 针, 按 要 求 需 四 字 节 对 齐 MCU EDU 第 163 页 作 者 :Dai ShangJu

31 p=(long *)0x1001; // 这 里 将 指 针 地 址 指 向 0x1001 这 样 的 代 码 有 的 编 译 器 不 会 报 告 错 误, 而 实 际 上 类 型 为 long 的 指 针 地 址 是 必 须 四 字 节 对 齐 的, 所 以 代 码 带 有 错 误, 执 行 这 样 的 代 码 会 导 致 错 误 发 生, 而 程 序 员 还 以 为 自 己 已 经 成 功 将 地 址 0x1001 交 给 指 针 p 指 针 空 间 溢 出 的 错 误 在 实 际 中 最 容 易 发 生, 常 常 会 遇 到 这 样 的 情 况, 变 量 没 有 被 任 何 代 码 直 接 修 改, 但 程 序 运 行 的 结 果 发 现 变 量 内 容 被 修 改 成 程 序 员 所 不 期 望 的 内 容, 这 种 错 误 大 都 是 使 用 指 针 空 间 溢 出 导 致 的 对 于 这 种 错 误 由 于 不 能 通 过 查 看 代 码 是 否 更 改 了 变 量, 加 上 错 误 的 产 生 是 偶 然 的, 需 要 在 某 些 特 定 条 件 下 才 会 出 现, 所 以 如 果 仿 真 调 试 工 具 功 能 不 是 很 强 大 的 话 很 难 调 试 跟 踪 这 种 错 误 虽 然 这 种 错 误 经 常 会 遇 到, 但 形 成 的 原 因 往 往 错 综 复 杂, 不 大 容 易 用 一 个 简 洁 的 例 子 就 能 说 明 清 楚, 这 里 给 出 一 个 例 子, 错 误 产 生 的 根 源 也 许 并 不 能 完 全 归 于 指 针, 但 确 实 是 和 使 用 指 针 有 关 我 们 通 过 UART 收 发 数 据, 数 据 依 照 下 面 格 式 进 行 传 送, 最 大 长 度 不 超 过 1024 字 节 ( 例 子 代 码 是 针 对 演 示 错 误 而 特 意 写 成 下 面 形 式 ) Byte1 同 步 字 0xFF, 用 来 标 示 数 据 包 开 始 Byte2~3 两 个 字 节 用 来 表 示 数 据 包 长 度 Byte4~N 数 据 内 容, 规 定 数 据 包 中 不 可 以 包 含 0xFF 以 免 与 同 步 字 冲 突 ByteN+1 数 据 包 内 容 校 验 码 低 位 字 节 ByteN+2 数 据 包 内 容 校 验 码 高 位 字 节 接 收 端 代 码 : unsigned short receive_count; // 数 据 接 收 计 数 器 unsigned short check_sum; // 用 来 计 算 数 据 包 校 验 码 unsigned char receive_buf[1024],*p; // 数 据 存 放 缓 冲 区 和 接 收 存 放 指 针 char receive_flag=0; // 数 据 接 收 状 态 标 志 UART_RxInt() // 每 收 到 一 个 字 节 都 会 触 发 该 中 断 函 数 unsigned char temp; temp=*uart_rx_data; // 将 接 收 到 的 数 据 读 到 temp 中 // 其 它 代 码 if((receive_flag==0)&&(temp==0xff)) // 如 果 接 收 状 态 为 0 且 当 前 收 到 同 步 字 receive_falg=1; // 接 收 状 态 转 为 1 p=receive_buf; // 接 收 指 针 指 向 接 收 缓 冲 区 首 地 址 else if(receive_flag==1) // 如 果 接 收 状 态 为 1 MCU EDU 第 164 页 作 者 :Dai ShangJu

32 receive_flag=2; // 接 收 状 态 转 为 2 receive_count=temp; // 保 存 数 据 包 长 度 低 位 字 节 else if(receive_flag==2) // 如 果 接 收 状 态 为 2 receive_flag=3; // 接 收 状 态 转 为 3 receive_count =(temp<<8); // 保 存 数 据 包 长 度 高 位 字 节 else if(receive_flag==3) // 如 果 接 收 状 态 为 3 if(receive_count>0) // 保 存 数 据 直 到 数 据 接 收 计 数 器 为 零 *p++=temp; // 保 存 数 据 到 缓 冲 区, 指 针 地 址 加 一 receive_count--; // 数 据 接 收 计 数 器 减 一 else receive_flag=4; // 接 收 状 态 转 为 4 else if(receive_flag==4) // 如 果 接 收 状 态 为 4 receive_flag=5; // 接 收 状 态 转 为 5 check_sum=temp; // 得 到 校 验 码 低 位 字 节 else if(receive_flag==5) // 如 果 接 收 状 态 为 5 receive_flag=0; // 接 收 状 态 转 为 0 check_sum =(temp<<8); // 得 到 校 验 码 高 位 字 节 // 数 据 处 理 代 码 不 能 说 上 面 代 码 是 错 误 的, 正 常 情 况 下 上 面 的 代 码 运 行 结 果 都 不 会 有 什 么 问 题, 但 这 部 分 代 码 是 用 来 接 收 另 外 设 备 通 过 UART 发 送 过 来 的 数 据, 这 个 收 发 过 程 可 能 会 因 为 外 部 干 扰 等 原 因 造 成 传 MCU EDU 第 165 页 作 者 :Dai ShangJu

33 输 数 据 出 错, 当 这 种 情 况 发 生 时, 程 序 就 会 变 的 不 在 稳 定 可 靠 实 际 上 前 面 的 代 码 也 有 考 虑 到 数 据 传 输 可 能 会 出 错, 在 数 据 包 中 加 上 校 验 码 就 是 用 来 判 断 数 据 传 输 是 否 出 错, 如 果 数 据 传 输 出 错, 校 验 码 会 不 对, 这 样 程 序 就 可 以 把 所 接 收 到 的 数 据 包 做 相 应 处 理 但 对 这 部 分 代 码 传 输 出 错 的 考 虑 不 够 周 到, 只 是 去 判 断 数 据 包 是 否 出 错, 并 没 有 去 考 虑 出 错 位 置 不 同 可 能 带 来 的 不 同 影 响 干 扰 是 随 机 的, 所 以 传 输 的 错 误 可 以 产 生 在 数 据 包 的 任 意 位 置, 如 果 果 然 刚 好 在 传 送 数 据 包 长 度 的 时 候 导 致 数 据 传 输 出 错, 比 如 现 在 数 据 包 长 度 原 本 是 0x200(512 字 节 ), 干 扰 导 致 这 个 长 度 变 为 0x1200(4608) 字 节, 这 时 前 面 代 码 面 临 的 问 题 就 非 常 严 重, 会 从 receive_buf[] 的 起 始 位 置 开 始 存 放 4608 字 节 后 才 终 止 接 收 过 程, 而 receive_buf[] 只 有 1024 字 节 的 空 间, 也 就 是 说 后 面 会 有 =3584 字 节 的 空 间 会 被 指 针 错 误 修 改 象 这 种 错 误 的 调 试 跟 踪 会 非 常 困 难, 因 为 它 发 生 的 概 率 本 身 就 非 常 小, 可 以 说 连 续 发 生 两 次 的 几 率 几 乎 为 零, 而 这 个 错 误 一 旦 发 生, 很 有 可 能 让 整 个 程 序 崩 溃, 即 便 当 时 想 通 过 仿 真 调 试 工 具 去 查 看 现 场 也 是 很 困 难, 可 以 说 是 无 法 通 过 调 试 的 方 法 手 段 来 找 出 这 类 错 误 根 源, 如 果 想 避 免 这 类 错 误, 只 能 是 在 编 写 代 码 阶 段 就 充 分 考 虑 到 各 种 可 能 性, 在 代 码 中 对 各 种 异 常 做 出 相 应 保 护 而 避 免 意 外 出 错 真 可 谓 是 指 针 虽 好, 可 用 起 来 并 不 简 单, 刚 开 始 接 触 单 片 机 C 语 言 编 程 的 朋 友 还 是 多 用 数 组 来 编 写 代 码 比 较 好 一 些, 当 自 己 对 C 语 言 有 一 个 良 好 的 掌 握 程 度 后 再 去 逐 步 使 用 指 针, 使 用 指 针 的 时 候 一 定 要 仔 细 确 认 指 针 是 不 是 依 照 自 己 的 想 法 在 变 动, 最 好 在 指 针 改 变 后 查 看 一 下 地 址 是 否 正 确 4.9. 循 环 延 时 用 C 语 言 编 写 单 片 机 程 序 时, 常 会 遇 到 一 些 需 要 延 时 等 待 的 情 况, 不 少 程 序 员 为 了 图 方 便 经 常 会 用 for(i=0;i<1000;i++) 这 样 循 环 来 实 现 延 时, 我 自 己 有 时 候 也 都 这 么 做, 这 不 是 一 个 好 的 方 法 首 先 这 样 的 循 环 代 码 写 出 来 后 程 序 员 自 己 也 不 清 楚 这 段 代 码 到 底 延 时 有 多 久, 还 需 要 用 仿 真 器 观 察 对 应 汇 编 指 令 或 者 用 仪 器 测 试 延 时 时 间 的 大 小 其 次 所 得 到 延 时 时 间 稳 定 性 不 够 好, 如 果 在 延 时 循 环 中 有 中 断 产 生 就 会 使 得 延 时 变 大, 所 以 在 实 际 程 序 运 行 时 执 行 完 这 个 循 环 所 耗 用 的 时 间 存 在 长 短 不 一 的 可 能, 中 断 对 循 环 延 时 的 影 响 还 不 是 特 别 大, 因 为 其 它 方 式 实 现 延 时 也 会 受 到 中 断 的 影 响, 比 如 我 们 想 实 现 延 时 100us, 延 时 循 环 中 一 个 需 要 耗 时 200us 的 中 断 产 生, 这 样 不 管 用 什 么 方 法, 当 响 应 完 中 断 返 回 时 时 间 就 多 出 了 200us, 也 就 是 说 这 时 无 论 什 么 方 法 来 实 现 的 延 时 都 不 会 少 于 200us 对 循 环 方 式 延 时 影 响 真 正 大 的 是 编 译 优 化 系 统 时 钟 改 变 这 两 种 操 作 我 们 来 看 一 下 用 ADS 编 译 器 不 同 优 化 条 件 下 对 循 环 for(i=0;i<1000;i++) 的 影 响, 先 关 闭 优 化 功 能, 可 以 看 出 循 环 部 分 代 码 需 要 四 条 汇 编 指 令 MCU EDU 第 166 页 作 者 :Dai ShangJu

34 图 ADS 对 for 循 环 无 优 化 编 译 结 果 图 再 来 看 看 打 开 优 化 功 能 后 的 情 况, 循 环 部 分 的 代 码 从 原 来 的 四 条 变 成 了 三 条, 也 就 是 说 在 硬 件 不 做 任 何 变 动 的 情 况 循 环 的 时 间 会 改 变 为 原 来 的 四 分 之 三, 这 个 影 响 是 非 常 明 显 的, 很 有 可 能 就 形 成 延 时 不 够 的 情 况 图 ADS 对 for 循 环 有 优 化 编 译 结 果 图 对 于 系 统 时 钟 改 变 的 情 况 很 容 易 理 解, 系 统 时 钟 被 改 变, 每 条 指 令 执 行 的 时 间 同 样 会 相 应 发 生 变 化, 举 个 极 端 的 例 子, 原 本 是 用 8MHz 的 晶 振 现 在 改 用 4MHz, 每 条 执 行 执 行 的 时 间 就 会 增 加 一 倍, 循 环 所 花 的 时 间 自 然 也 就 增 加 了 一 倍 有 人 可 能 有 疑 问, 我 们 在 实 际 应 用 中 不 会 改 用 不 同 频 率 的 晶 振, 那 不 就 不 用 担 心 这 样 的 情 况 了 吗? 是 的, 大 多 数 时 候 不 用 担 心 这 个 问 题, 但 在 某 些 特 殊 情 况 下 就 需 要 考 虑 该 问 题, 比 如 功 能 强 大 一 点 的 MCU 可 以 通 过 PLL 来 设 定 系 统 时 钟, 即 便 不 改 变 晶 振 频 率 也 可 以 改 变 系 统 时 钟, 当 系 统 时 钟 频 率 高 的 时 候 MCU 处 理 速 度 快, 但 会 有 芯 片 发 热 大 对 外 辐 射 增 加 稳 定 性 变 差 这 些 问 题 产 生, 所 以 有 的 产 品 当 需 要 高 速 处 理 数 据 的 时 候 就 将 PLL 设 为 高 频 率 以 满 MCU EDU 第 167 页 作 者 :Dai ShangJu

35 足 数 据 处 理 需 求, 当 数 据 处 理 完 又 恢 复 为 PLL 低 频 率 得 到 一 个 稳 定 可 靠 的 工 作 状 态, 对 于 这 种 情 况 循 环 延 时 就 会 不 准 确 我 们 知 道 电 源 电 压 波 动 电 阻 阻 值 误 差 这 些 因 素 都 会 影 响 RC 振 荡 器 的 工 作 频 率, 所 以 当 MCU 使 用 RC 振 荡 器 的 时 候 也 会 让 循 环 延 时 不 准,PLL 还 可 以 根 据 对 PLL 的 设 定 值 判 断 当 前 工 作 频 率 来 解 决 时 钟 变 化 导 致 的 影 响, 而 RC 振 荡 器 则 完 全 无 法 知 道 时 钟 的 变 化, 通 过 程 序 是 无 法 让 循 环 延 时 修 正 误 差 如 果 想 要 避 免 因 优 化 对 循 环 延 时 产 生 的 影 响, 建 议 用 汇 编 指 令 来 延 时, 编 译 器 不 会 对 汇 编 指 令 进 行 优 化, 所 以 编 译 器 优 化 的 选 择 与 否 不 会 影 响 汇 编 指 令 的 那 部 分 代 码, 汇 编 语 言 写 的 延 时 代 码 只 要 系 统 时 钟 不 变 就 能 保 证 延 时 恒 定 另 外 通 过 查 询 MCU 的 编 程 手 册, 可 以 知 道 每 条 汇 编 指 令 所 需 要 的 机 器 周 期 数, 汇 编 语 言 写 的 延 时 代 码 可 以 精 确 一 个 机 器 周 期, 程 序 员 通 过 计 算 汇 编 指 令 数 就 能 知 道 延 时 时 间 的 长 短, 从 而 解 决 了 用 C 语 言 写 循 环 代 码 延 时 时 间 不 透 明 的 问 题 时 钟 改 变 的 情 况 不 容 易 处 理, 只 能 是 在 程 序 中 依 据 硬 件 的 实 际 情 况 提 前 做 出 预 测, 尽 量 做 到 延 时 时 间 不 小 于 最 低 要 求, 从 而 保 证 程 序 的 可 靠 执 行, 比 如 现 在 采 用 的 是 RC 振 荡 器, 经 过 分 析 预 计 其 工 作 频 率 可 能 存 在 2% 的 误 差, 如 果 需 要 延 时 100 微 秒,MCU 一 个 机 器 周 期 是 1/8 微 秒, 我 们 就 要 保 证 延 时 代 码 的 理 论 延 时 不 小 于 102*8=816 个 机 器 周 期, 否 则 可 能 有 少 量 硬 件 延 时 达 不 到 100 微 秒, 对 于 实 际 应 用 还 需 要 留 有 足 够 的 余 量, 我 一 般 是 将 这 个 余 量 定 为 20%, 也 就 是 说 按 120 微 秒 来 编 写 代 码 这 段 以 6502 指 令 为 基 础 的 C 汇 编 延 时 代 码 可 以 用 来 帮 助 大 家 了 解 如 何 在 C 语 言 编 程 中 实 现 汇 编 代 码 延 时, 假 定 是 指 令 周 期 等 于 机 器 周 期, 不 考 虑 中 断 的 影 响 void _delay_cycle(unsigned char n) #ASM ; 标 示 下 面 为 嵌 入 到 C 代 码 中 的 汇 编 代 码 TAX ; 执 行 该 汇 编 指 令 需 1 个 机 器 周 期,C 函 数 参 数 传 入 DELAY_100LOOP: ; 循 环 体 执 行 需 要 3*X-1 个 机 器 周 期 DEX ; 执 行 该 汇 编 指 令 需 1 个 机 器 周 期 BNE DELAY_LOOP ; 跳 转 回 去 需 2 个 机 器 周 期, 结 束 循 环 需 1 个 机 器 周 期 #ENDASM ; 标 示 嵌 入 到 C 代 码 中 的 汇 编 代 码 结 束 //C 语 言 函 数 返 回 需 要 2 个 机 器 周 期 //RTS 调 用 示 例 : _delay_cycle(100); MCU EDU 第 168 页 作 者 :Dai ShangJu

36 //C 函 数 输 入 参 数 n 通 过 累 加 器 A 传 人, 将 n 写 入 累 加 器 A 需 1 个 机 器 周 期 //LDA #100 // 调 用 函 数 需 2 个 机 器 周 期 //JSR _delay_cycle 可 以 看 出 函 数 被 调 用 一 次 需 要 耗 费 1+2+(1+(n*3-1)+2)=n*3+5 个 机 器 周 期,n 的 取 值 范 围 为 0~255, 这 样 通 过 调 用 该 函 数 可 以 实 现 的 延 时 为 5~770 个 机 器 周 期, 间 隔 为 每 档 3 个 机 器 周 期, 如 果 是 一 个 系 统 时 钟 为 8MHz 的 系 统, 该 函 数 的 理 论 延 时 是 0.625~96.25 微 秒, 间 隔 为 微 秒 上 面 是 用 循 环 实 现 延 时, 即 便 是 用 汇 编 代 码 来 实 现 从 我 个 人 的 角 度 看 也 不 值 得 提 倡, 比 较 好 的 做 法 应 该 是 充 分 利 用 MCU 所 带 的 timer 资 源, 用 timer 中 断 实 现 延 时, 这 样 做 在 计 算 延 时 时 间 时 要 便 捷 不 少, 同 时 还 能 保 证 到 具 有 良 好 延 时 精 准 度 这 章 最 后 用 C 的 伪 代 码 给 大 家 示 意 一 下 如 何 可 以 通 过 timer 中 断 实 现 精 确 延 时, 假 定 可 以 将 timer 中 断 设 置 到 比 较 高 的 中 断 优 先 级, 通 过 timer 中 断 来 停 止 在 主 程 序 中 启 动 的 testing, 这 样 的 做 法 可 以 让 延 时 非 常 精 准 void (*timer_callback)(void); // 定 义 一 个 函 数 指 针 unsigned long timer_int_flag=0; // 定 义 timer 中 断 标 志 变 量 void timer_irq(void) //timer 中 断 函 数 if(timer_callback!=null) timer_callback(); // 如 果 函 数 指 针 不 为 空 则 执 行 对 应 函 数 // 如 指 针 为 stop_testing 则 执 行 stop_testing() DISABLE_TIMER_IRQ(); // 禁 止 timer 中 断, 具 体 代 码 忽 略 timer_callback=null; // 清 函 数 指 针 为 空 timer_int_flag=1; // 置 timer 中 断 标 志 void timer_delay(unsigned long us,void *callback) // 将 第 二 输 入 参 数 的 指 针 给 函 数 指 针 timer_callback=callback; // 将 第 二 输 入 参 数 的 指 针 给 函 数 指 针 set_timer_counter(us); // 将 timer 相 关 寄 存 器 设 定 为 所 需 要 的 内 容 // 具 体 代 码 忽 略 ENABLE_TIMER_IRQ(); // 使 能 timer 中 断, 具 体 代 码 忽 略 MCU EDU 第 169 页 作 者 :Dai ShangJu

37 void start_testing(void) // 启 动 测 试 函 数... // 启 动 测 试 的 代 码, 具 体 代 码 忽 略 void stop_testing(void) // 停 止 测 试 函 数... // 停 止 测 试 的 代 码, 具 体 代 码 忽 略 void main(void)... timer_int_flag=0; // 清 timer 中 断 标 志 start_testing(); // 调 用 启 动 测 试 函 数 timer_delay(10000,stop_testing); // 延 时 10000us 后 产 生 timer 中 断 停 止 测 试 // 在 timer 中 断 中 会 执 行 函 数 stop_testing() while(time_int_flag==0); // 等 待 timer 中 断 标 志 被 置 为 1... 例 子 中 的 伪 代 码 没 有 考 虑 代 码 自 身 产 生 的 延 时, 也 没 有 考 虑 如 果 有 优 化 时 对 全 局 变 量 应 采 取 的 相 应 保 护 措 施 留 一 个 问 题 给 大 家, 为 什 么 需 要 将 停 止 测 试 的 函 数 stop_testing() 放 在 timer 中 断 中, 而 不 是 在 while(time_int_flag==0); 之 后 调 用? 运 算 表 达 式 用 C 语 言 编 程, 少 不 了 使 用 运 算 表 达 式,C 语 言 的 运 算 表 达 式 和 日 常 生 活 中 的 数 学 表 达 式 非 常 接 近, 所 以 运 算 表 达 式 对 使 用 者 来 说 非 常 直 观, 也 很 容 易 理 解 数 学 里 面 一 个 数 是 正 是 负 是 整 数 还 是 小 数 可 以 用 负 号 和 小 数 点 来 让 人 知 道 这 个 数 的 类 型, 知 道 了 数 的 类 型 人 们 就 可 以 按 照 数 学 法 则 进 行 运 算 但 C 语 言 毕 竟 不 是 我 们 上 小 学 就 开 始 学 习 的 数 学, 因 为 计 算 机 技 术 的 限 制, 在 C 程 序 中 出 现 整 数 和 小 数 有 符 号 数 和 无 符 号 数 混 用 等 情 况 时, 为 了 保 证 计 算 结 果 正 确,C 语 言 对 这 些 情 况 做 出 了 一 些 自 己 的 特 性 约 定, 让 不 同 类 型 的 数 混 用 时 按 某 一 个 规 律 自 动 进 行 转 换, 这 样 一 来 就 出 现 同 样 的 运 算 表 达 式 C 语 言 和 日 常 生 活 中 的 数 学 运 算 结 果 不 相 同 的 情 况 在 用 C 语 言 进 行 编 程 时, 一 定 要 留 意 它 和 日 常 生 活 中 数 学 在 处 理 运 算 表 达 式 方 面 的 不 同, 否 则 就 会 让 程 序 出 现 一 些 本 可 以 避 免 的 错 误 我 曾 经 遇 到 过 这 样 的 情 况, 用 check_sum 对 通 讯 的 数 据 进 行 一 个 简 单 的 保 护, 保 护 的 方 法 相 当 MCU EDU 第 170 页 作 者 :Dai ShangJu

38 简 单, 就 是 将 通 讯 的 数 据 累 加 求 和, 发 送 完 数 据 后 再 将 计 算 所 得 的 和 发 送 给 接 收 方, 接 收 方 也 同 样 将 所 接 收 的 数 据 累 加 求 和, 然 后 和 发 送 过 来 的 校 验 和 做 比 较, 如 果 两 者 一 致 就 认 为 数 据 传 输 过 程 是 可 靠 的 按 说 这 个 方 法 很 简 单, 不 大 可 能 出 错, 可 实 际 情 况 就 是 我 所 写 的 C 程 序 会 出 错, 会 将 原 本 传 输 正 确 的 数 据 错 误 判 断 为 传 输 出 错 出 错 的 原 因 就 是 对 C 语 言 的 运 算 表 达 式 理 解 有 误,C 语 言 在 进 行 处 理 运 算 表 达 式 的 时 候 有 一 条 基 本 法 则 : 如 果 在 运 算 表 达 式 中 有 不 同 类 型 的 变 量, 运 算 的 时 候 是 signed 遇 到 unsigned 会 自 动 将 signed 转 换 成 unsigned, 数 据 位 宽 度 小 的 自 动 转 换 成 和 大 的 数 据 位 宽 一 致 暂 先 不 对 这 条 基 本 法 则 做 过 多 的 解 释, 看 看 我 当 时 是 如 何 出 错 的, 接 收 方 C 代 码 是 将 接 收 到 的 数 据 放 到 unsigned char data_buf[] 中, 再 将 全 部 数 据 累 加 求 和 得 出 校 验 码 发 送 方 采 用 汇 编 编 写 代 码, 这 里 不 列 出 具 体 代 码 unsigned char buf[7]; // 前 面 6 个 字 节 放 数 据, 第 7 个 字 节 为 校 验 码 unsigned char receive_flag; // 用 来 表 示 校 验 结 果 的 标 志 变 量 if((buf[0]+buf[1]+buf[2]+buf[3]+buf[4]+buf[5])==buf[6]) receive_flag=data_check_right; // 校 验 结 果 正 确, 认 为 传 输 可 靠 else receive_flag=data_check_error; // 校 验 出 错, 认 为 传 输 有 错 误 传 输 的 数 据 包 长 度 不 长, 为 节 省 代 码, 没 有 用 循 环 语 句 而 是 直 接 将 6 个 字 节 的 数 据 相 加 求 和, 当 时 我 的 理 解 是 if((buf[0]+buf[1]+buf[2]+buf[3]+buf[4]+buf[5])==buf[6]) 表 达 式 中 全 部 是 同 一 类 型 的 unsigned char 数 组 成 员 变 量, 那 计 算 过 程 也 应 该 是 自 动 按 unsigned char 类 型 处 理, 如 果 数 据 相 加 求 和 溢 出 也 会 将 求 和 自 动 转 换 成 unsigned char 类 型, 比 如 这 6 个 字 节 加 起 来 的 和 为 0x0123, 会 自 动 将 这 个 和 处 理 成 0x23, 溢 出 的 高 位 将 被 舍 弃 掉, 这 样 代 码 是 可 靠 的 实 际 情 况 并 不 是 我 所 想 像 的 样 子, 假 如 现 在 buf[7]=0x11,0x22,0x33,0x44,0x55,0x66,0x65, 人 工 计 算 0x11+0x22+ +0x66=0x165, 那 么 汇 编 计 算 出 来 的 校 验 码 应 是 0x65, 和 数 组 最 后 一 个 字 节 一 致, 表 明 这 次 传 输 的 数 据 是 可 靠 的, 但 C 代 码 执 行 的 结 果 并 不 是 这 样, 会 报 告 数 据 校 验 出 错, 通 过 调 试 查 看 C 代 码 对 应 的 汇 编 指 令 知 道 错 误 原 因, 对 数 据 相 加 的 结 果 不 是 和 我 所 想 的 一 样 会 自 动 转 换 成 unsigned char 类 型, 这 个 时 候 是 将 加 出 来 的 结 果 按 MCU 的 位 宽 来 处 理, 所 以 校 验 出 错, 正 确 代 码 应 如 下 所 示 将 运 算 表 达 式 的 结 果 先 进 行 强 制 转 换 if(((buf[0]+buf[1]+buf[2]+buf[3]+buf[4]+buf[5])&0xff)==buf[6]) // 或 if((unsigned char)((buf[0]+buf[1]+buf[2]+buf[3]+buf[4]+buf[5]))==buf[6]) MCU EDU 第 171 页 作 者 :Dai ShangJu