C语言嵌入式系统编程------软件架构篇

zzxyd_qiao

模块划分
3 d( @' S' {' ~0 B3 k) m) y
模块划分的"划"是规划的意思，意指怎样合理的将一个很大的软件划分为一系列功能独立的部分合作完成系统的需求。C语言作为一种结构化的程序设计语言，在模块的划分上主要依据功能（依功能进行划分在面向对象设计中成为一个错误，牛顿定律遇到了>相对论）， C语言模块化程序设计需理解如下概念：
8 ~* h8 d1 ~/ N) J6 y% h  G- r
（1） 模块即是一个.c文件和一个.h文件的结合，头文件(.h)中是对于该模块接口的声明；
! N; O# O: S! c, I" w（2） 某模块提供给其它模块调用的外部函数及数据需在.h中文件中冠以extern关键字声明；
$ ]" m9 A/ ^5 w" _1 {: B* c/ x* F# h（3） 模块内的函数和全局变量需在.c文件开头冠以static关键字声明；
/ ]) o; q& E. f7 H) r4 P1 ~: t（4） 永远不要在.h文件中定义变量！定义变量和声明变量的区别在于定义会产生内存分配的操作，是汇编阶段的概念；而声明则只是告诉包含该声明的模块在连接阶段从其它模块寻找外部函数和变量。如：

