1.1 嵌入式系统有何特殊之处

实时系统，” 实时” 并不意味着很快。

1.1.1 嵌入式设计的约束

减少使用硬件的需求
性能：吞吐量
可靠性：衡量系统正确完成功能的可能性
健壮性：违反先决条件下仍能提供相应服务的能力
安全性：系统的风险水平，可能会造成那些意外或者损失

1.1.2 嵌入式工具

交叉编译器：在主机上运行，开发的可执行代码在不同环境中运行
连接器
载入程序
调试器工具集
以上集成到 IDE 中

1.1.3 OS，RTOS，还是没有操作系统

1.1.4 嵌入式中间件

中间件是一种使用某种方法将软件组件连接的软件

1.1.5 与硬件协同开发

1.1.6 调试与测试

1.2 面向对象还是结构化

结构化编程：一方面，函数和过程形成基本的编程基础；另一方面是数据结构的概念。
面向对象编程：基于正交范式。面向对象编程仅有基于类概念的一个分类标准。类将数据（存储为属性）和在数据上的操作的过程（称为操作）组合到一起。对象是类的实例。
像 C 一样的结构化语言能够完成面向对象的编程么？可以。
如何实现？接着往下看。

1.2.1 类

类仅是一个 C 语言的结构体，但特殊之处是包含两种不同的特性：数据（属性）和行为（操作）。
最简单的实现类的方法是简单使用文件作为封装边界；公共变量和方法在头文件中课件，而在实现文件中包含方法体、私有变量和方法。
一个更为灵活的方式是使用文件内的结构体来表示类。类的操作用位于相同文件内的结构体的函数定义。
这允许我们拥有同一个类的多个实例，并且保证成员函数在正确的数据拷贝上工作。此外，类可以赋予 “特殊” 的操作。构造函数创建类的一个对象。初始化程序（可选择）初始化对象和它的属性。析构函数销毁类并释放已使用的内存。

代码 1-1 sensor.h

  1. #ifndef SENSOR_H
  2. #define SENDOR_H
  4. typedef struct sensor
  5. {
  6.     int filterFrequency;
  7.     int updateFrequency;
  8.     int value;
  9.     char whatKindOfInterface;
  10. }SENSOR;
  12. int Sensor_getFilterFrequency(const SENSOR* const me);
  13. void Sensor_setFilterFrequency(SENSOR* const me, int p_filterFrequency);
  14. int Sensor_getUpdateFrequency(const SENSOR* const me);
  15. void Sensor_setUpdateFrequency(SENSOR* const me, int p_updateFrequency);
  16. int Sensor_getValue(const SENSOR* const me);
  17. //int acquireValue(SENSOR* me);
  18. SENSOR* Sensor_create(void);
  19. void Sensor_Destroy(Sensor* const me);
  21. #endif

代码 1-2 sensor.c

  1. #include "sensor.h"
  4. void Sensor_Init(SENSOR* const me){
  7. }
  9. void Sensor_Cleanup(SENSOR* const me){
  12. }
  14. int Sensor_getFilterFrequency(const SENSOR* const me){
  16.     return me->filterFrequency;
  17. }
  19. void Sensor_setFilterFrequency(SENSOR* const me, int p_filterFrequency){
  21.     me->filterFrequency=p_filterFrequency;
  22. }
  24. int Sensor_getUpdateFrequency(const SENSOR* const me){
  26.     return me->updateFrequency;
  27. }
  29. void Sensor_setUpdateFrequency(SENSOR* const me, int p_updateFrequency){
  31.     me->updateFrequency=p_updateFrequency;
  32. }
  34. int Sensor_getValue(const SENSOR* const me){
  36.     return me->value;
  37. }
  39. /*
  40. int acquireValue(SENSOR* me){
  42.     int *r, *w;
  43.     int j;
  45.     switch(me->whatKindOfInterface)
  46.     {
  48.         case MEMPRYMAPPED:
  49.             w=(int*)WRITEADDR; //Address to write to sensor
  50.             *w=WRITEMASK;      //sensor command to force a read
  51.             for (j = 0; j < count; j++)
  52.             {
  53.                 // wait loop 
  54.             }
  55.             r=(int*)READADDR;  //Address to returned value
  56.             me->value=r;
  57.             break;
  58.         case PORTMAPPED:
  59.             me->value=inp(SENSORPORT);
  60.                                 //inp() is a compliler-specific port function
  61.             break;
  62.     }
  64.     return me->value;
  65. }
  66. */
  68. SENSOR* Sensor_create(void){
  70.     SENSOR* me=(SENSOR*)malloc(sizeof(SENSOR));
  71.     if (me != NULL)
  72.     {
  73.         Sensor_Init(me);
  74.     }
  76.     return me;
  77. }
  79. void Sensor_Destroy(SENSOR* const me){
  81.     if (me != NULL)
  82.     {
  83.         Sensor_Cleanup(me);
  84.     }
  86.     free(me);
  87. }

1.2.2 对象

对象是类的实例。

代码 1-3 main.c

  1. #include "sensor.h"
  2. #include <stdlib.h>
  3. #include <stdio.h>
  5. int main(int argc, char const *argv[])
  6. {
  7.     SENSOR *p_sensor0, *p_sensor1;
  8.     p_sensor0=Sensor_create();
  9.     p_sensor1=Sensor_create();
  11.     p_sensor0->value=99;
  12.     p_sensor1->value=-1;
  13.     printf("The current value from sensor0 is %d\n",
  14.         Sensor_getValue(p_sensor0));
  15.     printf("The current value from sensor1 is %d\n",
  16.         Sensor_getValue(p_sensor1));
  18.     Sensor_Destroy(p_sensor0);
  19.     Sensor_Destroy(p_sensor1);
  20.     return 0;
  21. }

1.2.3 多态和虚拟函数

多态允许相同函数名在一种上下文中完成一种功能，在另一种上下文中完成另一种功能。
在 C 语言中，标准的做法是使用选择语句 if 或者 switch。当出现多种上下文时，不方便；此外在最开始编写时就要知道所有可能的上下文，或者提供修改功能。

代码修改 1-1 sensor.h

  1. #ifndef SENSOR_H
  2. #define SENDOR_H
  4. typedef struct sensor
  5. {
  6.     int filterFrequency;
  7.     int updateFrequency;
  8.     int value;
  9.     char whatKindOfInterface;
  10. }SENSOR;
  12. int Sensor_getFilterFrequency(const SENSOR* const me);
  13. void Sensor_setFilterFrequency(SENSOR* const me, int p_filterFrequency);
  14. int Sensor_getUpdateFrequency(const SENSOR* const me);
  15. void Sensor_setUpdateFrequency(SENSOR* const me, int p_updateFrequency);
  16. //int Sensor_getValue(const SENSOR* const me);
  17. int acquireValue(SENSOR* me);
  18. SENSOR* Sensor_create(void);
  19. void Sensor_Destroy(Sensor* const me);
  21. #endif

代码修改 1-2 sensor.c

  1. #include "sensor.h"
  4. void Sensor_Init(SENSOR* const me){
  7. }
  9. void Sensor_Cleanup(SENSOR* const me){
  12. }
  14. int Sensor_getFilterFrequency(const SENSOR* const me){
  16.     return me->filterFrequency;
  17. }
  19. void Sensor_setFilterFrequency(SENSOR* const me, int p_filterFrequency){
  21.     me->filterFrequency=p_filterFrequency;
  22. }
  24. int Sensor_getUpdateFrequency(const SENSOR* const me){
  26.     return me->updateFrequency;
  27. }
  29. void Sensor_setUpdateFrequency(SENSOR* const me, int p_updateFrequency){
  31.     me->updateFrequency=p_updateFrequency;
  32. }
  34. /*
  35. int Sensor_getValue(const SENSOR* const me){
  37.     return me->value;
  38. }
  39. */
  41. int acquireValue(SENSOR* me){
  43.     int *r, *w;
  44.     int j;
  46.     switch(me->whatKindOfInterface)
  47.     {
  49.         case MEMPRYMAPPED:
  50.             w=(int*)WRITEADDR; //Address to write to sensor
  51.             *w=WRITEMASK;      //sensor command to force a read
  52.             for (j = 0; j < count; j++)
  53.             {
  54.                 /* wait loop */
  55.             }
  56.             r=(int*)READADDR;  //Address to returned value
  57.             me->value=r;
  58.             break;
  59.         case PORTMAPPED:
  60.             me->value=inp(SENSORPORT);
  61.                                 //inp() is a compliler-specific port function
  62.             break;
  63.     }
  65.     return me->value;
  66. }
  68. SENSOR* Sensor_create(void){
  70.     SENSOR* me=(SENSOR*)malloc(sizeof(SENSOR));
  71.     if (me != NULL)
  72.     {
  73.         Sensor_Init(me);
  74.     }
  76.     return me;
  77. }
  79. void Sensor_Destroy(SENSOR* const me){
  81.     if (me != NULL)
  82.     {
  83.         Sensor_Cleanup(me);
  84.     }
  86.     free(me);
  87. }