$ C2 [* K- T! `4 y" r+ r1 ]/*module1.h*/
int a = 5; /* 在模块1的.h文件中定义int a */
3 L4 {6 J+ P8 N! G
3 ?* Z  G' p2 _/ J( {/*module1 .c*/
4 F4 ]9 X3 ]6 ]#include "module1.h" /* 在模块1中包含模块1的.h文件 */
$ X, K) e+ T9 b) z2 o; ^
/*module2 .c*/
#include "module1.h" /* 在模块2中包含模块1的.h文件 */
7 x" k4 E6 E9 \, d* N
/*module3 .c*/
#include "module1.h" /* 在模块3中包含模块1的.h文件 */
) r: B! {& G; _) u5 z
以上程序的结果是在模块1、2、3中都定义了整型变量a，a在不同的模块中对应不同的地址单元，这个世界上从来不需要这样的程序。正确的做法是：
9 U6 C/ V% _# n4 B; F
& j0 q4 C- z) g1 g4 S" A+ V: n/*module1.h*/
extern int a; /* 在模块1的.h文件中声明int a */
; N3 _' H4 h  E
/*module1 .c*/
#include "module1.h" /* 在模块1中包含模块1的.h文件 */
int a = 5; /* 在模块1的.c文件中定义int a */
1 Y' ^& L$ X3 U- y) z3 n$ @9 A+ \# }
5 j$ M8 @$ ]5 T) Q" F8 }; @/*module2 .c*/
6 L( |+ I8 [6 G#include "module1.h" /* 在模块2中包含模块1的.h文件 */
7 t( S% V: |' h* i* ~$ R
/*module3 .c*/
" p0 u* H5 o# {  |' x1 ~#include "module1.h" /* 在模块3中包含模块1的.h文件 */

  b* C! Y' |; K& d  D这样如果模块1、2、3操作a的话，对应的是同一片内存单元。一个嵌入式系统通常包括两类模块：

1 n* U( O6 p* ?: w1 S7 E（1）硬件驱动模块，一种特定硬件对应一个模块；
（2）软件功能模块，其模块的划分应满足低偶合、高内聚的要求。
+ z, S- X3 H+ Q. X) Q
0 x; M4 z7 x) D- g多任务还是单任务
0 P/ [* K! X2 [9 O* E! p) I
# ]% s+ t) w4 [6 _2 X所谓"单任务系统"是指该系统不能支持多任务并发操作，宏观串行地执行一个任务。而多任务系统则可以宏观并行（微观上可能串行）地"同时"执行多个任务。
" P/ p1 D3 s7 O! m5 p$ m
3 C" T& g5 w; m% U多任务的并发执行通常依赖于一个多任务操作系统（OS），多任务OS的核心是系统调度器，它使用任务控制块（TCB）来管理任务调度功能。TCB包括任务的当前状态、优先级、要等待的事件或资源、任务程序码的起始地址、初始堆栈指针等信息。调度器在任务被激活时，要用到这些信息。此外，TCB还被用来存放任务的"上下文"（context)。任务的上下文就是当一个执行中的任务被停止时，所要保存的所有信息。通常，上下文就是计算机当前的状态，也即各个寄存器的内容。当发生任务切换时，当前运行的任务的上下文被存入TCB，并将要被执行的任务的上下文从它的TCB中取出，放入各个寄存器中。
1 x: G8 g9 S1 P0 V- \2 P* d/ }
1 B  `) C/ P$ ~, L/ J嵌入式多任务OS的典型例子有Vxworks、ucLinux等。嵌入式OS并非遥不可及的神坛之物，我们可以用不到1000行代码实现一个针对80186处理器的功能最简单的OS内核，作者正准备进行此项工作，希望能将心得贡献给大家。
  E! R$ W( S! h0 q
究竟选择多任务还是单任务方式，依赖于软件的体系是否庞大。例如，绝大多数手机程序都是多任务的，但也有一些小灵通的协议栈是单任务的，没有操作系统，它们的主程序轮流调用各个软件模块的处理程序，模拟多任务环境。

单任务程序典型架构

（1）从CPU复位时的指定地址开始执行；
- L7 W5 @5 H- X; G（2）跳转至汇编代码startup处执行；
（3）跳转至用户主程序main执行，在main中完成：
a.初试化各硬件设备；
b.初始化各软件模块；
c.进入死循环（无限循环），调用各模块的处理函数

: g2 e% E1 q( Y3 O
用户主程序和各模块的处理函数都以C语言完成。用户主程序最后都进入了一个死循环，其首选方案是：

while(1)
% c: q$ B" b* s2 v{
}
- |( C7 P1 ~+ G! ^. Y4 I
7 b5 C4 Q% Z3 c" S# ]有的程序员这样写：
2 r/ \  N2 E% w! Q6 M" @1 l. C, F, N5 o
for(;;)
5 v0 B2 [5 q9 j1 U) o{
}
' d6 \; E1 f# J0 O5 E" D" t
6 d/ l, c' W' n* T* s这个语法没有确切表达代码的含义，我们从for(;;)看不出什么，只有弄明白for(;;)在C语言中意味着无条件循环才明白其意。下面是几个"著名"的死循环：
* c8 l& u9 f- T/ E3 x4 J' L0 T- \8 h
（1）操作系统是死循环；
- \: w1 ]2 g: {8 f; F! ]5 `（2）WIN32程序是死循环；
9 L6 E/ s# K+ b（3）嵌入式系统软件是死循环；
8 [5 A7 {7 p/ ^# |4 ^（4）多线程程序的线程处理函数是死循环。
, q  A" L1 Y7 y& {0 o# y
你可能会辩驳，大声说："凡事都不是绝对的，2、3、4都可以不是死循环"。Yes，you areright，但是你得不到鲜花和掌声。实际上，这是一个没有太大意义的牛角尖，因为这个世界从来不需要一个处理完几个消息就喊着要OS杀死它的WIN32程序，不需要一个刚开始RUN就自行了断的嵌入式系统，不需要莫名其妙启动一个做一点事就干掉自己的线程。有时候，过于严谨制造的不是便利而是麻烦。君不见，五层的TCP/IP协议栈超越严谨的ISO/OSI七层协议栈大行其道成为事实上的标准？
+ T! W+ |4 C2 t( m1 g
经常有网友讨论：

printf("%d,%d",++i,i++); /* 输出是什么？*/
# s" I) |) q2 h5 ^c = a+++b; /* c=? */
- X7 g$ R. X5 s  e8 b+ ~* c
等类似问题。面对这些问题，我们只能发出由衷的感慨：世界上还有很多有意义的事情等着我们去消化摄入的食物。实际上，嵌入式系统要运行到世界末日。

! R" p) E, [8 H2 I6 b6 ?中断服务程序
" A$ J3 u3 Y; ]+ c6 {
. A# S- ]( _' O3 b$ ]1 m中断是嵌入式系统中重要的组成部分，但是在标准C中不包含中断。许多编译开发商在标准C上增加了对中断的支持，提供新的关键字用于标示中断服务程序(ISR)，类似于__interrupt、#programinterrupt等。当一个函数被定义为ISR的时候，编译器会自动为该函数增加中断服务程序所需要的中断现场入栈和出栈代码。

  B% ?# b! V: |中断服务程序需要满足如下要求：

(1)不能返回值；
(2)不能向ISR传递参数；
(3) ISR应该尽可能的短小精悍；
(4) printf(char * lpFormatString,…)函数会带来重入和性能问题，不能在ISR中采用。
! a1 g& ?* m  J; \
在某项目的开发中，我们设计了一个队列，在中断服务程序中，只是将中断类型添加入该队列中，在主程序的死循环中不断扫描中断队列是否有中断，有则取出队列中的第一个中断类型，进行相应处理。
% v+ `; y8 Y; g2 u' `3 [# Z
2 ]1 ~! s- x3 A8 l/* 存放中断的队列 */
5 ^. V1 W% @. j- |2 C$ d7 ?6 ntypedef struct tagIntQueue
{
* j8 k5 G  u* I5 q　int intType; /* 中断类型 */
. s, Y* s; Y8 C7 ~8 Z* A' A: q　struct tagIntQueue *next;
8 r5 K( Y6 y4 n7 a$ f}IntQueue;
5 B# B- Z$ i  d5 e. \  ?/ P
IntQueue lpIntQueueHead;
3 S' u, `; D. N7 U* r
__interrupt ISRexample ()
3 _, x% s9 Q5 [) u, t{
　int intType;
4 ]" I6 K9 F# A. B: P　intType = GetSystemType();
　QueueAddTail(lpIntQueueHead, intType)；/* 在队列尾加入新的中断 */
}
1 a7 S/ _, X& S$ \" ~
在主程序循环中判断是否有中断：
( j+ b& ^3 I6 V3 H, a8 o$ L5 E1 P
/ Q$ l2 }0 g6 ^% O3 MWhile(1)
{
　If( !IsIntQueueEmpty() )
- I6 h2 h* R6 U　{
9 d; ]! F/ j* s' o! W3 u　　intType = GetFirstInt();
　　switch(intType) /* 是不是很象WIN32程序的消息解析函数? */
* r1 k- J* |" E　　{
　　　/* 对，我们的中断类型解析很类似于消息驱动 */
  P) }2 k- V' g  x7 I% W; Y8 B% v, A　　　case xxx: /* 我们称其为"中断驱动"吧？ */
　　　　…
$ Z$ |% {  R( o( K1 T7 f　　　　break;
　　　case xxx:
　　　　…
" K. b8 K) B- K4 B: D( |　　　　break;
　　　…
0 B/ I- l; A% D　　}
- z! S7 J3 j) r5 P9 M　}
1 M: V7 ~0 ~, Z8 ]% y: H}
' Z  y3 i1 a, J3 E+ m1 W' l
按上述方法设计的中断服务程序很小，实际的工作都交由主程序执行了。

硬件驱动模块

" W, @- _$ p( P: P) i$ E+ }一个硬件驱动模块通常应包括如下函数：
* I; J8 I2 _) N- g  [
（1）中断服务程序ISR
( a: X# V: _, K+ m6 c$ `/ O（2）硬件初始化
6 t3 P( ]3 W8 j. q" ca.修改寄存器，设置硬件参数（如UART应设置其波特率，AD/DA设备应设置其采样速率等）；
, g5 Y+ t0 Z) l9 C  {b.将中断服务程序入口地址写入中断向量表：

. X( T3 Y- s: x5 [9 B! p! c
7 \1 w8 [$ m0 l' B1 p! S/* 设置中断向量表 */
: i1 {* d! |( sm_myPtr = make_far_pointer(0l); /* 返回void far型指针void far * */
  s# i" O: D) _; P4 v' q1 ?) J* dm_myPtr += ITYPE_UART; /* ITYPE_UART： uart中断服务程序 */
/* 相对于中断向量表首地址的偏移 */
*m_myPtr = &UART _Isr; /* UART _Isr：UART的中断服务程序 */

（3）设置CPU针对该硬件的控制线
a.如果控制线可作PIO（可编程I/O）和控制信号用，则设置CPU内部对应寄存器使其作为控制信号；
: f3 g1 b* ?7 S5 S8 k7 ]  _* Ob.设置CPU内部的针对该设备的中断屏蔽位，设置中断方式（电平触发还是边缘触发）。
7 P$ ^" D1 D5 p; Q$ X% I' }  o3 }
* y/ M1 Y' j7 p% G0 b
（4）提供一系列针对该设备的操作接口函数。例如，对于LCD，其驱动模块应提供绘制像素、画线、绘制矩阵、显示字符点阵等函数；而对于实时钟，其驱动模块则需提供获取时间、设置时间等函数。
7 X3 ~+ O9 x2 p5 s
C的面向对象化

# z! A9 r& C& |- G在面向对象的语言里面，出现了类的概念。类是对特定数据的特定操作的集合体。类包含了两个范畴：数据和操作。而C语言中的struct仅仅是数据的集合，我们可以利用函数指针将struct模拟为一个包含数据和操作的"类"。下面的C程序模拟了一个最简单的"类"：
( p) y, b( @  G$ J% c4 [
#ifndef C_Class
#define C_Class struct
3 t' d: j7 D& B" n+ g1 F#endif
C_Class A
; R2 {  W& ?# ]7 \{
( I( ^" o, {" a& _( j　C_Class A *A_this; /* this指针 */
　void (*Foo)(C_Class A *A_this); /* 行为：函数指针 */
9 Y, [  x# L5 t& Q9 y& w/ }　int a; /* 数据 */
　int b;
};

我们可以利用C语言模拟出面向对象的三个特性：封装、继承和多态，但是更多的时候，我们只是需要将数据与行为封装以解决软件结构混乱的问题。C模拟面向对象思想的目的不在于模拟行为本身，而在于解决某些情况下使用C语言编程时程序整体框架结构分散、数据和函数脱节的问题。我们在后续章节会看到这样的例子。
; L: V$ \* z5 ~1 |( A, F
总结

本篇介绍了嵌入式系统编程软件架构方面的知识，主要包括模块划分、多任务还是单任务选取、单任务程序典型架构、中断服务程序、硬件驱动模块设计等，从宏观上给出了一个嵌入式系统软件所包含的主要元素。

请记住：软件结构是软件的灵魂！结构混乱的程序面目可憎，调试、测试、维护、升级都极度困难。

( X% @% H, `, x$ L% f

kiygb

中断是嵌入式系统中重要的组成部分，但是在标准C中不包含中断