1.2.4 子类化

子类化（也被称为泛化或者继承），能够重用设计或代码。

代码 1-4 queue.h

  1. #ifndef QUEUE_H
  2. #define QUEUE_H
  4. #define QUEUE_SIZE 10
  6. typedef struct queue
  7. {
  8.     int buffer[QUEUE_SIZE];
  9.     int head;
  10.     int size;
  11.     int tail;
  13.     int (*isFull)(struct queue* const me);
  14.     int (*isEmpty)(struct queue* const me);
  15.     int (*getSize)(struct queue* const me);
  16.     void (*insert)(struct queue* const me, int k);
  17.     int (*remove)(struct queue* const me);
  18. }QUEUE;
  20. void Queue_Init(QUEUE* me, int (*isFullFunction)(QUEUE* const me),
  21.     int (*isEmptyFunction)(QUEUE* const me),
  22.     int (*getSizeFunction)(QUEUE* const me),
  23.     void (*insertFunction)(QUEUE* const me, int k),
  24.     int (*removeFunction)(QUEUE* const me));
  25. void Queue_Cleanup(QUEUE* const me);
  27. int Queue_isFull(QUEUE* const me);
  28. int Queue_isEmpty(QUEUE* const me);
  29. int Queue_getSize(QUEUE* const me);
  30. void Queue_insert(QUEUE* const me, int k);
  31. int Queue_remove(QUEUE* const me);
  33. QUEUE* Queue_Create(void);
  34. void Queue_Destroy(QUEUE* const me);
  36. #endif

代码 1-5 queue.c

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include "queue.h"
  5. void Queue_Init(QUEUE* me, int (*isFullFunction)(QUEUE* const me),
  6.     int (*isEmptyFunction)(QUEUE* const me),
  7.     int (*getSizeFunction)(QUEUE* const me),
  8.     void (*insertFunction)(QUEUE* const me, int k),
  9.     int (*removeFunction)(QUEUE* const me)){
  11.     me->head=0;
  12.     me->tail=0;
  13.     me->size=0;
  15.     me->isFull=isFullFunction;
  16.     me->isEmpty=isEmptyFunction;
  17.     me->getSize=getSizeFunction;
  18.     me->insert=insertFunction;
  19.     me->remove=removeFunction;
  20. }
  22. void Queue_Cleanup(QUEUE* const me){
  25. }
  27. int Queue_isFull(QUEUE* const me){
  29.     return (me->head+1)%QUEUE_SIZE==me->tail;
  30. }
  32. int Queue_isEmpty(QUEUE* const me){
  34.     return me->head==me->tail;
  35. }
  37. int Queue_getSize(QUEUE* const me){
  39.     return me->size;
  40. }
  42. void Queue_insert(QUEUE* const me, int k){
  44.     if (!me->isFull(me))
  45.     {
  46.         me->buffer[me->head]=k;
  47.         me->head=(me->head+1)%QUEUE_SIZE;
  48.         ++me->size;
  49.     }
  50. }
  52. int Queue_remove(QUEUE* const me){
  54.     int value=-9999;
  56.     if(!me->isEmpty(me))
  57.     {
  58.         value=me->buffer[me->tail];
  59.         me->tail=(me->tail+1)%QUEUE_SIZE;
  60.         --me->size;
  61.     }
  63.     return value;
  64. }
  66. QUEUE* Queue_Create(void){
  68.     QUEUE* me=(QUEUE*)malloc(sizeof(QUEUE));
  70.     if (me!=NULL)
  71.     {
  72.         Queue_Init(me,Queue_isFull,Queue_isEmpty,Queue_getSize,
  73.             Queue_insert,Queue_remove);
  74.     }
  76.     return me;
  77. }
  79. void Queue_Destroy(QUEUE* const me){
  81.     if (me!=NULL)
  82.     {
  83.         Queue_Cleanup(me);
  84.     }
  86.     free(me);
  87. }

代码 1-6 test_queue.c

  1. #include "queue.h"
  2. #include <stdlib.h>
  3. #include <stdio.h>
  5. int main(void)
  6. {
  7.     int j,k,h,t;
  9.     QUEUE* myQ;
  10.     myQ=Queue_Create();
  11.     k=1000;
  13.     for (j = 0; j<QUEUE_SIZE; j++)
  14.     {
  15.         h=myQ->head;
  16.         myQ->insert(myQ, k);
  17.         printf("inserting %d at position %d, size=%d\n", k--,h,myQ->getSize(myQ));
  18.     }
  19.     printf("Iserted %d elements\n", myQ->getSize(myQ));
  21.     for (j = 0; j<QUEUE_SIZE; j++)
  22.     {
  23.         t=myQ->tail;
  24.         k=myQ->remove(myQ);
  25.         printf("Removing %d at position %d, size=%d\n", k, t, myQ->getSize(myQ));
  26.     }
  27.     printf("Last item removed = %d\n", k);
  29.     printf("Current queue size %d\n", myQ->getSize(myQ));
  30.     puts("Queue test program");
  32.     return 0;
  33. }

代码 1-7 cachedqueue.h

  1. //cached queue means the memory does not have enough space to store the whole queue
  2. //so we divide the queue into two sides:
  3. //one store in memory
  4. //another store in disk
  6. #ifndef CACHEDQUEUE_H
  7. #define CACHEDQUEUE_H
  9. #include "queue.h"
  11. typedef struct cachedqueue
  12. {
  13.     QUEUE* queue;       //base class
  14.     char filename[80];  //new attributes
  15.     int numberElementsOnDisk;
  16.     QUEUE* outputQueue; //aggregation in subclass
  18.     //Inherited virtual functions
  19.     int (*isFull)(struct cachedqueue* const me);
  20.     int (*isEmpty)(struct cachedqueue* const me);
  21.     int (*getSize)(struct cachedqueue* const me);
  22.     void (*insert)(struct cachedqueue* const me, int k);
  23.     int (*remove)(struct cachedqueue* const me);
  25.     //new virtual functions
  26.     void (*flush)(struct cachedqueue* const me);
  27.     void (*load)(struct cachedqueue* const me);
  29. }CACHEDQUEUE;
  31. void CachedQueue_Init(CACHEDQUEUE* const me, char* filename,
  32.     int (*isFullFunction)(CACHEDQUEUE* const me),
  33.     int (*isEmptyFunction)(CACHEDQUEUE* const me),
  34.     int (*getSizeFunction)(CACHEDQUEUE* const me),
  35.     void (*insertFunction)(CACHEDQUEUE* const me),
  36.     int (*removeFunction)(CACHEDQUEUE* const me),
  37.     void (*flushFunction)(CACHEDQUEUE* const me),
  38.     void (*loadFunction)(CACHEDQUEUE* const me));
  39. void CachedQueue_Cleanup(CACHEDQUEUE* const me);
  41. int CachedQueue_isFull(CACHEDQUEUE* const me);
  42. int Cachedqueue_isEmpty(CACHEDQUEUE* const me);
  43. int Cachedqueue_getSize(CACHEDQUEUE* const me);
  44. void Cachedqueue_insert(CACHEDQUEUE* const me, int k);
  45. int CachedQueue_remove(CACHEDQUEUE* const me);
  46. void Cachedqueue_flush(CACHEDQUEUE* const me);
  47. void Cachedqueue_load(CACHEDQUEUE* const me);
  49. CACHEDQUEUE* CachedQueue_Create(void);
  50. void CachedQueue_Destroy(CACHEDQUEUE* const me);
  52. #endif

代码 1-8 cachedqueue.c

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include "cachedqueue.h"
  6. void CachedQueue_Init(CACHEDQUEUE* const me, char* filename,
  7.     int (*isFullFunction)(CACHEDQUEUE* const me),
  8.     int (*isEmptyFunction)(CACHEDQUEUE* const me),
  9.     int (*getSizeFunction)(CACHEDQUEUE* const me),
  10.     void (*insertFunction)(CACHEDQUEUE* const me),
  11.     int (*removeFunction)(CACHEDQUEUE* const me),
  12.     void (*flushFunction)(CACHEDQUEUE* const me),
  13.     void (*loadFunction)(CACHEDQUEUE* const me)){
  15.     me->queue=Queue_Create();
  16.     me->numberElementsOnDisk=0;
  17.     strcpy(me->filename,filename);
  18.     me->outputQueue=Queue_Create();
  20.     me->isFull=isFullFunction;
  21.     me->isEmpty=isEmptyFunction;
  22.     me->getSize=getSizeFunction;
  23.     me->insert=insertFunction;
  24.     me->remove=removeFunction;
  25.     me->flush=flushFunction;
  26.     me->load=loadFunction;
  27. }
  29. void CachedQueue_Cleanup(CACHEDQUEUE* const me){
  31.     Queue_Cleanup(me->queue);
  32. }
  34. int CachedQueue_isFull(CACHEDQUEUE* const me){
  36.     return me->queue->isFull(me->queue) &&
  37.            me->outputQueue->isFull(me->outputQueue);
  38. }
  40. int CachedQueue_isEmpty(CACHEDQUEUE* const me){
  42.     return me->queue->isEmpty(me->queue) &&
  43.            me->outputQueue->isEmpty(me->outputQueue) &&
  44.            (me->numberElementsOnDisk==0);
  45. }
  47. int CachedQueue_getSize(CACHEDQUEUE* const me){
  49.     return me->queue->getSize(me->queue)+
  50.            me->outputQueue->getSize(me->outputQueue)+
  51.            me->numberElementsOnDisk;
  52. }
  54. void CachedQueue_insert(CACHEDQUEUE* const me,int k){
  56.     if (me->queue->isFull(me->queue))
  57.     {
  58.         me->flush(me);
  59.     }
  61.     me->queue->insert(me->queue,k);
  62. }
  64. int CachedQueue_remove(CACHEDQUEUE* const me){
  66.     if (!me->outputQueue->isEmpty(me->outputQueue))
  67.     {
  68.         return me->outputQueue->remove(me->outputQueue);
  69.     }
  70.     else if (me->numberElementsOnDisk>0)
  71.         {
  72.             me->load(me);
  73.             return me->queue->remove(me->remove);
  74.         }
  75.         else
  76.         {
  77.             return me->queue->remove(me->remove);
  78.         }
  79. }
  81. void CachedQueue_flush(CACHEDQUEUE* const me){
  83.     //while not queue->isEmpty()
  84.     //          queue->remove();
  85.     //          write date to disk
  86.     //          numberElementsOnDisk++
  87.     //end while
  88. }
  90. void CachedQueue_load(CACHEDQUEUE* const me){
  92.     //while (!outputQueue->isFull()&&(numberElementsOnDisk>0))
  93.     //      read from start of file
  94.     //      numberElementsOnDisk--;
  95.     //      outputQueue->insert();
  96.     //end while
  97. }
  99. CACHEDQUEUE* CachedQueue_Create(CACHEDQUEUE* const me){
  101.     CACHEDQUEUE* me=(CACHEDQUEUE*)malloc(sizeof(CACHEDQUEUE));
  103.     if(me!=NULL)
  104.     {
  105.         CachedQueue_Init(me,"C:\\queuebuffer.dat",
  106.             CachedQueue_isFull,CachedQueue_isEmpty,
  107.             CachedQueue_getSize,CachedQueue_insert,
  108.             CachedQueue_remove,CachedQueue_flush,CachedQueue_load);
  109.     }
  111.     return me;
  112. }
  114. void CachedQueue_Destroy(CACHEDQUEUE* const me){
  116.     if(me!=NULL)
  117.     {
  118.         CachedQueue_Cleanup(me);
  119.     }
  121.     free(me);
  122. }

1.2.5 有限状态机

有限状态机（Finite State Machine,FSM）

代码 1-9 SecuritySupervisor.c

  1. static eventStatus dispatchEvent(short id){
  3.     eventStatus res=eventNotConsumed;
  5.     switch (activeState)
  6.     {
  7.         case SecuritySupervisor_Idle:
  8.         {
  9.             if (id==NULL_id)
  10.             {
  11.                 if(retries>=3)
  12.                 {
  13.                     activeState=SecuritySupervisor_ErrorState;
  14.                     displayMSg("ERROR: Max retries Exceeded");
  15.                     res=eventConsumed;
  16.                 }
  17.                 else
  18.                 {
  19.                     ++retries;
  20.                     activeState=SecuritySupervisor_Accepting;
  21.                     res=eventConsumed;
  22.                 }
  23.             }
  25.         }
  26.         break;
  28.         case SecuritySupervisor_Accepting:
  29.         {
  30.             if (id==keypress_SequritySupervisor_Event_id)
  31.             {
  32.                 if (isCANCEL(params->keys))
  33.                 {
  34.                     retries=0;
  35.                     displayMSg("Cancelled");
  36.                     activeState=SecuritySupervisor_Idle;
  37.                     strcpy(pin,"");
  38.                     res=eventConsumed;
  39.                 }
  40.                 else
  41.                 {
  42.                     if (isDigit(params->keys))
  43.                     {
  44.                         addKey(params->keys);
  45.                         activeState=SecuritySupervisor_Accepting;
  46.                         res=eventConsumed;
  47.                     }
  48.                     else
  49.                     {
  50.                         if(isEnter(params->keys))
  51.                         {
  52.                             activeState=SecuritySupervisor_CheckingLength;
  53.                             res=eventConsumed;
  54.                         }
  55.                     }
  56.                 }
  57.             }
  58.         }
  59.         break;
  61.         case SecuritySupervisor_CheckingLength:
  62.         {
  63.             if (id==NULL_id)
  64.             {
  65.                 if(strlen(pin)==4)
  66.                 {
  67.                     activeState=SecuritySupervisor_ValidatingPIN;
  68.                     res=eventConsumed;
  69.                 }
  70.                 else
  71.                 {
  72.                     displayMSg("ERROR:PIN wrong length");
  73.                     activeState=SecuritySupervisor_Idle;
  74.                     strcpy(pin,"");
  75.                     res=eventConsumed;
  76.                 }
  77.             }
  78.         }
  79.         break;
  81.         case SecuritySupervisor_ValidatingPIN:
  82.         {
  83.             if (id==NULL_id)
  84.             {
  85.                 if (isValid(pin))
  86.                 {
  87.                     unlockDoor();
  88.                     displayMSg("Door unlocked");
  89.                     activeState=SecuritySupervisor_SecurityOpen;
  90.                     res=eventConsumed;
  91.                 }
  92.                 else
  93.                 {
  94.                     displayMSg("ERROR: Invalid PIN");
  95.                     activeState=SecuritySupervisor_Idle;
  96.                     strcpy(pin,"");
  97.                     res=eventConsumed;
  98.                 }
  99.             }
  100.         }
  101.         break;
  103.         case SecuritySupervisor_SecurityOpen:
  104.         {
  105.             if (id==keypress_SequritySupervisor_Event_id)
  106.             {
  107.                 if (isRESET(params->keys))
  108.                 {
  109.                     lockDoor();
  110.                     displayMSg("Door locked");
  111.                     activeState=SecuritySupervisor_Idle;
  112.                     strcpy(pin,"");
  113.                     res=eventConsumed;
  114.                 }
  115.             }
  116.         }
  117.         break;
  119.         default:
  120.         break;
  122.     }
  124.     return res;
  125. }

1.3 小结

结构化方法将软件组织成两个并行分类，一个是数据，另一个是行为。面向对象的方法将两者结合，当低耦合时，为固有紧密耦合的元素和内容的封装提高内聚力。C 不是面向对象语言，可以用于开发基于对象或面向对象的嵌入式系统。